mirrors
/
Tasmota
mirror of https://github.com/arendst/Tasmota.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
Tasmota/tasmota/tasmota_xlgt_light/xlgt_05_sonoff_l1.ino

424 lines
15 KiB
C++
Raw Permalink Blame History

/*
xlgt_05_sonoff_l1.ino - Sonoff L1 led support for Tasmota
Copyright (C) 2021 Theo Arends
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/>.
*/
#ifdef USE_LIGHT
#ifdef USE_SONOFF_L1
/*********************************************************************************************\
* Sonoff L1
\*********************************************************************************************/
#define XLGT_05 5
#define SONOFF_L1_START_DELAY // Sync Nuvotron power state with Tasmota on power up
//#define SONOFF_L1_ALLOW_REMOTE_INTERRUPT // During schemes 2..4 or if fade is active
#define SONOFF_L1_DEBUG1 // Add send and receive logging
#define SONOFF_L1_BUSY 200 // Time in milliseconds to handle a serial request
#define SONOFF_L1_BUFFER_SIZE 170
#define SONOFF_L1_MODE_COLORFUL 1 // [Color key] Colorful (static color)
#define SONOFF_L1_MODE_COLORFUL_GRADIENT 2 // [SMOOTH] Colorful Gradient
#define SONOFF_L1_MODE_COLORFUL_BREATH 3 // [FADE] Colorful Breath
#define SONOFF_L1_MODE_DIY_GRADIENT 4 // DIY Gradient (fade in and out) [Speed 1- 100, color]
#define SONOFF_L1_MODE_DIY_PULSE 5 // DIY Pulse (faster fade in and out) [Speed 1- 100, color]
#define SONOFF_L1_MODE_DIY_BREATH 6 // DIY Breath (toggle on/off) [Speed 1- 100, color]
#define SONOFF_L1_MODE_DIY_STROBE 7 // DIY Strobe (faster toggle on/off) [Speed 1- 100, color]
#define SONOFF_L1_MODE_RGB_GRADIENT 8 // RGB Gradient
#define SONOFF_L1_MODE_RGB_PULSE 9 // [STROBE] RGB Pulse
#define SONOFF_L1_MODE_RGB_BREATH 10 // RGB Breath
#define SONOFF_L1_MODE_RGB_STROBE 11 // [FLASH] RGB strobe
#define SONOFF_L1_MODE_SYNC_TO_MUSIC 12 // Sync to music [Speed 1- 100, sensitivity 1 - 10]
struct SNFL1 {
char *buffer;
uint32_t process_time = 0;
uint32_t unlock = 0;
uint32_t busy = SONOFF_L1_BUSY;
uint16_t sequence;
uint8_t color[3];
uint8_t dimmer;
uint8_t power;
uint8_t old_music_sync = 0;
uint8_t sensitive;
uint8_t speed;
} Snfl1;
const char kL1Commands[] PROGMEM = "L1|" // Prefix
"MusicSync";
void (* const L1Command[])(void) PROGMEM = {
&CmndMusicSync };
/********************************************************************************************/
#ifdef SONOFF_L1_START_DELAY
#include <Ticker.h>
Ticker SnfL1StartDelay;
void SnfL1SendDelayed(void) {
SnfL1Send();
}
#endif // SONOFF_L1_START_DELAY
#include <Ticker.h>
Ticker SnfL1Backlog;
void SnfL1SendBacklog(void) {
// AddLog(LOG_LEVEL_DEBUG, PSTR("SL1: ++Exec backlog"));
SnfL1SetChannels(true);
}
void SnfL1Send(void) {
#ifdef SONOFF_L1_DEBUG1
AddLog(LOG_LEVEL_DEBUG, PSTR("SL1: Send '%s'"), Snfl1.buffer);
#endif
Serial.print(Snfl1.buffer);
Serial.write(0x1B);
Serial.flush();
Snfl1.process_time = millis();
Snfl1.unlock = Snfl1.process_time + Snfl1.busy; // Wait for 'AT+RESULT="sequence":"1630250830439"'
}
void SnfL1SendOk(void) {
snprintf_P(Snfl1.buffer, SONOFF_L1_BUFFER_SIZE, PSTR("AT+SEND=ok"));
SnfL1Send();
}
bool SnfL1SerialInput(void) {
if (TasmotaGlobal.serial_in_byte != 0x1B) {
if (TasmotaGlobal.serial_in_byte_counter >= SONOFF_L1_BUFFER_SIZE) {
TasmotaGlobal.serial_in_byte_counter = 0;
}
if (TasmotaGlobal.serial_in_byte_counter || (!TasmotaGlobal.serial_in_byte_counter && ('A' == TasmotaGlobal.serial_in_byte))) { // A from AT
TasmotaGlobal.serial_in_buffer[TasmotaGlobal.serial_in_byte_counter++] = TasmotaGlobal.serial_in_byte;
}
} else {
TasmotaGlobal.serial_in_buffer[TasmotaGlobal.serial_in_byte_counter++] = 0x00;
// AT+RESULT="sequence":"0458" = L1
// AT+RESULT="sequence":"0458","switch" = L1 lite - just returns part of receive buffer
// AT+RESULT="sequence":"1554682835320" = L1 both
// AT+UPDATE="sequence":"1554682835320","switch":"on","light_type":1,"colorR":0,"colorG":16,"colorB":0,"bright":6,"mode":1
// AT+UPDATE="switch":"on","light_type":1,"colorR":255,"colorG":0,"colorB":0,"bright":6,"mode":1,"speed":100,"sensitive":10
#ifdef SONOFF_L1_DEBUG1
AddLog(LOG_LEVEL_DEBUG, PSTR("SL1: Rcvd '%s'"), TasmotaGlobal.serial_in_buffer);
#endif
if (!strncmp(TasmotaGlobal.serial_in_buffer +3, "RESULT", 6)) {
#ifdef SONOFF_L1_ALLOW_REMOTE_INTERRUPT
Snfl1.busy = 500;
#else
/*
// Read sequence number and calculate time it took from send of same sequence
// this indicates Nuvoton processing speed (50-60 for L1, 30-40 for L1 lite)
// Important for constant color change schemes and fade
char *end_str;
char *string = TasmotaGlobal.serial_in_buffer +10;
char *token = strtok_r(string, ",", &end_str);
if (token) {
char* end_token;
char* token2 = strtok_r(token, ":", &end_token);
char* token3 = strtok_r(nullptr, ":", &end_token);
if (!strncmp(token2, "\"sequence\"", 10) && (strlen(token3) > 3)) {
token3 = token3 + strlen(token3) - 4; // Last three digits
if (Snfl1.sequence == atoi(token3)) {
Snfl1.busy = (millis() - Snfl1.process_time) + 30; // Add some scatter time
if (Snfl1.busy > SONOFF_L1_BUSY) {
Snfl1.busy = SONOFF_L1_BUSY;
}
}
}
}
*/
Snfl1.busy = 80;
#endif // SONOFF_L1_ALLOW_REMOTE_INTERRUPT
// AddLog(LOG_LEVEL_DEBUG, PSTR("Sl1: ++Busy %d"), Snfl1.busy);
SnfL1SendOk();
return true;
}
else if (!strncmp(TasmotaGlobal.serial_in_buffer +3, "UPDATE", 6)) {
char cmnd_dimmer[20];
char cmnd_color[20];
char *end_str;
char *string = TasmotaGlobal.serial_in_buffer +10;
char *token = strtok_r(string, ",", &end_str);
bool color_updated[3] = { false, false, false };
bool switch_state = false;
bool is_power_change = false;
bool is_color_change = false;
bool is_brightness_change = false;
while (token != nullptr) {
char* end_token;
char* token2 = strtok_r(token, ":", &end_token);
char* token3 = strtok_r(nullptr, ":", &end_token);
if (!strncmp(token2, "\"sequence\"", 10)) {
// AddLog(LOG_LEVEL_DEBUG, PSTR("SL1: Rcvd sequence %s"), token3);
token = nullptr;
}
else if (!strncmp(token2, "\"switch\"", 8)) {
switch_state = !strncmp(token3, "\"on\"", 4) ? true : false;
// AddLog(LOG_LEVEL_DEBUG, PSTR("SL1: Rcvd switch %d (%d)"), switch_state, Light.power);
is_power_change = (switch_state != Light.power);
}
else if (!strncmp(token2, "\"color", 6)) {
char color_channel_name = token2[6];
int color_index;
switch(color_channel_name) {
case 'R': color_index = 0;
break;
case 'G': color_index = 1;
break;
case 'B': color_index = 2;
break;
}
int color_value = atoi(token3);
Snfl1.color[color_index] = color_value;
color_updated[color_index] = true;
bool all_color_channels_updated = color_updated[0] && color_updated[1] && color_updated[2];
if (all_color_channels_updated) {
// AddLog(LOG_LEVEL_DEBUG, PSTR("SL1: Rcvd color R%d G%d B%d (R%d G%d B%d)"),
// Snfl1.color[0], Snfl1.color[1], Snfl1.color[2],
// Settings->light_color[0], Settings->light_color[1], Settings->light_color[2]);
is_color_change = (Light.power && (memcmp(Snfl1.color, Settings->light_color, 3) != 0));
}
snprintf_P(cmnd_color, sizeof(cmnd_color), PSTR(D_CMND_COLOR "2 %02x%02x%02x"), Snfl1.color[0], Snfl1.color[1], Snfl1.color[2]);
}
else if (!strncmp(token2, "\"bright\"", 8)) {
uint8_t dimmer = atoi(token3);
// AddLog(LOG_LEVEL_DEBUG, PSTR("SL1: Rcvd dimmer %d (%d)"), dimmer, Settings->light_dimmer);
is_brightness_change = (Light.power && (dimmer > 0) && (dimmer != Settings->light_dimmer));
snprintf_P(cmnd_dimmer, sizeof(cmnd_dimmer), PSTR(D_CMND_DIMMER " %d"), dimmer);
}
else if (!strncmp(token2, "\"mode\"", 6)) {
uint8_t received_mode = atoi(token3);
Settings->sbflag1.sonoff_l1_music_sync = (SONOFF_L1_MODE_SYNC_TO_MUSIC == received_mode);
}
token = strtok_r(nullptr, ",", &end_str);
}
SnfL1SendOk();
if (is_power_change) {
if (Settings->light_scheme > 0) {
if (!switch_state) { // If power off RC button pressed stop schemes
char cmnd_scheme[20];
snprintf_P(cmnd_scheme, sizeof(cmnd_scheme), PSTR(D_CMND_SCHEME " 0"));
ExecuteCommand(cmnd_scheme, SRC_REMOTE);
}
}
// else {
ExecuteCommandPower(1, switch_state, SRC_REMOTE);
// }
}
else if (is_brightness_change) {
ExecuteCommand(cmnd_dimmer, SRC_REMOTE);
}
else if (Light.power && is_color_change) {
if (0 == Settings->light_scheme) { // Fix spurious color receptions when scheme > 0
if (Settings->light_fade) { // Disable fade as RC button colors overrule and are immediate supressing ghost colors
char cmnd_fade[20];
snprintf_P(cmnd_fade, sizeof(cmnd_fade), PSTR(D_CMND_FADE " 0"));
ExecuteCommand(cmnd_fade, SRC_REMOTE);
}
if (Settings->light_correction) { // Disable ledtable as RC button colors overrule and are immediate supressing ghost colors
char cmnd_fade[20];
snprintf_P(cmnd_fade, sizeof(cmnd_fade), PSTR(D_CMND_LEDTABLE " 0"));
ExecuteCommand(cmnd_fade, SRC_REMOTE);
}
ExecuteCommand(cmnd_color, SRC_REMOTE);
}
}
}
return true;
}
TasmotaGlobal.serial_in_byte = 0;
return false;
}
/********************************************************************************************/
void SnfL1SetChannels(bool backlog) {
// Takes about 100ms at 9600 bps
if (!backlog) {
uint8_t power = Light.power;
bool power_changed = (Snfl1.power != power);
Snfl1.power = power;
uint8_t dimmer = light_state.getDimmer();
bool dimmer_changed = (Snfl1.dimmer != dimmer);
Snfl1.dimmer = dimmer;
uint8_t *scale_col = (uint8_t*)XdrvMailbox.topic;
bool color_changed = false;
if (!power_changed) {
for (uint32_t i = 0; i < 3; i++) {
if (Snfl1.color[i] != scale_col[i]) {
color_changed = true;
}
Snfl1.color[i] = scale_col[i];
}
}
if (!power_changed && !dimmer_changed && !color_changed && (Snfl1.old_music_sync == Settings->sbflag1.sonoff_l1_music_sync)) { return; }
}
if (TimeReached(Snfl1.unlock)) {
// AddLog(LOG_LEVEL_DEBUG, PSTR("SL1: ++SC snd"));
uint32_t mode = (Settings->sbflag1.sonoff_l1_music_sync) ? SONOFF_L1_MODE_SYNC_TO_MUSIC : SONOFF_L1_MODE_COLORFUL;
Snfl1.sequence = millis()%1000;
snprintf_P(Snfl1.buffer, SONOFF_L1_BUFFER_SIZE, PSTR("AT+UPDATE=\"sequence\":\"%d%03d\",\"switch\":\"%s\",\"light_type\":1,\"colorR\":%d,\"colorG\":%d,\"colorB\":%d,\"bright\":%d,\"mode\":%d"),
LocalTime(), Snfl1.sequence,
Snfl1.power ? "on" : "off",
Snfl1.color[0], Snfl1.color[1], Snfl1.color[2],
Snfl1.dimmer,
mode);
if (SONOFF_L1_MODE_SYNC_TO_MUSIC == mode) {
snprintf_P(Snfl1.buffer, SONOFF_L1_BUFFER_SIZE, PSTR("%s,\"sensitive\":%d,\"speed\":%d"),
Snfl1.buffer,
Snfl1.sensitive,
Snfl1.speed);
}
#ifdef SONOFF_L1_START_DELAY
static bool first_call = true;
if (first_call) {
SnfL1StartDelay.once_ms(900, SnfL1SendDelayed); // Allow startup time for Nuvotron microcontroller
first_call = false;
} else
#endif // SONOFF_L1_START_DELAY
SnfL1Send();
} else {
if (Settings->light_scheme == 0) {
// Fix last fade state
// AddLog(LOG_LEVEL_DEBUG, PSTR("SL1: ++SC bck"));
SnfL1Backlog.once_ms(SONOFF_L1_BUSY, SnfL1SendBacklog); // Set backlog
}
}
}
bool SnfL1SetChannelsFromFunc(void) {
static bool first_call = true;
if (first_call) {
first_call = false; // Allow MusicSync at init time
} else {
Settings->sbflag1.sonoff_l1_music_sync = 0; // Disable MusicSync on user color change
}
SnfL1SetChannels(false);
return true;
}
bool SnfL1ModuleSelected(void) {
if (SONOFF_L1 == TasmotaGlobal.module_type) {
if (PinUsed(GPIO_RXD) && PinUsed(GPIO_TXD)) {
Snfl1.buffer = (char*)malloc(SONOFF_L1_BUFFER_SIZE);
if (Snfl1.buffer) {
SetSerial(19200, TS_SERIAL_8N1);
Snfl1.power = !Light.power;
Snfl1.dimmer = !light_state.getDimmer();
Snfl1.sensitive = 5; // 1..10
Snfl1.speed = 50; // 1..100
TasmotaGlobal.light_type = LT_RGB;
TasmotaGlobal.light_driver = XLGT_05;
AddLog(LOG_LEVEL_DEBUG, PSTR("LGT: Sonoff L1 Found"));
return true;
}
}
}
return false;
}
void CmndMusicSync(void) {
// Format is L1MusicSync on/off/toggle, sensitivity, speed
// sensitivity 1..10, speed 1..100
if (XdrvMailbox.data_len > 0) {
Snfl1.old_music_sync = Settings->sbflag1.sonoff_l1_music_sync;
uint32_t parm[3] = { 0 };
ParseParameters(3, parm);
if (2 == parm[0]) {
Settings->sbflag1.sonoff_l1_music_sync ^= 1; // Toggle
} else {
Settings->sbflag1.sonoff_l1_music_sync = parm[0] & 1; // On or Off
}
if ((parm[1] > 0) && (parm[1] < 11)) {
Snfl1.sensitive = parm[1]; // 1..10
}
if ((parm[2] > 0) && (parm[2] < 101)) {
Snfl1.speed = parm[2]; // 1..100
}
SnfL1SetChannels(false);
}
Response_P(PSTR("{\"%s\":{\"Mode\":\"%s\",\"Sensitive\":%d,\"Speed\":%d}}"),
XdrvMailbox.command, GetStateText(Settings->sbflag1.sonoff_l1_music_sync), Snfl1.sensitive, Snfl1.speed);
}
/*********************************************************************************************\
* Interface
\*********************************************************************************************/
bool Xlgt05(uint32_t function)
{
bool result = false;
switch (function) {
case FUNC_SERIAL:
result = SnfL1SerialInput();
break;
case FUNC_SET_CHANNELS:
result = SnfL1SetChannelsFromFunc();
break;
case FUNC_MODULE_INIT:
result = SnfL1ModuleSelected();
break;
case FUNC_COMMAND:
result = DecodeCommand(kL1Commands, L1Command);
break;
}
return result;
}
#endif // USE_SONOFF_L1
#endif // USE_LIGHT
Reference in New Issue View Git Blame Copy Permalink