/* xnrg_30_dummy.ino - Dummy energy sensor support for Tasmota Copyright (C) 2021 Theo Arends This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ #ifdef USE_ENERGY_SENSOR #ifdef USE_ENERGY_DUMMY /*********************************************************************************************\ * Provides dummy energy monitoring for up to three channels based on relay count * * User is supposed to enter valid data for Voltage, Current and Power using commands * VoltageSet 240 (= 240V), CurrentSet 0.417 (= 417mA) and PowerSet 100 (= 100W) or * VoltageCal 24000 (= 240V), CurrentCal 41666 (= 0.417A) and PowerCal 10000 (= 100W) * Each phase or channel can be set using commands overriding above commands * EnergyConfig1, EnergyConfig2 and EnergyConfig3 for Current phases (0.417 = 417mA) * EnergyConfig4, EnergyConfig5 and EnergyConfig6 for Active Power phases (100 = 100W) * In addition on ESP32 supporting more channels: * EnergyConfig11 to 18 for Current phases 1 to 8 (0.417 = 417mA) * EnergyConfig111 to 118 for Active Power phases 1 to 8 (100 = 100W) * * Active Power is adjusted to calculated Apparent Power (=U*I) if the latter is smaller than the first * * Enable by selecting any GPIO as Option A2 \*********************************************************************************************/ #define XNRG_30 30 #define NRG_DUMMY_U_COMMON true // Phase voltage = false, Common voltage = true #define NRG_DUMMY_F_COMMON true // Phase frequency = false, Common frequency = true #define NRG_DUMMY_DC false // AC = false, DC = true; #define NRG_DUMMY_OVERTEMP true // Use global temperature for overtemp detection #define NRG_DUMMY_UREF 24000 // Voltage 240.00 V (= P / I) #define NRG_DUMMY_IREF 41666 // Current 0.417 A (= P / U) #define NRG_DUMMY_PREF 10000 // Power 100.00 W (= U * I) #define NRG_DUMMY_FREF 5000 // Frequency 50.00 Hz /********************************************************************************************/ struct { int32_t current[ENERGY_MAX_PHASES] = { 0 }; int32_t power[ENERGY_MAX_PHASES] = { 0 }; } NrgDummy; void NrgDummyEverySecond(void) { if (Energy->power_on) { // Powered on for (uint32_t channel = 0; channel < Energy->phase_count; channel++) { float power_calibration = (float)EnergyGetCalibration(ENERGY_POWER_CALIBRATION, channel) / 100; float voltage_calibration = (float)EnergyGetCalibration(ENERGY_VOLTAGE_CALIBRATION, channel) / 100; float current_calibration = (float)EnergyGetCalibration(ENERGY_CURRENT_CALIBRATION, channel) / 100000; float frequency_calibration = (float)EnergyGetCalibration(ENERGY_FREQUENCY_CALIBRATION, channel) / 100; Energy->voltage[channel] = voltage_calibration; // V Energy->frequency[channel] = frequency_calibration; // Hz if (bitRead(TasmotaGlobal.power, channel)) { // Emulate power read only if device is powered on Energy->active_power[channel] = (NrgDummy.power[channel]) ? ((float)NrgDummy.power[channel] / 1000) : power_calibration; // W if (0 == Energy->active_power[channel]) { Energy->current[channel] = 0; } else { Energy->current[channel] = (NrgDummy.current[channel]) ? ((float)NrgDummy.current[channel] / 1000) : current_calibration; // A Energy->kWhtoday_delta[channel] += Energy->active_power[channel] * 1000 / 36; } Energy->data_valid[channel] = 0; } } EnergyUpdateToday(); } } bool NrgDummyCommand(void) { bool serviced = true; int32_t value = (int32_t)(CharToFloat(XdrvMailbox.data) * 1000); // 1.234 = 1234, -1.234 = -1234 uint32_t abs_value = abs(value) / 10; // 1.23 = 123, -1.23 = 123 if ((CMND_POWERCAL == Energy->command_code) || (CMND_VOLTAGECAL == Energy->command_code) || (CMND_CURRENTCAL == Energy->command_code)) { // Service in xdrv_03_energy.ino } else if (CMND_POWERSET == Energy->command_code) { if (XdrvMailbox.data_len) { if ((abs_value >= 100) && (abs_value <= 16000000)) { // Between 1.00 and 160000.00 W XdrvMailbox.payload = abs_value; } } } else if (CMND_VOLTAGESET == Energy->command_code) { if (XdrvMailbox.data_len) { if ((abs_value >= 10000) && (abs_value <= 40000)) { // Between 100.00 and 400.00 V XdrvMailbox.payload = abs_value; } } } else if (CMND_CURRENTSET == Energy->command_code) { if (XdrvMailbox.data_len) { if ((abs_value >= 1000) && (abs_value <= 40000000)) { // Between 10.00 mA and 400.00000 A XdrvMailbox.payload = abs_value; } } } else if (CMND_FREQUENCYSET == Energy->command_code) { if (XdrvMailbox.data_len) { if ((abs_value >= 4500) && (abs_value <= 6500)) { // Between 45.00 and 65.00 Hz XdrvMailbox.payload = abs_value; } } } else if (CMND_ENERGYCONFIG == Energy->command_code) { AddLog(LOG_LEVEL_DEBUG, PSTR("NRG: Config index %d, payload %d, value %d, data '%s'"), XdrvMailbox.index, XdrvMailbox.payload, value, XdrvMailbox.data ? XdrvMailbox.data : "null" ); // EnergyConfig1 to 3 = Set Energy->current[channel] in A like 0.417 for 417mA if ((XdrvMailbox.index > 0) && (XdrvMailbox.index < 4)) { NrgDummy.current[XdrvMailbox.index -1] = value; } // EnergyConfig4 to 6 = Set Energy->active_power[channel] in W like 100 for 100W if ((XdrvMailbox.index > 3) && (XdrvMailbox.index < 7)) { NrgDummy.power[XdrvMailbox.index -4] = value; } #ifdef ESP32 // EnergyConfig11 to 18 = Set Energy->current[channel] in A like 0.417 for 417mA if ((XdrvMailbox.index > 10) && (XdrvMailbox.index < ENERGY_MAX_PHASES + 10)) { NrgDummy.current[XdrvMailbox.index -1] = value; } // EnergyConfig111 to 118 = Set Energy->active_power[channel] in W like 100 for 100W if ((XdrvMailbox.index > 110) && (XdrvMailbox.index < ENERGY_MAX_PHASES +110)) { NrgDummy.power[XdrvMailbox.index -4] = value; } #endif } else serviced = false; // Unknown command return serviced; } void NrgDummyDrvInit(void) { if (TasmotaGlobal.gpio_optiona.dummy_energy && TasmotaGlobal.devices_present) { Energy->phase_count = (TasmotaGlobal.devices_present < ENERGY_MAX_PHASES) ? TasmotaGlobal.devices_present : ENERGY_MAX_PHASES; if (HLW_PREF_PULSE == EnergyGetCalibration(ENERGY_POWER_CALIBRATION)) { for (uint32_t i = 0; i < Energy->phase_count; i++) { EnergySetCalibration(ENERGY_POWER_CALIBRATION, NRG_DUMMY_PREF, i); EnergySetCalibration(ENERGY_VOLTAGE_CALIBRATION, NRG_DUMMY_UREF, i); EnergySetCalibration(ENERGY_CURRENT_CALIBRATION, NRG_DUMMY_IREF, i); EnergySetCalibration(ENERGY_FREQUENCY_CALIBRATION, NRG_DUMMY_FREF, i); } } Energy->voltage_common = NRG_DUMMY_U_COMMON; // Phase voltage = false, Common voltage = true Energy->frequency_common = NRG_DUMMY_F_COMMON; // Phase frequency = false, Common frequency = true Energy->type_dc = NRG_DUMMY_DC; // AC = false, DC = true; Energy->use_overtemp = NRG_DUMMY_OVERTEMP; // Use global temperature for overtemp detection TasmotaGlobal.energy_driver = XNRG_30; } } /*********************************************************************************************\ * Interface \*********************************************************************************************/ bool Xnrg30(uint32_t function) { bool result = false; switch (function) { case FUNC_ENERGY_EVERY_SECOND: NrgDummyEverySecond(); break; case FUNC_COMMAND: result = NrgDummyCommand(); break; case FUNC_PRE_INIT: NrgDummyDrvInit(); break; } return result; } #endif // USE_ENERGY_DUMMY #endif // USE_ENERGY_SENSOR