DreherTankController/DreherTankController.ino

#ifndef ARDUINO_AVR_MEGA2560
#error This program was written for an Arduino Mega (Atmega2560)
#endif

#include "src/common.h"
#include "src/modbus/ModbusRTUSlave.h"
#include <EEPROM.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 timeStampOverflow = false; // true, wenn mehr als 0xFFF Zehntelsekunden vergangen sind
unsigned long timeStamp;
u16 lastRefTime = 0xFFFF;
u16 zones = 1; // Aktuell ist nur eine Kühlzone implementiert
u32 currMillis;

#if _MODBUS == 1
ModbusRTUSlave mb(&Serial1, 2);
#endif

// cs, btnNext, btnPrev, btnSelect, btnCancel, bgLed
Display display(10, 3, 4, 5, 6, 9);
// Analogeingang Druck, OneWire-Pin, t1Pin, t2Pin, pRisePin, pFallPin
Controller controller(A0, 8, 55, 56, 57, 58);

void setup()
{
#if _DEBUG == 1
    Serial.begin(115200);
#endif

    pinMode(BTN_PWR, INPUT_PULLUP);
    pinMode(53, OUTPUT); // Mega CS-Pin (um Slave-Betrieb zu vermeiden)

    display.init();
    display.bgLight(true);

    getModbusParams();
    _printf("ModbusAddress:  ");
    _println(modbusParams.address);
    _printf("ModbusBaudrate: ");
    _println(modbusParams.baudrate);
    getPSensor();
    getParams();
    getFaultSettings();

    u16 powerOnCount;
    EEPROM.get(_EEPROM_POWERON_COUNT, powerOnCount);
    switch (powerOnCount) {
    case 0:
    case 0xFFFF:
        powerOnCount = 1;
        break;
    case 0xFFFE:
        break;
    default:
        powerOnCount++;
    }
    EEPROM.put(_EEPROM_POWERON_COUNT, powerOnCount);

#if _MODBUS == 1
    setupModbus(powerOnCount);
    mb.callbackCoil = modbusCallbackCoil;
    mb.callbackRegister = modbusCallbackRegister;
#endif

    display.greeting();

    delay(1000);
    controller.init(true);
    if (params.cEn)
        display.bgLight(true);
    else
        display.bgLight(100);

    _printf("Gespeicherte Alarme: "); _println(faults.count());

    timeStamp = millis();
}

void loop()
{
    currMillis = millis();
    static bool pwrBtnPressed;
    bool currentPwrBtnState = readPwrBtn();
    if (!pwrBtnPressed && currentPwrBtnState) {
        _printlnf("pwrButton pressed");
        pwrBtnPressed = true;
    } else if(pwrBtnPressed && !currentPwrBtnState) {
        _printlnf("pwrButton released");
        pwrBtnPressed = false;
        Parameters p;
        p.cEn = !params.cEn;
        setParams(p, true);
    }

    controller.process();
    display.process();

#if _MODBUS == 1
    mb.process();
    //checkModbusParams();
    static bool firstLoop = true;
    if (refTime != lastRefTime) {
        // _printf("refTime: "); _print(refTime); _printf(", lastRefTime: ");
        // _print(lastRefTime); _printf(", new Alarm: "); _println(bitRead(modbusData[1], 12));
        lastRefTime = refTime;
        timeStamp = currMillis;
        modbusData[5] = 0;
        eventCounter = 0;
        timeStampOverflow = false;
        // Bit 12 gibt an, ob ein neuer Alarm aufgetreten ist - zurücksetzen
        bitClear(modbusData[1], 12);
        // Bit 13 gibt an, ob ein Alarm aktiv ist
        if (faults.state() == activeFault) {
            bitSet(modbusData[1], 13);
        } else {
            bitClear(modbusData[1], 13);
        }
        // Setze das 'Timer-Überlauf'-Bit zurück (falls es gesetzt war)
        bitClear(modbusData[1], 14);
        if (firstLoop) {
            // Nachden die 'ReferenzZeit' erstmalig gesetzt wurde, wird dieses Bit gelöscht
            bitClear(modbusData[1], 15);
            firstLoop = false;
        }
        // Setze die Durchschnittswerte für die Messwerte zurück
        controller.resetAverageCounters();
        _printblnf("Der 12 Bit Timer wurde zurückgesetzt");
    }
    modbusData[5] = (currMillis - timeStamp) / 100;
    if (modbusDelAlarms[0] != 0 && modbusDelAlarms[0] != 0xFFFF) {
        modbusDelAlarms[0] = (faults.removeID(modbusDelAlarms[0])) ? 0 : 0xFFFF;
    } else if (modbusDelAlarms[1] != 0 && modbusDelAlarms[1] != 0xFFFF) {
        modbusDelAlarms[1] = (faults.removeAll()) ? 0 : 0xFFFF;
    }
    if (!timeStampOverflow && modbusData[5] > 0xFFF) {
#if _DEBUG_MODBUS == 1
        _printf("Der 12 Bit Timer ist übergelaufen. Vergangene Sekunden: ");
        _print(modbusData[5] / 10); _printf("."); _println(modbusData[5] % 10);
#endif //  _DEBUG_MODBUS == 1
        timeStampOverflow = true;
        bitSet(modbusData[1], 14);
    }
#endif // _MODBUS == 1

#if 0
    static unsigned long counter = 0;
    static unsigned long tl = currMillis;
    if (currMillis - tl > 1000) {
        tl = currMillis;
        _printf("Loops / Sekunde: "); _println(counter);
        counter = 0;
    } else {
        counter++;
    }
#endif
}