1065 lines
35 KiB
C++
1065 lines
35 KiB
C++
/**
|
|
* Wordclock 2.0 - Wordclock with ESP8266 and NTP time update
|
|
*
|
|
* created by techniccontroller 04.12.2021
|
|
*
|
|
* components:
|
|
* - ESP8266
|
|
* - Neopixelstrip
|
|
*
|
|
* Board settings:
|
|
* - Board: NodeMCU 1.0 (ESP-12E Module)
|
|
* - Flash Size: 4MB (FS:2MB OTA:~1019KB)
|
|
* - Upload Speed: 115200
|
|
*
|
|
*
|
|
* with code parts from:
|
|
* - Adafruit NeoPixel strandtest.ino, https://github.com/adafruit/Adafruit_NeoPixel/blob/master/examples/strandtest/strandtest.ino
|
|
* - Esp8266 und Esp32 webserver https://fipsok.de/
|
|
* - https://github.com/pmerlin/PMR-LED-Table/blob/master/tetrisGame.ino
|
|
* - https://randomnerdtutorials.com/wifimanager-with-esp8266-autoconnect-custom-parameter-and-manage-your-ssid-and-password/
|
|
*
|
|
*/
|
|
#include <Arduino.h>
|
|
#include "wordclock_esp8266.h"
|
|
|
|
#include <Adafruit_GFX.h> // https://github.com/adafruit/Adafruit-GFX-Library
|
|
#include <Adafruit_NeoMatrix.h> // https://github.com/adafruit/Adafruit_NeoMatrix
|
|
#include <Adafruit_NeoPixel.h> // NeoPixel library used to run the NeoPixel LEDs: https://github.com/adafruit/Adafruit_NeoPixel
|
|
#include <EEPROM.h> //from ESP8266 Arduino Core (automatically installed when ESP8266 was installed via Boardmanager)
|
|
#include <ESP8266WebServer.h>
|
|
#include <ESP8266WiFi.h>
|
|
#include <WiFiManager.h> //https://github.com/tzapu/WiFiManager WiFi Configuration Magic
|
|
#include <WiFiUdp.h>
|
|
|
|
// own libraries
|
|
#include "animationfunctions.h"
|
|
#include "pong.h"
|
|
#include "snake.h"
|
|
#include "tetris.h"
|
|
#include "ledmatrix.h"
|
|
#include "littlefs_wrapper.h"
|
|
#include "base64_wrapper.h" // copied from https://github.com/Xander-Electronics/Base64
|
|
#include "ntp_client_plus.h"
|
|
#include "otafunctions.h"
|
|
#include "udp_logger.h"
|
|
#include "wordclock_constants.h"
|
|
#include "wordclock_functions.h"
|
|
|
|
// DEBUG
|
|
uint32_t dbg_counter = 0; // TODO RM
|
|
|
|
const String state_names[] = {"Clock", "DiClock", "Spiral", "Tetris", "Snake", "PingPong"};
|
|
// PERIODS for each state (different for stateAutoChange or Manual mode)
|
|
const uint16_t PERIODS[2][NUM_STATES] = {{PERIOD_TIME_VISU_UPDATE, // stateAutoChange = 0
|
|
PERIOD_TIME_VISU_UPDATE,
|
|
PERIOD_ANIMATION,
|
|
PERIOD_TETRIS,
|
|
PERIOD_SNAKE,
|
|
PERIOD_PONG},
|
|
{PERIOD_TIME_VISU_UPDATE, // stateAutoChange = 1
|
|
PERIOD_TIME_VISU_UPDATE,
|
|
PERIOD_ANIMATION,
|
|
PERIOD_ANIMATION,
|
|
PERIOD_ANIMATION,
|
|
PERIOD_PONG}};
|
|
|
|
// ----------------------------------------------------------------------------------
|
|
// GLOBAL VARIABLES
|
|
// ----------------------------------------------------------------------------------
|
|
|
|
// Webserver
|
|
ESP8266WebServer webserver(HTTP_PORT);
|
|
|
|
// When we setup the NeoPixel library, we tell it how many pixels, and which pin to use to send signals.
|
|
// Note that for older NeoPixel strips you might need to change the third parameter--see the strandtest
|
|
// example for more information on possible values.
|
|
Adafruit_NeoMatrix matrix = Adafruit_NeoMatrix(MATRIX_WIDTH, MATRIX_HEIGHT + 1, NEOPIXEL_PIN,
|
|
NEO_MATRIX_TOP + NEO_MATRIX_LEFT + NEO_MATRIX_ROWS + NEO_MATRIX_ZIGZAG,
|
|
NEO_GRB + NEO_KHZ800);
|
|
|
|
// Globals
|
|
uint8_t brightness = 40; // current brightness of LEDs
|
|
LEDMatrix led_matrix = LEDMatrix(&matrix, brightness, &logger);
|
|
UDPLogger logger;
|
|
|
|
// Statics
|
|
static bool spiral_direction = false;
|
|
|
|
static WiFiUDP wifi_udp;
|
|
static NTPClientPlus ntp_client = NTPClientPlus(wifi_udp, NTP_SERVER_URL, 1, true);
|
|
static Pong pong = Pong(&led_matrix, &logger);
|
|
static Snake snake = Snake(&led_matrix, &logger);
|
|
static Tetris tetris = Tetris(&led_matrix, &logger);
|
|
|
|
// Timestamp variables
|
|
static unsigned long button_press_start = 0; // time of push button press start
|
|
static unsigned long last_led_direct = 0; // time of last direct LED command (=> fall back to normal mode after timeout)
|
|
static unsigned long last_animation_step = millis(); // time of last Matrix update
|
|
static unsigned long last_heartbeat = millis(); // time of last heartbeat sending
|
|
static unsigned long last_nightmode_check = millis(); // time of last nightmode check
|
|
static unsigned long last_ntp_update = millis() - PERIOD_NTP_UPDATE - 5000; // time of last NTP update
|
|
static unsigned long last_state_change = millis(); // time of last state change
|
|
static unsigned long last_step = millis(); // time of last animation step
|
|
|
|
static bool night_mode = false; // stores state of nightmode
|
|
static bool state_auto_change = false; // stores state of automatic state change
|
|
static float filter_factor = DEFAULT_SMOOTHING_FACTOR; // stores smoothing factor for led transition
|
|
static uint32_t maincolor_clock = colors_24bit[2]; // color of the clock and digital clock
|
|
static uint32_t maincolor_snake = colors_24bit[1]; // color of the random snake animation
|
|
static uint8_t current_state = (uint8_t)ST_CLOCK; // stores current state
|
|
static int watchdog_counter = 30; // Watchdog counter to trigger restart if NTP update was not possible 30 times in a row (5min)
|
|
|
|
// Nightmode time settings
|
|
NightModeTimes_st night_mode_times = {
|
|
NIGHTMODE_START_HR,
|
|
NIGHTMODE_START_MIN,
|
|
NIGHTMODE_END_HR,
|
|
NIGHTMODE_END_MIN};
|
|
|
|
// ----------------------------------------------------------------------------------
|
|
// SETUP
|
|
// ----------------------------------------------------------------------------------
|
|
|
|
void setup()
|
|
{
|
|
// put your setup code here, to run once:
|
|
Serial.begin(115200);
|
|
delay(100);
|
|
Serial.println();
|
|
Serial.printf("\nSketchname: %s\nBuild: %s\n", (__FILE__), (__TIMESTAMP__));
|
|
Serial.println();
|
|
|
|
// Reset info
|
|
rst_info *resetInfo = ESP.getResetInfoPtr();
|
|
Serial.printf("Reset reason: %u\n", resetInfo->reason);
|
|
Serial.printf("Reset cause: %u\n", resetInfo->exccause);
|
|
Serial.printf("Reset address: %u\n", resetInfo->excvaddr);
|
|
Serial.println();
|
|
|
|
// Init EEPROM
|
|
EEPROM.begin(EEPROM_SIZE);
|
|
|
|
// Load color for clock from EEPROM
|
|
load_main_color();
|
|
|
|
// configure button pin as input
|
|
pinMode(BUTTON_PIN, INPUT_PULLUP);
|
|
|
|
// setup Matrix LED functions
|
|
led_matrix.setup_matrix();
|
|
led_matrix.set_current_limit(CURRENT_LIMIT_LED);
|
|
|
|
// Turn on minutes leds (blue)
|
|
led_matrix.set_min_indicator(15, colors_24bit[6]);
|
|
led_matrix.draw_on_matrix_instant();
|
|
|
|
/** Use WiFiMaanger for handling initial Wifi setup **/
|
|
|
|
// Local intialization. Once its business is done, there is no need to keep it around
|
|
WiFiManager wifiManager;
|
|
|
|
// fetches ssid and pass from eeprom and tries to connect
|
|
// if it does not connect it starts an access point with the specified name
|
|
// here "wordclockAP"
|
|
// and goes into a blocking loop awaiting configuration
|
|
wifiManager.autoConnect(AP_SSID);
|
|
|
|
// if you get here you have connected to the WiFi
|
|
Serial.printf("Connected, IP address: ");
|
|
Serial.println(WiFi.localIP());
|
|
|
|
// Turn off minutes leds
|
|
led_matrix.set_min_indicator(15, 0);
|
|
led_matrix.draw_on_matrix_instant();
|
|
|
|
// init ESP8266 File manager (LittleFS)
|
|
setup_filesystem();
|
|
|
|
// setup OTA
|
|
setupOTA(HOSTNAME);
|
|
|
|
webserver.on("/cmd", handle_command); // process commands
|
|
webserver.on("/data", handle_data_request); // process datarequests
|
|
webserver.on("/leddirect", HTTP_POST, handle_led_direct); // Call the 'handle_led_direct' function when a POST request is made to URI "/leddirect"
|
|
webserver.begin();
|
|
|
|
// create UDP Logger to send logging messages via UDP multicast
|
|
logger = UDPLogger(WiFi.localIP(), LOGGER_MULTICAST_IP, LOGGER_MULTICAST_PORT, "Wordclock 2.0");
|
|
logger.log_string("Start program\n");
|
|
delay(10);
|
|
logger.log_string("Sketchname: " + String(__FILE__));
|
|
delay(10);
|
|
logger.log_string("Build: " + String(__TIMESTAMP__));
|
|
delay(10);
|
|
logger.log_string("IP: " + WiFi.localIP().toString());
|
|
delay(10);
|
|
logger.log_string("Reset Reason: " + ESP.getResetReason());
|
|
|
|
if (resetInfo->reason != REASON_SOFT_RESTART)
|
|
{
|
|
// test quickly each LED
|
|
for (int r = 0; r < MATRIX_HEIGHT; r++)
|
|
{
|
|
for (int c = 0; c < MATRIX_WIDTH; c++)
|
|
{
|
|
matrix.fillScreen(0);
|
|
matrix.drawPixel(c, r, LEDMatrix::color_24_to_16bit(colors_24bit[2]));
|
|
matrix.show();
|
|
delay(10);
|
|
}
|
|
}
|
|
|
|
// clear Matrix
|
|
matrix.fillScreen(0);
|
|
matrix.show();
|
|
delay(200);
|
|
|
|
// display IP
|
|
uint8_t address = WiFi.localIP()[3];
|
|
led_matrix.print_char(1, 0, 'I', maincolor_clock);
|
|
led_matrix.print_char(5, 0, 'P', maincolor_clock);
|
|
led_matrix.print_number(0, 6, (address / 100), maincolor_clock);
|
|
led_matrix.print_number(4, 6, (address / 10) % 10, maincolor_clock);
|
|
led_matrix.print_number(8, 6, address % 10, maincolor_clock);
|
|
led_matrix.draw_on_matrix_instant();
|
|
delay(2000);
|
|
|
|
// clear matrix
|
|
led_matrix.flush();
|
|
led_matrix.draw_on_matrix_instant();
|
|
}
|
|
// setup NTP
|
|
ntp_client.setupNTPClient();
|
|
logger.log_string("NTP running");
|
|
logger.log_string("Time: " + ntp_client.getFormattedTime());
|
|
logger.log_string("TimeOffset (seconds): " + String(ntp_client.getTimeOffset()));
|
|
|
|
// show the current time for short time in words
|
|
int hours = ntp_client.getHours24();
|
|
int minutes = ntp_client.getMinutes();
|
|
String timeMessage = time_to_string(hours, minutes);
|
|
show_string_on_clock(timeMessage, maincolor_clock);
|
|
draw_minute_indicator(minutes, maincolor_clock);
|
|
led_matrix.draw_on_matrix_smooth(filter_factor);
|
|
|
|
// init all animation modes
|
|
// init snake
|
|
random_snake(true, 8, colors_24bit[1], -1);
|
|
// init spiral
|
|
draw_spiral(true, spiral_direction, MATRIX_WIDTH - 6);
|
|
// init random tetris
|
|
random_tetris(true);
|
|
|
|
// Read nightmode setting from EEPROM
|
|
night_mode_times.nightmode_start_hour = EEPROM_read_address(ADR_NM_START_H);
|
|
night_mode_times.nightmode_start_min = EEPROM_read_address(ADR_NM_START_M);
|
|
night_mode_times.nightmode_end_hour = EEPROM_read_address(ADR_NM_END_H);
|
|
night_mode_times.nightmode_end_min = EEPROM_read_address(ADR_NM_END_M);
|
|
|
|
if (night_mode_times.nightmode_start_hour < 0 || night_mode_times.nightmode_start_hour > 23)
|
|
{
|
|
night_mode_times.nightmode_start_hour = NIGHTMODE_START_HR;
|
|
}
|
|
if (night_mode_times.nightmode_start_min < 0 || night_mode_times.nightmode_start_min > 59)
|
|
{
|
|
night_mode_times.nightmode_start_min = NIGHTMODE_START_MIN;
|
|
}
|
|
if (night_mode_times.nightmode_end_hour < 0 || night_mode_times.nightmode_end_hour > 23)
|
|
{
|
|
night_mode_times.nightmode_end_hour = NIGHTMODE_END_HR;
|
|
}
|
|
if (night_mode_times.nightmode_end_min < 0 || night_mode_times.nightmode_end_min > 59)
|
|
{
|
|
night_mode_times.nightmode_end_min = NIGHTMODE_END_MIN;
|
|
}
|
|
logger.log_string("Nightmode starts at: " + String(night_mode_times.nightmode_start_hour) + ":" + String(night_mode_times.nightmode_start_min));
|
|
logger.log_string("Nightmode ends at: " + String(night_mode_times.nightmode_end_hour) + ":" + String(night_mode_times.nightmode_end_min));
|
|
|
|
// Read brightness setting from EEPROM, lower limit is 10 so that the LEDs are not completely off
|
|
brightness = EEPROM_read_address(ADR_BRIGHTNESS);
|
|
if (brightness < 10)
|
|
{
|
|
brightness = 10;
|
|
}
|
|
logger.log_string("Brightness: " + String(brightness));
|
|
led_matrix.set_brightness(brightness);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------------
|
|
// LOOP
|
|
// ----------------------------------------------------------------------------------
|
|
|
|
void loop()
|
|
{
|
|
handleOTA(); // handle OTA
|
|
logger.log_string("After handleOTA");
|
|
|
|
webserver.handleClient(); // handle webserver
|
|
logger.log_string("After handleClient");
|
|
|
|
send_heartbeat(); // send heartbeat update
|
|
logger.log_string("After send_heartbeat");
|
|
|
|
handle_current_state(); // handle current state - main process
|
|
logger.log_string("After handle_current_state");
|
|
|
|
update_matrix(); // update matrix
|
|
logger.log_string("After update_matrix");
|
|
|
|
handle_button(); // handle button press
|
|
logger.log_string("After handle_button");
|
|
|
|
update_state_machine(); // handle state changes
|
|
logger.log_string("After update_state_machine");
|
|
|
|
ntp_time_update(); // ntp time update
|
|
logger.log_string("After ntp_time_update");
|
|
|
|
check_night_mode(); // check night mode
|
|
logger.log_string("After check_night_mode");
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------------
|
|
// OTHER FUNCTIONS
|
|
// ----------------------------------------------------------------------------------
|
|
|
|
void update_state_machine()
|
|
{
|
|
if (state_auto_change && (millis() - last_state_change > PERIOD_STATE_CHANGE) && !night_mode)
|
|
{
|
|
// increment state variable and trigger state change
|
|
state_change((current_state + 1) % NUM_STATES);
|
|
// save last automatic state change
|
|
last_state_change = millis();
|
|
}
|
|
}
|
|
|
|
void handle_current_state()
|
|
{
|
|
// handle mode behaviours (trigger loopCycles of different modes depending on current mode)
|
|
if (!night_mode && (millis() - last_step > PERIODS[state_auto_change][current_state]) && (millis() - last_led_direct > TIMEOUT_LEDDIRECT))
|
|
{
|
|
switch (current_state)
|
|
{
|
|
case ST_CLOCK: // state clock
|
|
{
|
|
int hours = ntp_client.getHours24();
|
|
int minutes = ntp_client.getMinutes();
|
|
|
|
(void)show_string_on_clock(time_to_string((uint8_t)hours, (uint8_t)minutes), maincolor_clock);
|
|
draw_minute_indicator((uint8_t)minutes, maincolor_clock);
|
|
break;
|
|
}
|
|
case ST_DICLOCK: // state diclock
|
|
{
|
|
int hours = ntp_client.getHours24();
|
|
int minutes = ntp_client.getMinutes();
|
|
show_digital_clock((uint8_t)hours, (uint8_t)minutes, maincolor_clock);
|
|
break;
|
|
}
|
|
case ST_SPIRAL: // state spiral
|
|
{
|
|
int res = draw_spiral(false, spiral_direction, MATRIX_WIDTH - 6);
|
|
if (res && spiral_direction == 0)
|
|
{
|
|
// change spiral direction to closing (draw empty leds)
|
|
spiral_direction = 1;
|
|
// init spiral with new spiral direction
|
|
draw_spiral(true, spiral_direction, MATRIX_WIDTH - 6);
|
|
}
|
|
else if (res && spiral_direction == 1)
|
|
{
|
|
// reset spiral direction to normal drawing leds
|
|
spiral_direction = 0;
|
|
// init spiral with new spiral direction
|
|
draw_spiral(true, spiral_direction, MATRIX_WIDTH - 6);
|
|
}
|
|
break;
|
|
}
|
|
case ST_TETRIS: // state tetris
|
|
{
|
|
if (state_auto_change)
|
|
{
|
|
random_tetris(false);
|
|
}
|
|
else
|
|
{
|
|
tetris.loopCycle();
|
|
}
|
|
break;
|
|
}
|
|
case ST_SNAKE: // state snake
|
|
{
|
|
if (state_auto_change)
|
|
{
|
|
led_matrix.flush();
|
|
if (random_snake(false, 8, maincolor_snake, -1))
|
|
{
|
|
// init snake for next run
|
|
random_snake(true, 8, maincolor_snake, -1);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
snake.loopCycle();
|
|
}
|
|
break;
|
|
}
|
|
case ST_PINGPONG: // state ping pong
|
|
{
|
|
pong.loopCycle();
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
last_step = millis();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Update matrix colors, should be called in loop()
|
|
*
|
|
* @param None
|
|
*/
|
|
void update_matrix()
|
|
{
|
|
// periodically write colors to matrix
|
|
if (millis() - last_animation_step > PERIOD_MATRIX_UPDATE)
|
|
{
|
|
led_matrix.draw_on_matrix_smooth(filter_factor);
|
|
last_animation_step = millis();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Send heartbeat, should be called in loop()
|
|
*
|
|
* @param None
|
|
*/
|
|
void send_heartbeat()
|
|
{
|
|
// send regularly heartbeat messages via UDP multicast
|
|
if (millis() - last_heartbeat > PERIOD_HEARTBEAT)
|
|
{
|
|
logger.log_string("Heartbeat, state: " + state_names[current_state] + ", FreeHeap: " + ESP.getFreeHeap() + ", HeapFrag: " + ESP.getHeapFragmentation() + ", MaxFreeBlock: " + ESP.getMaxFreeBlockSize() + "\nCounter: " + dbg_counter + " , Hours: " + (float)(dbg_counter) / 3600.0 + "\n"); // TODO CHANGE
|
|
last_heartbeat = millis();
|
|
|
|
// Check wifi status (only if no apmode)
|
|
if (WiFi.status() != WL_CONNECTED)
|
|
{
|
|
Serial.println("WiFi connection lost!");
|
|
led_matrix.grid_add_pixel(0, 5, colors_24bit[1]);
|
|
led_matrix.draw_on_matrix_instant();
|
|
}
|
|
dbg_counter++; // TODO RM
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Night mode check, should be called in loop()
|
|
*
|
|
* @param None
|
|
*/
|
|
void check_night_mode()
|
|
{
|
|
// check if nightmode need to be activated
|
|
if (millis() - last_nightmode_check > PERIOD_NIGHTMODE_CHECK)
|
|
{
|
|
int hours = ntp_client.getHours24();
|
|
int minutes = ntp_client.getMinutes();
|
|
|
|
if (hours == night_mode_times.nightmode_start_hour && minutes == night_mode_times.nightmode_start_min)
|
|
{
|
|
set_night_mode(true);
|
|
}
|
|
else if (hours == night_mode_times.nightmode_end_hour && minutes == night_mode_times.nightmode_end_min)
|
|
{
|
|
set_night_mode(false);
|
|
}
|
|
|
|
last_nightmode_check = millis();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief NTP time update, should be called in loop()
|
|
*
|
|
* @param None
|
|
*/
|
|
void ntp_time_update()
|
|
{
|
|
// NTP time update
|
|
if (millis() - last_ntp_update > PERIOD_NTP_UPDATE)
|
|
{
|
|
int ntp_retval = ntp_client.updateNTP();
|
|
switch (ntp_retval)
|
|
{
|
|
case NTP_UPDATE_SUCCESS:
|
|
{
|
|
ntp_client.calcDate();
|
|
logger.log_string("NTP-Update successful");
|
|
logger.log_string("Time: " + ntp_client.getFormattedTime());
|
|
logger.log_string("Date: " + ntp_client.getFormattedDate());
|
|
logger.log_string("TimeOffset (seconds): " + String(ntp_client.getTimeOffset()));
|
|
logger.log_string("Summertime: " + String(ntp_client.updateSWChange()));
|
|
last_ntp_update = millis();
|
|
watchdog_counter = 30;
|
|
break;
|
|
}
|
|
case NTP_UPDATE_TIMEOUT:
|
|
{
|
|
logger.log_string("NTP-Update not successful. Reason: Timeout");
|
|
last_ntp_update += 10000;
|
|
watchdog_counter--;
|
|
break;
|
|
}
|
|
case NTP_UPDATE_DIFFTOOHIGH:
|
|
{
|
|
logger.log_string("NTP-Update not successful. Reason: Too large time difference");
|
|
logger.log_string("Time: " + ntp_client.getFormattedTime());
|
|
logger.log_string("Date: " + ntp_client.getFormattedDate());
|
|
logger.log_string("TimeOffset (seconds): " + String(ntp_client.getTimeOffset()));
|
|
logger.log_string("Summertime: " + String(ntp_client.updateSWChange()));
|
|
last_ntp_update += 10000;
|
|
watchdog_counter--;
|
|
break;
|
|
}
|
|
case NTP_UPDATE_TIME_INVALID:
|
|
default:
|
|
{
|
|
logger.log_string("NTP-Update not successful. Reason: NTP time not valid (<1970)");
|
|
last_ntp_update += 10000;
|
|
watchdog_counter--;
|
|
break;
|
|
}
|
|
}
|
|
|
|
logger.log_string("Watchdog Counter: " + String(watchdog_counter));
|
|
if (watchdog_counter <= 0)
|
|
{
|
|
logger.log_string("Trigger restart due to watchdog...");
|
|
delay(100);
|
|
ESP.restart();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief call entry action of given state
|
|
*
|
|
* @param state
|
|
*/
|
|
void on_state_entry(uint8_t state)
|
|
{
|
|
filter_factor = 0.5;
|
|
switch (state)
|
|
{
|
|
case ST_SPIRAL:
|
|
{ // Init spiral with normal drawing mode
|
|
spiral_direction = 0;
|
|
draw_spiral(true, spiral_direction, MATRIX_WIDTH - 6);
|
|
break;
|
|
}
|
|
case ST_TETRIS:
|
|
{
|
|
filter_factor = 1.0; // no smoothing
|
|
if (state_auto_change)
|
|
{
|
|
random_tetris(true);
|
|
}
|
|
else
|
|
{
|
|
tetris.ctrlStart();
|
|
}
|
|
break;
|
|
}
|
|
case ST_SNAKE:
|
|
{
|
|
if (state_auto_change)
|
|
{
|
|
random_snake(true, 8, colors_24bit[1], -1);
|
|
}
|
|
else
|
|
{
|
|
filter_factor = 1.0; // no smoothing
|
|
snake.initGame();
|
|
}
|
|
break;
|
|
}
|
|
case ST_PINGPONG:
|
|
{
|
|
if (state_auto_change)
|
|
{
|
|
pong.initGame(2);
|
|
}
|
|
else
|
|
{
|
|
filter_factor = 1.0; // no smoothing
|
|
pong.initGame(1);
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief execute a state change to given newState
|
|
*
|
|
* @param newState the new state to be changed to
|
|
*/
|
|
void state_change(uint8_t newState)
|
|
{
|
|
if (night_mode)
|
|
{
|
|
// deactivate Nightmode
|
|
set_night_mode(false);
|
|
}
|
|
// first clear matrix
|
|
led_matrix.flush();
|
|
// set new state
|
|
current_state = newState;
|
|
on_state_entry(current_state);
|
|
logger.log_string("State change to: " + state_names[current_state]);
|
|
delay(5);
|
|
logger.log_string("FreeMemory=" + String(ESP.getFreeHeap()));
|
|
}
|
|
|
|
/**
|
|
* @brief Handler for POST requests to /leddirect.
|
|
*
|
|
* Allows the control of all LEDs from external source.
|
|
* It will overwrite the normal program for 5 seconds.
|
|
* A 11x11 picture can be sent as base64 encoded string to be displayed on matrix.
|
|
*
|
|
*/
|
|
void handle_led_direct()
|
|
{
|
|
if (webserver.method() != HTTP_POST)
|
|
{
|
|
webserver.send(405, "text/plain", "Method Not Allowed");
|
|
}
|
|
else
|
|
{
|
|
String message = "POST data was:\n";
|
|
if (webserver.args() == 1)
|
|
{
|
|
String data = String(webserver.arg(0));
|
|
unsigned int dataLength = data.length();
|
|
|
|
// base64 decoding
|
|
char base64data[dataLength];
|
|
data.toCharArray(base64data, dataLength);
|
|
int base64dataLen = (int)dataLength;
|
|
int decodedLength = Base64.decodedLength(base64data, base64dataLen);
|
|
char byteArray[decodedLength];
|
|
Base64.decode(byteArray, base64data, base64dataLen);
|
|
|
|
for (unsigned int i = 0; i < dataLength; i += 4)
|
|
{
|
|
uint8_t red = byteArray[i]; // red
|
|
uint8_t green = byteArray[i + 1]; // green
|
|
uint8_t blue = byteArray[i + 2]; // blue
|
|
led_matrix.grid_add_pixel((i / 4) % MATRIX_WIDTH, (i / 4) / MATRIX_HEIGHT, LEDMatrix::color_24bit(red, green, blue));
|
|
}
|
|
led_matrix.draw_on_matrix_instant();
|
|
|
|
last_led_direct = millis();
|
|
}
|
|
webserver.send(200, "text/plain", message);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Check button commands
|
|
*
|
|
*/
|
|
void handle_button()
|
|
{
|
|
static bool lastButtonState = false;
|
|
bool buttonPressed = !digitalRead(BUTTON_PIN);
|
|
// check rising edge
|
|
if (buttonPressed == true && lastButtonState == false)
|
|
{
|
|
// button press start
|
|
logger.log_string("Button press started");
|
|
button_press_start = millis();
|
|
}
|
|
// check falling edge
|
|
if (buttonPressed == false && lastButtonState == true)
|
|
{
|
|
// button press ended
|
|
if ((millis() - button_press_start) > LONG_PRESS_MS)
|
|
{
|
|
// longpress -> nightmode
|
|
logger.log_string("Button press ended - long press");
|
|
|
|
set_night_mode(true);
|
|
}
|
|
else if ((millis() - button_press_start) > SHORT_PRESS_MS)
|
|
{
|
|
// shortpress -> state change
|
|
logger.log_string("Button press ended - short press");
|
|
|
|
if (night_mode)
|
|
{
|
|
set_night_mode(false);
|
|
}
|
|
else
|
|
{
|
|
state_change((current_state + 1) % NUM_STATES);
|
|
}
|
|
}
|
|
}
|
|
lastButtonState = buttonPressed;
|
|
}
|
|
|
|
/**
|
|
* @brief Set main color
|
|
*
|
|
*/
|
|
|
|
void set_main_color(uint8_t red, uint8_t green, uint8_t blue)
|
|
{
|
|
maincolor_clock = LEDMatrix::color_24bit(red, green, blue);
|
|
EEPROM.put(ADR_MC_RED, red);
|
|
EEPROM.put(ADR_MC_GREEN, green);
|
|
EEPROM.put(ADR_MC_BLUE, blue);
|
|
EEPROM.commit();
|
|
}
|
|
|
|
/**
|
|
* @brief Load maincolor from EEPROM
|
|
*
|
|
*/
|
|
|
|
void load_main_color()
|
|
{
|
|
uint8_t red = EEPROM.read(ADR_MC_RED);
|
|
uint8_t green = EEPROM.read(ADR_MC_GREEN);
|
|
uint8_t blue = EEPROM.read(ADR_MC_BLUE);
|
|
if (int(red) + int(green) + int(blue) < 50)
|
|
{
|
|
maincolor_clock = colors_24bit[2];
|
|
}
|
|
else
|
|
{
|
|
maincolor_clock = LEDMatrix::color_24bit(red, green, blue);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Handler for handling commands sent to "/cmd" url
|
|
*
|
|
*/
|
|
void handle_command()
|
|
{
|
|
// receive command and handle accordingly
|
|
for (uint8_t i = 0; i < webserver.args(); i++)
|
|
{
|
|
Serial.print(webserver.argName(i));
|
|
Serial.print(F(": "));
|
|
Serial.println(webserver.arg(i));
|
|
}
|
|
|
|
if (webserver.argName(0).equals("led")) // the parameter which was sent to this server is led color
|
|
{
|
|
String color_str = webserver.arg(0) + "-";
|
|
String red_str = split(color_str, '-', 0);
|
|
String green_str = split(color_str, '-', 1);
|
|
String blue_str = split(color_str, '-', 2);
|
|
logger.log_string(color_str);
|
|
logger.log_string("r: " + String(red_str.toInt()));
|
|
logger.log_string("g: " + String(green_str.toInt()));
|
|
logger.log_string("b: " + String(blue_str.toInt()));
|
|
// set new main color
|
|
set_main_color(red_str.toInt(), green_str.toInt(), blue_str.toInt());
|
|
}
|
|
else if (webserver.argName(0).equals("mode")) // the parameter which was sent to this server is mode change
|
|
{
|
|
String mode_str = webserver.arg(0);
|
|
logger.log_string("Mode change via Webserver to: " + mode_str);
|
|
// set current mode/state accordant sent mode
|
|
if (mode_str.equals("clock"))
|
|
{
|
|
state_change(ST_CLOCK);
|
|
}
|
|
else if (mode_str.equals("diclock"))
|
|
{
|
|
state_change(ST_DICLOCK);
|
|
}
|
|
else if (mode_str.equals("spiral"))
|
|
{
|
|
state_change(ST_SPIRAL);
|
|
}
|
|
else if (mode_str.equals("tetris"))
|
|
{
|
|
state_change(ST_TETRIS);
|
|
}
|
|
else if (mode_str.equals("snake"))
|
|
{
|
|
state_change(ST_SNAKE);
|
|
}
|
|
else if (mode_str.equals("pingpong"))
|
|
{
|
|
state_change(ST_PINGPONG);
|
|
}
|
|
}
|
|
else if (webserver.argName(0).equals("nightmode"))
|
|
{
|
|
String mode_str = webserver.arg(0);
|
|
logger.log_string("Nightmode change via Webserver to: " + mode_str);
|
|
mode_str.equals("1") ? set_night_mode(true) : set_night_mode(false);
|
|
}
|
|
else if (webserver.argName(0).equals("setting"))
|
|
{
|
|
String time_str = webserver.arg(0) + "-";
|
|
logger.log_string("Nightmode setting change via Webserver to: " + time_str);
|
|
night_mode_times.nightmode_start_hour = split(time_str, '-', 0).toInt();
|
|
night_mode_times.nightmode_start_min = split(time_str, '-', 1).toInt();
|
|
night_mode_times.nightmode_end_hour = split(time_str, '-', 2).toInt();
|
|
night_mode_times.nightmode_end_min = split(time_str, '-', 3).toInt();
|
|
brightness = split(time_str, '-', 4).toInt();
|
|
if (brightness < 10)
|
|
{
|
|
brightness = 10;
|
|
}
|
|
if (night_mode_times.nightmode_start_hour < 0 || night_mode_times.nightmode_start_hour > 23)
|
|
{
|
|
night_mode_times.nightmode_start_hour = NIGHTMODE_START_HR;
|
|
}
|
|
if (night_mode_times.nightmode_start_min < 0 || night_mode_times.nightmode_start_min > 59)
|
|
{
|
|
night_mode_times.nightmode_start_min = NIGHTMODE_START_MIN;
|
|
}
|
|
if (night_mode_times.nightmode_end_hour < 0 || night_mode_times.nightmode_end_hour > 23)
|
|
{
|
|
night_mode_times.nightmode_end_hour = NIGHTMODE_END_HR;
|
|
}
|
|
if (night_mode_times.nightmode_end_min < 0 || night_mode_times.nightmode_end_min > 59)
|
|
{
|
|
night_mode_times.nightmode_end_min = NIGHTMODE_END_MIN;
|
|
}
|
|
|
|
EEPROM_write_to_address(ADR_NM_START_H, night_mode_times.nightmode_start_hour);
|
|
EEPROM_write_to_address(ADR_NM_START_M, night_mode_times.nightmode_start_min);
|
|
EEPROM_write_to_address(ADR_NM_END_H, night_mode_times.nightmode_end_hour);
|
|
EEPROM_write_to_address(ADR_NM_END_M, night_mode_times.nightmode_end_min);
|
|
EEPROM_write_to_address(ADR_BRIGHTNESS, brightness);
|
|
|
|
logger.log_string("Nightmode starts at: " + String(night_mode_times.nightmode_start_hour) + ":" + String(night_mode_times.nightmode_start_min));
|
|
logger.log_string("Nightmode ends at: " + String(night_mode_times.nightmode_end_hour) + ":" + String(night_mode_times.nightmode_end_min));
|
|
logger.log_string("Brightness: " + String(brightness));
|
|
led_matrix.set_brightness(brightness);
|
|
}
|
|
else if (webserver.argName(0).equals("stateautochange"))
|
|
{
|
|
String mode_str = webserver.arg(0);
|
|
logger.log_string("stateAutoChange change via Webserver to: " + mode_str);
|
|
mode_str.equals("1") ? state_auto_change = true : state_auto_change = false;
|
|
}
|
|
else if (webserver.argName(0).equals("tetris"))
|
|
{
|
|
String cmd_str = webserver.arg(0);
|
|
logger.log_string("Tetris cmd via Webserver to: " + cmd_str);
|
|
if (cmd_str.equals("up"))
|
|
{
|
|
tetris.ctrlUp();
|
|
}
|
|
else if (cmd_str.equals("left"))
|
|
{
|
|
tetris.ctrlLeft();
|
|
}
|
|
else if (cmd_str.equals("right"))
|
|
{
|
|
tetris.ctrlRight();
|
|
}
|
|
else if (cmd_str.equals("down"))
|
|
{
|
|
tetris.ctrlDown();
|
|
}
|
|
else if (cmd_str.equals("play"))
|
|
{
|
|
tetris.ctrlStart();
|
|
}
|
|
else if (cmd_str.equals("pause"))
|
|
{
|
|
tetris.ctrlPlayPause();
|
|
}
|
|
}
|
|
else if (webserver.argName(0).equals("snake"))
|
|
{
|
|
String cmd_str = webserver.arg(0);
|
|
logger.log_string("Snake cmd via Webserver to: " + cmd_str);
|
|
if (cmd_str.equals("up"))
|
|
{
|
|
snake.ctrlUp();
|
|
}
|
|
else if (cmd_str.equals("left"))
|
|
{
|
|
snake.ctrlLeft();
|
|
}
|
|
else if (cmd_str.equals("right"))
|
|
{
|
|
snake.ctrlRight();
|
|
}
|
|
else if (cmd_str.equals("down"))
|
|
{
|
|
snake.ctrlDown();
|
|
}
|
|
else if (cmd_str.equals("new"))
|
|
{
|
|
snake.initGame();
|
|
}
|
|
}
|
|
else if (webserver.argName(0).equals("pong"))
|
|
{
|
|
String cmd_str = webserver.arg(0);
|
|
logger.log_string("Pong cmd via Webserver to: " + cmd_str);
|
|
if (cmd_str.equals("up"))
|
|
{
|
|
pong.ctrlUp(1);
|
|
}
|
|
else if (cmd_str.equals("down"))
|
|
{
|
|
pong.ctrlDown(1);
|
|
}
|
|
else if (cmd_str.equals("new"))
|
|
{
|
|
pong.initGame(1);
|
|
}
|
|
}
|
|
webserver.send(204, "text/plain", "No Content"); // this page doesn't send back content --> 204
|
|
}
|
|
|
|
/**
|
|
* @brief Splits a string at given character and return specified element
|
|
*
|
|
* @param s string to split
|
|
* @param parser separating character
|
|
* @param index index of the element to return
|
|
* @return String
|
|
*/
|
|
String split(String s, char parser, int index)
|
|
{
|
|
String rs = "";
|
|
int parser_cnt = 0;
|
|
int r_from_index = 0, r_to_index = -1;
|
|
while (index >= parser_cnt)
|
|
{
|
|
r_from_index = r_to_index + 1;
|
|
r_to_index = s.indexOf(parser, r_from_index);
|
|
if (index == parser_cnt)
|
|
{
|
|
if (r_to_index == 0 || r_to_index == -1)
|
|
{
|
|
return "";
|
|
}
|
|
return s.substring(r_from_index, r_to_index);
|
|
}
|
|
else
|
|
parser_cnt++;
|
|
}
|
|
return rs;
|
|
}
|
|
|
|
/**
|
|
* @brief Handler for GET requests
|
|
*
|
|
*/
|
|
void handle_data_request()
|
|
{
|
|
// receive data request and handle accordingly
|
|
for (uint8_t i = 0; i < webserver.args(); i++)
|
|
{
|
|
Serial.print(webserver.argName(i));
|
|
Serial.print(F(": "));
|
|
Serial.println(webserver.arg(i));
|
|
}
|
|
|
|
if (webserver.argName(0).equals("key")) // the parameter which was sent to this server is led color
|
|
{
|
|
String message = "{";
|
|
String keystr = webserver.arg(0);
|
|
if (keystr.equals("mode"))
|
|
{
|
|
message += "\"mode\":\"" + state_names[current_state] + "\"";
|
|
message += ",";
|
|
message += "\"modeid\":\"" + String(current_state) + "\"";
|
|
message += ",";
|
|
message += "\"stateAutoChange\":\"" + String(state_auto_change) + "\"";
|
|
message += ",";
|
|
message += "\"night_mode\":\"" + String(night_mode) + "\"";
|
|
message += ",";
|
|
message += "\"nightModeStart\":\"" + leading_zero2digit(night_mode_times.nightmode_start_hour) + "-" + leading_zero2digit(night_mode_times.nightmode_start_min) + "\"";
|
|
message += ",";
|
|
message += "\"nightModeEnd\":\"" + leading_zero2digit(night_mode_times.nightmode_end_hour) + "-" + leading_zero2digit(night_mode_times.nightmode_end_min) + "\"";
|
|
message += ",";
|
|
message += "\"brightness\":\"" + String(brightness) + "\"";
|
|
}
|
|
message += "}";
|
|
webserver.send(200, "application/json", message);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Set the nightmode state
|
|
*
|
|
* @param state true -> nightmode on
|
|
*/
|
|
void set_night_mode(bool state)
|
|
{
|
|
led_matrix.flush();
|
|
led_matrix.draw_on_matrix_smooth(0.2);
|
|
night_mode = state;
|
|
}
|
|
|
|
/**
|
|
* @brief Write value to EEPROM
|
|
*
|
|
* @param address address to write the value
|
|
* @param value value to write
|
|
*/
|
|
void EEPROM_write_to_address(int address, int value)
|
|
{
|
|
EEPROM.put(address, value);
|
|
EEPROM.commit();
|
|
}
|
|
|
|
/**
|
|
* @brief Read value from EEPROM
|
|
*
|
|
* @param address address
|
|
* @return int value
|
|
*/
|
|
int EEPROM_read_address(int address)
|
|
{
|
|
int value;
|
|
EEPROM.get(address, value);
|
|
return value;
|
|
}
|
|
|
|
/**
|
|
* @brief Convert Integer to String with leading zero
|
|
*
|
|
* @param value
|
|
* @return String
|
|
*/
|
|
String leading_zero2digit(int value)
|
|
{
|
|
String msg = "";
|
|
if (value < 10)
|
|
{
|
|
msg = "0";
|
|
}
|
|
msg += String(value);
|
|
return msg;
|
|
}
|