jeans/Tasmota
jeans/Tasmota
1
0
Fork 0
mirror of https://github.com/arendst/Tasmota.git synced 2025-07-23 18:56:38 +00:00
Code Issues Packages Projects Releases Wiki Activity

Shelly2 Cleanup

Browse Source 
Cleanup and debug updates
This commit is contained in:
Theo Arends 2018-09-24 18:16:35 +02:00
parent f65d8c0cbf
commit 43c3cf57d5
4 changed files with 349 additions and 329 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
sonoff/settings.h
View File

@ -337,21 +337,21 @@ struct SYSCFG {
} Settings;
struct RTCRBT {
uint16_t valid; // 000
uint8_t fast_reboot_count; // 002
uint8_t free_003[1]; // 003
uint16_t valid; // 280 (RTC memory offset 100 - sizeof(RTCRBT))
uint8_t fast_reboot_count; // 282
uint8_t free_003[1]; // 283
} RtcReboot;
struct RTCMEM {
uint16_t valid; // 000
byte oswatch_blocked_loop; // 002
uint8_t ota_loader; // 003
unsigned long energy_kWhtoday; // 004
unsigned long energy_kWhtotal; // 008
unsigned long pulse_counter[MAX_COUNTERS]; // 00C
power_t power; // 01C
uint8_t free_020[60]; // 020
// 05C next free location (64 (=core) + 100 (=tasmota offset) + 92 (=0x5C RTCMEM struct) = 256 bytes (max = 512))
uint16_t valid; // 290 (RTC memory offset 100)
byte oswatch_blocked_loop; // 292
uint8_t ota_loader; // 293
unsigned long energy_kWhtoday; // 294
unsigned long energy_kWhtotal; // 298
unsigned long pulse_counter[MAX_COUNTERS]; // 29C
power_t power; // 2AC
uint8_t free_020[60]; // 2B0
// 2EC - 2FF free locations
} RtcSettings;
struct TIME_T {

4
sonoff/settings.ino
View File

@ -95,7 +95,7 @@ void RtcSettingsSave()
void RtcSettingsLoad()
{
ESP.rtcUserMemoryRead(100, (uint32_t*)&RtcSettings, sizeof(RTCMEM));
ESP.rtcUserMemoryRead(100, (uint32_t*)&RtcSettings, sizeof(RTCMEM)); // 0x290
#ifdef DEBUG_THEO
AddLog_P(LOG_LEVEL_DEBUG, PSTR("Dump: Load"));
RtcSettingsDump();
@ -145,7 +145,7 @@ void RtcRebootSave()
void RtcRebootLoad()
{
ESP.rtcUserMemoryRead(100 - sizeof(RTCRBT), (uint32_t*)&RtcReboot, sizeof(RTCRBT));
ESP.rtcUserMemoryRead(100 - sizeof(RTCRBT), (uint32_t*)&RtcReboot, sizeof(RTCRBT)); // 0x280
if (RtcReboot.valid != RTC_MEM_VALID) {
memset(&RtcReboot, 0, sizeof(RTCRBT));
RtcReboot.valid = RTC_MEM_VALID;

186
sonoff/xdrv_99_debug.ino
View File

@ -35,20 +35,25 @@
* Debug commands
\*********************************************************************************************/
#define D_CMND_CFGDUMP "CfgDump"
#define D_CMND_CFGPOKE "CfgPoke"
#define D_CMND_CFGPEEK "CfgPeek"
#define D_CMND_CFGXOR "CfgXor"
#define D_CMND_CFGDUMP "CfgDump"
#define D_CMND_CFGPOKE "CfgPoke"
#define D_CMND_CFGPEEK "CfgPeek"
#define D_CMND_CFGSHOW "CfgShow"
#define D_CMND_CFGXOR "CfgXor"
#define D_CMND_CPUCHECK "CpuChk"
#define D_CMND_EXCEPTION "Exception"
#define D_CMND_CPUCHECK "CpuChk"
#define D_CMND_FREEMEM "FreeMem"
#define D_CMND_RTCDUMP "RtcDump"
#define D_CMND_HELP "Help"
enum DebugCommands { CMND_CFGDUMP, CMND_CFGPEEK, CMND_CFGPOKE, CMND_CFGXOR, CMND_EXCEPTION, CMND_CPUCHECK };
const char kDebugCommands[] PROGMEM = D_CMND_CFGDUMP "|" D_CMND_CFGPEEK "|" D_CMND_CFGPOKE "|" D_CMND_CFGXOR "|" D_CMND_EXCEPTION "|" D_CMND_CPUCHECK;
enum DebugCommands { CMND_CFGDUMP, CMND_CFGPEEK, CMND_CFGPOKE, CMND_CFGSHOW, CMND_CFGXOR, CMND_CPUCHECK, CMND_EXCEPTION, CMND_FREEMEM, CMND_RTCDUMP, CMND_HELP };
const char kDebugCommands[] PROGMEM = D_CMND_CFGDUMP "|" D_CMND_CFGPEEK "|" D_CMND_CFGPOKE "|" D_CMND_CFGSHOW "|" D_CMND_CFGXOR "|" D_CMND_CPUCHECK "|" D_CMND_EXCEPTION "|" D_CMND_FREEMEM "|" D_CMND_RTCDUMP "|" D_CMND_HELP;
uint32_t CPU_loops = 0;
uint32_t CPU_last_millis = 0;
uint32_t CPU_last_loop_time = 0;
uint8_t CPU_load_check = CPU_LOAD_CHECK;
uint8_t CPU_load_check = 0;
uint8_t CPU_show_freemem = 0;
/*******************************************************************************************/
@ -117,41 +122,6 @@ Decoding 14 results
}
}
/*******************************************************************************************/
void RtcSettingsDump()
{
#define CFG_COLS 16
uint16_t idx;
uint16_t maxrow;
uint16_t row;
uint16_t col;
uint8_t *buffer = (uint8_t *) &RtcSettings;
maxrow = ((sizeof(RTCMEM)+CFG_COLS)/CFG_COLS);
for (row = 0; row < maxrow; row++) {
idx = row * CFG_COLS;
snprintf_P(log_data, sizeof(log_data), PSTR("%03X:"), idx);
for (col = 0; col < CFG_COLS; col++) {
if (!(col%4)) {
snprintf_P(log_data, sizeof(log_data), PSTR("%s "), log_data);
}
snprintf_P(log_data, sizeof(log_data), PSTR("%s %02X"), log_data, buffer[idx + col]);
}
snprintf_P(log_data, sizeof(log_data), PSTR("%s |"), log_data);
for (col = 0; col < CFG_COLS; col++) {
// if (!(col%4)) {
// snprintf_P(log_data, sizeof(log_data), PSTR("%s "), log_data);
// }
snprintf_P(log_data, sizeof(log_data), PSTR("%s%c"), log_data, ((buffer[idx + col] > 0x20) && (buffer[idx + col] < 0x7F)) ? (char)buffer[idx + col] : ' ');
}
snprintf_P(log_data, sizeof(log_data), PSTR("%s|"), log_data);
AddLog(LOG_LEVEL_INFO);
}
}
#endif // DEBUG_THEO
/*******************************************************************************************/
@ -224,6 +194,68 @@ void DebugFreeMem()
/*******************************************************************************************/
void DebugRtcDump(char* parms)
{
#define CFG_COLS 16
uint16_t idx;
uint16_t maxrow;
uint16_t row;
uint16_t col;
char *p;
// |<--SDK data (256 bytes)-->|<--User data (512 bytes)-->|
// 000 - 0FF: SDK
// 000 - 01B: SDK rst_info
// 100 - 2FF: User
// 280 - 283: Tasmota RtcReboot (Offset 100 (x 4bytes) - sizeof(RTCRBT) (x 4bytes))
// 290 - 2EB: Tasmota RtcSettings (Offset 100 (x 4bytes))
uint8_t buffer[768];
// ESP.rtcUserMemoryRead(0, (uint32_t*)&buffer, sizeof(buffer));
system_rtc_mem_read(0, (uint32_t*)&buffer, sizeof(buffer));
maxrow = ((sizeof(buffer)+CFG_COLS)/CFG_COLS);
uint16_t srow = strtol(parms, &p, 16) / CFG_COLS;
uint16_t mrow = strtol(p, &p, 10);
// snprintf_P(log_data, sizeof(log_data), PSTR("Cnfg: Parms %s, Start row %d, rows %d"), parms, srow, mrow);
// AddLog(LOG_LEVEL_DEBUG);
if (0 == mrow) { // Default only 8 lines
mrow = 8;
}
if (srow > maxrow) {
srow = maxrow - mrow;
}
if (mrow < (maxrow - srow)) {
maxrow = srow + mrow;
}
for (row = srow; row < maxrow; row++) {
idx = row * CFG_COLS;
snprintf_P(log_data, sizeof(log_data), PSTR("%03X:"), idx);
for (col = 0; col < CFG_COLS; col++) {
if (!(col%4)) {
snprintf_P(log_data, sizeof(log_data), PSTR("%s "), log_data);
}
snprintf_P(log_data, sizeof(log_data), PSTR("%s %02X"), log_data, buffer[idx + col]);
}
snprintf_P(log_data, sizeof(log_data), PSTR("%s |"), log_data);
for (col = 0; col < CFG_COLS; col++) {
// if (!(col%4)) {
// snprintf_P(log_data, sizeof(log_data), PSTR("%s "), log_data);
// }
snprintf_P(log_data, sizeof(log_data), PSTR("%s%c"), log_data, ((buffer[idx + col] > 0x20) && (buffer[idx + col] < 0x7F)) ? (char)buffer[idx + col] : ' ');
}
snprintf_P(log_data, sizeof(log_data), PSTR("%s|"), log_data);
AddLog(LOG_LEVEL_INFO);
}
}
/*******************************************************************************************/
void DebugCfgDump(char* parms)
{
#define CFG_COLS 16
@ -322,6 +354,53 @@ void DebugCfgPoke(char* parms)
AddLog(LOG_LEVEL_INFO);
}
void DebugCfgShow(uint8_t more)
{
uint8_t *SetAddr;
SetAddr = (uint8_t *)&Settings;
snprintf_P(log_data, sizeof(log_data), PSTR("%03X: Hostname (%d) [%s]"), (uint8_t *)&Settings.hostname - SetAddr, sizeof(Settings.hostname)-1, Settings.hostname);
AddLog(LOG_LEVEL_INFO);
snprintf_P(log_data, sizeof(log_data), PSTR("%03X: SSids (%d) [%s], [%s]"), (uint8_t *)&Settings.sta_ssid - SetAddr, sizeof(Settings.sta_ssid[0])-1, Settings.sta_ssid[0], Settings.sta_ssid[1]);
AddLog(LOG_LEVEL_INFO);
snprintf_P(log_data, sizeof(log_data), PSTR("%03X: Friendlynames (%d) [%s], [%s], [%s], [%s]"), (uint8_t *)&Settings.friendlyname - SetAddr, sizeof(Settings.friendlyname[0])-1, Settings.friendlyname[0], Settings.friendlyname[1], Settings.friendlyname[2], Settings.friendlyname[3]);
AddLog(LOG_LEVEL_INFO);
snprintf_P(log_data, sizeof(log_data), PSTR("%03X: OTA Url (%d) [%s]"), (uint8_t *)&Settings.ota_url - SetAddr, sizeof(Settings.ota_url)-1, Settings.ota_url);
AddLog(LOG_LEVEL_INFO);
snprintf_P(log_data, sizeof(log_data), PSTR("%03X: StateText (%d) [%s], [%s], [%s], [%s]"), (uint8_t *)&Settings.state_text - SetAddr, sizeof(Settings.state_text[0])-1, Settings.state_text[0], Settings.state_text[1], Settings.state_text[2], Settings.state_text[3]);
AddLog(LOG_LEVEL_INFO);
snprintf_P(log_data, sizeof(log_data), PSTR("%03X: Syslog Host (%d) [%s]"), (uint8_t *)&Settings.syslog_host - SetAddr, sizeof(Settings.syslog_host)-1, Settings.syslog_host);
AddLog(LOG_LEVEL_INFO);
snprintf_P(log_data, sizeof(log_data), PSTR("%03X: NTP Servers (%d) [%s], [%s], [%s]"), (uint8_t *)&Settings.ntp_server - SetAddr, sizeof(Settings.ntp_server[0])-1, Settings.ntp_server[0], Settings.ntp_server[1], Settings.ntp_server[2]);
AddLog(LOG_LEVEL_INFO);
snprintf_P(log_data, sizeof(log_data), PSTR("%03X: MQTT Host (%d) [%s]"), (uint8_t *)&Settings.mqtt_host - SetAddr, sizeof(Settings.mqtt_host)-1, Settings.mqtt_host);
AddLog(LOG_LEVEL_INFO);
snprintf_P(log_data, sizeof(log_data), PSTR("%03X: MQTT Client (%d) [%s]"), (uint8_t *)&Settings.mqtt_client - SetAddr, sizeof(Settings.mqtt_client)-1, Settings.mqtt_client);
AddLog(LOG_LEVEL_INFO);
snprintf_P(log_data, sizeof(log_data), PSTR("%03X: MQTT User (%d) [%s]"), (uint8_t *)&Settings.mqtt_user - SetAddr, sizeof(Settings.mqtt_user)-1, Settings.mqtt_user);
AddLog(LOG_LEVEL_INFO);
snprintf_P(log_data, sizeof(log_data), PSTR("%03X: MQTT FullTopic (%d) [%s]"), (uint8_t *)&Settings.mqtt_fulltopic - SetAddr, sizeof(Settings.mqtt_fulltopic)-1, Settings.mqtt_fulltopic);
AddLog(LOG_LEVEL_INFO);
snprintf_P(log_data, sizeof(log_data), PSTR("%03X: MQTT Topic (%d) [%s]"), (uint8_t *)&Settings.mqtt_topic - SetAddr, sizeof(Settings.mqtt_topic)-1, Settings.mqtt_topic);
AddLog(LOG_LEVEL_INFO);
snprintf_P(log_data, sizeof(log_data), PSTR("%03X: MQTT GroupTopic (%d) [%s]"), (uint8_t *)&Settings.mqtt_grptopic - SetAddr, sizeof(Settings.mqtt_grptopic)-1, Settings.mqtt_grptopic);
AddLog(LOG_LEVEL_INFO);
snprintf_P(log_data, sizeof(log_data), PSTR("%03X: MQTT ButtonTopic (%d) [%s]"), (uint8_t *)&Settings.button_topic - SetAddr, sizeof(Settings.button_topic)-1, Settings.button_topic);
AddLog(LOG_LEVEL_INFO);
snprintf_P(log_data, sizeof(log_data), PSTR("%03X: MQTT SwitchTopic (%d) [%s]"), (uint8_t *)&Settings.switch_topic - SetAddr, sizeof(Settings.switch_topic)-1, Settings.switch_topic);
AddLog(LOG_LEVEL_INFO);
snprintf_P(log_data, sizeof(log_data), PSTR("%03X: MQTT Prefixes (%d) [%s], [%s], [%s]"), (uint8_t *)&Settings.mqtt_prefix - SetAddr, sizeof(Settings.mqtt_prefix[0])-1, Settings.mqtt_prefix[0], Settings.mqtt_prefix[1], Settings.mqtt_prefix[2]);
AddLog(LOG_LEVEL_INFO);
if (17 == more) {
snprintf_P(log_data, sizeof(log_data), PSTR("%03X: AP Passwords (%d) [%s], [%s]"), (uint8_t *)&Settings.sta_pwd - SetAddr, sizeof(Settings.sta_pwd[0])-1, Settings.sta_pwd[0], Settings.sta_pwd[1]);
AddLog(LOG_LEVEL_INFO);
snprintf_P(log_data, sizeof(log_data), PSTR("%03X: MQTT Password (%d) [%s]"), (uint8_t *)&Settings.mqtt_pwd - SetAddr, sizeof(Settings.mqtt_pwd)-1, Settings.mqtt_pwd);
AddLog(LOG_LEVEL_INFO);
snprintf_P(log_data, sizeof(log_data), PSTR("%03X: Web Password (%d) [%s]"), (uint8_t *)&Settings.web_password - SetAddr, sizeof(Settings.web_password)-1, Settings.web_password);
AddLog(LOG_LEVEL_INFO);
}
}
/*******************************************************************************************/
boolean DebugCommand()
@ -333,6 +412,15 @@ boolean DebugCommand()
if (-1 == command_code) {
serviced = false; // Unknown command
}
else if (CMND_HELP == command_code) {
snprintf_P(log_data, sizeof(log_data), kDebugCommands);
AddLog(LOG_LEVEL_INFO);
snprintf_P(mqtt_data, sizeof(mqtt_data), S_JSON_COMMAND_SVALUE, command, D_JSON_DONE);
}
else if (CMND_RTCDUMP == command_code) {
DebugRtcDump(XdrvMailbox.data);
snprintf_P(mqtt_data, sizeof(mqtt_data), S_JSON_COMMAND_SVALUE, command, D_JSON_DONE);
}
else if (CMND_CFGDUMP == command_code) {
DebugCfgDump(XdrvMailbox.data);
snprintf_P(mqtt_data, sizeof(mqtt_data), S_JSON_COMMAND_SVALUE, command, D_JSON_DONE);
@ -345,6 +433,10 @@ boolean DebugCommand()
DebugCfgPoke(XdrvMailbox.data);
snprintf_P(mqtt_data, sizeof(mqtt_data), S_JSON_COMMAND_SVALUE, command, D_JSON_DONE);
}
else if (CMND_CFGSHOW == command_code) {
DebugCfgShow(XdrvMailbox.payload);
snprintf_P(mqtt_data, sizeof(mqtt_data), S_JSON_COMMAND_SVALUE, command, D_JSON_DONE);
}
#ifdef USE_WEBSERVER
else if (CMND_CFGXOR == command_code) {
if (XdrvMailbox.data_len > 0) {
@ -366,6 +458,12 @@ boolean DebugCommand()
}
snprintf_P(mqtt_data, sizeof(mqtt_data), S_JSON_COMMAND_NVALUE, command, CPU_load_check);
}
else if (CMND_FREEMEM == command_code) {
if (XdrvMailbox.data_len > 0) {
CPU_show_freemem = XdrvMailbox.payload;
}
snprintf_P(mqtt_data, sizeof(mqtt_data), S_JSON_COMMAND_NVALUE, command, CPU_show_freemem);
}
else serviced = false; // Unknown command
return serviced;
@ -392,7 +490,7 @@ boolean Xdrv99(byte function)
result = DebugCommand();
break;
case FUNC_FREE_MEM:
DebugFreeMem();
if (CPU_show_freemem) { DebugFreeMem(); }
break;
}
return result;

464
sonoff/xnrg_04_mcp39f501.ino
View File

@ -56,7 +56,7 @@
#define MCP_FREQUENCY_GAIN_BASE 0x00AE
#define MCP_FREQUENCY_LEN 4
typedef struct mcp_calibration_registers_type {
typedef struct mcp_cal_registers_type {
uint16_t gain_current_rms;
uint16_t gain_voltage_rms;
uint16_t gain_active_power;
@ -77,24 +77,17 @@ typedef struct mcp_calibration_registers_type {
uint32_t calibration_active_power;
uint32_t calibration_reactive_power;
uint16_t accumulation_interval;
} mcp_calibration_registers_type;
mcp_calibration_registers_type mcp_calibration_registers;
} mcp_cal_registers_type;
typedef struct mcp_calibration_setpoint_type {
uint32_t calibration_current;
uint16_t calibration_voltage;
uint32_t calibration_active_power;
uint32_t calibration_reactive_power;
// uint32_t calibration_reactive_power;
uint16_t line_frequency_ref;
} mcp_calibration_setpoint_type;
mcp_calibration_setpoint_type mcp_calibration_setpoint;
typedef struct mcp_frequency_registers_type {
uint16_t line_frequency_ref;
uint16_t gain_line_frequency;
} mcp_frequency_registers_type;
mcp_frequency_registers_type mcp_frequency_registers;
typedef struct mcp_output_registers_type {
uint32_t current_rms;
uint16_t voltage_rms;
@ -103,15 +96,11 @@ typedef struct mcp_output_registers_type {
uint32_t apparent_power;
sint16_t power_factor;
uint16_t line_frequency;
uint16_t thermistor_voltage;
uint16_t event_flag;
uint16_t system_status;
} mcp_output_registers_type;
mcp_output_registers_type mcp_output_registers;
uint32_t mcp_system_configuration = 0x03000000;
uint16_t mcp_address = 0;
uint8_t mcp_single_wire_active = 0;
uint8_t mcp_address = 0;
uint8_t mcp_calibration_active = 0;
uint8_t mcp_init = 0;
uint8_t mcp_timeout = 0;
@ -128,12 +117,8 @@ uint8_t McpChecksum(uint8_t *data)
uint8_t offset = 0;
uint8_t len = data[1] -1;
if (MCP_SINGLE_WIRE == data[0]) {
offset = 3;
len = 15;
}
for (byte i = offset; i < len; i++) { checksum += data[i]; }
return (MCP_SINGLE_WIRE == data[0]) ? ~checksum : checksum;
return checksum;
}
unsigned long McpExtractInt(char *data, uint8_t offset, uint8_t size)
@ -170,19 +155,83 @@ void McpSend(uint8_t *data)
}
}
uint32_t McpGetRange(uint8_t shift)
void McpResetSetpoints(void)
{
return (mcp_calibration_registers.range >> shift) & 0xFF;
memset(&mcp_calibration_setpoint, 0, sizeof(mcp_calibration_setpoint));
}
void McpSetRange(uint8_t shift, uint32_t range)
/********************************************************************************************/
void McpGetAddress(void)
{
uint32_t old_range = McpGetRange(shift);
mcp_calibration_registers.range = mcp_calibration_registers.range ^ (old_range << shift);
mcp_calibration_registers.range = mcp_calibration_registers.range | (range << shift);
uint8_t data[] = { MCP_START_FRAME, 7, MCP_SET_ADDRESS, 0x00, 0x26, MCP_READ_16, 0x00 };
McpSend(data);
}
bool McpCalibrationCalc(uint8_t range_shift)
void McpAddressReceive(void)
{
// 06 05 004D 58
mcp_address = serial_in_buffer[3];
}
/********************************************************************************************/
void McpGetCalibration(void)
{
if (mcp_calibration_active) { return; }
mcp_calibration_active = 4;
uint8_t data[] = { MCP_START_FRAME, 8, MCP_SET_ADDRESS, (MCP_CALIBRATION_BASE >> 8) & 0xFF, MCP_CALIBRATION_BASE & 0xFF, MCP_READ, MCP_CALIBRATION_LEN, 0x00 };
McpSend(data);
}
void McpParseCalibration(void)
{
bool action = false;
mcp_cal_registers_type cal_registers;
// 06 37 C882 B6AD 0781 9273 06000000 00000000 00000000 0000 D3FF 0300 00000003 9204 120C1300 204E0000 9808 E0AB0000 D9940000 0200 24
cal_registers.gain_current_rms = McpExtractInt(serial_in_buffer, 2, 2);
cal_registers.gain_voltage_rms = McpExtractInt(serial_in_buffer, 4, 2);
cal_registers.gain_active_power = McpExtractInt(serial_in_buffer, 6, 2);
cal_registers.gain_reactive_power = McpExtractInt(serial_in_buffer, 8, 2);
cal_registers.offset_current_rms = McpExtractInt(serial_in_buffer, 10, 4);
cal_registers.offset_active_power = McpExtractInt(serial_in_buffer, 14, 4);
cal_registers.offset_reactive_power = McpExtractInt(serial_in_buffer, 18, 4);
cal_registers.dc_offset_current = McpExtractInt(serial_in_buffer, 22, 2);
cal_registers.phase_compensation = McpExtractInt(serial_in_buffer, 24, 2);
cal_registers.apparent_power_divisor = McpExtractInt(serial_in_buffer, 26, 2);
cal_registers.system_configuration = McpExtractInt(serial_in_buffer, 28, 4);
cal_registers.dio_configuration = McpExtractInt(serial_in_buffer, 32, 2);
cal_registers.range = McpExtractInt(serial_in_buffer, 34, 4);
cal_registers.calibration_current = McpExtractInt(serial_in_buffer, 38, 4);
cal_registers.calibration_voltage = McpExtractInt(serial_in_buffer, 42, 2);
cal_registers.calibration_active_power = McpExtractInt(serial_in_buffer, 44, 4);
cal_registers.calibration_reactive_power = McpExtractInt(serial_in_buffer, 48, 4);
cal_registers.accumulation_interval = McpExtractInt(serial_in_buffer, 52, 2);
if (mcp_calibration_setpoint.calibration_active_power) {
cal_registers.calibration_active_power = mcp_calibration_setpoint.calibration_active_power;
if (McpCalibrationCalc(&cal_registers, 16)) { action = true; }
}
if (mcp_calibration_setpoint.calibration_voltage) {
cal_registers.calibration_voltage = mcp_calibration_setpoint.calibration_voltage;
if (McpCalibrationCalc(&cal_registers, 0)) { action = true; }
}
if (mcp_calibration_setpoint.calibration_current) {
cal_registers.calibration_current = mcp_calibration_setpoint.calibration_current;
if (McpCalibrationCalc(&cal_registers, 8)) { action = true; }
}
mcp_timeout = 0;
if (action) { McpSetCalibration(&cal_registers); }
McpResetSetpoints();
}
bool McpCalibrationCalc(struct mcp_cal_registers_type *cal_registers, uint8_t range_shift)
{
uint32_t measured;
uint32_t expected;
@ -191,16 +240,16 @@ bool McpCalibrationCalc(uint8_t range_shift)
if (range_shift == 0) {
measured = mcp_output_registers.voltage_rms;
expected = mcp_calibration_registers.calibration_voltage;
gain = &(mcp_calibration_registers.gain_voltage_rms);
expected = cal_registers->calibration_voltage;
gain = &(cal_registers->gain_voltage_rms);
} else if (range_shift == 8) {
measured = mcp_output_registers.current_rms;
expected = mcp_calibration_registers.calibration_current;
gain = &(mcp_calibration_registers.gain_current_rms);
expected = cal_registers->calibration_current;
gain = &(cal_registers->gain_current_rms);
} else if (range_shift == 16) {
measured = mcp_output_registers.active_power;
expected = mcp_calibration_registers.calibration_active_power;
gain = &(mcp_calibration_registers.gain_active_power);
expected = cal_registers->calibration_active_power;
gain = &(cal_registers->gain_active_power);
} else {
return false;
}
@ -209,7 +258,7 @@ bool McpCalibrationCalc(uint8_t range_shift)
return false;
}
uint32_t range = McpGetRange(range_shift);
uint32_t range = (cal_registers->range >> range_shift) & 0xFF;
calc:
new_gain = (*gain) * expected / measured;
@ -229,104 +278,50 @@ calc:
}
*gain = new_gain;
McpSetRange(range_shift, range);
uint32_t old_range = (cal_registers->range >> range_shift) & 0xFF;
cal_registers->range = cal_registers->range ^ (old_range << range_shift);
cal_registers->range = cal_registers->range | (range << range_shift);
return true;
}
void McpCalibrationReactivePower()
/*
void McpCalibrationReactivePower(void)
{
mcp_calibration_registers.gain_reactive_power = mcp_calibration_registers.gain_reactive_power * mcp_calibration_registers.calibration_reactive_power / mcp_output_registers.reactive_power;
cal_registers.gain_reactive_power = cal_registers.gain_reactive_power * cal_registers.calibration_reactive_power / mcp_output_registers.reactive_power;
}
void McpCalibrationLineFrequency()
{
if ((0xFFFF == mcp_output_registers.line_frequency) || (0 == mcp_frequency_registers.gain_line_frequency)) { // Reset values to 50Hz
mcp_output_registers.line_frequency = 50000;
mcp_frequency_registers.gain_line_frequency = 0x8000;
}
mcp_frequency_registers.gain_line_frequency = mcp_frequency_registers.gain_line_frequency * mcp_frequency_registers.line_frequency_ref / mcp_output_registers.line_frequency;
}
void McpResetSetpoints()
{
mcp_calibration_setpoint.calibration_active_power = 0;
mcp_calibration_setpoint.calibration_voltage = 0;
mcp_calibration_setpoint.calibration_current = 0;
mcp_calibration_setpoint.calibration_reactive_power = 0;
mcp_calibration_setpoint.line_frequency_ref = 0;
}
/********************************************************************************************/
void McpGetAddress()
{
// A5 07 41 00 26 52 65
uint8_t data[7];
data[1] = sizeof(data);
data[2] = MCP_SET_ADDRESS; // Set address pointer
data[3] = 0x00; // address
data[4] = 0x26; // address
data[5] = MCP_READ_16; // Read 2 bytes
McpSend(data);
// Receives 06 05 004D 58
}
void McpGetCalibration()
{
if (mcp_calibration_active) { return; }
mcp_calibration_active = 4;
// A5 08 41 00 28 4E 34 98
uint8_t data[8];
data[1] = sizeof(data);
data[2] = MCP_SET_ADDRESS; // Set address pointer
data[3] = (MCP_CALIBRATION_BASE >> 8) & 0xFF; // address
data[4] = (MCP_CALIBRATION_BASE >> 0) & 0xFF; // address
data[5] = MCP_READ; // Read N bytes
data[6] = MCP_CALIBRATION_LEN;
McpSend(data);
// Receives 06 37 C882 B6AD 0781 9273 06000000 00000000 00000000 0000 D3FF 0300 00000003 9204 120C1300 204E0000 9808 E0AB0000 D9940000 0200 24
}
void McpSetCalibration()
*/
void McpSetCalibration(struct mcp_cal_registers_type *cal_registers)
{
uint8_t data[7 + MCP_CALIBRATION_LEN + 2 + 1];
data[1] = sizeof(data);
data[2] = MCP_SET_ADDRESS; // Set address pointer
data[3] = (MCP_CALIBRATION_BASE >> 8) & 0xFF; // address
data[4] = (MCP_CALIBRATION_BASE >> 0) & 0xFF; // address
data[2] = MCP_SET_ADDRESS; // Set address pointer
data[3] = (MCP_CALIBRATION_BASE >> 8) & 0xFF; // address
data[4] = (MCP_CALIBRATION_BASE >> 0) & 0xFF; // address
data[5] = MCP_WRITE; // Write N bytes
data[5] = MCP_WRITE; // Write N bytes
data[6] = MCP_CALIBRATION_LEN;
McpSetInt(mcp_calibration_registers.gain_current_rms, data, 0+7, 2);
McpSetInt(mcp_calibration_registers.gain_voltage_rms, data, 2+7, 2);
McpSetInt(mcp_calibration_registers.gain_active_power, data, 4+7, 2);
McpSetInt(mcp_calibration_registers.gain_reactive_power, data, 6+7, 2);
McpSetInt(mcp_calibration_registers.offset_current_rms, data, 8+7, 4);
McpSetInt(mcp_calibration_registers.offset_active_power, data, 12+7, 4);
McpSetInt(mcp_calibration_registers.offset_reactive_power, data, 16+7, 4);
McpSetInt(mcp_calibration_registers.dc_offset_current, data, 20+7, 2);
McpSetInt(mcp_calibration_registers.phase_compensation, data, 22+7, 2);
McpSetInt(mcp_calibration_registers.apparent_power_divisor, data, 24+7, 2);
McpSetInt(cal_registers->gain_current_rms, data, 0+7, 2);
McpSetInt(cal_registers->gain_voltage_rms, data, 2+7, 2);
McpSetInt(cal_registers->gain_active_power, data, 4+7, 2);
McpSetInt(cal_registers->gain_reactive_power, data, 6+7, 2);
McpSetInt(cal_registers->offset_current_rms, data, 8+7, 4);
McpSetInt(cal_registers->offset_active_power, data, 12+7, 4);
McpSetInt(cal_registers->offset_reactive_power, data, 16+7, 4);
McpSetInt(cal_registers->dc_offset_current, data, 20+7, 2);
McpSetInt(cal_registers->phase_compensation, data, 22+7, 2);
McpSetInt(cal_registers->apparent_power_divisor, data, 24+7, 2);
McpSetInt(mcp_calibration_registers.system_configuration, data, 26+7, 4);
McpSetInt(mcp_calibration_registers.dio_configuration, data, 30+7, 2);
McpSetInt(mcp_calibration_registers.range, data, 32+7, 4);
McpSetInt(cal_registers->system_configuration, data, 26+7, 4);
McpSetInt(cal_registers->dio_configuration, data, 30+7, 2);
McpSetInt(cal_registers->range, data, 32+7, 4);
McpSetInt(mcp_calibration_registers.calibration_current, data, 36+7, 4);
McpSetInt(mcp_calibration_registers.calibration_voltage, data, 40+7, 2);
McpSetInt(mcp_calibration_registers.calibration_active_power, data, 42+7, 4);
McpSetInt(mcp_calibration_registers.calibration_reactive_power, data, 46+7, 4);
McpSetInt(mcp_calibration_registers.accumulation_interval, data, 50+7, 2);
McpSetInt(cal_registers->calibration_current, data, 36+7, 4);
McpSetInt(cal_registers->calibration_voltage, data, 40+7, 2);
McpSetInt(cal_registers->calibration_active_power, data, 42+7, 4);
McpSetInt(cal_registers->calibration_reactive_power, data, 46+7, 4);
McpSetInt(cal_registers->accumulation_interval, data, 50+7, 2);
data[MCP_CALIBRATION_LEN+7] = MCP_SAVE_REGISTERS; // Save registers to flash
data[MCP_CALIBRATION_LEN+8] = mcp_address; // Device address
@ -334,187 +329,123 @@ void McpSetCalibration()
McpSend(data);
}
void McpGetFrequency()
/********************************************************************************************/
void McpGetFrequency(void)
{
if (mcp_calibration_active) { return; }
mcp_calibration_active = 4;
// A5 0B 41 00 94 52 41 00 AE 52 18
uint8_t data[11];
data[1] = sizeof(data);
data[2] = MCP_SET_ADDRESS; // Set address pointer
data[3] = (MCP_FREQUENCY_REF_BASE >> 8) & 0xFF; // address
data[4] = (MCP_FREQUENCY_REF_BASE >> 0) & 0xFF; // address
data[5] = MCP_READ_16; // Read register
data[6] = MCP_SET_ADDRESS; // Set address pointer
data[7] = (MCP_FREQUENCY_GAIN_BASE >> 8) & 0xFF; // address
data[8] = (MCP_FREQUENCY_GAIN_BASE >> 0) & 0xFF; // address
data[9] = MCP_READ_16; // Read register
uint8_t data[] = { MCP_START_FRAME, 11, MCP_SET_ADDRESS, (MCP_FREQUENCY_REF_BASE >> 8) & 0xFF, MCP_FREQUENCY_REF_BASE & 0xFF, MCP_READ_16,
MCP_SET_ADDRESS, (MCP_FREQUENCY_GAIN_BASE >> 8) & 0xFF, MCP_FREQUENCY_GAIN_BASE & 0xFF, MCP_READ_16, 0x00 };
McpSend(data);
}
void McpSetFrequency()
void McpParseFrequency(void)
{
// 06 07 C350 8000 A0
uint16_t line_frequency_ref = serial_in_buffer[2] * 256 + serial_in_buffer[3];
uint16_t gain_line_frequency = serial_in_buffer[4] * 256 + serial_in_buffer[5];
if (mcp_calibration_setpoint.line_frequency_ref) {
line_frequency_ref = mcp_calibration_setpoint.line_frequency_ref;
if ((0xFFFF == mcp_output_registers.line_frequency) || (0 == gain_line_frequency)) { // Reset values to 50Hz
mcp_output_registers.line_frequency = 50000;
gain_line_frequency = 0x8000;
}
gain_line_frequency = gain_line_frequency * line_frequency_ref / mcp_output_registers.line_frequency;
mcp_timeout = 0;
McpSetFrequency(line_frequency_ref, gain_line_frequency);
}
McpResetSetpoints();
}
void McpSetFrequency(uint16_t line_frequency_ref, uint16_t gain_line_frequency)
{
// A5 11 41 00 94 57 C3 B4 41 00 AE 57 7E 46 53 4D 03
uint8_t data[17];
data[ 1] = sizeof(data);
data[ 2] = MCP_SET_ADDRESS; // Set address pointer
data[ 2] = MCP_SET_ADDRESS; // Set address pointer
data[ 3] = (MCP_FREQUENCY_REF_BASE >> 8) & 0xFF; // address
data[ 4] = (MCP_FREQUENCY_REF_BASE >> 0) & 0xFF; // address
data[ 5] = MCP_WRITE_16; // Write register
data[ 6] = (mcp_frequency_registers.line_frequency_ref >> 8) & 0xFF; // line_frequency_ref high
data[ 7] = (mcp_frequency_registers.line_frequency_ref >> 0) & 0xFF; // line_frequency_ref low
data[ 5] = MCP_WRITE_16; // Write register
data[ 6] = (line_frequency_ref >> 8) & 0xFF; // line_frequency_ref high
data[ 7] = (line_frequency_ref >> 0) & 0xFF; // line_frequency_ref low
data[ 8] = MCP_SET_ADDRESS; // Set address pointer
data[ 9] = (MCP_FREQUENCY_GAIN_BASE >> 8) & 0xFF; // address
data[10] = (MCP_FREQUENCY_GAIN_BASE >> 0) & 0xFF; // address
data[ 8] = MCP_SET_ADDRESS; // Set address pointer
data[ 9] = (MCP_FREQUENCY_GAIN_BASE >> 8) & 0xFF; // address
data[10] = (MCP_FREQUENCY_GAIN_BASE >> 0) & 0xFF; // address
data[11] = MCP_WRITE_16; // Write register
data[12] = (mcp_frequency_registers.gain_line_frequency >> 8) & 0xFF; // gain_line_frequency high
data[13] = (mcp_frequency_registers.gain_line_frequency >> 0) & 0xFF; // gain_line_frequency low
data[11] = MCP_WRITE_16; // Write register
data[12] = (gain_line_frequency >> 8) & 0xFF; // gain_line_frequency high
data[13] = (gain_line_frequency >> 0) & 0xFF; // gain_line_frequency low
data[14] = MCP_SAVE_REGISTERS; // Save registers to flash
data[15] = mcp_address; // Device address
data[14] = MCP_SAVE_REGISTERS; // Save registers to flash
data[15] = mcp_address; // Device address
McpSend(data);
}
/********************************************************************************************/
void McpSetSystemConfiguration(uint16 interval)
{
// A5 11 41 00 42 45 03 00 01 00 41 00 5A 57 00 06 7A
uint8_t data[17];
data[ 1] = sizeof(data);
data[ 2] = MCP_SET_ADDRESS; // Set address pointer
data[ 3] = 0x00; // address
data[ 4] = 0x42; // address
data[ 5] = MCP_WRITE_32; // Write 4 bytes
data[ 6] = (mcp_system_configuration >> 24) & 0xFF; // system_configuration
data[ 7] = (mcp_system_configuration >> 16) & 0xFF; // system_configuration
data[ 8] = (mcp_system_configuration >> 8) & 0xFF; // system_configuration
data[ 9] = (mcp_system_configuration >> 0) & 0xFF; // system_configuration
data[10] = MCP_SET_ADDRESS; // Set address pointer
data[11] = 0x00; // address
data[12] = 0x5A; // address
data[13] = MCP_WRITE_16; // Write 2 bytes
data[14] = (interval >> 8) & 0xFF; // interval
data[15] = (interval >> 0) & 0xFF; // interval
data[ 2] = MCP_SET_ADDRESS; // Set address pointer
data[ 3] = 0x00; // address
data[ 4] = 0x42; // address
data[ 5] = MCP_WRITE_32; // Write 4 bytes
data[ 6] = (mcp_system_configuration >> 24) & 0xFF; // system_configuration
data[ 7] = (mcp_system_configuration >> 16) & 0xFF; // system_configuration
data[ 8] = (mcp_system_configuration >> 8) & 0xFF; // system_configuration
data[ 9] = (mcp_system_configuration >> 0) & 0xFF; // system_configuration
data[10] = MCP_SET_ADDRESS; // Set address pointer
data[11] = 0x00; // address
data[12] = 0x5A; // address
data[13] = MCP_WRITE_16; // Write 2 bytes
data[14] = (interval >> 8) & 0xFF; // interval
data[15] = (interval >> 0) & 0xFF; // interval
McpSend(data);
}
void McpSingleWireStart()
{
if ((mcp_system_configuration & (1 << 8)) != 0) { return; }
mcp_system_configuration = mcp_system_configuration | (1 << 8);
McpSetSystemConfiguration(6); // 64
mcp_single_wire_active = 1;
}
void McpSingleWireStop(uint8_t force)
{
if (!force && ((mcp_system_configuration & (1 << 8)) == 0)) { return; }
mcp_system_configuration = mcp_system_configuration & (~(1 << 8));
McpSetSystemConfiguration(2); // 4
mcp_single_wire_active = 0;
}
/********************************************************************************************/
void McpAddressReceive()
void McpGetData(void)
{
// 06 05 004D 58
mcp_address = serial_in_buffer[2] * 256 + serial_in_buffer[3];
uint8_t data[] = { MCP_START_FRAME, 8, MCP_SET_ADDRESS, 0x00, 0x04, MCP_READ, 22, 0x00 };
McpSend(data);
}
void McpParseCalibration()
void McpParseData(void)
{
bool action = false;
// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
// 06 19 61 06 00 00 FE 08 9B 0E 00 00 0B 00 00 00 97 0E 00 00 FF 7F 0C C6 35
// 06 19 CE 18 00 00 F2 08 3A 38 00 00 66 00 00 00 93 38 00 00 36 7F 9A C6 B7
// Ak Ln Current---- Volt- ActivePower ReActivePow ApparentPow Factr Frequ Ck
// 06 37 C882 B6AD 0781 9273 06000000 00000000 00000000 0000 D3FF 0300 00000003 9204 120C1300 204E0000 9808 E0AB0000 D9940000 0200 24
mcp_calibration_registers.gain_current_rms = McpExtractInt(serial_in_buffer, 2, 2);
mcp_calibration_registers.gain_voltage_rms = McpExtractInt(serial_in_buffer, 4, 2);
mcp_calibration_registers.gain_active_power = McpExtractInt(serial_in_buffer, 6, 2);
mcp_calibration_registers.gain_reactive_power = McpExtractInt(serial_in_buffer, 8, 2);
mcp_calibration_registers.offset_current_rms = McpExtractInt(serial_in_buffer, 10, 4);
mcp_calibration_registers.offset_active_power = McpExtractInt(serial_in_buffer, 14, 4);
mcp_calibration_registers.offset_reactive_power = McpExtractInt(serial_in_buffer, 18, 4);
mcp_calibration_registers.dc_offset_current = McpExtractInt(serial_in_buffer, 22, 2);
mcp_calibration_registers.phase_compensation = McpExtractInt(serial_in_buffer, 24, 2);
mcp_calibration_registers.apparent_power_divisor = McpExtractInt(serial_in_buffer, 26, 2);
mcp_calibration_registers.system_configuration = McpExtractInt(serial_in_buffer, 28, 4);
mcp_calibration_registers.dio_configuration = McpExtractInt(serial_in_buffer, 32, 2);
mcp_calibration_registers.range = McpExtractInt(serial_in_buffer, 34, 4);
mcp_calibration_registers.calibration_current = McpExtractInt(serial_in_buffer, 38, 4);
mcp_calibration_registers.calibration_voltage = McpExtractInt(serial_in_buffer, 42, 2);
mcp_calibration_registers.calibration_active_power = McpExtractInt(serial_in_buffer, 44, 4);
mcp_calibration_registers.calibration_reactive_power = McpExtractInt(serial_in_buffer, 48, 4);
mcp_calibration_registers.accumulation_interval = McpExtractInt(serial_in_buffer, 52, 2);
if (mcp_calibration_setpoint.calibration_active_power) {
mcp_calibration_registers.calibration_active_power = mcp_calibration_setpoint.calibration_active_power;
if (McpCalibrationCalc(16)) { action = true; }
}
if (mcp_calibration_setpoint.calibration_voltage) {
mcp_calibration_registers.calibration_voltage = mcp_calibration_setpoint.calibration_voltage;
if (McpCalibrationCalc(0)) { action = true; }
}
if (mcp_calibration_setpoint.calibration_current) {
mcp_calibration_registers.calibration_current = mcp_calibration_setpoint.calibration_current;
if (McpCalibrationCalc(8)) { action = true; }
}
mcp_timeout = 0;
if (action) { McpSetCalibration(); }
McpResetSetpoints();
}
void McpParseFrequency()
{
// 06 07 C350 8000 A0
mcp_frequency_registers.line_frequency_ref = serial_in_buffer[2] * 256 + serial_in_buffer[3];
mcp_frequency_registers.gain_line_frequency = serial_in_buffer[4] * 256 + serial_in_buffer[5];
if (mcp_calibration_setpoint.line_frequency_ref) {
mcp_frequency_registers.line_frequency_ref = mcp_calibration_setpoint.line_frequency_ref;
McpCalibrationLineFrequency();
mcp_timeout = 0;
McpSetFrequency();
}
McpResetSetpoints();
}
void McpParseData(uint8_t single_wire)
{
if (single_wire) {
// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
// AB CD EF 51 06 00 00 B8 08 FC 0D 00 00 0A C4 11
// Header-- Current---- Volt- Power------ Freq- Ck
mcp_output_registers.current_rms = McpExtractInt(serial_in_buffer, 3, 4);
mcp_output_registers.voltage_rms = McpExtractInt(serial_in_buffer, 7, 2);
mcp_output_registers.active_power = McpExtractInt(serial_in_buffer, 9, 4);
mcp_output_registers.line_frequency = McpExtractInt(serial_in_buffer, 13, 2);
} else {
// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
// 06 19 61 06 00 00 FE 08 9B 0E 00 00 0B 00 00 00 97 0E 00 00 FF 7F 0C C6 35
// 06 19 CE 18 00 00 F2 08 3A 38 00 00 66 00 00 00 93 38 00 00 36 7F 9A C6 B7
// Ak Ln Current---- Volt- ActivePower ReActivePow ApparentPow Factr Frequ Ck
mcp_output_registers.current_rms = McpExtractInt(serial_in_buffer, 2, 4);
mcp_output_registers.voltage_rms = McpExtractInt(serial_in_buffer, 6, 2);
mcp_output_registers.active_power = McpExtractInt(serial_in_buffer, 8, 4);
mcp_output_registers.reactive_power = McpExtractInt(serial_in_buffer, 12, 4);
mcp_output_registers.line_frequency = McpExtractInt(serial_in_buffer, 22, 2);
}
mcp_output_registers.current_rms = McpExtractInt(serial_in_buffer, 2, 4);
mcp_output_registers.voltage_rms = McpExtractInt(serial_in_buffer, 6, 2);
mcp_output_registers.active_power = McpExtractInt(serial_in_buffer, 8, 4);
// mcp_output_registers.reactive_power = McpExtractInt(serial_in_buffer, 12, 4);
// mcp_output_registers.power_factor = McpExtractInt(serial_in_buffer, 20, 2);
mcp_output_registers.line_frequency = McpExtractInt(serial_in_buffer, 22, 2);
if (energy_power_on) { // Powered on
energy_frequency = (float)mcp_output_registers.line_frequency / 1000;
@ -533,7 +464,9 @@ void McpParseData(uint8_t single_wire)
}
}
bool McpSerialInput()
/********************************************************************************************/
bool McpSerialInput(void)
{
serial_in_buffer[serial_in_byte_counter++] = serial_in_byte;
unsigned long start = millis();
@ -564,7 +497,7 @@ bool McpSerialInput()
AddLog_P(LOG_LEVEL_DEBUG, PSTR("MCP: " D_CHECKSUM_FAILURE));
} else {
if (5 == serial_in_buffer[1]) { McpAddressReceive(); }
if (25 == serial_in_buffer[1]) { McpParseData(0); }
if (25 == serial_in_buffer[1]) { McpParseData(); }
if (MCP_CALIBRATION_LEN + 3 == serial_in_buffer[1]) { McpParseCalibration(); }
if (MCP_FREQUENCY_LEN + 3 == serial_in_buffer[1]) { McpParseFrequency(); }
}
@ -573,15 +506,6 @@ bool McpSerialInput()
mcp_timeout = 0;
}
else if (MCP_SINGLE_WIRE == serial_in_buffer[0]) {
if (serial_in_byte_counter == 16) {
if (McpChecksum((uint8_t *)serial_in_buffer) != serial_in_buffer[serial_in_byte_counter -1]) {
AddLog_P(LOG_LEVEL_DEBUG, PSTR("MCP: " D_CHECKSUM_FAILURE));
} else {
McpParseData(1);
}
}
mcp_timeout = 0;
}
return 1;
@ -589,10 +513,8 @@ bool McpSerialInput()
/********************************************************************************************/
void McpEverySecond()
void McpEverySecond(void)
{
uint8_t get_state[] = { 0xA5, 0x08, 0x41, 0x00, 0x04, 0x4E, 0x16, 0x00 };
if (mcp_output_registers.active_power) {
energy_kWhtoday_delta += ((mcp_output_registers.active_power * 10) / 36);
EnergyUpdateToday();
@ -611,18 +533,18 @@ void McpEverySecond()
else if (!mcp_address) {
McpGetAddress();
}
else if (!mcp_single_wire_active) {
McpSend(get_state);
else {
McpGetData();
}
}
void McpSnsInit()
void McpSnsInit(void)
{
SetSeriallog(LOG_LEVEL_NONE); // Free serial interface from logging interference
digitalWrite(15, 1); // GPIO15 - MCP enable
}
void McpDrvInit()
void McpDrvInit(void)
{
if (!energy_flg) {
if (SHELLY2 == Settings.module) {
@ -638,7 +560,7 @@ void McpDrvInit()
}
}
boolean McpCommand()
boolean McpCommand(void)
{
boolean serviced = true;
unsigned long value = 0;