j3d1/fiatlux
1
0
Fork 1
Code Issues 18 Pull requests Projects Releases 2 Wiki Activity
fiatlux/firmware/lux.cpp
jedi 1cd16f0aad
Some checks failed
continuous-integration/drone/push Build is failing
Details
stash
2023-02-19 13:40:59 +01:00

387 lines
No EOL
11 KiB
C++
Raw Permalink Blame History

//
// Created by jedi on 25.06.21.
//
#include "lux.h"
#include "log.h"
#include "bus.h"
#include "esp/spi.h"
#include "espressif/esp_system.h"
#include <string.h>
#include <FreeRTOS.h>
#include <task.h>
#include <esp/spi.h>
#include <ws2812_i2s/ws2812_i2s.h>
#include <cstdio>
#include <ws2812_i2s/ws2812_i2s.h>
#include <cstdio>
extern "C" {
#include <sysparam.h>
}
const auto htons = [](uint16_t x) -> uint16_t {
return ((x) << 8 & 0xFF00) | ((x) >> 8 & 0x00FF);
};
const auto &ntohs = htons;
const auto htonl = [](uint32_t x) -> uint32_t {
return ((x) << 24 & 0xFF000000UL) | ((x) << 8 & 0x00FF0000UL) | ((x) >> 8 & 0x0000FF00UL) |
((x) >> 24 & 0x000000FFUL);
};
const auto &ntohl = htonl;
struct apa10xx_pixel_t {
struct {
unsigned int mod: 5, marker: 3;
} __attribute__((packed)) global = {0x1F, 0x7};
uint8_t b = 0;
uint8_t g = 0;
uint8_t r = 0;
};
volatile rgba_t top_color;
volatile rgba_t bottom_color;
volatile uint16_t light_value;
volatile uint16_t peripheral_version;
namespace fiatlux {
struct hal_error_t {
constexpr hal_error_t() = default;
hal_error_t(const char *) {}
hal_error_t(const char *, hal_error_t *cause) {}
};
constexpr hal_error_t empty_error;
enum class hal_module_t {
NONE, SIGNAL, RELAIS, SPI_DIMMER, WS28X, APA10X
};
namespace ports {
hal_module_t spi = hal_module_t::NONE;
hal_module_t uart = hal_module_t::NONE;
hal_module_t gpio2 = hal_module_t::NONE;
hal_module_t gpio4 = hal_module_t::NONE;
hal_module_t gpio5 = hal_module_t::NONE;
hal_module_t gpio15 = hal_module_t::NONE;
}
namespace signal {
void write_data(bool data) {
gpio_write(2, !data);
}
void setup() {
gpio_enable(2, GPIO_OUTPUT);
}
}
namespace relais {
void write_data(bool a, bool b) {
gpio_write(4, a);
gpio_write(5, b);
}
void write_data(uint8_t data[2]) {
write_data((bool) data[0], (bool) data[1]);
}
void setup() {
gpio_enable(4, GPIO_OUTPUT);
gpio_enable(5, GPIO_OUTPUT);
}
}
namespace spi_dimmer {
constexpr int cs0 = 15;
void write_data(uint16_t data[6]) {
for (int i = 0; i < 6; ++i) {
int dac_val = (data[i] << 2) & 0x3FFC;
spi_transfer_8(1, ~(0x00));
gpio_write(cs0, true);
gpio_write(cs0, false);
spi_transfer_8(1, ~(0x01 << i));
gpio_write(cs0, true);
gpio_write(cs0, false);
spi_transfer_16(1, dac_val);
spi_transfer_8(1, ~(0x00));
gpio_write(cs0, true);
gpio_write(cs0, false);
spi_transfer_8(1, ~(0x01 << i));
gpio_write(cs0, true);
gpio_write(cs0, false);
}
}
void setup() {
gpio_enable(cs0, GPIO_OUTPUT);
spi_init(1, SPI_MODE0, SPI_FREQ_DIV_1M, 1, SPI_BIG_ENDIAN, 1);
}
}
namespace ws28x {
void write_data(ws2812_pixel_t *data) {
ws2812_i2s_update(data, PIXEL_RGBW);
}
void setup(size_t len) {
ws2812_i2s_init(len, PIXEL_RGBW);
}
}
namespace apa10x {
void write_data(apa10xx_pixel_t *data, size_t len) {
spi_transfer_32(1, 0x00000000);
for (size_t i = 0; i < len; i++)
spi_transfer_32(1, *(uint32_t *) &data[i]);
//spi_transfer_32(1, *(uint32_t *) &data[len - 1]); // dunno maybe this helps
//spi_transfer_32(1, *(uint32_t *) &data[len - 1]); // dunno maybe this helps
spi_transfer_32(1, 0xFFFFFFFF);
spi_transfer_32(1, 0xFFFFFFFF);
}
void setup() {
spi_init(1, SPI_MODE0, SPI_FREQ_DIV_1M, 1, SPI_LITTLE_ENDIAN, false);
}
}
hal_error_t write_channel(uint8_t *data, size_t count, size_t stride, hal_module_t mod) {
if(mod == hal_module_t::SIGNAL) {
if(count != 1)
return "unsupported value for count";
if(stride != 1)
return "unsupported value for stride";
signal::write_data(data[0]);
} else if(mod == hal_module_t::RELAIS) {
if(count != 2)
return "unsupported value for count";
if(stride != 1)
return "unsupported value for stride";
relais::write_data(data);
} else if(mod == hal_module_t::SPI_DIMMER) {
if(count != 6)
return "unsupported value for count";
if(stride != 2)
return "unsupported value for stride";
spi_dimmer::write_data((uint16_t *) data);
} else if(mod == hal_module_t::WS28X) {
if(stride != 4)
return "unsupported value for stride";
ws28x::write_data((ws2812_pixel_t *) data);
} else if(mod == hal_module_t::APA10X) {
if(stride != 4)
return "unsupported value for stride";
apa10x::write_data((apa10xx_pixel_t *) data, count);
} else {
return "unsupported module";
}
return empty_error;
}
hal_error_t setup_channel(size_t count, size_t stride, hal_module_t mod) {
/*if(mod == hal_module_t::SIGNAL) {
if(count != 1)
return "unsupported value for count";
if(stride != 1)
return "unsupported value for stride";
signal::write_data(data[0]);
} else if(mod == hal_module_t::RELAIS) {
if(count != 2)
return "unsupported value for count";
if(stride != 1)
return "unsupported value for stride";
relais::write_data(data);
} else if(mod == hal_module_t::SPI_DIMMER) {
if(count != 6)
return "unsupported value for count";
if(stride != 2)
return "unsupported value for stride";
spi_dimmer::write_data((uint16_t *) data);
} else if(mod == hal_module_t::WS28X) {
if(stride != 4)
return "unsupported value for stride";
ws28x::write_data((ws2812_pixel_t *) data, count);
} else if(mod == hal_module_t::APA10X) {
if(stride != 4)
return "unsupported value for stride";
apa10x::write_data((apa10xx_pixel_t *) data, count);
} else {
return "unsupported module";
}*/
return empty_error;
}
}
//ws2812_pixel_t **pixels_ptr;
extern "C" void signal_led(bool state) {
fiatlux::signal::write_data(state);
}
typedef union {
struct {
unsigned dat: 12;
unsigned addr: 4;
} __attribute__((packed));
uint16_t _;
} cc48x6_frame;
extern "C" bool set_cc48x6(uint16_t a[6]) {
cc48x6_frame f[6] = {
{{a[0], 1}},
{{a[1], 2}},
{{a[2], 3}},
{{a[3], 4}},
{{a[4], 5}},
{{a[5], 6}},
};
return bus_transfer_msg_arr(1, (uint16_t *) f, 6);
}
extern "C" bool set_cc48(uint16_t a) {
uint16_t d[6] = {a, a, a, a, a, a};
return set_cc48x6(d);
}
uint32_t bus_timeout = 200;
/* This task uses the high level GPIO API (esp_gpio.h) to blink an LED.
*
*/
extern "C" [[noreturn]] void lux_task(void *pvParameters) {
fiatlux::signal::setup();
fiatlux::relais::setup();
bool bus_active = bus_init();
int32_t lux_ws2812_number = 240;
auto ret = sysparam_get_int32("lux_ws2812_number", &lux_ws2812_number);
if(ret != SYSPARAM_OK)
lux_ws2812_number = 240;
int32_t lux_apa10xx_number = 40;
ret = sysparam_get_int32("lux_apa10xx_number", &lux_apa10xx_number);
if(ret != SYSPARAM_OK)
lux_apa10xx_number = 40;
ws2812_pixel_t pixels[lux_ws2812_number];
ws2812_i2s_init(lux_ws2812_number, PIXEL_RGBW);
memset(pixels, 0, sizeof(ws2812_pixel_t) * lux_ws2812_number);
if(bus_active) {
reset_bus();
while (bus_init_next())vTaskDelay(100 / portTICK_PERIOD_MS);
}
//apa10xx_pixel_t leds[lux_apa10xx_number]; // TODO
//lux_apa102c_number
//gpio_enable(9, GPIO_INPUT);
//gpio_enable(10, GPIO_INPUT);
//fiatlux::spi_dimmer::setup();
//fiatlux::apa10x::setup();
/*
CC48 API:
- 12 x 16bit registers
- [2*n] = 12bit constant current value
- [2*n+1] = 8bit PWM value
*/
if(bus_active) {
peripheral_version = bus_get_version();
syslog("peripheral_version: ");
syslog_i32(peripheral_version);
syslog("\n");
}
light_value = 0xFFF;
uint16_t last_light_value = 0xFFFF;
while (true) {
if(bus_active) {
if(last_light_value != light_value) {
syslog("# ");
syslog_i32(light_value);
syslog("\n");
bool ok = set_cc48(light_value);
if(ok) {
last_light_value = light_value;
vTaskDelay(1000 / portTICK_PERIOD_MS);
bus_timeout = 200;
} else {
syslog("reset_bus\n");
reset_bus();
printf("timeout: %d\n", bus_timeout);
vTaskDelay(bus_timeout / portTICK_PERIOD_MS);
bus_timeout *= 2;
if(bus_timeout > 10000)
bus_timeout = 10000;
while (bus_init_next())vTaskDelay(100 / portTICK_PERIOD_MS);
}
} else {
bool ping = bus_ping();
if(!ping) {
syslog("ping: reset_bus\n");
reset_bus();
printf("timeout: %d\n", bus_timeout);
vTaskDelay(bus_timeout / portTICK_PERIOD_MS);
bus_timeout *= 2;
if(bus_timeout > 10000)
bus_timeout = 10000;
while (bus_init_next())vTaskDelay(100 / portTICK_PERIOD_MS);
} else {
bus_timeout = 200;
}
}
}
for (int i = 0; i < 120; i++)
pixels[i] = {{top_color.r, top_color.g, top_color.b, top_color.a}};
for (int i = 120; i < 240; i++)
pixels[i] = {{bottom_color.r, bottom_color.g, bottom_color.b, bottom_color.a}};
ws2812_i2s_update(pixels, PIXEL_RGBW);
//uint32_t lt = sdk_system_get_time();
vTaskDelay(200 / portTICK_PERIOD_MS);
//uint32_t dt = sdk_system_get_time() - lt;
//printf("delay: %d, expect: %d\n", dt, configTICK_RATE_HZ * 200);
/*//fiatlux::write_channel((uint8_t *) &leds[0], lux_apa10xx_number, 4, fiatlux::hal_module_t::APA10X);
vTaskDelay(200 / portTICK_PERIOD_MS);
fiatlux::relais::write_data(true, false);
vTaskDelay(200 / portTICK_PERIOD_MS);
fiatlux::relais::write_data(false, true);
vTaskDelay(200 / portTICK_PERIOD_MS);
fiatlux::relais::write_data(false, false);
fiatlux::signal::write_data(true);
vTaskDelay(200 / portTICK_PERIOD_MS);*/
}
}
Reference in a new issue View git blame Copy permalink