openWB, Wärmepumpe, Shelly

[mabe]

Hi,

ich bin gerade dabei eine Wärmepumpe mit ins System zu integrieren.

Zur Verfügung steht die openWB Wallbox und ein ShellyEM.
Die VIessmann Wärmepumpe hat einen SG Ready Eingang (230V werden geschaltet).

Kann ich den Shelly EM alleine benutzen (ebenfalls zur Verbrauchsmessung der Wärmepumpe und zur Relais Ansteuerung) oder brauche ich zusätzlich noch einen Shelly 2.5 ?

Gruß
Markus

[Flocki]

Hi,

für die SG-ready Ansteuerung benötigen die Viessmannsteuerungen einen potentialfreien Schalter. Der einzigen Shelly, der das bieten kann ist der Shelly 1 (nicht 1PM!).

Viele Viessmannsteuerungen unterstützen dazu auch noch eine Ansteuerung über Modbus/RS485. Das hat auch noch den Vorteil, dass die Wärmepumpe nicht nur ein Ein/Aus-Signal bekommt, sondern auch exakt weiß, wieviel Überschuss vorhanden ist und entsprechend steuert.
Wenn die Wallbox das untersttzt, wäre das natürlich noch eleganter...

Gruß,
Florian

[mabe]

Hallo Florian,

Viele Viessmannsteuerungen unterstützen dazu auch noch eine Ansteuerung über Modbus/RS485. Das hat auch noch den Vorteil, dass die Wärmepumpe nicht nur ein Ein/Aus-Signal bekommt, sondern auch exakt weiß, wieviel Überschuss vorhanden ist und entsprechend steuert.
Wenn die Wallbox das untersttzt, wäre das natürlich noch eleganter...

Du hast recht mit dem potentialfreien Kontakt. Ich habe hier noch einen Shelly 2.5.
So wie es aussieht ist dieser ebenfalls ohne zusätzliches Relais nicht brauchbar.

Allerdings gibt es bei der Vitocal 200 mehrere Möglichkeiten des Anschluß. Auf der Erweiterung EA1 ist es ein potentialfreier Kontakt (DE3). Und auf der Grundplatine wird der Kontakt X3.1 (L') mit C verbunden.


Kann ich softwareseitig (openWB) einen ShellyEM und einen Shelly 1 demselben Verbraucher (Wärmepumpe zuordnen).


Viessmann scheint mit dem Modus einen eignen Weg zu gehen. Hier wird scheinbar nur der eigne Modus Zähler unterstützt. Hat hier jemand nähere Infos ?

[Flocki]

Der von Viessman verwendete Zähler ist ein "ALE3D5FD10C2A00" mit Viessmann Aufdruck.

Informationen über die verwendeten Modbusregister gibt es im Datenblatt: https://datenblatt.energiezaehlershop.d ... Modbus.pdf

Da nur eine handvoll der Register tatsächlich verwendet wird, habe ich das bei mir mit einem RS485-USB-Stick an einem NAS nachgestellt (openWB kommt erst demnächst ). Demenstprechend sollte eine Implementierung auf einem Raspberry Pi auch kein Hexenwerk sein.

[mabe]

Hi Flocki,

hast du Deine openWB schon.
Ich suche noch einen Weg den aktuellen Stromüberschuß über Modus an die Vitocal zu übergeben.
Der externe Zähler von Viessmann fällt weg, da ich über einen Wandler den Stromverbrauch messen muß.
Im Augenblick wird er über den SMA Homemanager 2.0 an openWB übergeben.

Was für externe Hardware würde sich denn anbieten ?
Am besten Wifi -> Modbus -> Vitocal (angesteuert über openWB).


Gruß
Markus

[Flocki]

Hallo,

die OpenWB wird bei mir morgen endlich angeschlossen.

Die Ansteuerung der Wärmepumpe erfolgt bei mir über einen Raspberry Pi mit einem DSD TECH SH U10 (USB->RS485) Adapter, wobei ich hier einen externen Raspberry verwende und nicht den in der OpenWB verbauten.

Gruß,
Florian

[Speedlimit]

Hallo zusammen

Hab mir jetzt auch länger Gedanken gemacht wie ich den PV Überschuß nicht nur in die EV´s sondern falls nichts angesteckt ist, auch anderweitig speichern kann ohne ihn billig einzuspeisen.

Vorhanden sind.
- OpenWB
- EV,s
- Erdwärmepumpe
Leider ohne externe Regelung. Die Wärmepumpe ist mittlerweile schon 12 Jahre. Läuft aber noch sehr gut.

Nach einigem stöbern und lesen würde ich es so umsetzen.
Einen Shelly 1 verbauen der über die Open WB gesteuert wird. Bei Überschuß schaltet der Shelly eine Widerstand durch der Parallel zum Original PTC des Warmwasser Fühlers ist. Somit denkt die WP das sie ca 10 Grad weniger Temp im Warmwasser hat und heizt auf.

Wenn der Shelly wieder weggeschalten wird kommt der Originale Widerstandswert wieder zum tragen.

Was haltet ihr davon?
Bzw. wäre es sinnvoller den Außentemperaturfühler oder den Warmwasser Temperaturfühler zu nehmen.
Ich weiß. Ist etwas speziell.

Grüße Speedlimit

[mabe]

Hallo Flocke,

.Die Ansteuerung der Wärmepumpe erfolgt bei mir über einen Raspberry Pi mit einem DSD TECH SH U10 (USB->RS485) Adapter, wobei ich hier einen externen Raspberry verwende und nicht den in der OpenWB verbauten.

So weit bin ich mittlerweile ebenfalls.

Kannst du mir das Python Script zur Verfügung stellen ?

Besten Dank

[Flocki]

Ich habe mir ein kleines Programm in C, basierend auf der modbuslib geschrieben.
Es horcht am Port 1502 und bekommt den aktuellen Überschuss in Klartext als 5-stellige Zahl.

Soll es da die Zahlen in einem andern Format bekommen(z.b. MQTT) müsste man das anpassen oder ein anderes Skript vorschalten.


-------------------

#include <pthread.h>
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <strings.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include "/usr/include/modbus/modbus.h"

#define DEFAULT_BUFLEN 512
#define DEFAULT_PORT 1502

modbus_mapping_t *mapping;
int n_shutdown;

void *ModbusThread(void *lpParam)
{
uint8_t req[MODBUS_RTU_MAX_ADU_LENGTH];// request buffer
int len;// length of the request/response
int nStop;

mapping = modbus_mapping_new(0, 0, 52, 0);
if (!mapping) {
printf("Failed to allocate the mapping: %s\n", modbus_strerror(errno));
exit(1);
}

mapping->tab_registers[0] = 10; //Firmware
mapping->tab_registers[21] = 0; //Comm ok
mapping->tab_registers[24] = 0; //Metering ok
mapping->tab_registers[27] = 0; //Counter 1 Total high (in 10 Wh)
mapping->tab_registers[28] = 0; //Counter 1 Total low (in 10 Wh)
mapping->tab_registers[29] = 0; //Counter 1 Partial high (in 10 Wh)
mapping->tab_registers[30] = 0; //Counter 1 Partial low (in 10 Wh)
mapping->tab_registers[31] = 0; //Counter 2 Total high (in 10 Wh)
mapping->tab_registers[32] = 0; //Counter 2 Total low (in 10 Wh)
mapping->tab_registers[33] = 0; //Counter 2 Partial high (in 10 Wh)
mapping->tab_registers[34] = 0; //Counter 2 Partial low (in 10 Wh)
mapping->tab_registers[37] = 0; //Power Phase 1 (in 10W)
mapping->tab_registers[42] = 0; //Power Phase 2 (in 10W)
mapping->tab_registers[47] = 0; //Power Phase 3 (in 10W)



modbus_t *ctx = modbus_new_rtu("/dev/ttyUSB0", 19200, 'E', 8, 1);
if (!ctx) {
printf("Failed to create the context: %s\n", modbus_strerror(errno));
exit(1);
}

//Set the Modbus address of this slave (to 3)
modbus_set_slave(ctx, 60);


if (modbus_connect(ctx) == -1) {
printf("Unable to connect: %s\n", modbus_strerror(errno));
modbus_free(ctx);
exit(1);
}

nStop = 0;
while ((nStop == 0) && (n_shutdown == 0)) {
len = modbus_receive(ctx, req);

if (len == -1)
{
printf("Error on receive: %s\n", modbus_strerror(errno));
nStop = 1;
}
else {
//printf("Receive Length: %d\n", len);
len = modbus_reply(ctx, req, len, mapping);
}

}

printf("\nExit the loop: %s\n", modbus_strerror(errno));

modbus_mapping_free(mapping);
modbus_close(ctx);
modbus_free(ctx);

return 0;
}

void *SocketThread(void *lpParam)
{
int sockfd, newsockfd, portno;
socklen_t clilen;
char buffer[DEFAULT_BUFLEN];
struct sockaddr_in serv_addr, cli_addr;
int n;
unsigned int iPower;

sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0)
{
printf("ERROR opening socket");
n_shutdown = 1;
return 0;
}

bzero((char *) &serv_addr, sizeof(serv_addr));
portno = DEFAULT_PORT;
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = INADDR_ANY;
serv_addr.sin_port = htons(portno);

if (bind(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0)
{
printf("%d - ", errno);

printf("ERROR on binding");
close(sockfd);
n_shutdown = 1;
return 0;
}

while (n_shutdown == 0)
{
listen(sockfd,5);
clilen = sizeof(cli_addr);
newsockfd = accept(sockfd, (struct sockaddr *) &cli_addr, &clilen);
if (newsockfd < 0)
{
printf("ERROR on accept");
close(sockfd);
n_shutdown = 1;
return 0;
}

bzero(buffer,DEFAULT_BUFLEN);
n = read(newsockfd,buffer,DEFAULT_BUFLEN-1);
if (n < 0)
{
printf("ERROR reading from socket");
close(newsockfd);
close(sockfd);
n_shutdown = 1;
return 0;
}
if(n == 5)
{
iPower = atoi(buffer);
printf("\nPower: %u W", iPower);
mapping->tab_registers[37] = iPower / 30; //Power Phase 1 (in 10W)
mapping->tab_registers[42] = iPower / 30; //Power Phase 2 (in 10W)
mapping->tab_registers[47] = iPower / 30; //Power Phase 3 (in 10W)
}

close(newsockfd);
}

close(sockfd);
n_shutdown = 1;

return 0;
}

int main()
{
pthread_t threadSer;
pthread_t threadSock;

n_shutdown = 0;

pthread_create( &threadSock, NULL, SocketThread, NULL);

while(n_shutdown == 0)
{
pthread_create( &threadSer, NULL, ModbusThread, NULL);

pthread_join( threadSer, NULL);
}

pthread_join( threadSock, NULL);

return 0;
}

[mabe]

Besten Dank.

Der neue Raspberry und die Schnittstelle sind bestellt. Jetzt muss ich nur noch meine eingestaubten C++ Kenntnisse auffrischen.

Für die Daten des EnergyMeters (SMA Homemanager 2.0) habe ich zwei Möglichkeiten:

Variante 1:
Installation von smaemd. Hier werden die Werte ausgelesen und im Dateisystem gespeichert.

em-3002135xxx-p1regard em-3002135xxx-pregard
em-3002135xxx-p1surplus em-3002135xxx-pregardcounter
em-3002135xxx-p2regard em-3002135xxx-psurplus
em-3002135xxx-p2surplus em-3002135xxx-psurpluscounter
em-3002135xxx-p3regard em-status
em-3002135xxx-p3surplus


Variante 2:
In der neuesten Nightly Version hat die openWB einen Modbus Server integriert. Hier kann man die Werte ebenfalls abgreifen.
Was würdest du bevorzugen ?


Lässt du auf dem Raspberry noch weitere Auswertungen in Bezug auf die Viessmann Vitocal laufen ?