#include "leds.h" #include #include #include #include #include "shared.h" #include "esp8266/gpio_register.h" #include "rom/ets_sys.h" #include "driver/gpio.h" uint32_t g_serial_out_buffer[122]; union Led* g_leds = ((union Led*)g_serial_out_buffer + 1); struct Gradient g_default_gradient; struct Gradient g_current_gradient; int g_leds_are_default = 1; enum LedsSendStatus g_leds_send_state = LEDS_SEND_WAITING; SemaphoreHandle_t g_led_mutex; // mutex governing access to data for leds // use for all global data defined in this header struct LedThreadData g_led_thread_data = { .task = 0, .func = &leds_thread }; /// ======================================= // leds.h internal helper functions /// ======================================= static inline uint8_t lerp_uint8(uint8_t a, uint8_t b, float t) { if(t <= 0) return a; else if(t >= 1.0) return b; else { int dir = b - a; return a + dir * t; } } static inline void lerp_led(union Led* out, const union Led* from, const union Led* to, float t) { out->components.red = lerp_uint8(from->components.red, to->components.red, t); out->components.green = lerp_uint8(from->components.green, to->components.green, t); out->components.blue = lerp_uint8(from->components.blue, to->components.blue, t); uint8_t glob_from = from->components.global & ~0xE0; uint8_t glob_to = to->components.global & ~0xE0; out->components.global = GLOBAL(lerp_uint8(glob_from, glob_to, t)); } static inline void lerp_points_between(const struct GradientPoint from, const struct GradientPoint to) { const int dif = to.offset - from.offset; float t = 0.f; for(int led = from.offset; led <= to.offset; ++led) { t = (float)(led - from.offset) / (float)dif; lerp_led(g_leds + led, &from.led, &to.led, t); } } static void leds_config_gpio() { gpio_config_t config = { .intr_type = GPIO_INTR_DISABLE, .mode = GPIO_MODE_OUTPUT, .pin_bit_mask = 0x18030, .pull_up_en = 0, .pull_down_en = 0, }; gpio_config(&config); } static void serial_write(int high) { // set clock out to high, triggering a rising edge gpio_set_level(CLOCK, 1); // write bit to data out gpio_set_level(DATA, high); ets_delay_us(1); // set clock to low, triggering a falling edge, shifting the LEDs shift register gpio_set_level(CLOCK, 0); } /// ======================================= // leds.h external interface functions /// ======================================= void send_leds() { // index of the bit being written // fixed point number where the first 5 bits are the bit of a 32bit integger, and the rest is the integer int write_bit = 0; int write_next = 0; gpio_set_level(CLOCK, 0); while(write_bit < sizeof(g_serial_out_buffer) * 8) { // fetch the bit being addressed write_next = 0x1 & (g_serial_out_buffer[write_bit >> 5] >> (32 - (write_bit & 0x1F))); serial_write(write_next); write_bit++; } gpio_set_level(CLOCK, 0); gpio_set_level(DATA, 0); } void set_led_range(int start, int end, union Led value) { for(int i = start; i < end; ++i) { g_leds[i] = value; } } void leds_set_default_gradient(const struct Gradient* gradient) { g_default_gradient = *gradient; } void leds_set_current_gradient(const struct Gradient* gradient, int defer_send) { struct GradientPoint from = gradient->points[0]; struct GradientPoint to; set_led_range(0, gradient->points[0].offset, gradient->points[0].led); set_led_range(gradient->points[gradient->points_len-1].offset, 120, gradient->points[gradient->points_len-1].led); g_current_gradient = *gradient; for(int i = 1; i < gradient->points_len; ++i) { to = gradient->points[i]; lerp_points_between(from, to); from = to; } if(!defer_send) { send_leds(); } } void leds_reset_gradient(int defer_send) { leds_set_current_gradient(&g_default_gradient, defer_send); } // swap to ranges of memory using a temporary block static void memswap(void* d, void* s, size_t n) { void* tmp = malloc(n); memcpy(tmp, s, n); memcpy(s, d, n); memcpy(d, tmp, n); free(tmp); } void leds_animate() { for(size_t i = 0; i < g_current_gradient.points_len; ++i) { // The gradient point at i struct GradientPoint* point = g_current_gradient.points + i; // move towards end if(point->movement > 0) { // without moving past it point->offset = min(point->offset + 1, 120); // swap with next point if we pass it if(point->offset > (point+1)->offset) { memswap(point, point+1, sizeof(struct GradientPoint)); } // move towards start } else if(point->movement < 0) { // without passing it point->offset = max(0, point->offset - 1); // swap with previous point if we fall below it if(point->offset < (point-1)->offset) { memswap(point, point-1, sizeof(struct GradientPoint)); } } } leds_set_current_gradient(&g_current_gradient, 1); } void leds_thread() { send_leds(); float timer = 0; for(;;) { // wait for 10 milliseconds, // giving FreeRTOS time to run other tasks vTaskDelay(10 / portTICK_RATE_MS); xSemaphoreTake(g_led_mutex, portMAX_DELAY); { send_leds(); leds_animate(); if(timer > g_current_gradient.duration) { timer = 0.f; leds_set_current_gradient(&g_default_gradient, 0); } } xSemaphoreGive(g_led_mutex); } } void leds_init() { g_serial_out_buffer[0] = 0u; g_serial_out_buffer[61] = ~0u; set_led_range(0, 120, (union Led){.components = (struct LedComponents) { .red = 0, .green = 0, .blue = 0, .global = GLOBAL(5) }} ); g_led_mutex = xSemaphoreCreateMutex(); xTaskCreate(g_led_thread_data.func, "Leds", 1024, NULL, 1, &g_led_thread_data.task); // initialize mutex for leds data leds_config_gpio(); }