hellerbarde/esphome-wordclock
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

feat: wordclock works!

Browse source
This commit is contained in:
Philip Stark 2023-05-09 20:01:36 +02:00
parent 5b0930d616
commit 7f091409cf
8 changed files with 1405 additions and 12 deletions
Download patch file Download diff file Expand all files Collapse all files

447
components/wordclock/__init__.py Normal file
View file

@ -0,0 +1,447 @@
import logging
from esphome import core
from esphome.components import display, font, time, light
import esphome.config_validation as cv
import esphome.codegen as cg
import esphome.cpp_generator as cpp
from esphome.const import (
CONF_ID,
CONF_NAME,
CONF_RAW_DATA_ID,
CONF_TYPE,
CONF_TIME_ID,
CONF_SEGMENTS,
CONF_ADDRESSABLE_LIGHT_ID,
CONF_HOUR,
CONF_HOURS,
CONF_MINUTE,
CONF_MINUTES,
)
from esphome.core import CORE, HexInt
_LOGGER = logging.getLogger(__name__)
CONF_DISPLAY_ID = "display_id"
CONF_LINE_START_X = "x1"
CONF_LINE_START_Y = "y1"
CONF_LINE_END_X = "x2"
CONF_LINE_END_Y = "y2"
CONF_LINE = "line"
CONF_WORDCLOCK_STATIC_SEGMENTS = "static_segments"
CONF_HOUR_OFFSET = "hour_offset"
# CONF_HOURS_MIDNIGHT = "0"
# CONF_HOURS_ONE = "1"
# CONF_HOURS_TWO = "2"
# CONF_HOURS_THREE = "3"
# CONF_HOURS_FOUR = "4"
# CONF_HOURS_FIVE = "5"
# CONF_HOURS_SIX = "6"
# CONF_HOURS_SEVEN = "7"
# CONF_HOURS_EIGHT = "8"
# CONF_HOURS_NINE = "9"
# CONF_HOURS_TEN = "10"
# CONF_HOURS_ELEVEN = "11"
# CONF_HOURS_TWELVE = "12"
# CONF_HOURS_THIRTEEN = "13"
# CONF_HOURS_FOURTEEN = "14"
# CONF_HOURS_FIFTEEN = "15"
# CONF_HOURS_SIXTEEN = "16"
# CONF_HOURS_SEVENTEEN = "17"
# CONF_HOURS_EIGHTTEEN = "18"
# CONF_HOURS_NINETEEN = "19"
# CONF_HOURS_TWENTY = "20"
# CONF_HOURS_TWENTYONE = "21"
# CONF_HOURS_TWENTYTWO = "22"
# CONF_HOURS_TWENTYTHREE = "23"
# CONF_HOURS_MIDNIGHT = "midnight"
# CONF_HOURS_ONE = "one"
# CONF_HOURS_TWO = "two"
# CONF_HOURS_THREE = "three"
# CONF_HOURS_FOUR = "four"
# CONF_HOURS_FIVE = "five"
# CONF_HOURS_SIX = "six"
# CONF_HOURS_SEVEN = "seven"
# CONF_HOURS_EIGHT = "eight"
# CONF_HOURS_NINE = "nine"
# CONF_HOURS_TEN = "ten"
# CONF_HOURS_ELEVEN = "eleven"
# CONF_HOURS_TWELVE = "twelve"
# CONF_HOURS_THIRTEEN = "thirteen"
# CONF_HOURS_FOURTEEN = "fourteen"
# CONF_HOURS_FIFTEEN = "fifteen"
# CONF_HOURS_SIXTEEN = "sixteen"
# CONF_HOURS_SEVENTEEN = "seventeen"
# CONF_HOURS_EIGHTTEEN = "eightteen"
# CONF_HOURS_NINETEEN = "nineteen"
# CONF_HOURS_TWENTY = "twenty"
# CONF_HOURS_TWENTYONE = "twentyone"
# CONF_HOURS_TWENTYTWO = "twentytwo"
# CONF_HOURS_TWENTYTHREE = "twentythree"
# CONF_MINUTES_SHARP = "0"
# CONF_MINUTES_FIVE = "5"
# CONF_MINUTES_TEN = "10"
# CONF_MINUTES_FIFTEEN = "15"
# CONF_MINUTES_TWENTY = "20"
# CONF_MINUTES_TWENTYFIVE = "25"
# CONF_MINUTES_THIRTY = "30"
# CONF_MINUTES_THIRTYFIVE = "35"
# CONF_MINUTES_FORTY = "40"
# CONF_MINUTES_FORTYFIVE = "45"
# CONF_MINUTES_FIFTY = "50"
# CONF_MINUTES_FIFTYFIVE = "55"
DEPENDENCIES = ["display", "time"]
MULTI_CONF = False
wordclock_ns = cg.esphome_ns.namespace("wordclock")
SegmentCoords = wordclock_ns.struct("SegmentCoords")
Wordclock = wordclock_ns.class_(
"Wordclock", cg.PollingComponent
)
WORDCLOCK_SEGMENT_SCHEMA = {
cv.Required(CONF_NAME): cv.string_strict,
cv.Required(CONF_LINE): {
cv.Required(CONF_LINE_START_X): cv.int_,
cv.Required(CONF_LINE_START_Y): cv.int_,
cv.Required(CONF_LINE_END_X): cv.int_,
cv.Optional(CONF_LINE_END_Y): cv.int_,
},
}
WORDCLOCK_HOUR_SCHEMA = {
cv.Required(CONF_HOUR): cv.uint16_t,
cv.Required(CONF_SEGMENTS): cv.ensure_list(cv.string_strict),
}
WORDCLOCK_MINUTE_SCHEMA = {
cv.Required(CONF_MINUTE): cv.uint16_t,
cv.Required(CONF_HOUR_OFFSET): cv.int_range(-1,1),
cv.Required(CONF_SEGMENTS): cv.ensure_list(cv.string_strict),
}
# WORDCLOCK_CONFIG_SCHEMA = {
# cv.Optional(CONF_WORDCLOCK_STATIC_TEXT): cv.ensure_list(cv.string_strict),
# # cv.Required(CONF_LAMBDA): cv.lambda_,
# cv.Required(CONF_SEGMENTS): cv.ensure_list(WORDCLOCK_SEGMENT_SCHEMA),
# cv.Required(CONF_MINUTES): cv.ensure_list(WORDCLOCK_MINUTE_SCHEMA),
# cv.Required(CONF_HOURS): cv.ensure_list(WORDCLOCK_HOUR_SCHEMA),
# }
DATA1 = "data1"
DATA_X1 = "data_x1"
DATA_X2 = "data_x2"
DATA_Y1 = "data_y1"
DATA_Y2 = "data_y2"
DATA_SEGMENT_COORDS = "data_segment_coords"
DATA_MINUTES = "data_minutes"
DATA_HOURS = "data_hours"
DATA_SEGMENTS_HOUR = "data_segments_hour"
DATA_SEGMENTS_MINUTE = "data_segments_minute"
DATA3 = "data3"
DATA4 = "data4"
DATA_VECTOR_SEGMENTS_HOUR = "data_vector_segments_hour"
DATA_VECTOR_SEGMENTS_MINUTE = "data_vector_segments_minute"
int8 = cg.global_ns.namespace("int8_t")
uint16_ptr = cg.global_ns.namespace("uint16_t *")
WORDCLOCK_SCHEMA = cv.Schema(
{
cv.GenerateID(): cv.declare_id(Wordclock),
cv.Required(CONF_DISPLAY_ID): cv.use_id(
display.DisplayBuffer
),
cv.Required(CONF_TIME_ID): cv.use_id(
time.RealTimeClock
),
cv.Required(CONF_ADDRESSABLE_LIGHT_ID): cv.use_id(
light.AddressableLightState
),
# cv.Optional(CONF_LAMBDA): cv.lambda_,
cv.Optional(CONF_WORDCLOCK_STATIC_SEGMENTS): cv.ensure_list(cv.string_strict),
# cv.Required(CONF_LAMBDA): cv.lambda_,
cv.Required(CONF_SEGMENTS): cv.ensure_list(WORDCLOCK_SEGMENT_SCHEMA),
cv.Required(CONF_MINUTES): cv.ensure_list(WORDCLOCK_MINUTE_SCHEMA),
cv.Required(CONF_HOURS): cv.ensure_list(WORDCLOCK_HOUR_SCHEMA),
cv.GenerateID(DATA_X1): cv.declare_id(uint16_ptr),
cv.GenerateID(DATA_X2): cv.declare_id(cg.uint8),
cv.GenerateID(DATA_Y1): cv.declare_id(cg.uint8),
cv.GenerateID(DATA_Y2): cv.declare_id(cg.uint8),
cv.GenerateID(DATA_SEGMENT_COORDS): cv.declare_id(SegmentCoords),
# cv.GenerateID(DATA_MINUTES): cv.declare_id(int8),
# cv.GenerateID(DATA_HOURS): cv.declare_id(int8),
# cv.GenerateID(DATA_MINUTES): cv.declare_id(uint16_ptr),
# cv.GenerateID(DATA_HOURS): cv.declare_id(uint16_ptr),
# cv.GenerateID(DATA_SEGMENTS_MINUTE): cv.declare_id(cg.std_vector.template(cg.uint16)),
# cv.GenerateID(DATA_SEGMENTS_HOUR): cv.declare_id(cg.std_vector.template(cg.uint16)),
cv.GenerateID(DATA_VECTOR_SEGMENTS_HOUR): cv.declare_id(cg.std_vector.template(cg.std_vector.template(cg.uint16))),
cv.GenerateID(DATA_VECTOR_SEGMENTS_MINUTE): cv.declare_id(cg.std_vector.template(cg.std_vector.template(cg.uint16))),
# cv.GenerateID(DATA3): cv.declare_id(cg.uint8),
# cv.GenerateID(DATA4): cv.declare_id(cg.std_vector.template(cg.int32)),
# cv.Required(CONF_WORDCLOCK_CONFIG): cv.ensure_list(WORDCLOCK_CONFIG_SCHEMA),
# cv.Required(CONF_ID): cv.declare_id(Wordclock_),
# cv.Required(CONF_FILE): cv.file_,
# cv.Optional(CONF_RESIZE): cv.dimensions,
# cv.Optional(CONF_TYPE, default="BINARY"): cv.enum(IMAGE_TYPE, upper=True),
# cv.Optional(CONF_DITHER, default="NONE"): cv.one_of(
# "NONE", "FLOYDSTEINBERG", upper=True
# ),
# cv.GenerateID(CONF_RAW_DATA_ID): cv.declare_id(cg.uint8),
}
)
# CONFIG_SCHEMA = cv.All(font.validate_pillow_installed, WORDCLOCK_SCHEMA)
CONFIG_SCHEMA = WORDCLOCK_SCHEMA
async def to_code(config):
wrapped_display = await cg.get_variable(config[CONF_DISPLAY_ID])
wrapped_time = await cg.get_variable(config[CONF_TIME_ID])
wrapped_light_state = await cg.get_variable(config[CONF_ADDRESSABLE_LIGHT_ID])
var = cg.new_Pvariable(config[CONF_ID], wrapped_time, wrapped_display, wrapped_light_state)
SEGMENT_MAP = dict()
for idx, segm in enumerate(config[CONF_SEGMENTS]):
print(segm[CONF_NAME])
SEGMENT_MAP[segm[CONF_NAME]] = idx
line_start_x = segm[CONF_LINE][CONF_LINE_START_X]
line_end_x = segm[CONF_LINE][CONF_LINE_END_X]
line_start_y = segm[CONF_LINE][CONF_LINE_START_Y]
line_end_y = segm[CONF_LINE].get(CONF_LINE_END_Y, line_start_y)
exp = cg.StructInitializer(
SegmentCoords,
("x1", line_start_x),
("x2", line_end_x),
("y1", line_start_y),
("y2", line_end_y),
)
cg.add(var.add_segment(exp))
if CONF_WORDCLOCK_STATIC_SEGMENTS in config:
# cg.static_const_array(config[DATA_SEGMENT_COORDS], accumulator)
# print(SEGMENT_MAP)
for segment_name in config[CONF_WORDCLOCK_STATIC_SEGMENTS]:
cg.add(var.add_static(SEGMENT_MAP[segment_name]))
# static_segment_ids = config[CONF_WORDCLOCK_STATIC_SEGMENTS]
# exp = cg.std_vector.template(cg.uint16)(static_segment_ids)
# cg.add(var.add_static(hour[CONF_HOUR], cpp.UnaryOpExpression("&", exp)))
hours = []
for idx, hour in enumerate(config[CONF_HOURS]):
segment_ids = [SEGMENT_MAP[a] for a in hour[CONF_SEGMENTS]]
exp = cg.std_vector.template(cg.uint16)(segment_ids)
hours.append(exp)
hours_array = cg.new_variable(config[DATA_VECTOR_SEGMENTS_HOUR], cg.std_vector.template(cg.std_vector.template(cg.uint16))(hours))
minutes = []
for idx, hour in enumerate(config[CONF_MINUTES]):
segment_ids = [SEGMENT_MAP[a] for a in hour[CONF_SEGMENTS]]
exp = cg.std_vector.template(cg.uint16)(segment_ids)
minutes.append(exp)
minutes_array = cg.new_variable(config[DATA_VECTOR_SEGMENTS_MINUTE], cg.std_vector.template(cg.std_vector.template(cg.uint16))(minutes))
for idx, hour in enumerate(config[CONF_HOURS]):
exp = cg.std_vector.template(cg.uint16)(segment_ids)
cg.add(var.add_hour(hour[CONF_HOUR], cpp.UnaryOpExpression("&", hours_array[idx])))
# minutes = [[],] * 60
for idx, minute in enumerate(config[CONF_MINUTES]):
exp = cg.std_vector.template(cg.uint16)(segment_ids)
cg.add(var.add_minute(minute[CONF_MINUTE], cpp.UnaryOpExpression("&", minutes_array[idx])))
# segment_ids = [SEGMENT_MAP[a] for a in minute[CONF_SEGMENTS]]
# minutes[minute[CONF_MINUTE]] = cg.std_vector.template(cg.int32)()
# foo = []
# cg.ArrayInitializer()
'''exp = cg.std_vector.template(cg.uint16)(segment_ids)'''
# exp = cg.ArrayInitializer(minute[CONF_SEGMENTS])
'''cg.add(var.add_minute(minute[CONF_MINUTE], exp))'''
# for segment_str in minute[CONF_SEGMENTS]:
# foo.append(SEGMENT_MAP[segment_str])
# # minutes[minute[CONF_MINUTE]].push_back(SEGMENT_MAP[segment_str])
# minutes[minute[CONF_MINUTE]] = foo
# print(minute[CONF_MINUTE])
# SEGMENT_MAP[i[CONF_NAME]] = idx
# accumulator.append(idx)
for idx, minute in enumerate(config[CONF_MINUTES]):
cg.add(var.add_hour_offset(minute[CONF_MINUTE], minute[CONF_HOUR_OFFSET]))
await cg.register_component(var, config)
"""
accumulator = []
SEGMENT_MAP = dict()
for idx, segm in enumerate(config[CONF_SEGMENTS]):
print(segm[CONF_NAME])
SEGMENT_MAP[segm[CONF_NAME]] = idx
# x1.append()
# x2.append()
line_start_x = segm[CONF_LINE][CONF_LINE_START_X]
line_end_x = segm[CONF_LINE][CONF_LINE_END_X]
line_start_y = segm[CONF_LINE][CONF_LINE_START_Y]
line_end_y = segm[CONF_LINE].get(CONF_LINE_END_Y, line_start_y)
# print(line_start_y)
# print(line_end_y)
# y1.append(segm[CONF_LINE][CONF_LINE_START_Y])
# y2.append(line_end_y)
exp = cg.StructInitializer(
SegmentCoords,
("x1", line_start_x),
("x2", line_end_x),
("y1", line_start_y),
("y2", line_end_y),
)
accumulator.append(exp)
cg.static_const_array(config[DATA_SEGMENT_COORDS], accumulator)
print(SEGMENT_MAP)
minutes = [[],] * 60
for idx, minute in enumerate(config[CONF_MINUTES]):
# minutes[minute[CONF_MINUTE]] = cg.std_vector.template(cg.int32)()
foo = []
cg.ArrayInitializer()
for segment_str in minute[CONF_SEGMENTS]:
foo.append(SEGMENT_MAP[segment_str])
# minutes[minute[CONF_MINUTE]].push_back(SEGMENT_MAP[segment_str])
minutes[minute[CONF_MINUTE]] = foo
print(minute[CONF_MINUTE])
# SEGMENT_MAP[i[CONF_NAME]] = idx
# accumulator.append(idx)
print(minutes)
cg.static_const_array(config[DATA_MINUTES], minutes)
"""
"""
hours = [cg.std_vector.template(cg.uint16)()] * 24
cg.static_const_array(config[DATA_HOURS], hours)
for idx, i in enumerate(config[CONF_HOURS]):
# for segment_str in i[CONF_SEGMENTS]:
# print(config[DATA_HOURS].type)
# push = config[DATA_HOURS].get(i[CONF_HOUR]).push_back(SEGMENT_MAP[segment_str])
# cg.add(push)
# hours[i[CONF_HOUR]] = cg.std_vector.template(cg.int32)()
print(i[CONF_HOUR])
# SEGMENT_MAP[i[CONF_NAME]] = idx
# accumulator.append(idx)
print(hours)
# cg.static_const_array(config[DATA_HOURS], hours)
# cg.static_const_array(config[DATA3], hours)
# cg.static_const_array(config[DATA4], hours)
"""
# prog_arr = cg.progmem_array(config[CONF_RAW_DATA_ID], rhs)
# cg.add_global(cg.Statement(f"const int {i[CONF_NAME]} = 0;"))
# cg.add_global(f"""
# /*
# {global_consts}
# */
# """)
# from PIL import Image
# path = CORE.relative_config_path(config[CONF_FILE])
# try:
# image = Image.open(path)
# except Exception as e:
# raise core.EsphomeError(f"Could not load image file {path}: {e}")
# width, height = image.size
# if CONF_RESIZE in config:
# image.thumbnail(config[CONF_RESIZE])
# width, height = image.size
# else:
# if width > 500 or height > 500:
# _LOGGER.warning(
# "The image you requested is very big. Please consider using"
# " the resize parameter."
# )
# dither = Image.NONE if config[CONF_DITHER] == "NONE" else Image.FLOYDSTEINBERG
# if config[CONF_TYPE] == "GRAYSCALE":
# image = image.convert("L", dither=dither)
# pixels = list(image.getdata())
# data = [0 for _ in range(height * width)]
# pos = 0
# for pix in pixels:
# data[pos] = pix
# pos += 1
# elif config[CONF_TYPE] == "RGB24":
# image = image.convert("RGB")
# pixels = list(image.getdata())
# data = [0 for _ in range(height * width * 3)]
# pos = 0
# for pix in pixels:
# data[pos] = pix[0]
# pos += 1
# data[pos] = pix[1]
# pos += 1
# data[pos] = pix[2]
# pos += 1
# elif config[CONF_TYPE] == "RGB565":
# image = image.convert("RGB")
# pixels = list(image.getdata())
# data = [0 for _ in range(height * width * 3)]
# pos = 0
# for pix in pixels:
# R = pix[0] >> 3
# G = pix[1] >> 2
# B = pix[2] >> 3
# rgb = (R << 11) | (G << 5) | B
# data[pos] = rgb >> 8
# pos += 1
# data[pos] = rgb & 255
# pos += 1
# elif (config[CONF_TYPE] == "BINARY") or (config[CONF_TYPE] == "TRANSPARENT_BINARY"):
# image = image.convert("1", dither=dither)
# width8 = ((width + 7) // 8) * 8
# data = [0 for _ in range(height * width8 // 8)]
# for y in range(height):
# for x in range(width):
# if image.getpixel((x, y)):
# continue
# pos = x + y * width8
# data[pos // 8] |= 0x80 >> (pos % 8)
# elif config[CONF_TYPE] == "TRANSPARENT_IMAGE":
# image = image.convert("RGBA")
# width8 = ((width + 7) // 8) * 8
# data = [0 for _ in range(height * width8 // 8)]
# for y in range(height):
# for x in range(width):
# if not image.getpixel((x, y))[3]:
# continue
# pos = x + y * width8
# data[pos // 8] |= 0x80 >> (pos % 8)
# rhs = [HexInt(x) for x in data]
# prog_arr = cg.progmem_array(config[CONF_RAW_DATA_ID], rhs)
# cg.new_Pvariable(
# config[CONF_ID], prog_arr, width, height, IMAGE_TYPE[config[CONF_TYPE]]
# )

305
components/wordclock/wordclock.cpp Normal file
View file

@ -0,0 +1,305 @@
#include "wordclock.h"
namespace esphome {
namespace wordclock {
void Wordclock::setup() {
// this->time->update();
// this->light_state->add_effects({this->randomTwinkle});
// this->start_idle_animation();
}
void Wordclock::start_idle_animation() {
this->display->set_enabled(false);
// auto call =
this->light_state->turn_on().set_effect("random_twinkle").perform();
// call.set_effect("random_twinkle");
// call.perform();
}
void Wordclock::end_idle_animation() {
this->light_state->turn_off().perform();
this->display->set_enabled(true);
// this->light->clear_effect_data();
// this->display->get_light()->set_effect_active(false);
// auto call1 = this->light_state->turn_on();
// call1.set_effect("None");
// call1.perform();
// this->light->all().set(Color(0xF0FF00));
// this->display->fill(Color(0));
// this->light_state->turn_off().perform();
// call2.perform();
}
void Wordclock::update() {
// esphome::addressable_light::AddressableLightDisplay it = *(this->display);
// ESP_LOGD("loop", "beep");
// ESP_LOGD("loop", "time is now [%02i:%02i:%02i]", this->time->now().hour, this->time->now().minute, this->time->now().second);
// ESP_LOGE("wordclock.cpp", "display_ptr: 0x%x", it);
// ESP_LOGE("wordclock.cpp", "this: 0x%x", (this));
// ESP_LOGE("wordclock.cpp", "this->display: 0x%x", (this->display));
// ESP_LOGE("wordclock.cpp", "&this->display: 0x%x", &(this->display));
// ESP_LOGE("loop", "time_ptr: %i", this->time);
// it.line(0,0,0,0, Color(0x00FF00));
esphome::time::ESPTime time = this->time->now();
this->find_hour(9);
this->find_minute(31);
if (time.is_valid() == false) {
if (this->valid_time) {
ESP_LOGD("loop", "time is not valid [%02i:%02i:%02i]", time.hour, time.minute, time.second);
this->start_idle_animation();
this->valid_time = false;
return;
}
}
else {
if (!this->valid_time) {
this->end_idle_animation();
this->valid_time = true;
ESP_LOGD("wordclock.cpp", "time is now valid [%02i:%02i:%02i]", time.hour, time.minute, time.second);
return;
}
// for (uint8_t idx = 0;idx < ; idx++) {
// }
// std::vector<uint16_t> *minute = this->find_minute(time.minute);
// std::vector<uint16_t> *hour = this->find_hour(time.hour);
this->display->fill(Color(0x000000));
int8_t minute = this->find_minute(time.minute);
int8_t hour = this->find_hour((time.hour + this->hour_offsets->at(minute)) % 24);
for (uint16_t segment_idx : *this->static_segments){
this->draw_segment(segment_idx);
}
for (uint16_t segment_idx : this->minutes->at(minute)){
this->draw_segment(segment_idx);
}
for (uint16_t segment_idx : this->hours->at(hour)){
this->draw_segment(segment_idx);
}
// this->draw_segment(0);
// this->draw_segment(1);
// this->draw_segment(4);
// this->draw_segment(10);
// this->draw_segment(19);
// this->light->range(0, 10).fade_to_white(100);
// this->display->get_light()->range(18, 35).set(Color(0xf0ff0f));
// SegmentCoords s = this->segments->at(time);
// ESP_LOGD("wordclock.cpp", "time is now [%02i:%02i:%02i]", time.hour, time.minute, time.second);
// ESP_LOGD("wordclock.cpp", "x1: %i, y1: %i, x2: %i, y2: %i", s.x1, s.y1, s.x2, s.y2);
// this->display->draw_pixel_at(0, 0, Color(0xFF0000));
// this->display->draw_pixel_at(1, 0, Color(0x00FF00));
// this->display->draw_pixel_at(2, 0, Color(0x0000FF));
// if (time.second != second) {
// second = time.second;
// ESP_LOGD("loop", "time is now [%02i:%02i:%02i]", time.hour, time.minute, time.second);
// }
// if(time.hour != hour || time.minute != minute) {
// hour = time.hour;
// minute = time.minute;
// if (hour >= 0 && time.is_valid() == true){
// display_time(time.hour, time.minute, CRGB(red, green, blue));
// ESP_LOGE("loop", "Update Time: %i:%i Brightness: %i RGB: %i-%i-%i", time.hour, time.minute, brightness, red, green, blue);
// }
// }
// }
// if (!this->reading_ && !mode_funcs_.empty()) {
// this->reading_ = true;
// this->read_mode_(0);
}
}
void Wordclock::draw_segment(uint16_t segment_id) {
SegmentCoords s = this->segments->at(segment_id);
// ESP_LOGD("wordclock.cpp", "x1: %i, y1: %i, x2: %i, y2: %i", s.x1, s.y1, s.x2, s.y2);
this->display->line(s.x1, s.y1, s.x2, s.y2, esphome::Color(0xFFFFFF));
}
// void Wordclock::set_writer(display_writer_t &&writer) {
// this->writer_ = writer;
// }
void Wordclock::add_segment(SegmentCoords segment) {
// if (!this->segments) {
// }
this->segments->push_back(segment);
// this->writer_ = writer;
}
// std::vector<uint16_t> * Wordclock::find_hour(uint8_t hour) {
// std::vector<uint16_t> *empty_vector; // = new std::vector<uint16_t>();
// uint16_t last_defined_hour = -1;
// for (int i = 0; i < this->hours->size(); i++) {
// if (this->hours->at(i).size()) {
// if (hour == i) {
// return &(this->hours->at(i));
// }
// else {
// last_defined_hour = i;
// }
// }
// else {
// empty_vector = &(this->hours->at(i));
// if (hour == i) {
// if (last_defined_hour == -1) return empty_vector;
// return &(this->hours->at(last_defined_hour));
// }
// }
// }
// return empty_vector;
// }
int8_t Wordclock::find_hour(uint8_t hour) {
uint16_t last_defined_hour = -1;
for (int i = 0; i < this->hours->size(); i++) {
if (this->hours->at(i).size()) {
last_defined_hour = i;
if (hour == i) {
return last_defined_hour;
}
}
if (hour == i) break;
}
return last_defined_hour;
}
int8_t Wordclock::find_minute(uint8_t minute) {
uint16_t last_defined_minute = -1;
for (int i = 0; i < this->minutes->size(); i++) {
if (this->minutes->at(i).size()) {
last_defined_minute = i;
if (minute == i) {
return last_defined_minute;
}
}
if (minute == i) break;
}
return last_defined_minute;
}
// std::vector<uint16_t> * Wordclock::find_minute(uint8_t minute) {
// std::vector<uint16_t> *empty_vector;// = new std::vector<uint16_t>();
// uint16_t last_defined_minute = -1;
// for (int i = 0; i < this->minutes->size(); i++) {
// if (this->minutes->at(i).size()) {
// if (minute == i) {
// return &(this->minutes->at(i));
// }
// else {
// last_defined_minute = i;
// }
// }
// else {
// empty_vector = &(this->minutes->at(i));
// if (minute == i) {
// if (last_defined_minute == -1) return empty_vector;
// return &(this->minutes->at(last_defined_minute));
// }
// }
// }
// return empty_vector;
// }
void Wordclock::add_hour_offset(uint8_t index, int8_t offset) {
(*this->hour_offsets)[index] = offset;
}
void Wordclock::add_hour(uint8_t hour, std::vector<uint16_t> *segments) {
for (uint16_t i : *segments){
this->hours->at(hour).push_back(i);
}
}
void Wordclock::add_minute(uint8_t minute, std::vector<uint16_t> *segments) {
for (uint16_t i : *segments){
this->minutes->at(minute).push_back(i);
}
}
void Wordclock::add_static(uint16_t segment_id) {
this->static_segments->push_back(segment_id);
}
// uint16_t **
// Wordclock::Wordclock(std::vector<uint16_t> *minutes, std::vector<uint16_t> *hours, SegmentCoords *segments)
// Wordclock::Wordclock(uint16_t **minutes, uint16_t **hours, SegmentCoords *segments)
// : PollingComponent(1000) {
// // this->minutes = minutes;
// // this->hours = hours;
// // this->segments = segments;
// // std::vector<uint16_t> minutes[60];
// // std::vector<uint16_t> hours[24];
// }
Wordclock::Wordclock()
: PollingComponent(1000) {
// this->minutes = std::vector<std::vector<uint16_t>>();
// // for (int i=0; i<60; i++) this->minutes.push_back(std::vector<uint16_t>());
// this->hours = std::vector<std::vector<uint16_t>>();
// // for (int i=0; i<24; i++) this->minutes.push_back(std::vector<uint16_t>());
// this->segments = std::vector<SegmentCoords>();
}
Wordclock::Wordclock(esphome::time::RealTimeClock *time, esphome::addressable_light::AddressableLightDisplay *display, esphome::light::AddressableLightState *light_state)
: PollingComponent(16) {
// ESP_LOGE("wordclock.cpp", "this: 0x%x", (this));
// ESP_LOGE("wordclock.cpp", "display: 0x%x", (display));
// ESP_LOGE("wordclock.cpp", "&display: 0x%x", (&display));
this->time = time;
this->display = display;
this->light = this->display->get_light();
this->light_state = light_state;
// light::AddressableLight *light = this->display->get_light();
// light::AddressableRainbowLightEffect *light_addressablerainbowlighteffect;
// light::AddressableTwinkleEffect *light_addressabletwinkleeffect;
// light::AddressableRandomTwinkleEffect *light_addressablerandomtwinkleeffect;
// this->rainbow = new light::AddressableRainbowLightEffect("rainbow");
// this->rainbow->set_speed(10);
// this->rainbow->set_width(50);
// this->twinkle = new light::AddressableTwinkleEffect("twinkle");
// this->twinkle->set_twinkle_probability(0.05f);
// this->twinkle->set_progress_interval(4);
// this->randomTwinkle = new light::AddressableRandomTwinkleEffect("random_twinkle");
// this->randomTwinkle->set_twinkle_probability(0.05f);
// this->randomTwinkle->set_progress_interval(32);
this->hour_offsets = new std::vector<int8_t>(60, 0);
this->minutes = new std::vector<std::vector<uint16_t>>(60, std::vector<uint16_t>());
// for (int i=0; i<60; i++) this->minutes->push_back(std::vector<uint16_t>());
this->hours = new std::vector<std::vector<uint16_t>>(24, std::vector<uint16_t>());
// for (int i=0; i<24; i++) this->hours->push_back(std::vector<uint16_t>());
this->segments = new std::vector<SegmentCoords>();
this->static_segments = new std::vector<uint16_t>();
}
} // namespace wordclock
} // namespace esphome

227
components/wordclock/wordclock.h Normal file
View file

@ -0,0 +1,227 @@
#pragma once
#include "esphome.h"
// By now only loosely based on https://github.com/leinich/ha-wordclock-esphome
// esphome dependencies:
// needs: esphome time --> id: current_time
// needs: esphome fastled --> id: fastledlight
// #ifdef USE_ESP32
namespace esphome {
namespace wordclock {
///// Word Table /////
// .line(0,0,1,0, color);
// .line(2,0,3,0, color);
// int WORD_IT_IS[5][2] = {{4,0}, {0,0}, {0,1}, {0,3}, {0,4}};
// // .line(2,1,8,1, color);
// int WORD_QUARTER[8][2] = {{7,0}, {1,2}, {1,3}, {1,4}, {1,5}, {1,6}, {1,7}, {1,8}};
// // .line(0,2, 5,2, color);
// int WORD_TWENTY[7][2] = {{6,0}, {2,0}, {2,1}, {2,2}, {2,3}, {2,4}, {2,5}};
// // .line(6,2, 9,2, color);
// int WORD_FIVE_MINUTES[5][2] = {{4,0}, {2,6}, {2,7}, {2,8}, {2,9}};
// // .line(0,3, 3,3, color);
// int WORD_HALF[5][2] = {{4,0}, {3,0}, {3,1}, {3,2}, {3,3}};
// // .line(5,3, 7,3, color);
// int WORD_TEN_MINUTES[4][2] = {{3,0}, {3,5}, {3,6}, {3,7}};
// // .line(9,3, 10,3, color);
// int WORD_TO[3][2] = {{2,0}, {3,9}, {3,10}};
// // .line(0,4, 3,4, color);
// int WORD_PAST[5][2] = {{4,0}, {4,0}, {4,1}, {4,2}, {4,3}};
// int WORD_NINE[5][2] = {{4,0}, {4,7}, {4,8}, {4,9}, {4,10}};
// int WORD_ONE[4][2] = {{3,0}, {5,0}, {5,1}, {5,2}};
// int WORD_SIX[4][2] = {{3,0}, {5,3}, {5,4}, {5,5}};
// int WORD_THREE[6][2] = {{5,0}, {5,6}, {5,7}, {5,8}, {5,9}, {5,10}};
// int WORD_FOUR[5][2] = {{4,0}, {6,0}, {6,1}, {6,2}, {6,3}};
// int WORD_FIVE[5][2] = {{4,0}, {6,4}, {6,5}, {6,6}, {6,7}};
// int WORD_TWO[4][2] = {{3,0}, {6,8}, {6,9}, {6,10}};
// int WORD_EIGHT[6][2] = {{5,0}, {7,0}, {7,1}, {7,2}, {7,3}, {7,4}};
// int WORD_ELEVEN[7][2] = {{6,0}, {7,5}, {7,6}, {7,7}, {7,8}, {7,9}, {7,10}};
// int WORD_SEVEN[6][2] = {{5,0}, {8,0}, {8,1}, {8,2}, {8,3}, {8,4}};
// int WORD_TWELFE[7][2] = {{6,0}, {8,5}, {8,6}, {8,7}, {8,8}, {8,9}, {8,10}};
// int WORD_TEN[4][2] = {{3,0}, {9,0}, {9,1}, {9,2}};
// int WORD_OCLOCK[7][2] = {{6,0}, {9,5}, {9,6}, {9,7}, {9,8}, {9,9}, {9,10}};
// using display_writer_t = std::function<void(esphome::Dieplay::Display &)>;
struct SegmentCoords {
uint16_t x1;
uint16_t x2;
uint16_t y1;
uint16_t y2;
};
class Wordclock : public esphome::PollingComponent {
public:
Wordclock();
Wordclock(esphome::time::RealTimeClock *time, esphome::addressable_light::AddressableLightDisplay *display, esphome::light::AddressableLightState *light_state);
void add_segment(SegmentCoords segment);
void add_hour(uint8_t index, std::vector<uint16_t> *segments);
void add_minute(uint8_t index, std::vector<uint16_t> *segments);
void add_static(uint16_t segment_id);
void add_hour_offset(uint8_t index, int8_t offset);
void setup();
void update();
// void setup() override {
// }
// void set_writer(display_writer_t &&writer);
// void display_word(const int word[][2], const CRGB& c) {
// for (int i=1; i < word[0][0] + 1; i++) {
// leds[map_coords_to_strip(word[i][0], word[i][1])].setRGB(c.r, c.g, c.b);
// }
// }
// void display_minutes(int minutes, const CRGB& color) {
// int five_minute_chunk = minutes / 5;
// switch (five_minute_chunk)
// {
// case 0: // sharp
// display_word(WORD_OCLOCK, color); ESP_LOGD("minute", "oclock "); break;
// case 1: // five past
// display_word(WORD_FIVE_MINUTES, color); ESP_LOGD("minute", "five past "); break;
// case 2: // ten past
// display_word(WORD_TEN_MINUTES, color); ESP_LOGD("minute", "ten past "); break;
// case 3: // quarter past
// display_word(WORD_QUARTER, color); ESP_LOGD("minute", "quarter past "); break;
// case 4: // twenty past
// display_word(WORD_TWENTY, color); ESP_LOGD("minute", "twenty past "); break;
// case 5: // twenty five past
// display_word(WORD_TWENTY, color); display_word(WORD_FIVE_MINUTES, color);
// ESP_LOGD("minute", "twenty five past "); break;
// case 6: // half past
// display_word(WORD_HALF, color); ESP_LOGD("minute", "half past "); break;
// case 7: // twenty five to
// display_word(WORD_TWENTY, color); display_word(WORD_FIVE_MINUTES, color);
// ESP_LOGD("minute", "twenty five to "); break;
// case 8: // twenty to
// display_word(WORD_TWENTY, color); ESP_LOGD("minute", "twenty to "); break;
// case 9: // quarter to
// display_word(WORD_QUARTER, color); ESP_LOGD("minute", "quarter to "); break;
// case 10: // ten to
// display_word(WORD_TEN_MINUTES, color); ESP_LOGD("minute", "ten to "); break;
// case 11: // five to
// display_word(WORD_FIVE_MINUTES, color); ESP_LOGD("minute", "five to "); break;
// default:
// break;
// }
// if (five_minute_chunk > 6) {
// display_word(WORD_TO, color);
// } else if (five_minute_chunk > 0) {
// display_word(WORD_PAST, color);
// }
// }
// void display_hour(int hour, int minutes, const CRGB& color) {
// int five_minute_chunk = minutes / 5;
// if (five_minute_chunk > 6) {
// hour += 1;
// }
// switch (hour % 12)
// {
// case 0: // twelve
// display_word(WORD_TWELFE, color); ESP_LOGD("hour", "twelve "); break;
// case 1: // one
// display_word(WORD_ONE, color); ESP_LOGD("hour", "one "); break;
// case 2: // two
// display_word(WORD_TWO, color); ESP_LOGD("hour", "two "); break;
// case 3: // three
// display_word(WORD_THREE, color); ESP_LOGD("hour", "three "); break;
// case 4: // four
// display_word(WORD_FOUR, color); ESP_LOGD("hour", "four "); break;
// case 5: // five
// display_word(WORD_FIVE, color); ESP_LOGD("hour", "five "); break;
// case 6: // six
// display_word(WORD_SIX, color); ESP_LOGD("hour", "six "); break;
// case 7: // seven
// display_word(WORD_SEVEN, color); ESP_LOGD("hour", "seven "); break;
// case 8: // eight
// display_word(WORD_EIGHT, color); ESP_LOGD("hour", "eight "); break;
// case 9: // nine
// display_word(WORD_NINE, color); ESP_LOGD("hour", "nine "); break;
// case 10: // ten
// display_word(WORD_TEN, color); ESP_LOGD("hour", "ten "); break;
// case 11: // eleven
// display_word(WORD_ELEVEN, color); ESP_LOGD("hour", "eleven "); break;
// default:
// break;
// }
// }
// void display_time(int hour, int minutes, const CRGB& color) {
// // clear_all_leds();
// display_word(WORD_IT_IS, color);
// display_hour(hour, minutes, color);
// display_minutes(minutes, color);
// // FastLED.show();
// }
// void loop() override {
// // auto time = id(current_time).now();
// // https://www.esphome.io/api/classesphome_1_1light_1_1_light_color_values.html LightColorValues Class
// // auto fastledlight2 = id(fastledlight).current_values;
// //convert float 0.0 till 1.0 into int 0 till 255
// red = (int) (fastledlight2.get_red() * 125);
// green = (int) (fastledlight2.get_green() * 125);
// blue = (int) (fastledlight2.get_blue() * 125);
// brightness = 0;
// //check if light is on and set brightness
// if (fastledlight2.get_state() > 0 ) {
// brightness = (int) (fastledlight2.get_brightness()*125);
// } else {
// // ESP_LOGD("loop", "fastledlight state off - b: %i rgb %i %i %i", brightness, red, green, blue); delay(100);
// }
// FastLED.setBrightness(brightness);
// FastLED.show();
// //check if valid time. Blink red,green,blue until valid time is present
// }
protected:
void draw_segment(uint16_t segment_id);
int8_t find_hour(uint8_t hour);
int8_t find_minute(uint8_t minute);
// std::vector<uint16_t> * find_hour(uint8_t hour);
// std::vector<uint16_t> * find_minute(uint8_t minute);
std::vector<std::vector<uint16_t>> *minutes;
std::vector<std::vector<uint16_t>> *hours;
std::vector<uint16_t> *static_segments;
std::vector<int8_t> *hour_offsets;
void start_idle_animation();
void end_idle_animation();
// uint16_t **minutes;
// uint16_t **hours;
bool valid_time{true};
std::vector<SegmentCoords> *segments;
esphome::time::RealTimeClock *time;
esphome::light::AddressableLight *light;
esphome::light::AddressableLightState *light_state;
esphome::addressable_light::AddressableLightDisplay *display;
light::AddressableRainbowLightEffect *rainbow;
light::AddressableTwinkleEffect *twinkle;
light::AddressableRandomTwinkleEffect *randomTwinkle;
};
} // namespace wordclock
} // namespace esphome