ManuelW/esp8266-nanoleaf-webserver
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Compare commits

base: ManuelW:truncated-icosaLEDron
Branches Tags
ManuelW:master ManuelW:v1.0-no-ir ManuelW:v1.1 ManuelW:v1.0 ManuelW:wifi-experiment ManuelW:truncated-icosaLEDron ManuelW:ultim8x8-cube ManuelW:tinytim-cube ManuelW:sunrise-clock ManuelW:ultim8x8
ManuelW:3.0 ManuelW:2.0 ManuelW:1.0
..
compare: ManuelW:sunrise-clock
Branches Tags
ManuelW:master ManuelW:v1.0-no-ir ManuelW:v1.1 ManuelW:v1.0 ManuelW:wifi-experiment ManuelW:truncated-icosaLEDron ManuelW:ultim8x8-cube ManuelW:tinytim-cube ManuelW:sunrise-clock ManuelW:ultim8x8
ManuelW:3.0 ManuelW:2.0 ManuelW:1.0

2 Commits
truncated- ... sunrise-cl

Author SHA1 Message Date
Jason Coon
bde51bc675 Added more sunrise patterns. 2017-07-19 17:20:51 -05:00
Jason Coon
72cc218fb8 Work on the sunrise clock. 2017-07-13 08:46:28 -05:00
4 changed files with 560 additions and 289 deletions
Expand all files Collapse all files

32
README.md
View File

@ -6,38 +6,14 @@ Control an addressable LED strip with an ESP8266 via a web browser or infrared r
Hardware Hardware
-------- --------
##### ESP8266 development board An ESP8266 development board, such as the [Adafruit HUZZAH ESP8266 Breakout]:
[![Wemos D1 Mini Pro & Headers](https://ae01.alicdn.com/kf/HTB1P1KVaMsSMeJjSsphq6xuJFXah/WEMOS-D1-mini-Pro-V1-1-0-16M-bytes-external-antenna-connector-ESP8266-WIFI-Internet-of.jpg_200x200.jpg)](https://www.aliexpress.com/item/WEMOS-D1-mini-Pro-16M-bytes-external-antenna-connector-ESP8266-WIFI-Internet-of-Things-development-board/32724692514.html)
[Wemos D1 Mini Pro & Headers](https://www.aliexpress.com/item/WEMOS-D1-mini-Pro-16M-bytes-external-antenna-connector-ESP8266-WIFI-Internet-of-Things-development-board/32724692514.html)
or
[![Adafruit HUZZAH ESP8266 Breakout](https://cdn-shop.adafruit.com/310x233/2471-10.jpg)](https://www.adafruit.com/products/2471) [![Adafruit HUZZAH ESP8266 Breakout](https://cdn-shop.adafruit.com/310x233/2471-10.jpg)](https://www.adafruit.com/products/2471)
[Adafruit HUZZAH ESP8266 Breakout](https://www.adafruit.com/products/2471) Addressable LED strip, such as the [Adafruit NeoPixel Ring]:
##### Addressable LED strip
[![Adafruit NeoPixel Ring](https://www.adafruit.com/images/145x109/1586-00.jpg)](https://www.adafruit.com/product/1586) [![Adafruit NeoPixel Ring](https://www.adafruit.com/images/145x109/1586-00.jpg)](https://www.adafruit.com/product/1586)
[Adafruit NeoPixel Ring]
Other hardware:
* [3.3V to 5V Logic Level Shifter](http://www.digikey.com/product-detail/en/texas-instruments/SN74HCT245N/296-1612-5-ND/277258) (required if LEDs "glitch")
Recommended by [Adafruit NeoPixel "Best Practices"](https://learn.adafruit.com/adafruit-neopixel-uberguide/best-practices) to help protect LEDs from current onrush:
* [1000µF Capacitor](http://www.digikey.com/product-detail/en/panasonic-electronic-components/ECA-1EM102/P5156-ND/245015)
* [300 to 500 Ohm resistor](https://www.digikey.com/product-detail/en/stackpole-electronics-inc/CF14JT470R/CF14JT470RCT-ND/1830342)
Optional shield to make everything more tidy:
[![Wemos D1 Mini ESP8266 LED & Level Shifter Shield](https://d3s5r33r268y59.cloudfront.net/13194/products/thumbs/2017-05-06T15:02:37.208Z-IMG_20170506_100623.jpg.114x76_q85_pad_rcrop.jpg)](https://www.tindie.com/products/jasoncoon/wemos-d1-mini-esp8266-led-and-level-shifter-shield/)
[Wemos D1 Mini ESP8266 LED & Level Shifter Shield](https://www.tindie.com/products/jasoncoon/wemos-d1-mini-esp8266-led-and-level-shifter-shield)
Features Features
-------- --------
* Turn the NeoPixel Ring on and off * Turn the NeoPixel Ring on and off
@ -65,7 +41,7 @@ The app is installed via the Arduino IDE which can be [downloaded here](https://
The app depends on the following libraries. They must either be downloaded from GitHub and placed in the Arduino 'libraries' folder, or installed as [described here](https://www.arduino.cc/en/Guide/Libraries) by using the Arduino library manager. The app depends on the following libraries. They must either be downloaded from GitHub and placed in the Arduino 'libraries' folder, or installed as [described here](https://www.arduino.cc/en/Guide/Libraries) by using the Arduino library manager.
* [FastLED](https://github.com/FastLED/FastLED) * [FastLED](https://github.com/FastLED/FastLED)
* [IRremoteESP8266](https://github.com/sebastienwarin/IRremoteESP8266) * [IRremoteESP8266](https://github.com/markszabo/IRremoteESP8266)
* [Arduino WebSockets](https://github.com/Links2004/arduinoWebSockets) * [Arduino WebSockets](https://github.com/Links2004/arduinoWebSockets)
Download the app code from GitHub using the green Clone or Download button from [the GitHub project main page](https://github.com/jasoncoon/esp8266-fastled-webserver) and click Download ZIP. Decompress the ZIP file in your Arduino sketch folder. Download the app code from GitHub using the green Clone or Download button from [the GitHub project main page](https://github.com/jasoncoon/esp8266-fastled-webserver) and click Download ZIP. Decompress the ZIP file in your Arduino sketch folder.
@ -95,7 +71,7 @@ The firmware implements basic [RESTful web services](https://en.wikipedia.org/wi
Infrared Remote Control Infrared Remote Control
----------------------- -----------------------
Control via infrared remote control is also supported, via the [ESP8266 port of the IRremote library](https://github.com/sebastienwarin/IRremoteESP8266). Control via infrared remote control is also supported, via the [ESP8266 port of the IRremote library](https://github.com/markszabo/IRremoteESP8266).
[Adafruit NeoPixel Ring]:https://www.adafruit.com/product/1586 [Adafruit NeoPixel Ring]:https://www.adafruit.com/product/1586
[Adafruit HUZZAH ESP8266 Breakout]:https://www.adafruit.com/products/2471 [Adafruit HUZZAH ESP8266 Breakout]:https://www.adafruit.com/products/2471

65
Text.h Normal file
View File

@ -0,0 +1,65 @@
bool mask[NUM_LEDS];
const byte digits4x8[8 * 10] = {
0x06, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x06, // 0
0x04, 0x06, 0x04, 0x04, 0x04, 0x04, 0x04, 0x0e, // 1
0x06, 0x09, 0x08, 0x08, 0x04, 0x02, 0x01, 0x0f, // 2
0x06, 0x09, 0x08, 0x04, 0x08, 0x08, 0x09, 0x06, // 3
0x04, 0x05, 0x05, 0x05, 0x0f, 0x04, 0x04, 0x04, // 4
0x0f, 0x01, 0x01, 0x07, 0x08, 0x08, 0x09, 0x06, // 5
0x06, 0x09, 0x01, 0x07, 0x09, 0x09, 0x09, 0x06, // 6
0x0f, 0x08, 0x08, 0x04, 0x02, 0x01, 0x01, 0x01, // 7
0x06, 0x09, 0x09, 0x06, 0x09, 0x09, 0x09, 0x06, // 8
0x06, 0x09, 0x09, 0x09, 0x0e, 0x08, 0x09, 0x06, // 9
};
// preceed with a call to fillMask(false);
// set mask to true where digit should light
void digit(byte start, byte d) {
byte row, col;
for (col = 0; col < 4; col++) {
for (row = 0; row < 8; row++) {
if ((digits4x8[d * 8 + row] >> col) & 1) {
togglePixelMask(row, col + start, true);
}
else {
}
}
}
}
void displayNum(uint32_t n) {
digit( 0, (n / 10000) % 10);
digit( 5, (n / 1000) % 10);
digit(10, (n / 100) % 10);
digit(15, (n / 10) % 10);
digit(20, (n / 1) % 10);
}
void displayTime(uint32_t tm) {
uint8_t hh = (tm / 3600) % 12;
uint8_t mm = (tm / 60) % 60;
uint8_t ss = (tm) % 60;
if (hh > 9) {
digit( 1, hh / 10);
}
digit( 6, hh % 10);
setPixelMask(2, 11, true);
setPixelMask(3, 11, true);
setPixelMask(5, 11, true);
setPixelMask(6, 11, true);
digit(13, mm / 10);
digit(18, mm % 10);
if (hh > 9) {
digit( 1 + 24, hh / 10);
}
digit( 6 + 24, hh % 10);
setPixelMask(2, 11 + 24, true);
setPixelMask(3, 11 + 24, true);
setPixelMask(5, 11 + 24, true);
setPixelMask(6, 11 + 24, true);
digit(13 + 24, mm / 10);
digit(18 + 24, mm % 10);
}

557
esp8266-fastled-webserver.ino
View File

@ -1,23 +1,20 @@
/* /*
* ESP8266 + FastLED + IR Remote: https://github.com/jasoncoon/esp8266-fastled-webserver ESP8266 + FastLED + IR Remote: https://github.com/jasoncoon/esp8266-fastled-webserver
* Copyright (C) 2015-2016 Jason Coon Copyright (C) 2015-2016 Jason Coon
*
* 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/>.
*/
#define FASTLED_ALLOW_INTERRUPTS 0 This program is free software: you can redistribute it and/or modify
//#define FASTLED_INTERRUPT_RETRY_COUNT 1 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/>.
*/
#include <FastLED.h> #include <FastLED.h>
FASTLED_USING_NAMESPACE FASTLED_USING_NAMESPACE
@ -27,13 +24,13 @@ extern "C" {
} }
#include <ESP8266WiFi.h> #include <ESP8266WiFi.h>
//#include <ESP8266mDNS.h> #include <ESP8266mDNS.h>
#include <ESP8266WebServer.h> #include <ESP8266WebServer.h>
#include <ESP8266HTTPUpdateServer.h> #include <ESP8266HTTPUpdateServer.h>
#include <WebSocketsServer.h> #include <WebSocketsServer.h>
#include <FS.h> #include <FS.h>
#include <EEPROM.h> #include <EEPROM.h>
//#include <IRremoteESP8266.h> #include <IRremoteESP8266.h>
#include "GradientPalettes.h" #include "GradientPalettes.h"
#define ARRAY_SIZE(A) (sizeof(A) / sizeof((A)[0])) #define ARRAY_SIZE(A) (sizeof(A) / sizeof((A)[0]))
@ -42,10 +39,10 @@ extern "C" {
#define HOSTNAME "ESP8266-" ///< Hostname. The setup function adds the Chip ID at the end. #define HOSTNAME "ESP8266-" ///< Hostname. The setup function adds the Chip ID at the end.
//#define RECV_PIN D4 #define RECV_PIN 1
//IRrecv irReceiver(RECV_PIN); IRrecv irReceiver(RECV_PIN);
//#include "Commands.h" #include "Commands.h"
const bool apMode = false; const bool apMode = false;
@ -62,12 +59,15 @@ ESP8266HTTPUpdateServer httpUpdateServer;
#include "FSBrowser.h" #include "FSBrowser.h"
#define DATA_PIN D5 #define DATA_PIN MOSI
#define LED_TYPE WS2811 #define CLK_PIN SCK
#define COLOR_ORDER RGB #define LED_TYPE APA102
#define NUM_LEDS 32 #define COLOR_ORDER BGR
#define MatrixWidth 8 * 3
#define MatrixHeight 8
#define NUM_LEDS MatrixWidth * MatrixHeight
#define MILLI_AMPS 2000 // IMPORTANT: set the max milli-Amps of your power supply (4A = 4000mA) #define MILLI_AMPS 500 // IMPORTANT: set the max milli-Amps of your power supply (4A = 4000mA)
#define FRAMES_PER_SECOND 120 // here you can control the speed. With the Access Point / Web Server the animations run a bit slower. #define FRAMES_PER_SECOND 120 // here you can control the speed. With the Access Point / Web Server the animations run a bit slower.
CRGB leds[NUM_LEDS]; CRGB leds[NUM_LEDS];
@ -109,6 +109,8 @@ CRGBPalette16 IceColors_p = CRGBPalette16(CRGB::Black, CRGB::Blue, CRGB::Aqua, C
uint8_t currentPatternIndex = 0; // Index number of which pattern is current uint8_t currentPatternIndex = 0; // Index number of which pattern is current
uint8_t autoplay = 0; uint8_t autoplay = 0;
bool resetPattern = true;
uint8_t autoplayDuration = 10; uint8_t autoplayDuration = 10;
unsigned long autoPlayTimeout = 0; unsigned long autoPlayTimeout = 0;
@ -126,6 +128,30 @@ void dimAll(byte value)
} }
} }
const bool MatrixSerpentineLayout = true;
uint16_t XY(uint8_t x, uint8_t y)
{
uint16_t i;
if ( MatrixSerpentineLayout == false) {
i = (y * MatrixWidth) + x;
}
if ( MatrixSerpentineLayout == true) {
if ( x & 0x01) {
// Odd columns run backwards
uint8_t reverseY = (MatrixHeight - 1) - y;
i = (x * MatrixHeight) + reverseY;
} else {
// Even rows run forwards
i = (x * MatrixHeight) + y;
}
}
return i;
}
typedef void (*Pattern)(); typedef void (*Pattern)();
typedef Pattern PatternList[]; typedef Pattern PatternList[];
typedef struct { typedef struct {
@ -136,10 +162,17 @@ typedef PatternAndName PatternAndNameList[];
#include "Twinkles.h" #include "Twinkles.h"
#include "TwinkleFOX.h" #include "TwinkleFOX.h"
#include "Sunrise.h"
// List of patterns to cycle through. Each is defined as a separate function below. // List of patterns to cycle through. Each is defined as a separate function below.
PatternAndNameList patterns = { PatternAndNameList patterns = {
{ sunriseStatic, "Sunrise Static" },
{ sunriseFlicker, "Sunrise Flicker" },
{ sunriseWavesVertical, "Sunrise Waves Vertical" },
{ sunriseWavesHorizontal, "Sunrise Waves Horizontal" },
{ sunriseWavesDiagonal, "Sunrise Waves Diagonal" },
{ sunriseWavesRotating, "Sunrise Waves Rotating" },
{ pride, "Pride" }, { pride, "Pride" },
{ colorWaves, "Color Waves" }, { colorWaves, "Color Waves" },
@ -182,8 +215,8 @@ const uint8_t patternCount = ARRAY_SIZE(patterns);
typedef struct { typedef struct {
CRGBPalette16 palette; CRGBPalette16 palette;
String name; String name;
} PaletteAndName; } PaletteAndName;
typedef PaletteAndName PaletteAndNameList[]; typedef PaletteAndName PaletteAndNameList[];
const CRGBPalette16 palettes[] = { const CRGBPalette16 palettes[] = {
@ -205,10 +238,10 @@ const String paletteNames[paletteCount] = {
"Cloud", "Cloud",
"Lava", "Lava",
"Ocean", "Ocean",
"Forest", "Forest",
"Party", "Party",
"Heat", "Heat",
}; };
#include "Fields.h" #include "Fields.h"
@ -217,8 +250,8 @@ void setup() {
delay(100); delay(100);
Serial.setDebugOutput(true); Serial.setDebugOutput(true);
FastLED.addLeds<LED_TYPE, DATA_PIN, COLOR_ORDER>(leds, NUM_LEDS); // for WS2812 (Neopixel) // FastLED.addLeds<LED_TYPE, DATA_PIN, COLOR_ORDER>(leds, NUM_LEDS); // for WS2812 (Neopixel)
//FastLED.addLeds<LED_TYPE,DATA_PIN,CLK_PIN,COLOR_ORDER>(leds, NUM_LEDS); // for APA102 (Dotstar) FastLED.addLeds<LED_TYPE, DATA_PIN, CLK_PIN, COLOR_ORDER>(leds, NUM_LEDS); // for APA102 (Dotstar)
FastLED.setDither(false); FastLED.setDither(false);
FastLED.setCorrection(TypicalLEDStrip); FastLED.setCorrection(TypicalLEDStrip);
FastLED.setBrightness(brightness); FastLED.setBrightness(brightness);
@ -231,7 +264,7 @@ void setup() {
FastLED.setBrightness(brightness); FastLED.setBrightness(brightness);
// irReceiver.enableIRIn(); // Start the receiver irReceiver.enableIRIn(); // Start the receiver
Serial.println(); Serial.println();
Serial.print( F("Heap: ") ); Serial.println(system_get_free_heap_size()); Serial.print( F("Heap: ") ); Serial.println(system_get_free_heap_size());
@ -266,10 +299,10 @@ void setup() {
for (uint8_t i = 0; i < hostname.length(); i++) for (uint8_t i = 0; i < hostname.length(); i++)
hostnameChar[i] = hostname.charAt(i); hostnameChar[i] = hostname.charAt(i);
// MDNS.begin(hostnameChar); MDNS.begin(hostnameChar);
//
// // Add service to MDNS-SD // Add service to MDNS-SD
// MDNS.addService("http", "tcp", 80); MDNS.addService("http", "tcp", 80);
// Print hostname. // Print hostname.
Serial.println("Hostname: " + hostname); Serial.println("Hostname: " + hostname);
@ -305,7 +338,7 @@ void setup() {
if (String(WiFi.SSID()) != String(ssid)) { if (String(WiFi.SSID()) != String(ssid)) {
WiFi.begin(ssid, password); WiFi.begin(ssid, password);
} }
} }
httpUpdateServer.setup(&webServer); httpUpdateServer.setup(&webServer);
@ -357,7 +390,7 @@ void setup() {
webServer.on("/twinkleSpeed", HTTP_POST, []() { webServer.on("/twinkleSpeed", HTTP_POST, []() {
String value = webServer.arg("value"); String value = webServer.arg("value");
twinkleSpeed = value.toInt(); twinkleSpeed = value.toInt();
if(twinkleSpeed < 0) twinkleSpeed = 0; if (twinkleSpeed < 0) twinkleSpeed = 0;
else if (twinkleSpeed > 8) twinkleSpeed = 8; else if (twinkleSpeed > 8) twinkleSpeed = 8;
broadcastInt("twinkleSpeed", twinkleSpeed); broadcastInt("twinkleSpeed", twinkleSpeed);
sendInt(twinkleSpeed); sendInt(twinkleSpeed);
@ -366,7 +399,7 @@ void setup() {
webServer.on("/twinkleDensity", HTTP_POST, []() { webServer.on("/twinkleDensity", HTTP_POST, []() {
String value = webServer.arg("value"); String value = webServer.arg("value");
twinkleDensity = value.toInt(); twinkleDensity = value.toInt();
if(twinkleDensity < 0) twinkleDensity = 0; if (twinkleDensity < 0) twinkleDensity = 0;
else if (twinkleDensity > 8) twinkleDensity = 8; else if (twinkleDensity > 8) twinkleDensity = 8;
broadcastInt("twinkleDensity", twinkleDensity); broadcastInt("twinkleDensity", twinkleDensity);
sendInt(twinkleDensity); sendInt(twinkleDensity);
@ -479,7 +512,7 @@ void loop() {
webSocketsServer.loop(); webSocketsServer.loop();
webServer.handleClient(); webServer.handleClient();
// handleIrInput(); handleIrInput();
if (power == 0) { if (power == 0) {
fill_solid(leds, NUM_LEDS, CRGB::Black); fill_solid(leds, NUM_LEDS, CRGB::Black);
@ -514,6 +547,8 @@ void loop() {
FastLED.show(); FastLED.show();
resetPattern = false;
// insert a delay to keep the framerate modest // insert a delay to keep the framerate modest
// FastLED.delay(1000 / FRAMES_PER_SECOND); // FastLED.delay(1000 / FRAMES_PER_SECOND);
} }
@ -554,213 +589,213 @@ void webSocketEvent(uint8_t num, WStype_t type, uint8_t * payload, size_t length
break; break;
} }
} }
//
//void handleIrInput() void handleIrInput()
//{ {
// InputCommand command = readCommand(); InputCommand command = readCommand();
//
// if (command != InputCommand::None) { if (command != InputCommand::None) {
// Serial.print("command: "); Serial.print("command: ");
// Serial.println((int) command); Serial.println((int) command);
// } }
//
// switch (command) { switch (command) {
// case InputCommand::Up: { case InputCommand::Up: {
// adjustPattern(true); adjustPattern(true);
// break; break;
// } }
// case InputCommand::Down: { case InputCommand::Down: {
// adjustPattern(false); adjustPattern(false);
// break; break;
// } }
// case InputCommand::Power: { case InputCommand::Power: {
// setPower(power == 0 ? 1 : 0); setPower(power == 0 ? 1 : 0);
// break; break;
// } }
// case InputCommand::BrightnessUp: { case InputCommand::BrightnessUp: {
// adjustBrightness(true); adjustBrightness(true);
// break; break;
// } }
// case InputCommand::BrightnessDown: { case InputCommand::BrightnessDown: {
// adjustBrightness(false); adjustBrightness(false);
// break; break;
// } }
// case InputCommand::PlayMode: { // toggle pause/play case InputCommand::PlayMode: { // toggle pause/play
// setAutoplay(!autoplay); setAutoplay(!autoplay);
// break; break;
// } }
//
// // pattern buttons // pattern buttons
//
// case InputCommand::Pattern1: { case InputCommand::Pattern1: {
// setPattern(0); setPattern(0);
// break; break;
// } }
// case InputCommand::Pattern2: { case InputCommand::Pattern2: {
// setPattern(1); setPattern(1);
// break; break;
// } }
// case InputCommand::Pattern3: { case InputCommand::Pattern3: {
// setPattern(2); setPattern(2);
// break; break;
// } }
// case InputCommand::Pattern4: { case InputCommand::Pattern4: {
// setPattern(3); setPattern(3);
// break; break;
// } }
// case InputCommand::Pattern5: { case InputCommand::Pattern5: {
// setPattern(4); setPattern(4);
// break; break;
// } }
// case InputCommand::Pattern6: { case InputCommand::Pattern6: {
// setPattern(5); setPattern(5);
// break; break;
// } }
// case InputCommand::Pattern7: { case InputCommand::Pattern7: {
// setPattern(6); setPattern(6);
// break; break;
// } }
// case InputCommand::Pattern8: { case InputCommand::Pattern8: {
// setPattern(7); setPattern(7);
// break; break;
// } }
// case InputCommand::Pattern9: { case InputCommand::Pattern9: {
// setPattern(8); setPattern(8);
// break; break;
// } }
// case InputCommand::Pattern10: { case InputCommand::Pattern10: {
// setPattern(9); setPattern(9);
// break; break;
// } }
// case InputCommand::Pattern11: { case InputCommand::Pattern11: {
// setPattern(10); setPattern(10);
// break; break;
// } }
// case InputCommand::Pattern12: { case InputCommand::Pattern12: {
// setPattern(11); setPattern(11);
// break; break;
// } }
//
// // custom color adjustment buttons // custom color adjustment buttons
//
// case InputCommand::RedUp: { case InputCommand::RedUp: {
// solidColor.red += 8; solidColor.red += 8;
// setSolidColor(solidColor); setSolidColor(solidColor);
// break; break;
// } }
// case InputCommand::RedDown: { case InputCommand::RedDown: {
// solidColor.red -= 8; solidColor.red -= 8;
// setSolidColor(solidColor); setSolidColor(solidColor);
// break; break;
// } }
// case InputCommand::GreenUp: { case InputCommand::GreenUp: {
// solidColor.green += 8; solidColor.green += 8;
// setSolidColor(solidColor); setSolidColor(solidColor);
// break; break;
// } }
// case InputCommand::GreenDown: { case InputCommand::GreenDown: {
// solidColor.green -= 8; solidColor.green -= 8;
// setSolidColor(solidColor); setSolidColor(solidColor);
// break; break;
// } }
// case InputCommand::BlueUp: { case InputCommand::BlueUp: {
// solidColor.blue += 8; solidColor.blue += 8;
// setSolidColor(solidColor); setSolidColor(solidColor);
// break; break;
// } }
// case InputCommand::BlueDown: { case InputCommand::BlueDown: {
// solidColor.blue -= 8; solidColor.blue -= 8;
// setSolidColor(solidColor); setSolidColor(solidColor);
// break; break;
// } }
//
// // color buttons // color buttons
//
// case InputCommand::Red: { case InputCommand::Red: {
// setSolidColor(CRGB::Red); setSolidColor(CRGB::Red);
// break; break;
// } }
// case InputCommand::RedOrange: { case InputCommand::RedOrange: {
// setSolidColor(CRGB::OrangeRed); setSolidColor(CRGB::OrangeRed);
// break; break;
// } }
// case InputCommand::Orange: { case InputCommand::Orange: {
// setSolidColor(CRGB::Orange); setSolidColor(CRGB::Orange);
// break; break;
// } }
// case InputCommand::YellowOrange: { case InputCommand::YellowOrange: {
// setSolidColor(CRGB::Goldenrod); setSolidColor(CRGB::Goldenrod);
// break; break;
// } }
// case InputCommand::Yellow: { case InputCommand::Yellow: {
// setSolidColor(CRGB::Yellow); setSolidColor(CRGB::Yellow);
// break; break;
// } }
//
// case InputCommand::Green: { case InputCommand::Green: {
// setSolidColor(CRGB::Green); setSolidColor(CRGB::Green);
// break; break;
// } }
// case InputCommand::Lime: { case InputCommand::Lime: {
// setSolidColor(CRGB::Lime); setSolidColor(CRGB::Lime);
// break; break;
// } }
// case InputCommand::Aqua: { case InputCommand::Aqua: {
// setSolidColor(CRGB::Aqua); setSolidColor(CRGB::Aqua);
// break; break;
// } }
// case InputCommand::Teal: { case InputCommand::Teal: {
// setSolidColor(CRGB::Teal); setSolidColor(CRGB::Teal);
// break; break;
// } }
// case InputCommand::Navy: { case InputCommand::Navy: {
// setSolidColor(CRGB::Navy); setSolidColor(CRGB::Navy);
// break; break;
// } }
//
// case InputCommand::Blue: { case InputCommand::Blue: {
// setSolidColor(CRGB::Blue); setSolidColor(CRGB::Blue);
// break; break;
// } }
// case InputCommand::RoyalBlue: { case InputCommand::RoyalBlue: {
// setSolidColor(CRGB::RoyalBlue); setSolidColor(CRGB::RoyalBlue);
// break; break;
// } }
// case InputCommand::Purple: { case InputCommand::Purple: {
// setSolidColor(CRGB::Purple); setSolidColor(CRGB::Purple);
// break; break;
// } }
// case InputCommand::Indigo: { case InputCommand::Indigo: {
// setSolidColor(CRGB::Indigo); setSolidColor(CRGB::Indigo);
// break; break;
// } }
// case InputCommand::Magenta: { case InputCommand::Magenta: {
// setSolidColor(CRGB::Magenta); setSolidColor(CRGB::Magenta);
// break; break;
// } }
//
// case InputCommand::White: { case InputCommand::White: {
// setSolidColor(CRGB::White); setSolidColor(CRGB::White);
// break; break;
// } }
// case InputCommand::Pink: { case InputCommand::Pink: {
// setSolidColor(CRGB::Pink); setSolidColor(CRGB::Pink);
// break; break;
// } }
// case InputCommand::LightPink: { case InputCommand::LightPink: {
// setSolidColor(CRGB::LightPink); setSolidColor(CRGB::LightPink);
// break; break;
// } }
// case InputCommand::BabyBlue: { case InputCommand::BabyBlue: {
// setSolidColor(CRGB::CornflowerBlue); setSolidColor(CRGB::CornflowerBlue);
// break; break;
// } }
// case InputCommand::LightBlue: { case InputCommand::LightBlue: {
// setSolidColor(CRGB::LightBlue); setSolidColor(CRGB::LightBlue);
// break; break;
// } }
// } }
//} }
void loadSettings() void loadSettings()
{ {
@ -807,7 +842,7 @@ void setPower(uint8_t value)
} }
void setAutoplay(uint8_t value) void setAutoplay(uint8_t value)
{ {
autoplay = value == 0 ? 0 : 1; autoplay = value == 0 ? 0 : 1;
EEPROM.write(6, autoplay); EEPROM.write(6, autoplay);
@ -882,12 +917,14 @@ void setPattern(uint8_t value)
} }
broadcastInt("pattern", currentPatternIndex); broadcastInt("pattern", currentPatternIndex);
resetPattern = true;
} }
void setPatternName(String name) void setPatternName(String name)
{ {
for(uint8_t i = 0; i < patternCount; i++) { for (uint8_t i = 0; i < patternCount; i++) {
if(patterns[i].name == name) { if (patterns[i].name == name) {
setPattern(i); setPattern(i);
break; break;
} }
@ -909,8 +946,8 @@ void setPalette(uint8_t value)
void setPaletteName(String name) void setPaletteName(String name)
{ {
for(uint8_t i = 0; i < paletteCount; i++) { for (uint8_t i = 0; i < paletteCount; i++) {
if(paletteNames[i] == name) { if (paletteNames[i] == name) {
setPalette(i); setPalette(i);
break; break;
} }
@ -1004,13 +1041,13 @@ void sinelon()
{ {
// a colored dot sweeping back and forth, with fading trails // a colored dot sweeping back and forth, with fading trails
fadeToBlackBy( leds, NUM_LEDS, 20); fadeToBlackBy( leds, NUM_LEDS, 20);
int pos = beatsin16(speed, 0, NUM_LEDS - 1); int pos = beatsin16(speed, 0, NUM_LEDS);
static int prevpos = 0; static int prevpos = 0;
CRGB color = ColorFromPalette(palettes[currentPaletteIndex], gHue, 255); CRGB color = ColorFromPalette(palettes[currentPaletteIndex], gHue, 255);
if( pos < prevpos ) { if ( pos < prevpos ) {
fill_solid( leds+pos, (prevpos-pos)+1, color); fill_solid( leds + pos, (prevpos - pos) + 1, color);
} else { } else {
fill_solid( leds+prevpos, (pos-prevpos)+1, color); fill_solid( leds + prevpos, (pos - prevpos) + 1, color);
} }
prevpos = pos; prevpos = pos;
} }

193
sunrise.h Normal file
View File

@ -0,0 +1,193 @@
const uint16_t sunriseSeconds = 60; // how long should the "sun" take to rise from completely dark to completely lit
const uint16_t sunriseMillis = (sunriseSeconds * 1000);
const uint16_t sunriseInterval = sunriseMillis / 240; // when using palettes, the usable range is 0-240 before it starts wrapping from the last color to the first
uint8_t sunriseIncrement = 4; // how much to change brightness for each level of the matrix
uint8_t sunriseLevel;
const CRGBPalette16 sunrisePalette = HeatColors_p;
const uint8_t centerX = MatrixWidth / 2;
void updateSunrise() {
EVERY_N_MILLIS(sunriseInterval) {
if (sunriseLevel < 240) {
sunriseLevel++;
Serial.print("Current level: "); Serial.println(sunriseLevel);
}
else if (sunriseIncrement > 0) {
sunriseIncrement--;
}
}
if (resetPattern) {
sunriseLevel = 0;
sunriseIncrement = 4;
FastLED.clear();
}
}
void sunriseStatic() {
updateSunrise();
for (uint8_t x = 0; x < MatrixWidth; x++) {
int16_t d = sunriseLevel - sunriseIncrement;
for (uint8_t y = 0; y < MatrixHeight; y++) {
if (d >= 0) {
CRGB newcolor = ColorFromPalette(sunrisePalette, random(0, d), random8(d, 255));
uint16_t pixelnumber = XY(x, y);
nblend(leds[pixelnumber], newcolor, 64);
}
d -= sunriseIncrement;
}
}
}
void sunriseFlicker() {
dimAll(240);
updateSunrise();
for (uint8_t x = 0; x < MatrixWidth; x++) {
int16_t d = sunriseLevel - sunriseIncrement;
for (uint8_t y = 0; y < MatrixHeight; y++) {
if (d >= 0) {
CRGB newcolor = ColorFromPalette(sunrisePalette, random(0, d), random8(d, 255));
uint16_t pixelnumber = XY(x, y);
nblend(leds[pixelnumber], newcolor, 64);
}
d -= sunriseIncrement;
}
}
}
void sunriseWavesDiagonal() {
dimAll(240);
updateSunrise();
uint8_t t = beat8(60);
for (uint8_t x = 0; x < MatrixWidth; x++) {
for (uint8_t y = 0; y < MatrixHeight; y++) {
uint8_t cx = sin8(x);
uint8_t cy = cos8(y);
uint8_t bri8 = sin8(8 * (cx + cy) + t);
CRGB newcolor = ColorFromPalette(sunrisePalette, sunriseLevel, bri8);
uint16_t pixelnumber = XY(x, y);
pixelnumber = (NUM_LEDS - 1) - pixelnumber;
nblend(leds[pixelnumber], newcolor, 64);
}
}
}
void sunriseWavesVertical() {
updateSunrise();
static uint16_t sPseudotime = 0;
static uint16_t sLastMillis = 0;
uint8_t brightdepth = beatsin88( 341, 96, 224);
uint16_t brightnessthetainc16 = beatsin88( 203, (25 * 256), (40 * 256));
uint8_t msmultiplier = beatsin88(147, 23, 60);
uint16_t ms = millis();
uint16_t deltams = ms - sLastMillis ;
sLastMillis = ms;
sPseudotime += deltams * msmultiplier;
uint16_t brightnesstheta16 = sPseudotime;
for (uint8_t y = 0; y < MatrixHeight; y++) {
brightnesstheta16 += brightnessthetainc16;
uint16_t b16 = sin16( brightnesstheta16 ) + 32768;
uint16_t bri16 = (uint32_t)((uint32_t)b16 * (uint32_t)b16) / 65536;
uint8_t bri8 = (uint32_t)(((uint32_t)bri16) * brightdepth) / 65536;
bri8 += (255 - brightdepth);
for (uint8_t x = 0; x < MatrixWidth; x++) {
CRGB newcolor = ColorFromPalette(sunrisePalette, sunriseLevel, bri8);
uint16_t pixelnumber = XY(x, (MatrixHeight - 1) - y);
pixelnumber = (NUM_LEDS - 1) - pixelnumber;
nblend(leds[pixelnumber], newcolor, 64);
}
}
}
void sunriseWavesHorizontal() {
updateSunrise();
static uint16_t sPseudotime = 0;
static uint16_t sLastMillis = 0;
uint8_t brightdepth = beatsin88( 341, 96, 224);
uint16_t brightnessthetainc16 = beatsin88( 203, (25 * 256), (40 * 256));
uint8_t msmultiplier = beatsin88(147, 23, 60);
uint16_t ms = millis();
uint16_t deltams = ms - sLastMillis ;
sLastMillis = ms;
sPseudotime += deltams * msmultiplier;
uint16_t brightnesstheta16 = sPseudotime;
for (uint8_t x = 0; x < MatrixWidth; x++) {
brightnesstheta16 += brightnessthetainc16;
uint16_t b16 = sin16( brightnesstheta16 ) + 32768;
uint16_t bri16 = (uint32_t)((uint32_t)b16 * (uint32_t)b16) / 65536;
uint8_t bri8 = (uint32_t)(((uint32_t)bri16) * brightdepth) / 65536;
bri8 += (255 - brightdepth);
for (uint8_t y = 0; y < MatrixHeight; y++) {
CRGB newcolor = ColorFromPalette(sunrisePalette, sunriseLevel, bri8);
uint16_t pixelnumber = XY(x, y);
pixelnumber = (NUM_LEDS - 1) - pixelnumber;
nblend(leds[pixelnumber], newcolor, 64);
}
}
}
void sunriseWavesRotating() {
updateSunrise();
static uint16_t sPseudotime = 0;
static uint16_t sLastMillis = 0;
uint8_t brightdepth = beatsin88( 341, 96, 224);
uint16_t brightnessthetainc16 = beatsin88( 203, (25 * 256), (40 * 256));
uint8_t msmultiplier = beatsin88(147, 23, 60);
uint16_t ms = millis();
uint16_t deltams = ms - sLastMillis ;
sLastMillis = ms;
sPseudotime += deltams * msmultiplier;
uint16_t brightnesstheta16 = sPseudotime;
for (uint8_t x = 0; x < MatrixWidth; x++) {
for (uint8_t y = 0; y < MatrixHeight; y++) {
brightnesstheta16 += brightnessthetainc16;
uint16_t b16 = sin16( brightnesstheta16 ) + 32768;
uint16_t bri16 = (uint32_t)((uint32_t)b16 * (uint32_t)b16) / 65536;
uint8_t bri8 = (uint32_t)(((uint32_t)bri16) * brightdepth) / 65536;
bri8 += (255 - brightdepth);
CRGB newcolor = ColorFromPalette(sunrisePalette, sunriseLevel, bri8);
uint16_t pixelnumber = XY(x, y);
pixelnumber = (NUM_LEDS - 1) - pixelnumber;
nblend(leds[pixelnumber], newcolor, 64);
}
}
}