Beiträge von SolarEngel

Hallo,

Auf der Suche nach Informationen zum UVR-CAN-Bus bin ich im Internet auf einige sehr interessante
GitHub-Repositories von Matthias Hochgatterer gestossen die sich mit can, canopen und uvr1611 beschäftigten.

Das ganze Projekt ist sehr umfangreich und enthält viel Dokumentation zum CAN-Bus aber auch zur UVR1611.
Das Interesse war geweckt und nachdem ich von Go nichts verstehe, wollte ich auf jedenfall sehen was das Programm
uvrdump von meiner UVR1611 über den CAN-Bus auslesen kann. Aber wie so oft bei Linux-Systemen gibt es vorher immer was zu tun.

Das ganze ist in der Programmier-Sprache Go realisiert worden und sollte auf dem Raspberry Pi mit PICAN2 Modul laufen.

Das PiCAN 2 Aufsteckmodul für den Raspberry Pi gibts für ca. 45 EURO im Internet zu kaufen.
Das PiCAN 2 Modul besitzt zwei Schaltkreise. Zum einen den CAN-Bus-Transceiver MCP2551,
der die 12V CAN-Bus-Signale in TTL-Signale umwandelt und zum zweiten einen
MCP2515 CAN Controller der über SPI vom Raspberry Pi und dem SocketCAN Treiber angesprochen wird.

Hier mein Raspberry Pi 3 mit aufgestecktem PiCAN 2 Modul


Der SocketCAN Treiber, erscheint für die Anwendungsprogramme als can0.
Um das PICAN2 Modul auf dem Raspberry Pi 3 zum laufen zu bekommen, müssen zuerst in der Datei
mit sudo nano /boot/config.txt drei Zeilen hinzugefügt werden und dann den Raspberry Pi 3 nochmal neu booten.

dtparam=spi=on
dtoverlay=mcp2515-can0,oscillator=16000000,interrupt=25
dtoverlay=spi-bcm2835

Zum starten der CAN-Schnittstelle can0 den nachfolgenden Befehl ausführen.

sudo /sbin/ip link set can0 up type can bitrate 50000

mit dem Befehl ifconfig kann überprüft werden ob die CAN-Schnittstelle can0 korrekt gestartet worden ist.

pi@raspberrypi:~ $ ifconfig
can0: flags=193<UP,RUNNING,NOARP> mtu 16
unspec 00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00 txqueuelen 10 (UNSPEC)

Nachdem der UVR-CAN-Bus mit dem PICAN2 über CAN-H und CAN-L verbunden wurde,
habe ich mit dem Testprogramm candump, das bei PICAN2 dabei ist, probiert meinen UVR-CAN-Bus zu lesen.

i@raspberrypi:~/pican2-test/can-test_pi2 $ ./candump can0
can0 738 [1] 05
can0 738 [8] 05 8A 01 00 00 00 00 00
can0 701 [1] 05
can0 73E [1] 05
can0 4BE [8] 01 F4 4F 01 01 00 00 00
can0 4BE [8] 01 F4 4F 01 01 00 00 00
can0 4BE [8] 81 F1 4F 01 01 00 00 00
can0 481 [8] 01 F0 4F 01 04 08 03 80
can0 481 [8] 01 F0 4F 02 3F 39 41 01

can0 481 [8] 01 F0 4F 03 DC 03 41 01
...

das hat schonmal gut geklappt.. die Identifier und Daten kamen mir bekannt vor, hatte ich schon mit dem ESP32 auch so ausgelesen.

Nachdem der UVR1611-CAN-Bus gelesen werden kann, gehts weiter mit dem Go Projekt, zum eigentlichen Programm uvrdump.

Die Programmier-Sprache Go versucht, ein besseres C und eine gute Alternative zu C++ zu sein.
Der geringe Hauptspeicherbedarf von Go-Programmen und die eingebaute Parallelisierung
machen die Sprache für bestimmte Einsatzgebiete gut geeignet.
Die Eignung für massiv parallele Systeme mit vielen Prozessoren und Prozessorkernen war eines der zentralen Entwurfsziele von Go.

Vorher muss auf dem Raspberry Pi mit den nachfolgenden drei Befehlen das Go Paket installiert werden,
damit das kompilieren vom uvr-Projekt mit den can- und canopen Bibliotheken klappt.

wget https://storage.googleapis.com…1.8.3.linux-armv6l.tar.gz
sudo tar -C /usr/local -xzf go1.8.3.linux-armv6l.tar.gz
export PATH=$PATH:/usr/local/go/bin

Dann die ZIP-Dateien von den drei GitHub-Repositories von Matthias Hochgatterer aus dem Internet auf den Raspberry Pi runterladen.

GitHub - brutella/can: Connect to a CAN bus in Go
https://github.com/brutella/can

GitHub - brutella/canopen: Communicate with other CANopen nodes ...
https://github.com/brutella/canopen

GitHub - brutella/uvr: Communicate with an UVR1611 over the CAN bus
https://github.com/brutella/uvr

Dann auf dem Raspberry Pi ins Verzeichnis /usr/local/go/src wechseln
und die zwei folgenden Verzeichnisse github.com/brutella hier anlegen.

sodass es nachher so aussieht /usr/local/go/src/github.com/brutella

Dann die Verzeichnisse (can), (canopen) und (uvr) von den ausgepackten ZIP-Dateien jeweils komplett
in /usr/local/go/src/github.com/brutella in eigene Verzeichnisse kopieren.

so sollte es nachher aussehen:

/usr/local/go/src/github.com/brutella/can
/usr/local/go/src/github.com/brutella/canopen
/usr/local/go/src/github.com/brutella/uvr

dann ins Verzeichnis /usr/local/go/src/github.com/brutella/uvr wechseln und einfach make eingeben.

Damit wird mit Hilfe der Datei Makefile in diesem Verzeichnis ein Go Kompilerlauf gestartet,
der als Ergebnis eine ausführbare Datei uvrdump in diesem Verzeichnis erzeugt.

pi@raspberrypi:~/uvr $ make
GOOS=linux GOARCH=arm GOARM=7 go build cmd/uvrdump.go

Nachdem der Kompilerlauf erfolgreich war, hab ich mit dem Aufruf vom Programm uvrdump
über den UVR-CAN-Bus die Eingänge und Ausgänge von meiner UVR1611 auslesen können.

pi@raspberrypi:~/uvr $ ./uvrdump 
2018/10/20 15:21:05 uvrdump.go:90: +---------+-----------------+--------+------
2018/10/20 15:21:05 uvrdump.go:91: | Eingang | Bezeichnung     | Status | Wert
2018/10/20 15:21:05 uvrdump.go:92: +---------+-----------------+--------+------
2018/10/20 15:21:06 uvrdump.go:95: | 1       | Kollektor       | OK     | 49.3
2018/10/20 15:21:06 uvrdump.go:95: | 2       | SP.oben         | OK     | 73.4
2018/10/20 15:21:06 uvrdump.go:95: | 3       | Puffer.u        | OK     | 45.9
2018/10/20 15:21:06 uvrdump.go:95: | 4       | Puffer.o        | OK     | 31.3
2018/10/20 15:21:06 uvrdump.go:95: | 5       | Kollektor2      | OK     | 41.6
2018/10/20 15:21:06 uvrdump.go:95: | 6       | SP.unten        | OK     | 44.5
2018/10/20 15:21:06 uvrdump.go:95: | 7       | SP.mitte        | OK     | 62.9
2018/10/20 15:21:06 uvrdump.go:95: | 8       | Puffer.m2       | OK     | 59.5
2018/10/20 15:21:07 uvrdump.go:95: | 9       | Puffer.m        | OK     | 49.2
2018/10/20 15:21:07 uvrdump.go:95: | 10      | Heizkr.VL       | OK     | 33.7
2018/10/20 15:21:07 uvrdump.go:95: | 11      | Heizkr.RL       | OK     | 25.5
2018/10/20 15:21:07 uvrdump.go:95: | 12      | Temp.Aussen     | OK     | 18.1
2018/10/20 15:21:07 uvrdump.go:95: | 13      | Temp.Raum       | OK     | 23.6
2018/10/20 15:21:07 uvrdump.go:95: | 14      | Solar-VL        | OK     | 60.4
2018/10/20 15:21:07 uvrdump.go:95: | 15      | Solar-RL        | OK     | 45.7
2018/10/20 15:21:07 uvrdump.go:95: | 16      | Durchfl.Sol.    | OK     | 122.0
2018/10/20 15:21:07 uvrdump.go:97: +---------+-----------------+--------+------
2018/10/20 15:21:07 uvrdump.go:60: +---------+-----------------+--------+------+
2018/10/20 15:21:07 uvrdump.go:61: | Ausgang | Bezeichnung     | Mode   | Wert |
2018/10/20 15:21:07 uvrdump.go:62: +---------+-----------------+--------+------+
2018/10/20 15:21:08 uvrdump.go:65: | 1       | Pumpe-Solar     | AUTO   | EIN  |
2018/10/20 15:21:08 uvrdump.go:65: | 2       | Ladep.SP.       | AUTO   | AUS  |
2018/10/20 15:21:08 uvrdump.go:65: | 3       | Anf.Kessel      | AUTO   | AUS  |
2018/10/20 15:21:08 uvrdump.go:65: | 4       | Ventil          | AUTO   | AUS  |
2018/10/20 15:21:08 uvrdump.go:65: | 5       |   -----         |        | AUS  |
2018/10/20 15:21:08 uvrdump.go:65: | 6       |   -----         |        | AUS  |
2018/10/20 15:21:08 uvrdump.go:65: | 7       |   -----         |        | AUS  |
2018/10/20 15:21:09 uvrdump.go:65: | 8       | Misch.Hzkr1     | AUTO   | AUS  |
2018/10/20 15:21:09 uvrdump.go:65: | 9       |   -----         | AUTO   | AUS  |
2018/10/20 15:21:09 uvrdump.go:65: | 10      |   -----         |        | AUS  |
2018/10/20 15:21:09 uvrdump.go:65: | 11      | Vent.Solar      | AUTO   | AUS  |
2018/10/20 15:21:09 uvrdump.go:65: | 12      | Pumpe-Hzkr      | AUTO   | EIN  |
2018/10/20 15:21:09 uvrdump.go:65: | 13      |   -----         |        | AUS  |
2018/10/20 15:21:09 uvrdump.go:67: +---------+-----------------+--------+------+

Gruß
Jürgen

Hallo,

da der ESP32 im Umgang und in der Programmierung Arduino-ähnlich ist, möchte ich diesem Thread antworten.

Ich bin zur Zeit am experimentieren mit dem ESP32, der kennt laut Datenblatt auch CAN-Funtionen.
Speziell wollte ich herausfinden, ob es mit einfachen Mitteln möglich ist die Datenpakete
von meinem CAN-Bus an dem die uvr1611, cmi, bl-net und can-io dranhängen mitzulesen.

Es ist nur einen CAN-Bus-Transceiver notwendig, der die 12V CAN-Bus-Signale in die für den ESP32
notwendigen 3,3V TTL-Signale (rx und tx) umwandelt. Den Rest kann der ESP32 und ein bisschen Software.

Man merkt schon dass in den letzten Jahren die Maker-Szene grösser geworden ist. Es gibt auch dafür sehr preisgünstig Fertigmodule.
Ich habe ein Waveshare SN65HVD230 CAN Board für ca. 5,94 EURO bei Eckstein gefunden, das genau diesen Zweck erfüllt.

Die ersten Versuche wurden mit dem Logikanalyser gemacht, der kann auch CAN-Protokoll analysieren.
Hier ein Standard CAN-Datenpaket mit Checksumme am Ende. Mein UVR CAN-Bus läuft mit 50kBit/s.

erster Testaufbau auf dem Steckbrett

Ich betrachte diese Monitoringsmöglichkeit meines UVR - CAN-Bus wie ein Messgerät das die CAN-Bussignale sichtbar machen
kann, nicht mehr und nicht weniger.

Nützlich sein kann diese Information im Fehlerfall, wenn man Datenpakete von einem bestimmten Gerät
auf dem Bus vermisst und nicht genau weiss wo man suchen soll.
Interessant finde ich auch die Heartbeatmeldungen, die alle TA-Geräte in regelmässigen Abständen senden.
Da kann man sehen ob ein Gerät noch funktioniert, auch wenn keine sonstige Kommunikaton stattfindet.

Ich möchte einfach ein Gefühl dafür bekommen, ob der Bus z.B. überlastet ist. Dann könnte ich z.B. einige
Abfragen nicht so oft durchführen. Oder wenn es timeouts geben sollte, dann könnte ich sehen
welche Geräte besonders aktiv auf dem CAN-Bus sind und dann besser rausfinden warum.. usw..

Jedes CAN-Datenpaket hat am Anfang einen Identifier, der sagt ganz grob aus, von welchem Gerät zu welchem Zweck
die Daten kommen.

In einer CANOPEN-Beschreibung habe ich eine soche CAN-Identifier-Zurodnungsmöglichkeit gefunden..

Identifierzuordnung
----------------------------------------------------------->gefundene Identifiers in meinen CAN-Busdaten
180 + NID TPDO1 Netzwerkvariable Digital 1....16 -->01BE=BL-NET, 01A0=CAN-IO
200 + NID TPDO2 Analog 1.....4 ---------------------->023E=BL-NET
280 + NID TPDO3 Analog 5.....8 ---------------------->02BE=BL-NET
300 + NID TPDO4 Analog 9....12 ---------------------->033E=BL-NET
380 + NID TPDO5 Analog 13...16 --------------------->03BE=BL-NET
400 + NID MPDO6 Client - Server Adressierung
480 + NID MPDO7 Datenlogging --------------------->0481=UVR, 04BE=BL-NET, 04A6=CMI
580 + NIDS SSDO1 Server -> Client
5C0 + NIDC SSDO2....SSDO63 Server -> Client ---->05F8=CMI
600 + NIDS SSDO1 Client -> Server
640 + NIDC SSDO2....SSDO63 Client -> Server ---->0678=CMI
700 + NID Heartbeat ---------------------------------->0701=UVR, 073E=BL-NET, 0738=CMI, 0720=CAN-IO

NID ..... Knotennummer ( 1....62)
NIDS…. Knotennummer Server
NIDC.... Knotennummer Client

Meine Geräte die am CAN-Bus hängen und deren Knoten-Nr in hex, um den Identifier zu berechnen.
knoten 56 = CMI hex 38
Knoten 1 = UVR1611 hex 01
Knoten 32 = CAN-IO hex 20
Knoten 62 = BL-NET hex 3E

Beispiel um den CAN-Idendifier vom Heartbeat-Paket der UVR1611 zu Berechnen: 0700hex + 01hex = 0701hex = Heartbeat-id von der UVR1611

Hier ein Auszug vom Mitschnitt meiner CAN-Bus Daten von dem ESP32-Programm,
damit man sieht, wie CAN-Datenpakete von den einzelnen Geräten beispielhaft identifiziert werden können.

---------------------------->CAN-Identifier
New standard frame from 0x00000720, DLC 1, Data 0x05 --> Heartbeat-Paket von CAN-IO
New standard frame from 0x0000073E, DLC 1, Data 0x05 --> Heartbeat-Paket von BL-NET
New standard frame from 0x00000701, DLC 1, Data 0x05 --> Heartbeat-Paket von UVR1611
New standard frame from 0x000004BE, DLC 8, Data 0x01 0xF4 0x4F 0x01 0x01 0x00 0x00 0x00 --> Datenlogging BL-NET
New standard frame from 0x000004BE, DLC 8, Data 0x81 0xF1 0x4F 0x01 0x01 0x00 0x00 0x00
New standard frame from 0x00000481, DLC 8, Data 0x01 0xF0 0x4F 0x01 0x01 0x00 0x03 0x80 --> Datenlogging UVR1611
New standard frame from 0x00000481, DLC 8, Data 0x01 0xF0 0x4F 0x02 0x3A 0x02 0x41 0x01
New standard frame from 0x00000481, DLC 8, Data 0x01 0xF0 0x4F 0x03 0xFC 0x02 0x41 0x01
New standard frame from 0x00000481, DLC 8, Data 0x01 0xF0 0x4F 0x04 0x9E 0x02 0x41 0x01
New standard frame from 0x00000481, DLC 8, Data 0x01 0xF0 0x4F 0x05 0x29 0x02 0x41 0x01
New standard frame from 0x00000481, DLC 8, Data 0x01 0xF0 0x4F 0x06 0xF3 0x01 0x41 0x01
New standard frame from 0x00000481, DLC 8, Data 0x01 0xF0 0x4F 0x07 0x88 0x01 0x41 0x01
New standard frame from 0x00000481, DLC 8, Data 0x01 0xF0 0x4F 0x08 0x44 0x02 0x41 0x01
New standard frame from 0x00000481, DLC 8, Data 0x01 0xF0 0x4F 0x09 0xC6 0x01 0x41 0x01
New standard frame from 0x00000481, DLC 8, Data 0x01 0xF0 0x4F 0x0A 0x34 0x02 0x41 0x01
New standard frame from 0x00000481, DLC 8, Data 0x01 0xF0 0x4F 0x0B 0x25 0x01 0x41 0x01
New standard frame from 0x00000481, DLC 8, Data 0x01 0xF0 0x4F 0x0C 0x1F 0x01 0x41 0x01
New standard frame from 0x00000481, DLC 8, Data 0x01 0xF0 0x4F 0x0D 0x23 0x01 0x41 0x01
New standard frame from 0x00000481, DLC 8, Data 0x01 0xF0 0x4F 0x0E 0x0A 0x01 0x41 0x01
New standard frame from 0x00000481, DLC 8, Data 0x01 0xF0 0x4F 0x0F 0xAB 0x02 0x41 0x01
New standard frame from 0x00000481, DLC 8, Data 0x01 0xF0 0x4F 0x10 0x27 0x02 0x41 0x01
New standard frame from 0x00000481, DLC 8, Data 0x01 0xF0 0x4F 0x11 0x79 0x00 0x40 0x03
New standard frame from 0x00000481, DLC 8, Data 0x01 0xF0 0x4F 0x12 0x0F 0x00 0x80 0x80
New standard frame from 0x00000481, DLC 8, Data 0x01 0xF0 0x4F 0x13 0x32 0x12 0x00 0x00
New standard frame from 0x00000481, DLC 8, Data 0x01 0xF0 0x4F 0x14 0xA8 0x17 0x1C 0x00
New standard frame from 0x00000481, DLC 8, Data 0x01 0xF0 0x4F 0x15 0x00 0x00 0x00 0x00
New standard frame from 0x00000481, DLC 8, Data 0x01 0xF0 0x4F 0x16 0xAA 0x0C 0x5C 0x00
New standard frame from 0x000004BE, DLC 8, Data 0x81 0xF3 0x4F 0x01 0x01 0x00 0x00 0x00 --> Datenlogging BL-NET
New standard frame from 0x000004BE, DLC 8, Data 0x01 0xF4 0x4F 0x01 0x01 0x00 0x00 0x00
New standard frame from 0x000004BE, DLC 8, Data 0x81 0xF1 0x4F 0x01 0x02 0x00 0x00 0x00
New standard frame from 0x00000738, DLC 1, Data 0x05 --> Heartbeat-Paket von CMI
New standard frame from 0x00000678, DLC 8, Data 0x40 0x05 0x58 0x00 0x00 0x00 0x00 0x00 --> Client -> Server CMI
New standard frame from 0x000005F8, DLC 8, Data 0x40 0x05 0x58 0x00 0x00 0x00 0x00 0x00 --> Server -> Client CMI
New standard frame from 0x00000678, DLC 8, Data 0x60 0x00 0x00 0x00 0x00 0x00 0x00 0x00
New standard frame from 0x000005F8, DLC 8, Data 0x00 0xC2 0xC6 0x07 0x45 0x49 0x4E 0x47
New standard frame from 0x00000678, DLC 8, Data 0x70 0x00 0x00 0x00 0x00 0x00 0x00 0x00
New standard frame from 0x000005F8, DLC 8, Data 0x10 0x41 0x45 0x4E 0x47 0x45 0xC5 0xC3
New standard frame from 0x00000678, DLC 8, Data 0x60 0x00 0x00 0x00 0x00 0x00 0x00 0x00
New standard frame from 0x0000023E, DLC 8, Data 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF --> Analog 1.....4 von BL-NET
New standard frame from 0x000003BE, DLC 8, Data 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF --> Analog 13...16 von BL-NET
New standard frame from 0x0000033E, DLC 8, Data 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF --> Analog 9....12 von BL-NET
New standard frame from 0x000002BE, DLC 8, Data 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF --> Analog 5.....8 von BL-NET
New standard frame from 0x000001A0, DLC 2, Data 0x00 0x00 --> Netzwerkvariable Digital 1....16 von CAN-IO
New standard frame from 0x000001BE, DLC 2, Data 0xFF 0xFF --> Netzwerkvariable Digital 1....16 von BL-NET

Es ist nicht meine Absicht, den CAN-Bus und die Datepakete aller angeschlossenen Geräte zu dekodieren
und irgendwelche externe Steuerungsmöglichkeiten zu schaffen. Dazu fehlen mir die Kenntnisse und Fähigkeiten
und vor allem die notwendige Zeit. Ich habe auch nirgends eine Beschreibung des CAN-Protokolls der Geräte von TA gelesen.

Das Programm ist sehr einfach und die Ausgabe erfolgt auf dem seriellen Monitor.
Wenn man Arduinos programmieren kann, dann ist die Umstellung auf den ESP32 unproblematisch.
Der Link zum runterladen der notwendigen ESP32CAN-Biliothek steht im Source-Code.
Diese wird in der Programmier-IDE (version Arduino 1.8.6) im Menüpunkt SKETCH-Bibliothek einbinden-.zip-Bibliothek hinzufügen, den Programmen zugeordnet.

In der Datei CAN_config.h in der ESP32CAN-Biliothek musste eine neue Zeile CAN_SPEED_50KBPS für die fehlende CAN-Busgeschwindigkeit
hinzugefügt werden, damit auch 50kBit/s CAN-Bus gelesen werden kann.

hier der Auszug von der Datei, in der geändert werden muss:
....
/** \brief CAN Node Bus speed */
typedef enum {
CAN_SPEED_50KBPS = 50, /**< \brief CAN Node runs at 50kBit/s. */ /**--> diese Zeile muss hinzugefügt werden */
CAN_SPEED_100KBPS = 100, /**< \brief CAN Node runs at 100kBit/s. */
CAN_SPEED_125KBPS = 125, /**< \brief CAN Node runs at 125kBit/s. */
...
CAN_SPEED_1000KBPS = 1000 /**< \brief CAN Node runs at 1000kBit/s. */
} CAN_speed_t;
....

Die angehängte .ZIP Datei mit einem UNZIPPER Programm entzippen. Dann die INO-Datei mit der Arduino IDE einlesen, kompilieren und auf den ESP32 hochladen.

Gruß
Jürgen

Hallo Andreas,

freut mich dass es wieder einer geschafft hat die Brennerdaten auszulesen und weiterzuverarbeiten im SmartHome.
Ich habe leider nicht die neue Hardware und kann somit deine Signale im Original nicht messen mit dem Logikanalyser
und auch nicht auslesen und näher analysieren.. schade.

Die Sternchen sind in der zweiten, unteren LCD-Zeile, sollten also vorhanden sein, wenn alle 68 Halbbytes eingelesen und dekodiert werden.

Jede der zwei LCD-Zeilen hat als Ergebnis in der Ausgabe 16 Zeichen+1 nicht sichtbares Steuerbyte am Anfang.

Das LCD-Display im A25-Brenner arbeitet ganz normal wie die meisten LCD-Anzeigen im 4-Bit Mode,
also mit 4 Datenleitungen D4,D5,D6,D7 laut Datenblatt. Jede der 4 Datenleitungen entspricht einem Bit.
Um ein Byte (8Bit) zum Display zu bringen werden 2 Bytes mit jeweils 4Bit Inhalt hintereinander übertragen.
Der HD44780 Controller im LCD-Display setzt diese beiden Bytes wieder intern zusammen und bringt sie zur Anzeige.

Beim Auslesen (mitlesen) muss ich das selber im Programm machen, genauso wie der HD44780 Controller im LCD-Display.
Das ist die Idee die dahintersteckt. Ich mach in meinem Arduino/ESP32-Programm das gleiche wie der HD44780 Controller im LCD-Display
und gebe als Ergebnis ein darstellbares Ascii-Zeichen aus.
Die 2 * 4Bits die hintereinander kommen in ein Byte mit 8bit zusammenbauen, deshalb spreche ich von Halbbytes.
Die Übertragung einer LCD-Zeile erfolgt mit 34 Halbbytes und (2 * 34 Halbbytes = 2 LCD-Zeilen).
Zu Beginn jeder der zwei LCD-Zeilen gibt es ein Steuerzeichen (siehe Beitrag # 16062).
Die überlese ich in der Ausgabe-Schleife absichtlich, weil es nicht darstellbare Ascii-Zeichen sind.
Solche Steuerzeichen werden mit den Filtern zu SPACE (32) umdefiniert.

Bei mir geht ein Ascii-Zeichen bei der MQTT-Übertragung verloren, das Grad-Zeichen hinter dem C.
Denn in einer Serial.println-Ausgabe im Seriellen Monitor vor der MQTT-Übertragung im ESP32 ist es noch da und später,
beim einlesen (Subsriben) vom Message-Broker mit Node-RED oder einem anderen Programm nicht mehr.
Aber das ist ein Schönheitsfehler, den nehme ich in Kauf.
Ich hatte noch keine Lust mich mit den möglichen verschiedenen Code-Pages zu beschäftigen die in den verschiedenen
Systemen zusammenspielen.

Gruß
Jürgen

Hallo Volker,

spannendes Thema, CAN-Bus Funkübertragung, interessiert mich auch.
Bitte teile deine Erfahrungen und Forschungsergebnisse mit uns.

Gruß
Jürgen

Hallo,

die Daten auf meinem drahtlosen Bussystem mit MQTT laufen wie alle IoT-Daten im Hintergrund und unsichtbar, permanent 24/7 im WLAN und stehen allen MQTT-fähigen Programmen
zur Kommunikation und Steuerung zur Verfügung.

Ich war nach vielem Suchen und Anschauen einiger YouTube-Videos sehr begeistert, eine einfache Visualisierung für meine MQTT-Daten gefunden zu haben.
Node-RED, ein Tool von IBM entwickelt, ist Open-Source-Software mit einem grafischer Editor als Herzstück. Damit geht Programmieren sehr flink.
Die Programmierung von Node-RED erfordert keine Kenntnisse einer Progammiersprache.

Hört sich komisch an, aber mit nur wenigen Klicks hatte ich ein einfaches, textbasiertes, aber voll funktionsfähiges Dashboard fertig und konnte gleich
am A25-Brenner mit der Fernsteuerung rumspielen und Parameter im A25-Brenner ändern.
Das ganze läuft im Browser und kann somit vom PC, Tablet oder Handy sofort und überall im WLAN genutzt werden.

Der Abstraktionsgrad ist vergleichbar so wie bei TAPPs, mit der eine UVR-Steuerung grafisch programmiert werden kann.

Man zieht sich grafisch aus einer Bibliothek vordefinierte Funktionsbausteine in ein Fenster.
Zieht mit der Maus von einem zum anderen Funktionsbaustein Verbindungen, wie so Fäden.
Parametrisiert die einzelnen Funktionsbausteine und fertig ist das einfache Dashboard mit Text-Zeilen Ausgabe und Push-Buttons für die Fernbedienung.

Auf dem Raspberry Pi 3 ist das Tool standadmässig bei der aktuellen Version "Jessie dabei. Es muss nur noch das notwendige Dashboard nachinstalliert werden.
Dafür gibts einige Videos und Anleitungen im Internet.

Zur Definition wird im ersten Browser-Fenster mit der URL http://ipadresse_wo_node-red_läuft:1880 der Node-RED Grafik-Editor angezeigt.
Hier am Beispiel ist MQTT auf der Seite FLOW1 ein MQTT-Funktionsbaustein mehrfach, für jedes MQTT-token, als input ins Fenster reingezogen worden.
Dann jeweils mit einem TEXT-Funktionsbaustein für die Ausgabe-Anzeige verbunden und parametrisiert.

Auf der rechten Seite ist noch ein Debug-Fenster. Hier lasse ich mir alle tokens (#) anzeigen, wie im ersten Knoten definiert.

Für die Fernsteuerung ist auf der Seite Flow2 ein Button-Funktionsbaustein, für jedes Fersteuerungs-Kommando, als input ins Fenster reingezogen worden.
Dann jeweils mit einem MQTT-Funktionsbaustein für die Ausgabe verbunden und parametrisiert.

Als Ergebnis wird im zweiten Browser-Fenster mit der URL http://ipadresse_wo_node-red_läuft:1880/ui das fertige Node-RED Dashboard angezeigt.

Hier das einfache Node-RED Dashboard auf dem Tablet.

Gruß
Jürgen

Hallo Jan,

bei meinem A25 Brenner AC07 version 0.18 (Baujahr vor 2012, altes Modell)
hab ich die beiden genannten Werte S10X und S10Y noch in keinem der Menüs oder Parameter gesehen.
Mein A25-Datenlogger kann alles auslesen, was an der LCD-Anzeige angezeigt wird. Mehr leider nicht.

Gruß
Jürgen

Hallo,

der hier verwendete ESP32 ist sehr preiswert, klein, stromsparend und deutlich leistungsfähiger als ein Arduino und hat zwei Rechenkerne und Wlan und noch vieles andere
und verfügt vergleichsweise über einen einen riesigen Speicher. Wenn man Arduinos programmieren kann, dann ist die Umstellung auf den ESP32 unproblematisch.

Mein selbstgebauter Tropföler läuft schon über ein Jahr problemlos und ist auch nach der Sommerpause ohne Verstopfung wieder in Betrieb gegangen.

Um die seriellen A25 Brennerdaten zu lesen, läuft der ESP32 hier im SPI-Slave Modus. Der Link zum runterladen der notwendigen SPI-Slave-Biliothek steht im Source-Code.
Diese wird in der Programmier-IDE (version Arduino 1.8.6) im Menüpunkt SKETCH-Bibliothek einbinden-.zip-Bibliothek hinzufügen, den Programmen zugeordnet.
Ich habe lange gesucht und experimentiert um den ESP32 im SPI-Slave Mode zum laufen zu bringen, denn die dafür notwendigen Kenntnisse um so eine Bibliothek selber
zu schreiben übersteigen meine Fähigkeiten und die dafür notwendige Zeit. Um nicht allzuoft neben dem Brenner zum basteln und programmieren
im Heizraum zu hocken, hab ich zum Testen einen Generator (SPI-Master) mit A25 Signalen und ein Fernsteuerungsprogramm (MQTT) für einen zweiten ESP32 gebaut.

Damit das Timimg der SPI-Signale anschaulicher wird, habe ich 2 Bytes mit dem Logikanalyser näher gezoomt.
Man sieht der SPI-Clock läuft mit 200Khz und ein Byte braucht ca. 120us.

Auf der mitgeloggten Zeitachse von 2 LCD-Zeilen sieht man dass zwischen den Zeilen (nach 2*34Bytes)
jeweils eine Pause von 92ms vor Beginn der neuen LCD-Zeile eingebaut ist. Diese Info ist notwendig, wenn man einen A25-Testgenerator bauen will.

Time (s), Analyzer Name, Decoded Protocol Result
0.041488500000000,SPI,MOSI: '0' (0x00); MISO: '0' (0x00)
0.041608375000000,SPI,MOSI: '0' (0x00); MISO: '148' (0x94)
0.041728312500000,SPI,MOSI: '0' (0x00); MISO: '128' (0x80)
0.041848125000000,SPI,MOSI: '0' (0x00); MISO: '140' (0x8C)
...
0.045204437500000,SPI,MOSI: '0' (0x00); MISO: '136' (0x88)
0.045324312500000,SPI,MOSI: '0' (0x00); MISO: '128' (0x80) Ende 1. LCD-Zeile
0.045444125000000,SPI,MOSI: '0' (0x00); MISO: '6' (0x06)
0.045564000000000,SPI,MOSI: '0' (0x00); MISO: '0' (0x00)
0.045683875000000,SPI,MOSI: '0' (0x00); MISO: '136' (0x88)
0.045803687500000,SPI,MOSI: '0' (0x00); MISO: '128' (0x80)
0.045923562500000,SPI,MOSI: '0' (0x00); MISO: '136' (0x88)
...
0.049279687500000,SPI,MOSI: '0' (0x00); MISO: '136' (0x88)
0.049399437500000,SPI,MOSI: '0' (0x00); MISO: '128' (0x80) Ende 2. LCD-Zeile
0.141642750000000,SPI,MOSI: '0' (0x00); MISO: '2' (0x02) Beginn neue LCD-Zeile
0.141748437500000,SPI,MOSI: '0' (0x00); MISO: '0' (0x00)

Die Signaldekodierung habe ich schon in den vorherigen Arduino-Projekten beschrieben. Diese wurde auch hier wieder so übernommen, also wiederverwendet.
Erweiterung wie das Schalten eines zusätzlichen Ausgangs GPIO27 für Relais Tropföler und ein paar zusätzliche timer.
Dann das MQTT-Senden zur Weitergabe der Brennerdaten über WLAN an den MQTT-Broker und der gibt dann weiter an FHEM oder Node-RED(testweise) oder OpenHAB(testweise) oder Handy oder Tablet
oder an sonstige Programme mit MQTT-Schnittstelle.
Dann MQTT-Empfang zum Empfangen der Fernsteuerbefehle über WLAN vom MQTT-Broker.
Der bekommt die Fernsteuerbefehle von einem Programm mit MQTT-Schnittstelle. In meinem Fall von einem zweiten ESP32 mit MQTT-Fernsteuer-Programm.
Das kann aber auch von FHEM oder Node-RED oder OpenHAB oder Handy oder Tablet sein.

Ich habe mir im Haus inzwischen ein drahtloses Bussystem mit MQTT aufgebaut. Alle an diesem Bus (MQTT-Broker) angemeldeten Geräte können Daten senden (publish) und empfangen (subscribe).
Und das tolle daran, alles gleichzeitig und auch jeder von jedem. Das eröffnet natürlich ungeahnte Möglichkeiten der Steuerung und Kommunikation untereinander.
Bei mir hängen zur Zeit am MQTT-Bus der Lambda-Check, UVR-1611, Friwa, A25-Brenner,Tropföler, SMA-Wechselrichter, FHEM meine SmarthomeSoftware, Homematic-Zentrale,
Datensammler Cubitruck (noch ein paar andere Geräte die ich aus Sicherheitsgründen nicht nennen mag) ein Tablet zur Anzeige
und jederzeit zuschaltbar ein paar Raspis, ESP32 und Notebook. Vorraussetzung zur Teilnahme am Bussystem ist MQTT-Senden und MQTT-Empfangen können.
Alle Geräte die das nicht können aber interessante oder wichtige Daten zur Verfügung stellen könnten oder steuerbar gemacht werden könnten,
werden dann so nach und nach mit ESP32, ESP8266 oder Raspi MQTT-fähig gemacht und an den MQTT Bus angeschlossen.

Der erste Schaltungsentwurf auf dem Steckbrett und mit einem zweiten ESP32 als A25 Simulator (Signalgenerator) und dem Logikananlyser zum Messen sieht so aus:
Damit kann man sehr leicht und ohne zu löten eine Schaltung aufbauen, damit experimentieren, optimieren und Fehler suchen.

Ein übersichtlicher Schaltungsaufbau mit einem Fritzing Board.

Die Schaltung ist relativ einfach und deshalb auch auf einer Lochrasterplatine etwas aufgeräumt aufgebaut und in einem Gehäuse untergebracht.
Alle Komponenten, das ESP32-Modul und das 5V-Relaismodul und ein 10poliger Dip-Schalter sind steckbar, bis auf die Widerstände und Transistoren.
Die gehen auch nicht kaputt. Mit dem Dip-Schalter kann ich bei Bedarf jede Verbindungsleitung, auch 5V, 12V und Masse, von der Platine zum A25-Brenner einzeln abtrennen.
An den wichtigen Schnittstellen sind zusätzliche Buchsenleisten dazugebaut, sodaß ich mit kurzen Messstrippen wie auf dem Steckbrett an alle Signale zum Messen rankomme.

Ich bin nach wie vor von den individuellen Möglichkeiten des Selbstbauens mit überschaubarem Aufwand und Zeit fasziniert,
denn sowas kann man sich nicht grad so kaufen, aber nachbauen sehr wohl.

Im Anhang sind 3 gezippte INO Programm-Dateien für den ESP32.

1. ESP32_MQTT_A25_SPI_SLAVE.ZIP ESP32 A25-Wlan_MQTT-Datenlogger_mit_Tropföler-Steuerung (mit A25H MQTT token)
2. ESP32_A25_SPI_MASTER.ZIP ESP32 Test-Generator (A25-Simulaton) mit Daten einer kompletten Info-Sequenz
3. ESP32_MQTT_A25_REMOTE.ZIP ESP32 Fernsteuerungs-Programm , um mit MQTT-Messages am A25 Brenner die 4-Tasten über Wlan zu steuern (mit A25c MQTT token)

Die 3 angehängten .ZIP Dateien mit einem UNZIPPER Programm entpacken. Dann die INO-Dateien mit der Arduino IDE einlesen,kompilieren und auf den ESP32 hochladen.

Gruß
Jürgen

[xattach=19398]ESP32 A25-Wlan_MQTT-Datenlogger[/xattach]
[xattach=19357]ESP32 Test-Generator[/xattach]
[xattach=19358]ESP32 Fernsteuerungs-Programm[/xattach]

Hallo,

zur neuen Heizsaison habe ich für meinen A25 Brenner (Baujahr vor 2012, altes Modell) ein neues Wlan-Steckmodul mit Tropfölersteuerung gebaut.
Es ersetzt den Arduino und den Raspi im Heizraum. Da der Stromverbrauch vom ESP32 und dem Mikromagentventi sehr gering ist, habe ich die
Stromversorgung 5V und 12V vom A25-Brenner mitverwendet. Das Wlan-Steckmodul liest wie bisher auch die A25-Brennerdaten zeilenweise aus und drückt dazu
ferngesteuert über Transistor-Schalter die entsprechenden der 4 Tasten vom A25-Brenner in einer festgelegten Reihenfolge sehr schnell (programmierte Tastensequenz)
und gibt sie bei mir über Wlan zeilenweise an den MQTT Mosquitto Message-Broker weiter.

Das Wlan-Modul basiert auf dem ESP32 DEVKITV1, das genauso wie der Aduino und mit der gleichen IDE programmiert wird.
Auf der Lochrasterplatine befindet sich auch ein 5V Releais zur Ansteuerung des Tropfölers.

Das Modul wird direkt ohne Kabel in die 14 polige J3-DISPLAY Steckerleiste reingesteckt.
Direkt daneben links, ein 12V Anschluss, der über Relais geschaltet, das 12V Mikromagentventil ein- und ausschaltet.

Der selbstgebaute Tropföler besteht aus einem 12V Mikromagnetventil, einer SpritzFlasche einem Messingrohr und einem Aquariumschlauch.
Die Teile ausser dem Magnetventil gibts alle für ein paar Euro im Baumarkt. Das 12V Mikromagnetventil gabs für 3 Euro bei Pollin.
Das ESP32 DEVKITV1 gibts für unter 10 Euro bei Reichelt oder Pollin. Das 5Volt-Relaismodul (KY-019) gibts für 3,50 Euro bei Reichelt.
Widerstände und 4 NPN-Transistoren hat man in der Bastelkiste. Durch den Selbstbau und das Vorhandensein aktueller A25-Brennerdaten,
kann ich den Tropföler (Relais) so programmieren, dass er nur dann angesteuert wird, wenn der Brenner tatsächlich läuft.
Die zwei Zeiten, wann, immer nach ein paar Minuten und wie lange, ein paar Sekunden, sind somit individuell einstellbar.

Das Messingrohr ist mit 3 Kabelbindern am Schneckenrohr aussen fixiert und steht innen im Behälter am Ende an der Schneckenöffnung ca. 1cm drüberhinaus,
damit das öl sich gut an der Schneckenöffnung auf die Pellets verteilen kann.
Den Aquariumschlauch habe ich einfach ein Stück in das Messingrohr reingeschoben.

Gruß
Jürgen

Hallo Martin,

wenn du selber das Hydraulikschema ausgedacht hast und mit Tapps 2 gezeichnet hast
und dir vor deinem geistigen Auge die einzelnen Kreisläufe ablaufen lassen kannst,
dann würde ich an deiner Stelle auf jedenfall weitermachen und den nächsten Schritt in Angriff nehmen.
Genauso wie im Hydraulikschema wird das UVR Programm aus einzelnen Komponenten zusammengebaut.

Ich kann mir nicht vorstellen, dass du mit externer Programmierung zufrieden sein wirst.
Früher oder später wirst da selber ran wollen und kleine Änderungen oder Erweiterungen vornehmen wollen.
Warum nicht gleich ...

Es ist kein UVR Programmierer vom Himmel gefallen. Alle haben sich das mit mehr oder
weniger Aufwand selber beigebracht.

Ich selber hab vor 10 Jahren eine intensive Analyse in vielen Heizungsforen betrieben und mich als Laie
ca. 1 Jahr mit nächtelangem Lesen und Verstehen beschäftigt. Erst dann konnte ein Konzept erstellt werden.
Und erst dann die Entscheidung 'make or buy' getroffen werden.
Aber das Konzept der UVR und die vielen Beispiele hatten mich damals sehr motiviert
schrittweise beginnend mit der Solaranlage die ganze Sache in Angriff zu nehmen.
Allerdings hatte ich mir damals 2 UVR's zugelegt. Eine zum Programmieren und Testen mit Simulationsbox
und eine zweite für das produktive System, das ja ungestört und möglichst fehlerfrei immer laufen muss.

Heute braucht man kein zweites System zum Testen, denn es gibt einen Simulator, mit dem
man die Programme austesten kann.

Es gibt hier im Forum viele User die diesen Schritt gewagt und ganz sicher nicht bereut haben.

Ich betrachte diese Forum auch als Innovationszentrum, denn es gibt hier sehr viel unterschiedliches
verteiltes Wissen. Und wenn damit wertschätzend umgegangen wird,
dann wird einem ganz bestimmt auch von vielen geholfen.

Gruß
Jürgen

Hallo Lex,

ein externes Schichtladerohr kann auch selber gebaut werden..

Für meine Solaranlage 2*10m2 mit 2*1000 Liter Pufferspeicher in Reihe geschaltet habe
ich zwei externe Schichtladerohre mit Kupferrohren und Winkeln selber zusammengelötet.

Das erste zum Einschichten der Solarwärme am ersten Pufferspeicher
und das zweite zum Einschichten des Heizungsrücklaufs im zweiten
Pufferspeicher, so wie du das ungefähr auch vor hast.

Gruß
Jürgen

Hallo revox76,

ich betreibe seit 2010 eine 20m2 Ost/West Anlage mit Heatpipe-Vakuumröhren und trockener Anbindung an den Sammler.
Hydraulisch sind alle 4 Module (1 Modul mit 30 Röhren und Spiegel auf der Unterseite = 5m2) in Reihe geschaltet.
10m2 auf der Ostseite und 10m2 auf der Westseite. Die möglichen Verluste durch diese Reihenschaltung sind für mich vernachlässigbar.
Für die Steuerung und Drehzahlregelung der Solarpumpe gibt es bei mir nur eine Kollektortemperatur, also wie wenn nur ein Modul da wäre.
Das vereinfacht die SolarSteuerung sehr. Gebildet wird diese eine Kollekortemperatur bei meiner UVR1611 mit einer Max-Funktion
aus den beiden Ost- und West Kollektor-Temperatur-Werten.

Es gibt auch noch eine Min-Funktion, gebildet aus den gleichen beiden Ost- und West Kollektor-Temperatur-Werten für die Frostschutzfunktion.
Zur Ansteuerung der Solarpumpe von der Frostschutzfunktion verwende ich ein WW-Anforderungsmodul.
Du musst die Frostschutzfunktion autark betrachten (Sicherheitsaspekt).
Die Solarpumpe kann somit von der Sonne oder von der Frostschutzfunktion (WW-Anforderung) angesteuert werden.
Völlig unabhängig. Das ist wichtig, damit die notwendige Sicherheit für den Frostschutz gewährleisten kannst.

Bei mir läuft das seit 2010 fehlerfrei. Immer wenn die Min-Funktion unter 4 Grad meldet, dann springt der Frostschutz an.
Dieser schaltet noch zusätzlich zur Solarpumpe mit einem Zonenventil den Solarkreis nach unten im Speicher um,
damit für den Frostschutz das kälteste Wasser vom Speicher verwendet wird und die aufgewendete Wärme dafür so gering wie möglich ist
und meine Schichtung nicht beeinflusst wird.
Bis jetzt hatte ich noch keinen Stromausfall im Winter. Aber wenn ich das auch noch absichern müsste,
dann würde ich die UVR1611 an eine USV hängen und mich per Smarthome aufs Handy alarmieren lassen.

Min-Funktion für Frostschutz aus den beiden Ost- und West Kollektor-Temperatur-Werten und WW-Anforderung

WW-Anforderungsmodul mit den entsprechenden Einstellungen

Frostschutz ist heute Nacht 3 mal angesprungen

Gruß
Jürgen

Hallo Jörg,

die Überprüfung der Röhren würde ich auch mit einer Wärmebildkamera machen, falls sowas vorhanden wäre.
Meine Anlage läuft auch schon seit 2010 und bis jetzt ist nur eine von 120 Röhren kaputt (kein Vakuum mehr).

In deinem Hydraulikplan sind ja durch Umschalten mit 5MG von Esbe mehrere Zonen im 4850 l Puffer zur
solaren Einspeisung vorgesehen.

Und mit der UVR1611 zur Steurung der Solaranlage bist ja wie man so sagt hardwaremässig gut ausgestattet.
Interessant wäre jetzt noch zu erfahren wie die Solarsteuerung mit der 1611 Programmierung umgesetzt wurde.

Es gibt da bestimmt viele unterschiedliche Varianten der Umsetzung bei jedem UVR1611 User.
Daten der Anlage hast bestimmt auch mitgeloggt. Die sind für Analysen immer hilfreich.

Vielleicht kannst erläutern wie deine Solarsteuerung programmtechnisch funktioniert.
Welche Module verwendet worden sind. Sind die Pumpen drehzahlgesteuert usw..
Wie sind die Temperaturschwellwerte bei denen die Pumpen ein- und ausgeschaltet werden.

Mit welchen Bedingungen werden die 4 Zonen zur Einschichtung umgeschaltet. In welchem Temperaturbereich arbeitet
der Solarkreislauf primär und auf der anderen Seite der Trennstation. Weche Strategien verfolgst du High-Flow
mit maximalen Erträgen oder Low-Flow mit höheren Temperaturen und kleineren Volumenströmen usw..

Ich bin der Meinung in der Anlagensteuerung steckt auch viel Optimierungspotential drin.
Aber mit der UVR1611 bist ja sehr flexibel was Programmierung anbelangt.

Gruß
Jürgen

Hallo Jörg,

ich habe 2*10m2 Ost-West RK mit 50° Dachneigung und teilweise Verschattung.
Also nicht die allerbeste Lage und keine Südseite für ST. Im letzten Jahr waren es 3850 kWh.

Hab etwas gegoogelt wegen der Solaren Trennstation von KAMO.
Ist das eine KaMo Solar X mini: bis 15 m² Kollektorfläche ?
Die hat eine eigene Steuerung für die zwei Pumpen.

Kannst du erklären wie diese Solare Trennstation funktioniert,
wie die angesteuert wird, welche Temperaturen und Schwellwerte
da zusammenarbeiten ?

Wie erkennst du und wie beseitigst im solaren Kreislauf Luftprobleme ?
Wie lange ist die Solarleitung?

Du hast ja eine UVR1611 zum steuern der Anlage. Wie funktioniert das Zusammenspiel
mit der Steuerung der solaren Trennstation?

Ich kann mir fast nicht vorstellen, dass die Röhren so schlecht sind,
dafür muss es andere Gründe geben für die geringe Leistung.

Gruß
Jürgen

Hier die Messwerte von 01/2018:

Meßbescheinigung:

Gruß
Jürgen

Hallo,

habe diese Woche wieder nach ein paar Jahren erfolgreich die Messung für Stufe 1 bestanden.

Allerdings unter erschwerten Bedingungen. Wir haben einen neuen Schorni bekommen
und der wollte unbedingt vor der Messung noch das Kamin und auch das kurze Zwischenstück
am Kesselausgang in der Nähe der Meßstelle fegen...

Dann hat die ganze Messung anschliessend mit dem Aufheizen des Kessels begonnen..
Was solls.. aufregen hilft nix.. aber die Messwerte waren trotzdem traumhaft.

Feinstaub 0,01 g/m3 OHNE Partikelfilter, Grenzwert 0,06 g/m3
CO 0,1 g/m3 Grenzwert 0,8 g/m3
Sauerstoff 8,9 %
Kaminzug -13 Pa mit Zugregler
Abgastemp. 135 Grd Cel.

Mein ATMOS D15P hat auch die Stufe 2 erfüllt, obwohl er es nicht bräuchte.

3 Dinge habe ich erfolgreich versucht vorher zu optimieren:
- Einbau von 3 Abgasbremsen vom D20P, das hat den Kaminzug von -18Pa auf -13Pa reduziert
und die Abgastemp. 20-30 Grad runtergenommen.
- Verbrennung (Restsauerstoff mit LC und Luftklappe auf 4-7 % eingestellt).
- Tropföler vor Pelletschnecke eingebaut, alle 2 Min. für 2 Sek. ein paar Tropfen Sonnenblumenöl,
dadurch kein Staub in der Pelletschnecke sichtbar

Meine eigenen Smarthome-Daten vom Schorni-Termin von 08:12-8:55 Uhr.

LC-Daten: Restsauerstoff sieht sehr gut aus.. nur ein kleiner Ausreisser.
Abgastemperatur ist während der Messung noch ansteigend.

Laddomat-Daten: Nur durch Kesselvorwärmung ist die Kesseltemperatur sofort über 80Grad angestiegen

Kessel-Daten: Die Wärmeabgabe in den Puffer ist während der Messung weit unter dem Normalwert.
Der Peak am Anfang ist negative Wärmeabgabe über 20kW durch Kesselvorwärmung.

Strom-Verbrauch: Die Schorni-Feinstaubmeßstation braucht nur ein paar hundert Watt.
Man sieht hier auch 5 Minuten Anheizzeit der Heizspiralen bis das Feuer brennt.

Schorni-Feinstaubmeßstation Wöhler SM 500

Gruß
Jürgen

Hallo Volker,

spannendes Thema Luftmenge mit Lüfterdrehzahl, anstatt mit dem Schieber regeln.

Für die „Einmaleinstellung“ brauchst ja nur in den A25-Brenner Parametern
S3 (Sollwert Drehzahl vom Lüfter bei Normalbetrieb AN)
von 100% solange nach unten verändern (Drehzahl verringern in 1% Schritten),
bis die gleichen Verbrennungs-Werte von der Lambdasonde auslesen kannst wie die jetzigen Werte.
Den Schieber am Lüfter würde ich ganz aufmachen oder wegschrauben.

Zum Automatisieren fehlen zwei Tastensequenzen eine mit +1% und eine -1%.
Dafür ist eine Erweiterung in dem Arduino-Sketch notwendig.

Gruß
Jürgen

Hallo 855,

in einem alten Thread aus dem ATMOS-Forum hat der User Hubschrauber
die Beschreibung von EBMPAPST nachfolgend übersetzt.

SG2 Signalgeber + Flansch muß man extra dazu bestellen...
(SG 2)Allgemeine Beschreibung
Der Signalgeber SG 2 ist ein Impulsgeber zum Anbau an die Motorbaureihen EM30 und KM.
Über einen 24-poligen, kunststoffgebundenen Hartferrit-Magnetring und einem Hall-IC werden 12 Rechteckimpulse je Motorumdrehung erzeugt.
Mit einer nachgeschalteten Auswerte-Elektronik kann dieses Signal zur Drehzahlerkennung, z.B. für eine Drehzahlregelung genutzt werden.
Im einfachsten Fall ist hierzu eine Versorgungsspannung von 4,5 - 24 V sowie ein Pull-up-Widerstand von z.B. 2,7 KOhm, 0,25 W erforderlich,
um am Ausgang ein digitales Signal mit konstanter Amplitude zu erhalten.
Der Signalgeber zeichnet sich aus durch hohe Betriebssicherheit, geringe Abmessungen, beliebige Einbaulage und keine Laufgeräusche.

Im Datenblatt von EBMPAPST sind auch noch diverse Bilder und Zeichnungen dabei.
Beim Atmos A25 Brenner wird der Signalgeber mit 5V Versorgungsspannung betrieben.

Was hast du vor mit den Informationen zur Drehzahlerkennung?
Ist der Impulsgeber oder der Lüfter defekt ?

Gruß
Jürgen

Die ersten Messreihen erfolgten heute am ungereinigten Atmos D15P (ca. 4 Wochen keine Wärmetauscherreinigung)
Brennerschale und Brennraum regelmässig mit Staubsauger gereinigt.

Die Parameter am A25 Brenner sind T4=5,0 Sek und T6=15,0 Sek
Restsauerstoff und Abgastemperatur mit Lamdacheck gemessen.
Bei der Luftklappe am A25 Brenner Ventilator ist der Luftspalt fest eingestellt ca. 15mm in der Mitte des Radius gemessen.
Relative Feinstaubmessung mit dem Sensor SDS011 und NodeMcu (ESP8266) im Bypass wie vorher gezeigt.
Es sind keine Abgasbremsen oder Wirbulatoren in den Wärmetauscherröhren verbaut.
Leistung 10-12 kW mit 2 Temp-Sensoren und Durchflussmesser in UVR1611 mit Wärmemengenzähler errechnet.
LambdaSonde vom Lamdacheck ist auf der Rückseite vom Kessel unten in der Mitte der Reinigungsabdeckung eingebaut.
Messdaten werden über Wlan mit MQTT zu fhem übertragen und dort mit nachfogenden SVG-Diagrammen zur Anzeige gebracht.

Bild1: Brenner Startphase

Bild2: nach einer Stunde Laufzeit

Gruß
Jürgen

Mein Atmos D15P mit A25 hatt die letzte Messung erfolgreich bestanden, aber dennoch interessiert mich das Thema Feinstaub und die
Messung bei den Pelletern. Beim Suchen und Lesen im Netz bin ich auf den Feinstabsensor SDS011 (kostet 29,95Euro bei W..rott) gestossen.
Dieser Sensor wird sehr oft in Projekten verbaut z.B. vom OK Lab Stuttgart mit dem Citizen Science Projekt luftdaten.info.

Was beim Durchlesen vom Datenblatt sofort auffällt ist die extreme Empfindlichkeit, PM2,5, und PM10, max. Messbereich von 0,0-999,9 ug / m3.
Wir bewegen uns mit unseren Pelletern feinstaubmässig im Bereich von 20.000 - 60.000 ug / m3 also um den Faktor 20-60 grösser.

Bei Spannung und Strom-Messgeräten kann man einen Messbereich vergrössern mit entsprechenden Vorwiderständen oder Spannungsteilern.
Für die Messbereichserweiterung im Rauchgas für die Feinstaubmessung hab ich mir folgendes überlegt:

Ich versuche zum Messen das Rauchgas mit Luft zu mischen um somit die Konzentration zu verdünnen, wie beim Moped mit dem Vergaser und Luftgemisch.
In der Hoffnung, das in diesem verdünnten Rauchgas so viel Feinstaub drin ist, so dass der Sensor in seinem
Messbereich 0,0-999,9 ug / m3 arbeiten kann. Ich begnüge mich dann mit einem relativen Feinstaubmesswert, also einem Bruchteil
vom eigentlichen Feinstaubmesswert.
Wenn ich mit diesem relativen Feinstaubmesswert Parameter-Änderungen in der Verbrennung wie Restsauerstoff, Abgastemperatur, Leistung oder
Wirbulatorenoptimierungen nachvollziehen kann, dann reicht mir das vollkommen aus um meinen Pelleter feinstaubmässig noch optimieren zu können.

Realisiert hab ich das ganze mit einem Bypass, um eine geringe Menge Rauchgas zur Messung aus dem Ofenrohr abzuzweigen (ausleiten zum Messen)
und anschliessend wieder zurückzuführen.

Bild1 links unten Bypass-Eingang, unten rechts Luftmischung, oben mitte Feinstaubmessung mit sensor SDS011 und NodeMcu oben links Bypass-Ausgang

Bild2 Anschlüsse ans Ofenrohr, die ersten 50cm mit Kupferrohr zum Abkühlen des Rauchgases

Bild3 erste Messoptimierung, Luftmischung mit Deckel mit 10mm Loch, Lüfter entfernt

Im ersten Versuch habe ich mit 3 Ventilatoren begonnen, einer am Eingang des Bypass, einer am Ausgang des Bypass
und einer zum Lufteinblasen (Mischen).

Die erste Messung mit Anheizen und ein paar Stunden Heizbetrieb hat überraschend gute Werte gezeigt.
Ich habe natürlich überall rumgespielt und an allen möglichen Punkten am Bypass Veränderungen vorgenommen.
Die Feinstaubmesswerte PM2,5, und PM10 schwankten dabei im Bereich von 100 - 8000 ug / m3 also deutlich über 1000 ug / m3.
An der Luftmischung hab ich den Lüfter entfernt und einen Deckel drauf mit einem 10mm Loch in der Mitte. Jetzt liegen die
Feinstaubmesswerte PM2,5, und PM10 im normalen Betrieb im Bereich 200-300 ug / m3.

Wenn ich die Ofentür aufmache und die Verbrennung sich daurch natürlich verschlechtert, dann sehe ich dies auch in einer
Änderung der Feinstaubwerte. Die steigen dann bis über 900 ug / m3 an, also grade noch im normalen Messbereich des Sensors.
Die Feinstaubmessung reagiert etwas träge, es dauert schon einige Sekunden bis sich der Messwert ändert.
Die ersten Erfahrungen stimmen mich positiv.

Vielleicht kennt sich jemand richtig gut aus mit heisser Luft und dem mischen von dieser.
Ich weiss, ist ein heikles Thema, deshalb bitte nur konstruktive Vorschläge.

Gruß
Jürgen

Ich bin schon eine Weile mit MQTT am experimentieren, heute mit dem Projekt ESP8266 WLAN Messdatenübertragung der KAMO FWS-Daten zum Message-Broker Mosquitto einen Schritt weitergekommen.

Mit dem NodeMCU-(ESP-12E-Modul mit CP2102 USB), einem sehr kleinen, preiswerten(7Euro) stromsparenden leistungsfähigen Mikrokontroller mit WLAN, bin ich auf Anhieb sehr gut zurecht gekommen,
musste nicht viel umlernen, weil er sich auch mit der Arduino-IDE (Programmieroberfläche) leicht programmieren lässt.
Die verschiedenen erhältlichen ESP8266-Module unterscheiden sich eigentlich nicht in der Programmierung, kann man ein Modul programmieren, kann man im Grunde alle programmieren.
Weiterhin wurde die Programmierung erheblich vereinfacht, da jetzt auch die zwei Handshake-Leitungen per USB genutzt werden um das Board jederzeit per Arduino programmieren zu können.
Das NodeMCU-Board hat noch zwei Taster (Reset und Flash), aber wenn man wie ich per Arduino IDE programmiert, braucht man den Flash Taster nicht nutzen.
Die Software wird einfach per Arduino IDE mit einem Arduino Sketch überschrieben.
Im Grunde braucht man nur das USB-Kabel einstecken und kann loslegen, es muss nichts mehr speziell für die Programmierung verkabelt werden, was die Sache sehr komfortabel für Programmierer macht.
Achtet möglichst beim Kauf darauf, dass das Modul als USB-Wandler den Chip CP2102 verwendet,
das hat nämlich den Vorteil dass Ihr unter neueren Betriebsystemen (Windows 7 / 8 / 10) keinen Treiber installieren müsst, da Windows diesen bereits besitzen sollte.

Der ESP8266-Chip enthält eine 32-Bit CPU Tensilica Xtensa LX106 mit 80 MHz Taktfrequenz,
1 MByte Programmspeicher und 96 KByte Datenspeicher sowie einen Flashspeicher von 4 MBytes.
Bis zu 16 GPIO-Anschlüsse (GPIO = General Purpose IO)
SPI- und I2C-Bus
UART für Duplex-Betrieb, einen für reines Senden
10-Bit-Analog-/Digitalwandler

ESP8266-Module arbeiten mit 3,3V.
5-V-Signale (z.B. Tx) zerlegt man per Spannungsteiler in zwei Komponenten mit 1,7 V und 3,3 V und führt die 3,3 V an den Eingang des ESP8266 (z.B. Rx).

Meine Kamo-Frischwasserstation hat einen 5V TTL Datenausgang mit einer Geschwindigkeit von 19200 Baud und sendet in (standby) alle 15 Sekunden und wenn WW gezapft wird im 2 Sekundentakt eine Datenzeile.

Fritzing Plan Kamo-Projekt

Testaufbau auf dem Schreibtisch, mit Arduino-Uno als Test-Sender (5V TTL mit 19200 Baud)

Einbau in KAMO Frischwasserstation, das kleine Experimentierboard wurde über der Steuerung befestigt.

Kamo Frischwasserstation mit ESP8266

ESP8266-Arduino-Sketch (Programm)

#include <SoftwareSerial.h>
#include <ESP8266WiFi.h>
#include <PubSubClient.h>


// PIN-Belegung von NodeMCU V2
// D5 14 // GPIO14 SoftwareSerial RX Eingang
// D6 12 // GPIO12 SoftwareSerial TX Ausgang
// D9 3 //  GPIO3 RX0 (Serial console)
// D10 1 // GPIO1 TX0 (Serial console)


//                   RX, TX(GPIO's)
SoftwareSerial swSer(14, 12, false, 256);


// Update these with values suitable for your network. 
const char* ssid = "NETZ123";                // Name des WLAN an das sich der ESP connecten soll
const char* password = "pw4711";             // wlan-key vom WLAN an das sich der ESP connecten soll
const char* mqtt_server = "192.168.08.15";   // ip-adresse des Rechners, auf dem der broker(z.B. Mosquitto) läuft 


WiFiClient espClient;
PubSubClient client(espClient);
long lastMsg = 0;
char msg[500];
int value = 0;
char hzeile[ ] = "dd hh:mm:ss Tsoll T_WW_ T_Zir TPrVL TPufO TPrRL TPufM 01 02 03 04 05 06 07 08 09 10 l/min FB P1% P2% LS Anh RL Err";
char kzeile[ ] = "                                                                                                                  ";
int av = 0;
int av2 = 0;
int zaktiv = 0;
String s2 = " ";


void setup() {
  pinMode(BUILTIN_LED, OUTPUT);     // Initialize the BUILTIN_LED pin as an output
  Serial.begin(115200);
   swSer.begin(19200);
   Serial.println("\nSoftware serial test started");
   delay(1000);
  setup_wifi();
  client.setServer(mqtt_server, 1883);
  client.setCallback(callback);
  // ------init blinker
  pinMode(LED_BUILTIN, OUTPUT);     // Initialize the LED_BUILTIN pin as an output
  //Versionspflege
  Serial.println("MQTT_ESP12E_UART_V3_31102017");
}


void setup_wifi() {
  delay(10);
  // We start by connecting to a WiFi network
  Serial.println();
  Serial.print("Connecting to ");
  Serial.println(ssid);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("WiFi connected");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());
  delay(1000);
}


void callback(char* topic, byte* payload, unsigned int length) {
  Serial.print("Message arrived [");
  Serial.print(topic);
  Serial.print("] ");
  for (int i = 0; i < length; i++) {
    Serial.print((char)payload[i]);
  }
  Serial.println();


  // Switch on the LED if an 1 was received as first character 
  if ((char)payload[0] == '1') {
    digitalWrite(BUILTIN_LED, LOW);   // Turn the LED on 
  } else {
    digitalWrite(BUILTIN_LED, HIGH);  // Turn the LED off 
  }


}


void reconnect() {
  // Loop until we're reconnected
  while (!client.connected()) {
    Serial.print("Attempting MQTT connection...");
    // Attempt to connect
    //#####################################################################
    // eindeutiger Client-Name für jedes NodeMCU-Modul verwenden. 
    // Info steht im mosquitto-broker log  /var/log/mosquitto/mosquitto.log 
    //#####################################################################
    client.connect("KamoESP8266Client");
    if (client.connect("KamoESP8266Client")) {  
      Serial.println("connected");
      // Once connected, publish an announcement...
      client.publish("kamoi", "hello world"); // msg mit topic kamoi zum broker schicken
      // ... and resubscribe
      //client.subscribe("#");      // alle topics lesen mit #
      client.subscribe("inTopic");  // Lesebeispiel, topic inTopic lesen
    } else {
      Serial.print("failed, rc=");
      Serial.print(client.state());
      Serial.println(" try again in 5 seconds");
      // Wait 5 seconds before retrying
      delay(5000);
    }
  }
}


void loop() {


  if (!client.connected()) {
    reconnect();
  }
  client.loop();


  if (swSer.available() > 0) {
    char kzeile[ ] = "                                                                                                                  ";
    zaktiv = 1;
    delay(100);    // empirisch ermittelte Wartezeit bis die ganze Datenzeile komplett im Buffer drin ist 
    av2 = swSer.available(); // in av2 steht die Anzahl der im Buffer eingelesenen Zeichen von der KAMO
  }
  if (swSer.available() > 0) {
    int av = swSer.available();
    for (int i = 0; i < av; i++) {
       kzeile[i] = swSer.read();    // serielle Daten mit 19200 Baud von der KAMO einlesen
    }
  }
  if (zaktiv > 0) {
    s2 = kzeile;
    int num = strlen(kzeile);
    s2 = s2.substring(1,av2);
    s2.toCharArray(kzeile, 116);
  }
  if (zaktiv > 0) {
    snprintf (msg, 120, kzeile);
    Serial.println("Publish message: ");
    Serial.println(msg);
    client.publish("kamod", msg); // msg (kzeile) mit topic kamod zum broker schicken
    delay(10);
    char kzeile[ ] = "                                                                                                                  ";
    zaktiv = 0;
  }
  // ----- blinker led für optische Kontrolle, dass der ESP läuft
  digitalWrite(LED_BUILTIN, LOW);   // Turn the LED on 
  delay(50);                        // Wait 
  digitalWrite(LED_BUILTIN, HIGH);  // Turn the LED off 
  delay(50);                        // Wait  
  // ----- blinker led
}

Mit dem NodeMCU-(ESP8266) werden nachfolgende Message (Daten) Zeilen alle 15 Sekunden von der KAMO seriell über den UART im ESP8266 mit 19200 Baud eingelesen
und über WLAN an den Message-Broker Mosquitto geschickt.

d hh:mm:ss Tsoll T_WW_ T_Zir TPrVL TPufO TPrRL TPufM 01 02 03 04 05 06 07 08 09 10 l/min FB P1% P2% LS Anh RL Err
Message arrived [kamod] 1 09:21:56 060,0 059,1 024,3 078,0 222,2 063,7 222,2 84 79 155 02 117 100 100 100 100 100 000,0 01 000 000 0 0 1 0
Message arrived [kamod] 1 09:22:11 060,0 059,1 024,3 078,0 222,2 063,7 222,2 84 79 155 02 117 100 100 100 100 100 000,0 01 000 000 0 0 1 0
...

Nun können diese Messages zeitgleich von allen an den Message-Broker Mosquitto
connecteten Anwendungen mit dem topic kamod gelesen und weiterverarbeitet werden.

Gruß
Jürgen