jeans/Tasmota
jeans/Tasmota
1
0
Fork 0
mirror of https://github.com/arendst/Tasmota.git synced 2025-07-25 11:46:31 +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; } Settings;
struct RTCRBT { struct RTCRBT {
uint16_t valid; // 000 uint16_t valid; // 280 (RTC memory offset 100 - sizeof(RTCRBT))
uint8_t fast_reboot_count; // 002 uint8_t fast_reboot_count; // 282
uint8_t free_003[1]; // 003 uint8_t free_003[1]; // 283
} RtcReboot; } RtcReboot;
struct RTCMEM { struct RTCMEM {
uint16_t valid; // 000 uint16_t valid; // 290 (RTC memory offset 100)
byte oswatch_blocked_loop; // 002 byte oswatch_blocked_loop; // 292
uint8_t ota_loader; // 003 uint8_t ota_loader; // 293
unsigned long energy_kWhtoday; // 004 unsigned long energy_kWhtoday; // 294
unsigned long energy_kWhtotal; // 008 unsigned long energy_kWhtotal; // 298
unsigned long pulse_counter[MAX_COUNTERS]; // 00C unsigned long pulse_counter[MAX_COUNTERS]; // 29C
power_t power; // 01C power_t power; // 2AC
uint8_t free_020[60]; // 020 uint8_t free_020[60]; // 2B0
// 05C next free location (64 (=core) + 100 (=tasmota offset) + 92 (=0x5C RTCMEM struct) = 256 bytes (max = 512)) // 2EC - 2FF free locations
} RtcSettings; } RtcSettings;
struct TIME_T { struct TIME_T {

4
sonoff/settings.ino
View File

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

186
sonoff/xdrv_99_debug.ino
View File

@ -35,20 +35,25 @@
* Debug commands * Debug commands
\*********************************************************************************************/ \*********************************************************************************************/
#define D_CMND_CFGDUMP "CfgDump" #define D_CMND_CFGDUMP "CfgDump"
#define D_CMND_CFGPOKE "CfgPoke" #define D_CMND_CFGPOKE "CfgPoke"
#define D_CMND_CFGPEEK "CfgPeek" #define D_CMND_CFGPEEK "CfgPeek"
#define D_CMND_CFGXOR "CfgXor" #define D_CMND_CFGSHOW "CfgShow"
#define D_CMND_CFGXOR "CfgXor"
#define D_CMND_CPUCHECK "CpuChk"
#define D_CMND_EXCEPTION "Exception" #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 }; 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_CFGXOR "|" D_CMND_EXCEPTION "|" D_CMND_CPUCHECK; 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_loops = 0;
uint32_t CPU_last_millis = 0; uint32_t CPU_last_millis = 0;
uint32_t CPU_last_loop_time = 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 #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) void DebugCfgDump(char* parms)
{ {
#define CFG_COLS 16 #define CFG_COLS 16
@ -322,6 +354,53 @@ void DebugCfgPoke(char* parms)
AddLog(LOG_LEVEL_INFO); 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() boolean DebugCommand()
@ -333,6 +412,15 @@ boolean DebugCommand()
if (-1 == command_code) { if (-1 == command_code) {
serviced = false; // Unknown command 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) { else if (CMND_CFGDUMP == command_code) {
DebugCfgDump(XdrvMailbox.data); DebugCfgDump(XdrvMailbox.data);
snprintf_P(mqtt_data, sizeof(mqtt_data), S_JSON_COMMAND_SVALUE, command, D_JSON_DONE); snprintf_P(mqtt_data, sizeof(mqtt_data), S_JSON_COMMAND_SVALUE, command, D_JSON_DONE);
@ -345,6 +433,10 @@ boolean DebugCommand()
DebugCfgPoke(XdrvMailbox.data); DebugCfgPoke(XdrvMailbox.data);
snprintf_P(mqtt_data, sizeof(mqtt_data), S_JSON_COMMAND_SVALUE, command, D_JSON_DONE); 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 #ifdef USE_WEBSERVER
else if (CMND_CFGXOR == command_code) { else if (CMND_CFGXOR == command_code) {
if (XdrvMailbox.data_len > 0) { 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); 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 else serviced = false; // Unknown command
return serviced; return serviced;
@ -392,7 +490,7 @@ boolean Xdrv99(byte function)
result = DebugCommand(); result = DebugCommand();
break; break;
case FUNC_FREE_MEM: case FUNC_FREE_MEM:
DebugFreeMem(); if (CPU_show_freemem) { DebugFreeMem(); }
break; break;
} }
return result; return result;

464
sonoff/xnrg_04_mcp39f501.ino
View File

@ -56,7 +56,7 @@
#define MCP_FREQUENCY_GAIN_BASE 0x00AE #define MCP_FREQUENCY_GAIN_BASE 0x00AE
#define MCP_FREQUENCY_LEN 4 #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_current_rms;
uint16_t gain_voltage_rms; uint16_t gain_voltage_rms;
uint16_t gain_active_power; uint16_t gain_active_power;
@ -77,24 +77,17 @@ typedef struct mcp_calibration_registers_type {
uint32_t calibration_active_power; uint32_t calibration_active_power;
uint32_t calibration_reactive_power; uint32_t calibration_reactive_power;
uint16_t accumulation_interval; uint16_t accumulation_interval;
} mcp_calibration_registers_type; } mcp_cal_registers_type;
mcp_calibration_registers_type mcp_calibration_registers;
typedef struct mcp_calibration_setpoint_type { typedef struct mcp_calibration_setpoint_type {
uint32_t calibration_current; uint32_t calibration_current;
uint16_t calibration_voltage; uint16_t calibration_voltage;
uint32_t calibration_active_power; uint32_t calibration_active_power;
uint32_t calibration_reactive_power; // uint32_t calibration_reactive_power;
uint16_t line_frequency_ref; uint16_t line_frequency_ref;
} mcp_calibration_setpoint_type; } mcp_calibration_setpoint_type;
mcp_calibration_setpoint_type mcp_calibration_setpoint; 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 { typedef struct mcp_output_registers_type {
uint32_t current_rms; uint32_t current_rms;
uint16_t voltage_rms; uint16_t voltage_rms;
@ -103,15 +96,11 @@ typedef struct mcp_output_registers_type {
uint32_t apparent_power; uint32_t apparent_power;
sint16_t power_factor; sint16_t power_factor;
uint16_t line_frequency; 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_type mcp_output_registers; mcp_output_registers_type mcp_output_registers;
uint32_t mcp_system_configuration = 0x03000000; uint32_t mcp_system_configuration = 0x03000000;
uint16_t mcp_address = 0; uint8_t mcp_address = 0;
uint8_t mcp_single_wire_active = 0;
uint8_t mcp_calibration_active = 0; uint8_t mcp_calibration_active = 0;
uint8_t mcp_init = 0; uint8_t mcp_init = 0;
uint8_t mcp_timeout = 0; uint8_t mcp_timeout = 0;
@ -128,12 +117,8 @@ uint8_t McpChecksum(uint8_t *data)
uint8_t offset = 0; uint8_t offset = 0;
uint8_t len = data[1] -1; 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]; } 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) 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); uint8_t data[] = { MCP_START_FRAME, 7, MCP_SET_ADDRESS, 0x00, 0x26, MCP_READ_16, 0x00 };
mcp_calibration_registers.range = mcp_calibration_registers.range ^ (old_range << shift);
mcp_calibration_registers.range = mcp_calibration_registers.range | (range << shift); 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 measured;
uint32_t expected; uint32_t expected;
@ -191,16 +240,16 @@ bool McpCalibrationCalc(uint8_t range_shift)
if (range_shift == 0) { if (range_shift == 0) {
measured = mcp_output_registers.voltage_rms; measured = mcp_output_registers.voltage_rms;
expected = mcp_calibration_registers.calibration_voltage; expected = cal_registers->calibration_voltage;
gain = &(mcp_calibration_registers.gain_voltage_rms); gain = &(cal_registers->gain_voltage_rms);
} else if (range_shift == 8) { } else if (range_shift == 8) {
measured = mcp_output_registers.current_rms; measured = mcp_output_registers.current_rms;
expected = mcp_calibration_registers.calibration_current; expected = cal_registers->calibration_current;
gain = &(mcp_calibration_registers.gain_current_rms); gain = &(cal_registers->gain_current_rms);
} else if (range_shift == 16) { } else if (range_shift == 16) {
measured = mcp_output_registers.active_power; measured = mcp_output_registers.active_power;
expected = mcp_calibration_registers.calibration_active_power; expected = cal_registers->calibration_active_power;
gain = &(mcp_calibration_registers.gain_active_power); gain = &(cal_registers->gain_active_power);
} else { } else {
return false; return false;
} }
@ -209,7 +258,7 @@ bool McpCalibrationCalc(uint8_t range_shift)
return false; return false;
} }
uint32_t range = McpGetRange(range_shift); uint32_t range = (cal_registers->range >> range_shift) & 0xFF;
calc: calc:
new_gain = (*gain) * expected / measured; new_gain = (*gain) * expected / measured;
@ -229,104 +278,50 @@ calc:
} }
*gain = new_gain; *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; 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() void McpSetCalibration(struct mcp_cal_registers_type *cal_registers)
{
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()
{ {
uint8_t data[7 + MCP_CALIBRATION_LEN + 2 + 1]; uint8_t data[7 + MCP_CALIBRATION_LEN + 2 + 1];
data[1] = sizeof(data); data[1] = sizeof(data);
data[2] = MCP_SET_ADDRESS; // Set address pointer data[2] = MCP_SET_ADDRESS; // Set address pointer
data[3] = (MCP_CALIBRATION_BASE >> 8) & 0xFF; // address data[3] = (MCP_CALIBRATION_BASE >> 8) & 0xFF; // address
data[4] = (MCP_CALIBRATION_BASE >> 0) & 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; data[6] = MCP_CALIBRATION_LEN;
McpSetInt(mcp_calibration_registers.gain_current_rms, data, 0+7, 2); McpSetInt(cal_registers->gain_current_rms, data, 0+7, 2);
McpSetInt(mcp_calibration_registers.gain_voltage_rms, data, 2+7, 2); McpSetInt(cal_registers->gain_voltage_rms, data, 2+7, 2);
McpSetInt(mcp_calibration_registers.gain_active_power, data, 4+7, 2); McpSetInt(cal_registers->gain_active_power, data, 4+7, 2);
McpSetInt(mcp_calibration_registers.gain_reactive_power, data, 6+7, 2); McpSetInt(cal_registers->gain_reactive_power, data, 6+7, 2);
McpSetInt(mcp_calibration_registers.offset_current_rms, data, 8+7, 4); McpSetInt(cal_registers->offset_current_rms, data, 8+7, 4);
McpSetInt(mcp_calibration_registers.offset_active_power, data, 12+7, 4); McpSetInt(cal_registers->offset_active_power, data, 12+7, 4);
McpSetInt(mcp_calibration_registers.offset_reactive_power, data, 16+7, 4); McpSetInt(cal_registers->offset_reactive_power, data, 16+7, 4);
McpSetInt(mcp_calibration_registers.dc_offset_current, data, 20+7, 2); McpSetInt(cal_registers->dc_offset_current, data, 20+7, 2);
McpSetInt(mcp_calibration_registers.phase_compensation, data, 22+7, 2); McpSetInt(cal_registers->phase_compensation, data, 22+7, 2);
McpSetInt(mcp_calibration_registers.apparent_power_divisor, data, 24+7, 2); McpSetInt(cal_registers->apparent_power_divisor, data, 24+7, 2);
McpSetInt(mcp_calibration_registers.system_configuration, data, 26+7, 4); McpSetInt(cal_registers->system_configuration, data, 26+7, 4);
McpSetInt(mcp_calibration_registers.dio_configuration, data, 30+7, 2); McpSetInt(cal_registers->dio_configuration, data, 30+7, 2);
McpSetInt(mcp_calibration_registers.range, data, 32+7, 4); McpSetInt(cal_registers->range, data, 32+7, 4);
McpSetInt(mcp_calibration_registers.calibration_current, data, 36+7, 4); McpSetInt(cal_registers->calibration_current, data, 36+7, 4);
McpSetInt(mcp_calibration_registers.calibration_voltage, data, 40+7, 2); McpSetInt(cal_registers->calibration_voltage, data, 40+7, 2);
McpSetInt(mcp_calibration_registers.calibration_active_power, data, 42+7, 4); McpSetInt(cal_registers->calibration_active_power, data, 42+7, 4);
McpSetInt(mcp_calibration_registers.calibration_reactive_power, data, 46+7, 4); McpSetInt(cal_registers->calibration_reactive_power, data, 46+7, 4);
McpSetInt(mcp_calibration_registers.accumulation_interval, data, 50+7, 2); 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+7] = MCP_SAVE_REGISTERS; // Save registers to flash
data[MCP_CALIBRATION_LEN+8] = mcp_address; // Device address data[MCP_CALIBRATION_LEN+8] = mcp_address; // Device address
@ -334,187 +329,123 @@ void McpSetCalibration()
McpSend(data); McpSend(data);
} }
void McpGetFrequency() /********************************************************************************************/
void McpGetFrequency(void)
{ {
if (mcp_calibration_active) { return; } if (mcp_calibration_active) { return; }
mcp_calibration_active = 4; mcp_calibration_active = 4;
// A5 0B 41 00 94 52 41 00 AE 52 18 uint8_t data[] = { MCP_START_FRAME, 11, MCP_SET_ADDRESS, (MCP_FREQUENCY_REF_BASE >> 8) & 0xFF, MCP_FREQUENCY_REF_BASE & 0xFF, MCP_READ_16,
uint8_t data[11]; MCP_SET_ADDRESS, (MCP_FREQUENCY_GAIN_BASE >> 8) & 0xFF, MCP_FREQUENCY_GAIN_BASE & 0xFF, MCP_READ_16, 0x00 };
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
McpSend(data); 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 // A5 11 41 00 94 57 C3 B4 41 00 AE 57 7E 46 53 4D 03
uint8_t data[17]; uint8_t data[17];
data[ 1] = sizeof(data); 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[ 3] = (MCP_FREQUENCY_REF_BASE >> 8) & 0xFF; // address
data[ 4] = (MCP_FREQUENCY_REF_BASE >> 0) & 0xFF; // address data[ 4] = (MCP_FREQUENCY_REF_BASE >> 0) & 0xFF; // address
data[ 5] = MCP_WRITE_16; // Write register data[ 5] = MCP_WRITE_16; // Write register
data[ 6] = (mcp_frequency_registers.line_frequency_ref >> 8) & 0xFF; // line_frequency_ref high data[ 6] = (line_frequency_ref >> 8) & 0xFF; // line_frequency_ref high
data[ 7] = (mcp_frequency_registers.line_frequency_ref >> 0) & 0xFF; // line_frequency_ref low data[ 7] = (line_frequency_ref >> 0) & 0xFF; // line_frequency_ref low
data[ 8] = MCP_SET_ADDRESS; // Set address pointer data[ 8] = MCP_SET_ADDRESS; // Set address pointer
data[ 9] = (MCP_FREQUENCY_GAIN_BASE >> 8) & 0xFF; // address data[ 9] = (MCP_FREQUENCY_GAIN_BASE >> 8) & 0xFF; // address
data[10] = (MCP_FREQUENCY_GAIN_BASE >> 0) & 0xFF; // address data[10] = (MCP_FREQUENCY_GAIN_BASE >> 0) & 0xFF; // address
data[11] = MCP_WRITE_16; // Write register data[11] = MCP_WRITE_16; // Write register
data[12] = (mcp_frequency_registers.gain_line_frequency >> 8) & 0xFF; // gain_line_frequency high data[12] = (gain_line_frequency >> 8) & 0xFF; // gain_line_frequency high
data[13] = (mcp_frequency_registers.gain_line_frequency >> 0) & 0xFF; // gain_line_frequency low data[13] = (gain_line_frequency >> 0) & 0xFF; // gain_line_frequency low
data[14] = MCP_SAVE_REGISTERS; // Save registers to flash data[14] = MCP_SAVE_REGISTERS; // Save registers to flash
data[15] = mcp_address; // Device address data[15] = mcp_address; // Device address
McpSend(data); McpSend(data);
} }
/********************************************************************************************/
void McpSetSystemConfiguration(uint16 interval) void McpSetSystemConfiguration(uint16 interval)
{ {
// A5 11 41 00 42 45 03 00 01 00 41 00 5A 57 00 06 7A // A5 11 41 00 42 45 03 00 01 00 41 00 5A 57 00 06 7A
uint8_t data[17]; uint8_t data[17];
data[ 1] = sizeof(data); data[ 1] = sizeof(data);
data[ 2] = MCP_SET_ADDRESS; // Set address pointer data[ 2] = MCP_SET_ADDRESS; // Set address pointer
data[ 3] = 0x00; // address data[ 3] = 0x00; // address
data[ 4] = 0x42; // address data[ 4] = 0x42; // address
data[ 5] = MCP_WRITE_32; // Write 4 bytes data[ 5] = MCP_WRITE_32; // Write 4 bytes
data[ 6] = (mcp_system_configuration >> 24) & 0xFF; // system_configuration data[ 6] = (mcp_system_configuration >> 24) & 0xFF; // system_configuration
data[ 7] = (mcp_system_configuration >> 16) & 0xFF; // system_configuration data[ 7] = (mcp_system_configuration >> 16) & 0xFF; // system_configuration
data[ 8] = (mcp_system_configuration >> 8) & 0xFF; // system_configuration data[ 8] = (mcp_system_configuration >> 8) & 0xFF; // system_configuration
data[ 9] = (mcp_system_configuration >> 0) & 0xFF; // system_configuration data[ 9] = (mcp_system_configuration >> 0) & 0xFF; // system_configuration
data[10] = MCP_SET_ADDRESS; // Set address pointer data[10] = MCP_SET_ADDRESS; // Set address pointer
data[11] = 0x00; // address data[11] = 0x00; // address
data[12] = 0x5A; // address data[12] = 0x5A; // address
data[13] = MCP_WRITE_16; // Write 2 bytes data[13] = MCP_WRITE_16; // Write 2 bytes
data[14] = (interval >> 8) & 0xFF; // interval data[14] = (interval >> 8) & 0xFF; // interval
data[15] = (interval >> 0) & 0xFF; // interval data[15] = (interval >> 0) & 0xFF; // interval
McpSend(data); 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) void McpSingleWireStop(uint8_t force)
{ {
if (!force && ((mcp_system_configuration & (1 << 8)) == 0)) { return; } if (!force && ((mcp_system_configuration & (1 << 8)) == 0)) { return; }
mcp_system_configuration = mcp_system_configuration & (~(1 << 8)); mcp_system_configuration = mcp_system_configuration & (~(1 << 8));
McpSetSystemConfiguration(2); // 4 McpSetSystemConfiguration(2); // 4
mcp_single_wire_active = 0;
} }
/********************************************************************************************/ /********************************************************************************************/
void McpAddressReceive() void McpGetData(void)
{ {
// 06 05 004D 58 uint8_t data[] = { MCP_START_FRAME, 8, MCP_SET_ADDRESS, 0x00, 0x04, MCP_READ, 22, 0x00 };
mcp_address = serial_in_buffer[2] * 256 + serial_in_buffer[3];
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_output_registers.current_rms = McpExtractInt(serial_in_buffer, 2, 4);
mcp_calibration_registers.gain_current_rms = McpExtractInt(serial_in_buffer, 2, 2); mcp_output_registers.voltage_rms = McpExtractInt(serial_in_buffer, 6, 2);
mcp_calibration_registers.gain_voltage_rms = McpExtractInt(serial_in_buffer, 4, 2); mcp_output_registers.active_power = McpExtractInt(serial_in_buffer, 8, 4);
mcp_calibration_registers.gain_active_power = McpExtractInt(serial_in_buffer, 6, 2); // mcp_output_registers.reactive_power = McpExtractInt(serial_in_buffer, 12, 4);
mcp_calibration_registers.gain_reactive_power = McpExtractInt(serial_in_buffer, 8, 2); // mcp_output_registers.power_factor = McpExtractInt(serial_in_buffer, 20, 2);
mcp_calibration_registers.offset_current_rms = McpExtractInt(serial_in_buffer, 10, 4); mcp_output_registers.line_frequency = McpExtractInt(serial_in_buffer, 22, 2);
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);
}
if (energy_power_on) { // Powered on if (energy_power_on) { // Powered on
energy_frequency = (float)mcp_output_registers.line_frequency / 1000; 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; serial_in_buffer[serial_in_byte_counter++] = serial_in_byte;
unsigned long start = millis(); unsigned long start = millis();
@ -564,7 +497,7 @@ bool McpSerialInput()
AddLog_P(LOG_LEVEL_DEBUG, PSTR("MCP: " D_CHECKSUM_FAILURE)); AddLog_P(LOG_LEVEL_DEBUG, PSTR("MCP: " D_CHECKSUM_FAILURE));
} else { } else {
if (5 == serial_in_buffer[1]) { McpAddressReceive(); } 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_CALIBRATION_LEN + 3 == serial_in_buffer[1]) { McpParseCalibration(); }
if (MCP_FREQUENCY_LEN + 3 == serial_in_buffer[1]) { McpParseFrequency(); } if (MCP_FREQUENCY_LEN + 3 == serial_in_buffer[1]) { McpParseFrequency(); }
} }
@ -573,15 +506,6 @@ bool McpSerialInput()
mcp_timeout = 0; mcp_timeout = 0;
} }
else if (MCP_SINGLE_WIRE == serial_in_buffer[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; mcp_timeout = 0;
} }
return 1; 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) { if (mcp_output_registers.active_power) {
energy_kWhtoday_delta += ((mcp_output_registers.active_power * 10) / 36); energy_kWhtoday_delta += ((mcp_output_registers.active_power * 10) / 36);
EnergyUpdateToday(); EnergyUpdateToday();
@ -611,18 +533,18 @@ void McpEverySecond()
else if (!mcp_address) { else if (!mcp_address) {
McpGetAddress(); McpGetAddress();
} }
else if (!mcp_single_wire_active) { else {
McpSend(get_state); McpGetData();
} }
} }
void McpSnsInit() void McpSnsInit(void)
{ {
SetSeriallog(LOG_LEVEL_NONE); // Free serial interface from logging interference SetSeriallog(LOG_LEVEL_NONE); // Free serial interface from logging interference
digitalWrite(15, 1); // GPIO15 - MCP enable digitalWrite(15, 1); // GPIO15 - MCP enable
} }
void McpDrvInit() void McpDrvInit(void)
{ {
if (!energy_flg) { if (!energy_flg) {
if (SHELLY2 == Settings.module) { if (SHELLY2 == Settings.module) {
@ -638,7 +560,7 @@ void McpDrvInit()
} }
} }
boolean McpCommand() boolean McpCommand(void)
{ {
boolean serviced = true; boolean serviced = true;
unsigned long value = 0; unsigned long value = 0;