brunotic/DreherTankController
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity
DreherTankController/src/common.cpp

615 lines
25 KiB
C++
Raw Normal View History

codebase heavily refactored
2021-01-27 15:19:56 +01:00
#include "common.h"
#include <EEPROM.h>
extern Display display;
extern u32 currMillis;
extern u16 zones;
static void checkParamINT16(int16_t *source, int16_t *target, const int &std, const int &min, const int &max)
{
_printf("source: "); _print(*source);
if (*source == _SENSOR_FAULT) {
*source = *target = std;
} else if (*source > max) {
*source = *target = max;
} else if (*source < min) {
*source = *target = min;
} else if (*source == min || *source == max) {
*target = *source;
} else {
u8 mod = *source % 5;
_printf(", modulo: "); _print(mod);
if (mod == 0)
*target = *source;
else {
int tempVal = *source - mod;
_printf(", tempVal: "); _print(tempVal);
if (mod > 2) { // runde auf den nächsten 5er Schritt bzw. setze auf max
if ((tempVal + 5) > max) {
*source = *target = max;
_printf(" ... auf max setzen");
} else {
*source = *target = tempVal + 5;
_printf(" ... aufrunden");
}
} else { // runde auf den vorigen 5er Schritt bzw. setze auf min
if (tempVal < min) {
*source = *target = min;
_printf(" ... auf min setzen");
} else {
*source = *target = tempVal;
_printf(" ... abrunden");
}
}
}
}
_printf(", target: "); _print(*target); _printf(", source: "); _println(*source);
}
static void checkParamUINT8(u8 *source, u8 *target, const u8 &std)
{
_printf("checkParamUINT8 source vorher: "); _print(*source);
if (*source > 1) {
*source = *target = std;
} else {
*target = *source;
}
_printf(", target: "); _print(*target); _printf(", source: "); _println(*source);
}
#if _MODBUS == 1
#include "modbus/ModbusRTUSlave.h"
u8 modbusCoils[1]; // Bit0: tEn, 1: pInc, 2: pDec, 3: cEn, 4: akustisch, 5: optisch, 6: t-off-if-error, 7: p-off-if-error
u8 modbusValves[1]; // Bit0: Temp1, Bit1: Temp2, Bit2: Druck
// 0: Event-Counter, 1: high: modbusValves[0], low: modbusCoils[0], 2...4: Temp 1, 2, Druck, ab5: gespeicherte Schaltvorgänge
u16 modbusData[_REGS_INFRONTOF_EVENTS + _MODBUS_MAX_EVENTS];
u16 modbusMiscReadable[21]; // Version, Kühlzonen, Anzahl PowerOns, Konstanten
// Anzahl der gespeicherten Alarme + gespeicherte Alarme
u16 modbusAlarms[1 + (_MAX_FAULTS * 3)];
// Löschen von einzelnen/allen Alarmen
u16 modbusDelAlarms[2];
// modbusCoils[0], Temp1, 2, Druck jeweils Sollwert + Hysterese, T+Error, T-Error, P+-Error
u16 modbusHolding[10];
u16 modbusRefTime[1]; // setzt bei Änderung Event-Counter und -Timer zurück
u16 &eventCounter = modbusData[0];
u16 &refTime = modbusRefTime[0];
extern ModbusRTUSlave mb;
static void setBitInRegisters(u8 bitNr, u8 val)
{
_print("Setze Register "); _print(bitNr); _print(" auf "); _println(val);
bitWrite(modbusCoils[0], bitNr, val);
bitWrite(modbusData[1], bitNr, val);
bitWrite(modbusHolding[0], bitNr, val);
}
static void setBitInRegisters(u8 bitNr, u8 val, Parameters &p, FaultSettings &fs)
{
setBitInRegisters(bitNr, val);
switch(bitNr) {
case 0: // Temperaturregelung
p.tEn = val;
break;
case 1: // Drucksteigerung
p.pInc = val;
break;
case 2: // Druckabfall
p.pDec = val;
break;
case 3: // Regler aktiv
p.cEn = val;
break;
case 4: // akustisches Warnsignal
fs.acoustic = val;
break;
case 5: // optisches Warnsignal
fs.optical = val;
break;
case 6: // Temperaturregelung im Fehlerfall
fs.tOnIfError = val;
break;
case 7: // Druckregelung im Fehlerfall
fs.pOnIfError = val;
break;
}
}
void beginModbus()
{
mb.begin(modbusParams.address, modbusParams.baudrate);
mb.waitWithAnswerMicroS = modbusParams.delay * 100; // 1/10 ms -> us
}
void setupModbus(const u16 &powerOnCount)
{
bool modbusFail = false;
if (!mb.addDiscreteInputArea(0xD0, modbusValves, 1))
modbusFail = true;
if (!modbusFail && !mb.addHoldingRegisterArea(0xA0, modbusHolding, 10))
modbusFail = true;
if (!modbusFail && !mb.addCoilArea(0xB0, modbusCoils, 1))
modbusFail = true;
if (!modbusFail && !mb.addHoldingRegisterArea(0xC0, modbusRefTime, 1))
modbusFail = true;
if (!modbusFail && !mb.addInputRegisterArea(0x00, modbusData, _REGS_INFRONTOF_EVENTS + _MODBUS_MAX_EVENTS))
modbusFail = true;
if (!modbusFail && !mb.addInputRegisterArea(0x0100, modbusAlarms, 1 + (_MAX_FAULTS * 3)))
modbusFail = true;
if (!modbusFail && !mb.addHoldingRegisterArea(0x0200, modbusDelAlarms, 2))
modbusFail = true;
if (!modbusFail && !mb.addInputRegisterArea(0x0F00, modbusMiscReadable, 21))
modbusFail = true;
if (modbusFail) {
display.modbusProblem();
while(1);
}
modbusData[0] = 0; // EventCounter
modbusData[1] |= 0x8000; // setze das MSB. Das Bit wird durch setzen von modbusRefTime[0] zurückgesetzt
modbusData[2] = _SENSOR_FAULT; // Temp1 in 100stel-°C
modbusData[3] = _SENSOR_FAULT; // Temp2 in 100stel-°C, noch nicht implementiert
modbusData[4] = _SENSOR_FAULT; // Druck in 100stel bar
modbusData[5] = 0; // Zehntelsekunden seit Reglerstart / letzter Referenzierung
modbusAlarms[0] = 0; // Alarm-Counter
modbusDelAlarms[0] = 0; // Löschen eines Alarms anhand einer ID
modbusDelAlarms[1] = 0; // Alle inaktiven Alarme löschen
modbusMiscReadable[0] = _VERSION_NUMBER;
modbusMiscReadable[1] = zones;
modbusMiscReadable[2] = powerOnCount;
modbusMiscReadable[3] = _STD_T_EN;
bitWrite(modbusMiscReadable[3], 1, _STD_P_EN_INC);
bitWrite(modbusMiscReadable[3], 2, _STD_P_EN_DEC);
bitWrite(modbusMiscReadable[3], 3, _STD_C_EN);
bitWrite(modbusMiscReadable[3], 4, _STD_FAULTS_ACOUSTIC);
bitWrite(modbusMiscReadable[3], 5, _STD_FAULTS_OPTICAL);
bitWrite(modbusMiscReadable[3], 6, _STD_FAULTS_T_ON);
bitWrite(modbusMiscReadable[3], 7, _STD_FAULTS_P_ON);
modbusMiscReadable[4] = _STD_TEMP_SETPOINT;
modbusMiscReadable[5] = _STD_TEMP_HYSTERESIS;
modbusMiscReadable[6] = _STD_P_SETPOINT;
modbusMiscReadable[7] = _STD_P_HYSTERESIS;
modbusMiscReadable[8] = _STD_FAULTS_T_R_RATE;
modbusMiscReadable[9] = _STD_FAULTS_T_F_RATE;
modbusMiscReadable[10] = _STD_FAULTS_P_RATE;
modbusMiscReadable[11] = _MIN_TEMP_SETPOINT;
modbusMiscReadable[12] = _MAX_TEMP_SETPOINT;
modbusMiscReadable[13] = _MIN_TEMP_HYSTERESIS;
modbusMiscReadable[14] = _MAX_TEMP_HYSTERESIS;
modbusMiscReadable[15] = _MIN_P_SETPOINT;
modbusMiscReadable[16] = _MAX_P_SETPOINT;
modbusMiscReadable[17] = _MIN_P_HYSTERESIS;
modbusMiscReadable[18] = _MAX_P_HYSTERESIS;
modbusMiscReadable[19] = _MIN_FAULTS_RATE;
modbusMiscReadable[20] = _MAX_FAULTS_RATE;
modbusRefTime[0] = 0xFFFF;
beginModbus();
}
void modbusCallbackCoil(u16 reg, bool val)
{
Parameters p;
FaultSettings fs;
if ((reg >= 0xB0) && (reg <= 0xB7)) {
setBitInRegisters(reg - 0xB0, val, p, fs);
}
setParams(p, false);
setFaultSettings(fs, false);
}
u16 modbusCallbackRegister(u16 reg, u16 val)
{
Parameters p;
FaultSettings fs;
switch(reg) {
case 0xA0: // Bit 0...7: siehe Coils (Bit 0: 0xB0)
for (u8 i=0; i<8; i++) {
u8 bitVal = bitRead(val, i);
if (bitVal != bitRead(modbusHolding[0], i)) {
setBitInRegisters(i, bitVal, p, fs);
}
}
break;
case 0xA1: // Temperatur 1 Sollwert
checkParamINT16((int16_t*)&val, &p.ts1, _STD_TEMP_SETPOINT, _MIN_TEMP_SETPOINT, _MAX_TEMP_SETPOINT);
val = p.ts1;
break;
case 0xA2: // Temperatur 1 Hysterese
checkParamINT16((int16_t*)&val, &p.th1, _STD_TEMP_HYSTERESIS, _MIN_TEMP_HYSTERESIS, _MAX_TEMP_HYSTERESIS);
val = p.th1;
break;
case 0xA3: // Temperatur 2 Sollwert (noch nicht implementiert – Wert wird ignoriert)
case 0xA4: // Temperatur 2 Hysterese (noch nicht implementiert – Wert wird ignoriert)
break;
case 0xA5: // Druck Sollwert
checkParamINT16((int16_t*)&val, &p.ps, _STD_P_SETPOINT, _MIN_P_SETPOINT, _MAX_P_SETPOINT);
val = p.ps;
break;
case 0xA6: // Druck Hysterese
checkParamINT16((int16_t*)&val, &p.ph, _STD_P_HYSTERESIS, _MIN_P_HYSTERESIS, _MAX_P_HYSTERESIS);
val = p.ph;
break;
case 0xA7: // Temperatur-Steigerungsrate (Hundertstel-°C / 1 Stunde)
checkParamINT16((int16_t*)&val, &fs.tMinRRate, _STD_FAULTS_T_R_RATE, _MIN_FAULTS_RATE, _MAX_FAULTS_RATE);
val = fs.tMinRRate;
break;
case 0xA8: // Temperatur-Abfallrate (Hundertstel-°C / 1 Stunde)
checkParamINT16((int16_t*)&val, &fs.tMinFRate, _STD_FAULTS_T_F_RATE, _MIN_FAULTS_RATE, _MAX_FAULTS_RATE);
val = fs.tMinFRate;
break;
case 0xA9: // Druckrate (Steigerung und Abfall - Hundertstel-Bar / 10 Sekunden)
checkParamINT16((int16_t*)&val, &fs.pMinRate, _STD_FAULTS_P_RATE, _MIN_FAULTS_RATE, _MAX_FAULTS_RATE);
val = fs.pMinRate;
break;
}
setParams(p, false);
setFaultSettings(fs, false);
return val;
}
#endif // _MODBUS == 1
void getParams()
{
Parameters p;
EEPROM.get(_EEPROM_TEMP_SETPOINT, p.ts1);
EEPROM.get(_EEPROM_TEMP_HYSTERESIS, p.th1);
EEPROM.get(_EEPROM_P_SETPOINT, p.ps);
EEPROM.get(_EEPROM_P_HYSTERESIS, p.ph);
EEPROM.get(_EEPROM_P_EN_INC, p.pInc);
EEPROM.get(_EEPROM_P_EN_DEC, p.pDec);
EEPROM.get(_EEPROM_T_EN, p.tEn);
EEPROM.get(_EEPROM_CONTROL_EN, p.cEn);
_printlnf("getParams() vor Validierung:");
_printf(" Temperatur Sollwert: "); _println(p.ts1);
_printf(" Temperatur Hysterese: "); _println(p.th1);
_printf(" Druck Sollwert: "); _println(p.ps);
_printf(" Druck Hysterese: "); _println(p.ph);
_printf(" Temp-Regelung aktiv: "); _println(p.tEn);
_printf(" Drucksteigerung aktiv: "); _println(p.pInc);
_printf(" Druckabfall aktiv: "); _println(p.pDec);
_printf(" Regler aktiv: "); _println(p.cEn);
_printf("ts1 - UI -> Modbus - ");
checkParamINT16(&p.ts1, &params.ts1, _STD_TEMP_SETPOINT, _MIN_TEMP_SETPOINT, _MAX_TEMP_SETPOINT);
modbusHolding[1] = params.ts1;
_printf("th1 - UI -> Modbus - ");
checkParamINT16(&p.th1, &params.th1, _STD_TEMP_HYSTERESIS, _MIN_TEMP_HYSTERESIS, _MAX_TEMP_HYSTERESIS);
modbusHolding[2] = params.th1;
_printf("ps - UI -> Modbus - ");
checkParamINT16(&p.ps, &params.ps, _STD_P_SETPOINT, _MIN_P_SETPOINT, _MAX_P_SETPOINT);
modbusHolding[5] = params.ps;
_printf("ph - UI -> Modbus - ");
checkParamINT16(&p.ph, &params.ph, _STD_P_HYSTERESIS, _MIN_P_HYSTERESIS, _MAX_P_HYSTERESIS);
modbusHolding[6] = params.ph;
_printf("tEn - ");
checkParamUINT8(&p.tEn, &params.tEn, _STD_T_EN);
setBitInRegisters(0, params.tEn);
_printf("pInc - ");
checkParamUINT8(&p.pInc, &params.pInc, _STD_P_EN_INC);
setBitInRegisters(1, params.pInc);
_printf("pDec - ");
checkParamUINT8(&p.pDec, &params.pDec, _STD_P_EN_DEC);
setBitInRegisters(2, params.pDec);
_printf("cEn - ");
checkParamUINT8(&p.cEn, &params.cEn, _STD_C_EN);
setBitInRegisters(3, params.cEn);
_printlnf("getParams() nach Validierung:");
_printf(" Temperatur Sollwert: "); _println(params.ts1);
_printf(" Temperatur Hysterese: "); _println(params.th1);
_printf(" Druck Sollwert: "); _println(params.ps);
_printf(" Druck Hysterese: "); _println(params.ph);
_printf(" Temp-Regelung aktiv: "); _println(params.tEn);
_printf(" Drucksteigerung aktiv: "); _println(params.pInc);
_printf(" Druckabfall aktiv: "); _println(params.pDec);
_printf(" Regler aktiv: "); _println(params.cEn);
}
void setParams(Parameters &p, bool writeModbusRegister)
{
if (p.ts1 != _SENSOR_FAULT) {
_printf("ts1 alt: "); _print(params.ts1); _printf(", neu: "); _println(p.ts1);
checkParamINT16(&p.ts1, &params.ts1, _STD_TEMP_SETPOINT, _MIN_TEMP_SETPOINT, _MAX_TEMP_SETPOINT);
EEPROM.put(_EEPROM_TEMP_SETPOINT, params.ts1);
if (writeModbusRegister) modbusHolding[1] = params.ts1;
}
if (p.th1 != _SENSOR_FAULT) {
_printf("th1 alt: "); _print(params.th1); _printf(", neu: "); _println(p.th1);
checkParamINT16(&p.th1, &params.th1, _STD_TEMP_HYSTERESIS, _MIN_TEMP_HYSTERESIS, _MAX_TEMP_HYSTERESIS);
EEPROM.put(_EEPROM_TEMP_HYSTERESIS, params.th1);
if (writeModbusRegister) modbusHolding[2] = params.th1;
}
if (p.ps != _SENSOR_FAULT) {
_printf("ps alt: "); _print(params.ps); _printf(", neu: "); _println(p.ps);
checkParamINT16(&p.ps, &params.ps, _STD_P_SETPOINT, _MIN_P_SETPOINT, _MAX_P_SETPOINT);
EEPROM.put(_EEPROM_P_SETPOINT, params.ps);
if (writeModbusRegister) modbusHolding[5] = params.ps;
}
if (p.ph != _SENSOR_FAULT) {
_printf("ph alt: "); _print(params.ph); _printf(", neu: "); _println(p.ph);
checkParamINT16(&p.ph, &params.ph, _STD_P_HYSTERESIS, _MIN_P_HYSTERESIS, _MAX_P_HYSTERESIS);
EEPROM.put(_EEPROM_P_HYSTERESIS, params.ph);
if (writeModbusRegister) modbusHolding[6] = params.ph;
}
if (p.pInc < 2) {
_printf("pInc alt: "); _print(params.pInc); _printf(", neu: "); _println(p.pInc);
params.pInc = p.pInc;
EEPROM.put(_EEPROM_P_EN_INC, params.pInc);
if (writeModbusRegister) setBitInRegisters(1, params.pInc);
}
if (p.pDec < 2) {
_printf("pDec alt: "); _print(params.pDec); _printf(", neu: "); _println(p.pDec);
params.pDec = p.pDec;
EEPROM.put(_EEPROM_P_EN_DEC, params.pDec);
if (writeModbusRegister) setBitInRegisters(2, params.pDec);
}
if (p.tEn < 2) {
_printf("tEn alt: "); _print(params.tEn); _printf(", neu: "); _println(p.tEn);
params.tEn = p.tEn;
EEPROM.put(_EEPROM_T_EN, params.tEn);
if (writeModbusRegister) setBitInRegisters(0, params.tEn);
}
if (p.cEn < 2) {
_printf("cEn alt: "); _print(params.cEn); _printf(", neu: "); _println(p.cEn);
params.cEn = p.cEn;
EEPROM.put(_EEPROM_CONTROL_EN, params.cEn);
if (writeModbusRegister) setBitInRegisters(3, params.cEn);
}
}
void getModbusParams()
{
uint8_t addr = EEPROM.read(_EEPROM_MODBUS_ADDRESS);
if (addr < _MODBUS_ADDR_MIN || addr > _MODBUS_ADDR_MAX)
modbusParams.address = _MODBUS_ADDR_MIN;
else
modbusParams.address = addr;
uint32_t baudrate;
EEPROM.get(_EEPROM_MODBUS_BAUDRATE, baudrate);
switch (baudrate) {
case 115200: break;
case 57600: break;
case 38400: break;
case 19200: break;
case 9600: break;
case 4800: break;
case 2400: break;
case 1200: break;
case 300: break;
default: baudrate = 9600;
}
modbusParams.baudrate = baudrate;
uint8_t delay_ = EEPROM.read(_EEPROM_MODBUS_DELAY);
if (delay_ < _MODBUS_DELAY_MIN)
modbusParams.delay = _MODBUS_DELAY_MIN;
else if (delay_ > _MODBUS_DELAY_MAX)
modbusParams.delay = _MODBUS_DELAY_MAX;
else
modbusParams.delay = delay_;
}
void setModbusParams(const ModbusParameters &p)
{
bool changed = false;
if (p.address <= _MODBUS_ADDR_MAX) {
EEPROM.put(_EEPROM_MODBUS_ADDRESS, p.address);
modbusParams.address = p.address;
changed = true;
}
if (p.baudrate != _MODBUS_INVALID_BAUDRATE) {
EEPROM.put(_EEPROM_MODBUS_BAUDRATE, p.baudrate);
modbusParams.baudrate = p.baudrate;
changed = true;
}
if (p.delay <= _MODBUS_DELAY_MAX) {
EEPROM.put(_EEPROM_MODBUS_DELAY, p.delay);
modbusParams.delay = p.delay;
changed = true;
}
if (changed) {
#if _MODBUS == 1
beginModbus();
#endif
}
}
void getPSensor()
{
uint8_t val;
EEPROM.get(_EEPROM_P_SENSOR, val);
switch (val) {
case SMC_1_5V_0_5BAR:
pSensor = SMC_1_5V_0_5BAR;
break;
case GEMS_0_5V_0_6BAR:
pSensor = GEMS_0_5V_0_6BAR;
break;
default:
pSensor = SMC_1_5V_0_5BAR;
EEPROM.put(_EEPROM_P_SENSOR, pSensor);
}
return pSensor;
}
void setPSensor(const PSensor &sensor)
{
EEPROM.put(_EEPROM_P_SENSOR, sensor);
pSensor = sensor;
}
void getFaultSettings()
{
FaultSettings settings;
EEPROM.get(_EEPROM_FAULTS_ACOUSTIC, settings.acoustic);
EEPROM.get(_EEPROM_FAULTS_OPTICAL, settings.optical);
EEPROM.get(_EEPROM_FAULTS_T_ON, settings.tOnIfError);
EEPROM.get(_EEPROM_FAULTS_P_ON, settings.pOnIfError);
EEPROM.get(_EEPROM_FAULTS_T_R_RATE, settings.tMinRRate);
EEPROM.get(_EEPROM_FAULTS_T_F_RATE, settings.tMinFRate);
EEPROM.get(_EEPROM_FAULTS_P_RATE, settings.pMinRate);
_printlnf("getFaultSettings() vor Validierung:");
_printf(" akustisches Signal: "); _println(settings.acoustic);
_printf(" optisches Signal : "); _println(settings.optical);
_printf(" t on if error : "); _println(settings.tOnIfError);
_printf(" p on if error : "); _println(settings.pOnIfError);
_printf(" t min rise rate : "); _println(settings.tMinRRate);
_printf(" t min fall rate : "); _println(settings.tMinFRate);
_printf(" p min r/f rate : "); _println(settings.pMinRate);
if (settings.acoustic < 2) {
faultSettings.acoustic = settings.acoustic;
} else {
faultSettings.acoustic = _STD_FAULTS_ACOUSTIC;
}
setBitInRegisters(4, faultSettings.acoustic);
if (settings.optical < 2) {
faultSettings.optical = settings.optical;
} else {
faultSettings.optical = _STD_FAULTS_OPTICAL;
}
setBitInRegisters(5, faultSettings.optical);
if (settings.tOnIfError < 2) {
faultSettings.tOnIfError = settings.tOnIfError;
} else {
faultSettings.tOnIfError = _STD_FAULTS_T_ON;
}
setBitInRegisters(6, faultSettings.tOnIfError);
if (settings.pOnIfError < 2) {
faultSettings.pOnIfError = settings.pOnIfError;
} else {
faultSettings.pOnIfError = _STD_FAULTS_P_ON;
}
setBitInRegisters(7, faultSettings.pOnIfError);
if (settings.tMinRRate == 0x8000) {
faultSettings.tMinRRate = _STD_FAULTS_T_R_RATE;
} else if (settings.tMinRRate < _MIN_FAULTS_RATE) {
faultSettings.tMinRRate = _MIN_FAULTS_RATE;
} else if (settings.tMinRRate > _MAX_FAULTS_RATE) {
faultSettings.tMinRRate = _MAX_FAULTS_RATE;
} else {
faultSettings.tMinRRate = settings.tMinRRate;
}
modbusHolding[7] = faultSettings.tMinRRate;
if (settings.tMinFRate == 0x8000) {
faultSettings.tMinFRate = _STD_FAULTS_T_F_RATE;
} else if (settings.tMinFRate < _MIN_FAULTS_RATE) {
faultSettings.tMinFRate = _MIN_FAULTS_RATE;
} else if (settings.tMinFRate > _MAX_FAULTS_RATE) {
faultSettings.tMinFRate = _MAX_FAULTS_RATE;
} else {
faultSettings.tMinFRate = settings.tMinFRate;
}
modbusHolding[8] = faultSettings.tMinFRate;
if (settings.pMinRate == 0x8000) {
faultSettings.pMinRate = _STD_FAULTS_P_RATE;
} else if (settings.pMinRate < _MIN_FAULTS_RATE) {
faultSettings.pMinRate = _MIN_FAULTS_RATE;
} else if (settings.pMinRate > _MAX_FAULTS_RATE) {
faultSettings.pMinRate = _MAX_FAULTS_RATE;
} else {
faultSettings.pMinRate = settings.pMinRate;
}
modbusHolding[9] = faultSettings.pMinRate;
_printlnf("getFaultSettings() nach Validierung:");
_printf(" akustisches Signal: "); _println(faultSettings.acoustic);
_printf(" optisches Signal : "); _println(faultSettings.optical);
_printf(" t on if error : "); _println(faultSettings.tOnIfError);
_printf(" p on if error : "); _println(faultSettings.pOnIfError);
_printf(" t min rise rate : "); _println(faultSettings.tMinRRate);
_printf(" t min fall rate : "); _println(faultSettings.tMinFRate);
_printf(" p min r/f rate : "); _println(faultSettings.pMinRate);
}
void setFaultSettings(const FaultSettings &settings, bool writeModbusRegister)
{
if (settings.acoustic < 2 && settings.acoustic != faultSettings.acoustic) {
_printf("faultSettings.acoustic alt: "); _print(faultSettings.acoustic);
_printf(", neu: "); _println(settings.acoustic);
faultSettings.acoustic = settings.acoustic;
EEPROM.put(_EEPROM_FAULTS_ACOUSTIC, settings.acoustic);
if (writeModbusRegister) setBitInRegisters(4, settings.acoustic);
}
if (settings.optical < 2 && settings.optical != faultSettings.optical) {
_printf("faultSettings.optical alt: "); _print(faultSettings.optical);
_printf(", neu: "); _println(settings.optical);
faultSettings.optical = settings.optical;
EEPROM.put(_EEPROM_FAULTS_OPTICAL, settings.optical);
if (writeModbusRegister) setBitInRegisters(5, settings.optical);
}
if (settings.tOnIfError < 2 && settings.tOnIfError != faultSettings.tOnIfError) {
_printf("faultSettings.tOnIfError alt: "); _print(faultSettings.tOnIfError);
_printf(", neu: "); _println(settings.tOnIfError);
faultSettings.tOnIfError = settings.tOnIfError;
EEPROM.put(_EEPROM_FAULTS_T_ON, settings.tOnIfError);
if (writeModbusRegister) setBitInRegisters(6, settings.tOnIfError);
}
if (settings.pOnIfError < 2 && settings.pOnIfError != faultSettings.pOnIfError) {
_printf("faultSettings.pOnIfError alt: "); _print(faultSettings.pOnIfError);
_printf(", neu: "); _println(settings.pOnIfError);
faultSettings.pOnIfError = settings.pOnIfError;
EEPROM.put(_EEPROM_FAULTS_P_ON, settings.pOnIfError);
if (writeModbusRegister) setBitInRegisters(7, settings.pOnIfError);
}
if (settings.tMinRRate != 0x8000 && settings.tMinRRate != faultSettings.tMinRRate) {
if (settings.tMinRRate < _MIN_FAULTS_RATE) {
faultSettings.tMinRRate == _MIN_FAULTS_RATE;
EEPROM.put(_EEPROM_FAULTS_T_R_RATE, _MIN_FAULTS_RATE);
} else if (settings.tMinRRate > _MAX_FAULTS_RATE) {
faultSettings.tMinRRate == _MAX_FAULTS_RATE;
EEPROM.put(_EEPROM_FAULTS_T_R_RATE, _MAX_FAULTS_RATE);
} else {
faultSettings.tMinRRate == settings.tMinRRate;
EEPROM.put(_EEPROM_FAULTS_T_R_RATE, settings.tMinRRate);
}
if (writeModbusRegister) modbusHolding[7] = settings.tMinRRate;
_printf("faultSettings.tMinRRate alt: "); _print(faultSettings.tMinRRate);
_printf(", neu: "); _println(settings.tMinRRate);
}
if (settings.tMinFRate != 0x8000 && settings.tMinFRate != faultSettings.tMinFRate) {
if (settings.tMinFRate < _MIN_FAULTS_RATE) {
faultSettings.tMinFRate == _MIN_FAULTS_RATE;
EEPROM.put(_EEPROM_FAULTS_T_F_RATE, _MIN_FAULTS_RATE);
} else if (settings.tMinFRate > _MAX_FAULTS_RATE) {
faultSettings.tMinFRate == _MAX_FAULTS_RATE;
EEPROM.put(_EEPROM_FAULTS_T_F_RATE, _MAX_FAULTS_RATE);
} else {
faultSettings.tMinFRate == settings.tMinFRate;
EEPROM.put(_EEPROM_FAULTS_T_F_RATE, settings.tMinFRate);
}
if (writeModbusRegister) modbusHolding[8] = settings.tMinFRate;
_printf("faultSettings.tMinFRate alt: "); _print(faultSettings.tMinFRate);
_printf(", neu: "); _println(settings.tMinFRate);
}
if (settings.pMinRate != 0x8000 && settings.pMinRate != faultSettings.pMinRate) {
if (settings.pMinRate < _MIN_FAULTS_RATE) {
faultSettings.pMinRate == _MIN_FAULTS_RATE;
EEPROM.put(_EEPROM_FAULTS_P_RATE, _MIN_FAULTS_RATE);
} else if (settings.pMinRate > _MAX_FAULTS_RATE) {
faultSettings.pMinRate == _MAX_FAULTS_RATE;
EEPROM.put(_EEPROM_FAULTS_P_RATE, _MAX_FAULTS_RATE);
} else {
faultSettings.pMinRate == settings.pMinRate;
EEPROM.put(_EEPROM_FAULTS_P_RATE, settings.pMinRate);
}
if (writeModbusRegister) modbusHolding[9] = settings.pMinRate;
_printf("faultSettings.pMinRate alt: "); _print(faultSettings.pMinRate);
_printf(", neu: "); _println(settings.pMinRate);
}
}
bool readPwrBtn()
{
const uint8_t debounceDelay = 20;
static unsigned long lastDebounceTime;
static bool lastBounceState;
static bool steadyState;
bool currentState = !digitalRead(BTN_PWR);
if (currentState != lastBounceState) {
lastDebounceTime = currMillis;
lastBounceState = currentState;
}
if ((currMillis - lastDebounceTime) > debounceDelay)
steadyState = currentState;
if (steadyState && (currMillis - lastDebounceTime) > 3000)
display.reset();
return steadyState;
}
Reference in a new issue Copy permalink