init

zuno-test.ino

@@ -0,0 +1,453 @@
+#include "EEPROM.h"
+
+#include <ZUNO_OneWire.h>
+#include <ZUNO_DS18B20.h>
+
+#define PIN_RELAY_BURNER 12
+#define PIN_RELAY_WATER_LOAD 11
+#define PIN_RELAY_WATER_RECYCLING 10
+#define PIN_RELAY_HEAT_PUMP_1 9
+
+#define PIN_INPUT_BURNER_RUNNING 16
+#define PIN_INPUT_BURNER_ALARM 17
+#define PIN_INPUT_BOILER_ALARM 18
+
+#define PIN_ONEWIRE 15
+
+#define EEPROM_MAGIC_VALUE 0x4242
+#define EEPROM_MAGIC_ADDR 0
+#define EEPROM_REQUESTED_TEMP_ADDR_BASE (EEPROM_MAGIC_ADDR + 2)
+#define EEPROM_THERMOSTAT_MODE_BASE (EEPROM_REQUESTED_TEMP_ADDR_BASE + 4) // req temp is 2 bytes per thermostat
+
+#define ZW_PARAM_BASE 64
+#define ZW_PARAM_UPDATE_UNSOLICITED_TIME_BASE (ZW_PARAM_BASE) // 64, 65
+#define ZW_PARAM_UPDATE_THRESHOLD_TEMP_BASE (ZW_PARAM_UPDATE_UNSOLICITED_TIME_BASE + 2) // 66, 67
+#define ZW_PARAM_MIN_CYCLE_DURATION_BASE (ZW_PARAM_UPDATE_THRESHOLD_TEMP_BASE + 2) // 68, 69
+#define ZW_PARAM_TOLERANCE_TEMP_BASE (ZW_PARAM_MIN_CYCLE_DURATION_BASE + 2) // 70, 71
+
+#define LOG_INIT() Serial.begin(9600)
+#define LOG_WRITE(x) Serial.print(x)
+#define LOG_WRITELN(x) Serial.println(x)
+
+//#define LOG_INIT()
+//#define LOG_WRITE(x)
+//#define LOG_WRITELN(x)
+
+#define DALLAS_ADDR_SIZE 8
+
+struct thermostat_t {
+  byte dallasAddress[DALLAS_ADDR_SIZE];
+  word currentTemp;
+  
+  byte requestedMode;
+  word requestedTemp;
+  
+  unsigned long lastZwaveReadTime;
+  word lastZwaveReadTemp;
+  
+  word updateUnsolicitedTime;
+  word updateThresholdTemp;
+  
+  word minCycleDuration;
+  word toleranceTemp;
+
+  bool requestHeat;
+};
+
+struct output_t {
+  int pin;
+  bool currentValue;
+  unsigned long lastChangedTime;
+};
+
+OneWire oneWire(PIN_ONEWIRE);
+DS18B20Sensor dallas(&oneWire);
+
+
+#define THERMOSTATS_COUNT 2
+#define THERMOSTAT_HEAT_IDX 0
+#define THERMOSTAT_WATER_IDX 1
+thermostat_t thermostats[THERMOSTATS_COUNT];
+
+#define OUTPUTS_COUNT 4
+#define OUTPUT_BURNER_IDX 0
+#define OUTPUT_WATER_LOAD_IDX 1
+#define OUTPUT_WATER_RECYCLING_IDX 2
+#define OUTPUT_HEAT_PUMP_1_IDX 3
+output_t outputs[OUTPUTS_COUNT];
+
+ZUNO_SETUP_CHANNELS(
+  ZUNO_THERMOSTAT(THERMOSTAT_FLAGS_OFF | THERMOSTAT_FLAGS_HEAT, THERMOSTAT_UNITS_CELSIUS, THERMOSTAT_RANGE_POS, 10, getHeaterMode, setHeaterMode, getHeaterTemp, setHeaterTemp), // Heater
+  ZUNO_SENSOR_MULTILEVEL(ZUNO_SENSOR_MULTILEVEL_TYPE_WATER_TEMPERATURE, SENSOR_MULTILEVEL_SCALE_CELSIUS, METER_SIZE_TWO_BYTES, SENSOR_MULTILEVEL_PRECISION_TWO_DECIMALS, getHeaterCurrentTemp), // Heater temp
+  ZUNO_THERMOSTAT(THERMOSTAT_FLAGS_OFF | THERMOSTAT_FLAGS_HEAT, THERMOSTAT_UNITS_CELSIUS, THERMOSTAT_RANGE_POS, 10, getWaterMode, setWaterMode, getWaterTemp, setWaterTemp), // Water
+  ZUNO_SENSOR_MULTILEVEL(ZUNO_SENSOR_MULTILEVEL_TYPE_WATER_TEMPERATURE, SENSOR_MULTILEVEL_SCALE_CELSIUS, METER_SIZE_TWO_BYTES, SENSOR_MULTILEVEL_PRECISION_TWO_DECIMALS, getWaterCurrentTemp), // Water temp
+  ZUNO_SWITCH_BINARY(getRelayBurner, setRelayBurner), // Burner
+  ZUNO_SWITCH_BINARY(getRelayWaterLoad, setRelayWaterLoad), // Water load pump
+  ZUNO_SWITCH_BINARY(getRelayWaterRecycling, setRelayWaterRecycling), // Water recycling pump
+  ZUNO_SWITCH_BINARY(getRelayHeatPump1, setRelayHeatPump1), // Heater pump Floor 1
+  ZUNO_SENSOR_BINARY(ZUNO_SENSOR_BINARY_TYPE_GENERAL_PURPOSE, getInputBurnerRunning), // Burner running
+  ZUNO_SENSOR_BINARY(ZUNO_SENSOR_BINARY_TYPE_GENERAL_PURPOSE, getInputBurnerAlarm), // Burner alarm
+  ZUNO_SENSOR_BINARY(ZUNO_SENSOR_BINARY_TYPE_GENERAL_PURPOSE, getInputBoilerAlarm)  // Boiler alarm
+);
+ZUNO_SETUP_CFGPARAMETER_HANDLER(config_parameter_changed);
+
+byte EEPROM_put(dword address, void * value, word val_size) {
+  byte res = EEPROM.put(address, value, val_size);
+  if (!res) {
+    LOG_WRITELN("EEPROM put: FAIL");
+  }
+  return res;
+}
+
+byte EEPROM_get(dword address, void * value, word val_size) {
+  byte res = EEPROM.get(address, value, val_size);
+  if (!res) {
+    LOG_WRITELN("EEPROM put: FAIL");
+  }
+  return res;
+}
+
+word abs_diff(word v1, word v2) {
+  if (v1 > v2) {
+    return v1 - v2;
+  }
+  return v2 - v1;
+}
+
+void setup() {
+  delay(2000);
+  LOG_INIT();
+  LOG_WRITELN("setup BEGIN");
+  
+  pinMode(PIN_INPUT_BURNER_RUNNING, INPUT);
+  pinMode(PIN_INPUT_BURNER_ALARM, INPUT);
+  pinMode(PIN_INPUT_BOILER_ALARM, INPUT);
+
+  word magic_value[1] = {0};
+  EEPROM_get(EEPROM_MAGIC_ADDR, magic_value, sizeof(magic_value));
+  if (magic_value[0] != EEPROM_MAGIC_VALUE) {
+    LOG_WRITE("First init: ");
+    LOG_WRITELN((int)magic_value[0]);
+
+    zunoSaveCFGParam(ZW_PARAM_UPDATE_UNSOLICITED_TIME_BASE + 0, 600); // 10 min
+    zunoSaveCFGParam(ZW_PARAM_UPDATE_UNSOLICITED_TIME_BASE + 1, 600); // 10 min
+
+    zunoSaveCFGParam(ZW_PARAM_UPDATE_THRESHOLD_TEMP_BASE + 0, 50); // 0.5 °C
+    zunoSaveCFGParam(ZW_PARAM_UPDATE_THRESHOLD_TEMP_BASE + 1, 50); // 0.5 °C
+
+    zunoSaveCFGParam(ZW_PARAM_MIN_CYCLE_DURATION_BASE + 0, 60); // 1 min
+    zunoSaveCFGParam(ZW_PARAM_MIN_CYCLE_DURATION_BASE + 1, 60); // 1 min
+
+    zunoSaveCFGParam(ZW_PARAM_TOLERANCE_TEMP_BASE + 0, 2000); // 20 °C
+    zunoSaveCFGParam(ZW_PARAM_TOLERANCE_TEMP_BASE + 1, 1000); // 10 °C
+
+    word requestedTemps[2] = {8000, 3000}; // 80 °C; 30 °C
+    EEPROM_put(EEPROM_REQUESTED_TEMP_ADDR_BASE, requestedTemps, sizeof(requestedTemps));
+
+    byte modes[2] = {THERMOSTAT_MODE_OFF, THERMOSTAT_MODE_OFF};
+    EEPROM_put(EEPROM_THERMOSTAT_MODE_BASE, modes, sizeof(modes));
+
+    magic_value[0] = EEPROM_MAGIC_VALUE;
+    EEPROM_put(EEPROM_MAGIC_ADDR, magic_value, sizeof(magic_value));
+  }
+
+  byte dallasAddresses[DALLAS_ADDR_SIZE * 2];
+  byte dallasAddressesCount = dallas.findAllSensors(dallasAddresses); // TODO retry if not 2
+  LOG_WRITE("Found ");
+  LOG_WRITE(dallasAddressesCount);
+  LOG_WRITELN(" sensors");
+
+  word requestedTemps[2] = {8000, 3000};
+  EEPROM_get(EEPROM_REQUESTED_TEMP_ADDR_BASE, requestedTemps, sizeof(requestedTemps));
+  byte modes[2] = {THERMOSTAT_MODE_OFF, THERMOSTAT_MODE_OFF};
+  EEPROM_get(EEPROM_THERMOSTAT_MODE_BASE, modes, sizeof(modes));
+
+  for (int ti = 0; ti < THERMOSTATS_COUNT; ++ti) {
+    memcpy(thermostats[ti].dallasAddress, &dallasAddresses[ti * DALLAS_ADDR_SIZE], DALLAS_ADDR_SIZE);
+    thermostats[ti].currentTemp = BAD_TEMP;
+    
+    thermostats[ti].requestedMode = modes[ti];
+    thermostats[ti].requestedTemp = requestedTemps[ti];
+    
+    thermostats[ti].lastZwaveReadTime = 0;
+    thermostats[ti].lastZwaveReadTemp = BAD_TEMP;
+    
+    thermostats[ti].updateUnsolicitedTime = zunoLoadCFGParam(ZW_PARAM_UPDATE_UNSOLICITED_TIME_BASE + ti);
+    thermostats[ti].updateThresholdTemp = zunoLoadCFGParam(ZW_PARAM_UPDATE_THRESHOLD_TEMP_BASE + ti);
+    
+    thermostats[ti].minCycleDuration = zunoLoadCFGParam(ZW_PARAM_MIN_CYCLE_DURATION_BASE + ti);
+    thermostats[ti].toleranceTemp = zunoLoadCFGParam(ZW_PARAM_TOLERANCE_TEMP_BASE + ti);
+
+    thermostats[ti].requestHeat = false;
+  }
+
+  outputs[OUTPUT_BURNER_IDX].pin = PIN_RELAY_BURNER;
+  outputs[OUTPUT_WATER_LOAD_IDX].pin = PIN_RELAY_WATER_LOAD;
+  outputs[OUTPUT_WATER_RECYCLING_IDX].pin = PIN_RELAY_WATER_RECYCLING;
+  outputs[OUTPUT_HEAT_PUMP_1_IDX].pin = PIN_RELAY_HEAT_PUMP_1;
+  for (int oi = 0; oi < OUTPUTS_COUNT; ++oi) {
+    outputs[oi].currentValue = 0;
+    outputs[oi].lastChangedTime = 0;
+    pinMode(outputs[oi].pin, OUTPUT);
+    digitalWrite(outputs[oi].pin, 0);
+  }
+  LOG_WRITELN("setup END");
+}
+
+void updateValues() {
+  // Temp sensors
+  for (int ti = 0; ti < THERMOSTATS_COUNT; ++ti) {
+    word newValue = BAD_TEMP;
+    for (int j = 0; j < 3 && (newValue == BAD_TEMP || newValue == 0); ++j) {
+      newValue = dallas.getTemperature(thermostats[ti].dallasAddress) * 100;
+    }
+    thermostats[ti].currentTemp = newValue;
+
+    if (thermostats[ti].requestedMode == THERMOSTAT_MODE_HEAT) {
+      if (thermostats[ti].currentTemp <= thermostats[ti].requestedTemp - thermostats[ti].toleranceTemp && !thermostats[ti].requestHeat) { // TODO Check overflow
+        LOG_WRITE("Thermostat ");
+        LOG_WRITE(ti);
+        LOG_WRITE(" is too low: ");
+        LOG_WRITE((int)thermostats[ti].currentTemp);
+        LOG_WRITE(" << ");
+        LOG_WRITELN((int)thermostats[ti].requestedTemp);
+        thermostats[ti].requestHeat = true;
+      }
+      else if (thermostats[ti].currentTemp >= thermostats[ti].requestedTemp && thermostats[ti].requestHeat) {
+        LOG_WRITE("Thermostat ");
+        LOG_WRITE(ti);
+        LOG_WRITE(" is acceptable: ");
+        LOG_WRITE((int)thermostats[ti].currentTemp);
+        LOG_WRITE(" >= ");
+        LOG_WRITELN((int)thermostats[ti].requestedTemp);
+        thermostats[ti].requestHeat = false;
+      }
+    }
+    else {
+      if (thermostats[ti].requestHeat) {
+        LOG_WRITE("Thermostat ");
+        LOG_WRITE(ti);
+        LOG_WRITELN(" has been turned OFF");
+        thermostats[ti].requestHeat = false;
+        setRelayManual(OUTPUT_BURNER_IDX, 0);
+        setRelayManual(OUTPUT_WATER_LOAD_IDX, 0);
+      }
+    }
+  }
+}
+
+void updateZwave() {
+  for (int ti = 0; ti < THERMOSTATS_COUNT; ++ti) {
+    const word oldValue = thermostats[ti].lastZwaveReadTemp;
+    const word newValue = thermostats[ti].currentTemp;
+    if (abs_diff(newValue, oldValue) > thermostats[ti].updateThresholdTemp) {
+      LOG_WRITE("Sensor ");
+      LOG_WRITE(ti);
+      LOG_WRITE(" value changed from ");
+      LOG_WRITE((int)oldValue);
+      LOG_WRITE(" to ");
+      LOG_WRITELN((int)newValue);
+      zunoSendReport(2 + (ti * 2)); // 2 or 4
+    }
+    else if (millis() - thermostats[ti].lastZwaveReadTime > (unsigned long)thermostats[ti].updateUnsolicitedTime * 1000) {
+      LOG_WRITE("Sensor ");
+      LOG_WRITE(ti);
+      LOG_WRITE(" unsolicited update to ");
+      LOG_WRITELN((int)newValue);
+      zunoSendReport(2 + (ti * 2)); // 2 or 4
+    }
+  }
+}
+
+void updateOutputs() {
+
+  // TODO Handle min cycle
+  bool burnerRequested = thermostats[THERMOSTAT_HEAT_IDX].requestHeat || (thermostats[THERMOSTAT_WATER_IDX].requestHeat && thermostats[THERMOSTAT_HEAT_IDX].currentTemp < thermostats[THERMOSTAT_WATER_IDX].requestedTemp);
+  bool waterLoadRequested = thermostats[THERMOSTAT_WATER_IDX].requestHeat && thermostats[THERMOSTAT_HEAT_IDX].currentTemp > thermostats[THERMOSTAT_WATER_IDX].currentTemp;
+
+  if (thermostats[THERMOSTAT_HEAT_IDX].requestedMode == THERMOSTAT_MODE_HEAT || thermostats[THERMOSTAT_WATER_IDX].requestedMode == THERMOSTAT_MODE_HEAT) {
+    setRelay(OUTPUT_BURNER_IDX, burnerRequested);
+  }
+  if (thermostats[THERMOSTAT_WATER_IDX].requestedMode == THERMOSTAT_MODE_HEAT) {
+    setRelay(OUTPUT_WATER_LOAD_IDX, waterLoadRequested);
+  }
+}
+
+void loop() {
+  updateValues();
+  updateZwave();
+  updateOutputs();
+  delay(100);
+}
+
+// ZWave callbacks
+void config_parameter_changed(byte param, word value) {
+    LOG_WRITE("Zwave param ");
+    LOG_WRITE((int)param);
+    LOG_WRITE(": ");
+    LOG_WRITELN((int)value);
+
+    if (param >= ZW_PARAM_UPDATE_UNSOLICITED_TIME_BASE && param < ZW_PARAM_UPDATE_UNSOLICITED_TIME_BASE + THERMOSTATS_COUNT) {
+      thermostats[param - ZW_PARAM_UPDATE_UNSOLICITED_TIME_BASE].updateUnsolicitedTime = value;
+    }
+    else if (param >= ZW_PARAM_UPDATE_THRESHOLD_TEMP_BASE && param < ZW_PARAM_UPDATE_THRESHOLD_TEMP_BASE + THERMOSTATS_COUNT) {
+      thermostats[param - ZW_PARAM_UPDATE_THRESHOLD_TEMP_BASE].updateThresholdTemp = value;
+    }
+    else if (param >= ZW_PARAM_MIN_CYCLE_DURATION_BASE && param < ZW_PARAM_MIN_CYCLE_DURATION_BASE + THERMOSTATS_COUNT) {
+      thermostats[param - ZW_PARAM_MIN_CYCLE_DURATION_BASE].minCycleDuration = value;
+    }
+    else if (param >= ZW_PARAM_TOLERANCE_TEMP_BASE && param < ZW_PARAM_TOLERANCE_TEMP_BASE + THERMOSTATS_COUNT) {
+      thermostats[param - ZW_PARAM_TOLERANCE_TEMP_BASE].toleranceTemp = value;
+    }
+}
+
+// Thermostats
+void setMode(int ti, byte mode) {
+  LOG_WRITE("Thermostat ");
+  LOG_WRITE(ti);
+  LOG_WRITE(" update: mode: ");
+  LOG_WRITELN((int)mode);
+  thermostats[ti].requestedMode = mode;
+  EEPROM_put(EEPROM_THERMOSTAT_MODE_BASE + (sizeof(thermostats[ti].requestedMode) * ti), &thermostats[ti].requestedMode, sizeof(thermostats[ti].requestedMode));
+}
+byte getMode(int ti) {
+  return thermostats[ti].requestedMode;
+}
+void setTemp(int ti, byte mode, word temp) {
+  LOG_WRITE("Thermostat ");
+  LOG_WRITE(ti);
+  LOG_WRITE(" update: mode: ");
+  LOG_WRITE((int)mode);
+  LOG_WRITE(" temp: ");
+  LOG_WRITELN((int)temp);
+  thermostats[ti].requestedMode = mode;
+  EEPROM_put(EEPROM_THERMOSTAT_MODE_BASE + (sizeof(thermostats[ti].requestedMode) * ti), &thermostats[ti].requestedMode, sizeof(thermostats[ti].requestedMode));
+  if (mode == THERMOSTAT_MODE_HEAT) {
+    thermostats[ti].requestedTemp = temp * 10;// Z-Wave thermostat precision is 0.1
+    EEPROM_put(EEPROM_REQUESTED_TEMP_ADDR_BASE + (sizeof(thermostats[ti].requestedTemp) * ti), &thermostats[ti].requestedTemp, sizeof(thermostats[ti].requestedTemp));
+  }
+}
+word getTemp(int ti, byte mode) {
+  if (mode == THERMOSTAT_MODE_HEAT) {
+    return thermostats[ti].requestedTemp / 10;// Z-Wave thermostat precision is 0.1
+  }
+  return 0;
+}
+word getCurrentTemp(int ti) {
+  LOG_WRITE("Sensor ");
+  LOG_WRITE(ti);
+  LOG_WRITELN(" Zwave update");
+  thermostats[ti].lastZwaveReadTime = millis();
+  thermostats[ti].lastZwaveReadTemp = thermostats[ti].currentTemp;
+  return thermostats[ti].lastZwaveReadTemp;
+}
+
+
+
+// Heater
+void setHeaterMode(byte mode) {
+  setMode(THERMOSTAT_HEAT_IDX, mode);
+}
+byte getHeaterMode(){
+  return getMode(THERMOSTAT_HEAT_IDX);
+}
+void setHeaterTemp(byte mode, word temp) {
+  setTemp(THERMOSTAT_HEAT_IDX, mode, temp);
+}
+word getHeaterTemp(byte mode) {
+  return getTemp(THERMOSTAT_HEAT_IDX, mode);
+}
+word getHeaterCurrentTemp() {
+  return getCurrentTemp(THERMOSTAT_HEAT_IDX);
+}
+
+// Water
+void setWaterMode(byte mode) {
+  setMode(THERMOSTAT_WATER_IDX, mode);
+}
+byte getWaterMode(){
+  return getMode(THERMOSTAT_WATER_IDX);
+}
+void setWaterTemp(byte mode, word temp) {
+  setTemp(THERMOSTAT_WATER_IDX, mode, temp);
+}
+word getWaterTemp(byte mode) {
+  return getTemp(THERMOSTAT_WATER_IDX, mode);
+}
+word getWaterCurrentTemp() {
+  return getCurrentTemp(THERMOSTAT_WATER_IDX);
+}
+
+// Raw outputs
+
+void setRelay(int oi, bool value) {
+  if (value != outputs[oi].currentValue) {
+    LOG_WRITE("Output ");
+    LOG_WRITE(oi);
+    LOG_WRITE(" update: value: ");
+    LOG_WRITELN((int)value);
+    outputs[oi].currentValue = value;
+    outputs[oi].lastChangedTime = millis();
+    digitalWrite(outputs[oi].pin, value);
+    zunoSendReport(5 + oi); // 5 to 8
+  }
+}
+byte getRelay(int oi) {
+  return outputs[oi].currentValue;
+}
+
+void setRelayManual(int oi, byte value) {
+  if (oi == OUTPUT_BURNER_IDX && (thermostats[THERMOSTAT_HEAT_IDX].requestedMode == THERMOSTAT_MODE_HEAT || thermostats[THERMOSTAT_WATER_IDX].requestedMode == THERMOSTAT_MODE_HEAT)) {
+    return;
+  }
+  if (oi == OUTPUT_WATER_LOAD_IDX && thermostats[THERMOSTAT_WATER_IDX].requestedMode == THERMOSTAT_MODE_HEAT) {
+    return;
+  }
+
+  setRelay(oi, value ? 1 : 0);
+}
+byte getRelayZwave(int oi) {
+  return getRelay(oi) ? 255 : 0;
+}
+
+void setRelayBurner(byte value) {
+  setRelayManual(OUTPUT_BURNER_IDX, value);
+}
+byte getRelayBurner() {
+  return getRelayZwave(OUTPUT_BURNER_IDX);
+}
+
+void setRelayWaterLoad(byte value) {
+  setRelayManual(OUTPUT_WATER_LOAD_IDX, value);
+}
+byte getRelayWaterLoad() {
+  return getRelayZwave(OUTPUT_WATER_LOAD_IDX);
+}
+
+void setRelayWaterRecycling(byte value) {
+  setRelayManual(OUTPUT_WATER_RECYCLING_IDX, value);
+}
+byte getRelayWaterRecycling() {
+  return getRelayZwave(OUTPUT_WATER_RECYCLING_IDX);
+}
+
+void setRelayHeatPump1(byte value) {
+  setRelayManual(OUTPUT_HEAT_PUMP_1_IDX, value);
+}
+byte getRelayHeatPump1() {
+  return getRelayZwave(OUTPUT_HEAT_PUMP_1_IDX);
+}
+
+// Raw inputs
+
+byte getInputBurnerRunning() {
+  return !digitalRead(PIN_INPUT_BURNER_RUNNING);
+}
+
+byte getInputBurnerAlarm() {
+  return !digitalRead(PIN_INPUT_BURNER_ALARM);
+}
+
+byte getInputBoilerAlarm() {
+  return !digitalRead(PIN_INPUT_BOILER_ALARM);
+}