und hier die aquarea.hpp
#pragma once
#include <array>
#include <functional>
#include <vector>
#include <cstdint>
#include <queue>
#include <algorithm>
#include "esphome/core/hal.h"
#include "esphome/core/gpio.h"
#include "esphome/core/component.h"
#include "esphome/core/log.h"
#include "esphome/components/sensor/sensor.h"
#include "esphome/components/text_sensor/text_sensor.h"
#include "esphome/components/binary_sensor/binary_sensor.h"
#include "esphome/components/button/button.h"
#include "esphome/components/switch/switch.h"
#include "esphome/components/number/number.h"
#include "esphome/components/select/select.h"
#include "esphome/components/uart/uart.h"
namespace esphome {
namespace aquarea {
enum Registers
{
Defrost = 17, OutsideTemp = 18, OutletTemp = 19, ErrorCode = 20,
InletTemp = 21, TankTemp = 22, Compressor = 23, LastErrorCode = 24,
Mode = 27, HeatLSB = 29, HeatMSB = 30, CoolLSB = 31, CoolMSB = 32,
TankLSB = 33, TankMSB = 34, PumpStage = 35, Force = 128, ResetError = 129,
HeatOutsideTempLow = 130, HeatOutsideTempHigh = 131, HeatWaterTempLow = 132,
HeatWaterTempHigh = 133, HeatOffOutsideTemp = 134, HeaterOnOutsideTemp = 135,
CoolSetpointTemp = 136, TankSetpointTemp = 137, ShiftSetpoint = 138,
ServiceMode = 142, ReqMode = 144, PumpSpeed = 147, Num
};
std::array<std::function<void(uint8_t value)>, (size_t)Registers::Num> registers;
class AquareaComponent : public Component, public uart::UARTDevice
{
public:
struct Power
{
void write_lb(long timestamp, uint8_t value) { valid = false; lb_timestamp = timestamp; power = value; }
void write_mb(long timestamp, uint8_t value) { power |= ((uint16_t)value) << 8; if ((timestamp - lb_timestamp) < 200) valid = true; }
bool is_valid() const { return valid; }
uint16_t get_power() const { return power; }
private:
long lb_timestamp = 0;
uint16_t power = 0u;
bool valid = false;
};
AquareaComponent() = delete;
AquareaComponent(InternalGPIOPin *rts_pin_) { rx_packet.reserve(4); rts_pin = rts_pin_; }
uint8_t heatpump_checksum(const std::vector<uint8_t>& packet) {
return (packet[0] + packet[1] + packet[2]) & 0xff;
}
void heatpump_write() {
if (write_queue.empty()) return;
std::vector<uint8_t> packet({0xAA, write_queue.front().first, write_queue.front().second});
packet.push_back(heatpump_checksum(packet));
rts_pin->digital_write(true);
// 156ms Hardware-Timing
delay(41);
ESP_LOGD("aquarea", "!!! SENDE JETZT: Reg %02X Wert %02X !!!", packet[1], packet[2]);
this->write_array(packet);
this->flush();
delay(110);
rts_pin->digital_write(false);
write_queue.pop();
}
bool heatpump_read() {
if (this->available()) {
rx_packet.push_back(this->read());
if ((rx_packet[0] == 0xAA || rx_packet[0] == 0x55)) {
if (rx_packet.size() == 4) {
if (heatpump_checksum(rx_packet) == rx_packet[3]) return true;
rx_packet.clear();
}
} else { rx_packet.clear(); }
}
return false;
}
void register_select_if_present(const Registers& reg, select::Select* select, std::function<std::string(uint8_t value)> modifier = {}) {
if (select) registers[reg] = [select, modifier](uint8_t value) { select->publish_state(modifier ? modifier(value) : std::to_string((uint32_t)value)); };
}
void register_text_sensor_if_present(const Registers& reg, text_sensor::TextSensor* text_sensor, std::function<std::string(uint8_t value)> modifier = {}) {
if (text_sensor) registers[reg] = [text_sensor, modifier](uint8_t value) { text_sensor->publish_state(modifier ? modifier(value) : std::to_string((uint32_t)value)); };
}
void register_binary_sensor_if_present(const Registers& reg, const std::vector<std::pair<binary_sensor::BinarySensor*, uint8_t>>& sensors) {
registers[reg] = [sensors](uint8_t value) { for (auto& s : sensors) if (s.first) s.first->publish_state(value & s.second); };
}
void register_sensor_if_present(const Registers& reg, sensor::Sensor* sensor, std::function<uint8_t(uint8_t value)> modifier = {}) {
if (sensor) registers[reg] = [sensor, modifier](uint8_t value) { int8_t final_val = modifier ? (int8_t)modifier(value) : (int8_t)value; sensor->publish_state(final_val); };
}
void register_power_sensor_if_present(const Registers& reg_lsb, const Registers& reg_msb, sensor::Sensor* sensor, Power& power_obj) {
if (sensor) {
registers[reg_lsb] = [&power_obj](uint8_t value) { power_obj.write_lb(millis(), value); };
registers[reg_msb] = [&power_obj, sensor](uint8_t value) { power_obj.write_mb(millis(), value); if (power_obj.is_valid()) sensor->publish_state(power_obj.get_power()); };
}
}
void register_switch_if_present(const Registers& reg, switch_::Switch* sw, std::function<bool(uint8_t value)> modifier = {}) {
if (sw) registers[reg] = [sw, modifier](uint8_t value) { sw->publish_state(modifier ? modifier(value) : (bool)value); };
}
void register_number_if_present(const Registers& reg, number::Number* number, std::function<uint8_t(uint8_t value)> modifier = {}) {
if (number) registers[reg] = [number, modifier](uint8_t value) { float final_val = modifier ? (float)modifier(value) : (float)*((int8_t*)&value); number->publish_state(final_val); };
}
std::string get_current_mode(uint8_t value) {
std::string mode(value & 1 ? "on" : "off");
if (value & 2) mode += " heat"; if (value & 4) mode += " cool";
if (value & 16) mode += " tank"; if (value & 32) mode += " auto";
if (value & 64) mode += " quiet"; if (value & 128) mode += " heater";
return mode;
}
void setup_registers_cbk() {
static const std::vector<std::pair<binary_sensor::BinarySensor*, uint8_t>> defrost_reg_sensors({{defrost_binary_sensor_, 64}, {booster_binary_sensor_, 2}});
register_binary_sensor_if_present(Registers::Defrost, defrost_reg_sensors);
register_sensor_if_present(Registers::OutsideTemp, outside_temperature_sensor_);
register_sensor_if_present(Registers::OutletTemp, outlet_temperature_sensor_);
register_sensor_if_present(Registers::InletTemp, inlet_temperature_sensor_);
register_sensor_if_present(Registers::TankTemp, tank_temperature_sensor_);
register_sensor_if_present(Registers::Compressor, compressor_value_sensor_);
register_power_sensor_if_present(Registers::HeatLSB, Registers::HeatMSB, heat_power_sensor_, heat_power);
register_power_sensor_if_present(Registers::CoolLSB, Registers::CoolMSB, cool_power_sensor_, cool_power);
register_power_sensor_if_present(Registers::TankLSB, Registers::TankMSB, tank_power_sensor_, tank_power);
register_sensor_if_present(Registers::PumpStage, pump_speed_sensor_, [](uint8_t value){ return value/16; });
register_text_sensor_if_present(Registers::ErrorCode, error_code_text_sensor_);
register_text_sensor_if_present(Registers::LastErrorCode, last_error_code_text_sensor_);
register_text_sensor_if_present(Registers::Mode, current_mode_text_sensor_, std::bind(&AquareaComponent::get_current_mode, this, std::placeholders::_1));
register_switch_if_present(Registers::Force, force_switch_, [](uint8_t value){ return (bool)(value & 0x40); });
register_number_if_present(Registers::HeatOutsideTempLow, heat_out_temp_low_number_);
register_number_if_present(Registers::HeatOutsideTempHigh, heat_out_temp_high_number_);
register_number_if_present(Registers::HeatWaterTempLow, heat_water_temp_low_number_);
register_number_if_present(Registers::HeatWaterTempHigh, heat_water_temp_high_number_);
register_number_if_present(Registers::HeatOffOutsideTemp, heat_off_out_temp_number_);
register_number_if_present(Registers::HeaterOnOutsideTemp, heater_on_out_temp_number_);
register_number_if_present(Registers::CoolSetpointTemp, cool_setpoint_temp_number_);
register_number_if_present(Registers::TankSetpointTemp, tank_setpoint_temp_number_);
register_number_if_present(Registers::ShiftSetpoint, shift_setpoint_temp_number_);
register_number_if_present(Registers::PumpSpeed, pump_speed_number_, [](uint8_t value){ return value*16; });
register_select_if_present(Registers::ReqMode, request_mode_select_, std::bind(&AquareaComponent::get_current_mode, this, std::placeholders::_1));
}
void setup() override { setup_registers_cbk(); rts_pin->digital_write(false); }
void loop() override {
if (heatpump_read()) {
if (rx_packet.size() >= 2 && rx_packet[0] == 0x55) {
if (registers[rx_packet[1]]) {
registers[rx_packet[1]](rx_packet[2]);
}
if (!write_queue.empty()) {
heatpump_write();
}
}
rx_packet.clear();
}
}
float get_setup_priority() const override { return setup_priority::BUS; }
Power heat_power, tank_power, cool_power;
InternalGPIOPin* rts_pin;
std::vector<uint8_t> rx_packet;
std::queue<std::pair<uint8_t, uint8_t>> write_queue;
protected:
SUB_BINARY_SENSOR(defrost); SUB_BINARY_SENSOR(booster);
SUB_SENSOR(outside_temperature); SUB_SENSOR(outlet_temperature);
SUB_SENSOR(inlet_temperature); SUB_SENSOR(tank_temperature);
SUB_SENSOR(compressor_value); SUB_SENSOR(heat_power);
SUB_SENSOR(cool_power); SUB_SENSOR(tank_power); SUB_SENSOR(pump_speed);
SUB_TEXT_SENSOR(error_code); SUB_TEXT_SENSOR(last_error_code);
SUB_TEXT_SENSOR(current_mode); SUB_BUTTON(reset_error);
SUB_SWITCH(force); SUB_NUMBER(heat_out_temp_low);
SUB_NUMBER(heat_out_temp_high); SUB_NUMBER(heat_water_temp_low);
SUB_NUMBER(heat_water_temp_high); SUB_NUMBER(heat_off_out_temp);
SUB_NUMBER(heater_on_out_temp); SUB_NUMBER(cool_setpoint_temp);
SUB_NUMBER(tank_setpoint_temp); SUB_NUMBER(shift_setpoint_temp);
SUB_NUMBER(pump_speed); SUB_SELECT(request_mode);
};
// Upgrade 2: Optimistische Klassen (publish_state)
class ResetErrorButton : public button::Button, public Parented<AquareaComponent> { protected: void press_action() override { parent_->write_queue.push({Registers::ResetError, 1}); } };
class ForceSwitch : public switch_::Switch, public Parented<AquareaComponent> { protected: void write_state(bool state) override { parent_->write_queue.push({Registers::Force, state ? 0x40 : 0x00}); this->publish_state(state); } };
class HeatOutsideTempLowNumber : public number::Number, public Parented<AquareaComponent> { protected: void control(float value) override { parent_->write_queue.push({Registers::HeatOutsideTempLow, (uint8_t)value}); this->publish_state(value); } };
class HeatOutsideTempHighNumber : public number::Number, public Parented<AquareaComponent> { protected: void control(float value) override { parent_->write_queue.push({Registers::HeatOutsideTempHigh, (uint8_t)value}); this->publish_state(value); } };
class HeatWaterTempLowNumber : public number::Number, public Parented<AquareaComponent> { protected: void control(float value) override { parent_->write_queue.push({Registers::HeatWaterTempLow, (uint8_t)value}); this->publish_state(value); } };
class HeatWaterTempHighNumber : public number::Number, public Parented<AquareaComponent> { protected: void control(float value) override { parent_->write_queue.push({Registers::HeatWaterTempHigh, (uint8_t)value}); this->publish_state(value); } };
class HeatOffOutsideTempNumber : public number::Number, public Parented<AquareaComponent> { protected: void control(float value) override { parent_->write_queue.push({Registers::HeatOffOutsideTemp, (uint8_t)value}); this->publish_state(value); } };
class HeaterOnOutsideTempNumber : public number::Number, public Parented<AquareaComponent> { protected: void control(float value) override { parent_->write_queue.push({Registers::HeaterOnOutsideTemp, (uint8_t)value}); this->publish_state(value); } };
class CoolSetpointTempNumber : public number::Number, public Parented<AquareaComponent> { protected: void control(float value) override { parent_->write_queue.push({Registers::CoolSetpointTemp, (uint8_t)value}); this->publish_state(value); } };
class TankSetpointTempNumber : public number::Number, public Parented<AquareaComponent> { protected: void control(float value) override { parent_->write_queue.push({Registers::TankSetpointTemp, (uint8_t)value}); this->publish_state(value); } };
class ShiftSetpointTempNumber : public number::Number, public Parented<AquareaComponent> { protected: void control(float value) override { parent_->write_queue.push({Registers::ShiftSetpoint, (uint8_t)value}); this->publish_state(value); } };
class PumpSpeedNumber : public number::Number, public Parented<AquareaComponent> { protected: void control(float value) override { parent_->write_queue.push({Registers::PumpSpeed, (uint8_t)value}); this->publish_state(value); } };
class ReqModeSelect : public select::Select, public Parented<AquareaComponent> {
protected:
void control(const std::string& value) override {
uint8_t mode = 0u;
if(value.find("on") != std::string::npos) mode += 1;
if(value.find("heat") != std::string::npos) mode += 2;
if(value.find("cool") != std::string::npos) mode += 4;
if(value.find("tank") != std::string::npos) mode += 16;
if(value.find("auto") != std::string::npos) mode += 32;
if(value.find("quiet") != std::string::npos) mode += 64;
if(value.find("heater") != std::string::npos) mode += 128;
parent_->write_queue.push({Registers::ReqMode, mode});
this->publish_state(value);
}
};
} // namespace esphome
} // namespace aquarea