Aurea 5 hybrid: interfaces met de buitenunit en thermostaat

[P1 modubus]

Zie nu het plaatje nu in deellast, je kunt de temperaturen erbij zien, ook de retour van de installatie, ook de Dt, vermogen in Amp en Watt meterstand is voor je niet interessant die gegevens komen van een goedgekeurde E-tussenmeter .

[WackoH]

Die geregelde bypass is een mooie concept om de nukken van de combinatie warmtepomp en controlbox te omzeilen. Maar je moet het eigenlijk niet willen.

Met die extra bypass (intern is er ook al eentje) wordt een deel van het verwarmde water weer terug naar de warmtepomp gestuurd. Zo til je temperatuur van de aanvoer en retour omhoog. Hogere watertemperaturen betekenen volgens mij per definitie dat het rendement (COP) lager wordt.
Nu gaat het hier maar om een paar graden en voornamelijk tijdens de start dus verder geen ramp, maar verschil maakt het wel.

Verder lijkt me een delta_T van 5oC geen wet, maar een handige vuistregel. Het water gaat met een vast debiet rond (tenminste, ik heb nog niet gevonden dat de pomp bij deze unit actief wordt gemoduleerd, maar kan dat ook niet uitsluiten), terwijl de warmtepomp een sterk wisselende hoeveelheid warmte toevoegt. Dus dit betekent dan weer per definitie dat de delta_T tussen aanvoer en retour sterk varieert. Bijvoorbeeld in mijn geval tussen de 1oC bij minimum en 5oC bij maximum vermogen. Wat de aanvoer/retourtemperatuur dan wordt hangt af van het warmteafgifte systeem. Radiatoren geven minder efficient warmte af dan een vloerverwarming, dus in het eerste geval liggen de temperaturen hoger.

Ik zie geen enkele reden (behalve in het Aurea geval ) waarom je bewust het hele systeem minder efficient zou moeten gaan laten werken door de warmtepomp kort te sluiten om zo een delta_T van 5oC te bereiken. Het betektent daarnaast ook dat de verdeling door de rest van de installatie verstoort raakt omdat je daar nu wisselende hoeveelheden water heen gaat sturen.


Over de wisellend vermogen gesproken: Ik zie overigens duidelijk dat bij een vast uitsturing naar de Chofu, het opgenomen vermogen sterk afhangt van de retour/aanvoertemperatuur (hogere temperaturen --> hoger vermogen). Het gaat om tientallen procenten verschil. De reden lijkt me dat het meer moeite (groter drukverschil) kost om het koelmiddel een hogere tempeatuur op te laten wekken zodat de compressor meer vermogen op gaat nemen als die met een bepaald toerental draait.

[P1 modubus]

Het is misschien een misverstand, de bypass is de meegeleverde bypass niet een extra, deze wordt ook niet steeds bijgeregeld, deze heb ik vast ingesteld zoals in de bijschrijving summier beschreven staat, alleen ik heb de mogelijkheid benut van een secuur systeem, om een dt van 5-6 grd te krijgen, bij een ingeregelde cv installatie dat hydraulisch bijna altijd het zelfde is of meer flow, je ziet ook aan de retour van de cv installatie maar weinig verschil, 1/2 grd C,
Ook werd er in dit platform eerder geschreven dat als het Dt te groot wordt dat dan de cv ketel in bedrijf komt,
Het is aan jullie hoe jullie het willen, maar nu ik iets meer van het systeem begrijp en zie hoe het bij mij functioneert ben ik best tevreden met weinig aanpassingen, gisteren 5.5 Kwh verbruikt, WP bijna aaneen stuk verwarmd, met een hoge piek tijdens het installeren van de CV ketel via opentherm, rest perfect gedraaid, zie plaatje

Het is ook gelukt om deze te koppelen helaas geeft de ketel dan een storing geen ruimteopnemer aangesloten, zal met Remeha telefoneren of hier een oplossing voor is, anders laat ik de Remeha standalone werken, niet aangesloten op de Plugwise regeling, deze kan ik via de app als nodig laten bijstoken, thermostaat naast de ketel hangen, laat dan Plugwise aan mijn regeling aangeven dat er warmte gevraagd wordt, via een Digitale ingang.
Nogmaals de koelsystemen zijn uitgelegd met een Dt van 6 grd een CV ketel met een Dt van 20 grd, als je een Dt van 5-6 grd hebt bij een maximaal vermogen dan werkt het perfect, is de flow over de unit niet te hoog en te laag, is de Dt te hoog heb een te kleine flow, is de Dt te klein is de flow te hoog,
Zie dan dat de WP het zelf ook perfect aanpast in deelvermogens.
Misschien was ik iets te onduidelijk maar de eerder plaatjes gaven de installatie goed weer er is niets meer of extra's toegevoegd. tot zover

[WackoH]

Ik had inderdaad de indruk dat je de bypass actief bijregelde naar een delta_T van 5oC. Maar goed om te horen dat je het met de basisspullen goed hebt gekregen! Mooi werk.

Verder schijnen er meerdere software veries te zijn. Maar dat is lastig te achterhalen omdat de enige aanwijzing het stickertje op de microntrollers in de controlbox is. Bij mij staat er bijvoorbeeld Tesla2_M op

[P1 modubus]

Na overleg met Remeha kan het probleem, het missen van een ruimteopnemer opgelost worden, ben alleen nog het twijfelen en of ik het aansluit, de thermostaat heb ik nu opgehangen naast de ketel en is via de app benaderbaar en te bedienen.
Eenmaal was de WP gestopt en wilde zomaar zonder verklaring de CV ketel laten stoken, dus laat ik het voorlopig zo.
Ook heb ik nu na een koude nacht de schakeling aangezet dat de buitentemperatuur 6 grd hoger maakt voor de WP, normaal neemt deze 7 watt op, bij 4 grd C wordt dit 54 Watt, dan laat de WP de circulatiepomp onnodig lopen, Ik zal naar 200 Mohm (nog uitproberen na montage kijk ik dit na op de WP zelf) gaan in de winter voor 4 grd verhogen van de buitentemperatuur, dit heeft 2 voordelen
1/ de circulatiepomp gaat niet onnodig draaien, bij 0 grd C pas;
2/ de WP blijft werken tot het rendement zodanig wordt dat het niet meer loont, dit kan ik met een schakeling automatisch laten gebeuren.

Alleen heb ik gemerkt dat de regeling bij mij niet aan of uit gaat via een rooster vannacht ging deze pas om 23.30 uur uit, heb zeker 3 tijden gezet 20.00, 22.00, 23.30 uur op nacht 18.00 grd staan.
Handmatig bediening en weergave denk ik op de Anna beter is dan de online versie,.


Zie de verschillen in de een is het volgens rooster en op de Anna is dit niet,
Ik vind het zelf leuk om iets te achterhalen zeker in de Meet&Regel techniek, maar vindt het jammer dat er ook geen eenvoudige rechtstreekse regeling bij kan, dit zal de WP beter verkoopbaar maken, zelf vind ik het, het beste apparaat voor mijn situatie, dat gun ik zeker iedereen.

[WackoH]

Hallo,

Het is misschien wel aardig om te zien hoe eenvoudig de Chofu warmtepomp kan worden aangestuurd.
Ik gebruik hiervoor een Arduino Diecimila met een rotary encoder.

In de controlbox heb ik 1 kant van weerstand R14 losgehaald (deze kant is bewust zodat de uitgang van de microcontroller door R14 beschermd blijft), en in een (groen) draadje met aan beide zijden een een DuPont connector gesoldeerd. De andere kant heb ik via een 1 kOhm weerstand met pin 2 van de Diecimila verbonden.
Verder heb ik aan de losse kant van weerstand R14 een draadje met een contra DuPont connector gesoldeerd. Zo kan ik de oorspronkelijke situatie herstellen door deze twee connectoren in elkaar te schuiven:


Daarnaast heb ik een min (of aarde) verbinding via PAD3 gemaakt door daar een connector in te solderen, en die met een GND van de Diecimila te verbinden. (De onderstaand foto is van voordat ik de verbinding heb gemaakt):



Dit is met versie 1.00 van de print en natuurlijk allemaal op eigen risico. Houd er rekening mee dat een foute verbinding (met name bij PAD 1 en 2, deze zijn zonder beschermende weerstanden met de beide microcontrollers verbonden), tot schade kan leiden.

Dit is de code:

Arduino:

/* 
Simple way to control the power setting of a Chofu AEYC-0643XU-CH heatpump with an Arduino
The power is set with a rotary switch and send via one-way serial communication at 666 bps to the heatpump, using the hardware of Atantic Aurea controlbox.
Lift the side of resistor R14 that is connected to the base of T2, and connect the output pin (default is pin 2) of the Arduino  via a 1 kOhm resistor to the base of T2.
Version 1.0, JHN 02-03-2025 */

#include "SoftwareSerialTX.h"
#include <string.h>

// Use a SoftwareSerialTX on Pin 2
SoftwareSerialTX txOnly(2);

//Define variables and constants
int PowerSetpoint;                                // Setpoint to heat pump  warmtepomp wordt gestuurd
int PowerStages = 9;                              // Number of useful steps in heatpump setpoint
// For rotary decoder
int pinCLK = 10;                                  // CLK of rotary encoder
int pinDT = 9;                                    // DT of  rotary encoder
int pinSwitch = 8;                                // Push button of rotary encoder to confirm setting
int encoderPosCount = 0;                          // Count position rotary encoder
int pinCLKLast;                                   // for rotary encoder
int aVal;                                         // for rotary encoder
bool bCW;                                         // Boolean Clockwise for rotary encoder
bool btnPressed = false;                          // Button of rotary switch pressed?
bool currentState = LOW;
const int LEDPin = 13;                            // Pin to activate LED
int TelegramCount = 0;                            // Follow-up number telegrams
volatile unsigned long Interval = 0;              // Time since last telegram
// Telegram timing 
unsigned long currentMicros = 0;                  // Storage current micro seconds
unsigned long previousMicros = 0;                 // Tracks the last pulse start time
const unsigned long SendInterval = 600000;        // Interval between pulses in microseconds 
byte data0[] = { 0x19, 0x0, 0x8, 0x0, 0x0, 0x0, 0xd9, 0xb5 };                             // Array of hexadecimal bytes for 1st message (last two butes are checksum)
byte data1[] = { 0x19, 0x1, 0x0c, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaa, 0x35 };        // Array of hexadecimal bytes for 2nd message (last two butes are checksum)
byte data2[] = { 0x19, 0x2, 0x8, 0x1, 0x1, 0x0, 0x99, 0x37 };                             // Array of hexadecimal bytes for 3rd message. This is the message to change bytes 4 (on/off) and 5 (power setpoint), and bytes 7 and 8 (checksum)
byte data3[] = { 0x19, 0x3, 0x8, 0xb2, 0x2, 0x0, 0xc1, 0x9a };                            // Array of hexadecimal bytes for 4th message (last two butes are checksum)
byte checksum1[] = { 0x9d, 0x99, 0xcc, 0xff, 0x66, 0x55, 0x00, 0x33, 0x23, 0x10, 0x45 };  //Array of 1st byte of checksum of 3rd message. First byte of the array is for 'off' and output '0', 2nd byte is for 'on' and putput '1' etc.
byte checksum2[] = { 0x36, 0x37, 0x64, 0x55, 0xc2, 0xf3, 0xa0, 0x91, 0xaf, 0x9e, 0xcd };  //Array of 2nd byte of presumed checksum. First byte of the array is for 'off' and output '0', 2nd byte is for 'on' and putput '1' etc.

void setup() {
  pinMode(LEDPin, OUTPUT);                        // Set the pulse pin as an output    

  // Rotary Encoder Setup
  pinMode(pinCLK, INPUT);
  pinMode(pinDT, INPUT);
  pinMode(pinSwitch, INPUT_PULLUP);
  pinCLKLast = digitalRead(pinCLK);               // Read Pin CLK, current pin state corresponds to latest position
  
  // Serial Setup
  Serial.begin(115200);                           // Start the Serial Monitor for debugging (Serial port 0)
  txOnly.begin(666);                              // Set-up software serial baurdrate for sending info to heat pump at 666 baud (pin 2)
  Serial.println("Setup complete...");
 }

void loop() {
// Send telegram
  currentMicros = micros();
  if (currentMicros - previousMicros >= SendInterval) {       // Start a new pulse if 500,000 µs have elapsed
    previousMicros = currentMicros;
    digitalWrite(LEDPin, HIGH);
        switch (TelegramCount) {
          case 0:                                             // Send message 0 (no changes)
            sendTelegram(data0, sizeof(data0), "Telegram 0");
            break;
          case 1:                                             // Send message 1 (no changes)
            sendTelegram(data1, sizeof(data1), "Telegram 1");
            break;
          case 2:                                             // Send and modify message 2 after modifiyng bytes 4, 5,7 and 8 according to the selected power setting
            if (PowerSetpoint > 0) {
              data2[3] = 0x1;
            } else {
              data2[3] = 0x0;
            }
            data2[4] = PowerSetpoint;
            data2[6] = checksum1[PowerSetpoint];
            data2[7] = checksum2[PowerSetpoint];
            sendTelegram(data2, sizeof(data2), "Telegram 2");
            break;
          case 3:                                             // Send message 3 (no changes)
            sendTelegram(data3, sizeof(data3), "Telegram 3");
            break;
          default:
            Serial.println("Invalid TelegramCount value");
            break;
        }
        TelegramCount = (TelegramCount + 1) % 4;              // Cycle through 0-3
        digitalWrite(LEDPin, LOW);
  }

// Check rotary encoder
   processRotaryEncoder();
}
////// End of main loop //////

// Below are the subroutines
void sendTelegram(byte *data, size_t size, const char *name) {
  for (size_t i = 0; i < size; i++) {
    txOnly.write(data[i]);
    if (i < size - 1) {
      }
  }
}

void processRotaryEncoder() {                                 // Read rotary decoder and write to screen
  int aVal = digitalRead(pinCLK);                
  if (aVal != pinCLKLast) {                                   // Knog is being turned
    // Determine direction of rotation by reading pin B
    bCW = (digitalRead(pinDT) != aVal);                       // This means that Pin A changed first --> clockwise rotation 
    encoderPosCount += bCW ? 1 : -1;                          // Otherwise Pin Bchanged first so counterclockwise rotation
    encoderPosCount = constrain(encoderPosCount, 0, PowerStages);
  }
  pinCLKLast = aVal;

  if (digitalRead(pinSwitch) == LOW && !btnPressed) {         // Button is pressed 
    btnPressed = true;
  } else if (digitalRead(pinSwitch) == HIGH && btnPressed) {  // Button is released 
    btnPressed = false;
    PowerSetpoint = encoderPosCount;
  }
}

[wybe-V]

Mooi om te zie dat je dit lukt en dat het werkt om op deze wijze de WP aan sturen
Ik zelf zou dit ook wil willen proberen en het aanpassen van de print is geen probleem maar met de Arduino Diecimila heb ik totaal geen ervaring
Is het misschien 🤔 een optie om dit als compleet setje aan te bieden tegen betaling en een extra vergoeding voor ontwikkeling
Dit alles natuurlijk wil op eigen risico 🤗😇🤔

[WackoH]

Oh, die Arduino Deicimila (een echte uit Italie, geen Chinese kloon) heb ik alleen maar voor de aardigheid genoemd. Ik heb het even nagekeken: Die heb ik in april 2008(!!) voor $33.50 bij Adafruit gekocht. Die is al lang niet meer verkrijgbaar

Welke microcontrollers je gebruikt is niet kritisch. Die van het Amerikaanse Atmel (tegenwoordig MicroChip) vormden de basis voor het Arduino ecosysteem (In de controlbox zitten trouwens twee ATmega8's, de lichtere versie van de ATmega168 in de Diecimila). Ik gebruik overigens voor het complexere programma een Arduino op basis van een ATmega2560 omdat die vier hardware seriele poorten heeft.

Tegenwoordig zijn microcontroller van het Chinese Espressif populair (ESP8266 en ESP32) omdat die wifi aan boord hebben en krachtiger zijn. Die hebben echter als nadeel dat ze met 3.3 V (ipv 5 zoals de bovnegenoemde Atmels) op de in en uitgangen werken. Ik denk dat die nog steeds de WP aan kunnen sturen want transistor T2 zit er tussen om de stroom naar optocoupler OK2 te versterken, maar inlezen van de data vereist een spanningsomzetter (kan een eenvoudige spanningsdeler met weerstanden zijn omdat de snelheden laag zijn).

Het beste installeer je de Arduino IDE want daarmee kun tientallen meer of minder complexe bordjes programmeren, en zoekt een courant microcontroller bordje, bv. de Arduino Uno. Het programmeren stelt echt niets voor. Ik was eerlijk niet van plan om geprogrammeerde bordjes rond te gaan sturen

[WackoH]

Het stookseizoen zit er bijna op. De warmtepomp heeft het grootste deel van de tijd prima gedraaid en vrijwel zonder gasverbruik (de laatste maanden helemaal niets). Maar dat ging niet vanzelf...

Sinds december heb ik flink wat tijd besteed om eerst te snappen hoe de communicatie tussen de buitenunit en de controlbox verloopt, en de communicatie tussen de microcontroller in de controlbox.

Ik had al snel een simpel programma in Arduino IDE dat ik op de bovengenoemde Diecimila draaide. Hiermee kon ik de snelheid (vermogen) van de Chofu buitenunit d.m.v. een rotary decoder instellen.

Vervolgens heb ik nagedacht wel kant ik op zou gaan. Er zijn namelijk verschillende richtingen:

1. De communicatie van en naar de warmtepomp met een eigen microcontroller afhandelen die het setpoint voor de aanvoertemperatuur via wifi van bv. Home Assistant krijgt. De elektronica van de controlbox dient alleen als hardware interface van en naar de warmtepomp.
2. Op een eigen microcontroller bordje zowel de OpenTherm communicatie als man-in-the-middle tussen ketel en thermostaat, als die met de warmtepomp afhandelen, en de controlbox alleen als hardware interface voor beide protocollen gebruiken.
3. Op zo’n manier in de communicatie naar de warmtepomp en tussen de microcontrollers in de controlbox ingrijpen dat de normale kamerthermostaat (Plugwise Smile + Anna) blijft werken, en bediening op afstand mogelijk is.

Optie 1 zou relatief makkelijk zijn, maar is voor mijn idee te kwetsbaar voor problemen met bv. Home Assistant; verwarming moet niet afhankelijk zijn van wifi etc. Optie 2 is de mooiste want dan geen last meer van de nukken van de controlbox. Er zijn meerdere Arduino IDE OpenTherm libraries die geschikt zijn voor verschillende microcontroller bordjes. (bv. https://reference.arduino...e/en/libraries/opentherm/). Maar om het niet al te complex te maken heb ik uiteindelijk optie 3 uitgewerkt.

Het concept heb ik in een eerdere post al uitgelegd. Hieronder staat een variant van de code zoals ik die nu op een Arduino Mega met een Atmel Mega2560 microcontroller gebruik. Het verschil met mijn eigenlijke code is dat ik alle schrijfacties naar een LCD met allerlei variabelen van warmtepomp en OpenTherm, eruit heb gehaald om de code compacter te houden en in plaats daarvan verschillende schrijfopdrachten naar de seriële poort gedaan (normaal gebruik ik die alleen voor foutmeldingen en troubleshooten). De code compileert, maar ik heb ‘m niet in het echt getest. Verder heb ik het gedrag op basis van buitentemperatuur (met name bij < -2.0oC alsnog CV inschakelen) bij gebrek aan juiste condities op het juiste moment, niet in de praktijk kunnen testen.
Tenslotte: Ik ben geen doorgewinterde programmeur, dus ik vergeef me als sommige zaken niet volgens het boekje zijn gedaan

Een paar algemene opmerkingen.

• Er wordt niets gedaan met foutmeldingen vanuit de warmtepomp. Dat kan de controlbox volgens de handleiding wel. Maar ik had geen zin om te proberen te achterhalen hoe dat allemaal is gedecodeerd. Het wordt vanzelf koud als er een probleem is...
• De code gebruik nu 7 standen van warmtepomp. Stand 8 geeft maar een klein beetje meer vermogensopname. De COP daalt met toenemend vermogen dus begrenzen tot 6 standen (als dat genoeg warmte voor het huis oplevert) geeft een beter rendement.
• De PID regelaar regelt conservatief als de afwijking tussen setpoint en aanvoertemperatuur minder dan 1oC is, en anders agressief. Dit voorkomt een overshoot omdat de Anna de gevraagde aanvoertemperatuur slechts binnen 0.2oC rond de gewenste kamertemperatuur regelt (in mijn geval tenminste).
• De optimale PID parameters zullen van de karakteristiek van je eigen systeemm afhangen
• Als er conservatief wordt geregeld, verandert het setpoint voor de WP niet sneller dan eens per 7 min. Dit op snel op en afschakelen van het vermogen te voorkomen
• Mijn programma heeft een watchdog timer op basis van een interrupt. Die heb ik er hier uitgelaten omdat die hardware specifiek is

Al deze instellingen zijn natuurlijk wijzigen.

Hier de code voor de besturing:

code:

/* 
Alternative control for the Atlantic Aurea heat pump, which based on the Chofu AEYC-0643XU-AT unit.
This is a sketch to control the power setting of a heat pump with an Arduino ATMega2560 and to modify communication inside the controlbox using 3 of the 4 hardware serial ports of this board. 
The original code shows various useful information like temperatures etc. on a 480*320 TFT LCD. This has been removed here to keep the code more compact.
Version 0.1Beta, JHN 19-03-2025 */

#include <QuickPID.h>                                   // Library for PID controller, see for documentation: https://github.com/Dlloydev/QuickPID

//Define variables and constants
  // General
  String MessageString = "";

  // For heat pump
  const uint8_t SpeedStages = 7;                        // Number of speed stages to be used (7 --> ~1400 W max)
  uint8_t SpeedSetpoint = 0;                            // Speed setpoint sent to heatpump   // const uint8_t MinTempSetpoint = 25;
  uint8_t TargetTemperatureThermostat = 20;             // Target temperature as requested by the thermostat   
  const float MinTemp4HP = -2;                          // Outside temperatute below wich heat pump should stop working and CV should start
  uint16_t TelegramCount = 0;                           // Follow-up number of telegrams
  // Variables to track timings
  uint32_t Interval = 0;                                // Time since last telegram
  uint32_t currentMillis = 0;                           // Check timing for sending messages
  uint32_t LastSpeedSetpointChange = 0;                 // Keep track when last time speedsetpint has been changed in milliseconds
  uint32_t SpeedSetpointHysteresis = 420000;            // Allow a change in speedsetpoint only once per 7 minutes (when using slow PID parameter set)
  // Cycle time check
  uint32_t previousCycleMicros = 0;                     // To store the time of the last cycle start
  uint32_t currentCycleMicros = 0;                      // To store the time of the current cycle start
  uint32_t cycleTime = 0;                               // To store the calculated cycle time
  uint16_t cycleCounter = 0;                            // Counter to track cycles
  const uint16_t displayInterval = 10000;               // Display cycle time every 10000 cycles
  uint8_t lcdUpdateStep = 0;                            // Variable to spread writing to screen over multiple steps
  // Receive and send inter MCU data 
  const uint32_t McuMessageWaitTime = 200;              // Waiting time between receiving message on Pad 1 (Serial 1) and sending on pad 2 (serial 2) in ms
  uint32_t McuMessageOneReceived = 0;                   // Tie last message send in ms
  bool dataMcu2Send = false;
  uint32_t PreviousMessageSerial2Sent = 0;   
  uint32_t MessageSerial2Interval = 10000;              // Maximum interval for sending message on serial 2 (to avoid that communication stops)
  const uint8_t DataMcuLength = 12;                     // Length of each transmission between MCU's
  uint8_t dataArrayOT_IC1_IC2[DataMcuLength] = {0};     // Array to store the incoming 12 bytes for OT IC1 to IC2.
  uint8_t dataArrayOT_IC2_IC1[DataMcuLength] = {0};     // Array to store the incoming 12 bytes for OT IC2 to IC1.
  uint8_t dataArrayOT_IC1_IC2_Old[DataMcuLength] = {0}; // Array to store the previous incoming 12 bytes for OT IC1 to IC2.
  uint8_t dataArrayOT_IC2_IC1_Old[DataMcuLength] = {0}; // Array to store the previous incoming 12 bytes for OT IC2 to IC1.  
  uint16_t ChecksumMCU = 0;                             // Checksum for communication between MCU's
// Variables for communication with heat pump
  uint8_t CB_HPlength = 0;                              // Length of communcation CB to HP
  uint16_t ChecksumCBHP = 0;                            // Checksum for communication of heat pump with control box
  uint8_t ChecksumCBHPfalseCount = 0;                   // Counter for number of times that the checksum did not match. After certain number of mismatches, message will be send to the serial port
  uint8_t data0[] = { 0x19, 0x0, 0x8, 0x0, 0x0, 0x0, 0xd9, 0xb5 };                       // Array of hexadecimal bytes
  uint8_t data1[] = { 0x19, 0x1, 0x0c, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaa, 0x35 };  // Array of hexadecimal bytes
  uint8_t data2[] = { 0x19, 0x2, 0x8, 0x1, 0x1, 0x0, 0x99, 0x37 };                       // Array of hexadecimal bytes. This is the one to change bytes 4 (on/off) and 5 (setpoint), and 7 and 8 (high and low bytes of the CRC CCITT checksum)
  uint8_t data3[] = { 0x19, 0x3, 0x8, 0xb2, 0x2, 0x0, 0xc1, 0x9a };                      // Array of hexadecimal bytes

// Variables for sending messages to heat pump
bool IncomingMessageEnded = 0;                          // Last message start time in milliseconds
volatile uint32_t PreviousMessageSent = 0;              // Time when prveious message was sent in milliseconds
volatile bool IsReceiving = false;                      // Tracks if message is being received from heat pump to block sending next message to heat pump
const uint32_t SendTimeout = 2000;                      // Time in milliseconds to wait before considering the communication ended
const uint32_t SendDelay = 99;                          // Delay in milliseconds before sending information to heatpump
const uint32_t MinMessageSendInterval  = 300;           // Minimum interval in millis between sending messages when no reply is received
volatile uint32_t previousMessageInEnded = 0;

// Definitions for reading and checking heat pump data
  // Prepare array for storing data from heatpump
    const uint8_t StartByte = 0x91;                     // First byte must be 145 (0x91)
    const uint8_t Rows = 4;                            // Number of rows in heat pump data array 
    const uint8_t Cols = 80;                            // Number of columns in heat pump data array 
    uint8_t numChars = 0;                               // Number of characters to be written to screen
    uint8_t dataHeatPumpTemp[Cols][Rows] = {0};         // Array to store of four messages from heatpump before checksum check
    uint8_t dataHeatPump[Cols][Rows] = {0};             // Array to store of four messages from heatpump after checksum is correct
    uint8_t dataHeatPumpOld[Cols][Rows] = {0};          // Array to store previous data of four messages so that screen is only updayted when needed
    uint8_t extractedRow[Cols];                         // 1D array to store the row  
    const uint8_t ValidLengths[] = {13, 14, 19, 21};    // Lengths 12, 13, 18 & 20   (12+1), (13+1), (18+1), (20+1)
    uint16_t value;                                     // Temporarily storage of datapoint from array
    float valuefloat;
    uint8_t Length = 0;
    float T_supply =0;                                  // Supply water temperature by heatpump
    float T_return =0;                                  // Return water temperature to heatpump
    float T_outside =0;                                 // Outside temperature measured on heatpump
  // State variables for non-blocking serial reading
    enum SerialState {  Wait_Start,                     // Waiting for the start of a serial message  
                        Read_Header,                    // Reading the header of the message  
                        Read_Payload,                   // Reading the main data (payload)  
                        Read_End                        // Reading the end of the message  
                        };                              // Enumeration type, which helps in defining different states of serial communication
    SerialState state = Wait_Start;                     // Make waiting to start the default
    uint8_t ID = 0;
    uint8_t msgLength = 0;
    uint8_t DataLength = 0;
    uint8_t buffer[Cols] = {0};                         // Temporary buffer for incoming data
    uint8_t index = 0;
    int8_t NegT = 0;                                    // Store if temperature is negative (value of 255 in MSB)
  // For PID controller 
    float TemperaturePIDsetpoint = 20;                  // Desired supply temperature
    const float TemperaturePIDsetpointMax = 37;         // Maximum temperature setpoint
    float TemperaturePIDinput = 0;                      // Current suppy temperature (feedback from the sensor in the heatpump)
    float TemperaturePIDoutput = 0;                     // Heat pump control signal
    float TemperaturePIDoutputRounded = 0;              // Heater control signal, rounded off
    // PID tuning parameter. Default values were Kp = 2.0, Ki = 5.0, Kd = 1.0
    uint8_t PIDParameterSet = 0;                        // Keep track of whcih PID parameters set is being used so that new parameter or only written when required
    float Sensitivity = 3;                              // Sensitivity (ratio) between the slow and fast PID settings. Optionally make this chnageable via rotary encoder
    float PIDParameterThreshold = 1;                    // Threshold for switch between fast (agressive) and slow (conservative) PID parameters
    float T_GapPIDParameterSwitch = 0;                  // Gap between the setpoint and actual temperature, used to determine which set PID parameters to use 
    const float Kp0 = 0.02, Ki0 = 0.008, Kd0 = 0.01;// 
    float Kp = Kp0, Ki = Ki0, Kd = Kd0;// 
// Create PID object
  QuickPID myPID(&TemperaturePIDinput, &TemperaturePIDoutput, &TemperaturePIDsetpoint, Kp, Ki, Kd, /* OPTIONS */
                myPID.pMode::pOnError,                   /* pOnError, pOnMeas, pOnErrorMeas */
                myPID.dMode::dOnMeas,                    /* dOnError, dOnMeas */
                myPID.iAwMode::iAwCondition,             /* iAwCondition, iAwClamp, iAwOff */
                myPID.Action::direct);                   /* direct, reverse */

void setup() {
// Serial Setup
  Serial.begin(115200);                                   // Start the Serial Monitor for debugging on terminal (Serial port 0)
  Serial1.begin(9600);                                    // Start serial port 1 for receiving messages from OT MCU to HP MCU (RX1, 9600 bps)
  Serial2.begin(9600);                                    // Start serial port 2 to receive messages from HP MCU and send modified message to OT MCU (RX2 pin & TX2 9600 bps)
  Serial3.begin(666);                                     // Start serial port 3 for sending an receiving info to heat pump at 666 baud (RX3 and TX3)
  Serial1.setTimeout(100);                                // Changes the timeout for readBytes() and other blocking serial read functions (readString(), readBytesUntil(), etc.).
  Serial2.setTimeout(100);
// For QuickPID
  myPID.SetOutputLimits(0, 99);                           // Set to max 99% to have max. 4 digits ('99.9')
  myPID.SetSampleTimeUs(5000000);                         // Sample time of PID controller in microseconds. Made slower than default because of relatively slow temperature changes and heat pump response to save processing time.
  myPID.SetTunings(Kp, Ki, Kd);
  myPID.SetMode(myPID.Control::automatic);                // Set PID controller in automatic, i.e. input (PV) is perdiodically compared with setpoint (SP) and control variable (CV) is adjusted 

  Serial.println("Setup complete.");
}

//////////////// Main loop ////////////
void loop() {
  currentMillis = millis();                                 // get curent millis (ms) for sending message to heat pump
  currentCycleMicros = micros();                            // Capture the current time (in us) to calculate the cycle time of the loop
  cycleCounter++;                                           // Increment the cycle counter
  
// Check for incoming data on Serial 1 (Pad 1 from MCU 2), 2 (Pad 2 from MCU 1) and Serial 3 (data from heat pump)
readSerialMessageHP();                                      // Call this function continuously to check for data on the incoming serial port from the heat pump
if (Serial1.available() >= DataMcuLength) {                 // Check whether the serial buffer connected to Pad 1 contains DataMcuLength (12) bytes or more  
  Serial.print("Serial1.available()"); Serial.println(Serial1.available()); 
  readSerialMessageMCU(1);                                  // When so, jump to subroutine to read the bytes or clear the buffer
  McuMessageOneReceived = currentMillis;                    // Set timestamp after receiving message on pad 1 (from MCU 2 to 1)
  dataMcu2Send = true;                                      // Set flag to send message on serial port 2
  TemperaturePIDsetpoint = 1 + 0.85 * dataArrayOT_IC2_IC1[0];// Scale the setpoint from the thermostat (0, and 30~40oC) to 25~37oC
  if (TemperaturePIDsetpoint > TemperaturePIDsetpointMax){
    TemperaturePIDsetpoint = TemperaturePIDsetpointMax;
    }
  }
if (Serial2.available() >= DataMcuLength) {                 // Check whether the serial buffer connected to Pad 2 contains DataMcuLength (12) bytes or more 
  Serial.print("Serial2.available()"); Serial.println(Serial2.available()); 
  readSerialMessageMCU(2);                                  // When so, jump to subrotuine to read the bytes or clear the buffer
  }

// Write modified message from MCU 1 to 2 on serial 2, McuMessageWaitTime (default 200 ms) after receiving message on serial 1 
if ((((currentMillis - McuMessageOneReceived) >= McuMessageWaitTime) && dataMcu2Send == true) || ((currentMillis-PreviousMessageSerial2Sent) > MessageSerial2Interval))  {
  Serial2.write(dataArrayOT_IC1_IC2, sizeof(dataArrayOT_IC1_IC2));    // Write array to serial port 2
  PreviousMessageSerial2Sent = currentMillis;
  dataMcu2Send = false;
  }

// Send the next message to the heat pump 100 ms after the previous incoming message has ended, or after 1000 ms without sending anything. Use the periodic sending also to update the screen
  currentMillis = millis();                                 // get curent millis (ms) for sending message to heat pump
    if ((( (currentMillis - previousMessageInEnded >= SendDelay)  &&  (!IsReceiving))  || ( currentMillis - previousMessageInEnded >= SendTimeout )) && (currentMillis - PreviousMessageSent >= ( MinMessageSendInterval ))) 
      {
      switch (TelegramCount) {
        case 0:
          Serial3.write(data0, sizeof(data0));
          break;
        case 1:
          Serial3.write(data1, sizeof(data1));
          break;
        case 2:
          SpeedSetpoint = (int)round( TemperaturePIDoutput / (100 / SpeedStages )) ;    // Scale the PID controller output from 0~100% to 0~8 speed setpoints, and convert from double to rounded integer
          if (SpeedSetpoint == 0) {
            data2[3] = 0x0;
            data2[4] = 0x0;
            } else {
              if ((PIDParameterSet == 0) && (currentMillis - LastSpeedSetpointChange > SpeedSetpointHysteresis)) { // Add hysteresis when slow PID parameter set is active
                data2[3] = 0x1;
                data2[4] = SpeedSetpoint;                 // Write calculate speed setpoint in array  
                LastSpeedSetpointChange = currentMillis;
                } else {
                  if ((PIDParameterSet > 0) && (currentMillis - LastSpeedSetpointChange > SpeedSetpointHysteresis/5)) 
                    { // Hysteresis 1/5 of default when fast PID parameter set is active to allow for fast respons
                    data2[3] = 0x1;
                    data2[4] = SpeedSetpoint;             // Write calculate speed setpoint in array  
                    }
                  }
              } 
          CB_HPlength = sizeof(data2);
          calculate_CRC_CCITT_Checksum(data2, CB_HPlength-2, &ChecksumCBHP);  
          data2[6] = (ChecksumCBHP >> 8) & 0xFF;          // Replace byte 6 with checksum High Byte
          data2[7] = ChecksumCBHP & 0xFF;                 // Replace byte 7 with checksum Low Byte
          Serial3.write(data2, sizeof(data2));
          break;
        case 3:
          Serial3.write(data3, sizeof(data3));
          break;
        default:
          Serial.print("Invalid TelegramCount value:  ");Serial.println(TelegramCount); 
          break;
        }
//        Serial.print("Message ");Serial.print(TelegramCount);Serial.println(" sent!");  // Confirm that message has bene sent
        TelegramCount = (TelegramCount + 1) % 4;          // Cycle through 0-3
        PreviousMessageSent = millis();
      }

   if (cycleCounter >= displayInterval) {
        if (previousCycleMicros != 0) {
          cycleTime = ( currentCycleMicros - previousCycleMicros ) / displayInterval;  // Time difference between cycles
          previousCycleMicros = currentCycleMicros;           // Update the previous cycle time
      cycleCounter = 0;                                   // Reset the cycle counter
      } else {
        previousCycleMicros = currentCycleMicros;
      }
    switch (lcdUpdateStep) {
      case 0:                                             // Print the cycle time etc. The timing for sneding message to the heatpump wil be oof when the cycle time is too long (> ~50 ms)
        Serial.println("Cycle time "+String(cycleTime)+" ms");
      break;
      case 1:                                             // Print PID settings
      break;
      case 2:                                             // Compresor speed 91-3,9
        if (dataHeatPump[9][3] != dataHeatPumpOld[9][3]) {  // Data has changed?
          Serial.print("Speed setpoint: "); Serial.println(dataHeatPump[9][3]);
          }
      break;
      case 3:                                             // Compresor power 91-3,10
        if (dataHeatPump[10][3] != dataHeatPumpOld[10][3]) {
          MessageString = String((25.6 * dataHeatPump[10][3]),0);
          Serial.print("Compressor power: "); Serial.println(MessageString);
          dataHeatPumpOld[10][3] = dataHeatPump[10][3];
          }
        // Compressor mode 91-1,3
        if (dataHeatPump[3][1] != dataHeatPumpOld[3][1]) {
          Serial.print("Compressor mode: "); Serial.println(dataHeatPump[3][1]);
          dataHeatPumpOld[3][1] = dataHeatPump[3][1];
          }
        // Defrost?   91-1,4
        if (dataHeatPump[4][1] != dataHeatPumpOld[4][1]) {
          Serial.print("Defrost ongoing? "); Serial.println(dataHeatPump[4][1]);
          dataHeatPumpOld[4][1] = dataHeatPump[4][1];
          }
      break;
      case 4:
        // ?Data? 91-3,5
        if (dataHeatPump[5][3] != dataHeatPumpOld[5][3]) {
          Serial.print("Generic info "); Serial.println(dataHeatPump[5][3]);
          dataHeatPumpOld[5][3] = dataHeatPump[5][3];
          } 
      break;
      case 5:                                             // Temperatures
        // Supply temperature   91-2,3~4
        if (dataHeatPump[3][2] != dataHeatPumpOld[3][2]) {
          value = dataHeatPump[4][2];                             // MSB of temperature; previous byte is the MSB
          T_supply = (((value*256+dataHeatPump[3][2])-(65536*((value == 255) ? 1 : 0)))/10.0);  // Do the conversion to temperature in such a way that also negative temperature can be shown
          TemperaturePIDinput = T_supply;                       // Make the input the PID controller equal to the current supply water temperature   
          MessageString = String(T_supply,1);
          Serial.print("Supply temperature "); Serial.println(MessageString);
          dataHeatPumpOld[3][2] = dataHeatPump[3][2];
        }
        // Return temperature 91-2,5~6
        if (dataHeatPump[5][2] != dataHeatPumpOld[5][2]) {
          value = dataHeatPump[6][2];               // MSB of temperature; previous byte is the MSB
          T_return = (((value*256+dataHeatPump[5][2])-(65536*((value == 255) ? 1 : 0)))/10.0);  // Do the conversion to temperature in such a way that also negative temperature can be shown
          MessageString = String(T_return,1);
          Serial.print("Return temperature "); Serial.println(MessageString);
          dataHeatPumpOld[5][2] = dataHeatPump[5][2];
        }
        break;
      case 6:
        // Outside temperature 282 91-2,7~8
        if (dataHeatPump[7][2] != dataHeatPumpOld[7][2]) {  
          value = dataHeatPump[8][2];               // MSB of temperature; previous byte is the MSB
          T_outside = (((value*256+dataHeatPump[7][2])-(65536*((value == 255) ? 1 : 0)))/10.0);  // Do the conversion to temperature in such a way that also negative temperature can be shown
          MessageString = String(T_outside,1);
          Serial.print("Outside temperature "); Serial.println(MessageString);
          }
 
      break;
      case 7:                                             // Do PID calculation
        // Evaluate PID calculation    
        T_GapPIDParameterSwitch = abs(TemperaturePIDsetpoint - TemperaturePIDinput);    // Check the gap between the temperature setpoint adn the actual temperature
        if ((T_GapPIDParameterSwitch < PIDParameterThreshold) && (PIDParameterSet = 1)) { // If the gap is smaller than the threshold and the PID controller is currently using the fast set, then
          Kp = Kp0; Ki = Ki0; Kd = Kd0;                       // Choose slow (conservative) settings
          myPID.SetTunings(Kp, Ki, Kd);                       // Write a new set of control parameter
          PIDParameterSet = 0;                                // Set parameter to default default (low) settings
          } else {
            if (PIDParameterSet = 1) {                          // Gap larger than threshold but slow parameters are used, then 
              Kp = Sensitivity*Kp0;                           // Choose fast or aggressive settings by larger gap
              Ki = Sensitivity*Ki0; 
              Kd = Sensitivity*Kd0;
              myPID.SetTunings(Kp, Ki, Kd);                   // Write a new set of control parameter
              PIDParameterSet = 1;                            // Set parameter to default default (low) settings
              }
            }
          break;
      case 8:                                             // Print inter MCU communication 
      break;
      case 9:
        TemperaturePIDoutputRounded = round(TemperaturePIDoutput*10.0)/10.0;
    }
    lcdUpdateStep = (lcdUpdateStep + 1) % 10;  // Cycle through screen updates
  }
}////////////// End of main loop  //////////////////////////

////////  Below are the subroutines //////////////////////
void readSerialMessageMCU(uint8_t MCU) {
uint8_t TempMcuData[DataMcuLength] = {0};
uint8_t TemperatureCategory;  // Variable to categorize temperature
  ////// Inter MCU communication
    switch (MCU) {
      case 1:          // 1. Communication IC2 (OT) to IC1 (HP): This communication is via PAD 1 and therefore used at serial 1. Check if enough data has arrived in the serial buffer and read it
        // for (int i = 0; i < DataMcuLength; i++) {
        //   TempMcuData[i] = Serial1.read();                 // Read the bytes into the array
        // }
        Serial1.readBytes(TempMcuData, DataMcuLength);        // Clean way of reading fixed number of bytes into array. Beware: Blocks execution until all bytes arrive or timeout (default timeout is 1000ms).
        calculateMCUChecksum(TempMcuData, DataMcuLength, ChecksumMCU);// Calculate and check the checksum by determining the sum of the first 11 bytes and taken modules 256
        if (ChecksumMCU == TempMcuData[DataMcuLength-1]) { // Check if the checksum matches
          // for (int i = 0; i < DataMcuLength; i++) {
          //   dataArrayOT_IC2_IC1[i] = TempMcuData[i];          
          //   }
          memcpy(dataArrayOT_IC2_IC1, TempMcuData, DataMcuLength); // Checksum OK so copy temp array to permanent array, cleaner and faster code than a loop  
          ChecksumMCU = false;                                // Make checksum false as start value for next time  
          } else {                                            // Checksum incorrect because communication possibly halfway received. 
              clearSerialBuffer(Serial1);                     // Clears the read buffer of serial 1 if the checksu was wrong to make a fresh start
              Serial.println("Serial buffer 1 cleared");
            }
      break;
      case 2:         // 2. Communication IC1 (HP) to IC2 (OT): This communication is via PAD 2 and therefore used at serial 2. Check if enough data has arrived in the serial buffer, read it, modify when required and resend
        Serial2.readBytes(TempMcuData, DataMcuLength);      // Clean way of reading fixed number of bytes into array. Beware: Blocks execution until all bytes arrive or timeout (default timeout is 1000ms).
        calculateMCUChecksum(TempMcuData, DataMcuLength, ChecksumMCU);// Calculate and check the checksum by determining the sum of the first 11 bytes and taken modules 256
        if (ChecksumMCU == TempMcuData[DataMcuLength-1]) { // Check if the checksum matches
          memcpy(dataArrayOT_IC1_IC2, TempMcuData, DataMcuLength); // Cleaner and faster code than a loop
          ChecksumMCU = false;                            // Make checksum false as start value for next time
          if (T_outside < MinTemp4HP) {
            TemperatureCategory = 0;                             // Too cold for heat pump, switch on cental heating
            } else if (T_outside < 4) {
              TemperatureCategory = 1;  // Below 4°C             // Prevent that controlbox starts CV 
              } else if (SpeedSetpoint == 0) {
                TemperatureCategory = 2;                         // SpeedSetpoint is zero
                } else {
                  TemperatureCategory = 3;                       // In all other cases use the temperature setpoint for water as read from Plugwise Anna via MCU2
                  }                 
          switch (TemperatureCategory) {
            case 0:                                     // Heat pump is not running because it is too cold so central heating should be started
              dataArrayOT_IC1_IC2[0] = 0xf0;
              break;
            case 1:                                     // Below 4°C but heat pump can run, adjust values to prevent central heating activation
              dataArrayOT_IC1_IC2[0] = dataArrayOT_IC2_IC1[0];
              dataArrayOT_IC1_IC2[9] = 0x04;
              dataArrayOT_IC1_IC2[4] = 0;               // Write 0's to force MCU2 to transfer HP temperature to OpenTherm 
              dataArrayOT_IC1_IC2[5] = 0;
              dataArrayOT_IC1_IC2[6] = 0;
              dataArrayOT_IC1_IC2[10] = 0;
              break;
              case 2:                                     // Heat pump is not running (Speedsetpoint  is zero), then let central heating boiler temperatures go to OpenTherm
              break;
              case 3:                                     // In all other cases use the temperature setpoint for water as read from Plugwise Anna via MCU2
                dataArrayOT_IC1_IC2[0] = dataArrayOT_IC2_IC1[0];
                dataArrayOT_IC1_IC2[4] = 0;             // Write 0's to force MCU2 to transfer HP temperature to OpenTherm 
                dataArrayOT_IC1_IC2[5] = 0;
                dataArrayOT_IC1_IC2[6] = 0;
                dataArrayOT_IC1_IC2[10] = 0; 
              break;
            }
            dataArrayOT_IC1_IC2[7] = round(T_supply);     // Write the actual outside temperature in the array. Will not work for temperatures below zero because array is 8 bits unsigned!
            dataArrayOT_IC1_IC2[8] = round(T_return);     //
            dataArrayOT_IC1_IC2[9] = round(T_outside);    // Write the actual outside temperature in the array. Will not wok for temperatures below zero because array is 8 bits unsigned!
            // Serial.print("T_supply: ");Serial.print(T_supply)     
            // Serial.print("T_return: ");Serial.print(T_return)
            // Serial.print("T_outside: ");Serial.print(T_outside)       
            calculateMCUChecksum(dataArrayOT_IC1_IC2, DataMcuLength, ChecksumMCU);// Recalculate the checksum
            dataArrayOT_IC1_IC2[11] = round(ChecksumMCU); // Replace old checksum value with new calculated one
            } else {                                      // Checksum incorrect because communication possibly halfway received. 
              clearSerialBuffer(Serial2);                 // Clears the read buffer of serial 2 if the checksu was wrong to make a fresh start
              Serial.println("Serial buffer 2 cleared");
              }
      break; 
    }
  }

void clearSerialBuffer(HardwareSerial &serialPort) {  
  while (serialPort.available() > 0) {
    serialPort.read();                                  // Read and discard the data in the buffer
  }
}

void calculateMCUChecksum(uint8_t dataArray[], int Length, unsigned int &checksum) {  // Calculate the checksum by determining the sum of the first 11 bytes and then take modules 256
  checksum = 0; // Initialize the checksum
      if (Length <= 1) {    // Ensure length is valid
        checksum = 0;
        return;
    }
    // Calculate the checksum for the first (Length-1) bytes in the specified row
    for (int i = 0; i < Length - 1; i++) {
        checksum += dataArray[i];
    }
    checksum %= 256;                                        // Modulus 256 to keep it in a single byte
}

// Function to calculate the CRC-CCITT (0xFFFF) checksum for the communication to and from the heat pump
void calculate_CRC_CCITT_Checksum(uint8_t *data, uint8_t Length, uint16_t *checksum) {
    uint16_t crc = 0xFFFF; // Initial value
    for (uint8_t i = 0; i < Length; i++) {
        crc ^= (uint16_t)data[i] << 8;
        for (uint8_t j = 0; j < 8; j++) {
            if (crc & 0x8000) {
                crc = (crc << 1) ^ 0x1021;
            } else {
                crc <<= 1;
            }
        }
    }
    *checksum = crc;
}

// Function that reads the serial data coming from the heat pump
void readSerialMessageHP() {
    while (Serial3.available()) {  // Check if data is available on Serial3
      IsReceiving = true;
      uint8_t byteReceived = Serial3.read();
       // Serial.print(String(byteReceived,DEC)+" ");
      IsReceiving = true;
        switch (state) {
            case Wait_Start:                            // Code to wait for the start character
                if (byteReceived == StartByte) {
                    state = Read_Header;
                    index = 0;
                    IncomingMessageEnded = false; // Reset if any other byte is received to indicate
                }
                break;
            case Read_Header:                           // Code to process header bytes
                if (index == 0) {
                    ID = byteReceived;
                    if (ID > 3) {  // ID must be 0-3
                        Serial.println("Invalid ID, resetting...");
                        state = Wait_Start;
                        return;
                    }
                } else if (index == 1) {
                    msgLength = byteReceived+1;
                    if (!IsValidLength(msgLength)) {
                        Serial.println("Invalid Length! Resetting...");
                        state = Wait_Start;  // Reset
                        return;
                    }
                    DataLength = msgLength - 3;  // Exclude first 3 bytes and last byte
                    index = 0;
                    state = Read_Payload;
                }
                index++;
                break;

            case Read_Payload:                          // Code to process data payload
                buffer[index++] = byteReceived;
                if (index >= DataLength) {
                    state = Read_End;
                }
                break;

            case Read_End:                              // Code to check that last byte of message corresponds to '0'
                if (byteReceived == 0) {  // Ensure last byte is 0
                    StoreMessage(ID, DataLength, buffer);
                    IncomingMessageEnded = true;                          // If the end of the incoming message is reached, set the infication boolean
                    previousMessageInEnded = millis();                    // Set timestamp after receiving end of incoming message             
                } else {
                    Serial.println("Warning: Last byte is not 0! Resetting...");
                }
                IsReceiving = false;
                state = Wait_Start;                                     // Reset for next message
                break;
                default:
                Serial.println("Error in readSerialMessageHP state"); 
                break;
        }
    }
}

// Function to check if the Length is valid
bool IsValidLength(uint8_t Length) {
    for (uint8_t i = 0; i < sizeof(ValidLengths) / sizeof(ValidLengths[0]); i++) {
        if (Length == ValidLengths[i]) return true;
    }
    return false;
}

// Function to store messages in separate arrays based on ID
void StoreMessage(uint8_t ID, uint8_t DataLength, uint8_t *message) {
    for (uint8_t i = 0; i < (DataLength); i++) {
      dataHeatPumpTemp[i+2][ID] = message[i];
      }
    dataHeatPumpTemp[0][ID] = StartByte;
    dataHeatPumpTemp[1][ID] = ID;
    dataHeatPumpTemp[2][ID] = DataLength+2; // 12, 13, 18, 20
     for (int j = 0; j < DataLength+2; j++) {                                  // Copy row 
       extractedRow[j] = dataHeatPumpTemp[j][ID];  
       } 
    calculate_CRC_CCITT_Checksum(extractedRow, DataLength+2, &ChecksumCBHP);   // Calculate checksum, including the two checksum bytes --> result will be zero if mesage has been sent error free
    if (ChecksumCBHP == 0) {                                                   // Check that result is indeed zero
      memcpy(dataHeatPump[ID], dataHeatPumpTemp[ID], Cols * sizeof(uint8_t));  // Transfer the temporarily array to the permanent array
      ChecksumCBHPfalseCount = 0; 
      Serial.println("Checksum heat pump data received not OK");               // Print a message if there is an error     
      } else {
        ChecksumCBHPfalseCount++;                                              // Increase counter for false checksums. Nog actie bedebken als threshold wordt bereikt
        Serial.print("Checksum error! ");                                      // Print a message if there is an error
        Serial.print("Now ");Serial.print(ChecksumCBHPfalseCount);Serial.print(" Checksum errors (of max 10) counted!");
        }
}

Verder heb ik een eenvoudige quick & dirty control box simulator van slechts 30 [edit: 55 regels. Ik heb simulate van MCU communicatie ook toegevoegd (met iets meer onderling verschil dan in het echt, nl. 480 vs. 200 ms] om het programma offline op de hardware te kunnen testen:

code:

/* Test program for serial communication related to Atlantic Aurea 
Hardware connections:
  Serial connections:
    Serial port 0: Monitoring and troubleshooting to USB port
    Serial port 1 (Orange): Connect Pin 19 (Rx1) to Pad 1: Receiving messages from OT MCU to HP MCU (9600 bps). This to extract thermostat setpoint     
    Serial port 2 (Brown/white): Connect Pin 16 & 17 (Tx2 (brown)& Rx2(white)) to Pad 2. Receive messages from HP MCU and send modified message to OT MCU (9600 bps)
    Serial port 3 (Connect: Pin 14 & optionally 15 (Tx3 & Rx3) (Green): Send messages with requested power to heatpump and optionally receive messages from HP for monitoring purposes and  (666 bps)
*/

//Define variables and constants
// Make pulse 
const uint32_t MessageSerialMCUInterval = 4200;                   // Interval for mesages send in between MCU (add delay for sending othr data)
uint32_t currentMillis = 0;                                       // Check timing for sending messages
uint32_t PreviousMessageSerial1Sent = 0;                        
bool SendSerial2 = false;

// Variables to receive inter MCU data
byte dataArrayOT_IC2_IC1[] = {44,20,154,0,0,33,14,32,29,8,0,78};  // Array for testing communication picked up at Pad 1 on PCB
byte dataArrayOT_IC1_IC2[] = {37,20,154,0,0,33,14,32,29,2,0,65};  // Array for testing communication picked up at Pad 2 on PCB

// Example of data send from heatpump to control box
byte dataHeatPump0[] = {25,0,8,0,0,0,217,181,         145,0,12,13,7,4,47,90,206,225,230,223,0};                       // Length 12
byte dataHeatPump1[] = {25,1,12,0,0,0,0,0,0,0,170,53, 145,1,13,80,0,0,0,0,0,138,82,164,39,0};                         // Length 13
byte dataHeatPump2[] = {25,2,8,1,5,0,85,243,          145,2,18,18,1,253,0,49,0,1,0,2,0,0,38,216,23,240,0};            // Length 18 
byte dataHeatPump3[] = {25,3,8,178,2,0,193,154,       145,3,20,120,81,168,151,21,0,83,53,2,0,24,0,0,0,0,233,241,0};   // Length 20

void setup() {
  // Serial Setup
  Serial1.begin(9600);                          // Start serial port 1 for receiving messages from OT MCU to HP MCU (9600 bps)
  Serial2.begin(9600);                          // Start serial port 2 to receive messages from HP MCU and send modified message to OT MCU (9600 bps)
  Serial3.begin(666);                           // Start serial port 3 for sending an receiving info to heat pump at 666 baud (pin 16)
  Serial.println("Setup complete.");
}

void loop() {
currentMillis = millis();                                 // get curent millis (ms) for sending message in between MCU's
if (currentMillis-PreviousMessageSerial1Sent > MessageSerialMCUInterval)  {
  Serial1.write(dataArrayOT_IC1_IC2, sizeof(dataArrayOT_IC1_IC2));    // Write array to serial port 1
  PreviousMessageSerial1Sent = currentMillis;
    SendSerial2 = true;
  }

Serial3.write(dataHeatPump0,sizeof(dataHeatPump0));
  delay(412);
if (SendSerial2)  {
  Serial2.write(dataArrayOT_IC1_IC2, sizeof(dataArrayOT_IC1_IC2));    // Write array to serial port 2
  SendSerial2 = false;
  }
Serial3.write(dataHeatPump1, sizeof(dataHeatPump1));
  delay(487);
Serial3.write(dataHeatPump2,sizeof(dataHeatPump2));
  delay(502);
Serial3.write(dataHeatPump3,sizeof(dataHeatPump3));
  delay(531);
}

Aan de hardware kant zij verder ook nog verbeteringen denkbaar. De belangrijkste die medetweakers ook noemden zijn:

• Een of twee relais gebruiken die in onbekrachtigde toestand de oorspronkelijke situatie herstellen
• De communicatie op de print aftappen door met tussenvoetjes bij de IC’s te werken. Zo zijn wijzigingen op de print niet nodig (in het geval van optie 1 en 2 hoeft dat zelfs niet want dan kunnen de microcontrollers worden verwijderd!)
• Toevoegen van een flowmeter om de COP te kunnen berekenen.

Hier een foto van het display in actie:


Dan nog de potlood schets van het relevante deel van de print (ik was van plan dit netjes met een tool uit te tekenen, maar had geen zin in de leercurve voor deze ene keer). Het stukje rechts op de print waar twee relais zitten, ontbreekt grotendeels want dat stuk had ik niet nodig:


En tenslotte waar het om gaat: Een paar mooie trends (ik log alles wel in Home Assistant; thermostaat stond op 20.5oC, en om 23:40 naar 19.5oC):

Doeltemperatuur woonkamer:


Doeltemperatuur aanvoer:


Opgenomen vermogen:


Temperatuur aanvoer (als de WP uit is, wordt afwisseld ook de CV (sanitair water) aanvoer getoond):


Temperatuur return (idem):


Het is hoogste tijd voor andere projecten

[ Voor 102% gewijzigd door WackoH op 21-03-2025 23:19 ]

[Grannetia]

Ha Jacco,
ik zat nog eens aandachtig naar je programma te kijken. Grote klasse weer hoor! Ik vroeg mij alleen nog af: is het juist opgemerkt dat niet alleen de communicatie bij R14 van de controlbox moet worden onderbroken, maar ook de communicatie van de aurea mcu naar de ot mcu bij pad 1? Zo ja, mag ik dan vragen hoe/waar je dat gedaan hebt? en heb je verder nog weerstanden moeten toevoegen om de communicatie aan alle kanten te laten slagen?
Bedankt weer! en veel plezier met de volgende uitdaging

edit: Misschien moet pad 2 ook wel ontkoppelt, anders zal de ot mcu mogelijk tegenstrijdige berichten ontvangen. Is het niet?

[ Voor 11% gewijzigd door Grannetia op 23-03-2025 16:14 . Reden: aangepaste veronderstelling ]

[WackoH]

Klopt. Schematisch heb ik het hier weergegeven: WackoH in "Aurea 5 hybrid: interfaces met de buitenunit en thermostaat"

- R14 van1 kOhm tussen IC4 (microcontroller voor de warmtepomp) en T2 heb ik aan de bovenkant losgemaakt.
- Op het vrijgekomen gaatje heb ik TX3 van de ATmega2560 via een nieuwe 1kOhm weerstand (op T2 dus) aangesloten
- Via het losse pootje van R14 kan ik eventueel uitlezen wat IC4 naar de warmtepomp zou willen sturen. De weerstand beschermt IC dan tegen bv. per ongeluk kortsluiting maken

Het is inderdaad essentieel om de verbinding tussen IC4 en IC2 die langs Pad 2 loopt, te onderbreken als je hier een nieuw signaal op in wilt voeden, want anders bestaat het risico dat de uitgang van IC4 kapot gaat. Dat zou niet best zijn.
Ik heb dat gedaan door het printspoor tussen IC4 en Pad 2 door te snijden (alternatief is via met ene tussenvoetje werken, of het betreffende pootje uit het voetje te houden en er een draadje aan te solderen). Vervolgens heb ik op het printspoor tussen IC4 en de onderbreking een draadje gesoldeerd. Zo ook in pad2.
Enerzijds kan ik zo de oorspronkelijke situatie herstellen door beide draadjes te verbinden. Maar ik heb nu de uitgang van IC4 via een 1kOhm weerstand met de RX2, en Pad 2 met TX2 van de ATmega2560, verbonden.

Hieronder nog twee foto's die het hopelijk wat duidelijker te maken. Ja, heeft hoog prototype gehalte Het handige van het breadboardje is dat ik gemakkelijk een logic analyzer en serial naar USB omzetter aan kan sluiten.



PS: In eerdere berichten en code heb ik het over IC1 (WP / HP). Dat is op printplaat echter IC4.

[ Voor 4% gewijzigd door WackoH op 25-03-2025 00:10 ]

[P1 modubus]

Goedendag De Flowmeter is geïnstalleerd. eenmaal even kunnen meten was toen 10.9 ltr/min




Plaatje is ook klaar nu moet de WP nog draaien, helaas na het installeren van de flowmeter gaf de Anna weer niet thuis kreeg geen verbinding met de Smile, weer alles opnieuw geïnstalleerd na aantal malen geprobeerd te hebben weer contact, nu gaf deze weer geen stookwens naar de WP, kamer temp. 23 grd gevraagd, weer verlaagd na tijdje weer verhoogd en zo gelaten, cv ketel maar even handmatig aangezet Vanmorgen was het warm, gezien dat de WP om 23.05 uur inkwam en niet meer uitgegaan was, 22 grd kamer. Namiddag weer aangezet de Anna vragend gezet 23 grd. maar komt niet in wel 22 grd. in de kamer, testfase natuurlijk, wil het middags hoger stoken i.v.m. zonne-energie, avonds uit omdat de vloer opgewarmd is, kan normaal WP uit tot volgende dag, middags dan weer het zelfde verhaal,
het moet toch kunnen zonder veel aanpassingen dit geregeld te krijgen, ben wel meet en regel man maar kan niet zoals hierboven de print met software aanpassen.

Vind optie 3 ook het beste alles zoveel mogelijk origineel laten, de echtgenote moet ook simpel verder kunnen mocht ik plotseling wegvallen, alles zo gemaakt dat het dan naar de originele status gaat,

De buitentemperatuur beïnvloeding van 4 grd, is schakelend gemaakt zodat de WP de circulatiepomp niet onnodig laat draaien, en bij lage buitentemperatuur toch inkomt, maar niet bevriezen kan, bij hogere buitentemperatuur dit weer normaal zet, dan is dat toch overbodig en werkt alles normaal

De vraag aan de cv Ketel doorgezet naar de testknop dit kan ook gemonitord worden met telwerk en tijd als dit nodig zou zijn, kan ook nog gestart worden zonder cv ketel vraag, maar moet wel vanuit de Smile warmte gevraagd worden, helaas is dit nu niet het geval.

Net weer een mail naar Plugwise gestuurd, hop een een positief bericht, de Anna/ Smile is een mooi systeem als het werkt, alleen is dit niet vaak het geval, in het begin deed als het prima, maar nu een en al problemen, jammer toch begrijp niet dat het niet eenvoudig geregeld kan worden, en jullie er zoveel aan moeten passen zodat de WP naar wens draait.

Heeft iemand de originele uitgebreide printplaat getest of geïnstalleerd met modbus aansluiting.?
Weet niet wat er dan nodig aan aanpassingen nodig zijn en of dit nu nog kan.
Heb reeds de hamer klaar liggen.

[WackoH]

P1 modubus schreef op dinsdag 25 maart 2025 @ 15:02:
[Afbeelding]
Heb reeds de hamer klaar liggen.

Haha, herkenbaar

Zelf heb ik de aanschaf van een flowmeter toch even geparkeerd. Ik ben namelijk vooral in de relative COP geïnteresseerd. Dus of de COP beter is bij lagere vermogens dan bij hogere. Als ik er van uit ga dat het debiet nauwelijks verandert, kan ik een aanname over het debiet doen en constant houden. Dan hoef ik alleen met de gemeten temperaturen en vermogen te werken.

Ik heb die berekening aan de software toegevoegd en met 9 kg/min krijg ik ene relatische waarde (niet perse de juiste) dat komt redelijk goed overeen met de kleine 11 die jij hebt gemeten) heb ik realistische COP waardes van bv. 4.0.

Wat me bij Plugwise opvalt, is dat de Opentherm communicatie tussen controlbox en ketel na inschakelen vaak niet goed op gang komt. Wat ik doen is de Homewizard Heatlink die in de lijn zit, even aanzetten. Die strijkt dan op de een van andere manier de rimpels glad en de communicatie is daarna goed. Misschien helpt een keertje reset in de controlbox drukken ook wel.

[_JGC_]

@WackoH Ik overweeg om dit ding tweedehands of mogelijk nieuw te kopen. Deze warmtepomp kost geen drol (1300 nieuw, 750 tweedehands) en ik heb aan 5KW meer dan voldoende. Met behulp van dit topic moet dat ding all-electric te maken zijn lijkt me.

Begrijp ik nou goed dat je 1 van de beide controllers in de box compleet buitenspel zet en zelf tussen de OpenTherm controller en de warmtepomp controller gaat zitten?

[WackoH]

Ja daar komt het eigenlijk wel op neer.

Het is een projectje wat is gegroeid in de tijd. De reden voor deze opzet is dat ik de functionaliteit van de Plugwise omgeving zoveel mogelijk wilde behouden. Vandaar dat de warmtepomp microcontroller nog wel mee mag doen om WP data aan Opentherm door te geven.

Met de kennis van nu zou ik beide microcontroller buiten spel zetten en alleen maar de delen uit de controlbox gebruiken die de spanningsomzetting voor de communicatie doen (dus zowel naar de WP als naar Opentherm).
Want het lijkt eigenlijk niet zo ingewikkeld om Opentherm communicatie in een microcontroller te zetten; daar zijn verschillende bibliotheken voor.
En dan eventueel nog communicatie met bv. HomeAssistant over WiFi toevoegen om meer data uit te lezen en eventueel te sturen.

Want ik nog niet weet, is hoe de foutcodes van de WP uit lezen. De controlbox kan dat wel (de rode LED gaat dan knipperen) maar ik heb het nog niet aangedurfd om fouten bewust op te wekken (door bv. stekkertjes van sensoren los te trekken) terwijl de communicatie wordt gemonitord.
Maar goed, als de WP het niet doet, merk je dat vanzelf wel. En dan is de foutcode op de WP zelf af te lezen.

[_JGC_]

@WackoH Ik heb eigenlijk geen behoefte aan OpenTherm of plugwise. Heb nu een DIYLESS Thermostat2, die stuurt temperaturen naar de ketel en ketel doet altijd 6KW. Soms gaat alleen de pomp aan omdat de overshoot van de vorige stooksessie nog boven de vraag ligt. 3 minuten water uit de vloer in de berging door de radiatoren pompen zonder stoken en vervolgens gaat de ketel weer uit.

Verwacht dat ik met jouw tekeningen en voorbeeldcode de hele thermostaatregeling wel over durf te nemen, mogelijk kan die code ook gewoon op de DIYLESS draaien.

[ThinkPad]

@WackoH Heb je AI al eens om hulp gevraagd voor het reverse engineeren? Ik heb gemerkt dat bijv. Claude AI goed is in code. Niet lullig bedoeld overigens, prima uitzoekwerk gedaan Maar juist als je al een 'haakje' hebt en dat voert aan AI dan kan deze je soms prima verder helpen om de laatste vraagtekens voor je op te lossen.

[WackoH]

Jazeker heb ik AI gebruikt, maar dan voornamelijk voor:

• Indentificeren van de versleutelingsprotocollen (dat lukte bij de communcaitie tussen beide microntroller wel, tussen warmtepomp en controlbox niet. Voor dat laatste heeft een medetweaker me op het goede spoor gezet).
• Maken van code voor de subroutines

Zonder AI had het me met name dat laatste veel meer tijd gekost, en (nog) slechtere code opgeleverd.

Waar ik het niet voor heb gebruikt is patroonherkenning om meer parameters te identificeren die de WP uitstuurt. Dat zou leuke extra info opleveren en zou ik nog wel eens kunnen proberen.

Over die foutcodes: Ook AI kan geen foutcodes herkennen als die er niet zijn. (of komt misschien juist met een fout antwoord). Het werk zit niet in het indentificeren van de foutcodes, maar in het uitlokken. Daarbij kan in theorie ook iets kapot gaan. Dus dat doe ik maar liever niet.

Als ik trouwens nu ChatGPT vraag hoe de Chofu warmtepomp met de controller communiceert, komt eerst dat het via Modbus gaat.
Als ik zeg dat dat niet klopt, komt dit:

Ik ben door ChatGPT gecyborgd!
Laat ik het maar al compliment beschouwen
Er is een bronverwijzing naar het draadje in Tweakers, dus da's wel netjes.

[ Voor 3% gewijzigd door WackoH op 09-08-2025 20:38 ]

[WackoH]

@_JGC_ Als je de 'intelligentie' van de controlbox helemaal niet nodig hebt, is het makkelijkste om de linker microcontroller (IC1) uit z'n voetje te halen en dan via het lege voetje op een of ander manier een verbinding met de seriele send (pin 26) en de receive (pin 27) naar de buitenunit te maken.
Die werken op 5V, dus met een moderne microcontroller is het verstandig een level shifter naar 3.3V toe te voegen.
Zo houd je het veilig. Ik weet niet precies welke spanningen naar de buitenunit gaan. Maar er is een link met netspanning, dus daar wil je ver van wegblijven.

En je kunt de buitenunit dus ook laten koelen:
0 = uit, 1 = verwarmen en 2 = koelen.

[_JGC_]

Ding opgehaald vandaag. Verkoper (installateur) deed me even uit de doeken hoe koud het was afgelopen winter want regeling was heel slecht en ketel werd vaak ook niet aangestuurd.
Toen ik 'm vertelde dat ik de chipjes ging wippen en de thermostaten niet gebruik maar de machine zelf aanstuur keek ie alsof ie water zag branden.

Zitten overigens de meest recente firmware chipjes in want Atlantic is af en aan geweest om dingen te testen.

[WackoH]

Dan snap ik niet waarom ze het niet beter werkend hebben gekregen. In essentie is de combinatie Chofu / Atlantic / Plugwise namelijk niet slecht, hooguit wat gedateerd.

Atlantic had meer rekening moeten houden met:

• De eigenschappen van de buitenunit. Die draait de eerst 20 min na een (eerste) start bij koud weer op ~400 W. Tja, dan ga je natuurlijk niet snel een aanvoersetpoint halen, al helemaal niet als een vloer de warmte opzuigt. Dit vermogen komt gewoon binnen, dus was kleine moeite geweest dit mee te nemen.
• Waarom mensen een WP kopen. Nl. om gas te sparen, voor klimaat of portemonnee. Dus niet zo snel naar CV schakelen en tot lagere buitentemperaturen doordraaien .

Wat ik heb gedaan heeft natuurlijk hoog hobby/prototype gehalte.
Een plug en play oplossing waar veel mensen mee geholpen zouden zijn, is een open source projectje met:

• Een printje dat in plaats van beide microcontrollers komt (dus in de bestaande voetjes prikt).
• Daarop zit dan een microcontroller met Wifi voor OtA updates en integratie met bv. Home Assistant.
• Wat dipswitches om bepaald gedrag in te stellen (voor degene die geen HA op willen tuigen):
• - Via Plugwise (OpenTherm) of HA aansturen (dan ook koelen mogelijk)
• - Tot welke buitentemperatuur moet de WP blijven werken (4,1, -2, altijd)
• - Modus om omschakelen naar CV te bepalen: Eco (altijd WP) of comfort (een beetje zoals nu).
• - Regelstrategie (radiatoren, vloer, beide)
• - Mag maximaal vermogen of moet tandje minder (=hogere COP)
• - Er is vast nog meer te bedenken

Helaas heb ik er geen tijd voor.

[_JGC_]

@WackoH Het ding is verkocht als universele aanvulling op je ketel. Meneer had een pompverdeler, die doet niks met 35 graden, dus schakelt continu je ketel in want je huis wordt koud.
Hij draait nu full electric en heeft nog steeds de pompverdeler... iets met dwarse installateurs die doen wat ze altijd doen. Heb hem verteld dat ie die pompverdeler zsm moest lozen. Hij gaf de schuld aan de bypass.

Wat ik voor komende winter ga doen is een Arduino Uno kopen met een Ethernet shield. Die hang ik met CAT5 in mijn netwerk. De ketel stel ik in als HR Solo Tap en de thermostaat laat ik hangen. Thermostaat vraagt een setpoint aan de ketel en de ketel negeert 'm volkomen, maar ondertussen vis ik via MQTT de aanvoer uit de thermostaat en stuur ik die door naar de controller. Als thermostaat afschakelt omdat temperatuur bereikt is laat ik de warmtepomp op laagste vermogen doordraaien.

Ik heb nog gekeken naar OpenTherm Slave, maar de meeste sturingen gaan over master mode (thermostaat), ik weet niet wat ik allemaal moet implementeren om een werkende aansturing met OpenTherm te krijgen.
Kan evt altijd nog de opentherm pinnen uit de tweede socket aan de Uno hangen en OpenTherm implementeren. Dat wordt project voor volgend jaar als er een boilervat en driewegklep komt en de ketel verdwijnt.

Edit: misschien toch maar een 3/5V logic shifter aanschaffen en een Wemos d1 kloon toepassen die ik nog heb. Arduino Uno is wel heel basic zie ik.

[ Voor 5% gewijzigd door _JGC_ op 11-08-2025 18:47 ]

[mhr-zip]

_JGC_ schreef op maandag 11 augustus 2025 @ 18:33:
@WackoH Het ding is verkocht als universele aanvulling op je ketel. Meneer had een pompverdeler, die doet niks met 35 graden, dus schakelt continu je ketel in want je huis wordt koud.
Hij draait nu full electric en heeft nog steeds de pompverdeler... iets met dwarse installateurs die doen wat ze altijd doen. Heb hem verteld dat ie die pompverdeler zsm moest lozen. Hij gaf de schuld aan de bypass.

Wat ik voor komende winter ga doen is een Arduino Uno kopen met een Ethernet shield. Die hang ik met CAT5 in mijn netwerk. De ketel stel ik in als HR Solo Tap en de thermostaat laat ik hangen. Thermostaat vraagt een setpoint aan de ketel en de ketel negeert 'm volkomen, maar ondertussen vis ik via MQTT de aanvoer uit de thermostaat en stuur ik die door naar de controller. Als thermostaat afschakelt omdat temperatuur bereikt is laat ik de warmtepomp op laagste vermogen doordraaien.

Ik heb nog gekeken naar OpenTherm Slave, maar de meeste sturingen gaan over master mode (thermostaat), ik weet niet wat ik allemaal moet implementeren om een werkende aansturing met OpenTherm te krijgen.
Kan evt altijd nog de opentherm pinnen uit de tweede socket aan de Uno hangen en OpenTherm implementeren. Dat wordt project voor volgend jaar als er een boilervat en driewegklep komt en de ketel verdwijnt.

Edit: misschien toch maar een 3/5V logic shifter aanschaffen en een Wemos d1 kloon toepassen die ik nog heb. Arduino Uno is wel heel basic zie ik.

Het is niet alleen bij die verkoper of dat hij water zag branden.

[_JGC_]

mhr-zip schreef op maandag 11 augustus 2025 @ 19:22:
[...]


Het is niet alleen bij die verkoper of dat hij water zag branden.

Mijn zwager is ook installateur die vanuit de CV ketels de wereld van de warmtepompen is ingerold. Die heeft dus ook dit ding en was altijd van mening dat warmtepompen waardeloos waren en we na 2050 nog gas stoken, want "onder de 5 graden doen ze niks". Heeft ook al vanalles aan zijn installatie verbouwd om het rendement beter te krijgen, maar zet geen zoden aan de dijk.

[WackoH]

_JGC_ schreef op maandag 11 augustus 2025 @ 18:33:
@WackoH Het ding is verkocht als universele aanvulling op je ketel. Meneer had een pompverdeler, die doet niks met 35 graden, dus schakelt continu je ketel in want je huis wordt koud.
Hij draait nu full electric en heeft nog steeds de pompverdeler... iets met dwarse installateurs die doen wat ze altijd doen. Heb hem verteld dat ie die pompverdeler zsm moest lozen. Hij gaf de schuld aan de bypass.

De pompverdeler hoeft geen probleem te zijn als die voldoende aanvoer kan krijgen en de pomp niet onnodig hard draait.
In een hybride opstelling is het zelf wel verstandig om die te hebben zodat de vloer bij een storing niet loeiheet wordt (en de kans op zo'n storing is aanzienlijk in de huidige opzet!!).

Ik heb zelf een (sjieke) pompverdeler (Therminon Flex line LTV met instelbare recycle; mooi modulair systeem) met 26 mm aan- en afvoer en dat werkt prima. De (grote) thermostaatkraan werkt als temperatuur beveiliging op de toevoer. Laat ik de pomp uit dan gaat de meeste warmte naar radiatoren. Zet ik 'm aan dan zuigt de pomp zoveel water aan dat er een mooie verdeling tussen radiatoren en vloer ontstaat.

Wat ik voor komende winter ga doen is een Arduino Uno kopen met een Ethernet shield. Die hang ik met CAT5 in mijn netwerk. De ketel stel ik in als HR Solo Tap en de thermostaat laat ik hangen. Thermostaat vraagt een setpoint aan de ketel en de ketel negeert 'm volkomen, maar ondertussen vis ik via MQTT de aanvoer uit de thermostaat en stuur ik die door naar de controller. Als thermostaat afschakelt omdat temperatuur bereikt is laat ik de warmtepomp op laagste vermogen doordraaien.

Denk ook aan de PAF (Partner Acceptance Factor). Het moet ook werken als je servertje is gecrashed.

Ik heb nog gekeken naar OpenTherm Slave, maar de meeste sturingen gaan over master mode (thermostaat), ik weet niet wat ik allemaal moet implementeren om een werkende aansturing met OpenTherm te krijgen.

Er zijn Opentherm libraries in de Arduino IDE. Bv. deze https://github.com/jpraus...erm/blob/master/README.md bevat volgens de beschrijving master, slave en gateway modes.

Kan evt altijd nog de opentherm pinnen uit de tweede socket aan de Uno hangen en OpenTherm implementeren. Dat wordt project voor volgend jaar als er een boilervat en driewegklep komt en de ketel verdwijnt.

Edit: misschien toch maar een 3/5V logic shifter aanschaffen en een Wemos d1 kloon toepassen die ik nog heb. Arduino Uno is wel heel basic zie ik.

Ik heb zelf wel een zwak voor de Arduino hardware vanwege de Italiaanse roots. Een Uno is een brede serie (vanaf vrijwel zelfde MCU als in Controlbox tot aan iets met cryptoprocessor). De eenvoudigste kan de buitenunit probleemloos aansturen. Maar Ethernet erbij wordt wel tricky want de timing met de buitenunit moet wel kloppen. Een Mega is dan nodig. Heeft ook voldoende seriele poorten. Maar met een WeMOs i.c.m. Arduino IDE heb je een goedkope oplossing,

[_JGC_]

Net nog even gekeken naar de ESPHome versie van de DIYLESS, maar die heeft eigenlijk helemaal niet zoveel OpenTherm dingen nodig. ch_setpoint accepteren, flame_on, ch_active, ch_temperature, rel_mod_level teruggeven en dan heeft 'ie al meer data dan ie nu van de Intergas ketel krijgt.

[_JGC_]

@WackoH Heb jij enig idee wat de controller doet om de ketel het over te laten nemen? Als ik je pin overzicht zo lees zou het relais dat moeten doen.

[WackoH]

Het grote relais (K3) kan de OpenTherm aansluiting naar de ketel kortsluiten, gelijk aan wat een aan-uit thermostaat doet. Dus ik vermoed dat de controlbox op deze manier de ketel aan/uit zet als de dipswitches van S3 op 'off' staan.

Beide andere relais (K1 verbonden Plugwise smile met en K2 met ketel) verbinden de Smile en ketel direct met elkaar in bekrachtigde toestand. Dit is wellicht hoe de controlbox de ketel in OpenTherm-mode aan zet. Maar ik heb dat verder niet precies uitgezocht.

[Maartenkromhout]

Dat is een mooie toevoeging op het geheel.

Vraag heeft deze ook Wifi mogelijkheden zodat je hem in Home assistant kan uitlezen? Zit hard te denken om deze eerdaags te gaan aanpassen dat ik dit ook kan toepassen.

[P1 modubus]

Goedendag allemaal, het stookseizoen zal weldra beginnen, zal dan ook weer deelnemen en mijn ervaring delen, inmiddels de 2de warmtepomp bij familie inbedrijf gezet, met de nodige problemen, maar de test gebeurd pas met koudere weersomstandigheden.
Om zoveel mogelijk de energie van de zonnepanelen te benutten heb ik het volgende ingesteld,
Thermostaat morgens 8 uur 20.0 Grd C middags naar 22 grd, dan koelt de buitentemperatuur en gaat de WP draaien als nodig.

Plugwise had mij doorgegeven dat het systeem Anna, Smile, Warmtepomp met Zonnepanelen geen beste combinatie was, zoals ik het wilde regelen.
Het laatste van het stookseizoen ging het prima met deze instellingen, middags opwarmen van de vloer en avonds werd opgeslagen warmte weer afgegeven aan de kamer, natuurlijk ga ik deze bijstellen als dit nodig zal zijn, denk aan de stooklijn nu maximaal 43 grd watertemperatuur.
Heb de cv ketel niet aangesloten op deze regeling, de warmtevraag naar de cv. ketel heb ik een externe regeling aangeboden, kan een alarm genereren met een melding als ik dit nodig vind, kan ook de warmtevraag automatisch doorzetten naar de WP aanvraag voor 20 minuten (drukker WP even kortsluiten)
De buiten temperatuur weerstand van de WP kan ik verlagen met een aantal graden zodat de WP langer in bedrijf blijft bij lage buitentemperaturen, meer heb ik niet aangepast.
Heb ook een testkoffer gemaakt zodat ik de bypass optimaal kan instellen, bij Maximaal bedrijf, Dt van 5-6 grd vooral als jullie de regeling overnemen is het belangrijk dat het hydraulisch goed werkt.
Zelf houd ik het zo origineel mogelijk, hoef ook niet te koelen, de Cv ketel regeling heb ik gewoon gelaten op de originele Remeha thermostaat, deze kan ik via de app bedienen als het nodig mocht zijn, de instellingen.
Deze aanpassingen zouden ook met een Arduino mogelijk zijn zolang je de maar potentiaal vrij maakt,
Tot zover, tot in het stookseizoen

[Maartenkromhout]

Misschien een gekke vraag. Maar zou jij in 1 post kunnen uitleggen wat je precies moet doen om het te laten werken. Ik vind nu overal stukjes bij elkaar. heb wel het idee dat het gaat lukken alleen durf ik het net niet aan.

En welk TFT scherm heb jij op de Arduino Mega?

[workzone]

Geweldige informatie @WackoH! Ongeveer twee jaar geleden had ik de Aurea 5 op mijn lijstje staan, alleen het uitschakelen onder 4/5 graden heeft me toen tegen gehouden. Als deze info toen beschikbaar was geweest dan wist ik het wel.

De meeste andere WP's waren toen 3400,- + en ik heb toen maar zelf een WP gemaakt van een AUX AC + Heatexchanger + Pomp, HA stuurt de AUX & Pomp aan op vermogen via een PID temp controller.

[WackoH]

@workzone Dat klinkt als dat het aansturen van Chofu buitenunit van de Aurea voor jou een eitje zou zijn geweest.
Ik heb de mijne afgelopen december voor 600 Euro tweedehands gekocht en zelf aangesloten (~100 Euro materiaal en weekendje werk). Nog een paar wintermaanden en dan is mijn financiele investering al terugverdiend
De tijd die ik er in heb gestopt om het kreng fatsoenlijk aan de praat te krijgen... moeten we maar als hobby en hulp aan wereld zien.

@Maartenkromhout Ik zou idd. de info die over veel post verspreid staat eens een keer samen moeten vatten. Ik heb dat wel een paar keer gedeeltelijk gedaan, maar niet als geheel.
Overigens is deze info inmiddels onderdeel van Ch*tG#T is geworden (inclusief verwijzing naar de Tweakers draadjes). Dus die kun je ook om raad vragen.

Het scherm dat ik op de Mega2560 heb is deze https://www.tinytronics.n...s-mega-compatible-ili9486

[_JGC_]

Ben hier iets meer kwijt: 750 voor de WP, 250 voor materialen en gereedschap, maar dan hang ik ook een T33 op in een slaapkamer omdat het water er dan toch uit is...

Maar zoals het nu lijkt met de informatie die ik uit dit topic heb en mijn huidige gasverbruik wordt het terugverdienen in 2 jaar tijd. Als het deze winter bevalt komt er ook nog een boilervat en driewegklep bij, dan kan de ketel weg en kan Energiewacht opgezegd worden.

Buurman was afgelopen maandag al druk aan het SMS'en over angst voor lawaai van dit ding. Hij had alleen de grindbak en de rubber voetjes gezien.

Toch leuk hoe je op Marktplaats aan het zoeken bent naar een boiler om je terugleverboete terug te dringen, dan een Inventum Ecolution combi50 tegenkomt, dat ding afschiet vanwege hoogte en klachten over lawaai en kort daarna erachter komt dat die Atlantic Aurea dingen voor een habbekrats te krijgen zijn. Eerste zoekactie op GoT wees me naar dit topic en even later was het idee "doen we gewoon!"

[Maartenkromhout]

Ik heb een code gemaakt voor een R4 met Wifi en de Mega.

Ik zal kijken of ik hem hier kan plaatsen. Is wel echt een eerste versie. heb hem nog niet hangen aan de WP maar het web deel werkt wel grappig.



Dit is voor de Mega

code:

/*
 * Arduino Mega 2560 - Complete Atlantic Aurea Heat Pump Interface
 * + Communication with R4 WiFi for web interface
 * 
 * Hardware connections:
 * Heat Pump Interface:
 *   Serial1 (Pin 19): OT MCU communication (9600 bps) - Pad 1
 *   Serial2 (Pin 17/16): HP MCU bidirectional (9600 bps) - Pad 2  
 *   Serial3 (Pin 15/14): Heat Pump direct (666 bps)
 *   
 * R4 WiFi Communication:
 *   Pin 18 (TX1) → R4 Pin 2 (RX)
 *   Pin 19 (RX1) ← R4 Pin 3 (TX)
 *   GND ↔ GND
 */

// Heat pump timing constants
const uint32_t MESSAGE_SERIAL_MCU_INTERVAL = 4200;       // 4.2 seconds between MCU messages
const uint16_t HP_MSG_DELAYS[] = {412, 487, 502, 531};   // Heat pump message delays in ms
const uint8_t HP_MSG_COUNT = 4;
const uint32_t R4_UPDATE_INTERVAL = 2000;                // Send data to R4 every 2 seconds

// Timing variables
uint32_t currentMillis = 0;
uint32_t previousMessageSerial1Sent = 0;
uint32_t previousR4Update = 0;
uint8_t currentHPMessageIndex = 0;
bool sendSerial2 = false;
bool r4Connected = false;

// Message counters for monitoring
uint32_t messageCounters[4] = {0, 0, 0, 0}; // serial1, serial2, serial3, received

// Communication buffers
const uint8_t MAX_BUFFER_SIZE = 64;
uint8_t serial1Buffer[MAX_BUFFER_SIZE];
uint8_t serial2Buffer[MAX_BUFFER_SIZE];
uint8_t serial3Buffer[MAX_BUFFER_SIZE];
uint8_t bufferIndex1 = 0, bufferIndex2 = 0, bufferIndex3 = 0;

// Atlantic Aurea test data arrays
const byte dataArrayOT_IC2_IC1[] = {44,20,154,0,0,33,14,32,29,8,0,78};
const byte dataArrayOT_IC1_IC2[] = {37,20,154,0,0,33,14,32,29,2,0,65};

// Heat pump message structure
struct HeatPumpMessage {
  const byte* data;
  uint8_t length;
};

const byte dataHeatPump0[] = {25,0,8,0,0,0,217,181,145,0,12,13,7,4,47,90,206,225,230,223,0};
const byte dataHeatPump1[] = {25,1,12,0,0,0,0,0,0,0,170,53,145,1,13,80,0,0,0,0,0,138,82,164,39,0};
const byte dataHeatPump2[] = {25,2,8,1,5,0,85,243,145,2,18,18,1,253,0,49,0,1,0,2,0,0,38,216,23,240,0};
const byte dataHeatPump3[] = {25,3,8,178,2,0,193,154,145,3,20,120,81,168,151,21,0,83,53,2,0,24,0,0,0,0,233,241,0};

const HeatPumpMessage heatPumpMessages[] = {
  {dataHeatPump0, sizeof(dataHeatPump0)},
  {dataHeatPump1, sizeof(dataHeatPump1)},
  {dataHeatPump2, sizeof(dataHeatPump2)},
  {dataHeatPump3, sizeof(dataHeatPump3)}
};

void setup() {
  // Serial initialization
  Serial.begin(115200);   // Debug output
  Serial1.begin(9600);    // OT MCU communication (was heat pump, now using Serial2/3)
  Serial2.begin(9600);    // HP MCU communication
  Serial3.begin(666);     // Heat pump direct communication (666 baud - special)
  
  Serial.println("=== Arduino Mega 2560 - Atlantic Aurea Complete System ===");
  Serial.println("Heat Pump Interface:");
  Serial.println("  Serial1: OT MCU (9600 bps)");
  Serial.println("  Serial2: HP MCU (9600 bps)"); 
  Serial.println("  Serial3: Heat Pump Direct (666 baud)");
  Serial.println("R4 WiFi Communication:");
  Serial.println("  Pin 18 → R4 Pin 2, Pin 19 ← R4 Pin 3");
  Serial.println("");
  
  delay(2000); // Give R4 time to start
  initR4Communication();
  
  Serial.println("Starting Atlantic Aurea heat pump monitoring...");
}

void loop() {
  currentMillis = millis();
  
  // Handle all heat pump communications
  handleSerial1Communication();  // OT MCU
  handleSerial2Communication();  // HP MCU  
  handleSerial3Communication();  // Heat pump direct
  
  // Process received data from heat pump
  processReceivedData();
  
  // Send data to R4 WiFi for web interface
  if (r4Connected && (currentMillis - previousR4Update >= R4_UPDATE_INTERVAL)) {
    sendDataToR4();
    previousR4Update = currentMillis;
  }
  
  // Check R4 responses
  checkR4Response();
  
  delay(50); // Small delay for system stability
}

void initR4Communication() {
  Serial.println("Initializing R4 WiFi communication...");
  
  // Send init command (using Serial1 for R4 comm via pins 18/19)
  Serial1.println("MEGA_INIT");
  delay(500);
  
  // Wait for R4 response
  unsigned long timeout = millis() + 5000;
  String response = "";
  
  while (millis() < timeout) {
    if (Serial1.available()) {
      response = Serial1.readStringUntil('\n');
      response.trim();
      if (response.length() > 0) break;
    }
    delay(100);
  }
  
  if (response.indexOf("R4_READY") != -1 || response.indexOf("R4:") != -1) {
    r4Connected = true;
    Serial.println("✅ R4 WiFi connected!");
    Serial.println("R4 Response: " + response);
  } else {
    Serial.println("⚠️ R4 WiFi not responding properly");
    Serial.println("Response: '" + response + "'");
    Serial.println("Continuing without R4...");
  }
}

void handleSerial1Communication() {
  // NOTE: Serial1 is now used for R4 communication
  // Original OT MCU communication moved to Serial2 for simplicity
  
  // Send periodic message on Serial2 (simulating OT MCU)
  if (currentMillis - previousMessageSerial1Sent >= MESSAGE_SERIAL_MCU_INTERVAL) {
    Serial2.write(dataArrayOT_IC1_IC2, sizeof(dataArrayOT_IC1_IC2));
    previousMessageSerial1Sent = currentMillis;
    sendSerial2 = true; // Trigger second message
    messageCounters[0]++; // Count as Serial1 equivalent
    
    Serial.print("Sent OT MCU message: ");
    printByteArray(dataArrayOT_IC1_IC2, sizeof(dataArrayOT_IC1_IC2));
  }
}

void handleSerial2Communication() {
  // Send follow-up message when triggered
  if (sendSerial2) {
    delay(100); // Small delay between messages
    Serial2.write(dataArrayOT_IC2_IC1, sizeof(dataArrayOT_IC2_IC1));
    sendSerial2 = false;
    messageCounters[1]++;
    
    Serial.print("Sent HP MCU message: ");
    printByteArray(dataArrayOT_IC2_IC1, sizeof(dataArrayOT_IC2_IC1));
  }
}

void handleSerial3Communication() {
  // Heat pump direct communication (666 baud)
  static uint32_t lastHPMessageTime = 0;
  static bool waitingForDelay = false;
  
  if (!waitingForDelay) {
    const HeatPumpMessage& currentMsg = heatPumpMessages[currentHPMessageIndex];
    Serial3.write(currentMsg.data, currentMsg.length);
    messageCounters[2]++;
    
    Serial.print("Heat Pump Msg " + String(currentHPMessageIndex) + ": ");
    printByteArray(currentMsg.data, currentMsg.length);
    
    lastHPMessageTime = currentMillis;
    waitingForDelay = true;
  }
  
  if (waitingForDelay && (currentMillis - lastHPMessageTime >= HP_MSG_DELAYS[currentHPMessageIndex])) {
    waitingForDelay = false;
    currentHPMessageIndex = (currentHPMessageIndex + 1) % HP_MSG_COUNT;
  }
}

void processReceivedData() {
  // Check Serial2 for heat pump responses
  while (Serial2.available() && bufferIndex2 < MAX_BUFFER_SIZE - 1) {
    serial2Buffer[bufferIndex2++] = Serial2.read();
  }
  
  // Check Serial3 for heat pump responses  
  while (Serial3.available() && bufferIndex3 < MAX_BUFFER_SIZE - 1) {
    serial3Buffer[bufferIndex3++] = Serial3.read();
  }
  
  // Process received messages
  if (bufferIndex2 > 0) {
    Serial.print("Received from HP MCU: ");
    printByteArray(serial2Buffer, bufferIndex2);
    messageCounters[3]++;
    bufferIndex2 = 0;
  }
  
  if (bufferIndex3 > 0) {
    Serial.print("Received from Heat Pump: ");
    printByteArray(serial3Buffer, bufferIndex3);
    messageCounters[3]++;
    bufferIndex3 = 0;
  }
}

void sendDataToR4() {
  if (!r4Connected) return;
  
  // Create JSON data for web interface
  String jsonData = "{";
  jsonData += "\"timestamp\":" + String(currentMillis);
  jsonData += ",\"uptime\":" + String(currentMillis / 1000);
  jsonData += ",\"counters\":{";
  jsonData += "\"ot_mcu\":" + String(messageCounters[0]);
  jsonData += ",\"hp_mcu\":" + String(messageCounters[1]); 
  jsonData += ",\"heat_pump\":" + String(messageCounters[2]);
  jsonData += ",\"received\":" + String(messageCounters[3]);
  jsonData += "},\"status\":{";
  jsonData += "\"current_hp_msg\":" + String(currentHPMessageIndex);
  jsonData += ",\"system\":\"Atlantic Aurea\"";
  jsonData += ",\"free_memory\":" + String(freeMemory());
  
  // Calculate message rate (messages per minute)
  uint32_t totalMessages = messageCounters[0] + messageCounters[1] + messageCounters[2];
  float messageRate = (float)totalMessages / ((float)currentMillis / 60000.0);
  if (currentMillis < 60000) messageRate = 0; // Avoid crazy numbers at startup
  
  jsonData += ",\"message_rate\":" + String(messageRate, 1);
  jsonData += "}}";
  
  // Send to R4 WiFi
  Serial1.println("DATA:" + jsonData);
  Serial.println("📤 Data sent to R4 WiFi");
}

void checkR4Response() {
  if (Serial1.available()) {
    String response = Serial1.readStringUntil('\n');
    response.trim();
    
    if (response.length() > 0) {
      Serial.println("📨 R4 WiFi: " + response);
      
      if (response.indexOf("WIFI_CONNECTED") != -1) {
        int colonPos = response.indexOf(":");
        if (colonPos != -1) {
          String ip = response.substring(colonPos + 1);
          Serial.println("");
          Serial.println("🌐 SUCCESS! Atlantic Aurea Web Monitor Available:");
          Serial.println("🌐 http://" + ip);
          Serial.println("");
        }
      }
    }
  }
}

void printByteArray(const byte* data, uint8_t length) {
  for (uint8_t i = 0; i < length; i++) {
    if (data[i] < 16) Serial.print("0");
    Serial.print(data[i], HEX);
    if (i < length - 1) Serial.print(" ");
  }
  Serial.println();
}

int freeMemory() {
  char top;
  extern char *__brkval;
  extern char __bss_end;
  return __brkval ? &top - __brkval : &top - &__bss_end;
}

[ Voor 3% gewijzigd door Maartenkromhout op 05-09-2025 21:38 ]

[Maartenkromhout]

Dit is de code voor de R4 paste niet in 1 post

code:

/*
 * Arduino Uno R4 WiFi - Atlantic Aurea with Home Assistant MQTT Discovery
 * Full heat pump monitoring and control with auto-discovery
 * Made by Maarten K
 * 
 * Hardware connections:
 * Pin 2 (RX) ← Arduino Mega Pin 18 (TX)
 * Pin 3 (TX) → Arduino Mega Pin 19 (RX)  
 * GND ↔ GND
 */

#include <WiFiS3.h>
#include <SoftwareSerial.h>
#include <ArduinoMqttClient.h>
#include <ArduinoJson.h>

// WiFi credentials
const char* ssid = "";
const char* password = "";

// Anna Thermostat settings
const char* annaIP = "192.168.1.";
const int annaPort = 80;
const char* annaUsername = "smile";
const char* annaPassword = "";

// MQTT Settings
const char* mqttBroker = "192.168.1.";
const int mqttPort = 1883;
const char* mqttUser = "";
const char* mqttPass = "";
const char* mqttClientId = "ArduinoR4_HeatPump";

// MQTT Topics
const char* mqttTopicPrefix = "atlantic_aurea/";
const char* mqttAnnaPrefix = "anna/";
const char* discoveryPrefix = "homeassistant/";

// Communication with Mega
SoftwareSerial megaComm(2, 3); // RX, TX

// Web server and MQTT
WiFiServer server(80);
WiFiClient wifiClient;
MqttClient mqttClient(wifiClient);

// Data from Arduino Mega
String lastMegaData = "{}";
unsigned long lastDataReceived = 0;
bool megaConnected = false;
bool wifiConnected = false;
bool mqttConnected = false;
bool discoveryPublished = false;

// Heat Pump Data Structure
struct HeatPumpData {
  float waterTemp = 0;
  float outsideTemp = 0;
  float returnTemp = 0;
  float evaporatorTemp = 0;
  float compressorTemp = 0;
  float targetTemp = 0;
  float currentPower = 0;
  bool compressorActive = false;
  bool defrostActive = false;
  bool heatingActive = false;
  bool coolingActive = false;
  bool dhwActive = false;  // Domestic Hot Water
  String operationMode = "standby";
  String errorCode = "none";
  int fanSpeed = 0;
  float cop = 0;  // Coefficient of Performance
} hpData;

// Anna thermostat data
float annaCurrentTemp = 0.0;
float annaSetpoint = 0.0;
String annaPresetMode = "home";
bool annaHeating = false;
unsigned long lastAnnaUpdate = 0;
const unsigned long annaUpdateInterval = 30000;

// MQTT timing
unsigned long lastMqttPublish = 0;
const unsigned long mqttPublishInterval = 30000;
unsigned long lastMqttReconnect = 0;
unsigned long lastDiscoveryPublish = 0;

// System info
unsigned long startTime = 0;
String systemStatus = "Starting...";
int refreshInterval = 30;

// Device info for Home Assistant
String deviceName = "Atlantic Aurea Heat Pump";
String deviceId = "atlantic_aurea_001";
String softwareVersion = "2.0.0";

void setup() {
  Serial.begin(115200);
  megaComm.begin(9600);
  
  startTime = millis();
  
  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, LOW);
  
  Serial.println("=== Arduino R4 WiFi - Atlantic Aurea HA Integration ===");
  Serial.println("Version: " + String(softwareVersion));
  
  // Startup LED sequence
  for (int i = 0; i < 3; i++) {
    digitalWrite(LED_BUILTIN, HIGH);
    delay(300);
    digitalWrite(LED_BUILTIN, LOW);
    delay(300);
  }
  
  initWiFi();
  
  if (wifiConnected) {
    connectMQTT();
  }
  
  megaComm.println("R4_READY");
  Serial.println("Sent R4_READY to Mega");
  
  if (wifiConnected) {
    updateAnnaData();
  }
}

void loop() {
  handleMegaCommunication();
  
  if (wifiConnected) {
    handleWebServer();
    
    if (millis() - lastAnnaUpdate > annaUpdateInterval) {
      updateAnnaData();
    }
    
    // MQTT operations
    if (!mqttClient.connected() && millis() - lastMqttReconnect > 5000) {
      connectMQTT();
      lastMqttReconnect = millis();
    }
    
    if (mqttClient.connected()) {
      mqttClient.poll();
      
      // Publish discovery if needed
      if (!discoveryPublished || millis() - lastDiscoveryPublish > 3600000) { // Re-publish every hour
        publishHomeAssistantDiscovery();
        lastDiscoveryPublish = millis();
      }
      
      // Publish data periodically
      if (millis() - lastMqttPublish > mqttPublishInterval) {
        publishMQTTData();
        lastMqttPublish = millis();
      }
    }
  }
  
  updateStatusLED();
  delay(50);
}

void initWiFi() {
  systemStatus = "Connecting to WiFi...";
  Serial.println("Connecting to WiFi: " + String(ssid));
  
  if (WiFi.status() == WL_NO_MODULE) {
    systemStatus = "WiFi module not found!";
    Serial.println("ERROR: WiFi module not found!");
    return;
  }
  
  WiFi.begin(ssid, password);
  
  int attempts = 0;
  while (WiFi.status() != WL_CONNECTED && attempts < 30) {
    delay(500);
    Serial.print(".");
    attempts++;
    digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));
  }
  
  if (WiFi.status() == WL_CONNECTED) {
    wifiConnected = true;
    systemStatus = "WiFi Connected";
    
    Serial.println("\nWiFi connected successfully!");
    Serial.print("IP address: ");
    Serial.println(WiFi.localIP());
    Serial.print("Signal strength: ");
    Serial.print(WiFi.RSSI());
    Serial.println(" dBm");
    
    server.begin();
    Serial.println("Web server started on port 80");
    Serial.println("===================================");
    Serial.println("Atlantic Aurea Monitor available at:");
    Serial.println("http://" + WiFi.localIP().toString());
    Serial.println("===================================");
    
    megaComm.println("WIFI_CONNECTED:" + WiFi.localIP().toString());
    
    for (int i = 0; i < 5; i++) {
      digitalWrite(LED_BUILTIN, HIGH);
      delay(100);
      digitalWrite(LED_BUILTIN, LOW);
      delay(100);
    }
  } else {
    systemStatus = "WiFi connection failed";
    Serial.println("\nWiFi connection failed!");
  }
}

void connectMQTT() {
  if (strlen(mqttBroker) == 0) return;
  
  Serial.print("Connecting to MQTT broker: ");
  Serial.println(mqttBroker);
  
  mqttClient.setId(mqttClientId);
  
  if (strlen(mqttUser) > 0) {
    mqttClient.setUsernamePassword(mqttUser, mqttPass);
  }
  
  // Set will message for availability
  String availTopic = String(mqttTopicPrefix) + "availability";
  mqttClient.beginWill(availTopic, false, true);
  mqttClient.print("offline");
  mqttClient.endWill();
  
  if (mqttClient.connect(mqttBroker, mqttPort)) {
    mqttConnected = true;
    discoveryPublished = false; // Force re-publish discovery
    Serial.println("MQTT connected successfully!");
    
    // Publish online status
    mqttClient.beginMessage(availTopic, true);
    mqttClient.print("online");
    mqttClient.endMessage();
    
    // Subscribe to control topics
    subscribeToControlTopics();
    
    // Set message callback
    mqttClient.onMessage(onMqttMessage);
    
    Serial.println("MQTT setup complete");
    
  } else {
    mqttConnected = false;
    Serial.print("MQTT connection failed! Error: ");
    Serial.println(mqttClient.connectError());
  }
}

void subscribeToControlTopics() {
  // Anna control topics
  mqttClient.subscribe(String(mqttAnnaPrefix) + "setpoint/set");
  mqttClient.subscribe(String(mqttAnnaPrefix) + "preset/set");
  
  // Heat pump control topics
  mqttClient.subscribe(String(mqttTopicPrefix) + "target_temp/set");
  mqttClient.subscribe(String(mqttTopicPrefix) + "mode/set");
  mqttClient.subscribe(String(mqttTopicPrefix) + "power/set");
  mqttClient.subscribe(String(mqttTopicPrefix) + "dhw/set");
  
  Serial.println("Subscribed to all control topics");
}

void publishHomeAssistantDiscovery() {
  Serial.println("Publishing Home Assistant Discovery messages...");
  
  // Device info for all entities
  String deviceInfo = "\"device\":{";
  deviceInfo += "\"identifiers\":[\"" + deviceId + "\"],";
  deviceInfo += "\"name\":\"" + deviceName + "\",";
  deviceInfo += "\"model\":\"Atlantic Aurea\",";
  deviceInfo += "\"manufacturer\":\"Atlantic\",";
  deviceInfo += "\"sw_version\":\"" + softwareVersion + "\"";
  deviceInfo += "}";
  
  // Anna Thermostat as Climate entity
  publishClimateDiscovery("anna", "Anna Thermostat", deviceInfo);
  
  // Heat Pump sensors
  publishSensorDiscovery("water_temp", "Water Temperature", "°C", "temperature", deviceInfo);
  publishSensorDiscovery("outside_temp", "Outside Temperature", "°C", "temperature", deviceInfo);
  publishSensorDiscovery("return_temp", "Return Temperature", "°C", "temperature", deviceInfo);
  publishSensorDiscovery("evaporator_temp", "Evaporator Temperature", "°C", "temperature", deviceInfo);
  publishSensorDiscovery("compressor_temp", "Compressor Temperature", "°C", "temperature", deviceInfo);
  publishSensorDiscovery("target_temp", "Target Temperature", "°C", "temperature", deviceInfo);
  publishSensorDiscovery("current_power", "Current Power", "kW", "power", deviceInfo);
  publishSensorDiscovery("cop", "COP", "", "power_factor", deviceInfo);
  publishSensorDiscovery("fan_speed", "Fan Speed", "rpm", "", deviceInfo);
  
  // Binary sensors
  publishBinarySensorDiscovery("compressor_active", "Compressor Active", "running", deviceInfo);
  publishBinarySensorDiscovery("defrost_active", "Defrost Active", "cold", deviceInfo);
  publishBinarySensorDiscovery("heating_active", "Heating Active", "heat", deviceInfo);
  publishBinarySensorDiscovery("cooling_active", "Cooling Active", "cold", deviceInfo);
  publishBinarySensorDiscovery("dhw_active", "DHW Active", "moisture", deviceInfo);
  
  // Selects and controls
  publishSelectDiscovery("mode", "Operation Mode", "auto,heat,cool,dhw,standby", deviceInfo);
  publishNumberDiscovery("target_temp_control", "Target Temperature Control", 15, 55, 0.5, deviceInfo);
  publishSwitchDiscovery("power", "Power", deviceInfo);
  publishSwitchDiscovery("dhw_boost", "DHW Boost", deviceInfo);
  
  // System sensors
  publishSensorDiscovery("uptime", "System Uptime", "s", "duration", deviceInfo);
  publishSensorDiscovery("wifi_rssi", "WiFi Signal", "dBm", "signal_strength", deviceInfo);
  publishSensorDiscovery("message_rate", "Message Rate", "msg/min", "", deviceInfo);
  publishSensorDiscovery("error_code", "Error Code", "", "problem", deviceInfo);
  
  discoveryPublished = true;
  Serial.println("Discovery messages published!");
}

void publishClimateDiscovery(String id, String name, String deviceInfo) {
  String topic = String(discoveryPrefix) + "climate/" + deviceId + "/" + id + "/config";
  String payload = "{";
  payload += "\"name\":\"" + name + "\",";
  payload += "\"unique_id\":\"" + deviceId + "_" + id + "\",";
  payload += "\"current_temperature_topic\":\"" + String(mqttAnnaPrefix) + "current_temp\",";
  payload += "\"temperature_state_topic\":\"" + String(mqttAnnaPrefix) + "setpoint\",";
  payload += "\"temperature_command_topic\":\"" + String(mqttAnnaPrefix) + "setpoint/set\",";
  payload += "\"mode_state_topic\":\"" + String(mqttAnnaPrefix) + "preset\",";
  payload += "\"mode_command_topic\":\"" + String(mqttAnnaPrefix) + "preset/set\",";
  payload += "\"modes\":[\"home\",\"away\",\"sleep\",\"vacation\"],";
  payload += "\"min_temp\":5,";
  payload += "\"max_temp\":30,";
  payload += "\"temp_step\":0.5,";
  payload += "\"availability_topic\":\"" + String(mqttTopicPrefix) + "availability\",";
  payload += deviceInfo;
  payload += "}";
  
  mqttClient.beginMessage(topic, true);
  mqttClient.print(payload);
  mqttClient.endMessage();
}

void publishSensorDiscovery(String id, String name, String unit, String deviceClass, String deviceInfo) {
  String topic = String(discoveryPrefix) + "sensor/" + deviceId + "/" + id + "/config";
  String payload = "{";
  payload += "\"name\":\"" + name + "\",";
  payload += "\"unique_id\":\"" + deviceId + "_" + id + "\",";
  payload += "\"state_topic\":\"" + String(mqttTopicPrefix) + id + "\",";
  if (unit.length() > 0) {
    payload += "\"unit_of_measurement\":\"" + unit + "\",";
  }
  if (deviceClass.length() > 0) {
    payload += "\"device_class\":\"" + deviceClass + "\",";
  }
  payload += "\"availability_topic\":\"" + String(mqttTopicPrefix) + "availability\",";
  payload += deviceInfo;
  payload += "}";
  
  mqttClient.beginMessage(topic, true);
  mqttClient.print(payload);
  mqttClient.endMessage();
}

void publishBinarySensorDiscovery(String id, String name, String deviceClass, String deviceInfo) {
  String topic = String(discoveryPrefix) + "binary_sensor/" + deviceId + "/" + id + "/config";
  String payload = "{";
  payload += "\"name\":\"" + name + "\",";
  payload += "\"unique_id\":\"" + deviceId + "_" + id + "\",";
  payload += "\"state_topic\":\"" + String(mqttTopicPrefix) + id + "\",";
  payload += "\"payload_on\":\"ON\",";
  payload += "\"payload_off\":\"OFF\",";
  if (deviceClass.length() > 0) {
    payload += "\"device_class\":\"" + deviceClass + "\",";
  }
  payload += "\"availability_topic\":\"" + String(mqttTopicPrefix) + "availability\",";
  payload += deviceInfo;
  payload += "}";
  
  mqttClient.beginMessage(topic, true);
  mqttClient.print(payload);
  mqttClient.endMessage();
}

void publishSelectDiscovery(String id, String name, String options, String deviceInfo) {
  String topic = String(discoveryPrefix) + "select/" + deviceId + "/" + id + "/config";
  String payload = "{";
  payload += "\"name\":\"" + name + "\",";
  payload += "\"unique_id\":\"" + deviceId + "_" + id + "\",";
  payload += "\"state_topic\":\"" + String(mqttTopicPrefix) + id + "\",";
  payload += "\"command_topic\":\"" + String(mqttTopicPrefix) + id + "/set\",";
  payload += "\"options\":[";
  
  // Parse options
  int start = 0;
  bool first = true;
  while (start < options.length()) {
    int end = options.indexOf(',', start);
    if (end == -1) end = options.length();
    
    if (!first) payload += ",";
    payload += "\"" + options.substring(start, end) + "\"";
    
    first = false;
    start = end + 1;
  }
  
  payload += "],";
  payload += "\"availability_topic\":\"" + String(mqttTopicPrefix) + "availability\",";
  payload += deviceInfo;
  payload += "}";
  
  mqttClient.beginMessage(topic, true);
  mqttClient.print(payload);
  mqttClient.endMessage();
}

void publishNumberDiscovery(String id, String name, float min, float max, float step, String deviceInfo) {
  String topic = String(discoveryPrefix) + "number/" + deviceId + "/" + id + "/config";
  String payload = "{";
  payload += "\"name\":\"" + name + "\",";
  payload += "\"unique_id\":\"" + deviceId + "_" + id + "\",";
  payload += "\"state_topic\":\"" + String(mqttTopicPrefix) + "target_temp\",";
  payload += "\"command_topic\":\"" + String(mqttTopicPrefix) + "target_temp/set\",";
  payload += "\"min\":" + String(min) + ",";
  payload += "\"max\":" + String(max) + ",";
  payload += "\"step\":" + String(step) + ",";
  payload += "\"unit_of_measurement\":\"°C\",";
  payload += "\"availability_topic\":\"" + String(mqttTopicPrefix) + "availability\",";
  payload += deviceInfo;
  payload += "}";
  
  mqttClient.beginMessage(topic, true);
  mqttClient.print(payload);
  mqttClient.endMessage();
}

void publishSwitchDiscovery(String id, String name, String deviceInfo) {
  String topic = String(discoveryPrefix) + "switch/" + deviceId + "/" + id + "/config";
  String payload = "{";
  payload += "\"name\":\"" + name + "\",";
  payload += "\"unique_id\":\"" + deviceId + "_" + id + "\",";
  payload += "\"state_topic\":\"" + String(mqttTopicPrefix) + id + "\",";
  payload += "\"command_topic\":\"" + String(mqttTopicPrefix) + id + "/set\",";
  payload += "\"payload_on\":\"ON\",";
  payload += "\"payload_off\":\"OFF\",";
  payload += "\"availability_topic\":\"" + String(mqttTopicPrefix) + "availability\",";
  payload += deviceInfo;
  payload += "}";
  
  mqttClient.beginMessage(topic, true);
  mqttClient.print(payload);
  mqttClient.endMessage();
}

void onMqttMessage(int messageSize) {
  String topic = mqttClient.messageTopic();
  String payload = "";
  
  while (mqttClient.available()) {
    payload += (char)mqttClient.read();
  }
  
  Serial.print("MQTT message - Topic: ");
  Serial.print(topic);
  Serial.print(" | Payload: ");
  Serial.println(payload);
  
  // Handle control commands
  if (topic.endsWith("setpoint/set")) {
    float newSetpoint = payload.toFloat();
    if (newSetpoint >= 5.0 && newSetpoint <= 30.0) {
      setAnnaTemperature(newSetpoint);
    }
  } else if (topic.endsWith("preset/set")) {
    setAnnaPreset(payload);
  } else if (topic.endsWith("target_temp/set")) {
    float targetTemp = payload.toFloat();
    sendHeatPumpCommand("SET_TARGET", String(targetTemp));
  } else if (topic.endsWith("mode/set")) {
    sendHeatPumpCommand("SET_MODE", payload);
  } else if (topic.endsWith("power/set")) {
    sendHeatPumpCommand("POWER", payload);
  } else if (topic.endsWith("dhw/set")) {
    sendHeatPumpCommand("DHW", payload);
  }
}

void sendHeatPumpCommand(String command, String value) {
  // Send command to Mega
  String cmd = "HP_CMD:" + command + ":" + value;
  megaComm.println(cmd);
  Serial.println("Sent to Mega: " + cmd);
}

void publishMQTTData() {
  if (!mqttClient.connected()) return;
  
  Serial.println("Publishing MQTT data...");
  
  // Parse heat pump data from Mega
  parseHeatPumpData();
  
  // Publish Heat Pump data
  publishMQTTValue(String(mqttTopicPrefix) + "water_temp", String(hpData.waterTemp));
  publishMQTTValue(String(mqttTopicPrefix) + "outside_temp", String(hpData.outsideTemp));
  publishMQTTValue(String(mqttTopicPrefix) + "return_temp", String(hpData.returnTemp));
  publishMQTTValue(String(mqttTopicPrefix) + "evaporator_temp", String(hpData.evaporatorTemp));
  publishMQTTValue(String(mqttTopicPrefix) + "compressor_temp", String(hpData.compressorTemp));
  publishMQTTValue(String(mqttTopicPrefix) + "target_temp", String(hpData.targetTemp));
  publishMQTTValue(String(mqttTopicPrefix) + "current_power", String(hpData.currentPower));
  publishMQTTValue(String(mqttTopicPrefix) + "cop", String(hpData.cop));
  publishMQTTValue(String(mqttTopicPrefix) + "fan_speed", String(hpData.fanSpeed));
  publishMQTTValue(String(mqttTopicPrefix) + "mode", hpData.operationMode);
  publishMQTTValue(String(mqttTopicPrefix) + "error_code", hpData.errorCode);
  
  // Binary states
  publishMQTTValue(String(mqttTopicPrefix) + "compressor_active", hpData.compressorActive ? "ON" : "OFF");
  publishMQTTValue(String(mqttTopicPrefix) + "defrost_active", hpData.defrostActive ? "ON" : "OFF");
  publishMQTTValue(String(mqttTopicPrefix) + "heating_active", hpData.heatingActive ? "ON" : "OFF");
  publishMQTTValue(String(mqttTopicPrefix) + "cooling_active", hpData.coolingActive ? "ON" : "OFF");
  publishMQTTValue(String(mqttTopicPrefix) + "dhw_active", hpData.dhwActive ? "ON" : "OFF");
  
  // Anna data
  publishMQTTValue(String(mqttAnnaPrefix) + "current_temp", String(annaCurrentTemp));
  publishMQTTValue(String(mqttAnnaPrefix) + "setpoint", String(annaSetpoint));
  publishMQTTValue(String(mqttAnnaPrefix) + "preset", annaPresetMode);
  publishMQTTValue(String(mqttAnnaPrefix) + "heating", annaHeating ? "ON" : "OFF");
  
  // System data
  String uptime = extractJSONValue(lastMegaData, "uptime");
  String msgRate = extractJSONValue(lastMegaData, "message_rate");
  
  publishMQTTValue(String(mqttTopicPrefix) + "uptime", uptime);
  publishMQTTValue(String(mqttTopicPrefix) + "wifi_rssi", String(WiFi.RSSI()));
  publishMQTTValue(String(mqttTopicPrefix) + "message_rate", msgRate);
  
  Serial.println("MQTT data published");
}

void publishMQTTValue(String topic, String value) {
  mqttClient.beginMessage(topic);
  mqttClient.print(value);
  mqttClient.endMessage();
}

void parseHeatPumpData() {
  // Extract heat pump values from JSON
  // This assumes the Mega sends detailed data
  hpData.waterTemp = extractJSONValue(lastMegaData, "water_temp").toFloat();
  hpData.outsideTemp = extractJSONValue(lastMegaData, "outside_temp").toFloat();
  hpData.returnTemp = extractJSONValue(lastMegaData, "return_temp").toFloat();
  hpData.evaporatorTemp = extractJSONValue(lastMegaData, "evaporator_temp").toFloat();
  hpData.compressorTemp = extractJSONValue(lastMegaData, "compressor_temp").toFloat();
  hpData.targetTemp = extractJSONValue(lastMegaData, "target_temp").toFloat();
  hpData.currentPower = extractJSONValue(lastMegaData, "power").toFloat();
  hpData.cop = extractJSONValue(lastMegaData, "cop").toFloat();
  hpData.fanSpeed = extractJSONValue(lastMegaData, "fan_speed").toInt();
  
  // States
  hpData.compressorActive = extractJSONValue(lastMegaData, "compressor") == "1";
  hpData.defrostActive = extractJSONValue(lastMegaData, "defrost") == "1";
  hpData.heatingActive = extractJSONValue(lastMegaData, "heating") == "1";
  hpData.coolingActive = extractJSONValue(lastMegaData, "cooling") == "1";
  hpData.dhwActive = extractJSONValue(lastMegaData, "dhw") == "1";
  
  hpData.operationMode = extractJSONValue(lastMegaData, "mode");
  hpData.errorCode = extractJSONValue(lastMegaData, "error");
  
  // Calculate COP if not provided
  if (hpData.cop == 0 && hpData.currentPower > 0) {
    // Estimate based on temperatures
    float deltaT = abs(hpData.waterTemp - hpData.outsideTemp);
    if (deltaT > 0) {
      hpData.cop = 5.0 - (deltaT * 0.1); // Simple estimation
      if (hpData.cop < 1.0) hpData.cop = 1.0;
      if (hpData.cop > 6.0) hpData.cop = 6.0;
    }
  }
}

void updateAnnaData() {
  WiFiClient annaClient;
  
  Serial.println("Updating Anna thermostat data...");
  
  if (annaClient.connect(annaIP, annaPort)) {
    String request = "GET /core/appliances HTTP/1.1\r\n";
    request += "Host: " + String(annaIP) + "\r\n";
    request += "Authorization: Basic " + base64Encode(String(annaUsername) + ":" + String(annaPassword)) + "\r\n";
    request += "Connection: close\r\n\r\n";
    
    annaClient.print(request);
    
    unsigned long timeout = millis();
    while (!annaClient.available() && millis() - timeout < 5000) {
      delay(10);
    }
    
    String response = "";
    while (annaClient.available()) {
      response += annaClient.readString();
    }
    
    parseAnnaXML(response);
    
    annaClient.stop();
    lastAnnaUpdate = millis();
    
    Serial.print("Anna: ");
    Serial.print(annaCurrentTemp);
    Serial.print("°C / ");
    Serial.print(annaSetpoint);
    Serial.println("°C");
    
  } else {
    Serial.println("Failed to connect to Anna");
  }
}

void setAnnaTemperature(float temperature) {
  WiFiClient annaClient;
  
  Serial.print("Setting Anna temperature to: ");
  Serial.println(temperature);
  
  if (annaClient.connect(annaIP, annaPort)) {
    String xmlPayload = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>";
    xmlPayload += "<thermostat><setpoint>" + String(temperature) + "</setpoint></thermostat>";
    
    String request = "PUT /core/appliances/thermostat HTTP/1.1\r\n";
    request += "Host: " + String(annaIP) + "\r\n";
    request += "Authorization: Basic " + base64Encode(String(annaUsername) + ":" + String(annaPassword)) + "\r\n";
    request += "Content-Type: text/xml\r\n";
    request += "Content-Length: " + String(xmlPayload.length()) + "\r\n";
    request += "Connection: close\r\n\r\n";
    request += xmlPayload;
    
    annaClient.print(request);
    
    delay(500);
    while (annaClient.available()) {
      annaClient.read();
    }
    
    annaClient.stop();
    
    Serial.println("Temperature command sent");
    
    delay(1000);
    updateAnnaData();
    
    if (mqttClient.connected()) {
      publishMQTTValue(String(mqttAnnaPrefix) + "setpoint", String(temperature));
    }
  }
}

void setAnnaPreset(String preset) {
  WiFiClient annaClient;
  
  Serial.print("Setting Anna preset to: ");
  Serial.println(preset);
  
  if (annaClient.connect(annaIP, annaPort)) {
    String xmlPayload = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>";
    xmlPayload += "<preset_mode>" + preset + "</preset_mode>";
    
    String request = "PUT /core/appliances/thermostat/preset HTTP/1.1\r\n";
    request += "Host: " + String(annaIP) + "\r\n";
    request += "Authorization: Basic " + base64Encode(String(annaUsername) + ":" + String(annaPassword)) + "\r\n";
    request += "Content-Type: text/xml\r\n";
    request += "Content-Length: " + String(xmlPayload.length()) + "\r\n";
    request += "Connection: close\r\n\r\n";
    request += xmlPayload;
    
    annaClient.print(request);
    
    delay(500);
    while (annaClient.available()) {
      annaClient.read();
    }
    
    annaClient.stop();
    
    Serial.println("Preset command sent");
    
    delay(1000);
    updateAnnaData();
  }
}

void parseAnnaXML(String xml) {
  int tempPos = xml.indexOf("<temperature>");
  if (tempPos != -1) {
    int endPos = xml.indexOf("</temperature>", tempPos);
    String tempStr = xml.substring(tempPos + 13, endPos);
    annaCurrentTemp = tempStr.toFloat();
  }
  
  int setpointPos = xml.indexOf("<setpoint>");
  if (setpointPos != -1) {
    int endPos = xml.indexOf("</setpoint>", setpointPos);
    String setpointStr = xml.substring(setpointPos + 10, endPos);
    annaSetpoint = setpointStr.toFloat();
  }
  
  annaHeating = xml.indexOf("<heating>true</heating>") != -1;
  
  int presetPos = xml.indexOf("<active_preset>");
  if (presetPos != -1) {
    int endPos = xml.indexOf("</active_preset>", presetPos);
    annaPresetMode = xml.substring(presetPos + 15, endPos);
  }
}

String base64Encode(String input) {
  const char* b64chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  String output = "";
  
  int i = 0;
  while (i < input.length()) {
    int a = i < input.length() ? input[i++] : 0;
    int b = i < input.length() ? input[i++] : 0;
    int c = i < input.length() ? input[i++] : 0;
    
    output += b64chars[a >> 2];
    output += b64chars[((a & 3) << 4) | (b >> 4)];
    output += b64chars[((b & 15) << 2) | (c >> 6)];
    output += b64chars[c & 63];
  }
  
  return output;
}

void handleMegaCommunication() {
  if (megaComm.available()) {
    String command = megaComm.readStringUntil('\n');
    command.trim();
    
    if (command.length() > 0 && command.length() < 1000) {
      Serial.println("From Mega: " + command);
      
      if (command == "MEGA_INIT") {
        megaComm.println("R4_READY");
        megaConnected = true;
        Serial.println("Sent R4_READY response");
        
      } else if (command.startsWith("DATA:")) {
        lastMegaData = command.substring(5);
        lastDataReceived = millis();
        megaConnected = true;
        megaComm.println("R4:DATA_OK");
        Serial.println("Received JSON data (" + String(lastMegaData.length()) + " chars)");
        
        // Immediately publish if significant changes detected
        if (mqttClient.connected()) {
          checkForSignificantChanges();
        }
        
      } else {
        megaComm.println("R4:OK");
      }
    }
  }
  
  if (millis() - lastDataReceived > 15000 && lastDataReceived > 0) {
    megaConnected = false;
    Serial.println("Mega communication timeout");
  }
}

void checkForSignificantChanges() {
  static float lastWaterTemp = 0;
  static bool lastCompressor = false;
  
  float currentWaterTemp = extractJSONValue(lastMegaData, "water_temp").toFloat();
  bool currentCompressor = extractJSONValue(lastMegaData, "compressor") == "1";
  
  // Publish immediately if significant change
  if (abs(currentWaterTemp - lastWaterTemp) > 1.0 || currentCompressor != lastCompressor) {
    publishMQTTData();
    lastMqttPublish = millis();
  }
  
  lastWaterTemp = currentWaterTemp;
  lastCompressor = currentCompressor;
}

String extractJSONValue(String json, String key) {
  int startPos = json.indexOf("\"" + key + "\":");
  if (startPos == -1) return "0";
  
  startPos += key.length() + 3;
  int endPos = json.indexOf(",", startPos);
  if (endPos == -1) endPos = json.indexOf("}", startPos);
  
  String value = json.substring(startPos, endPos);
  value.replace("\"", "");
  value.trim();
  
  return value;
}

String formatUptime(int seconds) {
  int hours = seconds / 3600;
  int minutes = (seconds % 3600) / 60;
  int secs = seconds % 60;
  
  String result = "";
  if (hours > 0) result += String(hours) + "h ";
  if (minutes > 0) result += String(minutes) + "m ";
  result += String(secs) + "s";
  
  return result;
}

void updateStatusLED() {
  static unsigned long lastBlink = 0;
  static bool ledState = false;
  
  unsigned long interval;
  if (wifiConnected && megaConnected && mqttConnected) {
    interval = 3000; // Slow blink = all systems go
  } else if (wifiConnected && megaConnected) {
    interval = 1500; // Medium = no MQTT
  } else if (wifiConnected) {
    interval = 500;  // Fast = no Mega
  } else {
    interval = 100;  // Very fast = no WiFi
  }
  
  if (millis() - lastBlink > interval) {
    lastBlink = millis();
    ledState = !ledState;
    digitalWrite(LED_BUILTIN, ledState);
  }
}

void handleWebServer() {
  WiFiClient client = server.available();
  
  if (client) {
    Serial.println("New web client connected");
    
    String request = "";
    String requestBody = "";
    bool isPost = false;
    int contentLength = 0;
    
    while (client.connected() && client.available()) {
      String line = client.readStringUntil('\n');
      
      if (request.length() == 0) {
        request = line;
        if (line.indexOf("POST") != -1) {
          isPost = true;
        }
      }
      
      if (line.indexOf("Content-Length: ") != -1) {
        contentLength = line.substring(16).toInt();
      }
      
      if (line == "\r") {
        if (isPost && contentLength > 0) {
          delay(10);
          requestBody = client.readString();
        }
        break;
      }
    }
    
    // Handle requests
    if (request.indexOf("POST /setrefresh") != -1) {
      int valuePos = requestBody.indexOf("interval=");
      if (valuePos != -1) {
        refreshInterval = requestBody.substring(valuePos + 9).toInt();
        if (refreshInterval < 5) refreshInterval = 5;  
        if (refreshInterval > 300) refreshInterval = 300;
      }
      client.println("HTTP/1.1 303 See Other");
      client.println("Location: /");
      client.println("Connection: close");
      client.println();
      
    } else if (request.indexOf("POST /anna/settemp") != -1) {
      int valuePos = requestBody.indexOf("temperature=");
      if (valuePos != -1) {
        float newTemp = requestBody.substring(valuePos + 12).toFloat();
        setAnnaTemperature(newTemp);
      }
      client.println("HTTP/1.1 303 See Other");
      client.println("Location: /");
      client.println("Connection: close");
      client.println();
      
    } else if (request.indexOf("POST /anna/setpreset") != -1) {
      int valuePos = requestBody.indexOf("preset=");
      if (valuePos != -1) {
        String preset = requestBody.substring(valuePos + 7);
        preset.trim();
        setAnnaPreset(preset);
      }
      client.println("HTTP/1.1 303 See Other");
      client.println("Location: /");
      client.println("Connection: close");
      client.println();
      
    } else if (request.indexOf("POST /hp/command") != -1) {
      // Handle heat pump commands from web
      int cmdPos = requestBody.indexOf("cmd=");
      int valPos = requestBody.indexOf("value=");
      if (cmdPos != -1 && valPos != -1) {
        String cmd = requestBody.substring(cmdPos + 4, requestBody.indexOf("&"));
        String val = requestBody.substring(valPos + 6);
        sendHeatPumpCommand(cmd, val);
      }
      client.println("HTTP/1.1 303 See Other");
      client.println("Location: /");
      client.println("Connection: close");
      client.println();
      
    } else if (request.indexOf("GET /api/data") != -1) {
      sendJSONResponse(client);
      
    } else {
      sendHTMLResponse(client);
    }
    
    client.stop();
    Serial.println("Client disconnected");
  }
}

void sendJSONResponse(WiFiClient &client) {
  // Parse current data
  parseHeatPumpData();
  
  client.println("HTTP/1.1 200 OK");
  client.println("Content-Type: application/json");
  client.println("Access-Control-Allow-Origin: *");
  client.println("Connection: close");
  client.println();
  
  client.print("{");
  
  // System status
  client.print("\"status\":{");
  client.print("\"wifi\":" + String(wifiConnected ? "true" : "false") + ",");
  client.print("\"mega\":" + String(megaConnected ? "true" : "false") + ",");
  client.print("\"mqtt\":" + String(mqttConnected ? "true" : "false") + ",");
  client.print("\"rssi\":" + String(WiFi.RSSI()) + ",");
  client.print("\"uptime\":" + String((millis() - startTime) / 1000));
  client.print("},");
  
  // Heat pump data
  client.print("\"heatpump\":{");
  client.print("\"water_temp\":" + String(hpData.waterTemp) + ",");
  client.print("\"outside_temp\":" + String(hpData.outsideTemp) + ",");
  client.print("\"return_temp\":" + String(hpData.returnTemp) + ",");
  client.print("\"evaporator_temp\":" + String(hpData.evaporatorTemp) + ",");
  client.print("\"compressor_temp\":" + String(hpData.compressorTemp) + ",");
  client.print("\"target_temp\":" + String(hpData.targetTemp) + ",");
  client.print("\"power\":" + String(hpData.currentPower) + ",");
  client.print("\"cop\":" + String(hpData.cop) + ",");
  client.print("\"fan_speed\":" + String(hpData.fanSpeed) + ",");
  client.print("\"mode\":\"" + hpData.operationMode + "\",");
  client.print("\"compressor\":" + String(hpData.compressorActive ? "true" : "false") + ",");
  client.print("\"defrost\":" + String(hpData.defrostActive ? "true" : "false") + ",");
  client.print("\"heating\":" + String(hpData.heatingActive ? "true" : "false") + ",");
  client.print("\"cooling\":" + String(hpData.coolingActive ? "true" : "false") + ",");
  client.print("\"dhw\":" + String(hpData.dhwActive ? "true" : "false") + ",");
  client.print("\"error\":\"" + hpData.errorCode + "\"");
  client.print("},");
  
  // Anna data
  client.print("\"anna\":{");
  client.print("\"current_temp\":" + String(annaCurrentTemp) + ",");
  client.print("\"setpoint\":" + String(annaSetpoint) + ",");
  client.print("\"mode\":\"" + annaPresetMode + "\",");
  client.print("\"heating\":" + String(annaHeating ? "true" : "false"));
  client.print("},");
  
  // Raw data
  client.print("\"raw_data\":" + lastMegaData);
  
  client.println("}");
}

void sendHTMLResponse(WiFiClient &client) {
  client.println("HTTP/1.1 200 OK");
  client.println("Content-Type: text/html; charset=UTF-8");
  client.println("Connection: close");
  client.println();
  
  // Parse current data
  parseHeatPumpData();
  
  client.println("<!DOCTYPE html>");
  client.println("<html>");
  client.println("<head>");
  client.println("<meta charset='UTF-8'>");
  client.println("<meta name='viewport' content='width=device-width, initial-scale=1.0'>");
  client.print("<meta http-equiv='refresh' content='");
  client.print(refreshInterval);
  client.println("'>");
  client.println("<title>Atlantic Aurea Control Center</title>");
  client.println("<style>");
  
  // Enhanced CSS
  client.println("body { font-family: 'Segoe UI', Arial, sans-serif; margin: 0; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); min-height: 100vh; }");
  client.println(".container { max-width: 1400px; margin: 0 auto; padding: 20px; }");
  client.println(".header { background: rgba(255,255,255,0.95); border-radius: 15px; padding: 20px; margin-bottom: 20px; box-shadow: 0 10px 30px rgba(0,0,0,0.2); text-align: center; }");
  client.println(".grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(300px, 1fr)); gap: 20px; margin-bottom: 20px; }");
  client.println(".card { background: white; border-radius: 10px; padding: 20px; box-shadow: 0 5px 15px rgba(0,0,0,0.1); }");
  client.println(".card h2 { margin-top: 0; color: #333; border-bottom: 2px solid #667eea; padding-bottom: 10px; }");
  client.println(".status-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(140px, 1fr)); gap: 10px; }");
  client.println(".status-item { background: linear-gradient(45deg, #667eea, #764ba2); color: white; padding: 10px; border-radius: 8px; text-align: center; }");
  client.println(".status-item.temp { background: linear-gradient(45deg, #f093fb, #f5576c); }");
  client.println(".status-item.active { background: linear-gradient(45deg, #4facfe, #00f2fe); }");
  client.println(".status-item.warning { background: linear-gradient(45deg, #fa709a, #fee140); }");
  client.println(".status-item.success { background: linear-gradient(45deg, #30cfd0, #330867); }");
  client.println(".label { font-size: 0.8em; opacity: 0.9; margin-bottom: 5px; }");
  client.println(".value { font-size: 1.5em; font-weight: bold; }");
  client.println(".control-panel { background: #f8f9fa; padding: 15px; border-radius: 8px; margin-top: 15px; }");
  client.println(".control-row { display: flex; align-items: center; gap: 10px; margin-bottom: 10px; flex-wrap: wrap; }");
  client.println(".btn { background: #667eea; color: white; border: none; padding: 8px 16px; border-radius: 5px; cursor: pointer; }");
  client.println(".btn:hover { background: #5a67d8; }");
  client.println(".btn-danger { background: #dc3545; }");
  client.println(".btn-danger:hover { background: #c82333; }");
  client.println(".btn-success { background: #28a745; }");
  client.println(".btn-success:hover { background: #218838; }");
  client.println("input, select { padding: 8px; border: 1px solid #ddd; border-radius: 5px; }");
  client.println(".indicator { display: inline-block; width: 12px; height: 12px; border-radius: 50%; margin-right: 5px; }");
  client.println(".indicator.on { background: #28a745; animation: pulse 2s infinite; }");
  client.println(".indicator.off { background: #6c757d; }");
  client.println("@keyframes pulse { 0% { opacity: 1; } 50% { opacity: 0.5; } 100% { opacity: 1; } }");
  client.println("</style>");
  client.println("</head>");
  client.println("<body>");
  
  client.println("<div class='container'>");
  
  // Header
  client.println("<div class='header'>");
  client.println("<h1>🔥 Atlantic Aurea Heat Pump Control Center</h1>");
  client.print("<p>System Status: ");
  if (megaConnected && wifiConnected && mqttConnected) {
    client.print("<span class='indicator on'></span>All Systems Online");
  } else {
    client.print("<span class='indicator off'></span>Limited Connectivity");
  }
  client.print(" | Home Assistant: ");
  client.print(discoveryPublished ? "Discovered ✓" : "Not Published");
  client.println("</p>");
  client.println("</div>");
  
  // Main grid
  client.println("<div class='grid'>");
  
  // Heat Pump Temperatures Card
  client.println("<div class='card'>");
  client.println("<h2>🌡️ Temperatures</h2>");
  client.println("<div class='status-grid'>");
  
  client.println("<div class='status-item temp'>");
  client.println("<div class='label'>Water</div>");
  client.print("<div class='value'>");
  client.print(hpData.waterTemp, 1);
  client.println("°C</div></div>");
  
  client.println("<div class='status-item temp'>");
  client.println("<div class='label'>Outside</div>");
  client.print("<div class='value'>");
  client.print(hpData.outsideTemp, 1);
  client.println("°C</div></div>");
  
  client.println("<div class='status-item temp'>");
  client.println("<div class='label'>Return</div>");
  client.print("<div class='value'>");
  client.print(hpData.returnTemp, 1);
  client.println("°C</div></div>");
  
  client.println("<div class='status-item temp'>");
  client.println("<div class='label'>Target</div>");
  client.print("<div class='value'>");
  client.print(hpData.targetTemp, 1);
  client.println("°C</div></div>");
  
  client.println("<div class='status-item temp'>");
  client.println("<div class='label'>Evaporator</div>");
  client.print("<div class='value'>");
  client.print(hpData.evaporatorTemp, 1);
  client.println("°C</div></div>");
  
  client.println("<div class='status-item temp'>");
  client.println("<div class='label'>Compressor</div>");
  client.print("<div class='value'>");
  client.print(hpData.compressorTemp, 1);
  client.println("°C</div></div>");
  
  client.println("</div>");
  client.println("</div>");
  
  // Heat Pump Status Card
  client.println("<div class='card'>");
  client.println("<h2>⚡ Heat Pump Status</h2>");
  client.println("<div class='status-grid'>");
  
  client.println("<div class='status-item " + String(hpData.compressorActive ? "active" : "") + "'>");
  client.println("<div class='label'>Compressor</div>");
  client.print("<div class='value'>");
  client.print(hpData.compressorActive ? "ON" : "OFF");
  client.println("</div></div>");
  
  client.println("<div class='status-item " + String(hpData.heatingActive ? "active" : "") + "'>");
  client.println("<div class='label'>Heating</div>");
  client.print("<div class='value'>");
  client.print(hpData.heatingActive ? "ON" : "OFF");
  client.println("</div></div>");
  
  client.println("<div class='status-item " + String(hpData.dhwActive ? "active" : "") + "'>");
  client.println("<div class='label'>DHW</div>");
  client.print("<div class='value'>");
  client.print(hpData.dhwActive ? "ON" : "OFF");
  client.println("</div></div>");
  
  client.println("<div class='status-item " + String(hpData.defrostActive ? "warning" : "") + "'>");
  client.println("<div class='label'>Defrost</div>");
  client.print("<div class='value'>");
  client.print(hpData.defrostActive ? "ON" : "OFF");
  client.println("</div></div>");
  
  client.println("<div class='status-item'>");
  client.println("<div class='label'>Power</div>");
  client.print("<div class='value'>");
  client.print(hpData.currentPower, 1);
  client.println(" kW</div></div>");
  
  client.println("<div class='status-item success'>");
  client.println("<div class='label'>COP</div>");
  client.print("<div class='value'>");
  client.print(hpData.cop, 1);
  client.println("</div></div>");
  
  client.println("</div>");
  
  // Heat Pump Control
  client.println("<div class='control-panel'>");
  client.println("<h3>Heat Pump Control</h3>");
  client.println("<form method='POST' action='/hp/command' style='display: flex; gap: 10px; flex-wrap: wrap;'>");
  client.println("<select name='cmd'>");
  client.println("<option value='SET_MODE'>Set Mode</option>");
  client.println("<option value='SET_TARGET'>Set Target Temp</option>");
  client.println("<option value='POWER'>Power On/Off</option>");
  client.println("<option value='DHW'>DHW On/Off</option>");
  client.println("</select>");
  client.println("<input type='text' name='value' placeholder='Value' style='width: 100px;'>");
  client.println("<button type='submit' class='btn'>Send Command</button>");
  client.println("</form>");
  client.println("</div>");
  
  client.println("</div>");
  
  // Anna Thermostat Card
  client.println("<div class='card'>");
  client.println("<h2>🏠 Anna Thermostat</h2>");
  client.println("<div class='status-grid'>");
  
  client.println("<div class='status-item temp'>");
  client.println("<div class='label'>Current</div>");
  client.print("<div class='value'>");
  client.print(annaCurrentTemp, 1);
  client.println("°C</div></div>");
  
  client.println("<div class='status-item temp'>");
  client.println("<div class='label'>Setpoint</div>");
  client.print("<div class='value'>");
  client.print(annaSetpoint, 1);
  client.println("°C</div></div>");
  
  client.println("<div class='status-item'>");
  client.println("<div class='label'>Mode</div>");
  client.print("<div class='value'>");
  client.print(annaPresetMode);
  client.println("</div></div>");
  
  client.println("<div class='status-item " + String(annaHeating ? "active" : "") + "'>");
  client.println("<div class='label'>Heating</div>");
  client.print("<div class='value'>");
  client.print(annaHeating ? "ON" : "OFF");
  client.println("</div></div>");
  
  client.println("</div>");
  
  // Anna Control
  client.println("<div class='control-panel'>");
  client.println("<h3>Thermostat Control</h3>");
  client.println("<div class='control-row'>");
  client.println("<form method='POST' action='/anna/settemp' style='display: flex; gap: 10px;'>");
  client.print("<input type='number' name='temperature' min='5' max='30' step='0.5' value='");
  client.print(annaSetpoint, 1);
  client.println("' style='width: 80px;'>");
  client.println("<button type='submit' class='btn'>Set Temp</button>");
  client.println("</form>");
  client.println("<form method='POST' action='/anna/setpreset' style='display: flex; gap: 10px;'>");
  client.println("<select name='preset'>");
  client.print("<option value='home'");
  if (annaPresetMode == "home") client.print(" selected");
  client.println(">Home</option>");
  client.print("<option value='away'");
  if (annaPresetMode == "away") client.print(" selected");
  client.println(">Away</option>");
  client.print("<option value='sleep'");
  if (annaPresetMode == "sleep") client.print(" selected");
  client.println(">Sleep</option>");
  client.print("<option value='vacation'");
  if (annaPresetMode == "vacation") client.print(" selected");
  client.println(">Vacation</option>");
  client.println("</select>");
  client.println("<button type='submit' class='btn'>Set Mode</button>");
  client.println("</form>");
  client.println("</div>");
  client.println("</div>");
  
  client.println("</div>");
  
  client.println("</div>"); // End grid
  
  // Refresh control
  client.println("<div class='card'>");
  client.println("<form method='POST' action='/setrefresh' style='display: flex; align-items: center; gap: 10px;'>");
  client.println("<label>Auto-refresh interval:</label>");
  client.print("<input type='number' name='interval' min='5' max='300' value='");
  client.print(refreshInterval);
  client.println("' style='width: 80px;'>");
  client.println("<span>seconds</span>");
  client.println("<button type='submit' class='btn'>Update</button>");
  client.print("<span style='margin-left: auto;'>Next refresh in <span id='countdown'>");
  client.print(refreshInterval);
  client.println("</span> seconds</span>");
  client.println("</form>");
  client.println("</div>");
  
  client.println("</div>"); // End container
  
  // JavaScript
  client.println("<script>");
  client.println("var seconds = " + String(refreshInterval) + ";");
  client.println("setInterval(function() {");
  client.println("  seconds--;");
  client.println("  if (seconds >= 0) document.getElementById('countdown').innerText = seconds;");
  client.println("}, 1000);");
  client.println("</script>");
  
  client.println("</body>");
  client.println("</html>");
}

[WackoH]

Ziet er al indrukwekkend uit!
Ik ben benieuwd hoe het zich ontwikkeld.

PS: Het is mogelijk om van de codevelden in je post uitklapbaar te maken. Het trucje hiervoor schijnt te zijn om het binnen een quote-blok te zetten. Dat houdt het forum wat toegankelijker

[ Voor 57% gewijzigd door WackoH op 05-09-2025 17:17 ]

[Maartenkromhout]

Dank voor de tip ik had zitten zoeken maar kon het niet vinden. plaatst niet zo veel hier

[_JGC_]

Gisteren de Aurea installatie voltooid, vandaag met de regeling gestart. Allereerst: zonder de Smile gateway gebeurt er hier niks. Ook geprobeerd een iSense aan te sluiten op de OT pinnen, thermostaat gaat aan maar er is geen communicatie op de IC2 pinnen voor OT.

Kan zijn dat mijn voltage level shifter niet lekker is en het daarom niet werkt, maar helpen doet het niet.

Volgende waar ik tegenaan loop is dat de ESP8266 maar 1 UART heeft en die hangt aan de USB interface. Die moet je swappen en daarna kan je de warmtepomp aansturen, maar dan heb je ook geen debug meer.

[WackoH]

Als ik me goed herinner, heb ik de boel wel een tijdje met een Remeha Celcia 20 i.p.v. Plugwise draaiend gehad. Maar het is wel fijn om de thermostaat via Plugwise op afstand te kunnen bedienen. Vandaar dat ik Anna Plugwise nu gebruik.

Nieuwe ketels kunnen problemen geven:
.
Snappen doe ik het niet: Als de ketel dan toch via aan/uit gaat, kun je de Controlbox toch ook op aan/uit zetten, zou je denken.

Het is bij mij soms lastig om de OpenTherm communicatie tussen controlbox en ketel (Remeha Avanta) op gang te krijgen, met name als het ketelprotocol in de Plugwise is gewist. Ik heb er daarom een HomeWizard Heatlink tussen zitten. Deze heb ik vroeger gebruikt om de ketel aan te sturen.
Deze heeft als voordeel dat het Openthermsignaal via relais wordt onderbroken: Geen stroom = geen invloed. Schakel ik 'm in, dan zie ik aan LEDs of de communcatie OK is of niet. Bovendien lijkt de Heatlink de communicatie in orde te kunnen maken (ik weet niet hoe of wat, maar het werkt om 'm even aan te zetten).

De communicatie tussen beide MCU's wordt door een van beiden geïnitieerd (die stuurt iedere 5 s een bitstream). Ik weet niet meer welke

PS: Pas op (schade en schande...) met te veel apparaten in de OpenTherm-keten. Ieder apparaat geeft vertraging en het protocol geeft storing als de vertraging te groot wordt. Thermostaat, ControlBox, HeatLink, ketel is op de grens. Nog iets erbij (bv. een OpenTherm Gateway) en het loopt op ene bepaald moment fout spaak met als gevolg dat de ketel vol aan gaat...

[WackoH]

Snappen doe ik het niet: Als de ketel dan toch via aan/uit gaat, kun je de Controlbox toch ook op aan/uit zetten, zou je denken.

Blijkbaar niet. Met relais (a 73 Euro) moet controlbox ook op aan/uit:

[_JGC_]

Heb 'm eindelijk werkend. En een herrie dat ding...

iSense ingesteld op 20 min, 32 max. Vervolgens de temperatuur omhoog geslingerd en de boel ging aan. Vermoedelijk 800W, buurman die bang is voor geluid kwam net thuis. Terwijl we stonden te praten toerde 'ie af naar een lager vermogen. Mogelijk moet ik het ding toch een kwartslag gaan draaien met een flexibele RVS leiding, dan blaast 'ie naar de oprit ipv naar de buren.

Wat er nodig was: originele chips terug in de socket en de aansturing van de (niet aangesloten) ketel op aan/uit.
Blijkbaar zet een van de chips een relais om zodra de warmtepomp iets moet doen en komt dan pas communicatie op gang. Ik had zonder aangesloten ketel een C7 storing op de buitenunit.

Pomp in de unit mag nog wel standje harder, mijn ketel verpompt op stand 3 meer water dan deze warmtepomp.
Heb vanmorgen het testprogramma op de buitenunit gestart, ik werd toen wel even bang van wat die pomp op de hoogste stand kon wegpompen (en vooral het geluid en brommen wat daarbij hoort)

Ik ga kijken of ik een pin-compatible controller in het voetje van de HP controller kan zetten, dan laat ik de OT sturing intact.

[WackoH]

Ik vind het geluid eerlijk wel meevallen.
De fan heeft voor zover ik weet en vaste snelheid. De compressor heeft een groot bereik (tussen ~150 en 1500 W), hangt van temperaturen af). De waterpomp kan op drie standen.
Volgens mij heeft het niet zo veel zin om de pomp van WP harder te zetten, net zo goed als dat het weinig zin heeft om de pomp van je CV op 3 (hoogste?) te zetten. De delta_T zijn toch maar relatief klein en hard pompen geeft alleen maar extra geluid en e-verbruik.

Een ATMega 168 en 328 zijn volgens mij pin compatibel (maar check dat nog even).

[_JGC_]

WackoH schreef op zondag 14 september 2025 @ 21:04:
Ik vind het geluid eerlijk wel meevallen.
De fan heeft voor zover ik weet en vaste snelheid. De compressor heeft een groot bereik (tussen ~150 en 1500 W), hangt van temperaturen af). De waterpomp kan op drie standen.
Volgens mij heeft het niet zo veel zin om de pomp van WP harder te zetten, net zo goed als dat het weinig zin heeft om de pomp van je CV op 3 (hoogste?) te zetten. De delta_T zijn toch maar relatief klein en hard pompen geeft alleen maar extra geluid en e-verbruik.

Een ATMega 168 en 328 zijn volgens mij pin compatibel (maar check dat nog even).

Ketel op stand 2 krijgt het water niet voldoende naar de woonkamer. Gevolg is dat aanvoertemperatuur heel snel oploopt en korte runs.
Zag nu al verschil in temperaturen op beide radiatoren, dus mogelijk moet de pomp een stand harder. Als stand 2 op de warmtepomp tussen stand 2 en 3 van de ketel in zit ben ik blij.

Warmtepomp had de aanvoer maar zo naar 32 graden overigens, maargoed... normaal stook ik de ketel niet met deze temperaturen.

[WackoH]

Mmm, klinkt alsof je huis via een rietje met CV en warmtepomp is verbonden

Geen ideale uitgangssituatie voor efficient gebruik van een warmtepomp omdat er meer water rond moet om de warmte over te dragen: Van een typische delta_T van 20oC (bv. 60/40) bij CV naar 5oC (35/30). Dus 4x water moet er rond om dezelfde kW's over te dragen.

Staat er misschein ergens iets geknepen?

[_JGC_]

WackoH schreef op maandag 15 september 2025 @ 21:10:
Mmm, klinkt alsof je huis via een rietje met CV en warmtepomp is verbonden

Geen ideale uitgangssituatie voor efficient gebruik van een warmtepomp omdat er meer water rond moet om de warmte over te dragen: Van een typische delta_T van 20oC (bv. 60/40) bij CV naar 5oC (35/30). Dus 4x water moet er rond om dezelfde kW's over te dragen.

Staat er misschein ergens iets geknepen?

Het water moet eerst 2 verdiepingen opgevoerd worden met een 28mm buis en splitst daar naar 2x22mm. Ik heb 2 jaar terug heel wat leidingwerk opnieuw gelegd en knietjes verwijderd, moet op het zuid stuk nog een paar vervangen door gebogen bochten.

Ik heb nu ketel en warmtepomp samenkomend op een 28mm T-stuk, vanaf daar naar zolder en daar weer splitsen naar 2x22mm.

Ik vind de warmtepomp op stand 1 heel tam qua pompgeluid, hoor dat ding totaal niet. Ik kijk het even aan. Zag wel dat warmtepomp in 25 minuten tijd het water van 20 naar 35 had gezet, daarna daalt 'ie naar 32 en blijft daar met een hele kleine zaagtand gewoon rond hangen. Moet de heatboosters nog wat beter afstellen, want bij 35 graden heb ik 30 retour, bij afzakken naar 32 blijft het 30 retour.

Denk dat het verschil tussen woonkamer en eethoek vooral de afstand is. Er zit 1,2 graad verschil tussen beide radiatoren. Op de lus naar de woonkamer zit nog een geknepen badkamer radiator en 2 slaapkamers, die op noord loopt door 1 slaapkamer. Grote kans dat het gewoon leidingverlies is. Op standje 3 van de ketel rag je dat water zo snel rond dat het onderweg amper tijd heeft om warmte te verliezen.

Ik stookte vorig jaar met ketel op 40/35. Met pomp op stand 3 had de ketel het moeilijk om naar die 40 graden te komen. Wat de warmtepomp nu ook mee heeft is dat het verwarmen gewoon doorgaat terwijl ik sta te douchen.

Overigens nog 1 ding: ik heb er nu een iSense aan, die krijgt de warmtepomp wel aan, maar als de temperatuur gehaald is schakelt de thermostaat af maar staat de warmtepomp meer dan een halfuur later nog steeds te draaien. Ik zet 'm dan maar gewoon uit met de schakelaar op de controlbox, ketel zit toch niet aangesloten. Al die tijd blijft vlammetje branden op de iSense.

Ik ga morgen met een experimenteerbordje en wat sockets de HP MCU verhuizen en dan zelf proberen aan te sturen. Ook kijken of de DIYLESS beter werkt dan een iSense.

edit: heatbooster stond op 45% bij 37 graden. Nu op 45% bij 32 graden gezet. Dingen worden wakker vanaf 25 graden en boosten naar full speed bij kamertemperatuur van 18.5 of lager.

[ Voor 3% gewijzigd door _JGC_ op 15-09-2025 22:01 ]

[WackoH]

Je leiding werk is dan best ruim.

Op zich zou pompen naar zolder geen probleem moeten zijn omdat het water ook weer naar beneden moet en het systeem gesloten is.

fan en pomp hoor ik ook niet. Enige wat geluid maakt is de compressor, maar je moet op hooguit en een paar meter staan om iets te horen.

Het vlammetje op de thermostaat betekent volgens mij dat de ketel aangeeft dat 'ie brandt. Bij oude versies van de MCU's kwam zo'n signaal niet door van de WP, bij nieuwere schijnbaar wel (ik heb een oude). Zou de thermostaat de 'ketel' op laag niveau door laten draaien?

Voor zover ik weet stuurt de WP zelf niet op de aanvoertemperatuur. Dat doet de controlbox die op basis van de aanvoertemperatuur de vermogensvraag naar de WP getrapt aanpast. Vandaar die zaagtand. De WP bewaakt alleen dat de aanvoertemperatuur niet >60.5oC wordt (tenminste, in de standaard uitvoering).

Dat met die heatboosters snap ik niet helemaal. Klopt als COP1 verwarming en dat willen we niet met z'n allen haha.

Succes met de experimenteerprint!

[_JGC_]

Ik hoor juist alleen de (airflow van de) fan, compressor hoor ik nauwelijks.

Thermostaat geeft een vlammetje en geen radiator. Er is geen vraag, wel "flame on". Misschien dat de iSense gewoon incompatible is... met de Intergas ketel stuurde de iSense gewoon een laag setpoint en ging de ketel dan uit met "temperatuur bereikt". Ik vermoed dat dat niet werkt met de controlbox.

Gisteravond de boel werkend gekregen, daarna met de knop op ketel gezet. Vanmorgen keek ik weer en toen stond het vlammetje er nog steeds. 24.5 graden op zoldertje en 22 graden instelling op thermostaat, dus die vraagt geen warmte meer.

De heatbooster (heatmeister tegenwoordig) is een printje van een medetweaker waar je 15 fans aan kunt hangen. Die koelen mijn 300x50 en 330x50 T22 radiatoren beneden zodat ik LTV kan stoken. Zit ook defrost detectie in, die heb ik ook maar aangezet. 45% vermogen is wat hier nog kan zonder dat je je stoort tijdens TV kijken. Die 100% boost bij <18.5 graden is oorverdovend maar 's morgens hebben de kinderen tijdens het ontbijt toch meer geluid .
Wil alleen met WP de nachtverlaging niet zo ver laten komen.

Edit: met de DIYLESS gaat de warmtepomp gewoon direct uit als de thermostaat dat wil. Thermostaat regelt mooi: als temperatuur gehaald is daalt setpoint en warmtepomp blijft mooi draaien. Thermostaat moet nog even het PID algoritme tunen, maar hoeft nu geen rekening meer te houden met de wispelturigheid van een veel te dikke ketel.

[ Voor 14% gewijzigd door _JGC_ op 16-09-2025 17:04 ]

[_JGC_]

@WackoH In jouw huidige setup, onderbreek je dan alleen de TX tussen MCU en WP, of ook de RX?

[WackoH]

Ik heb alleen de Tx van de WP-MCU naar WP onderbroken. De Rx luister ik alleen af..

De Control box vindt dit niet leuk want af en toe knippert de rode led in de schakelaar (check op afwijking tussen aansturing en feedback?). Maar 'boeie', want communicatie naar de Opentherm MCU vang ik toch op en pas aan.
Aha, dat zijn dus andere heatboosters! Ik kende dat project helemaal niet. Weer wat geleerd

[_JGC_]

Arduino Mega is onderweg. Denk dat mijn voltage level converters gewoon ruk zijn, dus dan maar een 5V controller gebruiken. ESP heeft ook maar anderhalve hardware UART, de Mega heeft er 4.

Verder nog even mbt pomp: ik heb 3,6 meter opvoerhoogte vanaf de ketel. De ketel doet op stand 2 iets meer dan 500 liter per uur. Op stand 3 doet die 1500 liter per uur.
De warmtepomp staat lager, die heeft 4,8 meter opvoerhoogte. Als ik in de handleiding het tabelletje bekijk is het 600 liter per uur op stand 1 en 1000 liter per uur op stand 2.
Wat mij betreft perfect dus, ik hoor de ketel door het hele huis ruisen met 1500 liter per uur, de warmtepomp hoor je nauwelijks met 1000 liter per uur.

[_JGC_]

@WackoH Ik zie in je foto's dat je R17 hebt losgekoppeld. Neem aan dat je die weer vastknoopt via je plankje en dan nog een 4.7K weerstand tussen die aftakking en de Mega controller zet?

[_JGC_]

Heb 'm inmiddels werkend, maar dan nog zonder manipulatie van de data, dus de OT controller staat ook continu in CV mode, ik krijg niks aan temperaturen terug in de thermostaat. Kan ook zijn dat het algoritme te traag is voor dat ding, met de standaard regeling gaat ie gewoon vol gas naar 32 graden en daarna terugregelen, de sturing uit de voorbeeldcode bouwt mooi op.
Verder haal ik met de pomp op 2 wel een mooie deltaT, die had ik met de pomp op 1 niet.

Om mijn vorige vraag te beanwoorden: ik heb een 5.1K weerstand op de RX gezet. Ik had geen 4.7K liggen.

Verder zitten er 2 bugs in de voorbeeldcode:
- not ok wordt gelogd als de data wel ok is (fijn als je al twijfelt aan de gebruikte weerstand )
- de compute aanroep voor quickpid zit niet in loop(), speedstate blijft dan altijd 0.

Verder gebruik ik niet de Anna, maar een DIYLESS. Die gaat na uitschakelen naar een setpoint van 10 graden. Heel onschuldig nu, maar als het winter wordt moet ik dat mogelijk compenseren.

[_JGC_]

Klaar met prutsen. Situatie nu:
- IC4 is eruit
- IC2 zit er nog in
- solderingen gedaan, printbaan naar TX-pad niet doorgesneden, IC4 is eruit dus niet nodig.
- DIYLESS doet de thermostaatregeling en duwt de aanvoer/retour/setpoint naar MQTT

Aangepaste versie van de code van @WackoH:

code:

/* 
Alternative control for the Atlantic Aurea heat pump, which based on the Chofu AEYC-0643XU-AT unit.
This is a sketch to control the power setting of a heat pump with an Arduino ATMega2560 and to modify communication inside the controlbox using 3 of the 4 hardware serial ports of this board. 
The original code shows various useful information like temperatures etc. on a 480*320 TFT LCD. This has been removed here to keep the code more compact.
Version 0.1Beta, JHN 19-03-2025
*/

#include <QuickPID.h>                                   // Library for PID controller, see for documentation: https://github.com/Dlloydev/QuickPID

//Define variables and constants
// General
String MessageString = "";

  // For heat pump
const uint8_t SpeedStages = 7;                        // Number of speed stages to be used (7 --> ~1400 W max)
uint8_t SpeedSetpoint = 0;                            // Speed setpoint sent to heatpump   // const uint8_t MinTempSetpoint = 25;
uint8_t TargetTemperatureThermostat = 20;             // Target temperature as requested by the thermostat
const float MinTemp4HP = -15;                         // Outside temperatute below wich heat pump should stop working and CV should start
uint16_t TelegramCount = 0;                           // Follow-up number of telegrams
// Variables to track timings
uint32_t Interval = 0;                                // Time since last telegram
uint32_t currentMillis = 0;                           // Check timing for sending messages
uint32_t LastSpeedSetpointChange = 0;                 // Keep track when last time speedsetpint has been changed in milliseconds
uint32_t SpeedSetpointHysteresis = 420000;            // Allow a change in speedsetpoint only once per 7 minutes (when using slow PID parameter set)
// Cycle time check
uint32_t previousCycleMicros = 0;                     // To store the time of the last cycle start
uint32_t currentCycleMicros = 0;                      // To store the time of the current cycle start
uint32_t cycleTime = 0;                               // To store the calculated cycle time
uint16_t cycleCounter = 0;                            // Counter to track cycles
const uint16_t displayInterval = 10000;               // Display cycle time every 10000 cycles
uint8_t lcdUpdateStep = 0;                            // Variable to spread writing to screen over multiple steps
// Receive and send inter MCU data 
const uint32_t McuMessageWaitTime = 200;              // Waiting time between receiving message on Pad 1 (Serial 1) and sending on pad 2 (serial 2) in ms
uint32_t McuMessageOneReceived = 0;                   // Tie last message send in ms
bool dataMcu2Send = false;
uint32_t PreviousMessageSerial1Sent = 0;   
uint32_t MessageSerial1Interval = 4200;              // Maximum interval for sending message on serial 2 (to avoid that communication stops)
const uint8_t DataMcuLength = 12;                     // Length of each transmission between MCU's
uint8_t dataArrayOT_IC1_IC2[DataMcuLength] = {32,20,154,0,0,0,0,32,29,7,0,18};     // Array to store the incoming 12 bytes for OT IC1 to IC2.
uint8_t dataArrayOT_IC2_IC1[DataMcuLength] = {0};     // Array to store the incoming 12 bytes for OT IC2 to IC1. 
uint16_t ChecksumMCU = 0;                             // Checksum for communication between MCU's
// Variables for communication with heat pump
uint8_t CB_HPlength = 0;                              // Length of communcation CB to HP
uint16_t ChecksumCBHP = 0;                            // Checksum for communication of heat pump with control box
uint8_t ChecksumCBHPfalseCount = 0;                   // Counter for number of times that the checksum did not match. After certain number of mismatches, message will be send to the serial port
uint8_t data0[] = { 0x19, 0x0, 0x8, 0x0, 0x0, 0x0, 0xd9, 0xb5 };                       // Array of hexadecimal bytes
uint8_t data1[] = { 0x19, 0x1, 0x0c, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaa, 0x35 };  // Array of hexadecimal bytes
uint8_t data2[] = { 0x19, 0x2, 0x8, 0x1, 0x1, 0x0, 0x99, 0x37 };                       // Array of hexadecimal bytes. This is the one to change bytes 4 (on/off) and 5 (setpoint), and 7 and 8 (high and low bytes of the CRC CCITT checksum)
uint8_t data3[] = { 0x19, 0x3, 0x8, 0xb2, 0x2, 0x0, 0xc1, 0x9a };                      // Array of hexadecimal bytes

// Variables for sending messages to heat pump
bool IncomingMessageEnded = false;                      // Last message start time in milliseconds
volatile uint32_t PreviousMessageSent = 0;              // Time when prveious message was sent in milliseconds
volatile bool IsReceiving = false;                      // Tracks if message is being received from heat pump to block sending next message to heat pump
const uint32_t SendTimeout = 2000;                      // Time in milliseconds to wait before considering the communication ended
const uint32_t SendDelay = 99;                          // Delay in milliseconds before sending information to heatpump
const uint32_t MinMessageSendInterval  = 300;           // Minimum interval in millis between sending messages when no reply is received
volatile uint32_t previousMessageInEnded = 0;

// Definitions for reading and checking heat pump data
// Prepare array for storing data from heatpump
const uint8_t StartByte = 0x91;                     // First byte must be 145 (0x91)
const uint8_t Rows = 4;                            // Number of rows in heat pump data array 
const uint8_t Cols = 80;                            // Number of columns in heat pump data array 
uint8_t numChars = 0;                               // Number of characters to be written to screen
uint8_t dataHeatPumpTemp[Cols][Rows] = {0};         // Array to store of four messages from heatpump before checksum check
uint8_t dataHeatPump[Cols][Rows] = {0};             // Array to store of four messages from heatpump after checksum is correct
uint8_t dataHeatPumpOld[Cols][Rows] = {0};          // Array to store previous data of four messages so that screen is only updayted when needed
uint8_t extractedRow[Cols];                         // 1D array to store the row  
const uint8_t ValidLengths[] = {13, 14, 19, 21};    // Lengths 12, 13, 18 & 20   (12+1), (13+1), (18+1), (20+1)
uint16_t value;                                     // Temporarily storage of datapoint from array
float valuefloat;
uint8_t Length = 0;
float T_supply =0;                                  // Supply water temperature by heatpump
float T_return =0;                                  // Return water temperature to heatpump
float T_outside =0;                                 // Outside temperature measured on heatpump
// State variables for non-blocking serial reading
enum SerialState {  Wait_Start,                     // Waiting for the start of a serial message  
                    Read_Header,                    // Reading the header of the message  
                    Read_Payload,                   // Reading the main data (payload)  
                    Read_End                        // Reading the end of the message  
                  };                              // Enumeration type, which helps in defining different states of serial communication
SerialState state = Wait_Start;                     // Make waiting to start the default
uint8_t ID = 0;
uint8_t msgLength = 0;
uint8_t DataLength = 0;
uint8_t buffer[Cols] = {0};                         // Temporary buffer for incoming data
uint8_t index = 0;
int8_t NegT = 0;                                    // Store if temperature is negative (value of 255 in MSB)
// For PID controller 
float TemperaturePIDsetpoint = 10;                  // Desired supply temperature
const float TemperaturePIDsetpointMax = 37;         // Maximum temperature setpoint
const float TemperaturePIDsetpointMin = 25;         // Maximum temperature setpoint
const float TemperaturePIDsetpointOff = 10;
float TemperaturePIDinput = 0;                      // Current suppy temperature (feedback from the sensor in the heatpump)
float TemperaturePIDoutput = 0;                     // Heat pump control signal
float TemperaturePIDoutputRounded = 0;              // Heater control signal, rounded off
// PID tuning parameter. Default values were Kp = 2.0, Ki = 5.0, Kd = 1.0
uint8_t PIDParameterSet = 0;                        // Keep track of whcih PID parameters set is being used so that new parameter or only written when required
float Sensitivity = 3;                              // Sensitivity (ratio) between the slow and fast PID settings. Optionally make this chnageable via rotary encoder
float PIDParameterThreshold = 1;                    // Threshold for switch between fast (agressive) and slow (conservative) PID parameters
float T_GapPIDParameterSwitch = 0;                  // Gap between the setpoint and actual temperature, used to determine which set PID parameters to use 
const float Kp0 = 0.02, Ki0 = 0.008, Kd0 = 0.01;// 
float Kp = Kp0, Ki = Ki0, Kd = Kd0;// 
// Create PID object
QuickPID myPID(&TemperaturePIDinput, &TemperaturePIDoutput, &TemperaturePIDsetpoint, Kp, Ki, Kd, /* OPTIONS */
                myPID.pMode::pOnError,                   /* pOnError, pOnMeas, pOnErrorMeas */
                myPID.dMode::dOnMeas,                    /* dOnError, dOnMeas */
                myPID.iAwMode::iAwCondition,             /* iAwCondition, iAwClamp, iAwOff */
                myPID.Action::direct);                   /* direct, reverse */

void setup() {
  // Serial Setup
  Serial.begin(115200);                                   // Start the Serial Monitor for debugging on terminal (Serial port 0)
  Serial2.begin(9600);                                    // Start serial port 1 for receiving messages from OT MCU to HP MCU (RX1, 9600 bps)
  Serial3.begin(666);                                     // Start serial port 3 for sending an receiving info to heat pump at 666 baud (RX3 and TX3)
  Serial2.setTimeout(100);                                // Changes the timeout for readBytes() and other blocking serial read functions (readString(), readBytesUntil(), etc.).
  // For QuickPID
  myPID.SetOutputLimits(0, 99);                           // Set to max 99% to have max. 4 digits ('99.9')
  myPID.SetSampleTimeUs(5000000);                         // Sample time of PID controller in microseconds. Made slower than default because of relatively slow temperature changes and heat pump response to save processing time.
  myPID.SetTunings(Kp, Ki, Kd);
  myPID.SetMode(myPID.Control::automatic);                // Set PID controller in automatic, i.e. input (PV) is perdiodically compared with setpoint (SP) and control variable (CV) is adjusted 

  delay(5000);
  Serial.println("Setup complete.");
}

//////////////// Main loop ////////////
void loop() {
  currentMillis = millis();                                 // get curent millis (ms) for sending message to heat pump
  currentCycleMicros = micros();                            // Capture the current time (in us) to calculate the cycle time of the loop
  cycleCounter++;                                           // Increment the cycle counter
  
  // Check for incoming data on Serial 1 (Pad 1 from MCU 2), 2 (Pad 2 from MCU 1) and Serial 3 (data from heat pump)
  readSerialMessageHP();                                      // Call this function continuously to check for data on the incoming serial port from the heat pump
  if (Serial2.available() >= DataMcuLength) {                 // Check whether the serial buffer connected to Pad 1 contains DataMcuLength (12) bytes or more  
    readSerialMessageMCU(1);                                  // When so, jump to subroutine to read the bytes or clear the buffer
    //TemperaturePIDsetpoint = 1 + 0.85 * dataArrayOT_IC2_IC1[0];// Scale the setpoint from the thermostat (0, and 30~40oC) to 25~37oC
    TemperaturePIDsetpoint = dataArrayOT_IC2_IC1[0];
    if (TemperaturePIDsetpoint > TemperaturePIDsetpointMax){
      TemperaturePIDsetpoint = TemperaturePIDsetpointMax;
    } else if (TemperaturePIDsetpoint <= TemperaturePIDsetpointOff) {
      TemperaturePIDsetpoint = 0;
    } else if (TemperaturePIDsetpoint < TemperaturePIDsetpointMin) {
      TemperaturePIDsetpoint = TemperaturePIDsetpointMin;
    }
  }

  
  // Write modified message from MCU 1 to 2 on serial 2
  if ((currentMillis-PreviousMessageSerial1Sent) > MessageSerial1Interval)  {
    readSerialMessageMCU(2);
    Serial2.write(dataArrayOT_IC1_IC2, sizeof(dataArrayOT_IC1_IC2));    // Write array to serial port 2
    PreviousMessageSerial1Sent = currentMillis;
  }
  

  // Send the next message to the heat pump 100 ms after the previous incoming message has ended, or after 1000 ms without sending anything. Use the periodic sending also to update the screen
  currentMillis = millis();                                 // get curent millis (ms) for sending message to heat pump
  if ((( (currentMillis - previousMessageInEnded >= SendDelay)  &&  (!IsReceiving))  || ( currentMillis - previousMessageInEnded >= SendTimeout )) && (currentMillis - PreviousMessageSent >= ( MinMessageSendInterval ))) 
  {
    switch (TelegramCount) {
      case 0:
        Serial3.write(data0, sizeof(data0));
        break;
      case 1:
        Serial3.write(data1, sizeof(data1));
        break;
      case 2:
        SpeedSetpoint = (int)round( TemperaturePIDoutput / (100 / SpeedStages )) ;    // Scale the PID controller output from 0~100% to 0~8 speed setpoints, and convert from double to rounded integer
        if (SpeedSetpoint == 0 && TemperaturePIDsetpoint > 0) {
          // Workaround: We still want heat, but not much. Keep WP running
          SpeedSetpoint = 1;
        }
        if (SpeedSetpoint == 0) {
          data2[3] = 0x0;
          data2[4] = 0x0;
        } else if ((PIDParameterSet == 0) && (currentMillis - LastSpeedSetpointChange > SpeedSetpointHysteresis)) { // Add hysteresis when slow PID parameter set is active
          data2[3] = 0x1;
          data2[4] = SpeedSetpoint;                 // Write calculate speed setpoint in array  
          LastSpeedSetpointChange = currentMillis;
        } else if ((PIDParameterSet > 0) && (currentMillis - LastSpeedSetpointChange > SpeedSetpointHysteresis/5)) { // Hysteresis 1/5 of default when fast PID parameter set is active to allow for fast respons
          data2[3] = 0x1;
          data2[4] = SpeedSetpoint;             // Write calculate speed setpoint in array  
        }
         
        CB_HPlength = sizeof(data2);
        calculate_CRC_CCITT_Checksum(data2, CB_HPlength-2, &ChecksumCBHP);  
        data2[6] = (ChecksumCBHP >> 8) & 0xFF;          // Replace byte 6 with checksum High Byte
        data2[7] = ChecksumCBHP & 0xFF;                 // Replace byte 7 with checksum Low Byte
        Serial3.write(data2, sizeof(data2));
        break;
      case 3:
        Serial3.write(data3, sizeof(data3));
        break;
      default:
        Serial.print("Invalid TelegramCount value:  ");Serial.println(TelegramCount); 
        break;
    }
    TelegramCount = (TelegramCount + 1) % 4;          // Cycle through 0-3
    PreviousMessageSent = millis();
  }

  if (cycleCounter >= displayInterval) {
    if (previousCycleMicros != 0) {
      cycleTime = ( currentCycleMicros - previousCycleMicros ) / displayInterval;  // Time difference between cycles
      previousCycleMicros = currentCycleMicros;           // Update the previous cycle time
      cycleCounter = 0;                                   // Reset the cycle counter
    } else {
      previousCycleMicros = currentCycleMicros;
    }
  
    switch (lcdUpdateStep) {
      case 0:                                             // Print the cycle time etc. The timing for sneding message to the heatpump wil be oof when the cycle time is too long (> ~50 ms)
        Serial.println("Cycle time "+String(cycleTime)+" ms");
        break;
      case 1:                                             // Print PID settings
        break;
      case 2:                                             // Compresor speed 91-3,9
        if (dataHeatPump[9][3] != dataHeatPumpOld[9][3]) {  // Data has changed?
          Serial.print("Speed setpoint: "); Serial.println(dataHeatPump[9][3]);
          }
        break;
      case 3:                                             // Compresor power 91-3,10
        if (dataHeatPump[10][3] != dataHeatPumpOld[10][3]) {
          MessageString = String((25.6 * dataHeatPump[10][3]),0);
          Serial.print("Compressor power: "); Serial.println(MessageString);
          dataHeatPumpOld[10][3] = dataHeatPump[10][3];
        }
        // Compressor mode 91-1,3
        if (dataHeatPump[3][1] != dataHeatPumpOld[3][1]) {
          Serial.print("Compressor mode: "); Serial.println(dataHeatPump[3][1]);
          dataHeatPumpOld[3][1] = dataHeatPump[3][1];
        }
        // Defrost?   91-1,4
        if (dataHeatPump[4][1] != dataHeatPumpOld[4][1]) {
          Serial.print("Defrost ongoing? "); Serial.println(dataHeatPump[4][1]);
          dataHeatPumpOld[4][1] = dataHeatPump[4][1];
        }
        break;
      case 4:
        // ?Data? 91-3,5
        if (dataHeatPump[5][3] != dataHeatPumpOld[5][3]) {
          Serial.print("Generic info "); Serial.println(dataHeatPump[5][3]);
          dataHeatPumpOld[5][3] = dataHeatPump[5][3];
        } 
        break;
      case 5:                                             // Temperatures
        // Supply temperature   91-2,3~4
        if (dataHeatPump[3][2] != dataHeatPumpOld[3][2]) {
          value = dataHeatPump[4][2];                             // MSB of temperature; previous byte is the MSB
          T_supply = (((value*256+dataHeatPump[3][2])-(65536*((value == 255) ? 1 : 0)))/10.0);  // Do the conversion to temperature in such a way that also negative temperature can be shown
          TemperaturePIDinput = T_supply;                       // Make the input the PID controller equal to the current supply water temperature   
          MessageString = String(T_supply,1);
          Serial.print("Supply temperature "); Serial.println(MessageString);
          dataHeatPumpOld[3][2] = dataHeatPump[3][2];
        }
        // Return temperature 91-2,5~6
        if (dataHeatPump[5][2] != dataHeatPumpOld[5][2]) {
          value = dataHeatPump[6][2];               // MSB of temperature; previous byte is the MSB
          T_return = (((value*256+dataHeatPump[5][2])-(65536*((value == 255) ? 1 : 0)))/10.0);  // Do the conversion to temperature in such a way that also negative temperature can be shown
          MessageString = String(T_return,1);
          Serial.print("Return temperature "); Serial.println(MessageString);
          dataHeatPumpOld[5][2] = dataHeatPump[5][2];
        }
        break;
      case 6:
        // Outside temperature 282 91-2,7~8
        if (dataHeatPump[7][2] != dataHeatPumpOld[7][2]) {  
          value = dataHeatPump[8][2];               // MSB of temperature; previous byte is the MSB
          T_outside = (((value*256+dataHeatPump[7][2])-(65536*((value == 255) ? 1 : 0)))/10.0);  // Do the conversion to temperature in such a way that also negative temperature can be shown
          MessageString = String(T_outside,1);
          Serial.print("Outside temperature "); Serial.println(MessageString);
        }
        break;
      case 7:                                             // Do PID calculation
        // Evaluate PID calculation    
        T_GapPIDParameterSwitch = abs(TemperaturePIDsetpoint - TemperaturePIDinput);    // Check the gap between the temperature setpoint adn the actual temperature
        if ((T_GapPIDParameterSwitch < PIDParameterThreshold) && (PIDParameterSet = 1)) { // If the gap is smaller than the threshold and the PID controller is currently using the fast set, then
          Kp = Kp0; Ki = Ki0; Kd = Kd0;                       // Choose slow (conservative) settings
          myPID.SetTunings(Kp, Ki, Kd);                       // Write a new set of control parameter
          PIDParameterSet = 0;                                // Set parameter to default default (low) settings
        } else if (PIDParameterSet = 1) {                          // Gap larger than threshold but slow parameters are used, then 
          Kp = Sensitivity*Kp0;                           // Choose fast or aggressive settings by larger gap
          Ki = Sensitivity*Ki0; 
          Kd = Sensitivity*Kd0;
          myPID.SetTunings(Kp, Ki, Kd);                   // Write a new set of control parameter
          PIDParameterSet = 1;                            // Set parameter to default default (low) settings
        }
        break;
      case 8:                                             // Print inter MCU communication 
        break;
      case 9:
        TemperaturePIDoutputRounded = round(TemperaturePIDoutput*10.0)/10.0;
    }
    lcdUpdateStep = (lcdUpdateStep + 1) % 10;  // Cycle through screen updates
  }
  myPID.Compute();
}////////////// End of main loop  //////////////////////////

////////  Below are the subroutines //////////////////////
void readSerialMessageMCU(uint8_t MCU) {
  uint8_t TempMcuData[DataMcuLength] = {0};
  uint8_t TemperatureCategory;  // Variable to categorize temperature
  ////// Inter MCU communication
  switch (MCU) {
    case 1:          // 1. Communication IC2 (OT) to IC1 (HP): This communication is via PAD 1 and therefore used at serial 1. Check if enough data has arrived in the serial buffer and read it
      Serial2.readBytes(TempMcuData, DataMcuLength);        // Clean way of reading fixed number of bytes into array. Beware: Blocks execution until all bytes arrive or timeout (default timeout is 1000ms).
      calculateMCUChecksum(TempMcuData, DataMcuLength, ChecksumMCU);// Calculate and check the checksum by determining the sum of the first 11 bytes and taken modules 256
      if (ChecksumMCU == TempMcuData[DataMcuLength-1]) { // Check if the checksum matches
        memcpy(dataArrayOT_IC2_IC1, TempMcuData, DataMcuLength); // Checksum OK so copy temp array to permanent array, cleaner and faster code than a loop  
        ChecksumMCU = false;                                // Make checksum false as start value for next time
        McuMessageOneReceived = currentMillis;

      } else {                                            // Checksum incorrect because communication possibly halfway received. 
        clearSerialBuffer(Serial2);                     // Clears the read buffer of serial 1 if the checksu was wrong to make a fresh start
        Serial.println("Serial buffer 1 cleared");
      }
      break;
    case 2:         // 2. Communication IC1 (HP) to IC2 (OT): This communication is via PAD 2 and therefore used at serial 2. Check if enough data has arrived in the serial buffer, read it, modify when required and resend
      //Serial1.readBytes(TempMcuData, DataMcuLength);      // Clean way of reading fixed number of bytes into array. Beware: Blocks execution until all bytes arrive or timeout (default timeout is 1000ms).
      //calculateMCUChecksum(TempMcuData, DataMcuLength, ChecksumMCU);// Calculate and check the checksum by determining the sum of the first 11 bytes and taken modules 256                            // Make checksum false as start value for next time
      if (T_outside < MinTemp4HP) {
        TemperatureCategory = 0;                             // Too cold for heat pump, switch on cental heating
      } else if (T_outside < 4) {
        TemperatureCategory = 1;  // Below 4°C             // Prevent that controlbox starts CV 
      } else if (SpeedSetpoint == 0) {
        TemperatureCategory = 2;                         // SpeedSetpoint is zero
      } else {
        TemperatureCategory = 3;                       // In all other cases use the temperature setpoint for water as read from Plugwise Anna via MCU2
      }                 
      switch (TemperatureCategory) {
        case 0:                                     // Heat pump is not running because it is too cold so central heating should be started
          dataArrayOT_IC1_IC2[0] = 0xf0;
          break;
        case 1:                                     // Below 4°C but heat pump can run, adjust values to prevent central heating activation
          dataArrayOT_IC1_IC2[0] = dataArrayOT_IC2_IC1[0];
          dataArrayOT_IC1_IC2[9] = 0x04;
          dataArrayOT_IC1_IC2[4] = 0;               // Write 0's to force MCU2 to transfer HP temperature to OpenTherm 
          dataArrayOT_IC1_IC2[5] = 0;
          dataArrayOT_IC1_IC2[6] = 0;
          dataArrayOT_IC1_IC2[10] = 0;
          break;
        case 2:                                     // Heat pump is not running (Speedsetpoint  is zero), then let central heating boiler temperatures go to OpenTherm
        case 3:                                     // In all other cases use the temperature setpoint for water as read from Plugwise Anna via MCU2
          dataArrayOT_IC1_IC2[0] = dataArrayOT_IC2_IC1[0];
          dataArrayOT_IC1_IC2[4] = 0;             // Write 0's to force MCU2 to transfer HP temperature to OpenTherm 
          dataArrayOT_IC1_IC2[5] = 0;
          dataArrayOT_IC1_IC2[6] = 0;
          dataArrayOT_IC1_IC2[10] = 0; 
          break;
      }
      dataArrayOT_IC1_IC2[7] = round(T_supply);
      dataArrayOT_IC1_IC2[8] = round(T_return);
      if (T_outside >= 4) {
        dataArrayOT_IC1_IC2[9] = round(T_outside);
      }
      calculateMCUChecksum(dataArrayOT_IC1_IC2, DataMcuLength, ChecksumMCU);// Recalculate the checksum
      dataArrayOT_IC1_IC2[11] = round(ChecksumMCU); // Replace old checksum value with new calculated one
      break;
  }
}

void clearSerialBuffer(HardwareSerial &serialPort) {  
  while (serialPort.available() > 0) {
    serialPort.read();                                  // Read and discard the data in the buffer
  }
}

void calculateMCUChecksum(uint8_t dataArray[], int Length, unsigned int &checksum) {  // Calculate the checksum by determining the sum of the first 11 bytes and then take modules 256
  checksum = 0; // Initialize the checksum
  if (Length <= 1) {    // Ensure length is valid
    checksum = 0;
    return;
  }
  // Calculate the checksum for the first (Length-1) bytes in the specified row
  for (int i = 0; i < Length - 1; i++) {
    checksum += dataArray[i];
  }
  checksum %= 256;                                        // Modulus 256 to keep it in a single byte
}

// Function to calculate the CRC-CCITT (0xFFFF) checksum for the communication to and from the heat pump
void calculate_CRC_CCITT_Checksum(uint8_t *data, uint8_t Length, uint16_t *checksum) {
  uint16_t crc = 0xFFFF; // Initial value
  for (uint8_t i = 0; i < Length; i++) {
    crc ^= (uint16_t)data[i] << 8;
    for (uint8_t j = 0; j < 8; j++) {
      if (crc & 0x8000) {
        crc = (crc << 1) ^ 0x1021;
      } else {
        crc <<= 1;
      }
    }
  }
  *checksum = crc;
}

// Function that reads the serial data coming from the heat pump
void readSerialMessageHP() {
  while (Serial3.available()) {  // Check if data is available on Serial3
    IsReceiving = true;
    uint8_t byteReceived = Serial3.read();
    IsReceiving = true;
    switch (state) {
      case Wait_Start:                            // Code to wait for the start character
        if (byteReceived == StartByte) {
          state = Read_Header;
          index = 0;
          IncomingMessageEnded = false; // Reset if any other byte is received to indicate
        }
        break;
      case Read_Header:                           // Code to process header bytes
        if (index == 0) {
          ID = byteReceived;
          if (ID > 3) {  // ID must be 0-3
            Serial.println("Invalid ID, resetting...");
            state = Wait_Start;
            return;
          }
        } else if (index == 1) {
          msgLength = byteReceived+1;
          if (!IsValidLength(msgLength)) {
            Serial.println("Invalid Length! Resetting...");
            state = Wait_Start;  // Reset
            return;
          }
          DataLength = msgLength - 3;  // Exclude first 3 bytes and last byte
          index = 0;
          state = Read_Payload;
        }
        index++;
        break;

      case Read_Payload:                          // Code to process data payload
        buffer[index++] = byteReceived;
        if (index >= DataLength) {
          state = Read_End;
        }
        break;

      case Read_End:                              // Code to check that last byte of message corresponds to '0'
        if (byteReceived == 0) {  // Ensure last byte is 0
          StoreMessage(ID, DataLength, buffer);
          IncomingMessageEnded = true;                          // If the end of the incoming message is reached, set the infication boolean
          previousMessageInEnded = millis();                    // Set timestamp after receiving end of incoming message             
        } else {
          Serial.println("Warning: Last byte is not 0! Resetting...");
        }
        IsReceiving = false;
        state = Wait_Start;                                     // Reset for next message
        break;
      default:
        Serial.println("Error in readSerialMessageHP state"); 
        break;
    }
  }
}

// Function to check if the Length is valid
bool IsValidLength(uint8_t Length) {
  for (uint8_t i = 0; i < sizeof(ValidLengths) / sizeof(ValidLengths[0]); i++) {
    if (Length == ValidLengths[i]) return true;
  }
  return false;
}

// Function to store messages in separate arrays based on ID
void StoreMessage(uint8_t ID, uint8_t DataLength, uint8_t *message) {
  for (uint8_t i = 0; i < (DataLength); i++) {
    dataHeatPumpTemp[i+2][ID] = message[i];
  }
  dataHeatPumpTemp[0][ID] = StartByte;
  dataHeatPumpTemp[1][ID] = ID;
  dataHeatPumpTemp[2][ID] = DataLength+2; // 12, 13, 18, 20
  for (int j = 0; j < DataLength+2; j++) {                                  // Copy row 
    extractedRow[j] = dataHeatPumpTemp[j][ID];  
  } 
  calculate_CRC_CCITT_Checksum(extractedRow, DataLength+2, &ChecksumCBHP);   // Calculate checksum, including the two checksum bytes --> result will be zero if mesage has been sent error free
  if (ChecksumCBHP == 0) {                                                   // Check that result is indeed zero
    memcpy(dataHeatPump[ID], dataHeatPumpTemp[ID], Cols * sizeof(uint8_t));  // Transfer the temporarily array to the permanent array
    ChecksumCBHPfalseCount = 0; 
  } else {
    ChecksumCBHPfalseCount++;                                              // Increase counter for false checksums. Nog actie bedebken als threshold wordt bereikt
    Serial.print("Checksum error! ");                                      // Print a message if there is an error
    Serial.print("Now ");Serial.print(ChecksumCBHPfalseCount);Serial.print(" Checksum errors (of max 10) counted!");
  }
}

Wat nog niet werkt:
- ik hoor geen enkel relais meer klikken, blijkbaar deed IC4 dat
- lampje naast de testknop brandt niet meer
- testknop doet niks
- schakelaar cv/wp doet niks
- lampje op schakelaar doet niks

Wat ik nog wil aanpassen:
- kijken of de WP aansturing ook op analoge SoftwareSerial pinnen werken (pin 26/27)
- Als dat werkt een Arduino Uno met DIP28 Mega328P bestellen
- Mega328P overzetten op plek van IC4

[ Voor 0% gewijzigd door _JGC_ op 23-09-2025 16:02 . Reden: workaround toegevoegd ]

[WackoH]

Je maakt mooie stappen!

Excuus voor de bugs.
De eerst (- not ok wordt gelogd als de data wel ok is) zit waarschijnlijk ook in mijn code. Maar ik heb er verder geen last van.
Die tweede (de compute aanroep voor quickpid zit niet in loop(), speedstate blijft dan altijd 0) is wellicht ontstaan toen ik de code wat opschoonde om hier neer te zetten. Bij mij lijkt de QuickPID tenminste volgens verwachting te werken.

Het algoritme moet inderdaad niet te traag worden. Bij mij bleek vooral het schrijven naar het scherm veel tijd te kosten. Vandaar dat dat zo is opgesplitst (iedere cyclus weer een ander deel updaten). Ik heb nu een cyclustijd van 30~40 ms

De grote van de weerstand maakt niet veel uit. Is alleen om de stroom te begrenzen. Ik heb dezelfde weerstand naar mijn AtMega2560 board opgenomen. Dat board had ik nog liggen en kwam goed uit vanwege de 4 hardware UARTs.

Software serial zou moeten werken, want dat moet de huidige MCU in de controlbox (ATmega8) ook doen om zowel en 1200 baud verbinding naar de andere MCU, als naar WP (666 baud) of Opentherm te onderhouden. Ik heb het ook wel op een Diecimila gebruikt toen ik aan het testen was.

[_JGC_]

Ik zit nu op 25ms met een 2560, maar dat is vooral omdat ik een statisch array bewerk op moment dat iets naar de OT MCU gestuurd moet worden. Die bewerk cyclus is trouwens best langzaam, die had ik eerst in de reguliere loop zitten, cyclustijd was toen 110ms.

150 liter RVS tapwater vat heb ik ook al, nu nog een 3wegklep, 2KW heater en temperatuursensor en iets om die boel aan te sturen. Moet 'm alleen nog wel even wrappen of spuiten want sprsun-goud is niet goed voor de WAF.

[_JGC_]

Zie dat er nog 1 hele nare bug in zit: als thermostaat warmte vraagt maar water heeft die temperatuur al dan blijft de warmtepomp uit. Geen circulatie, helemaal niks.
Heb vanmorgen op de laatste 0,3 graden verhoging mogen toekijken hoe elke paar minuten de warmtepomp aan en uit ging.

Fix is simpel: als er warmtevraag is vanuit thermostaat is, dan speedsetpoint minimaal 1.

Ketel loste dat op met code1 en dom rondpompen zonder te stoken.

Edit:
Aangepast in de post met de code van gisteren.
Zojuist even getest, stroomverbruik op stand 1 is marginaal, zo'n 200W. De helft van dat verbruik ging voorheen al op aan de ouderwetse AC pomp in de CV ketel.

[ Voor 19% gewijzigd door _JGC_ op 23-09-2025 16:09 ]

[WackoH]

_JGC_ schreef op dinsdag 23 september 2025 @ 11:13:
Zie dat er nog 1 hele nare bug in zit: als thermostaat warmte vraagt maar water heeft die temperatuur al dan blijft de warmtepomp uit. Geen circulatie, helemaal niks.

Bij mij speelt dit niet. Heb het even nagekeken:
De thermostaat staat op 20.5oC. De afgelopen 72 uur is de temperatuur binnen 0.4oC stabiel gebleven. De WP schakelt aan als de temperatuur naar 20.4oC gaat. Soms loopt de temperatuur op tot 20.7 en een enkele keer tot 20.8. Maar gemiddeld zal het iets van 20.55oC zijn.

Heb vanmorgen op de laatste 0,3 graden verhoging mogen toekijken hoe elke paar minuten de warmtepomp aan en uit ging.

Dit herken ik helemaal niet.
De verschillen zullen wel komen doordat mijn CV systeem anders in elkaar steekt (combinatie radiatoren en vloerverwarming) waardoor temperatuur tijdens het nadraaien van de pomp in buitenunit (~30s) al genoeg daalt.

Maar je oplossing om het setpoint op 1 te zetten als er warmtevraag is klinkt prima en maakt het geheel robuuster, want alleen de pomp aanzetten gaat niet voor zover ik weet.

[_JGC_]

Ik heb 'm vanmorgen laten lopen. Thermostaat vraagt continu setpoint van 25 graden bij verwarmen van 20.0 naar 20.5. Setpoint wordt redelijk snel gehaald en daarna stijgt deze in 3 uur tijd langzaam door naar 30 graden.
Het halfje opstoken op stand 1 duurde 2,5 uur en thermostaat liet de warmtepomp doorstoken tot 20.7. Al die tijd was het aangenaam, het kille gevoel van vanmorgen was vrij snel weg.

Nu is dit nog geen maatstaf voor de winter, want thermostaat regelt nog heel conservatief en de heatboosters starten de fans pas op bij verschil van 4 graden tussen aanvoer en kamertemperatuur. Verder hangen er boven nog radiatoren die in de winter ook warmte vragen maar nu helemaal niet.

Ik merk wel dat ik dit veel fijner vind dan die ketel die er 2-4x per uur even een paar minuten 6KW in duwde. Ook veel fijner dan de originele regeling die direct naar 35 graden doorstookt en daar blijft hangen.

[ Voor 13% gewijzigd door _JGC_ op 24-09-2025 22:19 ]

[_JGC_]

@WackoH Ik vermoed dat die dingen komen door verschillen in regeling. Ik kwam er vanmorgen achter dat de OT MCU helemaal niet luistert naar CH_ON en CH_OFF. Die geeft gewoon vrolijk het setpoint van de thermostaat door, dat is ook waarom de pomp met de iSense continu bleef draaien.

De DIYLESS bouwt bij <0,3 van de temperatuur verwijderd een setpoint op en zodra die >=20 graden wordt volgt een CH_ON. Vanmorgen heeft de warmtepomp volgens vraag van thermostaat van 6:55 tot 8:15 gestookt, om 8:35 ging deze vrolijk tot 11:00 op laagste stand draaien en thermostaat heeft nooit wat gevraagd . Setpoint was al die tijd 12-13 graden ipv 10.

Algoritme nog maar iets aanpassen, ik wil wel doorstoken als setpoint geen 10 (uit) is, maar als setpoint van 10 (uit) af komt niet eerder stoken dan wanneer deze 20 wordt.

[WackoH]

Zoals je het hier beschrijft en als ik naar het gedrag van de Anna kijkt, komt het inderdaad door de regeling.
Wat de Anna thermostaat doet, is de aanvraagtemperatuur op '0' houden als er geen warmtevraag is, en die snel laten stijgen als die er wel is. Dit ziet er dan zo uit:

Dus bij geen warmtevraag wordt het setpoint van aanvoertemperatuur van de WP ook naar snel beneden getrokken waardoor dat kort achter aan en uit schakelen wat jij zag, wordt vermeden.

Verder geeft de controlbox de aanvoertemperatuur naar de ketel 1-op-1 door, maar schaalt deze temperatuur als de WP warmte moet leveren.
Bv. 30oC aanvoer wordt setpoint 25oC voor de WP, en 60 wordt 40oC.
Dit concept heb ik overgenomen om de WP aan te sturen, maar ik weet eerlijk niet of het bij de ketel goed gaat. Die heb ik sinds begin dit jaar niet meer aan gehad

[_JGC_]

Inmiddels de code wat aangepast. Dingen waar ik tegenaan liep:
- afrondingsverschillen vanwege floats, thermostaat geeft 20 graden setpoint, maar 20 >= 20 is niet altijd true, dus ging de regeling pas stoken bij 21 graden setpoint.
- nogal agressieve regeling. Van laag vermogen direct naar hoogste en daar dan 7 minuten op blijven draaien (hallo buurman)

Wat ik heb aangepast:
- stappenmodulatie, elke 120 seconden mag de regeling 1 stap omhoog of 1 stap omlaag.
- Uit als setpoint onder 15 komt na een stooksessie (float afronding zal me hier een zorg zijn)
- Aan als setpoint 19 of hoger wordt (uint8_t ipv float nu)
- Schakelen tussen trage en snelle regeling eruit

code:

/* 
Alternative control for the Atlantic Aurea heat pump, which based on the Chofu AEYC-0643XU-AT unit.
This is a sketch to control the power setting of a heat pump with an Arduino ATMega2560 and to modify communication inside the controlbox using 3 of the 4 hardware serial ports of this board. 
The original code shows various useful information like temperatures etc. on a 480*320 TFT LCD. This has been removed here to keep the code more compact.
Version 0.1Beta, JHN 19-03-2025
*/

#include <QuickPID.h>                                   // Library for PID controller, see for documentation: https://github.com/Dlloydev/QuickPID

//Define variables and constants
// General
String MessageString = "";

  // For heat pump
const uint8_t SpeedStages = 6;                        // Number of speed stages to be used (7 --> ~1400 W max)
uint8_t SpeedSetpoint = 0;                            // Speed setpoint sent to heatpump
uint8_t SpeedSetpointOld = 0;
uint8_t TargetTemperatureThermostat = 20;             // Target temperature as requested by the thermostat
const float MinTemp4HP = -15;                         // Outside temperatute below wich heat pump should stop working and CV should start
uint16_t TelegramCount = 0;                           // Follow-up number of telegrams
// Variables to track timings
uint32_t Interval = 0;                                // Time since last telegram
uint32_t currentMillis = 0;                           // Check timing for sending messages
uint32_t LastSpeedSetpointChange = 0;                 // Keep track when last time speedsetpint has been changed in milliseconds
uint32_t SpeedSetpointHysteresis = 120000;            // Allow a change in speedsetpoint only once per 2 minutes (when using slow PID parameter set)
// Cycle time check
uint32_t previousCycleMicros = 0;                     // To store the time of the last cycle start
uint32_t currentCycleMicros = 0;                      // To store the time of the current cycle start
uint32_t cycleTime = 0;                               // To store the calculated cycle time
uint16_t cycleCounter = 0;                            // Counter to track cycles
const uint16_t displayInterval = 10000;               // Display cycle time every 10000 cycles
uint8_t lcdUpdateStep = 0;                            // Variable to spread writing to screen over multiple steps
// Receive and send inter MCU data 
const uint32_t McuMessageWaitTime = 200;              // Waiting time between receiving message on Pad 1 (Serial 1) and sending on pad 2 (serial 2) in ms
uint32_t McuMessageOneReceived = 0;                   // Tie last message send in ms
bool dataMcu2Send = false;
uint32_t PreviousMessageSerial1Sent = 0;   
uint32_t MessageSerial1Interval = 4200;              // Maximum interval for sending message on serial 2 (to avoid that communication stops)
const uint8_t DataMcuLength = 12;                     // Length of each transmission between MCU's
uint8_t dataArrayOT_IC1_IC2[DataMcuLength] = {32,20,154,0,0,0,0,32,29,7,0,18};     // Array to store the incoming 12 bytes for OT IC1 to IC2.
uint8_t dataArrayOT_IC2_IC1[DataMcuLength] = {0};     // Array to store the incoming 12 bytes for OT IC2 to IC1. 
uint16_t ChecksumMCU = 0;                             // Checksum for communication between MCU's
// Variables for communication with heat pump
uint8_t CB_HPlength = 0;                              // Length of communcation CB to HP
uint16_t ChecksumCBHP = 0;                            // Checksum for communication of heat pump with control box
uint8_t ChecksumCBHPfalseCount = 0;                   // Counter for number of times that the checksum did not match. After certain number of mismatches, message will be send to the serial port
uint8_t data0[] = { 0x19, 0x0, 0x8, 0x0, 0x0, 0x0, 0xd9, 0xb5 };                       // Array of hexadecimal bytes
uint8_t data1[] = { 0x19, 0x1, 0x0c, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaa, 0x35 };  // Array of hexadecimal bytes
uint8_t data2[] = { 0x19, 0x2, 0x8, 0x1, 0x1, 0x0, 0x99, 0x37 };                       // Array of hexadecimal bytes. This is the one to change bytes 4 (on/off) and 5 (setpoint), and 7 and 8 (high and low bytes of the CRC CCITT checksum)
uint8_t data3[] = { 0x19, 0x3, 0x8, 0xb2, 0x2, 0x0, 0xc1, 0x9a };                      // Array of hexadecimal bytes

// Variables for sending messages to heat pump
bool IncomingMessageEnded = false;                      // Last message start time in milliseconds
volatile uint32_t PreviousMessageSent = 0;              // Time when prveious message was sent in milliseconds
volatile bool IsReceiving = false;                      // Tracks if message is being received from heat pump to block sending next message to heat pump
const uint32_t SendTimeout = 2000;                      // Time in milliseconds to wait before considering the communication ended
const uint32_t SendDelay = 99;                          // Delay in milliseconds before sending information to heatpump
const uint32_t MinMessageSendInterval  = 300;           // Minimum interval in millis between sending messages when no reply is received
volatile uint32_t previousMessageInEnded = 0;

// Definitions for reading and checking heat pump data
// Prepare array for storing data from heatpump
const uint8_t StartByte = 0x91;                     // First byte must be 145 (0x91)
const uint8_t Rows = 4;                            // Number of rows in heat pump data array 
const uint8_t Cols = 80;                            // Number of columns in heat pump data array 
uint8_t numChars = 0;                               // Number of characters to be written to screen
uint8_t dataHeatPumpTemp[Cols][Rows] = {0};         // Array to store of four messages from heatpump before checksum check
uint8_t dataHeatPump[Cols][Rows] = {0};             // Array to store of four messages from heatpump after checksum is correct
uint8_t dataHeatPumpOld[Cols][Rows] = {0};          // Array to store previous data of four messages so that screen is only updayted when needed
uint8_t extractedRow[Cols];                         // 1D array to store the row  
const uint8_t ValidLengths[] = {13, 14, 19, 21};    // Lengths 12, 13, 18 & 20   (12+1), (13+1), (18+1), (20+1)
uint16_t value;                                     // Temporarily storage of datapoint from array
float valuefloat;
uint8_t Length = 0;
float T_supply =0;                                  // Supply water temperature by heatpump
float T_return =0;                                  // Return water temperature to heatpump
float T_outside =0;                                 // Outside temperature measured on heatpump
// State variables for non-blocking serial reading
enum SerialState {  Wait_Start,                     // Waiting for the start of a serial message  
                    Read_Header,                    // Reading the header of the message  
                    Read_Payload,                   // Reading the main data (payload)  
                    Read_End                        // Reading the end of the message  
                  };                              // Enumeration type, which helps in defining different states of serial communication
SerialState state = Wait_Start;                     // Make waiting to start the default
uint8_t ID = 0;
uint8_t msgLength = 0;
uint8_t DataLength = 0;
uint8_t buffer[Cols] = {0};                         // Temporary buffer for incoming data
uint8_t index = 0;
int8_t NegT = 0;                                    // Store if temperature is negative (value of 255 in MSB)
// For PID controller 
float TemperaturePIDsetpoint = 0;                  // Desired supply temperature
uint8_t TemperaturePIDsetpointOld = 0;
const float TemperaturePIDsetpointMax = 37;         // Maximum temperature setpoint
const float TemperaturePIDsetpointMin = 25;         // Maximum temperature setpoint
const float TemperaturePIDsetpointOff = 15;
const uint8_t TemperaturePIDsetpointMinStart = 19;
float TemperaturePIDinput = 0;                      // Current suppy temperature (feedback from the sensor in the heatpump)
float TemperaturePIDoutput = 0;                     // Heat pump control signal
float TemperaturePIDoutputRounded = 0;              // Heater control signal, rounded off
// PID tuning parameter. Default values were Kp = 2.0, Ki = 5.0, Kd = 1.0
const float Kp0 = 0.02, Ki0 = 0.008, Kd0 = 0.01;// 
float Kp = Kp0, Ki = Ki0, Kd = Kd0;// 
// Create PID object
QuickPID myPID(&TemperaturePIDinput, &TemperaturePIDoutput, &TemperaturePIDsetpoint, Kp, Ki, Kd, /* OPTIONS */
                myPID.pMode::pOnError,                   /* pOnError, pOnMeas, pOnErrorMeas */
                myPID.dMode::dOnMeas,                    /* dOnError, dOnMeas */
                myPID.iAwMode::iAwCondition,             /* iAwCondition, iAwClamp, iAwOff */
                myPID.Action::direct);                   /* direct, reverse */

void setup() {
  // Serial Setup
  Serial.begin(115200);                                   // Start the Serial Monitor for debugging on terminal (Serial port 0)
  Serial3.begin(9600);                                    // Start serial port 1 for receiving messages from OT MCU to HP MCU (RX3, 9600 bps)
  Serial1.begin(666);                                     // Start serial port 3 for sending an receiving info to heat pump at 666 baud (RX1 and TX1)
  Serial3.setTimeout(100);                                // Changes the timeout for readBytes() and other blocking serial read functions (readString(), readBytesUntil(), etc.).
  // For QuickPID
  myPID.SetOutputLimits(0, 99);                           // Set to max 99% to have max. 4 digits ('99.9')
  myPID.SetSampleTimeUs(5000000);                         // Sample time of PID controller in microseconds. Made slower than default because of relatively slow temperature changes and heat pump response to save processing time.
  myPID.SetTunings(Kp, Ki, Kd);
  myPID.SetMode(myPID.Control::automatic);                // Set PID controller in automatic, i.e. input (PV) is perdiodically compared with setpoint (SP) and control variable (CV) is adjusted 

  delay(5000);
  Serial.println("Setup complete.");
}

//////////////// Main loop ////////////
void loop() {
  currentMillis = millis();                                 // get curent millis (ms) for sending message to heat pump
  currentCycleMicros = micros();                            // Capture the current time (in us) to calculate the cycle time of the loop
  cycleCounter++;                                           // Increment the cycle counter
  
  // Check for incoming data on Serial 1 (Pad 1 from MCU 2), 2 (Pad 2 from MCU 1) and Serial 3 (data from heat pump)
  readSerialMessageHP();                                      // Call this function continuously to check for data on the incoming serial port from the heat pump
  if (Serial3.available() >= DataMcuLength) {                 // Check whether the serial buffer connected to Pad 1 contains DataMcuLength (12) bytes or more  
    readSerialMessageMCU(1);                                  // When so, jump to subroutine to read the bytes or clear the buffer
    TemperaturePIDsetpoint = dataArrayOT_IC2_IC1[0];
    if (TemperaturePIDsetpoint > TemperaturePIDsetpointMax){
      TemperaturePIDsetpoint = TemperaturePIDsetpointMax;
    } else if (TemperaturePIDsetpoint <= TemperaturePIDsetpointOff || (TemperaturePIDsetpointOld == 0 && round(TemperaturePIDsetpoint) < TemperaturePIDsetpointMinStart)) {
      TemperaturePIDsetpoint = 0;
    } else if (TemperaturePIDsetpoint < TemperaturePIDsetpointMin) {
      TemperaturePIDsetpoint = TemperaturePIDsetpointMin;
    }
    TemperaturePIDsetpointOld = round(TemperaturePIDsetpoint);
  }

  
  // Write modified message from MCU 1 to 2 on serial 2
  if ((currentMillis-PreviousMessageSerial1Sent) > MessageSerial1Interval)  {
    readSerialMessageMCU(2);
    Serial3.write(dataArrayOT_IC1_IC2, sizeof(dataArrayOT_IC1_IC2));    // Write array to serial port 2
    PreviousMessageSerial1Sent = currentMillis;
  }
  

  // Send the next message to the heat pump 100 ms after the previous incoming message has ended, or after 1000 ms without sending anything. Use the periodic sending also to update the screen
  currentMillis = millis();                                 // get curent millis (ms) for sending message to heat pump
  if ((( (currentMillis - previousMessageInEnded >= SendDelay)  &&  (!IsReceiving))  || ( currentMillis - previousMessageInEnded >= SendTimeout )) && (currentMillis - PreviousMessageSent >= ( MinMessageSendInterval ))) 
  {
    switch (TelegramCount) {
      case 0:
        Serial1.write(data0, sizeof(data0));
        break;
      case 1:
        Serial1.write(data1, sizeof(data1));
        break;
      case 2:
        SpeedSetpoint = (int)round( TemperaturePIDoutput / (100 / SpeedStages )) ;    // Scale the PID controller output from 0~100% to 0~8 speed setpoints, and convert from double to rounded integer
        if (SpeedSetpoint == 0 && TemperaturePIDsetpoint > 0) {
          // Workaround: We still want heat, but not much. Keep WP running
          SpeedSetpoint = 1;
        }
        if (SpeedSetpoint == 0) {
          data2[3] = 0x0;
          data2[4] = 0x0;
          SpeedSetpointOld = 0;
        } else if (SpeedSetpointOld != SpeedSetpoint && (currentMillis - LastSpeedSetpointChange > SpeedSetpointHysteresis)) {
          if (SpeedSetpoint > SpeedSetpointOld) {
            SpeedSetpoint = SpeedSetpointOld+1;
          } else {
            SpeedSetpoint = SpeedSetpointOld-1;
          }
          data2[3] = 0x1;
          data2[4] = SpeedSetpoint;                 // Write calculate speed setpoint in array  
          LastSpeedSetpointChange = currentMillis;
          SpeedSetpointOld = SpeedSetpoint;
        }
         
        CB_HPlength = sizeof(data2);
        calculate_CRC_CCITT_Checksum(data2, CB_HPlength-2, &ChecksumCBHP);  
        data2[6] = (ChecksumCBHP >> 8) & 0xFF;          // Replace byte 6 with checksum High Byte
        data2[7] = ChecksumCBHP & 0xFF;                 // Replace byte 7 with checksum Low Byte
        Serial1.write(data2, sizeof(data2));
        break;
      case 3:
        Serial1.write(data3, sizeof(data3));
        break;
      default:
        Serial.print("Invalid TelegramCount value:  ");Serial.println(TelegramCount); 
        break;
    }
    TelegramCount = (TelegramCount + 1) % 4;          // Cycle through 0-3
    PreviousMessageSent = millis();
  }

  if (cycleCounter >= displayInterval) {
    if (previousCycleMicros != 0) {
      cycleTime = ( currentCycleMicros - previousCycleMicros ) / displayInterval;  // Time difference between cycles
      previousCycleMicros = currentCycleMicros;           // Update the previous cycle time
      cycleCounter = 0;                                   // Reset the cycle counter
    } else {
      previousCycleMicros = currentCycleMicros;
    }
  
    switch (lcdUpdateStep) {
      case 0:                                             // Print the cycle time etc. The timing for sneding message to the heatpump wil be oof when the cycle time is too long (> ~50 ms)
        Serial.println("Cycle time "+String(cycleTime)+" ms");
        break;
      case 1:                                             // Print PID settings
        break;
      case 2:                                             // Compresor speed 91-3,9
        if (dataHeatPump[9][3] != dataHeatPumpOld[9][3]) {  // Data has changed?
          Serial.print("Speed setpoint: "); Serial.println(dataHeatPump[9][3]);
          dataHeatPumpOld[9][3] = dataHeatPump[9][3];
          }
        break;
      case 3:                                             // Compresor power 91-3,10
        if (dataHeatPump[10][3] != dataHeatPumpOld[10][3]) {
          MessageString = String((25.6 * dataHeatPump[10][3]),0);
          Serial.print("Compressor power: "); Serial.println(MessageString);
          dataHeatPumpOld[10][3] = dataHeatPump[10][3];
        }
        // Compressor mode 91-1,3
        if (dataHeatPump[3][1] != dataHeatPumpOld[3][1]) {
          Serial.print("Compressor mode: "); Serial.println(dataHeatPump[3][1]);
          dataHeatPumpOld[3][1] = dataHeatPump[3][1];
        }
        // Defrost?   91-1,4
        if (dataHeatPump[4][1] != dataHeatPumpOld[4][1]) {
          Serial.print("Defrost ongoing? "); Serial.println(dataHeatPump[4][1]);
          dataHeatPumpOld[4][1] = dataHeatPump[4][1];
        }
        break;
      case 4:
        // ?Data? 91-3,5
        if (dataHeatPump[5][3] != dataHeatPumpOld[5][3]) {
          Serial.print("Generic info "); Serial.println(dataHeatPump[5][3]);
          dataHeatPumpOld[5][3] = dataHeatPump[5][3];
        } 
        break;
      case 5:                                             // Temperatures
        // Supply temperature   91-2,3~4
        if (dataHeatPump[3][2] != dataHeatPumpOld[3][2]) {
          value = dataHeatPump[4][2];                             // MSB of temperature; previous byte is the MSB
          T_supply = (((value*256+dataHeatPump[3][2])-(65536*((value == 255) ? 1 : 0)))/10.0);  // Do the conversion to temperature in such a way that also negative temperature can be shown
          TemperaturePIDinput = T_supply;                       // Make the input the PID controller equal to the current supply water temperature   
          MessageString = String(T_supply,1);
          Serial.print("Supply temperature "); Serial.println(MessageString);
          dataHeatPumpOld[3][2] = dataHeatPump[3][2];
        }
        // Return temperature 91-2,5~6
        if (dataHeatPump[5][2] != dataHeatPumpOld[5][2]) {
          value = dataHeatPump[6][2];               // MSB of temperature; previous byte is the MSB
          T_return = (((value*256+dataHeatPump[5][2])-(65536*((value == 255) ? 1 : 0)))/10.0);  // Do the conversion to temperature in such a way that also negative temperature can be shown
          MessageString = String(T_return,1);
          Serial.print("Return temperature "); Serial.println(MessageString);
          dataHeatPumpOld[5][2] = dataHeatPump[5][2];
        }
        break;
      case 6:
        // Outside temperature 282 91-2,7~8
        if (dataHeatPump[7][2] != dataHeatPumpOld[7][2]) {  
          value = dataHeatPump[8][2];               // MSB of temperature; previous byte is the MSB
          T_outside = (((value*256+dataHeatPump[7][2])-(65536*((value == 255) ? 1 : 0)))/10.0);  // Do the conversion to temperature in such a way that also negative temperature can be shown
          MessageString = String(T_outside,1);
          Serial.print("Outside temperature "); Serial.println(MessageString);
          dataHeatPumpOld[7][2] = dataHeatPump[7][2];
        }
        break;
      case 7:                                             // Do PID calculation
        break;
      case 8:                                             // Print inter MCU communication 
        break;
      case 9:
        TemperaturePIDoutputRounded = round(TemperaturePIDoutput*10.0)/10.0;
    }
    lcdUpdateStep = (lcdUpdateStep + 1) % 10;  // Cycle through screen updates
  }
  myPID.Compute();
}////////////// End of main loop  //////////////////////////

////////  Below are the subroutines //////////////////////
void readSerialMessageMCU(uint8_t MCU) {
  uint8_t TempMcuData[DataMcuLength] = {0};
  uint8_t TemperatureCategory;  // Variable to categorize temperature
  ////// Inter MCU communication
  switch (MCU) {
    case 1:          // 1. Communication IC2 (OT) to IC1 (HP): This communication is via PAD 1 and therefore used at serial 1. Check if enough data has arrived in the serial buffer and read it
      Serial3.readBytes(TempMcuData, DataMcuLength);        // Clean way of reading fixed number of bytes into array. Beware: Blocks execution until all bytes arrive or timeout (default timeout is 1000ms).
      calculateMCUChecksum(TempMcuData, DataMcuLength, ChecksumMCU);// Calculate and check the checksum by determining the sum of the first 11 bytes and taken modules 256
      if (ChecksumMCU == TempMcuData[DataMcuLength-1]) { // Check if the checksum matches
        memcpy(dataArrayOT_IC2_IC1, TempMcuData, DataMcuLength); // Checksum OK so copy temp array to permanent array, cleaner and faster code than a loop  
        ChecksumMCU = false;                                // Make checksum false as start value for next time
        McuMessageOneReceived = currentMillis;

      } else {                                            // Checksum incorrect because communication possibly halfway received. 
        clearSerialBuffer(Serial3);                     // Clears the read buffer of serial 1 if the checksu was wrong to make a fresh start
        Serial.println("Serial buffer 1 cleared");
      }
      break;
    case 2:         // 2. Communication IC1 (HP) to IC2 (OT): This communication is via PAD 2 and therefore used at serial 2. Check if enough data has arrived in the serial buffer, read it, modify when required and resend
      //Serial1.readBytes(TempMcuData, DataMcuLength);      // Clean way of reading fixed number of bytes into array. Beware: Blocks execution until all bytes arrive or timeout (default timeout is 1000ms).
      //calculateMCUChecksum(TempMcuData, DataMcuLength, ChecksumMCU);// Calculate and check the checksum by determining the sum of the first 11 bytes and taken modules 256                            // Make checksum false as start value for next time
      if (T_outside < MinTemp4HP) {
        TemperatureCategory = 0;                             // Too cold for heat pump, switch on cental heating
      } else if (T_outside < 4) {
        TemperatureCategory = 1;  // Below 4°C             // Prevent that controlbox starts CV 
      } else if (SpeedSetpoint == 0) {
        TemperatureCategory = 2;                         // SpeedSetpoint is zero
      } else {
        TemperatureCategory = 3;                       // In all other cases use the temperature setpoint for water as read from Plugwise Anna via MCU2
      }                 
      switch (TemperatureCategory) {
        case 0:                                     // Heat pump is not running because it is too cold so central heating should be started
          dataArrayOT_IC1_IC2[0] = 0xf0;
          break;
        case 1:                                     // Below 4°C but heat pump can run, adjust values to prevent central heating activation
          dataArrayOT_IC1_IC2[0] = dataArrayOT_IC2_IC1[0];
          dataArrayOT_IC1_IC2[9] = 0x04;
          dataArrayOT_IC1_IC2[4] = 0;               // Write 0's to force MCU2 to transfer HP temperature to OpenTherm 
          dataArrayOT_IC1_IC2[5] = 0;
          dataArrayOT_IC1_IC2[6] = 0;
          dataArrayOT_IC1_IC2[10] = 0;
          break;
        case 2:                                     // Heat pump is not running (Speedsetpoint  is zero), then let central heating boiler temperatures go to OpenTherm
        case 3:                                     // In all other cases use the temperature setpoint for water as read from Plugwise Anna via MCU2
          dataArrayOT_IC1_IC2[0] = dataArrayOT_IC2_IC1[0];
          dataArrayOT_IC1_IC2[4] = 0;             // Write 0's to force MCU2 to transfer HP temperature to OpenTherm 
          dataArrayOT_IC1_IC2[5] = 0;
          dataArrayOT_IC1_IC2[6] = 0;
          dataArrayOT_IC1_IC2[10] = 0; 
          break;
      }
      dataArrayOT_IC1_IC2[7] = round(T_supply);
      dataArrayOT_IC1_IC2[8] = round(T_return);
      if (T_outside >= 4) {
        dataArrayOT_IC1_IC2[9] = round(T_outside);
      }
      calculateMCUChecksum(dataArrayOT_IC1_IC2, DataMcuLength, ChecksumMCU);// Recalculate the checksum
      dataArrayOT_IC1_IC2[11] = round(ChecksumMCU); // Replace old checksum value with new calculated one
      break;
  }
}

void clearSerialBuffer(HardwareSerial &serialPort) {  
  while (serialPort.available() > 0) {
    serialPort.read();                                  // Read and discard the data in the buffer
  }
}

void calculateMCUChecksum(uint8_t dataArray[], int Length, unsigned int &checksum) {  // Calculate the checksum by determining the sum of the first 11 bytes and then take modules 256
  checksum = 0; // Initialize the checksum
  if (Length <= 1) {    // Ensure length is valid
    checksum = 0;
    return;
  }
  // Calculate the checksum for the first (Length-1) bytes in the specified row
  for (int i = 0; i < Length - 1; i++) {
    checksum += dataArray[i];
  }
  checksum %= 256;                                        // Modulus 256 to keep it in a single byte
}

// Function to calculate the CRC-CCITT (0xFFFF) checksum for the communication to and from the heat pump
void calculate_CRC_CCITT_Checksum(uint8_t *data, uint8_t Length, uint16_t *checksum) {
  uint16_t crc = 0xFFFF; // Initial value
  for (uint8_t i = 0; i < Length; i++) {
    crc ^= (uint16_t)data[i] << 8;
    for (uint8_t j = 0; j < 8; j++) {
      if (crc & 0x8000) {
        crc = (crc << 1) ^ 0x1021;
      } else {
        crc <<= 1;
      }
    }
  }
  *checksum = crc;
}

// Function that reads the serial data coming from the heat pump
void readSerialMessageHP() {
  while (Serial1.available()) {  // Check if data is available on Serial1
    IsReceiving = true;
    uint8_t byteReceived = Serial1.read();
    IsReceiving = true;
    switch (state) {
      case Wait_Start:                            // Code to wait for the start character
        if (byteReceived == StartByte) {
          state = Read_Header;
          index = 0;
          IncomingMessageEnded = false; // Reset if any other byte is received to indicate
        }
        break;
      case Read_Header:                           // Code to process header bytes
        if (index == 0) {
          ID = byteReceived;
          if (ID > 3) {  // ID must be 0-3
            Serial.println("Invalid ID, resetting...");
            state = Wait_Start;
            return;
          }
        } else if (index == 1) {
          msgLength = byteReceived+1;
          if (!IsValidLength(msgLength)) {
            Serial.println("Invalid Length! Resetting...");
            state = Wait_Start;  // Reset
            return;
          }
          DataLength = msgLength - 3;  // Exclude first 3 bytes and last byte
          index = 0;
          state = Read_Payload;
        }
        index++;
        break;

      case Read_Payload:                          // Code to process data payload
        buffer[index++] = byteReceived;
        if (index >= DataLength) {
          state = Read_End;
        }
        break;

      case Read_End:                              // Code to check that last byte of message corresponds to '0'
        if (byteReceived == 0) {  // Ensure last byte is 0
          StoreMessage(ID, DataLength, buffer);
          IncomingMessageEnded = true;                          // If the end of the incoming message is reached, set the infication boolean
          previousMessageInEnded = millis();                    // Set timestamp after receiving end of incoming message             
        } else {
          Serial.println("Warning: Last byte is not 0! Resetting...");
        }
        IsReceiving = false;
        state = Wait_Start;                                     // Reset for next message
        break;
      default:
        Serial.println("Error in readSerialMessageHP state"); 
        break;
    }
  }
}

// Function to check if the Length is valid
bool IsValidLength(uint8_t Length) {
  for (uint8_t i = 0; i < sizeof(ValidLengths) / sizeof(ValidLengths[0]); i++) {
    if (Length == ValidLengths[i]) return true;
  }
  return false;
}

// Function to store messages in separate arrays based on ID
void StoreMessage(uint8_t ID, uint8_t DataLength, uint8_t *message) {
  for (uint8_t i = 0; i < (DataLength); i++) {
    dataHeatPumpTemp[i+2][ID] = message[i];
  }
  dataHeatPumpTemp[0][ID] = StartByte;
  dataHeatPumpTemp[1][ID] = ID;
  dataHeatPumpTemp[2][ID] = DataLength+2; // 12, 13, 18, 20
  for (int j = 0; j < DataLength+2; j++) {                                  // Copy row 
    extractedRow[j] = dataHeatPumpTemp[j][ID];  
  } 
  calculate_CRC_CCITT_Checksum(extractedRow, DataLength+2, &ChecksumCBHP);   // Calculate checksum, including the two checksum bytes --> result will be zero if mesage has been sent error free
  if (ChecksumCBHP == 0) {                                                   // Check that result is indeed zero
    memcpy(dataHeatPump[ID], dataHeatPumpTemp[ID], Cols * sizeof(uint8_t));  // Transfer the temporarily array to the permanent array
    ChecksumCBHPfalseCount = 0; 
  } else {
    ChecksumCBHPfalseCount++;                                              // Increase counter for false checksums. Nog actie bedebken als threshold wordt bereikt
    Serial.print("Checksum error! ");                                      // Print a message if there is an error
    Serial.print("Now ");Serial.print(ChecksumCBHPfalseCount);Serial.print(" Checksum errors (of max 10) counted!");
  }
}

[ Voor 0% gewijzigd door _JGC_ op 04-10-2025 15:52 . Reden: code aanpassingen ]

[_JGC_]

@WackoH Ik lees hier eerder in het topic dat de warmtepomp niet op stand 1 wil draaien op kou. Wat gaat deze doen dan? Gaat de warmtepomp dan steeds uit, of krijg je stand 2?

Nieuwe regeling lijkt hier de temperatuur niet meer door te geven aan de thermostaat, dus heb nog een bug ergens. Lampje op de schakelaar brandt vanmorgen ook ineens dus lijkt erop dat de OT MCU denkt dat de ketel stookt.

Edit: inmiddels achterhaald. Lijkt erop dat ik de seriele poort van mijn Mega gesloopt heb of de bedrading slecht contact maakt, ik krijg niks meer door van de OT MCU. Gek genoeg kreeg ik dat nog wel éénmalig na het flashen van de oude code, maar inmiddels ook niet meer.

Edit2: seriele poorten omgedraaid en werkt weer. Poort dus niet kapot maar speling op de prikkabeltjes.
Ik overweeg sterk om de OT MCU gewoon dood te zwijgen en een ESP8266 te gebruiken met een OT Slave bord erop. Huidige code gooit de setpoint naar 0.0 bij een communicatiefout, dat heb ik vanmorgen kunnen zien in de aanvoertemperaturen van de heatboosters. Ik dacht aan defrosts (koud en veel regen), maar ding heeft vanmorgen vroeg een hele tijd staan knipperen tussen aan en uit.

[ Voor 51% gewijzigd door _JGC_ op 04-10-2025 14:07 ]

[WackoH]

De buitenunit gaat gewoon aan als je stand 1 stuurt. Volgens mij bepaalt dit de snelheid van de compressor (vandaar dat ik het 'speed stage' en niet 'power stage' heb genoemd). Welk vermogen dan wordt opgenomen hangt vermoedelijk primair af van de gasdrukken in de buitenunit. En die hangen weer af van o.a. de buiten-, aan- en afvoertemperatuur (denk ik, ben geen airco specialist). Dit blijkt bv. hieruit:


Het beste wat ik heb kunnen doen is met een Arduino steeds een hogere stand vragen, en dan met een externe meter het opgenomen vermogen bepalen:

Mijn conclusie was dat er 12 standen (plus 'uit') zijn Maar er zijn ook condities dat de WP niet meer vermogen op gaat nemen bij de hoogste standen. Dan zit 'ie blijkbaar al eerder aan z'n max. Sowieso is het beter niet op max vermogen te draaien want dan zakt de COP in. Atlantic geeft slechts 1.1 kW als max. vermogen met een COP van 4.63 bij A7W35. In een Chofu service manual staat een COP van 4.20 bij 1.43 kW. Wellicht heeft Atlantic het vermogen begrensd om in een hogere subsidie-categorie te vallen.

Daarom heb ik het aantal standen in mijn programma tot slechts 7 beperkt. Daarmee wordt het opgenomen vermogen in de praktijk max. ~1400W. Dit voldeed om het huis gedurende de afgelopen winter zonder CV warm te houden.

Zoals ik het heb opgebouwd is relatief complex. Met de kennis van nu zou ik bv. een ESP32 (heeft twee complete hardware UARTS vrij, de ESP8266 is wat kreupel op dat vlak) nemen en die zeker de HP, en misschien zelfs de OT communicatie laten doen, en dan via WiFi met Home Assistant verbinden om data uit te lezen.

Ik heb er zelfs eentje liggen met scherm en al. Maar ja, ik heb nu de volledige Plugwise functionaliteit (incl. Home Assistant integratie), de temperatuur in de woonkamer blijft prima stabiel, en bovenal draait het probleemloos. Dus ik zou er niets op vooruit gaan.

[ Voor 5% gewijzigd door WackoH op 04-10-2025 22:19 ]

[_JGC_]

Heb hier de sturing nu enige tijd draaien. Verwarmt goed en relatief snel, maar merkte dat in de ochtend of bij een half graadje meer de regeling net even wat te agressief is. Thermostaat stuurt bij verhoging meteen op 35 graden setpoint, sturing rekent uit dat 27 graden verschil met de buitentemperatuur wel heel veel is en gaat meteen vol gas. Gevolg is deltaT van 10-12 graden en een rammelende compressor en een buurman die het in huis hoort (vanmorgen sms van hem dat hij het best wel vervelend vond).

Dan ben je blij met fatsoenlijke isolatie, nu de regeling tot speedstep 5 beperkt en de aanvoertemperatuur beperken op 5 graden boven retour (hier is de deltaT 2-3 graden bij lang draaien op laagste vermogen).

[P1 modubus]

Goedendag allemaal,
hier een update van mij, ik heb alleen de buitentemperatuur 6-7 grd hoger als werkelijk in schakelbaar gemaakt, om stroom te sparen, de circulatiepomp gaat dan pas draaien als het echt vriest, normaal <5grd C,
nu bij -1 grd., de WP blijft ook langer in bedrijf, hoelang zullen we spoedig zien.
De deltaT blijft ook mooi rond de 5- 6 grd.C
CV Ketel is niet aangesloten op de WP regeling, deze kan ik wel separaat inschakelen mocht het nodig zijn.
Ben nu nog tevreden, stook meestal middags vanaf 13.00 uur tot 20.00 uur wel tot 22 grd in de huiskamer,
Morgens is de dan nog 20.5 grd tot aan de middag 20.0 grd. C tot nu toe..
Zie plaatjes de gewenste watertemperatuur wordt niet gehaald maar is nu perfect voor ons de ruimtetemperatuur stijgt langzaam eigenlijk nog te snel maar om de zonnen energie te gebruiken is dit wel ideaal, al is het een leerproces voor volgend jaar.




Op het WebVision plaatje staat het rendement van 459% berekend uit het opgenomen vermogen en het afgegeven vermogen, de opgenomen energie, zijn de gegevens op het plaatje in de warmtepomp zelf Amp, en Watt, de afgegeven energie, deze zijn berekend uit de gegevens onder de ketel, toevoertemperatuur, retourtemperatuur en stroming..
De temperatuur boven de WP vermeld is de buiten temperatuur.

Gelukkig werkt het nu, ben niet zo goed met software schrijven, wel inmiddels een Arduino une en Raspberry PI 4 en 5 aangeschaft om me toch voor te bereiden, hopelijk is het niet nodig, een studie apart merk ik wel,
wel zeer interessant, wil de temperatuursverwachting mee laten wegen in het stook gedrag van HVAC regeling, weet natuurlijk niet wat het wordt maar dat zie ik wel,

Tot kouder weer.

[P1 modubus]

JGC schreef
Gevolg is deltaT van 10-12 graden en een rammelende compressor en een buurman die het in huis hoort (vanmorgen sms van hem dat hij het best wel vervelend vond).

Het is belangrijk dat het hydraulisch goed in me kaar zit, welke watertemperatuur ook gevraagd wordt, de Dt moet binnen de beperken blijven ook met 100% vermogen, zorg eerst dat de bypass goed ingeregeld wordt, daarna kun je verder, kijk maar naar mijn Dt en stookgedrag van de WP, buurman en jij zullen dan ook blij zijn geen overmatig geluid meer.

Ps. weet niet hoe ik een reactie moet plaatsen, dus nu maar zo.
Succes

[_JGC_]

P1 modubus schreef op maandag 17 november 2025 @ 20:56:
JGC schreef
Gevolg is deltaT van 10-12 graden en een rammelende compressor en een buurman die het in huis hoort (vanmorgen sms van hem dat hij het best wel vervelend vond).

Het is belangrijk dat het hydraulisch goed in me kaar zit, welke watertemperatuur ook gevraagd wordt, de Dt moet binnen de beperken blijven ook met 100% vermogen, zorg eerst dat de bypass goed ingeregeld wordt, daarna kun je verder, kijk maar naar mijn Dt en stookgedrag van de WP, buurman en jij zullen dan ook blij zijn geen overmatig geluid meer.

Ps. weet niet hoe ik een reactie moet plaatsen, dus nu maar zo.
Succes

Die bypass heeft als functie om de overload aan pompvermogen weg te krijgen als de ketel en warmtepomp samen in werking zijn. In mijn geval zou dat 2500 liter per uur betekenen (ik moet de ketelpomp nog een stand naar beneden zetten, maar ketel moet handmatig aangezet worden dus die draaien nooit tegelijk).
Leuk dat die bypass ook gebruikt kan worden om een Dt van 5 graden te maken bij het opwarmen van een installatie, maar daar is 'ie niet voor bedoeld. Zodra die installatie op temperatuur is werkt 'ie alleen maar tegen.

Ik heb overigens de regeling aangepast naar 7 graden... leuk die 5 graden regeling, maar waar bij 28 graden mijn Dt 2-3 graden is, is dat bij 35 graden een ander verhaal. Door die begrenzing wilde afgelopen weekend de aanvoer niet boven de 33 graden stijgen.

Maargoed, wat het geluid betreft... deze unit is niet heel stil. Hij staat bij mij op de oprit, gericht van de gevel af. Denk dat het zo'n 5-6 meter is naar de gevel van de buurman. Het geluid van de pomp wordt tegen zijn gevel geblazen en komt dan terug. Ik hoor 'm vanaf de zijkanten ook alleen maar omdat het geluid weerkaatst tegen de gevel. Ding staat daar gewoon verkeerd, ik ga 'm deze week met een paar RVS flexpijpen een kwartslag draaien zodat de ventilator over de oprit blaast. Mocht dat ook niet afdoende zijn moet ik hem alsnog verhuizen naar de achtergevel waar 12 meter tuin is tot de garage, is qua leidingen wel te doen maar even een uitdaging om het zonder slopen te doen (schuin gipsplafond).

Wat die Dt betreft: Ik heb hier alleen al in de leidingen al meer dan 25 liter water zitten. Komen de bakbeesten van T22 radiatoren nog bij. Dat water wordt met 1000 liter per uur rondgepompt (pompstand 2, 6 meter opvoerhoogte). Zou nog harder kunnen, maar dat geeft ruis. Langzamer geen optie, dan wordt de radiator van de woonkamer niet meer goed warm.

[_JGC_]

Vanmorgen op advies van @P1 modubus de pompstand naar 3 gezet om meer flow over de warmtepomp te krijgen. DeltaT is lager over de radiatoren, de vloer in de berging doet goed mee en de warmtepomp is stiller. Pomp gaat minder hard dan wat mijn ketel op stand 3 deed (alhoewel de curves in de handleidingen anders aangeven).

Verder zit er nogal wat lucht in de installatie, dat wordt nu eindelijk mooi rondgepompt en verzamelt in een paar ontluchtingspijpjes op zolder en in een aantal radiatoren op de bovenverdieping.

Komende dagen nog maar wat workarounds uit de software slopen. Met deze flow is de stappenmodulatie niet meer nodig en er zitten nog een aantal andere eigenaardigheden in.
Verder toch eens kijken of ik een ESP aangesloten kan krijgen. Ik zet nu handmatig een hard maximaal setpoint in de thermostaat zodat de warmtepomp 's nachts minder vermogen vraagt, ik wil gewoon een knopje voor een nachtmodus. Verder geeft directe communicatie meer inzichten aangezien ik via OpenTherm alleen afgeronde getallen zie.

[Ikke83]

_JGC_ mag ik vragen hoe jij het nu hebt gedaan, ik heb terug gelezen maar kom er toch niet helemaal uit.
wat ik me kan bedenken is het volgende:

- Je hebt de IC (die op een arduino uno zit) geprogrammeerd met een aangepaste code van WackoH en deze dan gewisseld met IC2 in de box
- ik lees dat je solderingen heb gedaan, waar precies? (of zijn dezelfde als WackoH?)
- IC4 heb je verwijderd waardoor je niet hoefde te snijden in de printplaat.
- een DIYLESS gebruik je als vervanger voor Anna, is deze dan aangesloten op de verbindingen van de Smile? zeg maar de meest linker aansluiting.

Bij mij gaat het met de standaard instellingen op zich prima.
Op de een of andere manier kan ik de maximale aanvoertemperatuur niet wijzigen, deze staat standaard (en grijs) op 60.
Op zich is dat geen probleem, want ik gebruik de weersafhankelijke modus. Heel vaak draait ie netjes op 34 graden aanvoer temperatuur, met de heatboosters in mijn convector radiatoren gaat dit heel goed.

Het jammere is dat als de temperatuur bereikt is volgens Anna de gehele warmtepomp uit gaat. Wat natuurlijk logisch is
Het liefst zou ik zien, net als bij jou en WackoH dat de Warmtepomp op iets van 250W gaat draaien zodat er toch iets van een warme luchtstroom (of wat er van over blijft) door het huis gaat. Het gevoel van kilheid komt namelijk snel boven als de Aurea er mee stopt.

alvast bedankt

[WackoH]

Ik ben begonnen met een GiHub pagina. Daar ben ik bezig alles samen te vatten, in plaats van dat het als een ontdekkingsreis in posts over een paar maanden verspreid staat. Deze staat nu nog even op private tot die verder is gevuld. Denk dat ik daar dit weekend wel tijd voor heb.

Ik zal dat in het Engels doen zodat er internationaal extra hulp kan komen, want dezelfde buitenunit wordt ook bekend in o.a. UK en Frankrijk gebruikt (wellicht wel met andere interface hardware). Ik vond laatst een aantal Engelse posts van iemand die ook e.e.a. had bereikt.

BIj mij doet de Anna nog steeds de primaire regeling, oftewel de aanvraag voor een bepaalde water aanvoertemperatuur.
Hoe dit wordt bereikt, regelt een Arduino nu i.p.v. de controlbox, Daarin zit een PID regelaar die de gemeten aanvoertemperatuur (bestaande sensor in de warmtepomp op met 0.1oC resolutie) gebruikt om en vermogensvraag te berekenen.
Het totaal is dus en 2-staps regeling, dus primair / secundaire (of aan master/slave control, maar dat is niet meer PC )
Dus ook bij mij gaat de WP uit als de Anna het genoeg vindt. Zonder verstoren (koken geeft veel warmte af) blijft de temperatuur in de woonkamer binnen paar tienden stabiel (vloer + 1 radiator)

[_JGC_]

Ikke83 schreef op donderdag 20 november 2025 @ 21:24:
_JGC_ mag ik vragen hoe jij het nu hebt gedaan, ik heb terug gelezen maar kom er toch niet helemaal uit.
wat ik me kan bedenken is het volgende:

- Je hebt de IC (die op een arduino uno zit) geprogrammeerd met een aangepaste code van WackoH en deze dan gewisseld met IC2 in de box
- ik lees dat je solderingen heb gedaan, waar precies? (of zijn dezelfde als WackoH?)
- IC4 heb je verwijderd waardoor je niet hoefde te snijden in de printplaat.
- een DIYLESS gebruik je als vervanger voor Anna, is deze dan aangesloten op de verbindingen van de Smile? zeg maar de meest linker aansluiting.

Bij mij gaat het met de standaard instellingen op zich prima.
Op de een of andere manier kan ik de maximale aanvoertemperatuur niet wijzigen, deze staat standaard (en grijs) op 60.
Op zich is dat geen probleem, want ik gebruik de weersafhankelijke modus. Heel vaak draait ie netjes op 34 graden aanvoer temperatuur, met de heatboosters in mijn convector radiatoren gaat dit heel goed.

Het jammere is dat als de temperatuur bereikt is volgens Anna de gehele warmtepomp uit gaat. Wat natuurlijk logisch is
Het liefst zou ik zien, net als bij jou en WackoH dat de Warmtepomp op iets van 250W gaat draaien zodat er toch iets van een warme luchtstroom (of wat er van over blijft) door het huis gaat. Het gevoel van kilheid komt namelijk snel boven als de Aurea er mee stopt.

alvast bedankt

Ik heb de IC die met de warmtepomp communiceert eruit gehaald, die ligt gewoon werkloos bovenop de box.
Ik heb voor nu de solderingen van @WackoH gedaan op de print zodat ik prikpennetjes heb die ik in een Arduino Mega kan stoppen. Het doorsnijden van printbanen heb ik niet gedaan want er zit nu geen chip in de voet.
De DIYLESS komt gewoon op de OT-pinnen waar je normaalgesproken de Smile op aansluit, de Smile en Anna gebruik je dan niet meer.

Overigens kan je met de standaard sturing ook gewoon met de DIYLESS werken. Enig dingetje waar je rekening mee moet houden is dat sommige thermostaten een setpoint blijven doorgeven. De controlbox van de Aurea doet niks met CH_ON, kijkt alleen naar het setpoint. Bij de DIYLESS is dat 10 graden, wat volgens de standaarden voldoet als "uit". De Anna doet daar 0. Bij 20 graden stuurt de DIYLESS een CH_ON, ik begin zelf al eerder met stoken. Een Remeha iSense kan je niet aansluiten, die blijft 24/7 doorstoken.

Het einddoel is om gewoon een Arduino Uno te kopen met verwijderbare chip en die in het voetje te drukken, dan hoef je niks te solderen. Code hoeft daar maar weinig aanpassingen voor.
Ik moet even kijken welke pinnen naar de schakelaar en het ingebouwde LED lampje gaan, waarschijnlijk kan ik op die pinnen dan de communicatie opzetten met een ESP32, hoeft daar alleen een draadje aan met een connector zonder dat er aan de print gesoldeerd hoeft te worden.

Edit: via de pinnen van LED/schakelaar wordt niks als ik de uitgetekende versie van de print goed begrijp. Dan eerder draadjes vastsolderen aan ongebruikte pinnen van de controller. Draadjes bij het voetje indrukken is sowieso no-go.

[ Voor 3% gewijzigd door _JGC_ op 21-11-2025 11:57 ]

[_JGC_]

Wordt tijd om een printje te solderen, de prikdraadjes is instabiel...

Misschien dat ik de foute data stuur nu het zo koud is, maar de OT controller stuurt prachtig de aanvoer/retour door naar de thermostaat, maar setpoint krijg ik niet meer terug. Er komt geen of te weinig data binnen op RX.

Omdat ik nu toch al aan het prutsen was met een ESP8266 en MQTT heb ik dus maar de thermostaat setpoint gepusht via MQTT. Daarnaast kan ik nu gewoon met een schuifje het maximale schakelpunt van de buitenunit instellen.

Doel: laat de thermostaat lekker op 20.5 of 20 staan 's avonds, schroef het vermogen gewoon terug en we zien wel hoe warm het in de ochtend is, mag dan het schuifje weer naar 5. Ik zit nu nml elke ochtend in de kou en uiteindelijk herrie als ik de thermostaat setpoint omhoog gooi omdat de warmtepomp niet snel genoeg inkomt.

[_JGC_]

Prikdraadjes is idd instabiel, ook tussen de ESP8266 en de Mega is de communicatie niet zonder storingen. Komt ook omdat die ESP met SoftwareSerial werkt. Dit zal ook de reden zijn waarom de OT controller lijkt te zwijgen, ik krijg soms wel data binnen maar het zijn niet genoeg bytes.

Ik heb nu een Uno R4 Wifi en een paar soldeer printplaten besteld. Printplaatje op maat maken voor de DIP28 socket en de juiste pinnen erin en dan gewoon alles afhandelen vanuit de Uno R4. WP communicatie zal dan met SoftwareSerial moeten. Simpelweg uit de socket aftappen en geen verdere solderingen meer nodig.

[dingo35]

Ik kan als hardware platform de ESP32 aanraden; krachtig genoeg om diverse protocollen te decoderen (RS232, RS485), en superveel libraries beschikbaar om MQTT, web-interface e.d. te maken.

Zie als voorbeeld https://github.com/dingo35/smartevse-3.5/

[ Voor 3% gewijzigd door dingo35 op 26-11-2025 02:47 ]

[_JGC_]

Nadeel van de ESP32 is 3.3V I/O. Ben al met level shifters of weerstanden bezig geweest, maar de data die uit de warmtepomp krijgt klopt dan niet met wat ik met een 5V controller krijg.

Overigens is de R4 Wifi ook niet de oplossing. Zodra je die aan MQTT knoopt wordt de cycle time 10 seconden.
Gelukkig is de ESP32 op dat ding te flashen, dus kan mijn Mega code in het Uno gedeelte en de ESP8266 code in het ESP32 deel. Is qua flashen wat meer uitdaging.

Overigens ga ik de hele code over de kop gooien. Ik ga zelf OT en ketelsturing doen, dan kan de OT controller er ook uit.

[dingo35]

Is een 74AHCT125 niet een veel simpeler oplossing?

EDIT: voor lezen van signalen zou een 1k weerstand in serie met het signaal al moeten werken, en anders een spanningsdeler 10k/20k. SN74LVC8T245 zou ook moeten werlen...

[ Voor 63% gewijzigd door dingo35 op 26-11-2025 13:41 ]

[_JGC_]

dingo35 schreef op woensdag 26 november 2025 @ 13:35:
Is een 74AHCT125 niet een veel simpeler oplossing?

EDIT: voor lezen van signalen zou een 1k weerstand in serie met het signaal al moeten werken, en anders een spanningsdeler 10k/20k. SN74LVC8T245 zou ook moeten werlen...

Logic shifter (zo'n goedkoop printje met 4 SMD transistors) had ik geprobeerd, die geeft geen werkend signaal. Die chip heb ik meer vertrouwen in dan een klein printje van Amazon.
Ik heb nu 1K/2K naar ground tussen de ESP en de Arduino Mega, dat werkt.
Ik heb ook even de print bestudeerd, of iig de tekening van @WackoH, er zitten al spanningsdelers in het circuit om er 5V van te maken. Daar dan nog eentje tussen zetten? Lijkt me handiger om te berekenen welke weerstand er dan wel moet komen om de spanningen goed te krijgen.

Maargoed, waar je even mee zit: de buitenunit wil een constant signaal krijgen van de controller, anders slaat 'ie af. Als je 1 controller gebruikt voor Wifi/MQTT, buitenunit communicatie en OpenTherm, kom je met je timings in de problemen zodra je MQTT niet lekker reageert of je wifi signaal slecht is.

Op de R4 Wifi kan je gewoon beide controllers flashen met eigen code, er is over USB dan nog communicatie via de SERIAL_AT poort: https://github.com/vshymanskyy/UNO-R4-WiFi-freedom

Ik ga de Wifi/MQTT code in de ESP32 flashen en dan gewoon data oversturen tussen beide controllers. Zo doe ik het nu ook met de ESP8266 en Mega2650 en dat werkt naar behoren.
OpenTherm ga ik proberen, laatste keer mislukte omdat ik de Ground niet verbonden had. Enige uitdaging daarin is dat de Renesas chip geen AVR architectuur is en de OpenTherm libraries alleen gemaakt zijn voor ESP of AVR. Paar #!ifdef __AVR__ blokken weggesloopt en het compileert, of het dan ook werkt is een 2e.

[dingo35]

_JGC_ schreef op woensdag 26 november 2025 @ 13:59:
[...]


Maargoed, waar je even mee zit: de buitenunit wil een constant signaal krijgen van de controller, anders slaat 'ie af. Als je 1 controller gebruikt voor Wifi/MQTT, buitenunit communicatie en OpenTherm, kom je met je timings in de problemen zodra je MQTT niet lekker reageert of je wifi signaal slecht is.

Ik heb veel ervaring met de SmartEVSE code; daar lezen we meerdere signalen tegelijkertijd uit:
-LCD scherm via SPI
-modbus via UART
-CP lijn via GPIO
....en dat gaat allemaal prima, zelfs onder zware HTTPS belasting, tegelijkertijd met MQTT. Geen problemen als de wifi wegvalt, die reconnect bij hersteld AP signaal gewoon weer netjes terug.

In een prototype communiceren we zelfs met een andere chip via UART2, bovenop al het hierboven genoemde, en dat gaat tot 1Mbps nog foutloos....

Dit zou dus gemakkelijk met een single chip oplossing moeten kunnen. Ik ben zelf meer de software man, als je (een link naar) je schema hebt kan ik het wel eens aan de hardware specialist voorleggen, maar alleen als je echt van plan bent die route op te gaan.

EDIT: De truc zit m erin dat we drie loops hebben, een 10ms loop, een 100ms loop, en een 1000ms loop; de kunst is om de juiste routine in de juiste timingloop aan te roepen, en die de juiste FreeRTOS prio te geven.
EDIT2: De eerlijkheid gebied te melden dat het prototype op een ESP32-S3 draaide, de productie hardware is een "gewone" 4MB ESP32...

[ Voor 12% gewijzigd door dingo35 op 26-11-2025 14:55 ]

[_JGC_]

@dingo35 Beschrijving van de communicatie zit hier:
WackoH in "Aurea 5 hybrid: interfaces met de buitenunit en thermostaat"

Tekening van de hardware zit in deze post:
WackoH in "Aurea 5 hybrid: interfaces met de buitenunit en thermostaat"

Code "werkt", maar is voor verbetering vatbaar. Ik vind het vooral onleesbaar. Heb een informatica opleiding genoten maar ben geen MCU-programmeur. Die code ga ik zeker herschrijven

Schijnt dat de timing niet eens heel idioot hoeft te kloppen, maar die 10 seconden zoals ik gisteren zag bij het opzetten van MQTT met een R4 Wifi slaat helemaal nergens op. Dat doet zelfs een ESP8266 beter. Vandaar dat ik de ESP zelf wil programmeren. Vind het zonde van de hardware dat ze het zo hebben opgelost.

[P1 modubus]

Dingo schreef,
Ik heb veel ervaring met de SmartEVSE code; daar lezen we meerdere signalen tegelijkertijd uit:
-LCD scherm via SPI
-modbus via UART
-CP lijn via GPIO
....en dat gaat allemaal prima, zelfs onder zware HTTPS belasting, tegelijkertijd met MQTT. Geen problemen als de wifi wegvalt, die reconnect bij hersteld AP signaal gewoon weer netjes terug.

Weten jullie of de Arduino of de Raspberry pi kan communiceren via Modbus RTU met de seriële verbinding,
ik wil namelijk de weersverwachting doorgeven aan de HVAC regeling.?

[dingo35]

De ESP32 kan zeker via de UART met modbus RTU communiceren, daar zijn ook verschillende modbus libraries voor; voor code voorbeeld zie de github repo enkele posts up.

[WackoH]

_JGC_ schreef op woensdag 26 november 2025 @ 15:24:
Code "werkt", maar is voor verbetering vatbaar. Ik vind het vooral onleesbaar. Heb een informatica opleiding genoten maar ben geen MCU-programmeur. Die code ga ik zeker herschrijven

Ik lees mee, heh…. Iets vriendelijker en minder arrogant/neerbuigend mag wel... 😉

Bij mij WERKT het perfect en robuust: Temperatuur binnen paar tienden stabiel, software crasht of hangt nooit. De Plugwise functionaliteit met Anna thermostaat, weersafhankelijke regeling (stooklijn), gebruik van app en HA integratie zijn volledig behouden en verbindingen zijn zeer stabiel. Dit is allemaal belangrijk voor de PAF (Partner Acceptance Factor).
Opgenomen vermogen zie ik via tussenstekker met Zigbee op HA.

Zou wel eens de best werkende Aurea in Nederland kunnen zijn😊
Ik kan zelfs koelen als ik zou willen.

De code is zoveel mogelijk geoptimaliseerd voor snelheid (met AI) omdat het schrijven naar het schermpje dat ik heb gebruikt veel tijd vraagt. En ja, dat maakt het lastig leesbaar. Maar ik heb voor jullie zo veel mogelijk toelichting erbij gezet.

De problemen die je noemt zijn bv. het gevolg van een andere manier van hardware implementatie en de manier waarop je het setpoint voor de aanvoertemperatuur geeft.

Het is een projectje geweest dat in de loop van de tijd is gegroeid. Van de aansturing begrijpen, via berichten minimaal modificeren tot nu volledige besturing nu. Dus ja, dan is het niet perfect en de code is ongetwijfeld voor verbetering vatbaar.

Met de kennis van nu zou ik het ook anders opzetten. Hiervoor heb ik al een touchscreen met ESP32 liggen. Maar waarom wijzigen wat ik nu heb? Het is goed genoeg en de Aurea gaat te weinig capaciteit hebben als ik huis uitbreid.

[_JGC_]

@WackoH Je rotary encoder voorbeeld is gewoon duidelijk. Probleem met de latere regeling is dat er heel veel dingen zijn toegevoegd en waar je later in hebt gesnoeid om het deelbaar op het forum te maken. Vervolgens heb ik daar nog een en ander in verbouwd waar het ook niet duidelijker van wordt. Niet om arrogant of neerbuigend te doen, ik ben juist heel blij met wat jij voor dit topic betekent. Zonder jouw werk was dit niet mogelijk geweest.

Zoals het nu lijkt ga ik je rotary encoder voorbeeld gebruiken, daar OpenTherm communicatie aan toevoegen en dan wat statistieken uitpoepen via die ESP controller naar MQTT. Via MQTT bepaal ik ook de maximale speed setpoint zodat ik een nachtmodus heb. Die OT controller gaat dus ook uit de box als het aan mij ligt.

Vandaag de hele dag op stand 2 en 3 gedraaid, vanmorgen 3 defrosts. Tussendoor is de warmtepomp even een uur uit geweest en vannacht 3x een halfuur uit. In de nacht gaat het maximale vermogen naar stand 2 (alhoewel de buitenunit soms alsnog eigenwijs 650W gaat draaien). Het is hier nu dag en nacht 20.3 graden met aanvoertemperatuur tussen 28 en 37 graden.

Enig dingetje is dat mijn sluipverbruik op slimmemeterportaal nu van 80W naar 546W is gegaan.

[ Voor 6% gewijzigd door _JGC_ op 26-11-2025 23:47 ]

[Ikke83]

@WackoH In november heb je gepost dat je met een GitHub pagina bezig was. Mag ik vragen hoe het er voor staat? Heb nu nogmaals de gehele post doorgelezen maar kom er toch nog niet helemaal uit.

De optie die _JGC_ voorstelde om een IC van de Arduino Uno te pakken en die in het voetje te drukken klonk mij het meest makkelijk maar volgens mij heb je dan niet alle opties vanwege de beperkingen van de Uno chip.

En zijn de codes van Maartenkromhout (met de mooie webinterface) nu nog de juiste, of is er in de tussentijd nog wat gewijzigd?

Thanks

[_JGC_]

@Ikke83 IC vervangen door een chip uit een uno met los voetje heb ik laten varen. Ik heb nu een Mega controller en een ESP8266. Code van Maartenkromhout en Wackoh heb ik aangepast en samengevoegd en stuurt nu mijn geheel aan. Ik heb dan geen webinterface overigens, maar doe alles via MQTT.

Ik ga komende week de Uno R4 Wifi inzetten, die heeft een ESP32 op het bordje zitten. Ik merk aan de grafiekjes in HA dat er best wel eens wat fouten in de communicatie zitten waardoor er tekens wegvallen in de json en waarden van powerlevel uitkomen op de waarde voor de berekende aansturing. De Uno R4 Wifi heeft een USB verbinding tussen beide chips wat veel minder storingsgevoelig is dan wat ik nu heb.

Tot nu toe werkt de sturing redelijk, hier en daar nog wat bugjes. Vorige week liep de hele sturing vast en moest ik de Mega controller resetten om het huis weer warm te krijgen.

[Ikke83]

Ben toch even begonnen met ontrafelen waar alles heen moet.
Voor nu weet ik alleen nog niet wat ik met R17 precies moet. en of deze überhaupt nodig is.
Moet er bij R14 aan de weerstand zijde (die naar RX3 gaat) nu nog een weerstand voor naar de Mega? en moet dat dan ook bij Pad1 en Pad2? of mogen die zonder?



Alvast bedankt! ik ga in ieder geval alvast een Arduino Mega bestellen

[_JGC_]

@Ikke83 Als je bereid bent de volledige regeling over te nemen kan je ook 2 rijen pinnen op een gaatjesprint solderen, draadjes eraan op de juiste pinnen en zo in je Mega bordje stoppen, hoef je aan de print niks te solderen en kan je gewoon de weerstanden van het bord zelf gebruiken.
Gaatjesprint met headers eraan prik je dan in de socket van de linker chip.

[Ikke83]

Ja, dat kan ook. heb ook gezien dat een rijtje dupont draadjes ook dezelfde afstand is.
Maar welke code voor de arduino hoort daar dan bij en welke draad gaat waarheen? Had wel gezien dat niet elk pootje van IC4 gebruikt wordt dus dat scheelt al. Het klinkt alleen wel wat ingewikkelder of heb jij misschien meer info hierover? Lijkt me wel tof

[_JGC_]

Ik ben inmiddels wat verder met mijn Uno R4 Wifi projectje. Heb een Oekraïense github repo gevonden waarbij beide controllers op het printje eigen code kunnen draaien en communicatie over USB mogelijk is. Daar wil ik op voortborduren en ben er inmiddels ook uit hoe OTA updates werken op beide controllers. De WifiS3 library is niks anders dan een USB modem tussen de Renesas controller en de ESP32, waarbij de Renesas controller steeds naar de ESP32 stuurt wat ie moet doen. Dat verklaart ook de traagheid ervan. OTA update van de Renesas controller wordt door de ESP32 uitgevoerd.

Idee is om nu een compleet project op te tuigen in de ESP32 en dan de Renesas controller de communicatie met buitenunit en de OT controller te laten doen. In principe kan de renesas controller zelfstandig opereren, maar alle bijsturing (max vermogen, setpoint override) en monitoring loopt via de ESP32.

@Ikke83 Voor de pinlayout moet je even terugzoeken in het topic, Wackoh heeft dat gedocumenteerd. In principe heb je GND en RX/TX naar de warmtepomp nodig. Daarnaast heb je nog een RX en een TX naar de OT controller. Ik heb eerder hierboven een aangepaste sturing gepost die met een statisch array met bytes werkt waar de OT controller genoegen mee neemt.
In principe heb je de OT controller ook niet nodig, maar als je een OT thermostaat hebt en je graag de hybride sturing wilt houden moet je die laten zitten. Volgens mij kan je de ketel ook in aan/uit mode zetten en het relais aansturen, dan zou de ketel ook aan moeten gaan. Maar dan nog heb je een setpoint nodig om op te sturen, die krijg je (als het werkt) via de OT controller van de thermostaat.

[Maartenkromhout]

@_JGC_ heb jij misschien die github voor ons?

Ik ben zelf ook weer bezig geweest en heb het 1 en ander op github staan. misschien leuk om te zien.

https://github.com/kromhoutmaarten-sys/Aurea-5-hybrid_uno4/

[_JGC_]

@Maartenkromhout Helaas nog vooral aan het knutselen met de Uno R4 Wifi op dit moment. De Mega met een ESP8266 doet hier de regeling nu.

Wel grappig om jouw regeling te doorgronden: je regelt volledig via MQTT of je webinterface, negeert de OT controller in de controlbox en doet gewoon lekker je eigen ding. Ook stand 1 draaien onder de 5 graden is leuk om te zien. In principe draait je thermostaat gewoon op je controller.

Ik regel in mijn setup nog op de OT-setpoint van de thermostaat. Ben er alleen nog niet over uit of dat wel zo handig is, met 2 PID algoritmes die van ruimtetemperatuur naar watertemperatuur naar warmtepomp vermogen rekenen. Zo heb ik de afgelopen dagen gestookt met stand 1 in de nacht, stand 2 in de ochtend en rest van de dag weer stand 1. Als het aan de thermostaat had gelegen had 'ie in de ochtend op stand 5 eerst het water naar 40 graden gestookt.

[ThinkPad]

Maartenkromhout schreef op dinsdag 24 februari 2026 @ 17:57:
@_JGC_ heb jij misschien die github voor ons?

Ik ben zelf ook weer bezig geweest en heb het 1 en ander op github staan. misschien leuk om te zien.

https://github.com/kromhoutmaarten-sys/Aurea-5-hybrid_uno4/

Je weet dat via de diff de credentials zo zijn terug te halen en dus nog steeds leesbaar in de repo zijn te vinden? Zoek even hoe je dat opschoont.
AI is flink los gegaan in je project trouwens, wat een bloat in die readme/code comments

@Maartenkromhout en @_JGC_ zijn jullie op de hoogte van OpenAmber: Itho Daalderop Amber warmtepomp firmware ? Gaat over aansturen via modbus dus voor de Chofu niet relevant. Maar qua algoritmes en andere code wellicht bruikbaar.

[ Voor 3% gewijzigd door ThinkPad op 24-02-2026 21:15 ]

[Maartenkromhout]

@_JGC_ Heb jij voor mij een foto van binnen uit jou kast? ik ben heel erg geintreseerd hoe jij het hebt gedaan zonder dingen los te halen.

misschien kan je dit hier uit de doeken doen ;-)

[_JGC_]

@Maartenkromhout Ik heb hier de RX en TX draden gesoldeerd zoals aangegeven in dit topic. Verder hangen er draden aan de pads naar de OT controller. De printbanen doorsnijden tussen de beide controllers heb ik niet gedaan, aangezien ik de chip verwijderd heb.

Volgende stap was een printplaatje voorzien van headers en in het voetje drukken, headers aan de andere kant en dan draadjes daarop prikken. Dan hoef je niet te solderen, maar helaas is mijn pakketje van AZdelivery kwijtgeraakt destijds en heb ik er verder geen tijd meer ingestoken.

@ThinkPad Dat project is me bekend, maar helaas heeft de Chofu buitenunit teveel eigenaardigheden om het op die manier op te lossen. Komt bij dat ik specifieke eisen heb vanwege de beroerde plaatsing te dicht op de woning van de buurman. Met dat project ga ik komend weekend aan de slag, eindelijk fatsoenlijk weer en een vrij weekend .

[Maartenkromhout]

@_JGC_ ik kom er dus niet uit hoe de draden precies moeten zitten. Ik zoek echt een "goede" duidelijk foto en waar wat moet

[Ikke83]

Ik liep daar ook al tegenaan, ik heb het hele forum nagelopen maar ik kan nergens vinden hoe de aansluitingen exact zitten. Het zou mooi zijn als dat inderdaad zichtbaar kan worden gemaakt dmv een foto of iets dergelijks. Of eventueel mijn foto in de eerdere post verduidelijken? Volgens mij klopt die wel aardig, zit alleen met die weerstanden te hannesen.

[hyeronimo]

Allereerst mijn dank voor het vele werk van @WackoH en @Maartenkromhout voor deze warmtepompsturing! op https://github.com/kromhoutmaarten-sys/Aurea-5-hybrid_uno4 vond ik alles wat ik nodig heb om de wp aan te sturen. Alleen op een punt ben ik nog onzeker: waar zijn de TX en RX op de control box? Zo te zien heeft Maarten dit werkend. Als ik de berichten doorlees, zie ik dat @WackoH de pins vann IC4 heeft beschreven. Als je IC4 eruit haalt en de besturing door de Arduino laat doen kom ik op de volgende aansluitingen:



Kan iemand dit bevestigen? Bij voorbaat dank!

[ Voor 32% gewijzigd door hyeronimo op 25-03-2026 13:09 ]

[dingo35]

Ik kom op die github repo dit plaatje tegen; mijn control box heeft helemaal geen LCD display.....?!?

╔═══════════════════════════════╗
║ Atlantic Aurea Controlbox ║
╠═══════════════════════════════╣
║ ┌─────────────┐ ║
║ │ Display LCD │ ║
║ └─────────────┘ ║
║ ║
║ Terminal Block (onderaan): ║
║ ┌───┬───┬───┬───┬───┐ ║
║ │TX │RX │5V │GND│ ? │ ║
║ └───┴───┴───┴───┴───┘ ║
╚═══════════════════════════════╝8

[hyeronimo]

Ja inderdaad, bij mij ook niet. het terminalblock linksonder heeft volgens mij 220V.