ctdo
/
esp-pixelprojektor
16
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
esp-pixelprojektor/pixelprojektor/pixelprojektor.ino

894 lines
23 KiB
C++
Raw Blame History

#include <Homie.h>
// homie lib from: https://github.com/marvinroger/homie-esp8266/
#include <Adafruit_NeoPixel.h>
#include <ArduinoOTA.h>
#ifdef __AVR__
#include <avr/power.h>
#endif
#define PIN D1 //data pin for ws2812 (pixelprojektor @ ctdo: PIN 2)
#define NUMPIXELS 64
#define FPS 15
uint8_t effect = 0;
#define EFFECT_NONE 0
#define EFFECT_SMOOTH 1
uint8_t movingPoint_x = 3;
uint8_t movingPoint_y = 3;
uint8_t wheelPos = 0;
uint8_t wheelPosSlow = 0; //for slower wheelPos increment than 1
int wheelSpeed = 16; //16=+1/frame
int smoothing = 80; //0 to 100. 100=no change (ultrasmooth), 0=no smoothing.
int strength = 50; //how much pixels to apply color to
#define EFFECT_SPIRAL 2
#define EFFECT_RANDOMFADE 3
#define EFFECT_CHASE 4
#define EFFECT_RADAR 5
#define EFFECT_LARSON 6
int fadespeedmax = 5; //1 to 255
int iconCountStart = 0; //for percentage calculation
int iconCountdown = 0; //0=off
uint8_t iconchar = 0; //last displayed char
int32_t iconcolor = 0; //last icon color
uint16_t Index; // current step within the pattern
// int Index = 0; // Step for Effect (e.g. chase)
// int state = 0; // Direction for Larson Scanner (spiral)
enum direction { FORWARD, REVERSE }; // Direction
direction Direction; // direction to run the pattern
/* the values in this array are a 8x8 bitmap font for ascii characters */
static uint64_t font[128] = {
/************************************************************************
font.c
Copyright (C) Lisa Milne 2014 <lisa@ltmnet.com>
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>
************************************************************************/
0x7E7E7E7E7E7E0000, /* NUL */
0x7E7E7E7E7E7E0000, /* SOH */
0x7E7E7E7E7E7E0000, /* STX */
0x7E7E7E7E7E7E0000, /* ETX */
0x7E7E7E7E7E7E0000, /* EOT */
0x7E7E7E7E7E7E0000, /* ENQ */
0x7E7E7E7E7E7E0000, /* ACK */
0x7E7E7E7E7E7E0000, /* BEL */
0x7E7E7E7E7E7E0000, /* BS */
0x0, /* TAB */
0x7E7E7E7E7E7E0000, /* LF */
0x7E7E7E7E7E7E0000, /* VT */
0x7E7E7E7E7E7E0000, /* FF */
0x7E7E7E7E7E7E0000, /* CR */
0x7E7E7E7E7E7E0000, /* SO */
0x7E7E7E7E7E7E0000, /* SI */
0x7E7E7E7E7E7E0000, /* DLE */
0x7E7E7E7E7E7E0000, /* DC1 */
0x7E7E7E7E7E7E0000, /* DC2 */
0x7E7E7E7E7E7E0000, /* DC3 */
0x7E7E7E7E7E7E0000, /* DC4 */
0x7E7E7E7E7E7E0000, /* NAK */
0x7E7E7E7E7E7E0000, /* SYN */
0x7E7E7E7E7E7E0000, /* ETB */
0x7E7E7E7E7E7E0000, /* CAN */
0x7E7E7E7E7E7E0000, /* EM */
0x7E7E7E7E7E7E0000, /* SUB */
0x7E7E7E7E7E7E0000, /* ESC */
0x7E7E7E7E7E7E0000, /* FS */
0x7E7E7E7E7E7E0000, /* GS */
0x7E7E7E7E7E7E0000, /* RS */
0x7E7E7E7E7E7E0000, /* US */
0x0, /* (space) */
0x808080800080000, /* ! */
0x2828000000000000, /* " */
0x287C287C280000, /* # */
0x81E281C0A3C0800, /* $ */
0x6094681629060000, /* % */
0x1C20201926190000, /* & */
0x808000000000000, /* ' */
0x810202010080000, /* ( */
0x1008040408100000, /* ) */
0x2A1C3E1C2A000000, /* * */
0x8083E08080000, /* + */
0x81000, /* , */
0x3C00000000, /* - */
0x80000, /* . */
0x204081020400000, /* / */
0x1824424224180000, /* 0 */
0x8180808081C0000, /* 1 */
0x3C420418207E0000, /* 2 */
0x3C420418423C0000, /* 3 */
0x81828487C080000, /* 4 */
0x7E407C02423C0000, /* 5 */
0x3C407C42423C0000, /* 6 */
0x7E04081020400000, /* 7 */
0x3C423C42423C0000, /* 8 */
0x3C42423E023C0000, /* 9 */
0x80000080000, /* : */
0x80000081000, /* ; */
0x6186018060000, /* < */
0x7E007E000000, /* = */
0x60180618600000, /* > */
0x3844041800100000, /* ? */
0x3C449C945C201C, /* @ */
0x1818243C42420000, /* A */
0x7844784444780000, /* B */
0x3844808044380000, /* C */
0x7844444444780000, /* D */
0x7C407840407C0000, /* E */
0x7C40784040400000, /* F */
0x3844809C44380000, /* G */
0x42427E4242420000, /* H */
0x3E080808083E0000, /* I */
0x1C04040444380000, /* J */
0x4448507048440000, /* K */
0x40404040407E0000, /* L */
0x4163554941410000, /* M */
0x4262524A46420000, /* N */
0x1C222222221C0000, /* O */
0x7844784040400000, /* P */
0x1C222222221C0200, /* Q */
0x7844785048440000, /* R */
0x1C22100C221C0000, /* S */
0x7F08080808080000, /* T */
0x42424242423C0000, /* U */
0x8142422424180000, /* V */
0x4141495563410000, /* W */
0x4224181824420000, /* X */
0x4122140808080000, /* Y */
0x7E040810207E0000, /* Z */
0x3820202020380000, /* [ */
0x4020100804020000, /* */
0x3808080808380000, /* ] */
0x1028000000000000, /* ^ */
0x7E0000, /* _ */
0x1008000000000000, /* ` */
0x3C023E463A0000, /* a */
0x40407C42625C0000, /* b */
0x1C20201C0000, /* c */
0x2023E42463A0000, /* d */
0x3C427E403C0000, /* e */
0x18103810100000, /* f */
0x344C44340438, /* g */
0x2020382424240000, /* h */
0x800080808080000, /* i */
0x800180808080870, /* j */
0x20202428302C0000, /* k */
0x1010101010180000, /* l */
0x665A42420000, /* m */
0x2E3222220000, /* n */
0x3C42423C0000, /* o */
0x5C62427C4040, /* p */
0x3A46423E0202, /* q */
0x2C3220200000, /* r */
0x1C201804380000, /* s */
0x103C1010180000, /* t */
0x2222261A0000, /* u */
0x424224180000, /* v */
0x81815A660000, /* w */
0x422418660000, /* x */
0x422214081060, /* y */
0x3C08103C0000, /* z */
0x1C103030101C0000, /* { */
0x808080808080800, /* | */
0x38080C0C08380000, /* } */
0x324C000000, /* ~ */
0x7E7E7E7E7E7E0000 /* DEL */
};
Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);
HomieNode homieNode("pixel", "commands");
uint8_t pixelR[NUMPIXELS];
uint8_t pixelG[NUMPIXELS];
uint8_t pixelB[NUMPIXELS];
//write to buffer, flip with showBuffer()
uint8_t pixelR_buffer[NUMPIXELS];
uint8_t pixelG_buffer[NUMPIXELS];
uint8_t pixelB_buffer[NUMPIXELS];
long lastMillis = 0;
long fpsdelay = 1000 / FPS;
int xyToPos(int x, int y) { //convert x y pixel position to matrix position
if (y % 2 == 0) {
return (y * 8 + x);
} else {
return (y * 8 + (7 - x));
}
}
int numToPos(int num) { //convert pixel number to actual 8x8 matrix position
int x = num % 8;
int y = num / 8;
return xyToPos(x, y);
}
int numToSpiralPos(int num) { // convert pixel number to actual 8x8 matrix position in a spiral
int findx = 7;
int findy = 0;
int stepsize = 7; // initial value (0..7)
int stepnumber = 0; // each "step" should be used twice
int count = -1;
int dir = 1; // direction: 0 = incX, 1=incY, 2=decX, 3=decY
if (num < 8) {
return num; // trivial
}
for (int i = 8; i <= num; i++)
{
count++;
if (count == stepsize) {
count = 0;
// Change direction
dir++;
stepnumber++;
if (stepnumber == 2) {
stepsize -= 1;
stepnumber = 0;
}
if (dir == 4) {
dir = 0;
}
}
switch (dir) {
case 0:
findx++;
break;
case 1:
findy++;
break;
case 2:
findx--;
break;
case 3:
findy--;
break;
}
}
return xyToPos(findx, findy);
}
uint32_t wheel(byte WheelPos) {
WheelPos = 255 - WheelPos;
if (WheelPos < 85) {
return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);
}
if (WheelPos < 170) {
WheelPos -= 85;
return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);
}
WheelPos -= 170;
return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
}
void led_fill(uint32_t c)
{
for (int i = 0; i < strip.numPixels(); i++) {
strip.setPixelColor(i, c);
}
strip.show();
}
void led_random()
{
for (int i = 0; i < strip.numPixels(); i++) {
strip.setPixelColor(i, wheel(random(0, 255)));
}
strip.show();
}
void showBuffer()
{
for (int i = 0; i < strip.numPixels(); i++) {
pixelR[i] = pixelR_buffer[i];
pixelG[i] = pixelG_buffer[i];
pixelB[i] = pixelB_buffer[i];
strip.setPixelColor(i, pixelR[i], pixelG[i], pixelB[i]);
}
strip.show();
}
uint8_t getAverage(uint8_t array[NUMPIXELS], uint8_t i, int x, int y)
{
uint16_t sum = 0;
uint8_t count = 0;
if (i >= 8) { //up
sum += array[i - 8];
count++;
}
if (i < (64 - 8)) { //down
sum += array[i + 8];
count++;
}
if (i >= 1) { //left
sum += array[i - 1];
count++;
}
if (i < (64 - 1)) { //right
sum += array[i + 1];
count++;
}
/*
if (i>=(8+1)){ //up left
sum+=array[i-8-1];
count++;
}
if (i<(64-8-1)){ //down left
sum+=array[i+8-1];
count++;
}
if (i>=(8-1)){ //up right
sum+=array[i-8+1];
count++;
}
if (i<(64-8+1)){ //down right
sum+=array[i+8+1];
count++;
}*/
return sum / count;
}
void led_smooth()
{
for (int i = 0; i < strip.numPixels(); i++) {
//uint8_t avgbrightness=pixelR_buffer[i]/3+pixelG_buffer[i]/3+pixelB_buffer[i]/3;
pixelR_buffer[i] = (smoothing / 100.0) * pixelR[i] + (1.0 - (smoothing / 100.0)) * getAverage(pixelR, i, 0, 0);
pixelG_buffer[i] = (smoothing / 100.0) * pixelG[i] + (1.0 - (smoothing / 100.0)) * getAverage(pixelG, i, 0, 0);
pixelB_buffer[i] = (smoothing / 100.0) * pixelB[i] + (1.0 - (smoothing / 100.0)) * getAverage(pixelB, i, 0, 0);
}
showBuffer();
}
void led_movingPoint()
{
uint32_t c = wheel(wheelPos);
wheelPosSlow += wheelSpeed;
wheelPos = (wheelPos + (wheelPosSlow / 10) ) % 255;
wheelPosSlow = wheelPosSlow % 16;
uint8_t r = (uint8_t)(c >> 16);
uint8_t g = (uint8_t)(c >> 8);
uint8_t b = (uint8_t)c;
movingPoint_x = movingPoint_x + 8 + random(-random(0, 1 + 1), random(0, 1 + 1) + 1);
movingPoint_y = movingPoint_y + 8 + random(-random(0, 1 + 1), random(0, 1 + 1) + 1);
if (movingPoint_x < 8) {
movingPoint_x = 8 - movingPoint_x;
} else if (movingPoint_x >= 16) {
movingPoint_x = 22 - movingPoint_x;
} else {
movingPoint_x -= 8;
}
if (movingPoint_y < 8) {
movingPoint_y = 8 - movingPoint_y;
} else if (movingPoint_y >= 16) {
movingPoint_y = 22 - movingPoint_y;
} else {
movingPoint_y -= 8;
}
uint8_t startx = movingPoint_x;
uint8_t starty = movingPoint_y;
for (int i = 0; i < strength; i++) {
movingPoint_x = startx + 8 + random(-random(0, 2 + 1), random(0, 2 + 1) + 1);
movingPoint_y = starty + 8 + random(-random(0, 2 + 1), random(0, 2 + 1) + 1);
if (movingPoint_x < 8) {
movingPoint_x = 8 - movingPoint_x;
} else if (movingPoint_x >= 16) {
movingPoint_x = 22 - movingPoint_x;
} else {
movingPoint_x -= 8;
}
if (movingPoint_y < 8) {
movingPoint_y = 8 - movingPoint_y;
} else if (movingPoint_y >= 16) {
movingPoint_y = 22 - movingPoint_y;
} else {
movingPoint_y -= 8;
}
if (pixelR[xyToPos(movingPoint_x, movingPoint_y)] < r) {
pixelR[xyToPos(movingPoint_x, movingPoint_y)]++;
} else if (pixelR[xyToPos(movingPoint_x, movingPoint_y)] > r) {
pixelR[xyToPos(movingPoint_x, movingPoint_y)]--;
}
if (pixelG[xyToPos(movingPoint_x, movingPoint_y)] < g) {
pixelG[xyToPos(movingPoint_x, movingPoint_y)]++;
} else if (pixelG[xyToPos(movingPoint_x, movingPoint_y)] > g) {
pixelG[xyToPos(movingPoint_x, movingPoint_y)]--;
}
if (pixelB[xyToPos(movingPoint_x, movingPoint_y)] < b) {
pixelB[xyToPos(movingPoint_x, movingPoint_y)]++;
} else if (pixelB[xyToPos(movingPoint_x, movingPoint_y)] > b) {
pixelB[xyToPos(movingPoint_x, movingPoint_y)]--;
}
}
//pixelR[xyToPos(movingPoint_x,movingPoint_y)]=0.5*pixelR[xyToPos(movingPoint_x,movingPoint_y)]+0.5*r;
//pixelG[xyToPos(movingPoint_x,movingPoint_y)]=0.5*pixelG[xyToPos(movingPoint_x,movingPoint_y)]+0.5*g;
//pixelB[xyToPos(movingPoint_x,movingPoint_y)]=0.5*pixelB[xyToPos(movingPoint_x,movingPoint_y)]+0.5*b;
movingPoint_x = startx;
movingPoint_y = starty;
}
void bufferClear()
{
for (int i = 0; i < strip.numPixels(); i++) {
pixelR_buffer[i] = 0;
pixelG_buffer[i] = 0;
pixelB_buffer[i] = 0;
}
}
void led_chase()
{
Index += 1;
if (Index > 255) {
Index = 1;
}
// for (int j=0; j < 256; j++) { // cycle all 256 colors in the wheel
for (int q = 0; q < 3; q++) {
for (uint16_t i = 0; i < strip.numPixels(); i = i + 3) {
strip.setPixelColor(i + q, wheel( (i + Index) % 255)); //turn every third pixel on
}
strip.show();
delay(49);
for (uint16_t i = 0; i < strip.numPixels(); i = i + 3) {
strip.setPixelColor(i + q, 0); //turn every third pixel off
}
}
}
void led_radar()
{
// "Sweep" in cirles...
// line(0,0,950*cos(radians(iAngle)),-950*sin(radians(iAngle)));
}
// Calculate 50% dimmed version of a color (used by led_larson())
uint32_t DimColor(uint32_t color)
{
// Shift R, G and B components one bit to the right
uint32_t Dimcolor = strip.Color(Red(color) >> 1, Green(color) >> 1, Blue(color) >> 1);
return Dimcolor;
}
// Returns the Red component of a 32-bit color
uint8_t Red(uint32_t color)
{
return (color >> 16) & 0xFF;
}
// Returns the Green component of a 32-bit color
uint8_t Green(uint32_t color)
{
return (color >> 8) & 0xFF;
}
// Returns the Blue component of a 32-bit color
uint8_t Blue(uint32_t color)
{
return color & 0xFF;
}
void Increment()
{
if (Direction == FORWARD)
{
Index++;
if (Index >= (strip.numPixels() - 1) * 2)
{
Index = 0;
}
}
else // Direction == REVERSE
{
--Index;
if (Index <= 0)
{
Index = (strip.numPixels() - 1) * 2 - 1;
}
}
}
void led_larson()
{
int EyeSize = 5;
uint32_t rgb[3] = {0};
wheelPos++;
if (wheelPos >= 256) {
wheelPos = 0;
}
int Color1 = wheel(wheelPos);
for (int i = 0; i < strip.numPixels(); i++)
{
int realpos = numToSpiralPos(i);
if (i == Index) // Scan Pixel to the right
{
strip.setPixelColor(realpos, Color1);
}
else if (i == ((strip.numPixels() - 1) * 2) - Index) // Scan Pixel to the left
{
strip.setPixelColor(realpos, Color1);
}
else // Fading tail
{
strip.setPixelColor(realpos, DimColor(strip.getPixelColor(realpos)));
}
}
strip.show();
Increment();
}
void led_spiral()
{
int every = 4;
wheelPos++;
int qp = Index % every;
Index++;
if (Index >= strip.numPixels()-1) {
Index = 0;
}
int q = Index % every;
for (uint16_t i = 0; i < strip.numPixels(); i = i + every) {
strip.setPixelColor(numToSpiralPos(i + q), wheel( (i + Index * 4) % 255)); //turn every "every" pixel on
}
for (uint16_t i = 0; i < strip.numPixels(); i = i + every) {
strip.setPixelColor(numToSpiralPos(i + qp), 0); //turn every "every" pixel off
}
strip.show();
}
void led_randomfade()
{
for (int i = 0; i < strip.numPixels(); i++) {
pixelR_buffer[i] += random(0, random(0, fadespeedmax + 1) + 1); //use buffer red channel for color wheel
strip.setPixelColor(i, wheel(pixelR_buffer[i]));
}
strip.show();
}
void led_icon(uint8_t fontchar, uint32_t iconcolor)
{
for (int i = 0; i < strip.numPixels(); i++) {
uint64_t mask = 1LL << (uint64_t)i;
if ( (font[fontchar]&mask) == 0) {
strip.setPixelColor(numToPos(i), strip.Color(0, 0, 0)); //bit is 0 at pos i
} else {
float _brightness = 1.0 - ( (iconCountStart - iconCountdown) * 1.0 / iconCountStart );
uint8_t _r = (uint8_t)(iconcolor >> 16);
uint8_t _g = (uint8_t)(iconcolor >> 8);
uint8_t _b = (uint8_t)iconcolor;
strip.setPixelColor(numToPos(i), strip.Color(_r * _brightness, _g * _brightness, _b * _brightness)); //bit is 1 at pos i
}
}
strip.show();
}
void set_randomBuffer()
{
for (int i = 0; i < strip.numPixels(); i++) {
uint32_t c = wheel(random(0, 256));
pixelR_buffer[i] = (uint8_t)(c >> 16);
pixelG_buffer[i] = (uint8_t)(c >> 8);
pixelB_buffer[i] = (uint8_t)c;
}
}
uint32_t parseColor(String value) {
if (value.charAt(0) == '#') { //solid fill
String color = value.substring(1);
int number = (int) strtol( &color[0], NULL, 16);
// Split them up into r, g, b values
int r = number >> 16;
int g = number >> 8 & 0xFF;
int b = number & 0xFF;
Homie.getLogger() << "r=" << r << " g=" << g << " b=" << b << endl;
//Serial.print("r=");Serial.print(r);
//Serial.print(" g=");Serial.print(g);
//Serial.print(" b=");Serial.println(b);
return strip.Color(r, g, b);
}
return 0;
}
bool effectHandler(const HomieRange& range, const String& value) {
Homie.getLogger() << "-> " << value << endl;
int sep = value.indexOf("|");
String command = value.substring(0, sep);
String parameters = value.substring(sep + 1);
Homie.getLogger() << "command=" << command << " parameters=" << parameters << endl;
if (command.equals("fill")) {
effect = EFFECT_NONE;
led_fill(parseColor(parameters));
} else if (command.equals("off")) {
effect = EFFECT_NONE;
led_fill(strip.Color(0, 0, 0));
} else if (command.equals("random")) {
effect = EFFECT_NONE;
led_random();
} else if (command.equals("set")) { //example: set|37#ff003a
effect = EFFECT_NONE;
int x = parameters.substring(0, 1).toInt();
int y = parameters.substring(1, 2).toInt();
String cstr = parameters.substring(2, 9);
strip.setPixelColor(xyToPos(x, y), parseColor(cstr));
strip.show();
} else if (command.equals("smooth")) { //example: smooth|[wheelspeed]|[smoothing]|[strength] wheelspeed=1-255, smoothing=0-100, strength=1-255
int sepparam = parameters.indexOf("|");
int p1 = parameters.substring(0, sepparam).toInt();
String parameters_part2 = parameters.substring(sepparam + 1);
sepparam = parameters_part2.indexOf("|");
int p2 = parameters_part2.substring(0, sepparam).toInt();
int p3 = parameters_part2.substring(sepparam + 1).toInt();
wheelSpeed = 16; //default, speed=+1 /frame
if (p1 > 0) {
wheelSpeed = p1;
}
smoothing = 80;
if (p2 > 0) {
smoothing = p2;
}
strength = 50;
if (p3 > 0) {
strength = p3;
}
Homie.getLogger() << "-- p1=" << p1 << " p2=" << p2 << " p3=" << p3 << endl;
effect = EFFECT_SMOOTH;
bufferClear();
showBuffer();
strip.show();
} else if (command.equals("spiral")) {
effect = EFFECT_SPIRAL;
Index = 0;
bufferClear();
showBuffer();
strip.show();
} else if (command.equals("clearbuffer")) {
bufferClear();
showBuffer();
strip.show();
} else if (command.equals("randomfade")) { //example: randomfade|5
int sepparam = parameters.indexOf("|");
int p1 = parameters.substring(0, sepparam).toInt();
fadespeedmax = 5;
if (p1 > 0) {
fadespeedmax = p1;
}
effect = EFFECT_RANDOMFADE;
set_randomBuffer(); //initialize random
} else if (command.equals("randombuffer")) {
set_randomBuffer(); //set random
showBuffer();
} else if (command.equals("chase")) {
effect = EFFECT_CHASE;
bufferClear();
showBuffer();
strip.show();
} else if (command.equals("radar")) {
effect = EFFECT_RADAR;
Index = 0;
bufferClear();
showBuffer();
strip.show();
} else if (command.equals("larson")) {
effect = EFFECT_LARSON;
Index = 0;
bufferClear();
showBuffer();
strip.show();
}
return true;
}
bool pixelsHandler(const HomieRange& range, const String& value) {
String remaining = value;
int i = 0;
effect = EFFECT_NONE;
do {
String current = remaining.substring(0, 7);
Homie.getLogger() << i << ":" << current << endl;
uint32_t currentcolor = parseColor(current);
strip.setPixelColor(i, currentcolor);
i++;
remaining = remaining.substring(7);
} while (remaining.length() > 2 && (i < strip.numPixels()));
Homie.getLogger() << " filling rest with black" << endl;
while (i < strip.numPixels()) {
strip.setPixelColor(numToPos(i), strip.Color(0, 0, 0));
i++;
}
strip.show();
return true;
}
bool iconHandler(const HomieRange& range, const String& value) {
String _iconname = value;
iconcolor = strip.Color(255, 255, 255); //default color
if (value[0] == '#') { //color given
iconcolor = parseColor(value.substring(0, 6));
_iconname = value.substring(7); // example: #ff00dc|A (pipe will be ignored)
}
iconCountStart = FPS * 2;
iconCountdown = iconCountStart;
if (_iconname.length() == 1) { //only one character
iconchar = value[0];
} else {
}
strip.show();
return true;
}
void setup() {
Serial.begin(115200);
Serial << endl << endl;
Serial << "Begin strip" << endl;
strip.begin();
strip.show(); // Initialize all pixels to 'off'
led_fill(strip.Color(100, 0, 0));
//delay(500);
Serial << "Homie_setFirmware" << endl;
Homie_setFirmware("pixelprojektor", "1.0.0");
Serial << "Homie node advertise" << endl;
homieNode.advertise("effect").settable(effectHandler);
homieNode.advertise("pixels").settable(pixelsHandler);
homieNode.advertise("icon").settable(iconHandler);
led_fill(strip.Color(0, 0, 0));
strip.setPixelColor(0, strip.Color(100, 0, 0));
strip.show();
Serial << "homie setup" << endl;
Homie.setup();
// Hostname defaults to esp8266-[ChipID]
ArduinoOTA.setHostname("pixelprojektor");
// No authentication by default
// ArduinoOTA.setPassword((const char *)"ctdo2342");
ArduinoOTA.onStart([]() {
Serial.println("Start");
led_fill(strip.Color(0, 0, 0)); // Clear
});
ArduinoOTA.onEnd([]() {
Serial.println("\nEnd");
});
ArduinoOTA.onProgress([](unsigned int progress, unsigned int total) {
strip.setPixelColor(numToPos((progress / (total / strip.numPixels()))), strip.Color(255, 255, 255));
strip.show();
Serial.printf("Progress: %u%%\r", (progress / (total / 100)));
});
ArduinoOTA.onError([](ota_error_t error) {
Serial.printf("Error[%u]: ", error);
if (error == OTA_AUTH_ERROR) Serial.println("Auth Failed");
else if (error == OTA_BEGIN_ERROR) Serial.println("Begin Failed");
else if (error == OTA_CONNECT_ERROR) Serial.println("Connect Failed");
else if (error == OTA_RECEIVE_ERROR) Serial.println("Receive Failed");
else if (error == OTA_END_ERROR) Serial.println("End Failed");
});
ArduinoOTA.begin();
// led_fill(strip.Color(0, 0, 0));
// Initialer Effekt
//effect = EFFECT_CHASE;
//effect = EFFECT_SPIRAL;
effect = EFFECT_LARSON;
Serial << "Setup finished" << endl;
}
void loop() {
Homie.loop();
ArduinoOTA.handle();
long currentMillis = millis();
if (lastMillis + fpsdelay < currentMillis) {
if (iconCountdown > 0) { //icon effect active
iconCountdown--;
led_icon(iconchar, iconcolor);
} else {
switch (effect) {
case EFFECT_SMOOTH:
led_movingPoint();
led_smooth();
break;
case EFFECT_SPIRAL:
led_spiral();
break;
case EFFECT_RANDOMFADE:
led_randomfade();
break;
case EFFECT_CHASE:
led_chase();
break;
case EFFECT_RADAR:
led_radar();
break;
case EFFECT_LARSON:
led_larson();
break;
}
}
lastMillis = currentMillis;
}
}
Reference in New Issue View Git Blame Copy Permalink