brunotic
/
DreherTankController
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
DreherTankController/DreherTankController.ino

516 lines
17 KiB
C++
Raw Blame History

#ifndef ARDUINO_AVR_MEGA2560
#error This program was written for an Arduino Mega (Atmega2560)
#endif
#include <EEPROM.h>
#include "src/OneWire/OneWire.h"
#include "src/DallasTemperature/DallasTemperature.h"
#include "src/display/display.h"
#include "src/controller/controller.h"
const uint8_t BTN_PWR = 7;
modbusParameters modbusParams;
parameters params; // Prozessparameter
values vals; // aktuelle Messwerte
PSensor pSensor; // verwendeter Drucksensor
valveStates vStates; // Zustände der Ausgänge
bool paramsChangedByUI; // true, außer ein Wert wurde über Modbus geändert
bool timeStampOverflow = false; // true, wenn mehr als 0xFFF Zehntelsekunden vergangen sind
unsigned long timeStamp;
u16 lastRefTime = 0xFFFF;
void checkParamINT16(int16_t *source, int16_t *target, const int &std, const int &min, const int &max) {
_print("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;
_print(", modulo: "); _print(mod);
if (mod == 0)
*target = *source;
else {
int tempVal = *source - mod;
_print(", tempVal: "); _print(tempVal);
if (mod > 2) { // runde auf den nächsten 5er Schritt bzw. setze auf max
if ((tempVal + 5) > max) {
*source = *target = max;
_print(" ... auf max setzen");
} else {
*source = *target = tempVal + 5;
_print(" ... aufrunden");
}
} else { // runde auf den vorigen 5er Schritt bzw. setze auf min
if (tempVal < min) {
*source = *target = min;
_print(" ... auf min setzen");
} else {
*source = *target = tempVal;
_print(" ... abrunden");
}
}
}
}
_print(", target: "); _print(*target); _print(", source: "); _println(*source);
}
void checkParamUINT8(u8 *source, u8 *target, const u8 &std) {
_print("checkParamUINT8 source vorher: "); _print(*source);
if (*source > 1) {
*source = *target = std;
} else {
*target = *source;
}
_print(", target: "); _print(*target); _print(", source: "); _println(*source);
}
#if _MODBUS == 1
#include "src/modbus/ModbusRTUSlave.h"
u8 modbusStates[1]; // Bit0: tEn, Bit1: pInc, Bit2: pDec, Bit3: cEn
u8 modbusValves[1]; // Bit0: Temp1, Bit1: Temp2, Bit2: Druck
// 0: Event-Counter, 1: high: modbusValves[0], low: modbusStates[0], 2...4: Temp 1, 2, Druck, ab5: gespeicherte Schaltvorgänge
u16 modbusData[_REGS_INFRONTOF_EVENTS + _MODBUS_MAX_EVENTS]; // Main Input Registers
u16 modbusMiscReadable[2]; // Version, Kühlzonen
u16 modbusSetpoints[6]; // Temp1, 2, Druck jeweils Sollwert + Hysterese
u16 modbusRefTime[1]; // setzt bei Änderung Event-Counter und -Timer zurück
u8 &states = modbusStates[0];
u8 &valves = modbusValves[0];
u16 &eventCounter = modbusData[0];
u16 &refTime = modbusRefTime[0];
ModbusRTUSlave mb(&Serial1, 2);
void checkParamBool(u8 &p, const u8 &bitNr, u8 *p2=nullptr) {
u8 *p_ = (p2) ? p2 : &p;
if (paramsChangedByUI) {
_print("UI -> Modbus - vorher: "); _print(bitRead(modbusStates[0], bitNr));
bitWrite(modbusStates[0], bitNr, *p_);
_print(", nachher: "); _println(bitRead(modbusStates[0], bitNr));
} else {
_print("Modbus -> UI - vorher: "); _print(*p_);
p = bitRead(modbusStates[0], bitNr);
_print(", nachher: "); _println(p);
}
bitWrite(modbusData[1], bitNr, bitRead(modbusStates[0], bitNr));
}
void checkModbusParams() {
parameters p;
if (modbusSetpoints[0] != params.ts1) {
if (paramsChangedByUI) {
_print("ts1 - UI -> Modbus - ");
checkParamINT16(&params.ts1, (int16_t*)&modbusSetpoints[0], _STD_TEMP_SETPOINT, _MIN_TEMP_SETPOINT, _MAX_TEMP_SETPOINT);
} else {
_print("ts1 - Modbus -> UI - ");
checkParamINT16((int16_t*)&modbusSetpoints[0], &params.ts1, _STD_TEMP_SETPOINT, _MIN_TEMP_SETPOINT, _MAX_TEMP_SETPOINT);
p.ts1 = params.ts1;
}
}
if (modbusSetpoints[1] != params.th1) {
if (paramsChangedByUI) {
_print("th1 - UI -> Modbus - ");
checkParamINT16(&params.th1, (int16_t*)&modbusSetpoints[1], _STD_TEMP_HYSTERESIS, _MIN_TEMP_HYSTERESIS, _MAX_TEMP_HYSTERESIS);
} else {
_print("th1 - Modbus -> UI - ");
checkParamINT16((int16_t*)&modbusSetpoints[1], &params.th1, _STD_TEMP_HYSTERESIS, _MIN_TEMP_HYSTERESIS, _MAX_TEMP_HYSTERESIS);
p.th1 = params.th1;
}
}
if (modbusSetpoints[4] != params.ps) {
if (paramsChangedByUI) {
_print("ps - UI -> Modbus - ");
checkParamINT16(&params.ps, (int16_t*)&modbusSetpoints[4], _STD_P_SETPOINT, _MIN_P_SETPOINT, _MAX_P_SETPOINT);
} else {
_print("ps - Modbus -> UI - ");
checkParamINT16((int16_t*)&modbusSetpoints[4], &params.ps, _STD_P_SETPOINT, _MIN_P_SETPOINT, _MAX_P_SETPOINT);
p.ps = params.ps;
}
}
if (modbusSetpoints[5] != params.ph) {
if (paramsChangedByUI) {
_print("ph - UI -> Modbus - ");
checkParamINT16(&params.ph, (int16_t*)&modbusSetpoints[5], _STD_P_HYSTERESIS, _MIN_P_HYSTERESIS, _MAX_P_HYSTERESIS);
} else {
_print("ph - Modbus -> UI - ");
checkParamINT16((int16_t*)&modbusSetpoints[5], &params.ph, _STD_P_HYSTERESIS, _MIN_P_HYSTERESIS, _MAX_P_HYSTERESIS);
p.ph = params.ph;
}
}
u8 bitNr = 0;
if (bitRead(modbusStates[0], bitNr) != params.tEn) {
_print("tEn - ");
checkParamBool(p.tEn, bitNr, &params.tEn);
}
bitNr++;
if (bitRead(modbusStates[0], bitNr) != params.pInc) {
_print("pInc - ");
checkParamBool(p.pInc, bitNr, &params.pInc);
}
bitNr++;
if (bitRead(modbusStates[0], bitNr) != params.pDec) {
_print("pDec - ");
checkParamBool(p.pDec, bitNr, &params.pDec);
}
bitNr++;
if (bitRead(modbusStates[0], bitNr) != params.cEn) {
_print("cEn - ");
checkParamBool(p.cEn, bitNr, &params.cEn);
}
if (!paramsChangedByUI) {
setParams(p);
}
paramsChangedByUI = false;
}
#endif // _MODBUS ==
// EEPROM Adressen:
#define _EEPROM_OFFSET 0 // Falls sich die Register nicht mehr beschreiben lassen
#define _EEPROM_MODBUS_ADDRESS 0 + _EEPROM_OFFSET // 1 byte
#define _EEPROM_MODBUS_BAUDRATE 1 + _EEPROM_OFFSET // 4 bytes
#define _EEPROM_MODBUS_DELAY 5 + _EEPROM_OFFSET // 1 byte
#define _EEPROM_TEMP_SETPOINT 6 + _EEPROM_OFFSET // 4 bytes
#define _EEPROM_TEMP_HYSTERESIS 10 + _EEPROM_OFFSET // 4 bytes
#define _EEPROM_P_SETPOINT 14 + _EEPROM_OFFSET // 4 bytes
#define _EEPROM_P_HYSTERESIS 18 + _EEPROM_OFFSET // 4 bytes
#define _EEPROM_P_EN_INC 22 + _EEPROM_OFFSET // 1 byte
#define _EEPROM_P_EN_DEC 23 + _EEPROM_OFFSET // 1 byte
#define _EEPROM_P_SENSOR 24 + _EEPROM_OFFSET // 1 byte
#define _EEPROM_BG_LIGHT 25 + _EEPROM_OFFSET // 1 byte
#define _EEPROM_T_EN 26 + _EEPROM_OFFSET // 1 byte
#define _EEPROM_CONTROL_EN 27 + _EEPROM_OFFSET // 1 byte
// cs, btnNext, btnPrev, btnSelect, btnCancel, bgLed, Parameter, Messwerte, Modbus, Drucksensor
Display d(10, 3, 4, 5, 6, 9, &params, &vals, &modbusParams, &pSensor, &vStates);
// Analogeingang Druck, OneWire-Pin, Parameter, Messwerte, Display, Drucksensor, Ausgangszustände
// nach vStates: t1Pin, t2Pin, pRisePin, pFallPin
Controller c(A0, 8, &params, &vals, &d, &pSensor, &vStates, 55, 56, 57, 58);
#if _MODBUS == 1
void beginModbus() {
mb.begin(modbusParams.address, modbusParams.baudrate);
mb.waitWithAnswerMicroS = modbusParams.delay * 100; // 1/10 ms -> us
}
#endif
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);
_println("getParams() vor Validierung:");
_print(" Temperatur Sollwert: "); _println(p.ts1);
_print(" Temperatur Hysterese: "); _println(p.th1);
_print(" Druck Sollwert: "); _println(p.ps);
_print(" Druck Hysterese: "); _println(p.ph);
_print(" Temp-Regelung aktiv: "); _println(p.tEn);
_print(" Drucksteigerung aktiv: "); _println(p.pInc);
_print(" Druckabfall aktiv: "); _println(p.pDec);
_print(" Regler aktiv: "); _println(p.cEn);
_print("ts1 - UI -> Modbus - ");
checkParamINT16(&p.ts1, &params.ts1, _STD_TEMP_SETPOINT, _MIN_TEMP_SETPOINT, _MAX_TEMP_SETPOINT);
_print("th1 - UI -> Modbus - ");
checkParamINT16(&p.th1, &params.th1, _STD_TEMP_HYSTERESIS, _MIN_TEMP_HYSTERESIS, _MAX_TEMP_HYSTERESIS);
_print("ps - UI -> Modbus - ");
checkParamINT16(&p.ps, &params.ps, _STD_P_SETPOINT, _MIN_P_SETPOINT, _MAX_P_SETPOINT);
_print("ph - UI -> Modbus - ");
checkParamINT16(&p.ph, &params.ph, _STD_P_HYSTERESIS, _MIN_P_HYSTERESIS, _MAX_P_HYSTERESIS);
_print("tEn - ");
checkParamUINT8(&p.tEn, &params.tEn, _STD_T_EN);
_print("pInc - ");
checkParamUINT8(&p.pInc, &params.pInc, _STD_P_EN_INC);
_print("pDec - ");
checkParamUINT8(&p.pDec, &params.pDec, _STD_P_EN_DEC);
_print("cEn - ");
checkParamUINT8(&p.cEn, &params.cEn, _STD_C_EN);
_println("getParams() nach Validierung:");
_print(" Temperatur Sollwert: "); _println(params.ts1);
_print(" Temperatur Hysterese: "); _println(params.th1);
_print(" Druck Sollwert: "); _println(params.ps);
_print(" Druck Hysterese: "); _println(params.ph);
_print(" Temp-Regelung aktiv: "); _println(params.tEn);
_print(" Drucksteigerung aktiv: "); _println(params.pInc);
_print(" Druckabfall aktiv: "); _println(params.pDec);
_print(" Regler aktiv: "); _println(params.cEn);
}
void setParams(parameters &p) {
if (p.ts1 != _SENSOR_FAULT) {
_print("ts1 alt: "); _print(params.ts1); _print(", 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 (p.th1 != _SENSOR_FAULT) {
_print("th1 alt: "); _print(params.th1); _print(", 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 (p.ps != _SENSOR_FAULT) {
_print("ps alt: "); _print(params.ps); _print(", 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 (p.ph != _SENSOR_FAULT) {
_print("ph alt: "); _print(params.ph); _print(", 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 (p.pInc < 2) {
_print("pInc alt: "); _print(params.pInc); _print(", neu: "); _println(p.pInc);
params.pInc = p.pInc;
EEPROM.put(_EEPROM_P_EN_INC, params.pInc);
}
if (p.pDec < 2) {
_print("pDec alt: "); _print(params.pDec); _print(", neu: "); _println(p.pDec);
params.pDec = p.pDec;
EEPROM.put(_EEPROM_P_EN_DEC, params.pDec);
}
if (p.tEn < 2) {
_print("tEn alt: "); _print(params.tEn); _print(", neu: "); _println(p.tEn);
params.tEn = p.tEn;
EEPROM.put(_EEPROM_T_EN, params.tEn);
}
if (p.cEn < 2) {
_print("cEn alt: "); _print(params.cEn); _print(", neu: "); _println(p.cEn);
params.cEn = p.cEn;
EEPROM.put(_EEPROM_CONTROL_EN, params.cEn);
}
paramsChangedByUI = true;
}
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
}
}
PSensor 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 setup() {
#if _DEBUG == 1
Serial.begin(115200);
#endif
pinMode(53, OUTPUT); // Mega CS-Pin (um Slave-Betrieb zu vermeiden)
paramsChangedByUI = true;
d.init();
d.bgLight(true);
d.setModbusParams = setModbusParams;
d.setPSensor = setPSensor;
d.setParams = setParams;
getModbusParams();
_print("ModbusAddress: ");
_println(modbusParams.address);
_print("ModbusBaudrate: ");
_println(modbusParams.baudrate);
getPSensor();
getParams();
pinMode(BTN_PWR, INPUT_PULLUP);
#if _MODBUS == 1
bool modbusFail = false;
if (!mb.addDiscreteInputArea(0xD0, modbusValves, 1))
modbusFail = true;
if (!modbusFail && !mb.addHoldingRegisterArea(0xA0, modbusSetpoints, 6))
modbusFail = true;
if (!modbusFail && !mb.addCoilArea(0xB0, modbusStates, 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(0xF0, modbusMiscReadable, 2))
modbusFail = true;
if (modbusFail) {
d.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
modbusMiscReadable[0] = _VERSION_NUMBER;
modbusMiscReadable[1] = 1; // Aktuell ist nur eine Kühlzone implementiert
modbusRefTime[0] = 0xFFFF;
beginModbus();
#endif
d.greeting();
delay(1000);
c.init(true);
if (params.cEn)
d.bgLight(true);
else
d.bgLight(100);
timeStamp = millis();
}
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 = millis();
lastBounceState = currentState;
}
if ((millis() - lastDebounceTime) > debounceDelay)
steadyState = currentState;
if (steadyState && (millis() - lastDebounceTime) > 3000)
d.reset();
return steadyState;
}
void loop() {
static bool pwrBtnPressed;
bool currentPwrBtnState = readPwrBtn();
if (!pwrBtnPressed && currentPwrBtnState) {
_println("pwrButton pressed");
pwrBtnPressed = true;
} else if(pwrBtnPressed && !currentPwrBtnState) {
_println("pwrButton released");
pwrBtnPressed = false;
parameters p;
p.cEn = !params.cEn;
if (p.cEn)
d.bgLight(true);
else
d.bgLight(100);
setParams(p);
}
c.process();
d.process();
#if _MODBUS == 1
mb.process();
checkModbusParams();
if (refTime != lastRefTime) {
lastRefTime = refTime;
timeStamp = millis();
modbusData[5] = 0;
eventCounter = 0;
timeStampOverflow = false;
// Setze das 'Timer-Überlauf'-Bit zurück (falls es gesetzt war)
bitClear(modbusData[1], 14);
// Nachden die 'ReferenzZeit' erstmalig gesetzt wurde, wird dieses Bit gelöscht
bitClear(modbusData[1], 15);
// Setze die Durchschnittswerte für die Messwerte zurück
c.resetAverageCounters();
_println("Der 12 Bit Timer wurde zurückgesetzt");
}
if (!timeStampOverflow && (millis() - timeStamp) / 100 > 0xFFF) {
#if _DEBUG == 1
u16 passed = (millis() - timeStamp) / 100;
_print("Der 12 Bit Timer ist übergelaufen. Vergangene Sekunden: ");
_print(passed / 10); _print("."); _println(passed % 10);
#endif // _DEBUG ==
timeStampOverflow = true;
bitSet(modbusData[1], 14);
}
modbusData[5] = (millis() - timeStamp) / 100;
#endif // _MODBUS ==
#if 1
static unsigned long counter = 0;
static unsigned long tl = millis();
if (millis() - tl > 1000) {
tl = millis();
_print("Loops / Sekunde: "); _println(counter);
counter = 0;
} else {
counter++;
}
#endif
}
Reference in New Issue View Git Blame Copy Permalink