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

Compare commits

base: 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
..
compare: 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

2 Commits
sunrise-cl ... truncated-

Author SHA1 Message Date
Jason Coon
37ba04106d Truncated IcosaLEDron 2017-11-17 20:31:40 -06:00
Jason Coon
545acb7144 Update README.md 2017-10-14 12:47:51 -05:00
4 changed files with 289 additions and 560 deletions
Expand all files Collapse all files

32
README.md
View File

@ -6,14 +6,38 @@ Control an addressable LED strip with an ESP8266 via a web browser or infrared r
Hardware
--------
An ESP8266 development board, such as the [Adafruit HUZZAH ESP8266 Breakout]:
##### ESP8266 development board
[![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)
Addressable LED strip, such as the [Adafruit NeoPixel Ring]:
[Adafruit HUZZAH ESP8266 Breakout](https://www.adafruit.com/products/2471)
##### Addressable LED strip
[![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
--------
* Turn the NeoPixel Ring on and off
@ -41,7 +65,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.
* [FastLED](https://github.com/FastLED/FastLED)
* [IRremoteESP8266](https://github.com/markszabo/IRremoteESP8266)
* [IRremoteESP8266](https://github.com/sebastienwarin/IRremoteESP8266)
* [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.
@ -71,7 +95,7 @@ The firmware implements basic [RESTful web services](https://en.wikipedia.org/wi
Infrared Remote Control
-----------------------
Control via infrared remote control is also supported, via the [ESP8266 port of the IRremote library](https://github.com/markszabo/IRremoteESP8266).
Control via infrared remote control is also supported, via the [ESP8266 port of the IRremote library](https://github.com/sebastienwarin/IRremoteESP8266).
[Adafruit NeoPixel Ring]:https://www.adafruit.com/product/1586
[Adafruit HUZZAH ESP8266 Breakout]:https://www.adafruit.com/products/2471

65
Text.h
View File

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

193
sunrise.h
View File

@ -1,193 +0,0 @@
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);
}
}
}