Fork of the espurna firmware for `mhsw` switches
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

234 lines
6.2 KiB

/*
POWER V9261F MODULE
Copyright (C) 2016-2017 by Xose Pérez <xose dot perez at gmail dot com>
*/
#if POWER_PROVIDER == POWER_PROVIDER_V9261F
// -----------------------------------------------------------------------------
// MODULE GLOBALS AND CACHE
// -----------------------------------------------------------------------------
#include <SoftwareSerial.h>
SoftwareSerial * _v9261f_uart;
double _v9261f_active = 0;
double _v9261f_reactive = 0;
double _v9261f_voltage = 0;
double _v9261f_current = 0;
double _v9261f_ratioP = V9261F_POWER_FACTOR;
double _v9261f_ratioC = V9261F_CURRENT_FACTOR;
double _v9261f_ratioV = V9261F_VOLTAGE_FACTOR;
double _v9261f_ratioR = V9261F_RPOWER_FACTOR;
unsigned char _v9261f_data[24];
// -----------------------------------------------------------------------------
// HAL
// -----------------------------------------------------------------------------
void _v9261fRead() {
static unsigned char state = 0;
static unsigned long last = 0;
static bool found = false;
static unsigned char index = 0;
if (state == 0) {
while (_v9261f_uart->available()) {
_v9261f_uart->flush();
found = true;
last = millis();
}
if (found && (millis() - last > V9261F_SYNC_INTERVAL)) {
_v9261f_uart->flush();
index = 0;
state = 1;
}
} else if (state == 1) {
while (_v9261f_uart->available()) {
_v9261f_uart->read();
if (index++ >= 7) {
_v9261f_uart->flush();
index = 0;
state = 2;
}
}
} else if (state == 2) {
while (_v9261f_uart->available()) {
_v9261f_data[index] = _v9261f_uart->read();
if (index++ >= 19) {
_v9261f_uart->flush();
last = millis();
state = 3;
}
}
} else if (state == 3) {
if (_v9261fChecksum()) {
_v9261f_active = (double) (
(_v9261f_data[3]) +
(_v9261f_data[4] << 8) +
(_v9261f_data[5] << 16) +
(_v9261f_data[6] << 24)
) / _v9261f_ratioP;
_v9261f_reactive = (double) (
(_v9261f_data[7]) +
(_v9261f_data[8] << 8) +
(_v9261f_data[9] << 16) +
(_v9261f_data[10] << 24)
) / _v9261f_ratioR;
_v9261f_voltage = (double) (
(_v9261f_data[11]) +
(_v9261f_data[12] << 8) +
(_v9261f_data[13] << 16) +
(_v9261f_data[14] << 24)
) / _v9261f_ratioV;
_v9261f_current = (double) (
(_v9261f_data[15]) +
(_v9261f_data[16] << 8) +
(_v9261f_data[17] << 16) +
(_v9261f_data[18] << 24)
) / _v9261f_ratioC;
if (_v9261f_active < 0) _v9261f_active = 0;
if (_v9261f_reactive < 0) _v9261f_reactive = 0;
if (_v9261f_voltage < 0) _v9261f_voltage = 0;
if (_v9261f_current < 0) _v9261f_current = 0;
_power_newdata = true;
}
last = millis();
index = 0;
state = 4;
} else if (state == 4) {
while (_v9261f_uart->available()) {
_v9261f_uart->flush();
last = millis();
}
if (millis() - last > V9261F_SYNC_INTERVAL) {
state = 1;
}
}
}
bool _v9261fChecksum() {
unsigned char checksum = 0;
for (unsigned char i = 0; i < 19; i++) {
checksum = checksum + _v9261f_data[i];
}
checksum = ~checksum + 0x33;
return checksum == _v9261f_data[19];
}
// -----------------------------------------------------------------------------
// POWER API
// -----------------------------------------------------------------------------
double _powerCurrent() {
return _v9261f_current;
}
double _powerVoltage() {
return _v9261f_voltage;
}
double _powerActivePower() {
return _v9261f_active;
}
double _powerApparentPower() {
return sqrt(_v9261f_reactive * _v9261f_reactive + _v9261f_active * _v9261f_active);
}
double _powerReactivePower() {
return _v9261f_reactive;
}
double _powerPowerFactor() {
double apparent = _powerApparentPower();
if (apparent > 0) return _powerActivePower() / apparent;
return 1;
}
void _powerEnabledProvider() {
// Nothing to do
}
void _powerConfigureProvider() {
_v9261f_ratioP = getSetting("pwrRatioP", V9261F_POWER_FACTOR).toFloat();
_v9261f_ratioV = getSetting("pwrRatioV", V9261F_VOLTAGE_FACTOR).toFloat();
_v9261f_ratioC = getSetting("pwrRatioC", V9261F_CURRENT_FACTOR).toFloat();
_v9261f_ratioR = getSetting("pwrRatioR", V9261F_RPOWER_FACTOR).toFloat();
}
void _powerCalibrateProvider(unsigned char magnitude, double value) {
if (value <= 0) return;
if (magnitude == POWER_MAGNITUDE_ACTIVE) {
_v9261f_ratioP = _v9261f_ratioP * (_v9261f_active / value);
setSetting("pwrRatioP", _v9261f_ratioP);
}
if (magnitude == POWER_MAGNITUDE_CURRENT) {
_v9261f_ratioC = _v9261f_ratioC * (_v9261f_current / value);
setSetting("pwrRatioC", _v9261f_ratioC);
}
if (magnitude == POWER_MAGNITUDE_VOLTAGE) {
_v9261f_ratioV = _v9261f_ratioV * (_v9261f_voltage / value);
setSetting("pwrRatioV", _v9261f_ratioV);
}
if (magnitude == POWER_MAGNITUDE_POWER_FACTOR) {
if (value < 100) {
double apparent = _v9261f_ratioP / (value / 100);
value = sqrt(apparent * apparent - _v9261f_ratioP * _v9261f_ratioP);
_v9261f_ratioR = _v9261f_ratioR * (_v9261f_reactive / value);
setSetting("pwrRatioR", _v9261f_ratioR);
}
}
saveSettings();
}
void _powerResetCalibrationProvider() {
delSetting("pwrRatioP");
delSetting("pwrRatioC");
delSetting("pwrRatioV");
delSetting("pwrRatioR");
_powerConfigureProvider();
saveSettings();
}
void _powerSetupProvider() {
_v9261f_uart = new SoftwareSerial(V9261F_PIN, SW_SERIAL_UNUSED_PIN, V9261F_PIN_INVERSE, 256);
_v9261f_uart->begin(V9261F_BAUDRATE);
}
void _powerLoopProvider(bool before) {
if (before) {
_v9261fRead();
}
}
#endif // POWER_PROVIDER == POWER_PROVIDER_V9261F