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

Remove AddLog_P in favour of AddLog 

Remove AddLog_P in favour of AddLog switching log from stack to heap allowing longer log entries (up to approximate log buffer size)
This commit is contained in:
Theo Arends 2021-06-05 11:47:09 +02:00
parent 22c9f2ece2
commit ebeb4ea7ff
54 changed files with 1016 additions and 288 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
tasmota/sendemail_ESP32.ino
View File

@ -151,7 +151,7 @@ uint16_t SendMail(char *buffer) {
#endif
#ifdef DEBUG_EMAIL_PORT
AddLog_P(LOG_LEVEL_INFO, PSTR("%s - %d - %s - %s"), mserv, port, user, passwd);
AddLog(LOG_LEVEL_INFO, PSTR("%s - %d - %s - %s"), mserv, port, user, passwd);
#endif
#ifdef EMAIL_FROM
@ -161,7 +161,7 @@ uint16_t SendMail(char *buffer) {
#endif
#ifdef DEBUG_EMAIL_PORT
AddLog_P(LOG_LEVEL_INFO, PSTR("%s - %s - %s - %s"), from, to, subject, cmd);
AddLog(LOG_LEVEL_INFO, PSTR("%s - %s - %s - %s"), from, to, subject, cmd);
#endif

44
tasmota/sendemail_ESP8266.ino
View File

@ -162,7 +162,7 @@ uint16_t SendMail(char *buffer) {
#endif
#ifdef DEBUG_EMAIL_PORT
AddLog_P(LOG_LEVEL_INFO, PSTR("%s - %s - %s - %s"),from,to,subject,cmd);
AddLog(LOG_LEVEL_INFO, PSTR("%s - %s - %s - %s"),from,to,subject,cmd);
#endif
if (mail) {
@ -217,7 +217,7 @@ String buffer;
buffer = readClient();
#ifdef DEBUG_EMAIL_PORT
AddLog_P(LOG_LEVEL_INFO, PSTR("%s"),buffer.c_str());
AddLog(LOG_LEVEL_INFO, PSTR("%s"),buffer.c_str());
#endif
if (!buffer.startsWith(F("220"))) {
goto exit;
@ -228,11 +228,11 @@ String buffer;
client->println(buffer);
#ifdef DEBUG_EMAIL_PORT
AddLog_P(LOG_LEVEL_INFO, PSTR("%s"),buffer.c_str());
AddLog(LOG_LEVEL_INFO, PSTR("%s"),buffer.c_str());
#endif
buffer = readClient();
#ifdef DEBUG_EMAIL_PORT
AddLog_P(LOG_LEVEL_INFO, PSTR("%s"),buffer.c_str());
AddLog(LOG_LEVEL_INFO, PSTR("%s"),buffer.c_str());
#endif
if (!buffer.startsWith(F("250"))) {
goto exit;
@ -242,11 +242,11 @@ String buffer;
buffer = F("AUTH LOGIN");
client->println(buffer);
#ifdef DEBUG_EMAIL_PORT
AddLog_P(LOG_LEVEL_INFO, PSTR("%s"),buffer.c_str());
AddLog(LOG_LEVEL_INFO, PSTR("%s"),buffer.c_str());
#endif
buffer = readClient();
#ifdef DEBUG_EMAIL_PORT
AddLog_P(LOG_LEVEL_INFO, PSTR("%s"),buffer.c_str());
AddLog(LOG_LEVEL_INFO, PSTR("%s"),buffer.c_str());
#endif
if (!buffer.startsWith(F("334")))
{
@ -257,11 +257,11 @@ String buffer;
client->println(buffer);
#ifdef DEBUG_EMAIL_PORT
AddLog_P(LOG_LEVEL_INFO, PSTR("%s"),buffer.c_str());
AddLog(LOG_LEVEL_INFO, PSTR("%s"),buffer.c_str());
#endif
buffer = readClient();
#ifdef DEBUG_EMAIL_PORT
AddLog_P(LOG_LEVEL_INFO, PSTR("%s"),buffer.c_str());
AddLog(LOG_LEVEL_INFO, PSTR("%s"),buffer.c_str());
#endif
if (!buffer.startsWith(F("334"))) {
goto exit;
@ -269,11 +269,11 @@ String buffer;
buffer = b.encode(passwd);
client->println(buffer);
#ifdef DEBUG_EMAIL_PORT
AddLog_P(LOG_LEVEL_INFO, PSTR("%s"),buffer.c_str());
AddLog(LOG_LEVEL_INFO, PSTR("%s"),buffer.c_str());
#endif
buffer = readClient();
#ifdef DEBUG_EMAIL_PORT
AddLog_P(LOG_LEVEL_INFO, PSTR("%s"),buffer.c_str());
AddLog(LOG_LEVEL_INFO, PSTR("%s"),buffer.c_str());
#endif
if (!buffer.startsWith(F("235"))) {
goto exit;
@ -285,11 +285,11 @@ String buffer;
buffer += from;
client->println(buffer);
#ifdef DEBUG_EMAIL_PORT
AddLog_P(LOG_LEVEL_INFO, PSTR("%s"),buffer.c_str());
AddLog(LOG_LEVEL_INFO, PSTR("%s"),buffer.c_str());
#endif
buffer = readClient();
#ifdef DEBUG_EMAIL_PORT
AddLog_P(LOG_LEVEL_INFO, PSTR("%s"),buffer.c_str());
AddLog(LOG_LEVEL_INFO, PSTR("%s"),buffer.c_str());
#endif
if (!buffer.startsWith(F("250"))) {
goto exit;
@ -298,11 +298,11 @@ String buffer;
buffer += to;
client->println(buffer);
#ifdef DEBUG_EMAIL_PORT
AddLog_P(LOG_LEVEL_INFO, PSTR("%s"),buffer.c_str());
AddLog(LOG_LEVEL_INFO, PSTR("%s"),buffer.c_str());
#endif
buffer = readClient();
#ifdef DEBUG_EMAIL_PORT
AddLog_P(LOG_LEVEL_INFO, PSTR("%s"),buffer.c_str());
AddLog(LOG_LEVEL_INFO, PSTR("%s"),buffer.c_str());
#endif
if (!buffer.startsWith(F("250"))) {
goto exit;
@ -311,11 +311,11 @@ String buffer;
buffer = F("DATA");
client->println(buffer);
#ifdef DEBUG_EMAIL_PORT
AddLog_P(LOG_LEVEL_INFO, PSTR("%s"),buffer.c_str());
AddLog(LOG_LEVEL_INFO, PSTR("%s"),buffer.c_str());
#endif
buffer = readClient();
#ifdef DEBUG_EMAIL_PORT
AddLog_P(LOG_LEVEL_INFO, PSTR("%s"),buffer.c_str());
AddLog(LOG_LEVEL_INFO, PSTR("%s"),buffer.c_str());
#endif
if (!buffer.startsWith(F("354"))) {
goto exit;
@ -325,19 +325,19 @@ String buffer;
buffer += from;
client->println(buffer);
#ifdef DEBUG_EMAIL_PORT
AddLog_P(LOG_LEVEL_INFO, PSTR("%s"),buffer.c_str());
AddLog(LOG_LEVEL_INFO, PSTR("%s"),buffer.c_str());
#endif
buffer = F("To: ");
buffer += to;
client->println(buffer);
#ifdef DEBUG_EMAIL_PORT
AddLog_P(LOG_LEVEL_INFO, PSTR("%s"),buffer.c_str());
AddLog(LOG_LEVEL_INFO, PSTR("%s"),buffer.c_str());
#endif
buffer = F("Subject: ");
buffer += subject;
client->println(buffer);
#ifdef DEBUG_EMAIL_PORT
AddLog_P(LOG_LEVEL_INFO, PSTR("%s"),buffer.c_str());
AddLog(LOG_LEVEL_INFO, PSTR("%s"),buffer.c_str());
#endif
#ifdef USE_SCRIPT
@ -359,13 +359,13 @@ String buffer;
#endif
client->println('.');
#ifdef DEBUG_EMAIL_PORT
AddLog_P(LOG_LEVEL_INFO, PSTR("%s"),buffer.c_str());
AddLog(LOG_LEVEL_INFO, PSTR("%s"),buffer.c_str());
#endif
buffer = F("QUIT");
client->println(buffer);
#ifdef DEBUG_EMAIL_PORT
AddLog_P(LOG_LEVEL_INFO, PSTR("%s"),buffer.c_str());
AddLog(LOG_LEVEL_INFO, PSTR("%s"),buffer.c_str());
#endif
status=true;
@ -378,7 +378,7 @@ exit:
void xsend_message_txt(char *msg) {
#ifdef DEBUG_EMAIL_PORT
AddLog_P(LOG_LEVEL_INFO, PSTR("%s"),msg);
AddLog(LOG_LEVEL_INFO, PSTR("%s"),msg);
#endif
#ifdef USE_UFILESYS

45
tasmota/support.ino
View File

@ -1608,7 +1608,7 @@ bool JsonTemplate(char* dataBuf)
// Old: {"NAME":"Shelly 2.5","GPIO":[56,0,17,0,21,83,0,0,6,82,5,22,156],"FLAG":2,"BASE":18}
// New: {"NAME":"Shelly 2.5","GPIO":[320,0,32,0,224,193,0,0,640,192,608,225,3456,4736],"FLAG":0,"BASE":18}
// AddLog_P(LOG_LEVEL_DEBUG, PSTR("TPL: |%s|"), dataBuf);
// AddLog(LOG_LEVEL_DEBUG, PSTR("TPL: |%s|"), dataBuf);
if (strlen(dataBuf) < 9) { return false; } // Workaround exception if empty JSON like {} - Needs checks
@ -2343,55 +2343,20 @@ void AddLogData(uint32_t loglevel, const char* log_data) {
}
void AddLog(uint32_t loglevel, PGM_P formatP, ...) {
// To save stack space support logging for max text length of 128 characters
char log_data[LOGSZ +4];
va_list arg;
va_start(arg, formatP);
uint32_t len = ext_vsnprintf_P(log_data, LOGSZ +1, formatP, arg);
char* log_data = ext_vsnprintf_malloc_P(formatP, arg);
va_end(arg);
if (len > LOGSZ) { strcat(log_data, "..."); } // Actual data is more
#ifdef DEBUG_TASMOTA_CORE
// Profile max_len
static uint32_t max_len = 0;
if (len > max_len) {
max_len = len;
Serial.printf("PRF: AddLog %d\n", max_len);
}
#endif
if (log_data == nullptr) { return; }
AddLogData(loglevel, log_data);
}
void AddLog_P(uint32_t loglevel, PGM_P formatP, ...) {
// Use more stack space to support logging for max text length of 700 characters
char log_data[MAX_LOGSZ];
va_list arg;
va_start(arg, formatP);
uint32_t len = ext_vsnprintf_P(log_data, sizeof(log_data), formatP, arg);
va_end(arg);
AddLogData(loglevel, log_data);
}
void AddLog_Debug(PGM_P formatP, ...)
{
char log_data[MAX_LOGSZ];
va_list arg;
va_start(arg, formatP);
uint32_t len = ext_vsnprintf_P(log_data, sizeof(log_data), formatP, arg);
va_end(arg);
AddLogData(LOG_LEVEL_DEBUG, log_data);
free(log_data);
}
void AddLogBuffer(uint32_t loglevel, uint8_t *buffer, uint32_t count)
{
char hex_char[(count * 3) + 2];
AddLog_P(loglevel, PSTR("DMP: %s"), ToHex_P(buffer, count, hex_char, sizeof(hex_char), ' '));
AddLog(loglevel, PSTR("DMP: %s"), ToHex_P(buffer, count, hex_char, sizeof(hex_char), ' '));
}
void AddLogSerial(uint32_t loglevel)

2
tasmota/support_command.ino
View File

@ -240,7 +240,7 @@ void CommandHandler(char* topicBuf, char* dataBuf, uint32_t data_len)
}
}
AddLog_P(LOG_LEVEL_DEBUG, PSTR("CMD: Grp %d, Cmnd '%s', Idx %d, Len %d, Data '%s'"),
AddLog(LOG_LEVEL_DEBUG, PSTR("CMD: Grp %d, Cmnd '%s', Idx %d, Len %d, Data '%s'"),
grpflg, type, index, data_len, (binary_data) ? HexToString((uint8_t*)dataBuf, data_len).c_str() : dataBuf);
if (type != nullptr) {

2
tasmota/support_tasmota.ino
View File

@ -1554,7 +1554,7 @@ void SerialInput(void)
if (serial_buffer_overrun) {
AddLog(LOG_LEVEL_INFO, PSTR(D_LOG_COMMAND "Serial buffer overrun"));
} else {
AddLog_P(LOG_LEVEL_INFO, PSTR(D_LOG_COMMAND "%s"), TasmotaGlobal.serial_in_buffer);
AddLog(LOG_LEVEL_INFO, PSTR(D_LOG_COMMAND "%s"), TasmotaGlobal.serial_in_buffer);
ExecuteCommand(TasmotaGlobal.serial_in_buffer, SRC_SERIAL);
}
TasmotaGlobal.serial_in_byte_counter = 0;

4
tasmota/support_udp.ino
View File

@ -132,7 +132,7 @@ void PollUdp(void)
AddLog(LOG_LEVEL_DEBUG_MORE, PSTR("UDP: Packet (%d/%d)"), len, pack_len);
#endif // ESP32
// AddLog_P(LOG_LEVEL_DEBUG_MORE, PSTR("\n%s"), packet_buffer);
// AddLog(LOG_LEVEL_DEBUG_MORE, PSTR("\n%s"), packet_buffer);
// Simple Service Discovery Protocol (SSDP)
if (Settings.flag2.emulation) {
@ -151,7 +151,7 @@ void PollUdp(void)
udp_remote_port = PortUdp.remotePort();
#endif
// AddLog_P(LOG_LEVEL_DEBUG_MORE, PSTR("UDP: M-SEARCH Packet from %_I:%d\n%s"),
// AddLog(LOG_LEVEL_DEBUG_MORE, PSTR("UDP: M-SEARCH Packet from %_I:%d\n%s"),
// (uint32_t)udp_remote_ip, udp_remote_port, packet_buffer);
LowerCase(packet_buffer, packet_buffer);

8
tasmota/tasmota_globals.h
View File

@ -483,22 +483,22 @@ bool first_device_group_is_local = true;
#endif // USE_DEVICE_GROUPS
#ifdef DEBUG_TASMOTA_CORE
#define DEBUG_CORE_LOG(...) AddLog_Debug(__VA_ARGS__)
#define DEBUG_CORE_LOG(...) AddLog(LOG_LEVEL_DEBUG, __VA_ARGS__)
#else
#define DEBUG_CORE_LOG(...)
#endif
#ifdef DEBUG_TASMOTA_DRIVER
#define DEBUG_DRIVER_LOG(...) AddLog_Debug(__VA_ARGS__)
#define DEBUG_DRIVER_LOG(...) AddLog(LOG_LEVEL_DEBUG, __VA_ARGS__)
#else
#define DEBUG_DRIVER_LOG(...)
#endif
#ifdef DEBUG_TASMOTA_SENSOR
#define DEBUG_SENSOR_LOG(...) AddLog_Debug(__VA_ARGS__)
#define DEBUG_SENSOR_LOG(...) AddLog(LOG_LEVEL_DEBUG, __VA_ARGS__)
#else
#define DEBUG_SENSOR_LOG(...)
#endif
#ifdef DEBUG_TASMOTA_TRACE
#define DEBUG_TRACE_LOG(...) AddLog_Debug(__VA_ARGS__)
#define DEBUG_TRACE_LOG(...) AddLog(LOG_LEVEL_DEBUG, __VA_ARGS__)
#else
#define DEBUG_TRACE_LOG(...)
#endif

6
tasmota/xdrv_01_webserver.ino
View File

@ -2881,7 +2881,7 @@ void HandleConsoleRefresh(void)
{
String svalue = Webserver->arg(F("c1"));
if (svalue.length() && (svalue.length() < MQTT_MAX_PACKET_SIZE)) {
AddLog_P(LOG_LEVEL_INFO, PSTR(D_LOG_COMMAND "%s"), svalue.c_str());
AddLog(LOG_LEVEL_INFO, PSTR(D_LOG_COMMAND "%s"), svalue.c_str());
ExecuteWebCommand((char*)svalue.c_str(), SRC_WEBCONSOLE);
}
@ -3246,11 +3246,11 @@ bool Xdrv01(uint8_t function)
}
if (Web.wifi_test_counter) {
Web.wifi_test_counter--;
AddLog_P(LOG_LEVEL_DEBUG, PSTR(D_LOG_WIFI D_TRYING_TO_CONNECT " %s"), SettingsText(SET_STASSID1));
AddLog(LOG_LEVEL_DEBUG, PSTR(D_LOG_WIFI D_TRYING_TO_CONNECT " %s"), SettingsText(SET_STASSID1));
if ( WifiCheck_hasIP(WiFi.localIP()) ) { // Got IP - Connection Established
Web.wifi_test_counter = 0;
Web.wifiTest = WIFI_TEST_FINISHED_SUCCESSFUL;
AddLog_P(LOG_LEVEL_INFO, PSTR(D_LOG_WIFI D_CMND_SSID "1 %s: " D_CONNECTED " - " D_IP_ADDRESS " %_I"), SettingsText(SET_STASSID1), (uint32_t)WiFi.localIP());
AddLog(LOG_LEVEL_INFO, PSTR(D_LOG_WIFI D_CMND_SSID "1 %s: " D_CONNECTED " - " D_IP_ADDRESS " %_I"), SettingsText(SET_STASSID1), (uint32_t)WiFi.localIP());
// TasmotaGlobal.blinks = 255; // Signal wifi connection with blinks
if (MAX_WIFI_OPTION != Web.old_wificonfig) {
TasmotaGlobal.wifi_state_flag = Settings.sta_config = Web.old_wificonfig;

4
tasmota/xdrv_04_light.ino
View File

@ -1138,7 +1138,7 @@ void LightInit(void)
}
LightCalcPWMRange();
#ifdef DEBUG_LIGHT
AddLog_P(LOG_LEVEL_DEBUG_MORE, "LightInit Light.pwm_multi_channels=%d Light.subtype=%d Light.device=%d TasmotaGlobal.devices_present=%d",
AddLog(LOG_LEVEL_DEBUG_MORE, "LightInit Light.pwm_multi_channels=%d Light.subtype=%d Light.device=%d TasmotaGlobal.devices_present=%d",
Light.pwm_multi_channels, Light.subtype, Light.device, TasmotaGlobal.devices_present);
#endif
@ -1637,7 +1637,7 @@ void LightSetPower(void)
Light.wakeup_active--;
}
#ifdef DEBUG_LIGHT
AddLog_P(LOG_LEVEL_DEBUG_MORE, "LightSetPower XdrvMailbox.index=%d Light.old_power=%d Light.power=%d mask=%d shift=%d",
AddLog(LOG_LEVEL_DEBUG_MORE, "LightSetPower XdrvMailbox.index=%d Light.old_power=%d Light.power=%d mask=%d shift=%d",
XdrvMailbox.index, Light.old_power, Light.power, mask, shift);
#endif
if (Light.power != Light.old_power) {

2
tasmota/xdrv_05_irremote_full.ino
View File

@ -381,7 +381,7 @@ uint32_t IrRemoteCmndIrHvacJson(void)
{
stdAc::state_t state;
//AddLog_P(LOG_LEVEL_DEBUG, PSTR("IRHVAC: Received %s"), XdrvMailbox.data);
//AddLog(LOG_LEVEL_DEBUG, PSTR("IRHVAC: Received %s"), XdrvMailbox.data);
JsonParser parser(XdrvMailbox.data);
JsonParserObject root = parser.getRootObject();
if (!root) { return IE_INVALID_JSON; }

2
tasmota/xdrv_07_domoticz.ino
View File

@ -315,7 +315,7 @@ bool DomoticzMqttData(void) {
}
if (!found) { return true; } // No command received
AddLog_P(LOG_LEVEL_DEBUG_MORE, PSTR(D_LOG_DOMOTICZ D_RECEIVED_TOPIC " %s, " D_DATA " %s"), XdrvMailbox.topic, XdrvMailbox.data);
AddLog(LOG_LEVEL_DEBUG_MORE, PSTR(D_LOG_DOMOTICZ D_RECEIVED_TOPIC " %s, " D_DATA " %s"), XdrvMailbox.topic, XdrvMailbox.data);
domoticz_update_flag = false;
return false; // Process new data

32
tasmota/xdrv_10_rules.ino
View File

@ -434,7 +434,7 @@ bool RulesRuleMatch(uint8_t rule_set, String &event, String &rule, bool stop_all
// rule_param = "0.100" or "%VAR1%"
#ifdef DEBUG_RULES
AddLog_P(LOG_LEVEL_DEBUG, PSTR("RUL-RM1: Teleperiod %d, Expr %s, Name %s, Param %s"), Rules.teleperiod, rule_expr.c_str(), rule_name.c_str(), rule_param.c_str());
AddLog(LOG_LEVEL_DEBUG, PSTR("RUL-RM1: Teleperiod %d, Expr %s, Name %s, Param %s"), Rules.teleperiod, rule_expr.c_str(), rule_name.c_str(), rule_param.c_str());
#endif
char rule_svalue[80] = { 0 };
@ -510,13 +510,13 @@ bool RulesRuleMatch(uint8_t rule_set, String &event, String &rule, bool stop_all
String buf = event; // Copy the string into a new buffer that will be modified
//AddLog_P(LOG_LEVEL_DEBUG, PSTR("RUL-RM2: RulesRuleMatch |%s|"), buf.c_str());
//AddLog(LOG_LEVEL_DEBUG, PSTR("RUL-RM2: RulesRuleMatch |%s|"), buf.c_str());
buf.replace("\\"," "); // "Disable" any escaped control character
JsonParser parser((char*)buf.c_str());
JsonParserObject obj = parser.getRootObject();
if (!obj) {
// AddLog_P(LOG_LEVEL_DEBUG, PSTR("RUL: Event too long (%d)"), event.length());
// AddLog(LOG_LEVEL_DEBUG, PSTR("RUL: Event too long (%d)"), event.length());
AddLog(LOG_LEVEL_DEBUG, PSTR("RUL: No valid JSON (%s)"), buf.c_str());
return false; // No valid JSON data
}
@ -547,7 +547,7 @@ bool RulesRuleMatch(uint8_t rule_set, String &event, String &rule, bool stop_all
}
#ifdef DEBUG_RULES
AddLog_P(LOG_LEVEL_DEBUG, PSTR("RUL-RM3: Name %s, Value |%s|, TrigCnt %d, TrigSt %d, Source %s, Json |%s|"),
AddLog(LOG_LEVEL_DEBUG, PSTR("RUL-RM3: Name %s, Value |%s|, TrigCnt %d, TrigSt %d, Source %s, Json |%s|"),
rule_name.c_str(), rule_svalue, Rules.trigger_count[rule_set], bitRead(Rules.triggers[rule_set],
Rules.trigger_count[rule_set]), event.c_str(), (str_value[0] != '\0') ? str_value : "none");
#endif
@ -608,7 +608,7 @@ bool RulesRuleMatch(uint8_t rule_set, String &event, String &rule, bool stop_all
if (stop_all_rules) { match = false; }
//AddLog_P(LOG_LEVEL_DEBUG, PSTR("RUL-RM4: Match 1 %d, Triggers %08X, TriggerCount %d"), match, Rules.triggers[rule_set], Rules.trigger_count[rule_set]);
//AddLog(LOG_LEVEL_DEBUG, PSTR("RUL-RM4: Match 1 %d, Triggers %08X, TriggerCount %d"), match, Rules.triggers[rule_set], Rules.trigger_count[rule_set]);
if (bitRead(Settings.rule_once, rule_set)) {
if (match) { // Only allow match state changes
@ -622,7 +622,7 @@ bool RulesRuleMatch(uint8_t rule_set, String &event, String &rule, bool stop_all
}
}
//AddLog_P(LOG_LEVEL_DEBUG, PSTR("RUL-RM5: Match 2 %d, Triggers %08X, TriggerCount %d"), match, Rules.triggers[rule_set], Rules.trigger_count[rule_set]);
//AddLog(LOG_LEVEL_DEBUG, PSTR("RUL-RM5: Match 2 %d, Triggers %08X, TriggerCount %d"), match, Rules.triggers[rule_set], Rules.trigger_count[rule_set]);
return match;
}
@ -694,7 +694,7 @@ bool RuleSetProcess(uint8_t rule_set, String &event_saved)
delay(0); // Prohibit possible loop software watchdog
//AddLog_P(LOG_LEVEL_DEBUG, PSTR("RUL-RP1: Event = %s, Rule = %s"), event_saved.c_str(), Settings.rules[rule_set]);
//AddLog(LOG_LEVEL_DEBUG, PSTR("RUL-RP1: Event = %s, Rule = %s"), event_saved.c_str(), Settings.rules[rule_set]);
String rules = GetRule(rule_set);
@ -728,7 +728,7 @@ bool RuleSetProcess(uint8_t rule_set, String &event_saved)
String event = event_saved;
#ifdef DEBUG_RULES
// AddLog_P(LOG_LEVEL_DEBUG, PSTR("RUL-RP2: Event |%s|, Rule |%s|, Command(s) |%s|"), event.c_str(), event_trigger.c_str(), commands.c_str());
// AddLog(LOG_LEVEL_DEBUG, PSTR("RUL-RP2: Event |%s|, Rule |%s|, Command(s) |%s|"), event.c_str(), event_trigger.c_str(), commands.c_str());
#endif
if (RulesRuleMatch(rule_set, event, event_trigger, stop_all_rules)) {
@ -808,7 +808,7 @@ bool RulesProcessEvent(char *json_event)
ShowFreeMem(PSTR("RulesProcessEvent"));
#endif
//AddLog_P(LOG_LEVEL_DEBUG, PSTR("RUL: ProcessEvent |%s|"), json_event);
//AddLog(LOG_LEVEL_DEBUG, PSTR("RUL: ProcessEvent |%s|"), json_event);
String event_saved = json_event;
// json_event = {"INA219":{"Voltage":4.494,"Current":0.020,"Power":0.089}}
@ -822,7 +822,7 @@ bool RulesProcessEvent(char *json_event)
}
event_saved.toUpperCase();
//AddLog_P(LOG_LEVEL_DEBUG, PSTR("RUL: Event |%s|"), event_saved.c_str());
//AddLog(LOG_LEVEL_DEBUG, PSTR("RUL: Event |%s|"), event_saved.c_str());
for (uint32_t i = 0; i < MAX_RULE_SETS; i++) {
if (GetRuleLen(i) && bitRead(Settings.rule_enabled, i)) {
@ -1050,13 +1050,13 @@ bool RulesMqttData(void)
bool serviced = false;
String sTopic = XdrvMailbox.topic;
String sData = XdrvMailbox.data;
//AddLog_P(LOG_LEVEL_DEBUG, PSTR("RUL: MQTT Topic %s, Event %s"), XdrvMailbox.topic, XdrvMailbox.data);
//AddLog(LOG_LEVEL_DEBUG, PSTR("RUL: MQTT Topic %s, Event %s"), XdrvMailbox.topic, XdrvMailbox.data);
MQTT_Subscription event_item;
//Looking for matched topic
for (uint32_t index = 0; index < subscriptions.size(); index++) {
event_item = subscriptions.get(index);
//AddLog_P(LOG_LEVEL_DEBUG, PSTR("RUL: Match MQTT message Topic %s with subscription topic %s"), sTopic.c_str(), event_item.Topic.c_str());
//AddLog(LOG_LEVEL_DEBUG, PSTR("RUL: Match MQTT message Topic %s with subscription topic %s"), sTopic.c_str(), event_item.Topic.c_str());
if (sTopic.startsWith(event_item.Topic)) {
//This topic is subscribed by us, so serve it
serviced = true;
@ -1133,7 +1133,7 @@ void CmndSubscribe(void)
}
}
}
//AddLog_P(LOG_LEVEL_DEBUG, PSTR("RUL: Subscribe command with parameters: %s, %s, %s."), event_name.c_str(), topic.c_str(), key.c_str());
//AddLog(LOG_LEVEL_DEBUG, PSTR("RUL: Subscribe command with parameters: %s, %s, %s."), event_name.c_str(), topic.c_str(), key.c_str());
event_name.toUpperCase();
if (event_name.length() > 0 && topic.length() > 0) {
//Search all subscriptions
@ -1154,7 +1154,7 @@ void CmndSubscribe(void)
topic.concat("/#");
}
}
//AddLog_P(LOG_LEVEL_DEBUG, PSTR("RUL: New topic: %s."), topic.c_str());
//AddLog(LOG_LEVEL_DEBUG, PSTR("RUL: New topic: %s."), topic.c_str());
//MQTT Subscribe
subscription_item.Event = event_name;
subscription_item.Topic = topic.substring(0, topic.length() - 2); //Remove "/#" so easy to match
@ -1753,7 +1753,7 @@ bool evaluateLogicalExpression(const char * expression, int len)
memcpy(expbuff, expression, len);
expbuff[len] = '\0';
//AddLog_P(LOG_LEVEL_DEBUG, PSTR("EvalLogic: |%s|"), expbuff);
//AddLog(LOG_LEVEL_DEBUG, PSTR("EvalLogic: |%s|"), expbuff);
char * pointer = expbuff;
LinkedList<bool> values;
LinkedList<int8_t> logicOperators;
@ -1879,7 +1879,7 @@ void ExecuteCommandBlock(const char * commands, int len)
memcpy(cmdbuff, commands, len);
cmdbuff[len] = '\0';
//AddLog_P(LOG_LEVEL_DEBUG, PSTR("ExecCmd: |%s|"), cmdbuff);
//AddLog(LOG_LEVEL_DEBUG, PSTR("ExecCmd: |%s|"), cmdbuff);
char oneCommand[len + 1]; //To put one command
int insertPosition = 0; //When insert into backlog, we should do it by 0, 1, 2 ...
char * pos = cmdbuff;

4
tasmota/xdrv_10_scripter.ino
View File

@ -7788,7 +7788,7 @@ String request;
request = String("POST ") + "/api/login/Basic" + " HTTP/1.1\r\n" + "Host: " + host + "\r\n" + cert + "\r\n" + "Content-Type: application/json" + "\r\n";
httpsClient->print(request);
AddLog_P(LOG_LEVEL_INFO,PSTR(">>> post request %s"),(char*)request.c_str());
AddLog(LOG_LEVEL_INFO,PSTR(">>> post request %s"),(char*)request.c_str());
String line = httpsClient->readStringUntil('\n');
AddLog(LOG_LEVEL_INFO,PSTR(">>> post response 1a %s"),(char*)line.c_str());
@ -7801,7 +7801,7 @@ String request;
"Host: " + host +
"\r\n" + "Connection: close\r\n\r\n";
httpsClient->print(request);
// AddLog_P(LOG_LEVEL_INFO,PSTR(">>> get request %s"),(char*)request.c_str());
// AddLog(LOG_LEVEL_INFO,PSTR(">>> get request %s"),(char*)request.c_str());
while (httpsClient->connected()) {
String line = httpsClient->readStringUntil('\n');

8
tasmota/xdrv_12_home_assistant.ino
View File

@ -366,7 +366,7 @@ void TryResponseAppend_P(const char *format, ...)
int slen = ResponseSize() - 1 - mlen;
if (dlen >= slen)
{
AddLog_P(LOG_LEVEL_ERROR, PSTR("%s (%u/%u):"), kHAssError1, dlen, slen);
AddLog(LOG_LEVEL_ERROR, PSTR("%s (%u/%u):"), kHAssError1, dlen, slen);
va_start(args, format);
char log_data[MAX_LOGSZ];
vsnprintf_P(log_data, sizeof(log_data), format, args);
@ -469,7 +469,7 @@ void HAssAnnounceRelayLight(void)
// suppress shutter relays
} else if ((i < Light.device) && !RelayX) {
err_flag = true;
AddLog_P(LOG_LEVEL_ERROR, PSTR("%s"), kHAssError2);
AddLog(LOG_LEVEL_ERROR, PSTR("%s"), kHAssError2);
} else {
if (Settings.flag.hass_discovery && (RelayX || (Light.device > 0) && (max_lights > 0)) && !err_flag )
{ // SetOption19 - Control Home Assistant automatic discovery (See SetOption59)
@ -898,7 +898,7 @@ void HAssAnnounceSensors(void)
JsonParserObject root = parser.getRootObject();
if (!root)
{
AddLog_P(LOG_LEVEL_ERROR, PSTR("%s '%s' (ERR1)"), kHAssError3, sensordata);
AddLog(LOG_LEVEL_ERROR, PSTR("%s '%s' (ERR1)"), kHAssError3, sensordata);
continue;
}
for (auto sensor_key : root)
@ -909,7 +909,7 @@ void HAssAnnounceSensors(void)
if (!sensors)
{
AddLog_P(LOG_LEVEL_ERROR, PSTR("%s '%s' (ERR2)"), kHAssError3, sensorname);
AddLog(LOG_LEVEL_ERROR, PSTR("%s '%s' (ERR2)"), kHAssError3, sensorname);
continue;
}

2
tasmota/xdrv_13_display.ino
View File

@ -1621,7 +1621,7 @@ void DisplayJsonValue(const char* topic, const char* device, const char* mkey, c
}
snprintf_P(buffer, sizeof(buffer), PSTR("%s %s"), source, svalue);
// AddLog_P(LOG_LEVEL_DEBUG, PSTR(D_LOG_DEBUG "mkey [%s], source [%s], value [%s], quantity_code %d, log_buffer [%s]"), mkey, source, value, quantity_code, buffer);
// AddLog(LOG_LEVEL_DEBUG, PSTR(D_LOG_DEBUG "mkey [%s], source [%s], value [%s], quantity_code %d, log_buffer [%s]"), mkey, source, value, quantity_code, buffer);
DisplayLogBufferAdd(buffer);
}

2
tasmota/xdrv_16_tuyamcu.ino
View File

@ -1227,7 +1227,7 @@ void TuyaSerialInput(void)
if (Settings.flag3.tuya_serial_mqtt_publish) { // SetOption66 - Enable TuyaMcuReceived messages over Mqtt
MqttPublishPrefixTopic_P(RESULT_OR_TELE, PSTR(D_JSON_TUYA_MCU_RECEIVED));
} else {
AddLog_P(LOG_LEVEL_DEBUG, TasmotaGlobal.mqtt_data);
AddLog(LOG_LEVEL_DEBUG, TasmotaGlobal.mqtt_data);
}
XdrvRulesProcess(0);

2
tasmota/xdrv_17_rcswitch.ino
View File

@ -100,7 +100,7 @@ void RfInit(void) {
void CmndRfProtocol(void) {
if (!PinUsed(GPIO_RFRECV)) { return; }
// AddLog_P(LOG_LEVEL_INFO, PSTR("RFR:CmndRfRxProtocol:: index:%d usridx:%d data_len:%d data:\"%s\""),XdrvMailbox.index, XdrvMailbox.usridx, XdrvMailbox.data_len,XdrvMailbox.data);
// AddLog(LOG_LEVEL_INFO, PSTR("RFR:CmndRfRxProtocol:: index:%d usridx:%d data_len:%d data:\"%s\""),XdrvMailbox.index, XdrvMailbox.usridx, XdrvMailbox.data_len,XdrvMailbox.data);
uint64_t thisdat;
if (1 == XdrvMailbox.usridx) {

8
tasmota/xdrv_20_hue.ino
View File

@ -207,17 +207,17 @@ void HueRespondToMSearch(void)
snprintf_P(response + len, sizeof(response) - len, msg[HUE_RESP_ST1], uuid.c_str());
PortUdp.write(response);
PortUdp.endPacket();
// AddLog_P(LOG_LEVEL_DEBUG_MORE, PSTR(D_LOG_UPNP "UDP resp=%s"), response);
// AddLog(LOG_LEVEL_DEBUG_MORE, PSTR(D_LOG_UPNP "UDP resp=%s"), response);
snprintf_P(response + len, sizeof(response) - len, msg[HUE_RESP_ST2], uuid.c_str(), uuid.c_str());
PortUdp.write(response);
PortUdp.endPacket();
// AddLog_P(LOG_LEVEL_DEBUG_MORE, PSTR(D_LOG_UPNP "UDP resp=%s"), response);
// AddLog(LOG_LEVEL_DEBUG_MORE, PSTR(D_LOG_UPNP "UDP resp=%s"), response);
snprintf_P(response + len, sizeof(response) - len, msg[HUE_RESP_ST3], uuid.c_str());
PortUdp.write(response);
PortUdp.endPacket();
// AddLog_P(LOG_LEVEL_DEBUG_MORE, PSTR(D_LOG_UPNP "UDP resp=%s"), response);
// AddLog(LOG_LEVEL_DEBUG_MORE, PSTR(D_LOG_UPNP "UDP resp=%s"), response);
snprintf_P(message, sizeof(message), PSTR(D_3_RESPONSE_PACKETS_SENT));
} else {
@ -1000,7 +1000,7 @@ void HueLights(String *path)
code = 406;
}
exit:
AddLog_P(LOG_LEVEL_DEBUG_MORE, PSTR(D_LOG_HTTP D_HUE " Result (%s)"), response.c_str());
AddLog(LOG_LEVEL_DEBUG_MORE, PSTR(D_LOG_HTTP D_HUE " Result (%s)"), response.c_str());
WSSend(code, CT_APP_JSON, response);
}

3
tasmota/xdrv_21_wemo_multi.ino
View File

@ -300,9 +300,8 @@ public:
} else {
snprintf_P(message, sizeof(message), PSTR(D_FAILED_TO_SEND_RESPONSE));
}
// Do not use AddLog_P here (interrupt routine) if syslog or mqttlog is enabled. UDP/TCP will force exception 9
AddLog(LOG_LEVEL_DEBUG, PSTR("WMO: WeMo Type %d, %s to %s:%d"),
echo_type, message, udp_remote_ip.toString().c_str(), udp_remote_port);
echo_type, message, udp_remote_ip.toString().c_str(), udp_remote_port);
}
void HandleServerLoop() {

2
tasmota/xdrv_23_zigbee_2a_devices_impl.ino
View File

@ -880,7 +880,7 @@ int32_t Z_Devices::deviceRestore(JsonParserObject json) {
data.setConfig(config);
}
} else {
AddLog_P(LOG_LEVEL_INFO, PSTR(D_LOG_ZIGBEE "Ignoring config '%s'"), conf_str);
AddLog(LOG_LEVEL_INFO, PSTR(D_LOG_ZIGBEE "Ignoring config '%s'"), conf_str);
}
}
}

2
tasmota/xdrv_23_zigbee_3_hue.ino
View File

@ -367,7 +367,7 @@ void ZigbeeHandleHue(uint16_t shortaddr, uint32_t device_id, String &response) {
else {
response = msg[HUE_ERROR_JSON];
}
AddLog_P(LOG_LEVEL_DEBUG_MORE, PSTR(D_LOG_HTTP D_HUE " Result (%s)"), response.c_str());
AddLog(LOG_LEVEL_DEBUG_MORE, PSTR(D_LOG_HTTP D_HUE " Result (%s)"), response.c_str());
WSSend(code, CT_APP_JSON, response);
free(buf);

24
tasmota/xdrv_23_zigbee_4a_nano_fs.ino
View File

@ -308,7 +308,7 @@ bool ZFS::findFileEntry(uint32_t name, ZFS_File_Entry & entry, uint8_t * _entry_
#ifdef Z_EEPROM_DEBUG
// {
// char hex_char[(sizeof(ZFS_File_Entry) * 2) + 2];
// AddLog_P(LOG_LEVEL_INFO, PSTR(D_LOG_ZIGBEE "Read entry %d at address 0x%04X contains %*_H"), entry_idx, entry_addr, sizeof(entry), &entry);
// AddLog(LOG_LEVEL_INFO, PSTR(D_LOG_ZIGBEE "Read entry %d at address 0x%04X contains %*_H"), entry_idx, entry_addr, sizeof(entry), &entry);
// }
#endif
if (entry.name == name) {
@ -341,7 +341,7 @@ void ZFS::erase(void) {
int32_t ZFS::readBytes(uint32_t name, void* buffer, size_t buffer_len, uint16_t read_start, uint16_t read_len) {
if (!zigbee.eeprom_ready) { return -1; }
#ifdef Z_EEPROM_DEBUG
// AddLog_P(LOG_LEVEL_INFO, PSTR(D_LOG_ZIGBEE "readBytes name=%08X, buffer_len=%d, read_start=0x%04X, read_len=%d"), name, buffer_len, read_start, read_len);
// AddLog(LOG_LEVEL_INFO, PSTR(D_LOG_ZIGBEE "readBytes name=%08X, buffer_len=%d, read_start=0x%04X, read_len=%d"), name, buffer_len, read_start, read_len);
#endif
if (name == 0x00000000) { return -1; }
if (buffer_len == 0) { return 0; }
@ -375,20 +375,20 @@ void ZFS::initOrFormat(void) {
if (!zigbee.eeprom_present) { return; }
#ifdef Z_EEPROM_DEBUG
// AddLog_P(LOG_LEVEL_INFO, PSTR(D_LOG_ZIGBEE "sizeof(ZFS_Bitmap)=%d sizeof(ZFS_File_Entry)=%d sizeof(ZFS_Root_Entry)=%d sizeof(ZFS_Dir_Block)=%d"), sizeof(ZFS_Bitmap), sizeof(ZFS_File_Entry), sizeof(ZFS_Root_Entry), sizeof(ZFS_Dir_Block));
// AddLog(LOG_LEVEL_INFO, PSTR(D_LOG_ZIGBEE "sizeof(ZFS_Bitmap)=%d sizeof(ZFS_File_Entry)=%d sizeof(ZFS_Root_Entry)=%d sizeof(ZFS_Dir_Block)=%d"), sizeof(ZFS_Bitmap), sizeof(ZFS_File_Entry), sizeof(ZFS_Root_Entry), sizeof(ZFS_Dir_Block));
{
byte map[256];
char hex_char[(256 * 2) + 2];
zigbee.eeprom.readBytes(0x0000, 256, map);
AddLog_P(LOG_LEVEL_INFO, PSTR(D_LOG_ZIGBEE "BLK 00 %s"), ToHex_P(map, sizeof(map), hex_char, sizeof(hex_char)));
AddLog(LOG_LEVEL_INFO, PSTR(D_LOG_ZIGBEE "BLK 00 %s"), ToHex_P(map, sizeof(map), hex_char, sizeof(hex_char)));
// zigbee.eeprom.readBytes(0x0100, 256, map);
// AddLog_P(LOG_LEVEL_INFO, PSTR(D_LOG_ZIGBEE "BLK 01 %s"), ToHex_P(map, sizeof(map), hex_char, sizeof(hex_char)));
// AddLog(LOG_LEVEL_INFO, PSTR(D_LOG_ZIGBEE "BLK 01 %s"), ToHex_P(map, sizeof(map), hex_char, sizeof(hex_char)));
zigbee.eeprom.readBytes(0x0200, 256, map);
AddLog_P(LOG_LEVEL_INFO, PSTR(D_LOG_ZIGBEE "BLK 02 %s"), ToHex_P(map, sizeof(map), hex_char, sizeof(hex_char)));
AddLog(LOG_LEVEL_INFO, PSTR(D_LOG_ZIGBEE "BLK 02 %s"), ToHex_P(map, sizeof(map), hex_char, sizeof(hex_char)));
zigbee.eeprom.readBytes(0x2100, 256, map);
AddLog_P(LOG_LEVEL_INFO, PSTR(D_LOG_ZIGBEE "BLK 21 %s"), ToHex_P(map, sizeof(map), hex_char, sizeof(hex_char)));
AddLog(LOG_LEVEL_INFO, PSTR(D_LOG_ZIGBEE "BLK 21 %s"), ToHex_P(map, sizeof(map), hex_char, sizeof(hex_char)));
// zigbee.eeprom.readBytes(0xFF00, 256, map);
// AddLog_P(LOG_LEVEL_INFO, PSTR(D_LOG_ZIGBEE "BLK FF %s"), ToHex_P(map, sizeof(map), hex_char, sizeof(hex_char)));
// AddLog(LOG_LEVEL_INFO, PSTR(D_LOG_ZIGBEE "BLK FF %s"), ToHex_P(map, sizeof(map), hex_char, sizeof(hex_char)));
}
#endif
@ -397,9 +397,9 @@ void ZFS::initOrFormat(void) {
if (dir->b0.signature == ZFS_SIGNATURE) {
// Good
AddLog_P(LOG_LEVEL_DEBUG, PSTR(D_LOG_ZIGBEE "EEPROM signature 0x%08X is correct"), dir->b0.signature);
AddLog(LOG_LEVEL_DEBUG, PSTR(D_LOG_ZIGBEE "EEPROM signature 0x%08X is correct"), dir->b0.signature);
} else {
AddLog_P(LOG_LEVEL_DEBUG, PSTR(D_LOG_ZIGBEE "EEPROM signature 0x%08X is incorrect, formatting"), dir->b0.signature);
AddLog(LOG_LEVEL_DEBUG, PSTR(D_LOG_ZIGBEE "EEPROM signature 0x%08X is incorrect, formatting"), dir->b0.signature);
format();
}
delete dir;
@ -411,7 +411,7 @@ void ZFS::initOrFormat(void) {
// Format EEPROM
//
void ZFS::format(void) {
AddLog_P(LOG_LEVEL_INFO, PSTR(D_LOG_ZIGBEE "Formatting EEPROM"));
AddLog(LOG_LEVEL_INFO, PSTR(D_LOG_ZIGBEE "Formatting EEPROM"));
// First write the bitmap
ZFS_Bitmap * bitmap = new ZFS_Bitmap();
@ -455,7 +455,7 @@ int32_t ZFS_Write_File::addBytes(void* buffer, size_t buffer_len) {
if (length + buffer_len > ZFS_FILE_BLOCKS * 256) { return -1; } // exceeded max size
// #ifdef Z_EEPROM_DEBUG
// AddLog_P(LOG_LEVEL_INFO, PSTR(D_LOG_ZIGBEE "eeprom.writeBytes address=0x%04X, len=%d"), (blk_start << 8) + length, buffer_len);
// AddLog(LOG_LEVEL_INFO, PSTR(D_LOG_ZIGBEE "eeprom.writeBytes address=0x%04X, len=%d"), (blk_start << 8) + length, buffer_len);
// #endif
zigbee.eeprom.writeBytes((blk_start << 8) + length, buffer_len, (byte*)buffer);
length += buffer_len;

4
tasmota/xdrv_23_zigbee_4b_data.ino
View File

@ -62,7 +62,7 @@ bool hydrateDeviceData(class Z_Device & device, const SBuffer & buf, size_t star
// #ifdef Z_EEPROM_DEBUG
// {
// char hex_char[((data_len+1) * 2) + 2];
// AddLog_P(LOG_LEVEL_INFO, PSTR(D_LOG_ZIGBEE "hydrateDeviceData data_len=%d contains %s"), data_len, ToHex_P(buf.buf(start+offset+1), data_len, hex_char, sizeof(hex_char)));
// AddLog(LOG_LEVEL_INFO, PSTR(D_LOG_ZIGBEE "hydrateDeviceData data_len=%d contains %s"), data_len, ToHex_P(buf.buf(start+offset+1), data_len, hex_char, sizeof(hex_char)));
// }
// #endif
Z_Data & data_elt = device.data.createFromBuffer(buf, start + offset + 1, data_len);
@ -89,7 +89,7 @@ int32_t hydrateSingleDeviceData(const SBuffer & buf) {
#ifdef Z_EEPROM_DEBUG
{
if (segment_len > 3) {
AddLog_P(LOG_LEVEL_INFO, PSTR(D_LOG_ZIGBEE "ZbData 0x%04X,%*_H"), shortaddr, buf.buf(2), buf.len() - 2);
AddLog(LOG_LEVEL_INFO, PSTR(D_LOG_ZIGBEE "ZbData 0x%04X,%*_H"), shortaddr, buf.buf(2), buf.len() - 2);
}
}
#endif

10
tasmota/xdrv_23_zigbee_5_converters.ino
View File

@ -751,7 +751,7 @@ public:
if (Settings.flag3.tuya_serial_mqtt_publish) {
MqttPublishPrefixTopicRulesProcess_P(TELE, PSTR(D_RSLT_SENSOR));
} else {
AddLog_P(LOG_LEVEL_DEBUG, PSTR(D_LOG_ZIGBEE "%s"), TasmotaGlobal.mqtt_data);
AddLog(LOG_LEVEL_DEBUG, PSTR(D_LOG_ZIGBEE "%s"), TasmotaGlobal.mqtt_data);
}
}
@ -2042,7 +2042,7 @@ void Z_postProcessAttributes(uint16_t shortaddr, uint16_t src_ep, class Z_attrib
uint8_t *attr_address = ((uint8_t*)&data) + sizeof(Z_Data) + map_offset;
uint32_t uval32 = attr.getUInt(); // call converter to uint only once
int32_t ival32 = attr.getInt(); // call converter to int only once
// AddLog_P(LOG_LEVEL_DEBUG_MORE, PSTR(D_LOG_ZIGBEE "Mapping type=%d offset=%d zigbee_type=%02X value=%d\n"), (uint8_t) map_type, map_offset, zigbee_type, ival32);
// AddLog(LOG_LEVEL_DEBUG_MORE, PSTR(D_LOG_ZIGBEE "Mapping type=%d offset=%d zigbee_type=%02X value=%d\n"), (uint8_t) map_type, map_offset, zigbee_type, ival32);
switch (ccccaaaa) {
case 0xEF000202:
case 0xEF000203: // need to convert Tuya temperatures from 1/10 to 1/00 °C
@ -2108,7 +2108,7 @@ void Z_parseAttributeKey_inner(class Z_attribute & attr, uint16_t preferred_clus
uint16_t local_cluster_id = CxToCluster(pgm_read_byte(&converter->cluster_short));
uint8_t local_type_id = pgm_read_byte(&converter->type);
int8_t local_multiplier = CmToMultiplier(pgm_read_byte(&converter->multiplier_idx));
// AddLog_P(LOG_LEVEL_DEBUG, PSTR("Try cluster = 0x%04X, attr = 0x%04X, type_id = 0x%02X"), local_cluster_id, local_attr_id, local_type_id);
// AddLog(LOG_LEVEL_DEBUG, PSTR("Try cluster = 0x%04X, attr = 0x%04X, type_id = 0x%02X"), local_cluster_id, local_attr_id, local_type_id);
if (!attr.key_is_str) {
if ((attr.key.id.cluster == local_cluster_id) && (attr.key.id.attr_id == local_attr_id)) {
@ -2117,7 +2117,7 @@ void Z_parseAttributeKey_inner(class Z_attribute & attr, uint16_t preferred_clus
}
} else if (pgm_read_word(&converter->name_offset)) {
const char * key = attr.key.key;
// AddLog_P(LOG_LEVEL_DEBUG, PSTR("Comparing '%s' with '%s'"), attr_name, converter->name);
// AddLog(LOG_LEVEL_DEBUG, PSTR("Comparing '%s' with '%s'"), attr_name, converter->name);
if (0 == strcasecmp_P(key, Z_strings + pgm_read_word(&converter->name_offset))) {
if ((preferred_cluster == 0xFFFF) || // any cluster
(local_cluster_id == preferred_cluster)) {
@ -2171,7 +2171,7 @@ bool Z_parseAttributeKey(class Z_attribute & attr, uint16_t preferred_cluster) {
attr.attr_type = type_id;
}
}
// AddLog_P(LOG_LEVEL_DEBUG, PSTR("cluster_id = 0x%04X, attr_id = 0x%04X"), cluster_id, attr_id);
// AddLog(LOG_LEVEL_DEBUG, PSTR("cluster_id = 0x%04X, attr_id = 0x%04X"), cluster_id, attr_id);
// do we already know the type, i.e. attribute and cluster are also known
if ((Zunk == attr.attr_type) && (preferred_cluster != 0xFFFF)) {

8
tasmota/xdrv_23_zigbee_6_commands.ino
View File

@ -283,7 +283,7 @@ void convertClusterSpecific(class Z_attribute_list &attr_list, uint16_t cluster,
uint8_t conv_direction;
Z_XYZ_Var xyz;
//AddLog_P(LOG_LEVEL_INFO, PSTR(">>> len = %d - %02X%02X%02X"), payload.len(), payload.get8(0), payload.get8(1), payload.get8(2));
//AddLog(LOG_LEVEL_INFO, PSTR(">>> len = %d - %02X%02X%02X"), payload.len(), payload.get8(0), payload.get8(1), payload.get8(2));
for (uint32_t i = 0; i < sizeof(Z_Commands) / sizeof(Z_Commands[0]); i++) {
const Z_CommandConverter *conv = &Z_Commands[i];
uint16_t conv_cluster = pgm_read_word(&conv->cluster);
@ -299,18 +299,18 @@ void convertClusterSpecific(class Z_attribute_list &attr_list, uint16_t cluster,
// - payload exactly matches conv->param (conv->param may be longer)
// - payload matches conv->param until 'x', 'y' or 'z'
const char * p = Z_strings + pgm_read_word(&conv->param_offset);
//AddLog_P(LOG_LEVEL_INFO, PSTR(">>>++1 param = %s"), p);
//AddLog(LOG_LEVEL_INFO, PSTR(">>>++1 param = %s"), p);
bool match = true;
for (uint8_t i = 0; i < payload.len(); i++) {
const char c1 = pgm_read_byte(p);
// const char c2 = pgm_read_byte(p+1);
//AddLog_P(LOG_LEVEL_INFO, PSTR(">>>++2 c1 = %c, c2 = %c"), c1, c2);
//AddLog(LOG_LEVEL_INFO, PSTR(">>>++2 c1 = %c, c2 = %c"), c1, c2);
if ((0x00 == c1) || isXYZ(c1)) {
break;
}
const char * p2 = p;
uint32_t nextbyte = parseHex_P(&p2, 2);
//AddLog_P(LOG_LEVEL_INFO, PSTR(">>>++3 parseHex_P = %02X"), nextbyte);
//AddLog(LOG_LEVEL_INFO, PSTR(">>>++3 parseHex_P = %02X"), nextbyte);
if (nextbyte != payload.get8(i)) {
match = false;
break;

6
tasmota/xdrv_23_zigbee_7_0_statemachine.ino
View File

@ -963,10 +963,10 @@ void ZigbeeGotoLabel(uint8_t label) {
const Zigbee_Instruction *cur_instr_line = &zb_prog[i];
cur_instr = pgm_read_byte(&cur_instr_line->i.i);
cur_d8 = pgm_read_byte(&cur_instr_line->i.d8);
//AddLog_P(LOG_LEVEL_DEBUG_MORE, PSTR("ZGB GOTO: pc %d instr %d"), i, cur_instr);
//AddLog(LOG_LEVEL_DEBUG_MORE, PSTR("ZGB GOTO: pc %d instr %d"), i, cur_instr);
if (ZGB_INSTR_LABEL == cur_instr) {
//AddLog_P(LOG_LEVEL_DEBUG_MORE, PSTR(D_LOG_ZIGBEE "found label %d at pc %d"), cur_d8, i);
//AddLog(LOG_LEVEL_DEBUG_MORE, PSTR(D_LOG_ZIGBEE "found label %d at pc %d"), cur_d8, i);
if (label == cur_d8) {
// label found, goto to this pc
zigbee.pc = i;
@ -1090,7 +1090,7 @@ void ZigbeeStateMachine_Run(void) {
}
break;
case ZGB_INSTR_LOG:
AddLog_P(cur_d8, (char*) cur_ptr1);
AddLog(cur_d8, (char*) cur_ptr1);
break;
case ZGB_INSTR_MQTT_STATE:
{

10
tasmota/xdrv_23_zigbee_8_parsers.ino
View File

@ -1219,7 +1219,7 @@ int32_t Z_Mgmt_Lqi_Bind_Rsp(int32_t res, const SBuffer &buf, boolean lqi) {
dstep = buf.get8(idx + 20);
idx += 21;
} else {
//AddLog_P(LOG_LEVEL_INFO, PSTR("ZNP_MgmtBindRsp unknwon address mode %d"), addrmode);
//AddLog(LOG_LEVEL_INFO, PSTR("ZNP_MgmtBindRsp unknwon address mode %d"), addrmode);
break; // abort for any other value since we don't know the length of the field
}
@ -1451,7 +1451,7 @@ void Z_SendCIEZoneEnrollResponse(uint16_t shortaddr, uint16_t groupaddr, uint16_
void Z_AutoBind(uint16_t shortaddr, uint16_t groupaddr, uint16_t cluster, uint8_t endpoint, uint32_t value) {
uint64_t srcLongAddr = zigbee_devices.getDeviceLongAddr(shortaddr);
AddLog_P(LOG_LEVEL_INFO, PSTR(D_LOG_ZIGBEE "auto-bind `ZbBind {\"Device\":\"0x%04X\",\"Endpoint\":%d,\"Cluster\":\"0x%04X\"}`"),
AddLog(LOG_LEVEL_INFO, PSTR(D_LOG_ZIGBEE "auto-bind `ZbBind {\"Device\":\"0x%04X\",\"Endpoint\":%d,\"Cluster\":\"0x%04X\"}`"),
shortaddr, endpoint, cluster);
#ifdef USE_ZIGBEE_ZNP
SBuffer buf(34);
@ -1577,7 +1577,7 @@ void Z_AutoConfigReportingForCluster(uint16_t shortaddr, uint16_t groupaddr, uin
ResponseAppend_P(PSTR("}}"));
if (buf.len() > 0) {
AddLog_P(LOG_LEVEL_INFO, PSTR(D_LOG_ZIGBEE "auto-bind `%s`"), TasmotaGlobal.mqtt_data);
AddLog(LOG_LEVEL_INFO, PSTR(D_LOG_ZIGBEE "auto-bind `%s`"), TasmotaGlobal.mqtt_data);
ZCLMessage zcl(buf.len()); // message is 4 bytes
zcl.shortaddr = shortaddr;
zcl.cluster = cluster;
@ -1680,7 +1680,7 @@ void Z_IncomingMessage(class ZCLFrame &zcl_received) {
zcl_received.parseClusterSpecificCommand(attr_list);
}
AddLog_P(LOG_LEVEL_DEBUG, PSTR(D_LOG_ZIGBEE D_JSON_ZIGBEEZCL_RAW_RECEIVED ": {\"0x%04X\":{%s}}"), srcaddr, attr_list.toString().c_str());
AddLog(LOG_LEVEL_DEBUG, PSTR(D_LOG_ZIGBEE D_JSON_ZIGBEEZCL_RAW_RECEIVED ": {\"0x%04X\":{%s}}"), srcaddr, attr_list.toString().c_str());
// discard the message if it was sent by us (broadcast or group loopback)
if (srcaddr == localShortAddr) {
@ -2164,7 +2164,7 @@ void ZCLFrame::autoResponder(const uint16_t *attr_list_ids, size_t attr_len) {
// we have a non-empty output
// log first
AddLog_P(LOG_LEVEL_INFO, PSTR("ZIG: Auto-responder: ZbSend {\"Device\":\"0x%04X\""
AddLog(LOG_LEVEL_INFO, PSTR("ZIG: Auto-responder: ZbSend {\"Device\":\"0x%04X\""
",\"Cluster\":\"0x%04X\""
",\"Endpoint\":%d"
",\"Response\":%s}"

78
tasmota/xdrv_23_zigbee_9_serial.ino
View File

@ -92,7 +92,7 @@ void ZigbeeInputLoop(void) {
while (ZigbeeSerial->available()) {
yield();
uint8_t zigbee_in_byte = ZigbeeSerial->read();
//AddLog_P(LOG_LEVEL_DEBUG_MORE, PSTR("ZbInput byte=%d len=%d"), zigbee_in_byte, zigbee_buffer->len());
//AddLog(LOG_LEVEL_DEBUG_MORE, PSTR("ZbInput byte=%d len=%d"), zigbee_in_byte, zigbee_buffer->len());
if (0 == zigbee_buffer->len()) { // make sure all variables are correctly initialized
zigbee_frame_len = 5;
@ -134,17 +134,17 @@ void ZigbeeInputLoop(void) {
}
if (zigbee_buffer->len() && (millis() > (zigbee_polling_window + ZIGBEE_POLLING))) {
// AddLog_P(LOG_LEVEL_DEBUG_MORE, PSTR(D_LOG_ZIGBEE "Bytes follow_read_metric = %0d"), ZigbeeSerial->getLoopReadMetric());
// AddLog(LOG_LEVEL_DEBUG_MORE, PSTR(D_LOG_ZIGBEE "Bytes follow_read_metric = %0d"), ZigbeeSerial->getLoopReadMetric());
// buffer received, now check integrity
if (zigbee_buffer->len() != zigbee_frame_len) {
// Len is not correct, log and reject frame
AddLog_P(LOG_LEVEL_INFO, PSTR(D_JSON_ZIGBEEZNPRECEIVED ": received frame of wrong size %_B, len %d, expected %d"), zigbee_buffer, zigbee_buffer->len(), zigbee_frame_len);
AddLog(LOG_LEVEL_INFO, PSTR(D_JSON_ZIGBEEZNPRECEIVED ": received frame of wrong size %_B, len %d, expected %d"), zigbee_buffer, zigbee_buffer->len(), zigbee_frame_len);
} else if (0x00 != fcs) {
// FCS is wrong, packet is corrupt, log and reject frame
AddLog_P(LOG_LEVEL_INFO, PSTR(D_JSON_ZIGBEEZNPRECEIVED ": received bad FCS frame %_B, %d"), zigbee_buffer, fcs);
AddLog(LOG_LEVEL_INFO, PSTR(D_JSON_ZIGBEEZNPRECEIVED ": received bad FCS frame %_B, %d"), zigbee_buffer, fcs);
} else {
// frame is correct
//AddLog_P(LOG_LEVEL_DEBUG_MORE, PSTR(D_JSON_ZIGBEEZNPRECEIVED ": received correct frame %s"), hex_char);
//AddLog(LOG_LEVEL_DEBUG_MORE, PSTR(D_JSON_ZIGBEEZNPRECEIVED ": received correct frame %s"), hex_char);
SBuffer znp_buffer = zigbee_buffer->subBuffer(2, zigbee_frame_len - 3); // remove SOF, LEN and FCS
@ -152,7 +152,7 @@ void ZigbeeInputLoop(void) {
if (Settings.flag3.tuya_serial_mqtt_publish) {
MqttPublishPrefixTopicRulesProcess_P(TELE, PSTR(D_RSLT_SENSOR));
} else {
AddLog_P(LOG_LEVEL_DEBUG, PSTR(D_LOG_ZIGBEE "%s"), TasmotaGlobal.mqtt_data);
AddLog(LOG_LEVEL_DEBUG, PSTR(D_LOG_ZIGBEE "%s"), TasmotaGlobal.mqtt_data);
}
// now process the message
ZigbeeProcessInput(znp_buffer);
@ -177,7 +177,7 @@ void ZigbeeInputLoop(void) {
yield();
uint8_t zigbee_in_byte = ZigbeeSerial->read();
// AddLog_P(LOG_LEVEL_DEBUG_MORE, PSTR("ZIG: ZbInput byte=0x%02X len=%d"), zigbee_in_byte, zigbee_buffer->len());
// AddLog(LOG_LEVEL_DEBUG_MORE, PSTR("ZIG: ZbInput byte=0x%02X len=%d"), zigbee_in_byte, zigbee_buffer->len());
// if (0 == zigbee_buffer->len()) { // make sure all variables are correctly initialized
// escape = false;
@ -189,13 +189,13 @@ void ZigbeeInputLoop(void) {
}
if (ZIGBEE_EZSP_ESCAPE == zigbee_in_byte) {
// AddLog_P(LOG_LEVEL_DEBUG_MORE, PSTR("ZIG: Escape byte received"));
// AddLog(LOG_LEVEL_DEBUG_MORE, PSTR("ZIG: Escape byte received"));
escape = true;
continue;
}
if (ZIGBEE_EZSP_CANCEL == zigbee_in_byte) {
// AddLog_P(LOG_LEVEL_DEBUG_MORE, PSTR("ZIG: ZbInput byte=0x1A, cancel byte received, discarding %d bytes"), zigbee_buffer->len());
// AddLog(LOG_LEVEL_DEBUG_MORE, PSTR("ZIG: ZbInput byte=0x1A, cancel byte received, discarding %d bytes"), zigbee_buffer->len());
zigbee_buffer->setLen(0); // empty buffer
escape = false;
frame_complete = false;
@ -222,10 +222,10 @@ void ZigbeeInputLoop(void) {
uint32_t frame_len = zigbee_buffer->len();
if (frame_complete || (frame_len && (millis() > (zigbee_polling_window + ZIGBEE_POLLING)))) {
// AddLog_P(LOG_LEVEL_DEBUG_MORE, PSTR(D_LOG_ZIGBEE "Bytes follow_read_metric = %0d"), ZigbeeSerial->getLoopReadMetric());
// AddLog(LOG_LEVEL_DEBUG_MORE, PSTR(D_LOG_ZIGBEE "Bytes follow_read_metric = %0d"), ZigbeeSerial->getLoopReadMetric());
if ((frame_complete) && (frame_len >= 3)) {
// frame received and has at least 3 bytes (without EOF), checking CRC
// AddLog_P(LOG_LEVEL_INFO, PSTR(D_JSON_ZIGBEE_EZSP_RECEIVED ": received raw frame %s"), hex_char);
// AddLog(LOG_LEVEL_INFO, PSTR(D_JSON_ZIGBEE_EZSP_RECEIVED ": received raw frame %s"), hex_char);
uint16_t crc = 0xFFFF; // frame CRC
// compute CRC
for (uint32_t i=0; i<frame_len-2; i++) {
@ -243,7 +243,7 @@ void ZigbeeInputLoop(void) {
// remove 2 last bytes
if (crc_received != crc) {
AddLog_P(LOG_LEVEL_INFO, PSTR(D_JSON_ZIGBEE_EZSP_RECEIVED ": bad crc (received 0x%04X, computed 0x%04X) %_B"), crc_received, crc, zigbee_buffer);
AddLog(LOG_LEVEL_INFO, PSTR(D_JSON_ZIGBEE_EZSP_RECEIVED ": bad crc (received 0x%04X, computed 0x%04X) %_B"), crc_received, crc, zigbee_buffer);
} else {
// copy buffer
SBuffer ezsp_buffer = zigbee_buffer->subBuffer(0, frame_len - 2); // CRC
@ -259,13 +259,13 @@ void ZigbeeInputLoop(void) {
}
}
AddLog_P(LOG_LEVEL_DEBUG_MORE, PSTR(D_LOG_ZIGBEE "{\"" D_JSON_ZIGBEE_EZSP_RECEIVED "2\":\"%_B\"}"), &ezsp_buffer);
AddLog(LOG_LEVEL_DEBUG_MORE, PSTR(D_LOG_ZIGBEE "{\"" D_JSON_ZIGBEE_EZSP_RECEIVED "2\":\"%_B\"}"), &ezsp_buffer);
// now process the message
ZigbeeProcessInputRaw(ezsp_buffer);
}
} else {
// the buffer timed-out, print error and discard
AddLog_P(LOG_LEVEL_INFO, PSTR(D_JSON_ZIGBEE_EZSP_RECEIVED ": time-out, discarding %_B"), zigbee_buffer);
AddLog(LOG_LEVEL_INFO, PSTR(D_JSON_ZIGBEE_EZSP_RECEIVED ": time-out, discarding %_B"), zigbee_buffer);
}
zigbee_buffer->setLen(0); // empty buffer
escape = false;
@ -281,10 +281,10 @@ void ZigbeeInputLoop(void) {
// Initialize internal structures
void ZigbeeInitSerial(void)
{
// AddLog_P(LOG_LEVEL_INFO, PSTR("ZigbeeInit Mem1 = %d"), ESP_getFreeHeap());
// AddLog(LOG_LEVEL_INFO, PSTR("ZigbeeInit Mem1 = %d"), ESP_getFreeHeap());
zigbee.active = false;
if (PinUsed(GPIO_ZIGBEE_RX) && PinUsed(GPIO_ZIGBEE_TX)) {
AddLog_P(LOG_LEVEL_DEBUG_MORE, PSTR(D_LOG_ZIGBEE "GPIOs Rx:%d Tx:%d"), Pin(GPIO_ZIGBEE_RX), Pin(GPIO_ZIGBEE_TX));
AddLog(LOG_LEVEL_DEBUG_MORE, PSTR(D_LOG_ZIGBEE "GPIOs Rx:%d Tx:%d"), Pin(GPIO_ZIGBEE_RX), Pin(GPIO_ZIGBEE_TX));
// if TasmotaGlobal.seriallog_level is 0, we allow GPIO 13/15 to switch to Hardware Serial
ZigbeeSerial = new TasmotaSerial(Pin(GPIO_ZIGBEE_RX), Pin(GPIO_ZIGBEE_TX), TasmotaGlobal.seriallog_level ? 1 : 2, 0, 256); // set a receive buffer of 256 bytes
ZigbeeSerial->begin(115200);
@ -293,9 +293,9 @@ void ZigbeeInitSerial(void)
uint32_t aligned_buffer = ((uint32_t)TasmotaGlobal.serial_in_buffer + 3) & ~3;
zigbee_buffer = new PreAllocatedSBuffer(sizeof(TasmotaGlobal.serial_in_buffer) - 3, (char*) aligned_buffer);
} else {
// AddLog_P(LOG_LEVEL_INFO, PSTR("ZigbeeInit Mem2 = %d"), ESP_getFreeHeap());
// AddLog(LOG_LEVEL_INFO, PSTR("ZigbeeInit Mem2 = %d"), ESP_getFreeHeap());
zigbee_buffer = new SBuffer(ZIGBEE_BUFFER_SIZE);
// AddLog_P(LOG_LEVEL_INFO, PSTR("ZigbeeInit Mem3 = %d"), ESP_getFreeHeap());
// AddLog(LOG_LEVEL_INFO, PSTR("ZigbeeInit Mem3 = %d"), ESP_getFreeHeap());
}
if (PinUsed(GPIO_ZIGBEE_RST)) {
@ -312,7 +312,7 @@ void ZigbeeInitSerial(void)
zigbee.state_machine = true; // start the state machine
ZigbeeSerial->flush();
}
// AddLog_P(LOG_LEVEL_INFO, PSTR("ZigbeeInit Mem9 = %d"), ESP_getFreeHeap());
// AddLog(LOG_LEVEL_INFO, PSTR("ZigbeeInit Mem9 = %d"), ESP_getFreeHeap());
}
#ifdef USE_ZIGBEE_ZNP
@ -323,14 +323,14 @@ void ZigbeeZNPFlush(void) {
for (uint32_t i = 0; i < 256; i++) {
ZigbeeSerial->write(0xFF);
}
AddLog_P(LOG_LEVEL_DEBUG, PSTR(D_LOG_ZIGBEE D_JSON_ZIGBEEZNPSENT " 0xFF x 255"));
AddLog(LOG_LEVEL_DEBUG, PSTR(D_LOG_ZIGBEE D_JSON_ZIGBEEZNPSENT " 0xFF x 255"));
}
}
void ZigbeeZNPSend(const uint8_t *msg, size_t len) {
if ((len < 2) || (len > 252)) {
// abort, message cannot be less than 2 bytes for CMD1 and CMD2
AddLog_P(LOG_LEVEL_DEBUG, PSTR(D_JSON_ZIGBEEZNPSENT ": bad message len %d"), len);
AddLog(LOG_LEVEL_DEBUG, PSTR(D_JSON_ZIGBEEZNPSENT ": bad message len %d"), len);
return;
}
uint8_t data_len = len - 2; // removing CMD1 and CMD2
@ -339,20 +339,20 @@ void ZigbeeZNPSend(const uint8_t *msg, size_t len) {
uint8_t fcs = data_len;
ZigbeeSerial->write(ZIGBEE_SOF); // 0xFE
//AddLog_P(LOG_LEVEL_DEBUG_MORE, PSTR("ZNPSend SOF %02X"), ZIGBEE_SOF);
//AddLog(LOG_LEVEL_DEBUG_MORE, PSTR("ZNPSend SOF %02X"), ZIGBEE_SOF);
ZigbeeSerial->write(data_len);
//AddLog_P(LOG_LEVEL_DEBUG_MORE, PSTR("ZNPSend LEN %02X"), data_len);
//AddLog(LOG_LEVEL_DEBUG_MORE, PSTR("ZNPSend LEN %02X"), data_len);
for (uint32_t i = 0; i < len; i++) {
uint8_t b = pgm_read_byte(msg + i);
ZigbeeSerial->write(b);
fcs ^= b;
//AddLog_P(LOG_LEVEL_DEBUG_MORE, PSTR("ZNPSend byt %02X"), b);
//AddLog(LOG_LEVEL_DEBUG_MORE, PSTR("ZNPSend byt %02X"), b);
}
ZigbeeSerial->write(fcs); // finally send fcs checksum byte
//AddLog_P(LOG_LEVEL_DEBUG_MORE, PSTR("ZNPSend FCS %02X"), fcs);
//AddLog(LOG_LEVEL_DEBUG_MORE, PSTR("ZNPSend FCS %02X"), fcs);
}
// Now send a MQTT message to report the sent message
AddLog_P(LOG_LEVEL_DEBUG, PSTR(D_LOG_ZIGBEE D_JSON_ZIGBEEZNPSENT " %*_H"), len, msg);
AddLog(LOG_LEVEL_DEBUG, PSTR(D_LOG_ZIGBEE D_JSON_ZIGBEEZNPSENT " %*_H"), len, msg);
}
//
@ -437,7 +437,7 @@ void ZigbeeEZSPSend_Out(uint8_t out_byte) {
void ZigbeeEZSPSendRaw(const uint8_t *msg, size_t len, bool send_cancel) {
if ((len < 1) || (len > 252)) {
// abort, message cannot be less than 2 bytes for CMD1 and CMD2
AddLog_P(LOG_LEVEL_DEBUG, PSTR(D_JSON_ZIGBEE_EZSP_SENT ": bad message len %d"), len);
AddLog(LOG_LEVEL_DEBUG, PSTR(D_JSON_ZIGBEE_EZSP_SENT ": bad message len %d"), len);
return;
}
// turn send led on
@ -484,13 +484,13 @@ void ZigbeeEZSPSendRaw(const uint8_t *msg, size_t len, bool send_cancel) {
}
// Now send a MQTT message to report the sent message
AddLog_P(LOG_LEVEL_DEBUG_MORE, PSTR(D_LOG_ZIGBEE D_JSON_ZIGBEE_EZSP_SENT_RAW " %*_H"), len, msg);
AddLog(LOG_LEVEL_DEBUG_MORE, PSTR(D_LOG_ZIGBEE D_JSON_ZIGBEE_EZSP_SENT_RAW " %*_H"), len, msg);
}
// Send an EZSP command and data
// Ex: Version with min v8 = 000008
void ZigbeeEZSPSendCmd(const uint8_t *msg, size_t len) {
AddLog_P(LOG_LEVEL_DEBUG, PSTR(D_LOG_ZIGBEE "ZbEZSPSend %*_H"), len, msg);
AddLog(LOG_LEVEL_DEBUG, PSTR(D_LOG_ZIGBEE "ZbEZSPSend %*_H"), len, msg);
SBuffer cmd(len+3); // prefix with seq number (1 byte) and frame control bytes (2 bytes)
@ -507,7 +507,7 @@ void ZigbeeEZSPSendCmd(const uint8_t *msg, size_t len) {
void ZigbeeEZSPSendDATA_frm(bool send_cancel, uint8_t to_frm, uint8_t from_ack) {
SBuffer *buf = EZSP_Serial.to_packets[to_frm];
if (!buf) {
AddLog_P(LOG_LEVEL_DEBUG_MORE, PSTR("ZIG: Buffer for packet %d is not allocated"), EZSP_Serial.to_send);
AddLog(LOG_LEVEL_DEBUG_MORE, PSTR("ZIG: Buffer for packet %d is not allocated"), EZSP_Serial.to_send);
return;
}
@ -524,7 +524,7 @@ void ZigbeeEZSPSendDATA(const uint8_t *msg, size_t len) {
buf->add8(0x00); // placeholder for control_byte
buf->addBuffer(msg, len);
//
AddLog_P(LOG_LEVEL_DEBUG_MORE, PSTR("ZIG: adding packet to_send, to_ack:%d, to_send:%d, to_end:%d"),
AddLog(LOG_LEVEL_DEBUG_MORE, PSTR("ZIG: adding packet to_send, to_ack:%d, to_send:%d, to_end:%d"),
EZSP_Serial.to_ack, EZSP_Serial.to_send, EZSP_Serial.to_end);
uint8_t to_frm = EZSP_Serial.to_end;
if (EZSP_Serial.to_packets[to_frm]) {
@ -552,7 +552,7 @@ void ZigbeeProcessInputEZSP(SBuffer &buf) {
// bool callbackPending = frame_control & 0x04;
bool security_enabled = frame_control & 0x8000;
if (truncated || overflow || security_enabled) {
AddLog_P(LOG_LEVEL_INFO, PSTR("ZIG: specific frame_control 0x%04X"), frame_control);
AddLog(LOG_LEVEL_INFO, PSTR("ZIG: specific frame_control 0x%04X"), frame_control);
}
// remove first 2 bytes, be
@ -597,7 +597,7 @@ void ZigbeeProcessInputEZSP(SBuffer &buf) {
log_level = LOG_LEVEL_DEBUG;
break;
}
AddLog_P(log_level, PSTR(D_LOG_ZIGBEE "%s"), TasmotaGlobal.mqtt_data); // TODO move to LOG_LEVEL_DEBUG when stable
AddLog(log_level, PSTR(D_LOG_ZIGBEE "%s"), TasmotaGlobal.mqtt_data); // TODO move to LOG_LEVEL_DEBUG when stable
}
// Pass message to state machine
@ -607,14 +607,14 @@ void ZigbeeProcessInputEZSP(SBuffer &buf) {
// Check if we advanced in the ACKed frames, and free from memory packets acknowledged
void EZSP_HandleAck(uint8_t new_ack) {
if (EZSP_Serial.to_ack != new_ack) { // new ack receveid
AddLog_P(LOG_LEVEL_DEBUG_MORE, PSTR("ZIG: new ack/data received, was %d now %d"), EZSP_Serial.to_ack, new_ack);
AddLog(LOG_LEVEL_DEBUG_MORE, PSTR("ZIG: new ack/data received, was %d now %d"), EZSP_Serial.to_ack, new_ack);
uint32_t i = EZSP_Serial.to_ack;
do {
if (EZSP_Serial.to_packets[i]) {
delete EZSP_Serial.to_packets[i];
EZSP_Serial.to_packets[i] = nullptr;
}
AddLog_P(LOG_LEVEL_DEBUG_MORE, PSTR("ZIG: freeing packet %d from memory"), i);
AddLog(LOG_LEVEL_DEBUG_MORE, PSTR("ZIG: freeing packet %d from memory"), i);
i = (i + 1) & 0x07;
} while (i != new_ack);
EZSP_Serial.to_ack = new_ack;
@ -635,10 +635,10 @@ void ZigbeeProcessInputRaw(SBuffer &buf) {
} else if (frame_type == 0xA0) {
// NAK
AddLog_P(LOG_LEVEL_DEBUG_MORE, PSTR("ZIG: Received NAK %d, to_ack:%d, to_send:%d, to_end:%d"),
AddLog(LOG_LEVEL_DEBUG_MORE, PSTR("ZIG: Received NAK %d, to_ack:%d, to_send:%d, to_end:%d"),
ack_num, EZSP_Serial.to_ack, EZSP_Serial.to_send, EZSP_Serial.to_end);
EZSP_Serial.to_send = ack_num;
AddLog_P(LOG_LEVEL_DEBUG, PSTR("ZIG: NAK, resending packet %d"), ack_num);
AddLog(LOG_LEVEL_DEBUG, PSTR("ZIG: NAK, resending packet %d"), ack_num);
} else if (control_byte == 0xC1) {
// RSTACK
@ -664,7 +664,7 @@ void ZigbeeProcessInputRaw(SBuffer &buf) {
} else {
// Unknown
AddLog_P(LOG_LEVEL_DEBUG, PSTR("ZIG: Received unknown control byte 0x%02X"), control_byte);
AddLog(LOG_LEVEL_DEBUG, PSTR("ZIG: Received unknown control byte 0x%02X"), control_byte);
}
} else { // DATA Frame
@ -864,7 +864,7 @@ void ZigbeeOutputLoop(void) {
#ifdef USE_ZIGBEE_EZSP
// while (EZSP_Serial.to_send != EZSP_Serial.to_end) {
if (EZSP_Serial.to_send != EZSP_Serial.to_end) { // we send only one packet per tick to lower the chance of NAK
AddLog_P(LOG_LEVEL_DEBUG_MORE, PSTR("ZIG: Something to_send, to_ack:%d, to_send:%d, to_end:%d"),
AddLog(LOG_LEVEL_DEBUG_MORE, PSTR("ZIG: Something to_send, to_ack:%d, to_send:%d, to_end:%d"),
EZSP_Serial.to_ack, EZSP_Serial.to_send, EZSP_Serial.to_end);
// we have a frame waiting to be sent
ZigbeeEZSPSendDATA_frm(true, EZSP_Serial.to_send, EZSP_Serial.from_ack);

2
tasmota/xdrv_23_zigbee_9a_upload.ino
View File

@ -77,7 +77,7 @@ char ZigbeeUploadFlashRead(void) {
if (sector != ZbUpload.sector_counter) {
ZbUpload.sector_counter = sector;
ESP.flashRead(ZbUpload.sector_counter * SPI_FLASH_SEC_SIZE, (uint32_t*)ZbUpload.buffer, SPI_FLASH_SEC_SIZE);
// AddLog_P(LOG_LEVEL_DEBUG, "= sector %d %*_H", ZbUpload.sector_counter, 256, ZbUpload.buffer);
// AddLog(LOG_LEVEL_DEBUG, "= sector %d %*_H", ZbUpload.sector_counter, 256, ZbUpload.buffer);
}
char data = ZbUpload.buffer[index];

20
tasmota/xdrv_23_zigbee_A_impl.ino
View File

@ -184,14 +184,14 @@ void zigbeeZCLSendCmd(class ZCLMessage &zcl) {
// endpoint is not specified, let's try to find it from shortAddr, unless it's a group address
zcl.endpoint = zigbee_devices.findFirstEndpoint(zcl.shortaddr);
if (0x00 == zcl.endpoint) { zcl.endpoint = 0x01; } // if we don't know the endpoint, try 0x01
//AddLog_P(LOG_LEVEL_DEBUG, PSTR("ZbSend: guessing endpoint 0x%02X"), endpoint);
//AddLog(LOG_LEVEL_DEBUG, PSTR("ZbSend: guessing endpoint 0x%02X"), endpoint);
}
// AddLog_P(LOG_LEVEL_DEBUG, PSTR("ZbSend: shortaddr 0x%04X, groupaddr 0x%04X, cluster 0x%04X, endpoint 0x%02X, cmd 0x%02X, data %_B"),
// AddLog(LOG_LEVEL_DEBUG, PSTR("ZbSend: shortaddr 0x%04X, groupaddr 0x%04X, cluster 0x%04X, endpoint 0x%02X, cmd 0x%02X, data %_B"),
// zcl.shortaddr, zcl.groupaddr, zcl.cluster, zcl.endpoint, zcl.cmd, &zcl.buf);
if ((0 == zcl.endpoint) && (zcl.validShortaddr())) { // endpoint null is ok for group address
AddLog_P(LOG_LEVEL_INFO, PSTR("ZbSend: unspecified endpoint"));
AddLog(LOG_LEVEL_INFO, PSTR("ZbSend: unspecified endpoint"));
return;
}
@ -202,7 +202,7 @@ void zigbeeZCLSendCmd(class ZCLMessage &zcl) {
zcl.transacSet = true;
}
AddLog_P(LOG_LEVEL_DEBUG, PSTR("ZigbeeZCLSend device: 0x%04X, group: 0x%04X, endpoint:%d, cluster:0x%04X, cmd:0x%02X, send:\"%_B\""),
AddLog(LOG_LEVEL_DEBUG, PSTR("ZigbeeZCLSend device: 0x%04X, group: 0x%04X, endpoint:%d, cluster:0x%04X, cmd:0x%02X, send:\"%_B\""),
zcl.shortaddr, zcl.groupaddr, zcl.endpoint, zcl.cluster, zcl.cmd, &zcl.buf);
ZigbeeZCLSend_Raw(zcl);
@ -312,7 +312,7 @@ bool ZbAppendWriteBuf(SBuffer & buf, const Z_attribute & attr, bool prepend_stat
if (res < 0) {
// remove the attribute type we just added
// buf.setLen(buf.len() - (operation == ZCL_READ_ATTRIBUTES_RESPONSE ? 4 : 3));
AddLog_P(LOG_LEVEL_INFO, PSTR(D_LOG_ZIGBEE D_ZIGBEE_UNSUPPORTED_ATTRIBUTE_TYPE " %04X/%04X '0x%02X'"), attr.key.id.cluster, attr.key.id.attr_id, attr.attr_type);
AddLog(LOG_LEVEL_INFO, PSTR(D_LOG_ZIGBEE D_ZIGBEE_UNSUPPORTED_ATTRIBUTE_TYPE " %04X/%04X '0x%02X'"), attr.key.id.cluster, attr.key.id.attr_id, attr.attr_type);
return false;
}
return true;
@ -518,7 +518,7 @@ void ZbSendSend(class JsonParserToken val_cmd, ZCLMessage & zcl) {
}
}
//AddLog_P(LOG_LEVEL_DEBUG, PSTR("ZbSend: command_template = %s"), cmd_str.c_str());
//AddLog(LOG_LEVEL_DEBUG, PSTR("ZbSend: command_template = %s"), cmd_str.c_str());
if (0xFF == cmd_var) { // if command number is a variable, replace it with x
zcl.cmd = x;
x = y; // and shift other variables
@ -653,7 +653,7 @@ void ZbSendRead(JsonParserToken val_attr, ZCLMessage & zcl) {
}
}
if (!found) {
AddLog_P(LOG_LEVEL_INFO, PSTR(D_LOG_ZIGBEE D_ZIGBEE_UNKNWON_ATTRIBUTE), key.getStr());
AddLog(LOG_LEVEL_INFO, PSTR(D_LOG_ZIGBEE D_ZIGBEE_UNKNWON_ATTRIBUTE), key.getStr());
}
}
@ -742,7 +742,7 @@ void CmndZbSend(void) {
zcl.endpoint = 0xFF; // endpoint not used for group addresses, so use a dummy broadcast endpoint
} else if (!zcl.validEndpoint()) { // if it was not already specified, try to guess it
zcl.endpoint = zigbee_devices.findFirstEndpoint(zcl.shortaddr);
AddLog_P(LOG_LEVEL_DEBUG, PSTR("ZIG: guessing endpoint %d"), zcl.endpoint);
AddLog(LOG_LEVEL_DEBUG, PSTR("ZIG: guessing endpoint %d"), zcl.endpoint);
}
if (!zcl.validEndpoint()) { // after this, if it is still zero, then it's an error
ResponseCmndChar_P(PSTR("Missing endpoint"));
@ -1621,7 +1621,7 @@ void CmndZbConfig(void) {
if (zb_channel > 26) { zb_channel = 26; }
// if network key is zero, we generate a truly random key with a hardware generator from ESP
if ((0 == zb_precfgkey_l) && (0 == zb_precfgkey_h)) {
AddLog_P(LOG_LEVEL_INFO, PSTR(D_LOG_ZIGBEE D_ZIGBEE_GENERATE_KEY));
AddLog(LOG_LEVEL_INFO, PSTR(D_LOG_ZIGBEE D_ZIGBEE_GENERATE_KEY));
zb_precfgkey_l = (uint64_t)HwRandom() << 32 | HwRandom();
zb_precfgkey_h = (uint64_t)HwRandom() << 32 | HwRandom();
}
@ -2092,7 +2092,7 @@ void ZigbeeMapRefresh(void) {
// Display a graphical representation of the Zigbee map using vis.js network
void ZigbeeShowMap(void) {
AddLog_P(LOG_LEVEL_DEBUG, PSTR(D_LOG_HTTP "Zigbee Mapper"));
AddLog(LOG_LEVEL_DEBUG, PSTR(D_LOG_HTTP "Zigbee Mapper"));
// if no map, then launch a new mapping
if ((!zigbee.init_phase) && (!zigbee.mapping_ready) && (!zigbee.mapping_in_progress)) {

10
tasmota/xdrv_27_shutter.ino
View File

@ -265,7 +265,7 @@ void ShutterInit(void)
for (uint32_t j = 0; j < MAX_INTERLOCKS * Settings.flag.interlock; j++) { // CMND_INTERLOCK - Enable/disable interlock
//AddLog(LOG_LEVEL_DEBUG, PSTR("SHT: Interlock state i=%d %d, flag %d, Shuttermask %d, MaskedIL %d"),i, Settings.interlock[i], Settings.flag.interlock,ShutterGlobal.RelayShutterMask, Settings.interlock[i]&ShutterGlobal.RelayShutterMask);
if (Settings.interlock[j] && (Settings.interlock[j] & ShutterGlobal.RelayShutterMask)) {
//AddLog_P(LOG_LEVEL_DEBUG, PSTR("SHT: Relay in Interlock group"));
//AddLog(LOG_LEVEL_DEBUG, PSTR("SHT: Relay in Interlock group"));
relay_in_interlock = true;
}
}
@ -554,7 +554,7 @@ void ShutterAllowPreStartProcedure(uint8_t i)
void ShutterStartInit(uint32_t i, int32_t direction, int32_t target_pos)
{
//AddLog_P(LOG_LEVEL_DEBUG_MORE, PSTR("SHT: dir %d, delta1 %d, delta2 %d, grant %d"),direction, (Shutter[i].open_max - Shutter[i].real_position) / Shutter[i].close_velocity, Shutter[i].real_position / Shutter[i].close_velocity, 2+Shutter[i].motordelay);
//AddLog(LOG_LEVEL_DEBUG_MORE, PSTR("SHT: dir %d, delta1 %d, delta2 %d, grant %d"),direction, (Shutter[i].open_max - Shutter[i].real_position) / Shutter[i].close_velocity, Shutter[i].real_position / Shutter[i].close_velocity, 2+Shutter[i].motordelay);
if ( ( (1 == direction) && ((Shutter[i].open_max - Shutter[i].real_position) / 100 <= 2) )
|| ( (-1 == direction) && (Shutter[i].real_position / Shutter[i].close_velocity <= 2)) ) {
ShutterGlobal.skip_relay_change = 1;
@ -624,7 +624,7 @@ void ShutterRelayChanged(void)
// SRC_IGNORE added because INTERLOCK function bite causes this as last source for changing the relay.
//uint8 manual_relays_changed = ((ShutterGlobal.RelayCurrentMask >> (Settings.shutter_startrelay[i] -1)) & 3) && SRC_IGNORE != TasmotaGlobal.last_source && SRC_SHUTTER != TasmotaGlobal.last_source && SRC_PULSETIMER != TasmotaGlobal.last_source ;
uint8 manual_relays_changed = ((ShutterGlobal.RelayCurrentMask >> (Settings.shutter_startrelay[i] -1)) & 3) && SRC_SHUTTER != TasmotaGlobal.last_source && SRC_PULSETIMER != TasmotaGlobal.last_source ;
AddLog_P(LOG_LEVEL_DEBUG_MORE, PSTR("SHT: Shtr%d, Source %s, Powerstate %ld, RelayMask %d, ManualChange %d"),
AddLog(LOG_LEVEL_DEBUG_MORE, PSTR("SHT: Shtr%d, Source %s, Powerstate %ld, RelayMask %d, ManualChange %d"),
i+1, GetTextIndexed(stemp1, sizeof(stemp1), TasmotaGlobal.last_source, kCommandSource), powerstate_local,ShutterGlobal.RelayCurrentMask,manual_relays_changed);
if (manual_relays_changed) {
//ShutterGlobal.skip_relay_change = true;
@ -833,7 +833,7 @@ void ShutterButtonHandler(void)
if (Settings.shutter_startrelay[shutter_index] && Settings.shutter_startrelay[shutter_index] <9) {
uint8_t pos_press_index = (buttonState == SHT_PRESSED_HOLD) ? 3 : (press_index-1);
if (pos_press_index>3) pos_press_index=3;
AddLog_P(LOG_LEVEL_DEBUG_MORE, PSTR("SHT: Shtr%d, Button %d = %d (single=1, double=2, tripple=3, hold=4)"), shutter_index+1, button_index+1, pos_press_index+1);
AddLog(LOG_LEVEL_DEBUG_MORE, PSTR("SHT: Shtr%d, Button %d = %d (single=1, double=2, tripple=3, hold=4)"), shutter_index+1, button_index+1, pos_press_index+1);
XdrvMailbox.index = shutter_index +1;
TasmotaGlobal.last_source = SRC_BUTTON;
XdrvMailbox.data_len = 0;
@ -1020,7 +1020,7 @@ void CmndShutterStop(void)
void CmndShutterIncDec(void)
{
//AddLog_P(LOG_LEVEL_DEBUG_MORE, PSTR("SHT: Change in: payload %s (%d), payload %d, idx %d, src %d"), XdrvMailbox.data , XdrvMailbox.data_len, XdrvMailbox.payload , XdrvMailbox.index, TasmotaGlobal.last_source );
//AddLog(LOG_LEVEL_DEBUG_MORE, PSTR("SHT: Change in: payload %s (%d), payload %d, idx %d, src %d"), XdrvMailbox.data , XdrvMailbox.data_len, XdrvMailbox.payload , XdrvMailbox.index, TasmotaGlobal.last_source );
if ((XdrvMailbox.index > 0) && (XdrvMailbox.index <= TasmotaGlobal.shutters_present)) {
if (XdrvMailbox.data_len > 0) {
XdrvMailbox.payload = ShutterRealToPercentPosition(Shutter[XdrvMailbox.index-1].target_position, XdrvMailbox.index-1)+XdrvMailbox.payload;

2
tasmota/xdrv_30_exs_dimmer.ino
View File

@ -250,7 +250,7 @@ bool ExsSyncState()
void ExsDebugState()
{
#ifdef EXS_DEBUG
AddLog_P(LOG_LEVEL_DEBUG, PSTR("EXS: MCU v%d.%d, c0: On:%d,Dim:%d,Tbl:%d(%d%%), c1: On:%d,Dim:%d,Tbl:%d(%d%%), ChLock: %d"),
AddLog(LOG_LEVEL_DEBUG, PSTR("EXS: MCU v%d.%d, c0: On:%d,Dim:%d,Tbl:%d(%d%%), c1: On:%d,Dim:%d,Tbl:%d(%d%%), ChLock: %d"),
Exs.dimmer.version_major, Exs.dimmer.version_minor,
Exs.dimmer.channel[0].on, Exs.dimmer.channel[0].dimm,
Exs.dimmer.channel[0].bright_tbl,

2
tasmota/xdrv_31_tasmota_client.ino
View File

@ -95,7 +95,7 @@ uint32_t SimpleHexParseLine(char *hexline) {
uint8_t addr_l = SimpleHexParseGetByte(hexline, 3);
uint8_t rectype = SimpleHexParseGetByte(hexline, 4);
// AddLog_P(LOG_LEVEL_DEBUG, PSTR("DBG: Hexline |%s|, Len %d, Address 0x%02X%02X, RecType %d"), hexline, len, addr_h, addr_l, rectype);
// AddLog(LOG_LEVEL_DEBUG, PSTR("DBG: Hexline |%s|, Len %d, Address 0x%02X%02X, RecType %d"), hexline, len, addr_h, addr_l, rectype);
if (len > 16) { return 5; } // Error: Line too long
if (rectype > 1) { return 6; } // Error: Invalid record type

12
tasmota/xdrv_40_telegram.ino
View File

@ -104,7 +104,7 @@ bool TelegramInit(void) {
}
String TelegramConnectToTelegram(String command) {
// AddLog_P(LOG_LEVEL_DEBUG, PSTR("TGM: Cmnd %s"), command.c_str());
// AddLog(LOG_LEVEL_DEBUG, PSTR("TGM: Cmnd %s"), command.c_str());
if (!TelegramInit()) { return ""; }
@ -201,13 +201,13 @@ void TelegramGetUpdates(uint32_t offset) {
// }
// ]}
AddLog_P(LOG_LEVEL_DEBUG_MORE, PSTR("TGM: Response %s"), response.c_str());
AddLog(LOG_LEVEL_DEBUG_MORE, PSTR("TGM: Response %s"), response.c_str());
JsonParser parser((char*)response.c_str());
JsonParserObject root = parser.getRootObject();
if (root) {
// AddLog_P(LOG_LEVEL_DEBUG, PSTR("TGM: Sent Update request messages up to %s"), offset.c_str());
// AddLog(LOG_LEVEL_DEBUG, PSTR("TGM: Sent Update request messages up to %s"), offset.c_str());
JsonParserArray arr = root[PSTR("result")];
uint32_t max_updates = arr.size();
@ -235,7 +235,7 @@ void TelegramGetUpdates(uint32_t offset) {
}
Telegram.next_update_id = Telegram.message[i].update_id +1; // Write id of last read message
AddLog_P(LOG_LEVEL_DEBUG_MORE, PSTR("TGM: Parsed update_id %d, chat_id %s, text \"%s\""), Telegram.message[i].update_id, Telegram.message[i].chat_id.c_str(), Telegram.message[i].text.c_str());
AddLog(LOG_LEVEL_DEBUG_MORE, PSTR("TGM: Parsed update_id %d, chat_id %s, text \"%s\""), Telegram.message[i].update_id, Telegram.message[i].chat_id.c_str(), Telegram.message[i].text.c_str());
}
} else {
// AddLog(LOG_LEVEL_DEBUG, PSTR("TGM: No new messages"));
@ -256,7 +256,7 @@ bool TelegramSendMessage(String chat_id, String text) {
String command = "bot" + _token + "/sendMessage?chat_id=" + chat_id + "&text=" + UrlEncode(text);
String response = TelegramConnectToTelegram(command);
// AddLog_P(LOG_LEVEL_DEBUG_MORE, PSTR("TGM: Response %s"), response.c_str());
// AddLog(LOG_LEVEL_DEBUG_MORE, PSTR("TGM: Response %s"), response.c_str());
if (response.startsWith("{\"ok\":true")) {
// AddLog(LOG_LEVEL_DEBUG, PSTR("TGM: Message sent"));
@ -279,7 +279,7 @@ void TelegramSendGetMe(void) {
// {"ok":true,"result":{"id":1179906608,"is_bot":true,"first_name":"Tasmota","username":"tasmota_bot","can_join_groups":true,"can_read_all_group_messages":false,"supports_inline_queries":false}}
// AddLog_P(LOG_LEVEL_DEBUG_MORE, PSTR("TGM: Response %s"), response.c_str());
// AddLog(LOG_LEVEL_DEBUG_MORE, PSTR("TGM: Response %s"), response.c_str());
}
*/

4
tasmota/xdrv_41_tcp_bridge.ino
View File

@ -90,7 +90,7 @@ void TCPLoop(void)
}
}
if (buf_len > 0) {
AddLog_P(LOG_LEVEL_DEBUG, PSTR(D_LOG_TCP "from MCU: %*_H"), buf_len, tcp_buf);
AddLog(LOG_LEVEL_DEBUG, PSTR(D_LOG_TCP "from MCU: %*_H"), buf_len, tcp_buf);
for (uint32_t i=0; i<nitems(client_tcp); i++) {
WiFiClient &client = client_tcp[i];
@ -110,7 +110,7 @@ void TCPLoop(void)
}
}
if (buf_len > 0) {
AddLog_P(LOG_LEVEL_DEBUG, PSTR(D_LOG_TCP "to MCU/%d: %*_H"), i+1, buf_len, tcp_buf);
AddLog(LOG_LEVEL_DEBUG, PSTR(D_LOG_TCP "to MCU/%d: %*_H"), i+1, buf_len, tcp_buf);
TCPSerial->write(tcp_buf, buf_len);
}
}

4
tasmota/xdrv_44_miel_hvac.ino
View File

@ -495,7 +495,7 @@ miel_hvac_send(struct miel_hvac_softc *sc, uint8_t type,
char hex_h[(sizeof(h) + 1) * 2];
char hex_d[(len + 1) * 2];
AddLog_P(LOG_LEVEL_DEBUG,
AddLog(LOG_LEVEL_DEBUG,
PSTR(MIEL_HVAC_LOGNAME ": sending %s %s %02x"),
ToHex_P((uint8_t *)&h, sizeof(h), hex_h, sizeof(hex_h)),
ToHex_P((uint8_t *)data, len, hex_d, sizeof(hex_d)),
@ -837,7 +837,7 @@ miel_hvac_log_bytes(struct miel_hvac_softc *sc, const char *name,
char hex[(MIEL_HVAC_DATABUFLEN + 1) * 2];
const unsigned char *b = (const unsigned char *)buf;
AddLog_P(LOG_LEVEL_DEBUG, PSTR(MIEL_HVAC_LOGNAME
AddLog(LOG_LEVEL_DEBUG, PSTR(MIEL_HVAC_LOGNAME
": response %s %s"), name, ToHex_P(b, len, hex, sizeof(hex)));
}

4
tasmota/xdrv_48_timeprop.ino
View File

@ -184,7 +184,7 @@ bool TimepropCommand()
bool serviced = true;
uint8_t ua_prefix_len = strlen(D_CMND_TIMEPROP); // to detect prefix of command
/*
AddLog_P(LOG_LEVEL_INFO, PSTR("Command called: "
AddLog(LOG_LEVEL_INFO, PSTR("Command called: "
"index: %d data_len: %d payload: %d topic: %s data: %s"),
XdrvMailbox.index,
XdrvMailbox.data_len,
@ -197,7 +197,7 @@ bool TimepropCommand()
int command_code = GetCommandCode(command, sizeof(command), XdrvMailbox.topic + ua_prefix_len, kTimepropCommands);
if (CMND_TIMEPROP_SETPOWER == command_code) {
/*
AddLog_P(LOG_LEVEL_INFO, PSTR("Timeprop command timeprop_setpower: "
AddLog(LOG_LEVEL_INFO, PSTR("Timeprop command timeprop_setpower: "
"index: %d data_len: %d payload: %d topic: %s data: %s"),
XdrvMailbox.index,
XdrvMailbox.data_len,

4
tasmota/xdrv_52_3_berry_tasmota.ino
View File

@ -382,7 +382,7 @@ extern "C" {
log_level = be_toint(vm, 3);
if (log_level > LOG_LEVEL_DEBUG_MORE) { log_level = LOG_LEVEL_DEBUG_MORE; }
}
AddLog_P(log_level, PSTR("%s"), msg);
AddLog(log_level, PSTR("%s"), msg);
be_return(vm); // Return
}
be_return_nil(vm); // Return nil when something goes wrong
@ -425,7 +425,7 @@ void berry_log(const char * berry_buf) {
}
// AddLog(LOG_LEVEL_INFO, PSTR("[Add to log] %s"), berry_buf);
berry.log.addString(berry_buf, pre_delimiter, "\n");
AddLog_P(LOG_LEVEL_INFO, PSTR("%s"), berry_buf);
AddLog(LOG_LEVEL_INFO, PSTR("%s"), berry_buf);
}
extern "C" {

8
tasmota/xdrv_52_9_berry.ino
View File

@ -408,7 +408,7 @@ void BrREPLRun(char * cmd) {
if (!be_isnil(berry.vm, 1)) {
const char * ret_val = be_tostring(berry.vm, 1);
berry.log.addString(ret_val, nullptr, "\n");
// AddLog_P(LOG_LEVEL_INFO, PSTR(">>> %s"), ret_val);
// AddLog(LOG_LEVEL_INFO, PSTR(">>> %s"), ret_val);
}
be_pop(berry.vm, 1);
}
@ -418,7 +418,7 @@ void BrREPLRun(char * cmd) {
char exception_s[120];
ext_snprintf_P(exception_s, sizeof(exception_s), PSTR("%s: %s"), be_tostring(berry.vm, -2), be_tostring(berry.vm, -1));
berry.log.addString(exception_s, nullptr, "\n");
// AddLog_P(LOG_LEVEL_INFO, PSTR(">>> %s"), exception_s);
// AddLog(LOG_LEVEL_INFO, PSTR(">>> %s"), exception_s);
be_pop(berry.vm, 2);
}
} while(0);
@ -602,7 +602,7 @@ void HandleBerryConsoleRefresh(void)
if (svalue.length()) {
berry.log.reset(); // clear all previous logs
berry.repl_active = true; // start recording
// AddLog_P(LOG_LEVEL_INFO, PSTR("BRY: received command %s"), svalue.c_str());
// AddLog(LOG_LEVEL_INFO, PSTR("BRY: received command %s"), svalue.c_str());
berry.log.addString(svalue.c_str(), nullptr, BERRY_CONSOLE_CMD_DELIMITER);
// Call berry
@ -655,7 +655,7 @@ void HandleBerryConsole(void)
// String svalue = Webserver->arg(F("c1"));
// if (svalue.length() && (svalue.length() < MQTT_MAX_PACKET_SIZE)) {
// // TODO run command and store result
// // AddLog_P(LOG_LEVEL_INFO, PSTR(D_LOG_COMMAND "%s"), svalue.c_str());
// // AddLog(LOG_LEVEL_INFO, PSTR(D_LOG_COMMAND "%s"), svalue.c_str());
// // ExecuteWebCommand((char*)svalue.c_str(), SRC_WEBCONSOLE);
// }

40
tasmota/xdrv_53_projector_ctrl.ino
View File

@ -103,7 +103,7 @@ projector_ctrl_pre_init(void)
sc = (struct projector_ctrl_softc_s *)malloc(sizeof(*sc));
if (sc == NULL) {
AddLog_P(LOG_LEVEL_ERROR, PSTR(PROJECTOR_CTRL_LOGNAME ": unable to allocate state"));
AddLog(LOG_LEVEL_ERROR, PSTR(PROJECTOR_CTRL_LOGNAME ": unable to allocate state"));
return;
}
@ -113,7 +113,7 @@ projector_ctrl_pre_init(void)
Pin(GPIO_PROJECTOR_CTRL_TX), 2);
if (!sc->sc_serial->begin(baudrate, 2)) {
AddLog_P(LOG_LEVEL_ERROR, PSTR(PROJECTOR_CTRL_LOGNAME ": unable to begin serial "
AddLog(LOG_LEVEL_ERROR, PSTR(PROJECTOR_CTRL_LOGNAME ": unable to begin serial "
"(baudrate %d)"), baudrate);
goto del;
}
@ -125,7 +125,7 @@ projector_ctrl_pre_init(void)
sc->sc_device = ++(TasmotaGlobal.devices_present); /* claim a POWER device slot */
AddLog_P(LOG_LEVEL_INFO, PSTR(PROJECTOR_CTRL_LOGNAME ": new RELAY%d, polling serial for Projector status"), sc->sc_device);
AddLog(LOG_LEVEL_INFO, PSTR(PROJECTOR_CTRL_LOGNAME ": new RELAY%d, polling serial for Projector status"), sc->sc_device);
projector_ctrl_sc = sc;
return;
@ -156,13 +156,13 @@ projector_ctrl_write(struct projector_ctrl_softc_s *sc, const uint8_t *bytes, co
serial->write(cksum);
#ifdef DEBUG_PROJECTOR_CTRL
char hex_b[(len + 1) * 2];
AddLog_P(LOG_LEVEL_DEBUG,PSTR(PROJECTOR_CTRL_LOGNAME ": RAW bytes %s %02x"),
AddLog(LOG_LEVEL_DEBUG,PSTR(PROJECTOR_CTRL_LOGNAME ": RAW bytes %s %02x"),
ToHex_P((uint8_t *)bytes, len, hex_b, sizeof(hex_b)), cksum);
#endif //DEBUG_PROJECTOR_CTRL
#else //!USE_PROJECTOR_CTRL_NEC
#ifdef DEBUG_PROJECTOR_CTRL
char hex_b[(len + 1) * 2];
AddLog_P(LOG_LEVEL_DEBUG,PSTR(PROJECTOR_CTRL_LOGNAME ": RAW bytes %s"),
AddLog(LOG_LEVEL_DEBUG,PSTR(PROJECTOR_CTRL_LOGNAME ": RAW bytes %s"),
ToHex_P((uint8_t *)bytes, len, hex_b, sizeof(hex_b)));
#endif //DEBUG_PROJECTOR_CTRL
#endif //!USE_PROJECTOR_CTRL_NEC
@ -182,7 +182,7 @@ projector_ctrl_request(struct projector_ctrl_softc_s *sc, const uint8_t command)
if ((sc->sc_dev_state!=PROJECTOR_CTRL_DEV_UNKNOWN)&&(sc->sc_ser_state!=PROJECTOR_CTRL_S_IDLE)) {
if ((command!=PROJECTOR_CTRL_S_QRY_PWR)&&(command!=PROJECTOR_CTRL_S_QRY_TYPE)) {
sc->sc_ser_next_cmd=(projector_ctrl_serial_state_e)command;
AddLog_P(LOG_LEVEL_INFO, PSTR(PROJECTOR_CTRL_LOGNAME
AddLog(LOG_LEVEL_INFO, PSTR(PROJECTOR_CTRL_LOGNAME
": Serial CMD %02x already running, enqueueing next (%02x)"), sc->sc_ser_state, command);
};
return;
@ -199,7 +199,7 @@ projector_ctrl_request(struct projector_ctrl_softc_s *sc, const uint8_t command)
sc->sc_ser_next_cmd=PROJECTOR_CTRL_S_UNCONNECTED;
sc->sc_ticks=0;
#ifdef DEBUG_PROJECTOR_CTRL
AddLog_P(LOG_LEVEL_DEBUG, PSTR(PROJECTOR_CTRL_LOGNAME
AddLog(LOG_LEVEL_DEBUG, PSTR(PROJECTOR_CTRL_LOGNAME
": Sending CMD %02x"), command);
#endif //DEBUG_PROJECTOR_CTRL
projector_ctrl_write(sc,e->send_codes,e->send_len);
@ -207,7 +207,7 @@ projector_ctrl_request(struct projector_ctrl_softc_s *sc, const uint8_t command)
}
};
#ifdef DEBUG_PROJECTOR_CTRL
AddLog_P(LOG_LEVEL_DEBUG, PSTR(PROJECTOR_CTRL_LOGNAME
AddLog(LOG_LEVEL_DEBUG, PSTR(PROJECTOR_CTRL_LOGNAME
": Undefined serial command %02x"), command);
#endif //DEBUG_PROJECTOR_CTRL
return;
@ -227,7 +227,7 @@ projector_ctrl_parse(struct projector_ctrl_softc_s *sc, const uint8_t byte)
case PROJECTOR_CTRL_S_IDLE:
case PROJECTOR_CTRL_S_UNCONNECTED:
#ifdef DEBUG_PROJECTOR_CTRL
AddLog_P(LOG_LEVEL_DEBUG, PSTR(PROJECTOR_CTRL_LOGNAME
AddLog(LOG_LEVEL_DEBUG, PSTR(PROJECTOR_CTRL_LOGNAME
": Spurious input in state %02x, got %02x, going UNCONNECTED"), nstate, byte);
#endif //DEBUG_PROJECTOR_CTRL
return(PROJECTOR_CTRL_S_UNCONNECTED);
@ -239,18 +239,18 @@ projector_ctrl_parse(struct projector_ctrl_softc_s *sc, const uint8_t byte)
if (byte==cmd->pass_first_byte){
sc->sc_ser_result=PROJECTOR_CTRL_R_PASS;
#ifdef DEBUG_PROJECTOR_CTRL
AddLog_P(LOG_LEVEL_DEBUG, PSTR(PROJECTOR_CTRL_LOGNAME
AddLog(LOG_LEVEL_DEBUG, PSTR(PROJECTOR_CTRL_LOGNAME
": CMD %02x PASS, 1st byte %02x"), nstate, byte);
#endif //DEBUG_PROJECTOR_CTRL
}else if (byte==cmd->fail_first_byte){
sc->sc_ser_result=PROJECTOR_CTRL_R_FAIL;
#ifdef DEBUG_PROJECTOR_CTRL
AddLog_P(LOG_LEVEL_DEBUG, PSTR(PROJECTOR_CTRL_LOGNAME
AddLog(LOG_LEVEL_DEBUG, PSTR(PROJECTOR_CTRL_LOGNAME
": CMD %02x FAIL, 1st byte %02x"), nstate, byte);
#endif //DEBUG_PROJECTOR_CTRL
}else{
#ifdef DEBUG_PROJECTOR_CTRL
AddLog_P(LOG_LEVEL_DEBUG, PSTR(PROJECTOR_CTRL_LOGNAME
AddLog(LOG_LEVEL_DEBUG, PSTR(PROJECTOR_CTRL_LOGNAME
": CMD %02x UNKNOWN, 1st byte %02x, going UNCONNECTED"), nstate, byte);
#endif //DEBUG_PROJECTOR_CTRL
return(PROJECTOR_CTRL_S_UNCONNECTED);
@ -265,7 +265,7 @@ projector_ctrl_parse(struct projector_ctrl_softc_s *sc, const uint8_t byte)
#ifdef USE_PROJECTOR_CTRL_NEC
if(sc->sc_ser_sum!=byte){
#ifdef DEBUG_PROJECTOR_CTRL
AddLog_P(LOG_LEVEL_DEBUG, PSTR(PROJECTOR_CTRL_LOGNAME
AddLog(LOG_LEVEL_DEBUG, PSTR(PROJECTOR_CTRL_LOGNAME
": Failed cksum for CMD %02x. Got %02x bytes, computed cksum: %02x, recevied cksum: %02x, going UNCONNECTED"),
nstate, sc->sc_ser_len, sc->sc_ser_sum, byte);
#endif //DEBUG_PROJECTOR_CTRL
@ -274,7 +274,7 @@ projector_ctrl_parse(struct projector_ctrl_softc_s *sc, const uint8_t byte)
#endif //USE_PROJECTOR_CTRL_NEC
{
#ifdef DEBUG_PROJECTOR_CTRL
AddLog_P(LOG_LEVEL_DEBUG, PSTR(PROJECTOR_CTRL_LOGNAME
AddLog(LOG_LEVEL_DEBUG, PSTR(PROJECTOR_CTRL_LOGNAME
": CMD %02x PASS, got %02x bytes, retval %02x, going IDLE"), nstate, sc->sc_ser_len, sc->sc_ser_value);
#endif //DEBUG_PROJECTOR_CTRL
nstate=PROJECTOR_CTRL_S_IDLE;
@ -291,7 +291,7 @@ projector_ctrl_parse(struct projector_ctrl_softc_s *sc, const uint8_t byte)
#ifdef USE_PROJECTOR_CTRL_NEC
if(sc->sc_ser_sum!=byte){
#ifdef DEBUG_PROJECTOR_CTRL
AddLog_P(LOG_LEVEL_DEBUG, PSTR(PROJECTOR_CTRL_LOGNAME
AddLog(LOG_LEVEL_DEBUG, PSTR(PROJECTOR_CTRL_LOGNAME
": Failed cksum for CMD %02x. Got %02x bytes, computed cksum: %02x, receied cksum: %02x, going UNCONNECTED"),
nstate, sc->sc_ser_len, sc->sc_ser_sum, byte);
#endif //DEBUG_PROJECTOR_CTRL
@ -300,7 +300,7 @@ projector_ctrl_parse(struct projector_ctrl_softc_s *sc, const uint8_t byte)
#endif //USE_PROJECTOR_CTRL_NEC
{
#ifdef DEBUG_PROJECTOR_CTRL
AddLog_P(LOG_LEVEL_DEBUG, PSTR(PROJECTOR_CTRL_LOGNAME
AddLog(LOG_LEVEL_DEBUG, PSTR(PROJECTOR_CTRL_LOGNAME
": CMD %02x FAIL, got %02x bytes, retval %02x, going idle"), nstate, sc->sc_ser_len, sc->sc_ser_value);
#endif //DEBUG_PROJECTOR_CTRL
nstate=PROJECTOR_CTRL_S_IDLE;
@ -333,13 +333,13 @@ projector_ctrl_loop(struct projector_ctrl_softc_s *sc)
case PROJECTOR_CTRL_S_UNCONNECTED:
if (sc->sc_dev_state!=PROJECTOR_CTRL_DEV_UNKNOWN){
sc->sc_dev_state=PROJECTOR_CTRL_DEV_UNKNOWN;
AddLog_P(LOG_LEVEL_INFO,PSTR(PROJECTOR_CTRL_LOGNAME ": DISCONNECTED(unexpected input)"));
AddLog(LOG_LEVEL_INFO,PSTR(PROJECTOR_CTRL_LOGNAME ": DISCONNECTED(unexpected input)"));
}
break;
case PROJECTOR_CTRL_S_IDLE:
if ((oldstate==PROJECTOR_CTRL_S_QRY_PWR)&&(sc->sc_ser_result==PROJECTOR_CTRL_R_PASS)){
if(sc->sc_dev_state==PROJECTOR_CTRL_DEV_UNKNOWN){
AddLog_P(LOG_LEVEL_INFO,PSTR(PROJECTOR_CTRL_LOGNAME ": CONNECTED"));
AddLog(LOG_LEVEL_INFO,PSTR(PROJECTOR_CTRL_LOGNAME ": CONNECTED"));
};
if(( (sc->sc_ser_value==PROJECTOR_CTRL_QRYPWR_ON)
||(sc->sc_ser_value==PROJECTOR_CTRL_QRYPWR_COOLING)
@ -396,7 +396,7 @@ projector_ctrl_tick(struct projector_ctrl_softc_s *sc)
};
}else if(sc->sc_ticks > sc->sc_cmd_info->timeout_ticks){
//current CMD has ran out of time, drop connection
AddLog_P(LOG_LEVEL_INFO,PSTR(PROJECTOR_CTRL_LOGNAME ": DISCONNECTED(timeout)"));
AddLog(LOG_LEVEL_INFO,PSTR(PROJECTOR_CTRL_LOGNAME ": DISCONNECTED(timeout)"));
sc->sc_dev_state=PROJECTOR_CTRL_DEV_UNKNOWN;
sc->sc_ser_state=PROJECTOR_CTRL_S_UNCONNECTED;
};
@ -410,7 +410,7 @@ projector_ctrl_set_power(struct projector_ctrl_softc_s *sc)
if (TasmotaGlobal.active_device==PROJECTOR_CTRL_PWR_BY_RELAY){
if ((sc->sc_dev_state == PROJECTOR_CTRL_DEV_PWR_ON) && (0==bitRead(XdrvMailbox.index, PROJECTOR_CTRL_PWR_BY_RELAY -1))) {
TasmotaGlobal.power = bitSet(TasmotaGlobal.power,PROJECTOR_CTRL_PWR_BY_RELAY -1);
AddLog_P(LOG_LEVEL_INFO,PSTR(PROJECTOR_CTRL_LOGNAME ": Keep RELAY" xxstr(PROJECTOR_CTRL_PWR_BY_RELAY) " ON"));
AddLog(LOG_LEVEL_INFO,PSTR(PROJECTOR_CTRL_LOGNAME ": Keep RELAY" xxstr(PROJECTOR_CTRL_PWR_BY_RELAY) " ON"));
} else {
return(false);
};

6
tasmota/xdrv_79_esp32_ble.ino
View File

@ -974,14 +974,14 @@ int SafeAddLog_P(uint32_t loglevel, PGM_P formatP, ...) {
vsnprintf_P(BLE_temp_log_data, maxlen, formatP, arg);
va_end(arg);
#ifdef USE_NATIVE_LOGGING
AddLog_P(loglevel, PSTR("%s"), BLE_temp_log_data);
AddLog(loglevel, PSTR("%s"), BLE_temp_log_data);
return 1;
#else
if (thistask == TasmotaMainTask){
loglevel = LOG_LEVEL_ERROR;
snprintf(BLE_temp_log_data + strlen(BLE_temp_log_data), 13, "-!MAINTHREAD!");
xSemaphoreGive(SafeLogMutex); // release mutex
AddLog_P(loglevel, PSTR("%s"), BLE_temp_log_data);
AddLog(loglevel, PSTR("%s"), BLE_temp_log_data);
return 0;
}
@ -3395,7 +3395,7 @@ static void BLEDiag()
uint32_t totalCount = BLEAdvertisment.totalCount;
uint32_t deviceCount = seenDevices.size();
#ifdef BLE_ESP32_DEBUG
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_INFO,PSTR("BLE: scans:%u,advertisements:%u,devices:%u,resets:%u,BLEStop:%d,BLERunning:%d,BLERunningScan:%d,BLELoopCount:%u,BLEOpCount:%u"), BLEScanCount, totalCount, deviceCount, BLEResets, BLEStop, BLERunning, BLERunningScan, BLELoopCount, BLEOpCount);
if (BLEDebugMode > 0) AddLog(LOG_LEVEL_INFO,PSTR("BLE: scans:%u,advertisements:%u,devices:%u,resets:%u,BLEStop:%d,BLERunning:%d,BLERunningScan:%d,BLELoopCount:%u,BLEOpCount:%u"), BLEScanCount, totalCount, deviceCount, BLEResets, BLEStop, BLERunning, BLERunningScan, BLELoopCount, BLEOpCount);
#endif
}

407
tasmota/xdrv_98_product_test.ino Normal file
View File

@ -0,0 +1,407 @@
/*
xdrv_98_product_test.ino - Product test for Sonoff-Tasmota
Copyright (C) 2021 Theo Arends and Adrian Scillato
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 PRODUCT_TEST // Enable this to include Tuya product test protocol
#define PRODUCT_TEST_DEBUG // Enable to compile status messages as shown below
#define PRODUCT_TEST_SSID "FACILITY_SSID" // <-- CHANGE THIS TO YOURS
#define PRODUCT_VOLTAGE "220.0" // Volt
#define PRODUCT_CURRENT "392.0" // milliAmpere
#define PRODUCT_POWER "87.0" // Watt
#define PRODUCT_CALIBRATE_CYCLE 20 // Seconds - Need at least 8 seconds
#define PRODUCT_SCAN_INTERVAL 8 // Seconds
#define PRODUCT_SCAN_RETRY 4 // Scan retry count
#define PRODUCT_TEST_VERSION "3.2"
/*********************************************************************************************\
This code is supported starting with Tasmota version 9.2.0.
The product test will run at power on when both SSids are empty.
The test can be restarted by power cycling off then on.
*** Flash firmware
Write binary firmware.bin
esptool.py --port COM4 write_flash -fs 1MB -fm dout 0x0 firmware.bin
*** Typical succesful product test with succesful wifi scan
Initial Power ON
00:00:00 CFG: Use defaults
00:00:00 TST: Product test v3.0
00:00:00 TST: 1/6 Product test started using ssid tuya_mdev_test1
00:00:00 SRC: Restart
00:00:00 Project sonoff Sonoff Version 6.4.1.19(basic)-2_4_2
00:00:00 CFG: Saved to flash at FA, Count 2, Bytes 3584
00:00:00 WIF: WifiManager active for 3 minutes
00:00:00 WIF: Wifimanager set AccessPoint
00:00:00 HTP: Web server active on sonoff-2927 with IP address 192.168.4.1
00:00:01 CFG: Saved to flash at F9, Count 3, Bytes 3584
00:00:04 TST: Scanned SSId1 indebuurt1
00:00:04 TST: Scanned SSId2 indebuurt2
00:00:04 TST: Scanned SSId3 indebuurt3
00:00:04 TST: Scanned SSId4 tuya_mdev_test1
00:00:04 TST: 2/6 Wifi found
00:00:13 APP: Boot Count 1
Button pressed
00:00:15 TST: 3/6 Button pressed first time - Toggle relay and led once
00:00:15 APP: Button1 immediate
00:00:15 SRC: Button
00:00:15 RSL: stat/sonoff/RESULT = {"POWER":"ON"}
00:00:15 RSL: stat/sonoff/POWER = ON
Button pressed again
00:00:20 TST: 4/6 Button pressed second time - Toggle relay and led three times
00:00:21 RSL: stat/sonoff/RESULT = {"POWER":"OFF"}
00:00:21 RSL: stat/sonoff/POWER = OFF
00:00:22 RSL: stat/sonoff/RESULT = {"POWER":"ON"}
00:00:22 RSL: stat/sonoff/POWER = ON
00:00:23 RSL: stat/sonoff/RESULT = {"POWER":"OFF"}
00:00:23 RSL: stat/sonoff/POWER = OFF
00:00:24 TST: 5/6 Button test finished - Start calibration
00:00:27 CFG: Saved to flash at FB, Count 4, Bytes 3584
00:00:27 TST: 6/6 Product test finished - Save to power off
Device can and should be powered off now as it is in an unknown state
*** Restore Product test prerequisite
Power off device
\*********************************************************************************************/
#ifdef PRODUCT_TEST
/*********************************************************************************************\
* Product test procedure support
*
* - Initiate test if power on and no user SSIDs configured
* - Init test environment (Led OFF, flash save off)
* - Wait for wifi scan to find PRODUCT_TEST_SSID then start flashing led every 250 mSec
* - Wait for user press button then turn relay and led ON
* - Wait for user press button again then toggle relay and led 3 times and increment bootcount
* - If energy monitoring is detected calibrate Voltage, Current and Power
* - Wait for power down
\*********************************************************************************************/
/*********************************************************************************************\
* Examples to test a particular device:
*
* Set in user_config_override.h the following:
*
* #undef MODULE
* #define MODULE SONOFF_BASIC // [Module] Select default model (the list is kModuleNiceList() in file tasmota_template.h)
* #undef FALLBACK_MODULE
* #define FALLBACK_MODULE SONOFF_BASIC // to Select the default model as FALLBACK when the user does a RESET 1
*
* or
*
* #define USER_TEMPLATE "{\"NAME\":\"Shelly 2.5\",\"GPIO\":[320,0,32,0,224,193,0,0,640,192,608,225,3456,4736],\"FLAG\":0,\"BASE\":18}" // [Template] Set JSON template
*
* For ESP32 examples check user_config.h
*
\*********************************************************************************************/
#define XDRV_98 98
enum ProductTestStates { PROD_TEST_IDLE, PROD_TEST_START, PROD_TEST_WIFI, PROD_TEST_BUTTON, PROD_TEST_CALIBRATE, PROD_TEST_DONE };
struct PRODUCTTEST {
uint8_t state = PROD_TEST_IDLE; // No product test
uint8_t blink = 3; // Toggle relay three times
uint8_t button_step = 0; // Either initial power toggle or end of test
uint8_t last_button = 0; // Store initial power toggle last button state
uint8_t scan_interval = 2; // Seconds after power on
uint8_t scan_retry = PRODUCT_SCAN_RETRY +1;
uint8_t calibrate_state = PRODUCT_CALIBRATE_CYCLE; // Calibrate cycle max seconds
uint8_t calibrate_timer = 0; // 100mS timer
uint16_t save_data_counter;
uint8_t ledstate;
uint8_t button_single;
uint8_t global_state;
} prodtest;
bool ProductTestTrigger(void)
{
// AddLog(LOG_LEVEL_INFO, PSTR("TST: resetInfo %d, sta_ssid1 (%s), sta_ssid2 (%s), save_flag %d"), resetInfo.reason, SettingsText(SET_STASSID1), SettingsText(SET_STASSID2), Settings.save_flag);
if (((resetInfo.reason == REASON_DEFAULT_RST) || (resetInfo.reason == REASON_EXT_SYS_RST)) && // Power on
!strlen(SettingsText(SET_STASSID1)) && // No configured SSID1
!strlen(SettingsText(SET_STASSID2)) // No configured SSID2
) {
return true;
}
return false;
}
bool ProductTestSsidFound(void)
{
bool result = false;
if (prodtest.scan_interval) {
prodtest.scan_interval--;
if (!prodtest.scan_interval) {
prodtest.scan_retry--;
if (prodtest.scan_retry) {
prodtest.scan_interval = PRODUCT_SCAN_INTERVAL;
int n = WiFi.scanNetworks();
if (n > 0) {
for (int i = 0; i < n; i++) {
#ifdef PRODUCT_TEST_DEBUG
AddLog(LOG_LEVEL_DEBUG, PSTR("TST: Scanned SSId%d %s"), i +1, WiFi.SSID(i).c_str());
#endif
if (!strcasecmp_P(WiFi.SSID(i).c_str(), PSTR(PRODUCT_TEST_SSID))) { result = true; }
}
}
} else {
if (Wifi.config_type) {
TasmotaGlobal.blinks = 255; // Re-enable wifi config blinks
}
Settings.ledstate = prodtest.ledstate;
Settings.flag.global_state = prodtest.global_state;
TasmotaGlobal.save_data_counter = prodtest.save_data_counter;
#ifdef PRODUCT_TEST_DEBUG
AddLog(LOG_LEVEL_INFO, PSTR("TST: 6/6 Product test failed"));
#endif
prodtest.state = PROD_TEST_IDLE;
}
}
}
return result;
}
void ProductTestLedOff(void)
{
TasmotaGlobal.blinks = 0; // No blinks
SetLedLink(0);
SetLedPower(0);
}
void ProductTestInit(void)
{
if (ProductTestTrigger()) {
#ifdef PRODUCT_TEST_DEBUG
TasmotaGlobal.seriallog_level = 3; // Enable more serial logging
AddLog(LOG_LEVEL_INFO, PSTR("TST: Product test v" PRODUCT_TEST_VERSION));
#endif
// Prepare for product test procedure
prodtest.save_data_counter = TasmotaGlobal.save_data_counter;
TasmotaGlobal.save_data_counter = 32000; // Stop auto saving data - Updating Settings
prodtest.global_state = Settings.flag.global_state;
Settings.flag.global_state = 1; // Disable global state (wifi and mqtt) led blinks as it interferes with the test protocol
prodtest.ledstate = Settings.ledstate;
Settings.ledstate = 0; // Disable led power state as it interferes with the test protocol
ProductTestLedOff(); // Signal start of test
#ifdef PRODUCT_TEST_DEBUG
AddLog(LOG_LEVEL_INFO, PSTR("TST: 1/6 Product test started using ssid " PRODUCT_TEST_SSID));
#endif // PRODUCT_TEST_DEBUG
prodtest.state = PROD_TEST_START;
} else {
prodtest.state = PROD_TEST_IDLE;
}
}
bool ProductTestButton(void)
{
bool result = false; // Ignore
if (prodtest.state > PROD_TEST_IDLE) {
result = true; // Disable button processing
if (PROD_TEST_WIFI == prodtest.state) {
if ((PRESSED == XdrvMailbox.payload) && (NOT_PRESSED == prodtest.last_button)) { // Button pressed
if (0 == prodtest.button_step) {
#ifdef PRODUCT_TEST_DEBUG
AddLog(LOG_LEVEL_INFO, PSTR("TST: 3/6 Button pressed first time - Toggle relay and led once"));
#endif
ProductTestLedOff(); // Signal button pressed and activate relay
Settings.ledstate = 1; // Enable led power state
prodtest.button_step++;
result = false; // Process normal button press which will turn relay and led on
} else {
#ifdef PRODUCT_TEST_DEBUG
AddLog(LOG_LEVEL_INFO, PSTR("TST: 4/6 Button pressed second time - Toggle relay and led three times"));
#endif
prodtest.state = PROD_TEST_BUTTON;
result = true; // Disable further button processing
}
}
prodtest.last_button = XdrvMailbox.payload;
}
}
return result;
}
void ProductTestEverySecond(void)
{
if (PROD_TEST_IDLE == prodtest.state) {
return;
}
else if (PROD_TEST_START == prodtest.state) {
TasmotaGlobal.blinks = 0; // Disable blinks initiated by WifiManager
if (ProductTestSsidFound()) {
#ifdef PRODUCT_TEST_DEBUG
AddLog(LOG_LEVEL_INFO, PSTR("TST: 2/6 Wifi found"));
#endif
TasmotaGlobal.sleep = 0; // Disable sleep
TasmotaGlobal.restart_flag = 0; // No restart and enable blinks
TasmotaGlobal.ota_state_flag = 0; // No OTA and enable blinks
prodtest.button_single = Settings.flag.button_single;
Settings.flag.button_single = 1; // Allow only single press
TasmotaGlobal.blinks = 255; // Signal wifi connection with blinks
prodtest.state = PROD_TEST_WIFI;
}
}
else if (PROD_TEST_BUTTON == prodtest.state) {
if (prodtest.blink) {
prodtest.blink--;
ExecuteCommandPower(1, POWER_TOGGLE, SRC_IGNORE); // Toggle relay and led
} else {
if (TasmotaGlobal.energy_driver != ENERGY_NONE) {
prodtest.state = PROD_TEST_CALIBRATE;
} else {
#ifdef PRODUCT_TEST_DEBUG
AddLog(LOG_LEVEL_INFO, PSTR("TST: 5/6 Button test finished"));
#endif
prodtest.state = PROD_TEST_DONE;
}
}
}
else if (PROD_TEST_CALIBRATE == prodtest.state) {
if (prodtest.calibrate_state) {
prodtest.calibrate_state--;
if (PRODUCT_CALIBRATE_CYCLE -1 == prodtest.calibrate_state) {
#ifdef PRODUCT_TEST_DEBUG
AddLog(LOG_LEVEL_INFO, PSTR("TST: 5/6 Start calibration"));
#endif
ExecuteCommandPower(1, POWER_ON, SRC_IGNORE); // On relay and led - start energy measurment
}
else if ((prodtest.calibrate_state < PRODUCT_CALIBRATE_CYCLE -4) && (prodtest.calibrate_state > 1)) {
// Allow a few seconds before starting calibration
uint8_t all_done = 0;
if (HLW_PREF_PULSE == Settings.energy_power_calibration) {
char set_value[] = PRODUCT_POWER;
XdrvMailbox.data = set_value;
XdrvMailbox.data_len = sizeof(set_value);
Energy.command_code = CMND_POWERSET;
HlwCommand(); // Get calibrated setting
} else {
all_done++;
}
if (HLW_UREF_PULSE == Settings.energy_voltage_calibration) {
char set_value[] = PRODUCT_VOLTAGE;
XdrvMailbox.data = set_value;
XdrvMailbox.data_len = sizeof(set_value);
Energy.command_code = CMND_VOLTAGESET;
HlwCommand(); // Get calibrated setting
} else {
all_done++;
}
if (HLW_IREF_PULSE == Settings.energy_current_calibration) {
char set_value[] = PRODUCT_CURRENT;
XdrvMailbox.data = set_value;
XdrvMailbox.data_len = sizeof(set_value);
Energy.command_code = CMND_CURRENTSET;
HlwCommand(); // Get calibrated setting
} else {
all_done++;
}
if (3 == all_done) {
prodtest.calibrate_state = 2;
}
}
else if (1 == prodtest.calibrate_state) {
ExecuteCommandPower(1, POWER_OFF, SRC_IGNORE); // Off relay and led - stop energy measurment
}
else if (0 == prodtest.calibrate_state) {
// Save calibration data
uint32_t power_calibration = Settings.energy_power_calibration;
uint32_t voltage_calibration = Settings.energy_voltage_calibration;
uint32_t current_calibration = Settings.energy_current_calibration;
SettingsDefaultSet1(); // Reset any Settings change
SettingsDefaultSet2(); // Init default settings
// Store calibration data
Settings.energy_power_calibration = power_calibration;
Settings.energy_voltage_calibration = voltage_calibration;
Settings.energy_current_calibration = current_calibration;
SettingsSave(2);
TasmotaGlobal.save_data_counter = 32000; // Stop auto saving data - Updating Settings
}
} else {
prodtest.state = PROD_TEST_DONE;
SetLedLink(1); // Wifi led on - Succesful calibration
}
}
else if (PROD_TEST_DONE == prodtest.state) {
#ifdef PRODUCT_TEST_DEBUG
AddLog(LOG_LEVEL_INFO, PSTR("TST: 6/6 Product test finished - Save to power off"));
#endif
while (1) {
OsWatchLoop(); // Feed OsWatch timer to prevent restart
delay(50); // Satisfy SDK
}
}
}
void ProductTestEvery100mSecond(void)
{
if (PROD_TEST_CALIBRATE == prodtest.state) {
// Blink wifi led 2 flashes every 3 seconds - Calibrating
prodtest.calibrate_timer++;
if (1 == prodtest.calibrate_timer) {
SetLedLink(0); // Wifi led off
}
else if (12 == prodtest.calibrate_timer) {
SetLedLink(1); // Wifi led on
}
else if (16 == prodtest.calibrate_timer) {
prodtest.calibrate_timer = 0;
}
}
}
/*********************************************************************************************\
* Interface
\*********************************************************************************************/
bool Xdrv98(uint8_t function)
{
bool result = false;
switch (function) {
case FUNC_EVERY_100_MSECOND:
ProductTestEvery100mSecond();
break;
case FUNC_EVERY_SECOND:
ProductTestEverySecond();
break;
case FUNC_BUTTON_PRESSED:
result = ProductTestButton();
break;
case FUNC_PRE_INIT:
ProductTestInit();
break;
}
return result;
}
#endif // PRODUCT_TEST

2
tasmota/xdrv_99_debug.ino
View File

@ -480,7 +480,7 @@ void SetFlashMode(uint8_t mode)
void CmndHelp(void)
{
AddLog_P(LOG_LEVEL_INFO, PSTR("HLP: %s"), kDebugCommands);
AddLog(LOG_LEVEL_INFO, PSTR("HLP: %s"), kDebugCommands);
ResponseCmndDone();
}

4
tasmota/xlgt_05_sonoff_l1.ino
View File

@ -78,7 +78,7 @@ void SnfL1SendDelayed(void) {
void SnfL1Send(void) {
#ifdef SONOFF_L1_DEBUG1
AddLog_P(LOG_LEVEL_DEBUG, PSTR("SL1: Send %s"), Snfl1.buffer);
AddLog(LOG_LEVEL_DEBUG, PSTR("SL1: Send %s"), Snfl1.buffer);
#endif
Serial.print(Snfl1.buffer);
Serial.write(0x1B);
@ -106,7 +106,7 @@ bool SnfL1SerialInput(void) {
// AT+UPDATE="sequence":"34906","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_P(LOG_LEVEL_DEBUG, PSTR("SL1: Rcvd %s"), TasmotaGlobal.serial_in_buffer);
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

22
tasmota/xnrg_15_teleinfo.ino
View File

@ -686,7 +686,7 @@ bool TInfoCmd(void) {
// At least "EnergyConfig"
if (CMND_ENERGYCONFIG == Energy.command_code) {
AddLog_P(LOG_LEVEL_DEBUG, PSTR("TIC: len %d, data '%s'"), XdrvMailbox.data_len, XdrvMailbox.data ? XdrvMailbox.data : "null" );
AddLog(LOG_LEVEL_DEBUG, PSTR("TIC: len %d, data '%s'"), XdrvMailbox.data_len, XdrvMailbox.data ? XdrvMailbox.data : "null" );
// Just "EnergyConfig" no more parameter
// Show Teleinfo configuration
@ -703,7 +703,7 @@ bool TInfoCmd(void) {
GetTextIndexed(mode_name, MAX_TINFO_COMMAND_NAME, index_mode, kTInfo_Commands);
GetTextIndexed(raw_name, MAX_TINFO_COMMAND_NAME, index_raw, kTInfo_Commands);
AddLog_P(LOG_LEVEL_INFO, TELEINFO_COMMAND_SETTINGS, mode_name, raw_name, Settings.teleinfo.raw_skip, Settings.teleinfo.raw_limit);
AddLog(LOG_LEVEL_INFO, TELEINFO_COMMAND_SETTINGS, mode_name, raw_name, Settings.teleinfo.raw_skip, Settings.teleinfo.raw_limit);
serviced = true;
@ -730,7 +730,7 @@ bool TInfoCmd(void) {
int command_code = GetCommandCode(command, sizeof(command), pParam, kTInfo_Commands);
AddLog_P(LOG_LEVEL_DEBUG, PSTR("TIC: param '%s' cmnd %d"), pParam, command_code);
AddLog(LOG_LEVEL_DEBUG, PSTR("TIC: param '%s' cmnd %d"), pParam, command_code);
switch (command_code) {
case CMND_TELEINFO_STANDARD:
@ -755,7 +755,7 @@ bool TInfoCmd(void) {
// Change mode
Settings.teleinfo.mode_standard = command_code == CMND_TELEINFO_STANDARD ? 1 : 0;
AddLog_P(LOG_LEVEL_INFO, PSTR("TIC: '%s' mode"), mode_name);
AddLog(LOG_LEVEL_INFO, PSTR("TIC: '%s' mode"), mode_name);
// Re init teleinfo (LibTeleinfo always free linked list on init)
TInfoInit();
@ -763,7 +763,7 @@ bool TInfoCmd(void) {
serviced = true;
} else {
AddLog_P(LOG_LEVEL_INFO, PSTR("TIC: No change to '%s' mode"), mode_name);
AddLog(LOG_LEVEL_INFO, PSTR("TIC: No change to '%s' mode"), mode_name);
}
}
break;
@ -787,7 +787,7 @@ bool TInfoCmd(void) {
Settings.teleinfo.raw_report_changed = command_code == CMND_TELEINFO_RAW_CHANGE ? 1 : 0;
}
AddLog_P(LOG_LEVEL_INFO, PSTR("TIC: Raw to '%s'"), raw_name);
AddLog(LOG_LEVEL_INFO, PSTR("TIC: Raw to '%s'"), raw_name);
serviced = true;
}
break;
@ -808,22 +808,22 @@ bool TInfoCmd(void) {
Settings.teleinfo.raw_skip = raw_skip;
if (raw_skip ==0) {
AddLog_P(LOG_LEVEL_INFO, PSTR("TIC: Raw no skip"));
AddLog(LOG_LEVEL_INFO, PSTR("TIC: Raw no skip"));
} else {
AddLog_P(LOG_LEVEL_INFO, PSTR("TIC: Raw each %d frame(s)"), raw_skip+1);
AddLog(LOG_LEVEL_INFO, PSTR("TIC: Raw each %d frame(s)"), raw_skip+1);
}
serviced = true;
} else {
AddLog_P(LOG_LEVEL_INFO, PSTR("TIC: skip can be 0 to 255"));
AddLog(LOG_LEVEL_INFO, PSTR("TIC: skip can be 0 to 255"));
}
} else {
AddLog_P(LOG_LEVEL_INFO, PSTR("TIC: no skip value"));
AddLog(LOG_LEVEL_INFO, PSTR("TIC: no skip value"));
}
}
break;
default:
AddLog_P(LOG_LEVEL_INFO, PSTR("TIC: bad cmd param '%s'"), pParam);
AddLog(LOG_LEVEL_INFO, PSTR("TIC: bad cmd param '%s'"), pParam);
break;
}

4
tasmota/xnrg_19_cse7761.ino
View File

@ -516,13 +516,13 @@ void Cse7761DumpRegs(void) {
for (uint32_t i = 0; i < 23; i++) {
snprintf_P(reg_data, sizeof(reg_data), PSTR("%s%s%8X"), reg_data, (i) ? "," : "", reg_num[i]);
}
AddLog_P(LOG_LEVEL_DEBUG, PSTR("C61: RegDump %s"), reg_data);
AddLog(LOG_LEVEL_DEBUG, PSTR("C61: RegDump %s"), reg_data);
reg_data[0] = '\0';
for (uint32_t i = 0; i < 23; i++) {
snprintf_P(reg_data, sizeof(reg_data), PSTR("%s%s%08X"), reg_data, (i) ? "," : "", registers[i]);
}
AddLog_P(LOG_LEVEL_DEBUG, PSTR("C61: RegDump %s"), reg_data);
AddLog(LOG_LEVEL_DEBUG, PSTR("C61: RegDump %s"), reg_data);
}
*/

2
tasmota/xnrg_20_dummy.ino
View File

@ -101,7 +101,7 @@ bool NrgDummyCommand(void) {
}
}
else if (CMND_ENERGYCONFIG == Energy.command_code) {
AddLog_P(LOG_LEVEL_DEBUG, PSTR("NRG: Config index %d, payload %d, data '%s'"),
AddLog(LOG_LEVEL_DEBUG, PSTR("NRG: Config index %d, payload %d, data '%s'"),
XdrvMailbox.index, XdrvMailbox.payload, XdrvMailbox.data ? XdrvMailbox.data : "null" );
}
else serviced = false; // Unknown command

2
tasmota/xsns_15_mhz19.ino
View File

@ -123,7 +123,7 @@ size_t MhzSendCmd(uint8_t command_id)
memcpy_P(&mhz_send[6], kMhzCommands[command_id] + sizeof(uint16_t), sizeof(uint16_t));
mhz_send[8] = MhzCalculateChecksum(mhz_send);
// AddLog_P(LOG_LEVEL_DEBUG, PSTR("Final MhzCommand: %x %x %x %x %x %x %x %x %x"),mhz_send[0],mhz_send[1],mhz_send[2],mhz_send[3],mhz_send[4],mhz_send[5],mhz_send[6],mhz_send[7],mhz_send[8]);
// AddLog(LOG_LEVEL_DEBUG, PSTR("Final MhzCommand: %x %x %x %x %x %x %x %x %x"),mhz_send[0],mhz_send[1],mhz_send[2],mhz_send[3],mhz_send[4],mhz_send[5],mhz_send[6],mhz_send[7],mhz_send[8]);
return MhzSerial->write(mhz_send, sizeof(mhz_send));
}

6
tasmota/xsns_31_ccs811_v2.ino
View File

@ -150,7 +150,7 @@ void CCS811ReadMailboxValue( uint8_t address, uint8_t mailbox, byte * pbuf, uint
for (uint8_t i = 0; i < buflen; i++) {
*(pbuf + i) = Wire.read();
#ifdef CCS811_DEBUG
AddLog_P(LOG_LEVEL_DEBUG, PSTR( D_LOG_DEBUG D_PRFX_CCS811 " reading byte %u: 0%02x / %u"), i, *(pbuf + i), *(pbuf + i));
AddLog(LOG_LEVEL_DEBUG, PSTR( D_LOG_DEBUG D_PRFX_CCS811 " reading byte %u: 0%02x / %u"), i, *(pbuf + i), *(pbuf + i));
#endif
}
}
@ -159,7 +159,7 @@ void CCS811WriteMailboxValue(uint8_t address, uint8_t mailbox, byte * pbuf, uint
{
#ifdef CCS811_DEBUG
for (uint8_t i = 0; i < buflen; i++) {
AddLog_P(LOG_LEVEL_DEBUG, PSTR( D_LOG_DEBUG D_PRFX_CCS811 " writing byte %u: 0%02x / %u"), i, *(pbuf + i), *(pbuf + i));
AddLog(LOG_LEVEL_DEBUG, PSTR( D_LOG_DEBUG D_PRFX_CCS811 " writing byte %u: 0%02x / %u"), i, *(pbuf + i), *(pbuf + i));
}
#endif
Wire.beginTransmission(address);
@ -180,7 +180,7 @@ CCS811DATA * CmndCCS811SelectDeviceFromIndex(void) {
if (pccsd->device_index == XdrvMailbox.index) {
pccsd_command = pccsd;
#ifdef CCS811_DEBUG
AddLog_P(LOG_LEVEL_DEBUG, PSTR( D_LOG_DEBUG D_PRFX_CCS811 " I2C Address: 0%02x"), pccsd_command->address);
AddLog(LOG_LEVEL_DEBUG, PSTR( D_LOG_DEBUG D_PRFX_CCS811 " I2C Address: 0%02x"), pccsd_command->address);
#endif
break;
}

357
tasmota/xsns_31_ccs811_v2_test.ino Normal file
View File

@ -0,0 +1,357 @@
/*
xsns_31_ccs811_v2.ino - CCS811 gas and air quality sensor support for Tasmota
Copyright (C) 2021 Gerhard Mutz and 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_I2C
#ifdef USE_CCS811_V2_TEST
/*********************************************************************************************\
* CCS811 - Gas (TVOC - Total Volatile Organic Compounds) and Air Quality (CO2)
*
* Source: Adafruit
*
* This driver supports one to two devices at a time at
* addressses 0x5A or/and 0x5B
* - for I2C address 0x5A, connect ADDR to GND
* - for I2C address 0x5B, connect ADDR to VCC
* NOTE:
* - Wake must be connected to GND (no sleep mode supported!)
* - depending on the breakout bouard, SDA & SCL may require
* pull-ups to VCC, e.g. 4k7R
*
\*********************************************************************************************/
#define XSNS_31 31
#define XI2C_24 24 // See I2CDEVICES.md
#define EVERYNSECONDS 5
#define RESETCOUNT 6
#include "Adafruit_CCS811.h"
uint8_t CCS811_addresses[] = { CCS811_ADDRESS, (CCS811_ADDRESS + 1) };
#define MAXDEVICECOUNT (sizeof( CCS811_addresses) / sizeof(uint8_t))
typedef struct {
uint8_t address;
uint8_t device_found;
uint8_t device_index;
uint8_t device_ready;
Adafruit_CCS811 ccsinstance;
uint16_t eCO2;
uint16_t TVOC;
uint8_t refresh_count;
uint8_t reset_count;
} CCS811DATA;
uint8_t CCS811_devices_found = 0;
CCS811DATA ccsd[ MAXDEVICECOUNT];
CCS811DATA * pccsd;
uint32_t i;
#define D_CMND_CCS811 "CCS811"
const char S_JSON_CCS811_COMMAND_XVALUE[] PROGMEM = "{\"" D_CMND_CCS811 "%s\":0x%02x}";
const char S_JSON_CCS811_COMMAND_NVALUE[] PROGMEM = "{\"" D_CMND_CCS811 "%s\":%u}";
const char S_JSON_CCS811_COMMAND_HWVERSION[] PROGMEM = "{\"" D_CMND_CCS811 "%s\":\"%x\"}";
const char S_JSON_CCS811_COMMAND_FWAPPVERSION[] PROGMEM = "{\"" D_CMND_CCS811 "%s\":\"%x.%x.%x\"}";
const char S_JSON_CCS811_COMMAND[] PROGMEM = "{\"" D_CMND_CCS811 "%s\"}";
const char kCCS811_Commands[] PROGMEM = "HW|FWApp|Baseline";
enum CCS811_Commands { // commands useable in console or rules
CMND_CCS811_HW,
CMND_CCS811_FWAPP,
CMND_CCS811_BASELINE
};
/********************************************************************************************/
void CCS811Detect(void)
{
if (!CCS811_devices_found) {
memset( ccsd, 0, sizeof( ccsd));
}
int active_index = 1;
for (i = 0, pccsd = ccsd; i < MAXDEVICECOUNT; i++, pccsd++) {
pccsd->address = CCS811_addresses[ i];
if (I2cActive( pccsd->address)) { continue; }
if (!pccsd->ccsinstance.begin(pccsd->address)) {
pccsd->device_found = 1;
CCS811_devices_found += 1;
I2cSetActiveFound( pccsd->address, "CCS811");
pccsd->device_index = active_index;
active_index++;
}
}
}
void CCS811Update(void) // Perform every n second
{
for (i = 0, pccsd = ccsd; i < MAXDEVICECOUNT; i++, pccsd++) {
if (!pccsd->device_found)
continue;
pccsd->refresh_count++;
if (pccsd->refresh_count >= EVERYNSECONDS) {
pccsd->refresh_count = 0;
pccsd->device_ready = 0;
if (pccsd->ccsinstance.available()) {
if (!pccsd->ccsinstance.readData()){
pccsd->TVOC = pccsd->ccsinstance.getTVOC();
pccsd->eCO2 = pccsd->ccsinstance.geteCO2();
pccsd->device_ready = 1;
if ((TasmotaGlobal.global_update) &&
(TasmotaGlobal.humidity > 0) &&
(!isnan(TasmotaGlobal.temperature_celsius))) {
pccsd->ccsinstance.setEnvironmentalData((uint8_t)TasmotaGlobal.humidity,
TasmotaGlobal.temperature_celsius);
}
pccsd->reset_count = 0;
}
} else {
// failed, count up
pccsd->reset_count++;
if (pccsd->reset_count > RESETCOUNT) {
// after 30 seconds, restart
pccsd->ccsinstance.begin( pccsd->address);
pccsd->reset_count = 0;
}
}
}
}
}
// no methods available in Adafruit library to read version data or
// read/set the baseline value, so we need to emulate the private methods
void CCS811ReadMailboxValue( uint8_t address, uint8_t mailbox, byte * pbuf, uint8_t buflen)
{
Wire.beginTransmission(address);
Wire.write(mailbox);
Wire.endTransmission();
Wire.requestFrom(address, buflen);
for (uint8_t i = 0; i < buflen; i++) {
*(pbuf + i) = Wire.read();
#ifdef CCS811_DEBUG
AddLog(LOG_LEVEL_DEBUG, PSTR( D_LOG_DEBUG D_CMND_CCS811 " reading byte %u: 0%02x / %u"), i, *(pbuf + i), *(pbuf + i));
#endif
}
}
void CCS811WriteMailboxValue(uint8_t address, uint8_t mailbox, byte * pbuf, uint8_t buflen)
{
#ifdef CCS811_DEBUG
for (uint8_t i = 0; i < buflen; i++) {
AddLog(LOG_LEVEL_DEBUG, PSTR( D_LOG_DEBUG D_CMND_CCS811 " writing byte %u: 0%02x / %u"), i, *(pbuf + i), *(pbuf + i));
}
#endif
Wire.beginTransmission(address);
Wire.write((uint8_t)mailbox);
Wire.write(pbuf, buflen);
Wire.endTransmission();
}
/*********************************************************************************************\
* Command Sensor31
\*********************************************************************************************/
bool CCS811CommandSensor()
{
char command[CMDSZ];
bool serviced = true;
uint8_t prefix_len = strlen(D_CMND_CCS811);
if ((!strncasecmp_P(XdrvMailbox.topic, PSTR(D_CMND_CCS811), prefix_len)) &&
(XdrvMailbox.index <= CCS811_devices_found)) { // check prefix and device index
int command_code = GetCommandCode(command, sizeof(command), XdrvMailbox.topic + prefix_len, kCCS811_Commands);
// select device data matching the index
CCS811DATA * pccsd_command;
for (i = 0, pccsd = ccsd; i < MAXDEVICECOUNT; i++, pccsd++) {
if (pccsd->device_index == XdrvMailbox.index) {
pccsd_command = pccsd;
#ifdef CCS811_DEBUG
AddLog(LOG_LEVEL_DEBUG, PSTR( D_LOG_DEBUG D_CMND_CCS811 " I2C Address: 0%02x"), pccsd_command->address);
#endif
break;
}
}
if (!pccsd_command) {
return false;
}
switch (command_code) {
case CMND_CCS811_HW:
{
byte CCS811_hw_version;
CCS811ReadMailboxValue( pccsd_command->address,
CCS811_HW_VERSION,
&CCS811_hw_version,
sizeof(CCS811_hw_version));
Response_P(S_JSON_CCS811_COMMAND_HWVERSION, command, CCS811_hw_version);
}
break;
case CMND_CCS811_FWAPP:
{
byte CCS811_fw_app_version[2];
CCS811ReadMailboxValue( pccsd_command->address,
CCS811_FW_APP_VERSION,
CCS811_fw_app_version,
(sizeof(CCS811_fw_app_version) / sizeof(byte)));
Response_P(S_JSON_CCS811_COMMAND_FWAPPVERSION,
command,
(CCS811_fw_app_version[0] >> 4), // major
(CCS811_fw_app_version[0] & 0xF), // minor
CCS811_fw_app_version[1]); // build
}
break;
case CMND_CCS811_BASELINE:
{
byte CCS811_baseline[2];
if (XdrvMailbox.data_len > 0) {
CCS811_baseline[0] = (XdrvMailbox.payload & 0xFF00) >> 8;
CCS811_baseline[1] = XdrvMailbox.payload & 0xFF;
CCS811WriteMailboxValue( pccsd_command->address,
CCS811_BASELINE,
CCS811_baseline,
(sizeof(CCS811_baseline) / sizeof(byte)));
} else {
CCS811ReadMailboxValue( pccsd_command->address,
CCS811_BASELINE,
CCS811_baseline,
(sizeof(CCS811_baseline) / sizeof(byte)));
}
Response_P(S_JSON_CCS811_COMMAND_NVALUE,
command,
((CCS811_baseline[0] << 8) + CCS811_baseline[1]));
}
break;
default:
// else for Unknown command
serviced = false;
break;
}
}
return serviced;
}
const char HTTP_SNS_CCS811[] PROGMEM =
"{s}%s " D_ECO2 "{m}%d " D_UNIT_PARTS_PER_MILLION "{e}" // {s} = <tr><th>, {m} = </th><td>, {e} = </td></tr>
"{s}%s " D_TVOC "{m}%d " D_UNIT_PARTS_PER_BILLION "{e}";
const char * devicenamelist[] PROGMEM = { "CCS811", "CCS811_1", "CCS811_2" };
void CCS811Show(bool json)
{
uint8_t ready_count = 0;
for (i = 0, pccsd = ccsd; i < MAXDEVICECOUNT; i++, pccsd++) {
if ((pccsd->device_found) && (pccsd->device_ready)) {
ready_count += 1;
}
}
if (!ready_count) {
return;
}
// in upcoming loops use either one device name
// with no index or or two names with index
const char ** pdevicename;
const char ** pdevicename_first = devicenamelist;
if (ready_count > 1) {
pdevicename_first++;
}
if (json) {
for (i = 0, pccsd = ccsd, pdevicename = pdevicename_first; i < MAXDEVICECOUNT; i++, pccsd++) {
if (pccsd->device_ready) {
ResponseAppend_P( PSTR(",\"%s\":{\"" D_JSON_ECO2 "\":%d,\"" D_JSON_TVOC "\":%d}"),
*pdevicename,
pccsd->eCO2,
pccsd->TVOC);
pdevicename++;
}
}
#ifdef USE_DOMOTICZ
if (0 == TasmotaGlobal.tele_period) {
if (pccsd->device_ready) {
pccsd = ccsd;
DomoticzSensor(DZ_AIRQUALITY, pccsd->eCO2);
}
}
#endif // USE_DOMOTICZ
#ifdef USE_WEBSERVER
} else {
for (i = 0, pccsd = ccsd, pdevicename = pdevicename_first; i < MAXDEVICECOUNT; i++, pccsd++) {
if (pccsd->device_ready) {
WSContentSend_PD( HTTP_SNS_CCS811,
*pdevicename, pccsd->eCO2,
*pdevicename, pccsd->TVOC);
pdevicename++;
}
}
#endif
}
}
/*********************************************************************************************\
* Interface
\*********************************************************************************************/
bool Xsns31(uint8_t function)
{
if (!I2cEnabled(XI2C_24)) { return false; }
bool result = false;
if (FUNC_INIT == function) {
CCS811Detect();
}
else if (CCS811_devices_found) {
switch (function) {
case FUNC_EVERY_SECOND:
CCS811Update();
break;
case FUNC_COMMAND:
result = CCS811CommandSensor();
break;
case FUNC_JSON_APPEND:
CCS811Show(1);
break;
#ifdef USE_WEBSERVER
case FUNC_WEB_SENSOR:
CCS811Show(0);
break;
#endif // USE_WEBSERVER
}
}
return result;
}
#endif // USE_CCS811_V2
#endif // USE_I2C

4
tasmota/xsns_37_rfsensor.ino
View File

@ -251,7 +251,7 @@ void RfSnsAnalyzeTheov2(void)
break;
}
AddLog_P(LOG_LEVEL_DEBUG, PSTR("RFS: TheoV2, ChkCalc %d, Chksum %d, id %d, Type %d, Ch %d, Volt %d, BattLo %d, Pld1 %d, Pld2 %d"),
AddLog(LOG_LEVEL_DEBUG, PSTR("RFS: TheoV2, ChkCalc %d, Chksum %d, id %d, Type %d, Ch %d, Volt %d, BattLo %d, Pld1 %d, Pld2 %d"),
chksum, Checksum, id, Type, Channel +1, Payload3, (Voltage & 0x80) >> 7, Payload1, Payload2);
}
@ -502,7 +502,7 @@ void RfSnsAnalyzeAlectov2()
rfsns_alecto_v2->wdir = data[8] & 0xf;
}
AddLog_P(LOG_LEVEL_DEBUG, PSTR("RFS: " D_ALECTOV2 ", ChkCalc %d, Chksum %d, rc %d, Temp %d, Hum %d, Rain %d, Wind %d, Gust %d, Dir %d, Factor %s"),
AddLog(LOG_LEVEL_DEBUG, PSTR("RFS: " D_ALECTOV2 ", ChkCalc %d, Chksum %d, rc %d, Temp %d, Hum %d, Rain %d, Wind %d, Gust %d, Dir %d, Factor %s"),
checksumcalc, checksum, rc, ((data[1] & 0x3) * 256 + data[2]) - 400, data[3], (data[6] * 256) + data[7], data[4], data[5], data[8] & 0xf, dtostrfd(factor, 3, buf1));
}

26
tasmota/xsns_42_scd30.ino
View File

@ -120,7 +120,7 @@ void Scd30Update(void)
scd30ErrorState = SCD30_STATE_ERROR_DATA_CRC;
scd30CrcError_count++;
#ifdef SCD30_DEBUG
AddLog_P(LOG_LEVEL_ERROR, PSTR("SCD30: CRC error, CRC error: %ld, CO2 zero: %ld, good: %ld, no data: %ld, sc30_reset: %ld, i2c_reset: %ld"),
AddLog(LOG_LEVEL_ERROR, PSTR("SCD30: CRC error, CRC error: %ld, CO2 zero: %ld, good: %ld, no data: %ld, sc30_reset: %ld, i2c_reset: %ld"),
scd30CrcError_count, scd30Co2Zero_count, scd30GoodMeas_count, scd30DataNotAvailable_count, scd30Reset_count, i2cReset_count);
#endif
break;
@ -128,7 +128,7 @@ void Scd30Update(void)
case ERROR_SCD30_CO2_ZERO:
scd30Co2Zero_count++;
#ifdef SCD30_DEBUG
AddLog_P(LOG_LEVEL_ERROR, PSTR("SCD30: CO2 zero, CRC error: %ld, CO2 zero: %ld, good: %ld, no data: %ld, sc30_reset: %ld, i2c_reset: %ld"),
AddLog(LOG_LEVEL_ERROR, PSTR("SCD30: CO2 zero, CRC error: %ld, CO2 zero: %ld, good: %ld, no data: %ld, sc30_reset: %ld, i2c_reset: %ld"),
scd30CrcError_count, scd30Co2Zero_count, scd30GoodMeas_count, scd30DataNotAvailable_count, scd30Reset_count, i2cReset_count);
#endif
break;
@ -136,7 +136,7 @@ void Scd30Update(void)
default: {
scd30ErrorState = SCD30_STATE_ERROR_READ_MEAS;
#ifdef SCD30_DEBUG
AddLog_P(LOG_LEVEL_ERROR, PSTR("SCD30: Update: ReadMeasurement error: 0x%lX, counter: %ld"), error, scd30Loop_count);
AddLog(LOG_LEVEL_ERROR, PSTR("SCD30: Update: ReadMeasurement error: 0x%lX, counter: %ld"), error, scd30Loop_count);
#endif
return;
}
@ -148,9 +148,9 @@ void Scd30Update(void)
case SCD30_STATE_ERROR_DATA_CRC: {
//scd30IsDataValid = false;
#ifdef SCD30_DEBUG
AddLog_P(LOG_LEVEL_ERROR, PSTR("SCD30: in error state: %d, good: %ld, no data: %ld, sc30 reset: %ld, i2c reset: %ld"),
AddLog(LOG_LEVEL_ERROR, PSTR("SCD30: in error state: %d, good: %ld, no data: %ld, sc30 reset: %ld, i2c reset: %ld"),
scd30ErrorState, scd30GoodMeas_count, scd30DataNotAvailable_count, scd30Reset_count, i2cReset_count);
AddLog_P(LOG_LEVEL_ERROR, PSTR("SCD30: got CRC error, try again, counter: %ld"), scd30Loop_count);
AddLog(LOG_LEVEL_ERROR, PSTR("SCD30: got CRC error, try again, counter: %ld"), scd30Loop_count);
#endif
scd30ErrorState = ERROR_SCD30_NO_ERROR;
}
@ -159,15 +159,15 @@ void Scd30Update(void)
case SCD30_STATE_ERROR_READ_MEAS: {
//scd30IsDataValid = false;
#ifdef SCD30_DEBUG
AddLog_P(LOG_LEVEL_ERROR, PSTR("SCD30: in error state: %d, good: %ld, no data: %ld, sc30 reset: %ld, i2c reset: %ld"),
AddLog(LOG_LEVEL_ERROR, PSTR("SCD30: in error state: %d, good: %ld, no data: %ld, sc30 reset: %ld, i2c reset: %ld"),
scd30ErrorState, scd30GoodMeas_count, scd30DataNotAvailable_count, scd30Reset_count, i2cReset_count);
AddLog_P(LOG_LEVEL_ERROR, PSTR("SCD30: not answering, sending soft reset, counter: %ld"), scd30Loop_count);
AddLog(LOG_LEVEL_ERROR, PSTR("SCD30: not answering, sending soft reset, counter: %ld"), scd30Loop_count);
#endif
scd30Reset_count++;
error = scd30.softReset();
if (error) {
#ifdef SCD30_DEBUG
AddLog_P(LOG_LEVEL_ERROR, PSTR("SCD30: resetting got error: 0x%lX"), error);
AddLog(LOG_LEVEL_ERROR, PSTR("SCD30: resetting got error: 0x%lX"), error);
#endif
error >>= 8;
if (error == 4) {
@ -184,16 +184,16 @@ void Scd30Update(void)
case SCD30_STATE_ERROR_SOFT_RESET: {
//scd30IsDataValid = false;
#ifdef SCD30_DEBUG
AddLog_P(LOG_LEVEL_ERROR, PSTR("SCD30: in error state: %d, good: %ld, no data: %ld, sc30 reset: %ld, i2c reset: %ld"),
AddLog(LOG_LEVEL_ERROR, PSTR("SCD30: in error state: %d, good: %ld, no data: %ld, sc30 reset: %ld, i2c reset: %ld"),
scd30ErrorState, scd30GoodMeas_count, scd30DataNotAvailable_count, scd30Reset_count, i2cReset_count);
AddLog_P(LOG_LEVEL_ERROR, PSTR("SCD30: clearing i2c bus"));
AddLog(LOG_LEVEL_ERROR, PSTR("SCD30: clearing i2c bus"));
#endif
i2cReset_count++;
error = scd30.clearI2CBus();
if (error) {
scd30ErrorState = SCD30_STATE_ERROR_I2C_RESET;
#ifdef SCD30_DEBUG
AddLog_P(LOG_LEVEL_ERROR, PSTR("SCD30: error clearing i2c bus: 0x%lX"), error);
AddLog(LOG_LEVEL_ERROR, PSTR("SCD30: error clearing i2c bus: 0x%lX"), error);
#endif
} else {
scd30ErrorState = ERROR_SCD30_NO_ERROR;
@ -204,7 +204,7 @@ void Scd30Update(void)
default: {
//scd30IsDataValid = false;
#ifdef SCD30_DEBUG
AddLog_P(LOG_LEVEL_ERROR, PSTR("SCD30: unknown error state: 0x%lX"), scd30ErrorState);
AddLog(LOG_LEVEL_ERROR, PSTR("SCD30: unknown error state: 0x%lX"), scd30ErrorState);
#endif
scd30ErrorState = SCD30_STATE_ERROR_SOFT_RESET; // try again
}
@ -340,7 +340,7 @@ bool Scd30CommandSensor()
if (error)
{
#ifdef SCD30_DEBUG
AddLog_P(LOG_LEVEL_ERROR, PSTR("SCD30: error getting FW version: 0x%lX"), error);
AddLog(LOG_LEVEL_ERROR, PSTR("SCD30: error getting FW version: 0x%lX"), error);
#endif
serviced = false;
}

18
tasmota/xsns_53_sml.ino
View File

@ -1856,7 +1856,7 @@ void SML_Decode(uint8_t index) {
if (lowByte(crc)!=smltbuf[mindex][pos]) goto nextsect;
if (highByte(crc)!=smltbuf[mindex][pos+1]) goto nextsect;
dval=mbus_dval;
//AddLog_P(LOG_LEVEL_INFO, PSTR(">> %s"),mp);
//AddLog(LOG_LEVEL_INFO, PSTR(">> %s"),mp);
mp++;
} else {
if (meter_desc_p[mindex].type=='p') {
@ -1879,7 +1879,7 @@ void SML_Decode(uint8_t index) {
meter_vars[vindex]=dval;
#endif
//AddLog_P(LOG_LEVEL_INFO, PSTR(">> %s"),mp);
//AddLog(LOG_LEVEL_INFO, PSTR(">> %s"),mp);
// get scaling factor
double fac = CharToDouble((char*)mp);
meter_vars[vindex] /= fac;
@ -2203,13 +2203,13 @@ char dstbuf[SML_SRCBSIZE*2];
Replace_Cmd_Vars(lp,1,dstbuf,sizeof(dstbuf));
lp+=SML_getlinelen(lp)+1;
uint32_t slen=strlen(dstbuf);
//AddLog_P(LOG_LEVEL_INFO, PSTR("%d - %s"),slen,dstbuf);
//AddLog(LOG_LEVEL_INFO, PSTR("%d - %s"),slen,dstbuf);
mlen+=slen+1;
if (*lp=='#') break;
if (*lp=='>') break;
if (*lp==0) break;
}
//AddLog_P(LOG_LEVEL_INFO, PSTR("len=%d"),mlen);
//AddLog(LOG_LEVEL_INFO, PSTR("len=%d"),mlen);
return mlen+32;
}
#else
@ -2221,7 +2221,7 @@ uint32_t SML_getscriptsize(char *lp) {
break;
}
}
//AddLog_P(LOG_LEVEL_INFO, PSTR("len=%d"),mlen);
//AddLog(LOG_LEVEL_INFO, PSTR("len=%d"),mlen);
return mlen;
}
#endif
@ -2406,7 +2406,7 @@ dddef_exit:
char dstbuf[SML_SRCBSIZE*2];
Replace_Cmd_Vars(lp, 1, dstbuf,sizeof(dstbuf));
lp += SML_getlinelen(lp);
//AddLog_P(LOG_LEVEL_INFO, PSTR("%s"),dstbuf);
//AddLog(LOG_LEVEL_INFO, PSTR("%s"),dstbuf);
char *lp1 = dstbuf;
if (*lp1 == '-' || isdigit(*lp1)) {
//toLogEOL(">>",lp);
@ -2783,10 +2783,10 @@ void SML_Check_Send(void) {
char *cp;
for (uint32_t cnt=sml_desc_cnt; cnt<meters_used; cnt++) {
if (script_meter_desc[cnt].trxpin>=0 && script_meter_desc[cnt].txmem) {
//AddLog_P(LOG_LEVEL_INFO, PSTR("100 ms>> %d - %s - %d"),sml_desc_cnt,script_meter_desc[cnt].txmem,script_meter_desc[cnt].tsecs);
//AddLog(LOG_LEVEL_INFO, PSTR("100 ms>> %d - %s - %d"),sml_desc_cnt,script_meter_desc[cnt].txmem,script_meter_desc[cnt].tsecs);
if ((sml_100ms_cnt>=script_meter_desc[cnt].tsecs)) {
sml_100ms_cnt=0;
//AddLog_P(LOG_LEVEL_INFO, PSTR("100 ms>> 2"),cp);
//AddLog(LOG_LEVEL_INFO, PSTR("100 ms>> 2"),cp);
if (script_meter_desc[cnt].max_index>1) {
script_meter_desc[cnt].index++;
if (script_meter_desc[cnt].index>=script_meter_desc[cnt].max_index) {
@ -2800,7 +2800,7 @@ void SML_Check_Send(void) {
//SML_Send_Seq(cnt,cp);
sml_desc_cnt++;
}
//AddLog_P(LOG_LEVEL_INFO, PSTR(">> %s"),cp);
//AddLog(LOG_LEVEL_INFO, PSTR(">> %s"),cp);
SML_Send_Seq(cnt,cp);
if (sml_desc_cnt>=meters_used) {
sml_desc_cnt=0;

4
tasmota/xsns_62_esp32_mi_ble.ino
View File

@ -2755,7 +2755,7 @@ void MI32ShowOneMISensor(){
id);
MqttPublish(SensorTopic);
//AddLog_P(LOG_LEVEL_DEBUG,PSTR("M32: %s: show some %d %s"),D_CMND_MI32, MI32.mqttCurrentSlot, TasmotaGlobal.mqtt_data);
//AddLog(LOG_LEVEL_DEBUG,PSTR("M32: %s: show some %d %s"),D_CMND_MI32, MI32.mqttCurrentSlot, TasmotaGlobal.mqtt_data);
}
MI32.mqttCurrentSingleSlot++;
}
@ -3011,7 +3011,7 @@ void MI32DiscoveryOneMISensor(){
//vTaskDelay(100/ portTICK_PERIOD_MS);
}
} // end if hass discovery
//AddLog_P(LOG_LEVEL_DEBUG,PSTR("M32: %s: show some %d %s"),D_CMND_MI32, MI32.mqttCurrentSlot, TasmotaGlobal.mqtt_data);
//AddLog(LOG_LEVEL_DEBUG,PSTR("M32: %s: show some %d %s"),D_CMND_MI32, MI32.mqttCurrentSlot, TasmotaGlobal.mqtt_data);
#endif //USE_HOME_ASSISTANT
}