mirror of
https://github.com/UtilitechAS/amsreader-firmware.git
synced 2026-01-14 15:54:47 +00:00
865 lines
21 KiB
C++
865 lines
21 KiB
C++
#include "AmsConfiguration.h"
|
|
|
|
uint8_t AmsConfiguration::getBoardType() {
|
|
return config.boardType;
|
|
}
|
|
|
|
void AmsConfiguration::setBoardType(uint8_t boardType) {
|
|
config.boardType = boardType;
|
|
}
|
|
|
|
char* AmsConfiguration::getWifiSsid() {
|
|
return config.wifiSsid;
|
|
}
|
|
|
|
void AmsConfiguration::setWifiSsid(const char* wifiSsid) {
|
|
wifiChanged |= strcmp(config.wifiSsid, wifiSsid) != 0;
|
|
strcpy(config.wifiSsid, wifiSsid);
|
|
}
|
|
|
|
char* AmsConfiguration::getWifiPassword() {
|
|
return config.wifiPassword;
|
|
}
|
|
|
|
void AmsConfiguration::setWifiPassword(const char* wifiPassword) {
|
|
wifiChanged |= strcmp(config.wifiPassword, wifiPassword) != 0;
|
|
strcpy(config.wifiPassword, wifiPassword);
|
|
}
|
|
|
|
char* AmsConfiguration::getWifiIp() {
|
|
return config.wifiIp;
|
|
}
|
|
|
|
void AmsConfiguration::setWifiIp(const char* wifiIp) {
|
|
wifiChanged |= strcmp(config.wifiIp, wifiIp) != 0;
|
|
strcpy(config.wifiIp, wifiIp);
|
|
}
|
|
|
|
char* AmsConfiguration::getWifiGw() {
|
|
return config.wifiGw;
|
|
}
|
|
|
|
void AmsConfiguration::setWifiGw(const char* wifiGw) {
|
|
wifiChanged |= strcmp(config.wifiGw, wifiGw) != 0;
|
|
strcpy(config.wifiGw, wifiGw);
|
|
}
|
|
|
|
char* AmsConfiguration::getWifiSubnet() {
|
|
return config.wifiSubnet;
|
|
}
|
|
|
|
void AmsConfiguration::setWifiSubnet(const char* wifiSubnet) {
|
|
wifiChanged |= strcmp(config.wifiSubnet, wifiSubnet) != 0;
|
|
strcpy(config.wifiSubnet, wifiSubnet);
|
|
}
|
|
|
|
char* AmsConfiguration::getWifiDns1() {
|
|
return config.wifiDns1;
|
|
}
|
|
|
|
void AmsConfiguration::setWifiDns1(const char* wifiDns1) {
|
|
wifiChanged |= strcmp(config.wifiDns1, wifiDns1) != 0;
|
|
strcpy(config.wifiDns1, wifiDns1);
|
|
}
|
|
|
|
char* AmsConfiguration::getWifiDns2() {
|
|
return config.wifiDns2;
|
|
}
|
|
|
|
void AmsConfiguration::setWifiDns2(const char* wifiDns2) {
|
|
wifiChanged |= strcmp(config.wifiDns2, wifiDns2) != 0;
|
|
strcpy(config.wifiDns2, wifiDns2);
|
|
}
|
|
|
|
char* AmsConfiguration::getWifiHostname() {
|
|
return config.wifiHostname;
|
|
}
|
|
|
|
void AmsConfiguration::setWifiHostname(const char* wifiHostname) {
|
|
wifiChanged |= strcmp(config.wifiHostname, wifiHostname) != 0;
|
|
strcpy(config.wifiHostname, wifiHostname);
|
|
}
|
|
|
|
void AmsConfiguration::clearWifi() {
|
|
setWifiSsid("");
|
|
setWifiPassword("");
|
|
setWifiHostname("");
|
|
clearWifiIp();
|
|
}
|
|
|
|
void AmsConfiguration::clearWifiIp() {
|
|
setWifiIp("");
|
|
setWifiGw("");
|
|
setWifiSubnet("");
|
|
setWifiDns1("");
|
|
setWifiDns2("");
|
|
}
|
|
|
|
bool AmsConfiguration::isWifiChanged() {
|
|
return wifiChanged;
|
|
}
|
|
|
|
void AmsConfiguration::ackWifiChange() {
|
|
wifiChanged = false;
|
|
}
|
|
|
|
|
|
char* AmsConfiguration::getMqttHost() {
|
|
return config.mqttHost;
|
|
}
|
|
|
|
void AmsConfiguration::setMqttHost(const char* mqttHost) {
|
|
mqttChanged |= strcmp(config.mqttHost, mqttHost) != 0;
|
|
strcpy(config.mqttHost, mqttHost);
|
|
}
|
|
|
|
uint16_t AmsConfiguration::getMqttPort() {
|
|
return config.mqttPort;
|
|
}
|
|
|
|
void AmsConfiguration::setMqttPort(uint16_t mqttPort) {
|
|
mqttChanged |= config.mqttPort != mqttPort;
|
|
config.mqttPort = mqttPort;
|
|
}
|
|
|
|
char* AmsConfiguration::getMqttClientId() {
|
|
return config.mqttClientId;
|
|
}
|
|
|
|
void AmsConfiguration::setMqttClientId(const char* mqttClientId) {
|
|
mqttChanged |= strcmp(config.mqttClientId, mqttClientId) != 0;
|
|
strcpy(config.mqttClientId, mqttClientId);
|
|
}
|
|
|
|
char* AmsConfiguration::getMqttPublishTopic() {
|
|
return config.mqttPublishTopic;
|
|
}
|
|
|
|
void AmsConfiguration::setMqttPublishTopic(const char* mqttPublishTopic) {
|
|
mqttChanged |= strcmp(config.mqttPublishTopic, mqttPublishTopic) != 0;
|
|
strcpy(config.mqttPublishTopic, mqttPublishTopic);
|
|
}
|
|
|
|
char* AmsConfiguration::getMqttSubscribeTopic() {
|
|
return config.mqttSubscribeTopic;
|
|
}
|
|
|
|
void AmsConfiguration::setMqttSubscribeTopic(const char* mqttSubscribeTopic) {
|
|
mqttChanged |= strcmp(config.mqttSubscribeTopic, mqttSubscribeTopic) != 0;
|
|
strcpy(config.mqttSubscribeTopic, mqttSubscribeTopic);
|
|
}
|
|
|
|
char* AmsConfiguration::getMqttUser() {
|
|
return config.mqttUser;
|
|
}
|
|
|
|
void AmsConfiguration::setMqttUser(const char* mqttUser) {
|
|
mqttChanged |= strcmp(config.mqttUser, mqttUser) != 0;
|
|
strcpy(config.mqttUser, mqttUser);
|
|
}
|
|
|
|
char* AmsConfiguration::getMqttPassword() {
|
|
return config.mqttPassword;
|
|
}
|
|
|
|
void AmsConfiguration::setMqttPassword(const char* mqttPassword) {
|
|
mqttChanged |= strcmp(config.mqttPassword, mqttPassword) != 0;
|
|
strcpy(config.mqttPassword, mqttPassword);
|
|
}
|
|
|
|
uint8_t AmsConfiguration::getMqttPayloadFormat() {
|
|
return config.mqttPayloadFormat;
|
|
}
|
|
|
|
void AmsConfiguration::setMqttPayloadFormat(uint8_t mqttPayloadFormat) {
|
|
config.mqttPayloadFormat = mqttPayloadFormat;
|
|
}
|
|
|
|
bool AmsConfiguration::isMqttSsl() {
|
|
return config.mqttSsl;
|
|
}
|
|
|
|
void AmsConfiguration::setMqttSsl(bool mqttSsl) {
|
|
mqttChanged |= config.mqttSsl != mqttSsl;
|
|
config.mqttSsl = mqttSsl;
|
|
}
|
|
|
|
void AmsConfiguration::clearMqtt() {
|
|
setMqttHost("");
|
|
setMqttPort(1883);
|
|
setMqttClientId("");
|
|
setMqttPublishTopic("");
|
|
setMqttSubscribeTopic("");
|
|
setMqttUser("");
|
|
setMqttPassword("");
|
|
setMqttSsl(false);
|
|
}
|
|
|
|
void AmsConfiguration::setMqttChanged() {
|
|
mqttChanged = true;
|
|
}
|
|
|
|
bool AmsConfiguration::isMqttChanged() {
|
|
return mqttChanged;
|
|
}
|
|
|
|
void AmsConfiguration::ackMqttChange() {
|
|
mqttChanged = false;
|
|
}
|
|
|
|
byte AmsConfiguration::getAuthSecurity() {
|
|
return config.authSecurity;
|
|
}
|
|
|
|
void AmsConfiguration::setAuthSecurity(byte authSecurity) {
|
|
config.authSecurity = authSecurity;
|
|
}
|
|
|
|
char* AmsConfiguration::getAuthUser() {
|
|
return config.authUser;
|
|
}
|
|
|
|
void AmsConfiguration::setAuthUser(const char* authUser) {
|
|
strcpy(config.authUser, authUser);
|
|
}
|
|
|
|
char* AmsConfiguration::getAuthPassword() {
|
|
return config.authPassword;
|
|
}
|
|
|
|
void AmsConfiguration::setAuthPassword(const char* authPassword) {
|
|
strcpy(config.authPassword, authPassword);
|
|
}
|
|
|
|
void AmsConfiguration::clearAuth() {
|
|
setAuthSecurity(0);
|
|
setAuthUser("");
|
|
setAuthPassword("");
|
|
}
|
|
|
|
uint8_t AmsConfiguration::getMeterType() {
|
|
return config.meterType;
|
|
}
|
|
|
|
void AmsConfiguration::setMeterType(uint8_t meterType) {
|
|
config.meterType = meterType;
|
|
}
|
|
|
|
uint8_t AmsConfiguration::getDistributionSystem() {
|
|
return config.distributionSystem;
|
|
}
|
|
|
|
void AmsConfiguration::setDistributionSystem(uint8_t distributionSystem) {
|
|
config.distributionSystem = distributionSystem;
|
|
}
|
|
|
|
uint8_t AmsConfiguration::getMainFuse() {
|
|
return config.mainFuse;
|
|
}
|
|
|
|
void AmsConfiguration::setMainFuse(uint8_t mainFuse) {
|
|
config.mainFuse = mainFuse;
|
|
}
|
|
|
|
uint8_t AmsConfiguration::getProductionCapacity() {
|
|
return config.productionCapacity;
|
|
}
|
|
|
|
void AmsConfiguration::setProductionCapacity(uint8_t productionCapacity) {
|
|
config.productionCapacity = productionCapacity;
|
|
}
|
|
|
|
bool AmsConfiguration::isSubstituteMissing() {
|
|
return config.substituteMissing;
|
|
}
|
|
|
|
void AmsConfiguration::setSubstituteMissing(bool substituteMissing) {
|
|
config.substituteMissing = substituteMissing;
|
|
}
|
|
|
|
bool AmsConfiguration::isSendUnknown() {
|
|
return config.sendUnknown;
|
|
}
|
|
|
|
void AmsConfiguration::setSendUnknown(bool sendUnknown) {
|
|
config.sendUnknown = sendUnknown;
|
|
}
|
|
|
|
void AmsConfiguration::clearMeter() {
|
|
setMeterType(0);
|
|
setDistributionSystem(0);
|
|
setMainFuse(0);
|
|
setProductionCapacity(0);
|
|
setSubstituteMissing(false);
|
|
setSendUnknown(false);
|
|
}
|
|
|
|
|
|
bool AmsConfiguration::isDebugTelnet() {
|
|
return config.debugTelnet;
|
|
}
|
|
|
|
void AmsConfiguration::setDebugTelnet(bool debugTelnet) {
|
|
config.debugTelnet = debugTelnet;
|
|
}
|
|
|
|
bool AmsConfiguration::isDebugSerial() {
|
|
return config.debugSerial;
|
|
}
|
|
|
|
void AmsConfiguration::setDebugSerial(bool debugSerial) {
|
|
config.debugSerial = debugSerial;
|
|
}
|
|
|
|
uint8_t AmsConfiguration::getDebugLevel() {
|
|
return config.debugLevel;
|
|
}
|
|
|
|
void AmsConfiguration::setDebugLevel(uint8_t debugLevel) {
|
|
config.debugLevel = debugLevel;
|
|
}
|
|
|
|
uint16_t AmsConfiguration::getDomoELIDX() {
|
|
return config.domoELIDX;
|
|
}
|
|
uint16_t AmsConfiguration::getDomoVL1IDX() {
|
|
return config.domoVL1IDX;
|
|
}
|
|
uint16_t AmsConfiguration::getDomoVL2IDX() {
|
|
return config.domoVL2IDX;
|
|
}
|
|
uint16_t AmsConfiguration::getDomoVL3IDX() {
|
|
return config.domoVL3IDX;
|
|
}
|
|
uint16_t AmsConfiguration::getDomoCL1IDX() {
|
|
return config.domoCL1IDX;
|
|
}
|
|
|
|
void AmsConfiguration::setDomoELIDX(uint16_t domoELIDX) {
|
|
domoChanged |= config.domoELIDX != domoELIDX;
|
|
config.domoELIDX = domoELIDX;
|
|
}
|
|
|
|
void AmsConfiguration::setDomoVL1IDX(uint16_t domoVL1IDX) {
|
|
domoChanged |= config.domoVL1IDX != domoVL1IDX;
|
|
config.domoVL1IDX = domoVL1IDX;
|
|
}
|
|
|
|
void AmsConfiguration::setDomoVL2IDX(uint16_t domoVL2IDX) {
|
|
domoChanged |= config.domoVL2IDX != domoVL2IDX;
|
|
config.domoVL2IDX = domoVL2IDX;
|
|
}
|
|
|
|
void AmsConfiguration::setDomoVL3IDX(uint16_t domoVL3IDX) {
|
|
domoChanged |= config.domoVL3IDX != domoVL3IDX;
|
|
config.domoVL3IDX = domoVL3IDX;
|
|
}
|
|
|
|
void AmsConfiguration::setDomoCL1IDX(uint16_t domoCL1IDX) {
|
|
domoChanged |= config.domoCL1IDX != domoCL1IDX;
|
|
config.domoCL1IDX = domoCL1IDX;
|
|
}
|
|
|
|
void AmsConfiguration::clearDomo() {
|
|
setDomoELIDX(0);
|
|
setDomoVL1IDX(0);
|
|
setDomoVL2IDX(0);
|
|
setDomoVL3IDX(0);
|
|
setDomoCL1IDX(0);
|
|
}
|
|
|
|
bool AmsConfiguration::pinUsed(uint8_t pin) {
|
|
if(pin == 0xFF)
|
|
return false;
|
|
return
|
|
pin == config.hanPin ||
|
|
pin == config.apPin ||
|
|
pin == config.ledPinRed ||
|
|
pin == config.ledPinGreen ||
|
|
pin == config.ledPinBlue ||
|
|
pin == config.tempSensorPin ||
|
|
pin == config.vccPin
|
|
;
|
|
}
|
|
|
|
uint8_t AmsConfiguration::getHanPin() {
|
|
return config.hanPin;
|
|
}
|
|
|
|
void AmsConfiguration::setHanPin(uint8_t hanPin) {
|
|
if(!pinUsed(hanPin)) {
|
|
config.hanPin = hanPin;
|
|
}
|
|
}
|
|
|
|
uint8_t AmsConfiguration::getApPin() {
|
|
return config.apPin;
|
|
}
|
|
|
|
void AmsConfiguration::setApPin(uint8_t apPin) {
|
|
if(!pinUsed(apPin)) {
|
|
config.apPin = apPin;
|
|
if(apPin >= 0)
|
|
pinMode(apPin, INPUT_PULLUP);
|
|
}
|
|
}
|
|
|
|
uint8_t AmsConfiguration::getLedPin() {
|
|
return config.ledPin;
|
|
}
|
|
|
|
void AmsConfiguration::setLedPin(uint8_t ledPin) {
|
|
if(!pinUsed(ledPin)) {
|
|
config.ledPin = ledPin;
|
|
}
|
|
}
|
|
|
|
bool AmsConfiguration::isLedInverted() {
|
|
return config.ledInverted;
|
|
}
|
|
|
|
void AmsConfiguration::setLedInverted(bool ledInverted) {
|
|
config.ledInverted = ledInverted;
|
|
}
|
|
|
|
|
|
uint8_t AmsConfiguration::getLedPinRed() {
|
|
return config.ledPinRed;
|
|
}
|
|
|
|
void AmsConfiguration::setLedPinRed(uint8_t ledPinRed) {
|
|
if(!pinUsed(ledPinRed)) {
|
|
config.ledPinRed = ledPinRed;
|
|
}
|
|
}
|
|
|
|
uint8_t AmsConfiguration::getLedPinGreen() {
|
|
return config.ledPinGreen;
|
|
}
|
|
|
|
void AmsConfiguration::setLedPinGreen(uint8_t ledPinGreen) {
|
|
if(!pinUsed(ledPinGreen)) {
|
|
config.ledPinGreen = ledPinGreen;
|
|
}
|
|
}
|
|
|
|
uint8_t AmsConfiguration::getLedPinBlue() {
|
|
return config.ledPinBlue;
|
|
}
|
|
|
|
void AmsConfiguration::setLedPinBlue(uint8_t ledPinBlue) {
|
|
if(!pinUsed(ledPinBlue)) {
|
|
config.ledPinBlue = ledPinBlue;
|
|
}
|
|
}
|
|
|
|
bool AmsConfiguration::isLedRgbInverted() {
|
|
return config.ledRgbInverted;
|
|
}
|
|
|
|
void AmsConfiguration::setLedRgbInverted(bool ledRgbInverted) {
|
|
config.ledRgbInverted = ledRgbInverted;
|
|
}
|
|
|
|
|
|
uint8_t AmsConfiguration::getTempSensorPin() {
|
|
return config.tempSensorPin;
|
|
}
|
|
|
|
void AmsConfiguration::setTempSensorPin(uint8_t tempSensorPin) {
|
|
if(!pinUsed(tempSensorPin)) {
|
|
config.tempSensorPin = tempSensorPin;
|
|
}
|
|
}
|
|
|
|
uint8_t AmsConfiguration::getVccPin() {
|
|
return config.vccPin;
|
|
}
|
|
|
|
void AmsConfiguration::setVccPin(uint8_t vccPin) {
|
|
if(!pinUsed(vccPin)) {
|
|
config.vccPin = vccPin;
|
|
}
|
|
}
|
|
|
|
double AmsConfiguration::getVccMultiplier() {
|
|
return config.vccMultiplier / 1000.0;
|
|
}
|
|
|
|
void AmsConfiguration::setVccMultiplier(double vccMultiplier) {
|
|
config.vccMultiplier = max(1, min((int) (vccMultiplier * 1000), 65535));
|
|
}
|
|
|
|
double AmsConfiguration::getVccBootLimit() {
|
|
return config.vccBootLimit / 10.0;
|
|
}
|
|
|
|
void AmsConfiguration::setVccBootLimit(double vccBootLimit) {
|
|
if(vccBootLimit == 0.0)
|
|
config.vccBootLimit = 0;
|
|
else
|
|
config.vccBootLimit = max(25, min((int)(vccBootLimit * 10), 35));
|
|
}
|
|
bool AmsConfiguration::isDomoChanged() {
|
|
return domoChanged;
|
|
}
|
|
|
|
void AmsConfiguration::ackDomoChange() {
|
|
domoChanged = false;
|
|
}
|
|
|
|
void AmsConfiguration::clear() {
|
|
clearMeter();
|
|
clearWifi();
|
|
clearMqtt();
|
|
clearAuth();
|
|
clearDomo();
|
|
|
|
int address = EEPROM_CONFIG_ADDRESS;
|
|
|
|
EEPROM.begin(EEPROM_SIZE);
|
|
while(address < EEPROM_CONFIG_ADDRESS+EEPROM_SIZE) {
|
|
EEPROM.put(address++, 0);
|
|
}
|
|
EEPROM.commit();
|
|
EEPROM.end();
|
|
}
|
|
|
|
bool AmsConfiguration::hasConfig() {
|
|
if(configVersion == 0) {
|
|
EEPROM.begin(EEPROM_SIZE);
|
|
configVersion = EEPROM.read(EEPROM_CONFIG_ADDRESS);
|
|
EEPROM.end();
|
|
}
|
|
switch(configVersion) {
|
|
case 71:
|
|
case 72:
|
|
case 75:
|
|
case 80:
|
|
case 81:
|
|
case 82:
|
|
return true;
|
|
default:
|
|
configVersion = 0;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
int AmsConfiguration::getConfigVersion() {
|
|
return configVersion;
|
|
}
|
|
|
|
bool AmsConfiguration::load() {
|
|
int address = EEPROM_CONFIG_ADDRESS;
|
|
bool success = false;
|
|
|
|
EEPROM.begin(EEPROM_SIZE);
|
|
int cs = EEPROM.read(address);
|
|
address++;
|
|
switch(cs) {
|
|
case 80: // v1.1
|
|
success = loadConfig80(address);
|
|
break;
|
|
case 81: // v1.2
|
|
success = loadConfig81(address);
|
|
break;
|
|
case 82: // v1.3
|
|
EEPROM.get(address, config);
|
|
success = true;
|
|
break;
|
|
}
|
|
EEPROM.end();
|
|
|
|
if(config.apPin >= 0)
|
|
pinMode(config.apPin, INPUT_PULLUP);
|
|
|
|
return success;
|
|
}
|
|
|
|
bool AmsConfiguration::loadConfig80(int address) {
|
|
char* temp;
|
|
|
|
address += readString(address, &temp);
|
|
setWifiSsid(temp);
|
|
address += readString(address, &temp);
|
|
setWifiPassword(temp);
|
|
address += readString(address, &temp);
|
|
setWifiIp(temp);
|
|
address += readString(address, &temp);
|
|
setWifiGw(temp);
|
|
address += readString(address, &temp);
|
|
setWifiSubnet(temp);
|
|
|
|
bool mqtt = false;
|
|
address += readBool(address, &mqtt);
|
|
if(mqtt) {
|
|
address += readString(address, &temp);
|
|
setMqttHost(temp);
|
|
int port;
|
|
address += readInt(address, &port);
|
|
setMqttPort(port);
|
|
address += readString(address, &temp);
|
|
setMqttClientId(temp);
|
|
address += readString(address, &temp);
|
|
setMqttPublishTopic(temp);
|
|
address += readString(address, &temp);
|
|
setMqttSubscribeTopic(temp);
|
|
|
|
bool secure = false;
|
|
address += readBool(address, &secure);
|
|
if (secure)
|
|
{
|
|
address += readString(address, &temp);
|
|
setMqttUser(temp);
|
|
address += readString(address, &temp);
|
|
setMqttPassword(temp);
|
|
} else {
|
|
setMqttUser("");
|
|
setMqttPassword("");
|
|
}
|
|
} else {
|
|
clearMqtt();
|
|
}
|
|
setMqttPayloadFormat(0);
|
|
|
|
byte b;
|
|
address += readByte(address, &b);
|
|
setAuthSecurity(b);
|
|
if (b > 0) {
|
|
address += readString(address, &temp);
|
|
setAuthUser(temp);
|
|
address += readString(address, &temp);
|
|
setAuthPassword(temp);
|
|
} else {
|
|
clearAuth();
|
|
}
|
|
|
|
int i;
|
|
address += readInt(address, &i);
|
|
setMeterType(i);
|
|
address += readInt(address, &i);
|
|
setDistributionSystem(i);
|
|
address += readInt(address, &i);
|
|
setMainFuse(i);
|
|
address += readInt(address, &i);
|
|
setProductionCapacity(i);
|
|
|
|
ackWifiChange();
|
|
|
|
setDebugLevel(3); // 3=Info
|
|
setDebugTelnet(false);
|
|
setDebugSerial(false);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool AmsConfiguration::loadConfig81(int address) {
|
|
char* temp;
|
|
|
|
address += readString(address, &temp);
|
|
setWifiSsid(temp);
|
|
address += readString(address, &temp);
|
|
setWifiPassword(temp);
|
|
|
|
bool staticIp = false;
|
|
address += readBool(address, &staticIp);
|
|
if(staticIp) {
|
|
address += readString(address, &temp);
|
|
setWifiIp(temp);
|
|
address += readString(address, &temp);
|
|
setWifiGw(temp);
|
|
address += readString(address, &temp);
|
|
setWifiSubnet(temp);
|
|
address += readString(address, &temp);
|
|
setWifiDns1(temp);
|
|
address += readString(address, &temp);
|
|
setWifiDns2(temp);
|
|
}
|
|
address += readString(address, &temp);
|
|
setWifiHostname(temp);
|
|
bool mqtt = false;
|
|
address += readBool(address, &mqtt);
|
|
if(mqtt) {
|
|
address += readString(address, &temp);
|
|
setMqttHost(temp);
|
|
int port;
|
|
address += readInt(address, &port);
|
|
setMqttPort(port);
|
|
address += readString(address, &temp);
|
|
setMqttClientId(temp);
|
|
address += readString(address, &temp);
|
|
setMqttPublishTopic(temp);
|
|
address += readString(address, &temp);
|
|
setMqttSubscribeTopic(temp);
|
|
|
|
bool secure = false;
|
|
address += readBool(address, &secure);
|
|
if (secure)
|
|
{
|
|
address += readString(address, &temp);
|
|
setMqttUser(temp);
|
|
address += readString(address, &temp);
|
|
setMqttPassword(temp);
|
|
} else {
|
|
setMqttUser("");
|
|
setMqttPassword("");
|
|
}
|
|
int payloadFormat;
|
|
address += readInt(address, &payloadFormat);
|
|
setMqttPayloadFormat(payloadFormat);
|
|
} else {
|
|
clearMqtt();
|
|
}
|
|
|
|
byte b;
|
|
address += readByte(address, &b);
|
|
setAuthSecurity(b);
|
|
if (b > 0) {
|
|
address += readString(address, &temp);
|
|
setAuthUser(temp);
|
|
address += readString(address, &temp);
|
|
setAuthPassword(temp);
|
|
} else {
|
|
clearAuth();
|
|
}
|
|
|
|
int i;
|
|
address += readInt(address, &i);
|
|
setMeterType(i);
|
|
address += readInt(address, &i);
|
|
setDistributionSystem(i);
|
|
address += readInt(address, &i);
|
|
setMainFuse(i);
|
|
address += readInt(address, &i);
|
|
setProductionCapacity(i);
|
|
|
|
bool debugTelnet = false;
|
|
address += readBool(address, &debugTelnet);
|
|
setDebugTelnet(debugTelnet);
|
|
bool debugSerial = false;
|
|
address += readBool(address, &debugSerial);
|
|
setDebugSerial(debugSerial);
|
|
address += readInt(address, &i);
|
|
setDebugLevel(i);
|
|
|
|
ackWifiChange();
|
|
|
|
return true;
|
|
}
|
|
|
|
bool AmsConfiguration::save() {
|
|
int address = EEPROM_CONFIG_ADDRESS;
|
|
|
|
EEPROM.begin(EEPROM_SIZE);
|
|
EEPROM.put(address, EEPROM_CHECK_SUM);
|
|
address++;
|
|
EEPROM.put(address, config);
|
|
bool success = EEPROM.commit();
|
|
EEPROM.end();
|
|
|
|
configVersion = EEPROM_CHECK_SUM;
|
|
return success;
|
|
}
|
|
|
|
int AmsConfiguration::readString(int pAddress, char* pString[]) {
|
|
int address = 0;
|
|
byte length = EEPROM.read(pAddress + address);
|
|
address++;
|
|
|
|
char* buffer = new char[length];
|
|
for (int i = 0; i<length; i++)
|
|
{
|
|
buffer[i] = EEPROM.read(pAddress + address++);
|
|
}
|
|
*pString = buffer;
|
|
return address;
|
|
}
|
|
|
|
int AmsConfiguration::readInt(int address, int *value) {
|
|
int lower = EEPROM.read(address);
|
|
int higher = EEPROM.read(address + 1);
|
|
*value = lower + (higher << 8);
|
|
return 2;
|
|
}
|
|
|
|
int AmsConfiguration::readBool(int address, bool *value) {
|
|
byte y = EEPROM.read(address);
|
|
*value = (bool)y;
|
|
return 1;
|
|
}
|
|
|
|
int AmsConfiguration::readByte(int address, byte *value) {
|
|
*value = EEPROM.read(address);
|
|
return 1;
|
|
}
|
|
|
|
void AmsConfiguration::print(Print* debugger)
|
|
{
|
|
debugger->print("Configuration size: ");
|
|
debugger->println(sizeof(config));
|
|
debugger->println("-----------------------------------------------");
|
|
debugger->printf("WiFi SSID: '%s'\r\n", this->getWifiSsid());
|
|
debugger->printf("WiFi Psk: '%s'\r\n", this->getWifiPassword());
|
|
|
|
if(strlen(getWifiIp()) > 0) {
|
|
debugger->printf("IP: '%s'\r\n", this->getWifiIp());
|
|
debugger->printf("Gateway: '%s'\r\n", this->getWifiGw());
|
|
debugger->printf("Subnet: '%s'\r\n", this->getWifiSubnet());
|
|
debugger->printf("Primary DNS: '%s'\r\n", this->getWifiDns1());
|
|
debugger->printf("Secondary DNS: '%s'\r\n", this->getWifiDns2());
|
|
}
|
|
|
|
debugger->printf("WiFi Host: '%s'\r\n", this->getWifiHostname());
|
|
|
|
if(strlen(getMqttHost()) > 0) {
|
|
debugger->printf("mqttHost: '%s'\r\n", this->getMqttHost());
|
|
debugger->printf("mqttPort: %i\r\n", this->getMqttPort());
|
|
debugger->printf("mqttClientID: '%s'\r\n", this->getMqttClientId());
|
|
debugger->printf("mqttPublishTopic: '%s'\r\n", this->getMqttPublishTopic());
|
|
debugger->printf("mqttSubscribeTopic: '%s'\r\n", this->getMqttSubscribeTopic());
|
|
if (this->getMqttUser()) {
|
|
debugger->printf("SECURE MQTT CONNECTION:\r\n");
|
|
debugger->printf("mqttUser: '%s'\r\n", this->getMqttUser());
|
|
debugger->printf("mqttPass: '%s'\r\n", this->getMqttPassword());
|
|
}
|
|
debugger->printf("payload format: %i\r\n", this->getMqttPayloadFormat());
|
|
}
|
|
|
|
if (this->getAuthSecurity()) {
|
|
debugger->printf("WEB AUTH:\r\n");
|
|
debugger->printf("authSecurity: %i\r\n", this->getAuthSecurity());
|
|
debugger->printf("authUser: '%s'\r\n", this->getAuthUser());
|
|
debugger->printf("authPass: '%s'\r\n", this->getAuthPassword());
|
|
}
|
|
|
|
debugger->printf("meterType: %i\r\n", this->getMeterType());
|
|
debugger->printf("distSys: %i\r\n", this->getDistributionSystem());
|
|
debugger->printf("fuseSize: %i\r\n", this->getMainFuse());
|
|
debugger->printf("productionCapacity: %i\r\n", this->getProductionCapacity());
|
|
debugger->printf("Substitute missing: %s\r\n", this->isSubstituteMissing() ? "Yes" : "No");
|
|
|
|
debugger->printf("HAN pin: %i\r\n", this->getHanPin());
|
|
debugger->printf("LED pin: %i\r\n", this->getLedPin());
|
|
debugger->printf("LED inverted: %s\r\n", this->isLedInverted() ? "Yes" : "No");
|
|
debugger->printf("LED red pin: %i\r\n", this->getLedPinRed());
|
|
debugger->printf("LED green pin: %i\r\n", this->getLedPinGreen());
|
|
debugger->printf("LED blue pin: %i\r\n", this->getLedPinBlue());
|
|
debugger->printf("LED inverted: %s\r\n", this->isLedRgbInverted() ? "Yes" : "No");
|
|
debugger->printf("AP pin: %i\r\n", this->getApPin());
|
|
debugger->printf("Temperature pin: %i\r\n", this->getTempSensorPin());
|
|
|
|
debugger->printf("Vcc pin: %i\r\n", this->getVccPin());
|
|
debugger->printf("Vcc multiplier: %f\r\n", this->getVccMultiplier());
|
|
debugger->printf("Vcc boot limit: %f\r\n", this->getVccBootLimit());
|
|
|
|
//if(this->getDomoELIDX() > 0) {
|
|
debugger->printf("Domoticz ELIDX: %i\r\n", this->getDomoELIDX());
|
|
debugger->printf("Domoticz VL1IDX: %i\r\n", this->getDomoVL1IDX());
|
|
debugger->printf("Domoticz VL2IDX: %i\r\n", this->getDomoVL2IDX());
|
|
debugger->printf("Domoticz VL3IDX: %i\r\n", this->getDomoVL3IDX());
|
|
debugger->printf("Domoticz CL1IDX: %i\r\n", this->getDomoCL1IDX());
|
|
//}
|
|
|
|
debugger->println("-----------------------------------------------");
|
|
}
|