A25 ext. Display und Datenlogger für Brennerdaten

    Holzheizer Forum und Holzvergaser Forum sind vereint.
    Du hast Probleme beim Login? Schreibe uns im Forum "Probleme mit der Registrierung".
      • 1

      • # 15709

      A25 ext. Display und Datenlogger für Brennerdaten

      Hallo zusammen,

      ich will im Sommer meinen A25 Pelletsbrenner am D15P mit der aktuellen Steuerelektronik AC07X(ab 2012)
      und der ATMOS Pressluftreinigung nachrüsten. Die notwendigen Teile liegen hier und warten auf das Ende der Heizperiode.

      Vorher will ich noch die Brennerdaten auf einem externen LCD-Display anzeigen,
      mit einem µC (Arduino oder RasPi) auslesen, loggen und visualisieren.

      Beim Aufschrauben der AC07X und näherem Betrachten der oberen Display-Platine ist mir aufgefallen, dass
      direkt unter dem LCD-Display auf der Platine noch ein IC sitzt, das zur Ansteuerung des LCD-Displays gehört.
      Da es schwer zugänglich ist, wollte ich mal nachfragen ob schon jemand dieses IC freigelegt hat und somit
      weiss um welchen Baustein es sich hier handelt.

      Vielen Dank für eure Hilfe.

      Gruß
      Jürgen
      Atmos D15P mit A25; LC und Belimo gesteuerte Luftklappe am Ventilator; UVR1611 mit CAN-I/O44 und BL-NET;
      2x1000l Puffer mit 2x10m² VRK und glykolfreie Solarthermie(Ost-West); WW-FWS; PV 3,2kW; Wasserenthärtung
      • 2

      • # 16062
      Hallo zusammen,

      Auf dem Weg an die Brennerdaten vom A25 ranzukommen, bin ich inzwischen direkt am 2*16 LCD Display vom Atmos A25-Brenner
      gelandet.

      Das Ausmessen der einzelnen Pins an der ausgebauten Display-Platine mit dem Ohmmeter ergab, dass das LCD-Display im 4-Bit Mode,
      also mit 4 Datenleitungen D4,D5,D6,D7 und E als Steuerleitung betrieben wird, weil die restlichen Datenleitungen D0,D1,D2,D3
      auf Masse hängen.

      Das folgende Bild mit dem Logicanalyser und der Protokollanalyse HD44780 von den LCD-Display-Daten zeigt
      im Klartext "AC 07" meine Brennerdaten im 4-Bit Mode.



      Time (s), Analyzer Name, Decoded Protocol Result
      5.914219200000000,HD44780,Write Command '128' (0x80) (Set DDRAM Addr '0' (0x00))
      5.915876500000000,HD44780,Write Data A (0x41) (Data 'A')
      5.916116200000000,HD44780,Write Data C (0x43) (Data 'C')
      5.916355800000000,HD44780,Write Data ' ' (0x20) (Data ' ')
      5.916595400000000,HD44780,Write Data 0 (0x30) (Data '0')
      5.916835200000000,HD44780,Write Data 7 (0x37) (Data '7')
      5.917074800000000,HD44780,Write Data ' ' (0x20) (Data ' ')
      5.917314400000000,HD44780,Write Data ' ' (0x20) (Data ' ')
      5.917554000000000,HD44780,Write Data ' ' (0x20) (Data ' ')
      5.917793700000000,HD44780,Write Data ' ' (0x20) (Data ' ')
      5.918033400000000,HD44780,Write Data ' ' (0x20) (Data ' ')
      5.918273100000000,HD44780,Write Data ' ' (0x20) (Data ' ')
      5.918512600000000,HD44780,Write Data ' ' (0x20) (Data ' ')
      5.918752300000000,HD44780,Write Data ' ' (0x20) (Data ' ')
      5.918991900000000,HD44780,Write Data ' ' (0x20) (Data ' ')
      5.919231600000000,HD44780,Write Data ' ' (0x20) (Data ' ')
      5.919471300000000,HD44780,Write Data ' ' (0x20) (Data ' ')
      5.919710900000000,HD44780,Write Command '192' (0xC0) (Set DDRAM Addr @ (0x40))
      5.919950600000000,HD44780,Write Data v (0x76) (Data 'v')
      5.920190200000000,HD44780,Write Data e (0x65) (Data 'e')
      5.920429900000000,HD44780,Write Data r (0x72) (Data 'r')
      5.920669600000000,HD44780,Write Data s (0x73) (Data 's')
      5.920909200000000,HD44780,Write Data i (0x69) (Data 'i')
      5.921148800000000,HD44780,Write Data o (0x6F) (Data 'o')
      5.921388400000000,HD44780,Write Data n (0x6E) (Data 'n')
      5.921628100000000,HD44780,Write Data ' ' (0x20) (Data ' ')
      5.921867800000000,HD44780,Write Data 0 (0x30) (Data '0')
      5.922107500000000,HD44780,Write Data . (0x2E) (Data '.')
      5.922347100000000,HD44780,Write Data 1 (0x31) (Data '1')
      5.922586700000000,HD44780,Write Data 8 (0x38) (Data '8')
      5.922826300000000,HD44780,Write Data ' ' (0x20) (Data ' ')
      5.923065900000000,HD44780,Write Data ' ' (0x20) (Data ' ')
      5.923305600000000,HD44780,Write Data ' ' (0x20) (Data ' ')
      5.923545200000000,HD44780,Write Data ' ' (0x20) (Data ' ')

      Da das ganze sehr zeitkritisch ist, denn die Displaydaten werden alle 100ms ans LCD-Display geschickt,
      das sind ca. 10mal pro Sekunde, habe ich mich fürs erste für meinen Arduino-Mega2560 zum Einlesen und dekodieren
      der Displaydaten und den Raspi2 zum sammeln und speichern der Daten in eine Logdatei entschieden.

      Der Arduino-Mega2560 ist per USB-Kabel mit dem Raspi2 verbunden. Eine Arduino-Software-IDE zum Programmieren
      hab ich direkt auf dem Raspi laufen, so kann ich den Arduino-Mega2560 der am Raspi2 hängt direkt vom
      Raspi2 aus programmieren. Der Raspi2 und der Arduino-Mega2560 sind im Heizraum direkt neben dem Brenner mit einem kurzen kabel mit
      dem 2*16 LCD Display vom Atmos A25-Brenner verbunden. Der Raspi2 hängt am Netzwerk und ist somit per REMOTE-Desktop-Verbindung
      vom entfernten Büro übers Netz bedienbar.

      Im nächsten Bild sieht man wie das 2*16 LCD Display vom Atmos A25-Brenner an den Arduino-Mega2560 bei mir angeschlossen ist.



      Damit konnte ich meine Brennerdaten auslesen und in eine Logdatei abspeichern.

      Parametern -


      LCD Anzeige Änderung festgestellt: CCx= 68

      Eine Display Zeile besteht aus 68 Halb-Bytes, wegen 4-Bit Mode
      1000-0-100-1001-110-1110-110-110-110-1111-111-10-110-1101-110-1-111-100-110-1001-110-1111-110-1110-10-0-10-0-10-0-10-0-10-0-
      1100-0-10-0-10-0-10-0-10-0-10-0-10-0-10-0-10-0-10-0-10-0-10-0-10-0-10-0-10-0-10-0-10-0-

      diese 68 Halb-Bytes wieder zusammengesetzt ergeben die folgenden 34 Hex-Bytes, sie entsprechen dem ASCII-Code

      80-49-6E-66-6F-72-6D-61-74-69-6F-6E-20-20-20-20-20-C0-20-20-20-20-20-20-20-20-20-20-20-20-20-20-20-20-
      ...
      Information -
      Photozelle - 0%
      untere Temp. - 32,2 C
      oberer Temp. - 59,8 C
      Ventilator - 0rpm
      Forderschnecke - OFF
      Schneckestorung - OK OK
      Gluhspirale - 1:OFF 2:OFF
      Spiralestorung - 1: OK 2: OK
      Ausgangsreserve - 1-OFF
      ...

      Screenshot mit den einzelnen Programmen vom Raspi2 von diesem Projekt auf einen Blick.



      Gruß
      Jürgen
      Atmos D15P mit A25; LC und Belimo gesteuerte Luftklappe am Ventilator; UVR1611 mit CAN-I/O44 und BL-NET;
      2x1000l Puffer mit 2x10m² VRK und glykolfreie Solarthermie(Ost-West); WW-FWS; PV 3,2kW; Wasserenthärtung
      • 3

      • # 16063
      Dann hast du aber jeweils nur die Daten, die gerade angezeigt werden. Oder habe ich das falsch verstanden?
      Viele Grüße
      Thomas

      Atmos P14/130 mit A25, Selbstbaupressluftreinigung und Laddomat, 850 l Puffer, Regelung mit UVR 63-H und ESR 21R + DK Flame Domo (Kaminofen) im Wohnzimmer.

      :lager:
      • 4

      • # 19345
      Hallo Solarengel,

      ich wollte genau das Selbe machen wie Du und bin schon mal sehr erfreut dass ich mir die Hardware nicht mehr anschauen muss.
      Deinen Infos zur Folge scheint das ja auch alles für mich kein Problem zu sein. Ich bin mit µC und Elektronik etwas bewandert ;).
      Könnte ich ein Sketch haben um etwas Zeit zu sparen ? Steuerst du die Tasten an um alle infos auszulesen ?
      Ich werde noch ein WIFI danbauen um das ganze später ans SmartHome anzuschliessen.

      Grüße Andreas
      • 5

      • # 19362
      Hallo Andreas,

      über den Sommer hatte mein D15P mit A25-Brenner Ferien, denn Solarthermie reichte für WW und Wäremeüberschussverwertung
      mit Wandheizung um die Kellerwände im Sommer trocken zu halten.
      Aber jetzt läuft er wieder und ich habe auch am Projekt weitergemacht.

      Vom 4-bit Display-Anschluss bin ich inzwischen weg und habe mich an den Anschluss J3 (Display)
      auf der Brenner-Steuerplatine hinbewegt. Da wollte ich auch ursprünglich aufsetzten.

      Hab im Frühjahr leider die seriellen SPI-Daten nicht verstanden oder auswerten können.
      Auf den zweiten Blick mit den 4-bit Displaydaten Erfahrungen konnte ich das ganze mit beiden (SPI und HD44780) Protokollen analysieren.

      Am Anschluss J3 (2*7 Pin) sind die Displaydaten im SPI-Protokoll seriell und an den restlichen Pins an J3
      sind auch die 4 Taster vom Bedienfeld rausgeführt. Also genau die richtige Stelle um Daten zu lesen und Tasten
      oder Tasten-Sequenzen ferngesteuert zu drücken um alle Infos und Parameter vom A25-Brenner auszulesen.

      Den neuen Sketch auf einem Arduino-UNO R3 mit SPI-Displaydaten und Tasten oder Tasten-Sequenzen ferngesteuert zu drücken
      hab ich schon einige Zeit am laufen. Den Sketch gibts natürlich auch, aber lass mich noch das ganze über die Tage ein bisschen dokumentieren,
      denn der Anschluss ist anders und wurde auch um die 4 Tasten erweitert.

      Ich hab diese Version mit dem Arduino-UNO R3 gemacht, weil der die gleiche Hardware wie
      das Gerduino Board für RASPI2 hat und dann noch einen austauschbaren ATMEGA328P-PU im PDIP28 Gehäuse drauf hat.

      Gruß
      Jürgen


      Anschluss J3 auf der Brenner-Steuerplatine


      Arduino-UNO R3 am A25-Brenner und über USB am Raspi2


      Auszug aus den Logdaten, die ich mit dem Raspi2 über den USB-Anschluss vom Arduino-UNO eingelesen und gespeichert habe:

      1.Infodaten-Liste, Tastensequenz wird periodisch aufgerufen, je nach status (START,AN,AUS) unterschiedliche Zeiten einstellbar
      25.11.2015 23:48:51 A25 ==>AN 74/ 41 C * * *
      25.11.2015 23:48:51 A25 ==>Parametern
      25.11.2015 23:48:51 A25 ==>Information
      25.11.2015 23:48:52 A25 ==>Photozelle 100%
      25.11.2015 23:48:52 A25 ==>untere Temp. 41,2 C
      25.11.2015 23:48:53 A25 ==>oberer Temp. 73,9 C
      25.11.2015 23:48:53 A25 ==>Ventilator 2850rpm
      25.11.2015 23:48:53 A25 ==>Forderschnecke OFF
      25.11.2015 23:48:54 A25 ==>Schneckestorung OK OK
      25.11.2015 23:48:54 A25 ==>Gluhspirale 1:OFF 2:OFF
      25.11.2015 23:48:55 A25 ==>Spiralestorung 1: OK 2: OK
      25.11.2015 23:48:55 A25 ==>Ausgangsreserve 1-OFF

      2. Parameter-Liste, Tastensequenz wird periodisch aufgerufen, kann auch aus bleiben, keine Änderungen der Werte
      25.11.2015 23:58:38 A25 ==>AN 74/ 41 C * * *
      25.11.2015 23:58:38 A25 ==>Parametern
      25.11.2015 23:58:39 A25 ==>Parametern Gerateart A25
      25.11.2015 23:58:39 A25 ==>Parametern T1 67s
      25.11.2015 23:58:39 A25 ==>Parametern T2 10min
      25.11.2015 23:58:40 A25 ==>Parametern T4 5,0s
      25.11.2015 23:58:40 A25 ==>Parametern T5 15min
      25.11.2015 23:58:41 A25 ==>Parametern T6 15,0s
      25.11.2015 23:58:41 A25 ==>Parametern T7 30s
      25.11.2015 23:58:41 A25 ==>Parametern T8 6min
      25.11.2015 23:58:42 A25 ==>Parametern T10 10min
      25.11.2015 23:58:42 A25 ==>Parametern S1 4
      25.11.2015 23:58:43 A25 ==>Parametern S2 5%
      25.11.2015 23:58:43 A25 ==>Parametern S3 100%
      25.11.2015 23:58:43 A25 ==>Parametern S4 1
      25.11.2015 23:58:44 A25 ==>Parametern S6 1
      25.11.2015 23:58:44 A25 ==>Parametern S7 1
      25.11.2015 23:58:45 A25 ==>Parametern S10 1
      25.11.2015 23:58:45 A25 ==>Parametern S11 50%
      25.11.2015 23:58:45 A25 ==>Parametern S12 1%
      25.11.2015 23:58:46 A25 ==>Parametern S13 0min
      25.11.2015 23:58:46 A25 ==>Parametern S15 2
      25.11.2015 23:58:47 A25 ==>Parametern S16 69 C
      25.11.2015 23:58:47 A25 ==>Parametern S17 72 C
      25.11.2015 23:58:47 A25 ==>Parametern OffsetTV +0,0 C
      25.11.2015 23:58:48 A25 ==>Parametern OffsetTS +0,0 C
      25.11.2015 23:58:48 A25 ==>Parametern Reset
      25.11.2015 23:58:49 A25 ==>Parametern Kalibr.
      25.11.2015 23:58:49 A25 ==>Parametern Sprache DE

      3. Ein kleines Menü für manuelle Tastensteuerung im Sketch, wenn mit der Arduino-IDE
      die Ausgabe im seriellen Monitor läuft.

      Serial.println("Menü (h)");
      Serial.println("i Informationen ");
      Serial.println("p Parameter ");
      Serial.println("x Remote off ");
      Serial.println("z Reset erzwingen ");
      Serial.println("e ESC Pfeil nach links ");
      Serial.println("r RET Pfeil nach links ");
      Serial.println("o Auf Pfeil nach oben ");
      Serial.println("u Ab Pfeil nach unten ");
      Atmos D15P mit A25; LC und Belimo gesteuerte Luftklappe am Ventilator; UVR1611 mit CAN-I/O44 und BL-NET;
      2x1000l Puffer mit 2x10m² VRK und glykolfreie Solarthermie(Ost-West); WW-FWS; PV 3,2kW; Wasserenthärtung
      • 6

      • # 19386
      Hallo Juergen,
      echt super dass Du noch weiter gemacht hast. Ich bin auch sehr beeindruckt von deiner Hilfsbereitschaft.
      Im allgemeinen sind meine Erfahrungen in Foren nicht so toll.
      Naja deine Zusage fuer den Code ist ja schon mal ein super Weihnachtsgeschenk fuer mich.
      Ich arbeite derzeit an einer Pellettransportstrecke.
      Ich habe einen Tagesbehaelter fuer 70 Euro ergattert und muss von dort die Pellets ueber ein paar HT Rohre/ Winkel und Lichtschranke zur Atmosschnecke befoerdern.
      Auf dem Tisch (mit USB Versorgung) klappt alles aber eingebaut nicht mehr. Ich glaube dass mein UNO eine kalte Loetstelle am Spannungsregler hat,
      denn das UNO haengt sich regelmaessig auf und die AD Werte laufen weg wenn ich den USB Stecker abziehe.
      Was ist eigentlich Wäremeüberschussverwertung ? Ich habe den Atmos mit 10kW Roehren und Trinkwasserstation.
      Evtl kommt noch ein Wasserfuehrender Ofen im Wohnzimmer dazu weil ich eine Menge (>10 m3) Altholz vom Umbau rumliegen habe.

      Gruesse und schoene Feiertage

      Andreas
      • 7

      • # 19414
      Hallo Andreas,

      die Solarthermie besteht bei mir aus 2* 10m2 Röhrenkollektoren OST-West und ist für Heizungsunterstützung in den Übergangszeiten und im Winter so wie jetzt
      dimensioniert. Aber im Sommer, wenn nicht geheizt wird, dann wäre die FWS vom WW der einzige Wärmeverbraucher. Mit meinem 2000 l Pufferspeicher
      kann ich leider nicht die ganze erzeugte und nicht sofort verbrauchte Wärme aus dem Pufferspeicher vom Sommer bis in den Winter zwischenspeichern.
      Deshalb werden im Sommer zusätzliche Heizkreise für Wandheizungen zum heizen der Grundmauern von unserem alten Gebäude im Sommer als Wäremeüberschussverwertung aktiviert.

      selbstgebaute Wandheizung der Grundmauern


      Der Arduino-UNO R3 ist per USB-Kabel mit dem Raspi2 verbunden und steht im Heizraum beim D15P-Kessel. Eine Arduino-Software-IDE zum Programmieren
      hab ich direkt auf dem Raspi laufen, so kann ich den Arduino am Raspi2 übers Netz vom Büro aus mit REMOTE-Desktop fernsteuern.

      Was hast du mit den ausgelesenen Brennerdaten vor? Welches SmartHome-System mit Wifi verwendest du?
      Wie bringst du die Daten vom Arduino über Wifi zum SmartHome-System?

      Aus den Brennerdaten konnte ich den Brennerstatus verwenden (AUS,START,AN), und sehen,
      dass die Lüfterdrehzahl vom A25-Brenner im Normalbetrieb sehr konstant mit 2850 läuft und nicht schwankt.
      Die %-Werte der Photozelle schwanken auch nicht während des Betriebs, sie sind konstant auf 100%,
      d.h. die eingestellen (Puls/Pause-Zeiten) für die Pelletsmenge aus der Sicht der Flammenüberwachung stimmen
      für ein gleichmäßiges verbrennen der Pellets.
      Die TS und TV Temperaturen wären auch noch da, aber die messe ich am Puffer mit der UVR zusätzlich mit anderen Sensoren.

      Anschluss des Arduino UNO R3 an meinen Atmos A25-Brenner (Baujahr vor 2012) über J3 Display Anschluß
      auf der Brennersteuerungsplatine mit 330 Ohm Schutzwiderständen.


      Arduino Sketch mit Ein/Ausgabe der Daten über USB-Anschluß bei mir zum Raspi2 mit Arduino-Software-IDE.

      C-Quellcode

      1. // A25_UNO_R3_SPI_slave_ARDUINO-IDE-Version
      2. //
      3. // Anschluss am ARDUINO UNO R3 Board:
      4. // UNO PB5 pin10 SS E ,ueber Widerstand 330 nach Masse, SPI-Slave-Modus fix
      5. // UNO PB4 pin11 MOSI ,ueber Widerstand 330 nach A25
      6. // UNO PB3 pin12 MISO ,nicht belegt
      7. // UNO PB2 pin13 SCK ,ueber Widerstand 330 nach A25
      8. // UNO PD7 pin4 pfeil nach oben , auf ,ueber Widerstand 330 nach A25
      9. // UNO PD6 pin6 pfeil nach unten , ab ,ueber Widerstand 330 nach A25
      10. // UNO PD5 pin5 pfeil nach rechts, RET ,ueber Widerstand 330 nach A25
      11. // UNO PD4 pin7 pfeil nach links , ESC ,ueber Widerstand 330 nach A25
      12. // UNO GND pin14 Masse , nach A25 Masse
      13. #include <SPI.h>
      14. #include <avr/wdt.h>
      15. byte CCNible[150];
      16. char LCDz[70];
      17. int CCx = 0;
      18. int iz = 0;
      19. String LCDzeile = "";
      20. volatile int CCa = 0;
      21. char buf [150];
      22. volatile byte pos;
      23. volatile boolean process_it;
      24. int ab = 6; //Pfeil nach unten
      25. int esc = 7; //Pfeil nach links
      26. int ret = 5; //Pfeil nach rechts
      27. int auf = 4; //Pfeil nach oben
      28. int cmd = 0;
      29. int A25p = 0;
      30. unsigned long pdauer = 500;
      31. unsigned long schleife = 0;
      32. int f_start = -1;
      33. int f_an = -1;
      34. int f_aus = -1;
      35. int info[15] = {5,6,5,6,6,6,6,6,6,6,6,6}; //Tastensequenz für Info-Liste
      36. int para[30] = {5,5,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6}; //Tastensequenz für Parameter-Liste
      37. String status;
      38. char incomingByte;
      39. unsigned long mszd = 120000; //alle 2 Minuten Parameter
      40. unsigned long pms = millis();
      41. unsigned long cms = millis();
      42. void setup (void)
      43. {
      44. Serial.begin (115200); // Ausgabe / debugging
      45. Serial.println("A25_UNO_R3_SPI_slave_V14_IDE ");
      46. // SPI in slave mode
      47. SPCR |= bit (SPE);
      48. pinMode(MISO, OUTPUT);
      49. A25p = 2; //default Informationen ausgeben
      50. pinMode(esc, OUTPUT);
      51. digitalWrite(esc,HIGH);
      52. delay(100);
      53. digitalWrite(esc,LOW); //ESC - Pfeil links, Display init,
      54. delay(10);
      55. digitalWrite(esc,HIGH);
      56. delay(100);
      57. pinMode(ret, OUTPUT);
      58. digitalWrite(ret,HIGH);
      59. delay(100);
      60. digitalWrite(esc,LOW); //ESC - Pfeil links, Display init,
      61. delay(10);
      62. digitalWrite(esc,HIGH);
      63. delay(100);
      64. pinMode(ab, OUTPUT);
      65. digitalWrite(ab,HIGH);
      66. delay(100);
      67. digitalWrite(esc,LOW); //ESC - Pfeil links, Display init,
      68. delay(10);
      69. digitalWrite(esc,HIGH);
      70. delay(100);
      71. pinMode(auf, OUTPUT);
      72. digitalWrite(auf,HIGH);
      73. delay(100);
      74. digitalWrite(esc,LOW); //ESC - Pfeil links, Display init,
      75. delay(10);
      76. digitalWrite(esc,HIGH);
      77. delay(100);
      78. //3 * ESC - Taste drücken, Display init,
      79. Serial.println("Taste esc gedrueckt");
      80. digitalWrite(esc,LOW); //ESC - Pfeil links, Display init,
      81. delay(10);
      82. digitalWrite(esc,HIGH);
      83. delay(200);
      84. Serial.println("Taste esc gedrueckt");
      85. digitalWrite(esc,LOW); //ESC - Pfeil links, Display init,
      86. delay(10);
      87. digitalWrite(esc,HIGH);
      88. delay(200);
      89. Serial.println("Taste esc gedrueckt");
      90. digitalWrite(esc,LOW); //ESC - Pfeil links, Display init,
      91. delay(10);
      92. digitalWrite(esc,HIGH);
      93. delay(200);
      94. pos = 0; // buffer leer
      95. process_it = false;
      96. wdt_enable(WDTO_8S);
      97. SPI.attachInterrupt();
      98. } // ende von setup
      99. // SPI interrupt routine
      100. ISR (SPI_STC_vect)
      101. {
      102. byte c = SPDR; // byte from SPI Data Register lesen
      103. if (pos == 150)
      104. {
      105. pos = 3;
      106. process_it = false;
      107. Serial.print("pos=150 ");
      108. }
      109. if (c == 2)
      110. {
      111. CCa++;
      112. if (CCa == 1)
      113. pos=0;
      114. if (CCa == 2)
      115. {
      116. SPI.detachInterrupt();
      117. process_it = true;
      118. }
      119. }
      120. if (pos >= 100)
      121. {
      122. process_it = true;
      123. Serial.print("Fall 1 ");
      124. Serial.print("pos ");
      125. Serial.println(pos);
      126. }
      127. if (pos == sizeof buf)
      128. {
      129. process_it = true;
      130. Serial.print("Fall 2 ");
      131. Serial.print("pos ");
      132. Serial.println(pos);
      133. pos = 3;
      134. }
      135. if (pos > sizeof buf)
      136. {
      137. process_it = true;
      138. Serial.print("Fall 3 ");
      139. Serial.print("pos ");
      140. Serial.println(pos);
      141. }
      142. if (pos < sizeof buf)
      143. {
      144. CCNible [pos] = c;
      145. buf [pos++] = c;
      146. }
      147. } // ende von interrupt routine SPI_STC_vect
      Alles anzeigen



      Der 2. Teil , die main loop, vom Arduino Sketch kommt im nächsten Beitrag, sonst wird dieser Abschnitt größer 10kB.


      Gruß und schöne Feiertage
      Jürgen
      Atmos D15P mit A25; LC und Belimo gesteuerte Luftklappe am Ventilator; UVR1611 mit CAN-I/O44 und BL-NET;
      2x1000l Puffer mit 2x10m² VRK und glykolfreie Solarthermie(Ost-West); WW-FWS; PV 3,2kW; Wasserenthärtung
      • 8

      • # 19415
      Hallo Andreas,

      hier kommt die zweite Hälfte:
      Teil 1 und Teil 2 zusammen in eine Arduino-Datei kopieren z.B A25_LOGGER.INO usw.

      Quellcode

      1. // main loop
      2. void loop (void)
      3. {
      4. cms = millis();
      5. if (cms - pms > mszd) //alle 2 Minuten Parameter
      6. {
      7. Serial.println("Warteschleife 2 Minuten Parameter");
      8. A25p = 2; // Parameter
      9. cmd = 0;
      10. pms = cms;
      11. }
      12. if (Serial.available() > 0) //Tasteneingaben
      13. {
      14. incomingByte = Serial.read();
      15. if (incomingByte == 'h')
      16. {
      17. Serial.println("Menü (h)");
      18. Serial.println("i Informationen ");
      19. Serial.println("p Parameter ");
      20. Serial.println("x Remote off ");
      21. Serial.println("z Reset erzwingen ");
      22. Serial.println("e ESC Pfeil nach links ");
      23. Serial.println("r RET Pfeil nach rechts ");
      24. Serial.println("o ESC Pfeil nach oben ");
      25. Serial.println("u ESC Pfeil nach unten ");
      26. A25p = 1;
      27. cmd = 0;
      28. }
      29. if (incomingByte == 'z')
      30. {
      31. delay(9000); //über Watchdog RESET auslösen
      32. }
      33. if (incomingByte == 'i')
      34. {
      35. A25p = 1; // Informationen
      36. cmd = 0;
      37. }
      38. if (incomingByte == 'p')
      39. {
      40. A25p = 2; // Parameter
      41. cmd = 0;
      42. }
      43. if (incomingByte == 'x')
      44. {
      45. A25p = 0; // Remote aus
      46. cmd = 0;
      47. }
      48. if (incomingByte == 'e')
      49. {
      50. //Serial.println("ESC Pfeil links ");
      51. digitalWrite(esc,LOW);
      52. delay(10);
      53. digitalWrite(esc,HIGH);
      54. delay(200);
      55. A25p = 3; // Remote aus
      56. }
      57. if (incomingByte == 'r')
      58. {
      59. //Serial.println("RET Pfeil rechts ");
      60. digitalWrite(ret,LOW);
      61. delay(10);
      62. digitalWrite(ret,HIGH);
      63. delay(200);
      64. A25p = 3; // Remote aus
      65. }
      66. if (incomingByte == 'o')
      67. {
      68. //Serial.println("RET Pfeil oben ");
      69. digitalWrite(auf,LOW);
      70. delay(10);
      71. digitalWrite(auf,HIGH);
      72. delay(200);
      73. A25p = 3; // Remote aus
      74. }
      75. if (incomingByte == 'u')
      76. {
      77. //Serial.println("RET Pfeil ab ");
      78. digitalWrite(ab,LOW);
      79. delay(10);
      80. digitalWrite(ab,HIGH);
      81. delay(200);
      82. A25p = 3; // Remote aus
      83. }
      84. Serial.flush();
      85. } // Ende Serial.available() > 0
      86. schleife++;
      87. wdt_reset();
      88. if (process_it)
      89. {
      90. SPI.detachInterrupt();
      91. schleife = 0;
      92. LCDzeile = "";
      93. for (int i=0; i <= pos; i++) // Anfang Nibble-Schleife
      94. {
      95. byte CCNL1 = CCNible[i];
      96. CCNL1 = CCNL1 << 2;
      97. CCNL1 = CCNL1 >> 4;
      98. i++;
      99. byte CCNH1 = CCNible[i];
      100. CCNH1 = CCNH1 >> 2;
      101. CCNH1 = CCNH1 << 4;
      102. byte CCLCD = CCNH1 | CCNL1;
      103. byte CNIBL = CCNible[i - 1];
      104. byte CNIBH = CCNible[i];
      105. if (CNIBL == 0x84 && CNIBH == 0x98) CCLCD = 0x43; //C
      106. if (CNIBL == 0x84 && CNIBH == 0x84) CCLCD = 0x44; //D
      107. if (CNIBL == 0x84 && CNIBH == 0x94) CCLCD = 0x45; //E
      108. if (CNIBL == 0x84 && CNIBH == 0x8C) CCLCD = 0x46; //F
      109. if (CNIBL == 0x84 && CNIBH == 0x92) CCLCD = 0x49; //I
      110. if (CNIBL == 0x84 && CNIBH == 0x9C) CCLCD = 0x47; //G
      111. if (CNIBL == 0x84 && CNIBH == 0x9A) CCLCD = 0x4B; //K
      112. if (CNIBL == 0x84 && CNIBH == 0x8E) CCLCD = 0x4E; //N
      113. if (CNIBL == 0x84 && CNIBH == 0x9E) CCLCD = 0x4F; //O
      114. if (CNIBL == 0x94 && CNIBH == 0x80) CCLCD = 0x50; //P
      115. if (CNIBL == 0x94 && CNIBH == 0x88) CCLCD = 0x52; //R
      116. if (CNIBL == 0x94 && CNIBH == 0x98) CCLCD = 0x53; //S
      117. if (CNIBL == 0x94 && CNIBH == 0x84) CCLCD = 0x54; //T
      118. //if (CNIBL == 0x9C && CNIBH == 0x94) CCLCD = 0x55; //U
      119. if (CNIBL == 0x94 && CNIBH == 0x8C) CCLCD = 0x56; //V
      120. if (CNIBL == 0x88 && CNIBH == 0x80) CCLCD = 0x20; //space
      121. if (CNIBL == 0x02 && CNIBH == 0x00) CCLCD = 0x20; // cmd zeile1 space
      122. if (CNIBL == 0x06 && CNIBH == 0x00) CCLCD = 0x20; // cmd zeile2 space
      123. if (CNIBL == 0x98 && CNIBH == 0x80) CCLCD = 0x30; //0
      124. if (CNIBL == 0x98 && CNIBH == 0x90) CCLCD = 0x31; //1
      125. if (CNIBL == 0x98 && CNIBH == 0x88) CCLCD = 0x32; //2
      126. if (CNIBL == 0x98 && CNIBH == 0x98) CCLCD = 0x33; //3
      127. if (CNIBL == 0x98 && CNIBH == 0x84) CCLCD = 0x34; //4
      128. if (CNIBL == 0x98 && CNIBH == 0x94) CCLCD = 0x35; //5
      129. if (CNIBL == 0x98 && CNIBH == 0x9C) CCLCD = 0x37; //7
      130. if (CNIBL == 0x98 && CNIBH == 0x82) CCLCD = 0x38; //8
      131. if (CNIBL == 0x98 && CNIBH == 0x92) CCLCD = 0x39; //9
      132. if (CNIBL == 0x88 && CNIBH == 0x9E) CCLCD = 0x2F; // /
      133. if (CNIBL == 0x88 && CNIBH == 0x86) CCLCD = 0x2C; //,
      134. if (CNIBL == 0x98 && CNIBH == 0x8A) CCLCD = 0x3A; //:
      135. if (CNIBL == 0x88 && CNIBH == 0x94) CCLCD = 0x25; //%
      136. if (CNIBL == 0x88 && CNIBH == 0x9A) CCLCD = 0x2B; //+
      137. if (CNIBL == 0x88 && CNIBH == 0x96) CCLCD = 0x2D; //-
      138. if (CNIBL == 0x80 && CNIBH == 0x90) CCLCD = 0x2A; // *
      139. //if (CNIBL == 0x80 && CNIBH == 0x80) CCLCD = 0xB0; // Grad
      140. if (CNIBL == 0x80 && CNIBH == 0x80) CCLCD = 0x20; // Grad als space
      141. if (CNIBL == 0x8C && CNIBH == 0x90) CCLCD = 0x61; //a
      142. if (CNIBL == 0x8C && CNIBH == 0x88) CCLCD = 0x62; //b
      143. if (CNIBL == 0x8C && CNIBH == 0x84) CCLCD = 0x64; //d
      144. if (CNIBL == 0x8C && CNIBH == 0x94) CCLCD = 0x65; //e
      145. if (CNIBL == 0x8C && CNIBH == 0x8C) CCLCD = 0x66; //f
      146. if (CNIBL == 0x8C && CNIBH == 0x9C) CCLCD = 0x67; //g
      147. if (CNIBL == 0x8C && CNIBH == 0x82) CCLCD = 0x68; //h
      148. if (CNIBL == 0x8C && CNIBH == 0x92) CCLCD = 0x69; //i
      149. if (CNIBL == 0x8C && CNIBH == 0x9A) CCLCD = 0x6B; //k
      150. if (CNIBL == 0x8C && CNIBH == 0x86) CCLCD = 0x6C; //l
      151. if (CNIBL == 0x8C && CNIBH == 0x96) CCLCD = 0x6D; //m
      152. if (CNIBL == 0x8C && CNIBH == 0x8E) CCLCD = 0x6E; //n
      153. if (CNIBL == 0x8C && CNIBH == 0x9E) CCLCD = 0x6F; //o
      154. if (CNIBL == 0x9C && CNIBH == 0x80) CCLCD = 0x70; //p
      155. if (CNIBL == 0x9C && CNIBH == 0x88) CCLCD = 0x72; //r
      156. if (CNIBL == 0x9C && CNIBH == 0x98) CCLCD = 0x73; //s
      157. if (CNIBL == 0x9C && CNIBH == 0x84) CCLCD = 0x74; //t
      158. if (CNIBL == 0x9C && CNIBH == 0x94) CCLCD = 0x75; //u
      159. if (CNIBL == 0x9C && CNIBH == 0x8C) CCLCD = 0x76; //v
      160. if (CNIBL == 0x9C && CNIBH == 0x8A) CCLCD = 0x7A; //z
      161. if (CNIBL == 0x88 && CNIBH == 0x8E) CCLCD = 0x2E; //.
      162. LCDz[iz] = CCLCD;
      163. iz++;
      164. } // Ende Nibble-Schleife
      165. buf [pos] = 0;
      166. pos = 0;
      167. process_it = false;
      168. for (int i=1; i <= 34; i++) // Anfang LCD-Zeile-Schleife
      169. {
      170. if (i == 17) i++;
      171. LCDzeile = String(LCDzeile + LCDz[i]);
      172. } // Ende LCD-Zeile-Schleife
      173. if (A25p >= 1) // 2* Statuszeile am Anfang
      174. {
      175. Serial.print(LCDzeile);
      176. Serial.println(" ");
      177. }
      178. if (A25p == 3) // delay
      179. {
      180. delay(500);
      181. }
      182. f_start = LCDzeile.indexOf("START");
      183. if (f_start >= 0) pdauer = 500;
      184. f_an = LCDzeile.indexOf("AN");
      185. if (f_an >= 0) pdauer = 5000;
      186. f_aus = LCDzeile.indexOf("AUS");
      187. if (f_aus >= 0) pdauer = 6900;
      188. f_start = -1;
      189. f_an = -1;
      190. f_aus = -1;
      191. iz = 0;
      192. LCDzeile = "";
      193. CCa = 0;
      194. if (cmd < 2) delay(200);
      195. if (cmd >= 2 && A25p == 1) // 2* Statuszeile am Anfang Informationen
      196. {
      197. SPI.detachInterrupt();
      198. digitalWrite(info[cmd-2],LOW);
      199. delay(20);
      200. digitalWrite(info[cmd-2],HIGH);
      201. delay(200);
      202. if (cmd == 13)
      203. {
      204. cmd = 0;
      205. //4 * ESC - Taste drücken, Display init,
      206. Serial.println("ESC Pfeil links 3* ");
      207. digitalWrite(esc,LOW);
      208. delay(10);
      209. digitalWrite(esc,HIGH);
      210. delay(200);
      211. //Serial.println("ESC Pfeil links ");
      212. digitalWrite(esc,LOW);
      213. delay(10);
      214. digitalWrite(esc,HIGH);
      215. delay(200);
      216. //Serial.println("ESC Pfeil links ");
      217. digitalWrite(esc,LOW);
      218. delay(10);
      219. digitalWrite(esc,HIGH);
      220. delay(200);
      221. //Serial.println("ESC Pfeil links ");
      222. digitalWrite(esc,LOW);
      223. delay(10);
      224. digitalWrite(esc,HIGH);
      225. delay(pdauer);
      226. } // Ende cmd == 13
      227. } // cmd >= 2 && A25p = 1
      228. if (cmd >= 2 && A25p == 2) // 2* Statuszeile am Anfang Parameter
      229. {
      230. SPI.detachInterrupt();
      231. digitalWrite(para[cmd-2],LOW);
      232. delay(20);
      233. digitalWrite(para[cmd-2],HIGH);
      234. delay(200);
      235. if (cmd == 30)
      236. {
      237. cmd = 0;
      238. //4 * ESC - Taste drücken, Display init,
      239. Serial.println("ESC Pfeil links 3* ");
      240. digitalWrite(esc,LOW);
      241. delay(10);
      242. digitalWrite(esc,HIGH);
      243. delay(200);
      244. //Serial.println("ESC Pfeil links ");
      245. digitalWrite(esc,LOW);
      246. delay(10);
      247. digitalWrite(esc,HIGH);
      248. delay(200);
      249. //Serial.println("ESC Pfeil links ");
      250. digitalWrite(esc,LOW);
      251. delay(10);
      252. digitalWrite(esc,HIGH);
      253. delay(200);
      254. //Serial.println("ESC Pfeil links ");
      255. digitalWrite(esc,LOW);
      256. delay(10);
      257. digitalWrite(esc,HIGH);
      258. delay(pdauer);
      259. A25p = 1; //zurückschalten Informationen
      260. cmd = 0;
      261. } //Ende cmd == 30
      262. } // cmd >= 2 && A25p = 2
      263. cmd++;
      264. SPI.attachInterrupt();
      265. } // end of process_it
      266. } // end of loop
      Alles anzeigen




      Gruß und schöne Feiertage
      Jürgen
      Atmos D15P mit A25; LC und Belimo gesteuerte Luftklappe am Ventilator; UVR1611 mit CAN-I/O44 und BL-NET;
      2x1000l Puffer mit 2x10m² VRK und glykolfreie Solarthermie(Ost-West); WW-FWS; PV 3,2kW; Wasserenthärtung
      • 9

      • # 19741
      Hallo liebe Leute,

      ergänzender Hinweis:

      Kann so nur bei A25-Brennern vor 2012 realisiert werden.
      Ab 2012 gibt es an der Stelle des Display-Konnektor (14pol.)
      einen RS485- (J1, oben, 3polig) und unterhalb einen Display-
      Konnektor (J7, 4 polig).
      Lt. Handbuch ist der 4pol. Anschluss (+5V,A,B,Masse) für das
      Externdisplay AC06B gedacht.
      Zu dem AC06B habe ich in keinem Forum etwas finden können.
      Bzgl. RS485 soll es von Atoms die Aussage geben, daß diese
      nur zu Updatezwecken sein soll.....
      So ich es verstehe werden die genannten Schnittstellen weder
      von Heizungsreglern noch vom ATMOS-GSM-Modul genutzt.

      Anmerkung:
      Evtl. muss man die beiden Schnittstellen andersrum sehen.
      Die 3plige könnte typisch "SPI" und die 4polige typisch
      "RS485" sein....

      Gruß
      Volker

      Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von ernie01 ()

      • 10

      • # 119928
      Hallo Jürgen,

      da ich einen A25-Brenner aus nach 2012 habe, wäre für mich deine "Erstlösung" (Anschluß am Display) interessant.
      Ist es möglich, von dir die zugehörigen Programme zu bekommen ?

      Gruß
      Volker
      • 11

      • # 120049
      Hallo Volker,

      was hast Du mit den ausgelesenen Brennerdaten vor?
      Mit der "Erstlösung" (Anschluß am Display) kannst ja nur eine Zeile (die aktuell angezeigte) Zeile auslesen.
      Mein A25-Brenner ist die Version vor 2012, also alte Version.

      Aus dieser Brennerdaten-Zeile konnte ich in der "Erstlösung" den Brennerstatus verwenden (AUS,START,AN),
      TS und TV Temperaturen und die Sternchen.

      Ich kenne allerdings nicht die Anzeigen der A25-Brenner Version nach 2012, also neue Version.
      Diese Anzeigen würden mich auch interessieren.
      Denn mit der neuen A25-Brenner Version nach 2012 stehen soweit ich der Doku entnehmen kann, mehr Parameter
      zum Einstellen und mehr Anschlüsse und auch warscheinlich mehr Statusanzeigen zur Verfügung.

      Vielleicht kannst du diese Anzeigen zur Verfügung stellen,
      damit die Nutzer der alten A25-Brenner Version vor 2012 auch sehen können, was im neuen Brenner mehr drin steckt.

      Wenn den Arduino-Sketch von der neuen Version (SPI-Displaydaten seriell) als Vorlage verwenden willst,
      dann ist die Änderung zum Display-Code "Erstlösung" (Anschluß am Display) sehr gering.

      In der Nible-Schleife müssen nur die beiden Nibles (Halb-Bytes) etwas anders zusammengesetzt werden,
      dann hast direkt den Ascii-Code.

      byte CCNH1 = CCNible;
      i++;
      byte CCNL1 = CCNible[i];
      CCNH1 = CCNH1 << 4;
      byte CCLCD = CCNH1 | CCNL1;

      im byte CCLCD steht der Ascii-Code drin, also kein großes Hexenwerk.

      Welchen Arduino willst Du dafür verwenden? Es gibt ja sehr viele Modelle.
      Wie willst die Daten vom Arduino weiter verarbeiten?

      Gruß
      Jürgen
      Atmos D15P mit A25; LC und Belimo gesteuerte Luftklappe am Ventilator; UVR1611 mit CAN-I/O44 und BL-NET;
      2x1000l Puffer mit 2x10m² VRK und glykolfreie Solarthermie(Ost-West); WW-FWS; PV 3,2kW; Wasserenthärtung
      • 12

      • # 120087
      Hallo Jürgen,

      vielen Dank für deine Rückmeldung.

      Bisher dachte ich, die Anzeigen alter/neuer A25 sind identisch. So sieht es jedenfalls auf den ersten Blick aus....
      Mehr Statusanzeigen ? Ich meine nicht. Muss ich mal genauer hinsehen....
      Benötige die Temperaturen, sowie AN/AUS für die Weiterverarbeitung (Informativ) mit einem Raspi 3.
      Arduino wäre jede Lösung recht...

      D.h. du kannst mit deiner Lösung letztlich aber beide Zeilen auslesen ? Dann sollte es für mich passen.
      Leider sind die Schnittstellen beim "neuen" anders (SPI / RS485 !?). Die 3polige (SPI ?) hat keine Pin-
      Beschriftung.

      P.S: Nun bin ich doch ein wenig verwirrt. Dein SPI-Sketch soll auch für die Erstlösung am Display passen !?
      Da sind aber doch andere Anschlüsse (u.a. 4x Datenleitungen DB)....

      Gruß
      Volker

      Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von ernie01 ()

      • 13

      • # 120163
      Hallo Volker,

      also wenn ich mir die beiden Handbücher anschaue,
      dann können die Anzeigen alter/neuer A25 nicht identisch sein.

      neu A25-Version nach 2012
      Zugängliche Parameter nach Berechtigung:
      Kunde: T1, T4, T6, S16, S17, S18, S19, Neustart, Sprache
      Service-Techniker: T1,T2, T4, T5, T6, T7, T8, T10, S1, S2, S3, S6, S11, S12, S13, S14, S15,
      S16, S17, S18, S19, S24, S26, S27, S28, S29, S30, S31, S32, S33, S34, S35,
      S36, S37, S38, S39, S40, S41, S42, S43, S44, S45, S48, S49, S50, S51, S52,
      S53, S54, S55, OffsetTS, OffsetTV, OffsetTK OffsetTSV, Reset, Neustart, Sprache

      alt A25-Version vor 2012
      Zugängliche Parameter nach Berechtigung:
      Kunde: T1, T4, T6, S16, S17, S18, Sprache
      Service-Techniker: T1,T2, T4, T5, T6, T7, T8, T10, S1, S2, S3, S6, S11, S12, S13, S15, S16,
      S17, S18, OffsetTV, OffsetTS, Reset, Sprache

      Ich kenne nicht die Anzeigen der A25-Brenner Version nach 2012, also neue Version.
      Diese Anzeigen würden mich immer noch interessieren.

      Mit der "Erstlösung" (Anschluß am Display) kannst ja nur eine Zeile (die aktuell angezeigte) Zeile auslesen.
      Ja, ich lese auf einmal das ganze Display aus. 2*16 Zeichen, so wie es laut Datenblatt angesteuert wird.
      Es ist erfreulicherweise ein ganz normales 2*16 LCD Display wie es in vielen Geräten zu finden ist.
      Mit dieser Methode könntest natürlich auch andere 2*16 LCD Displays auslesen.

      Ich habe mich zur Weiterverarbeitung der Display-Daten
      für einen Einzeiler 32 Zeichen lang (also beide Zeilen hintereinander) entschieden.

      Mit den (AUS,START,AN) Informationen könntest dir einen Betriebsstundenzähler für den A25-Brenner bauen.
      Die TS und TV Temperaturen könntest aufzeichnen und Diagramme zeichnen
      und damit Einschaltschwelle und Abschaltschwelle der Brennersteuerung prüfen, falls du den Brenner mit TS,TV ein/ausschaltest.

      Mit den Sternchen kannst die Brenn-Dauer der Heizspiralen in der Anheizphase aufzeichnen
      und einen Heizspiralen-Betriebsstundenzähler bauen.

      Mit dem Photozellensternchen kannst Flackern überwachen.. es darf nichts flackern.

      Die erste Aktion am LCD-Display war das Anlöten einer Stiftleiste, damit später eine Steckverbindung
      für den Anschluss des ARDUINO gemacht werden kann und zum Messen brauchte ich auch einen brauchbaren Anschluss.

      so sieht die angelötete Stiftleiste bei mir am LCD-Display aus.



      erster Messaufbau mit Logicanalyser.



      Gruß
      Jürgen
      Atmos D15P mit A25; LC und Belimo gesteuerte Luftklappe am Ventilator; UVR1611 mit CAN-I/O44 und BL-NET;
      2x1000l Puffer mit 2x10m² VRK und glykolfreie Solarthermie(Ost-West); WW-FWS; PV 3,2kW; Wasserenthärtung
      • 14

      • # 120224
      Hallo Volker,

      natürlich sind bei der "Erstlösung" (Anschluß am Display)
      4x Datenleitungen DB4-7 vom LCD-Display am PORTC vom MEGA2560 einzulesen.
      Die Schwierigkeit in diesem Projekt war das decodieren der Daten und das timing.

      Ich kann den letzten Stand vom Arduino Sketch von der "Erstlösung" (Anschluß am Display)
      zur Verfügung stellen.

      Zum Einlesen der Daten vom Arduino zum Raspi kannst entweder den Serial Monitor von der Arduino-IDE
      nehmen oder CuteCom oder irgend ein script das daten von /dev/ttyACM0 mit der speed von 57600 Baud
      einlesen kann. Ich kann auch ein perl script anhängen, das ich damals verwendet hatte.

      LCD_MEGA2560_PortC.ino

      Quellcode

      1. #include <PinChangeInt.h>
      2. #define PIN 53 // interrupt-pin E vom Atmos A25 LCD-Display
      3. byte CCNible[1500];
      4. byte C2Nible[100];
      5. int daktiv =0;
      6. int iper = 0;
      7. int CCx = 0;
      8. int CC2 = 0;
      9. int vfehl = 0;
      10. int vnix = 0;
      11. void setup()
      12. {
      13. Serial.begin(57600);
      14. Serial.println("MEGA2560_PortC_v8 PortC lesen/schreiben 05.04.2015");
      15. // Arduino Mega2560 -> DB4 PIN -> 37 PC0
      16. // Ports Display: -> DB5 PIN -> 36 PC1
      17. // vom Atmos A25 -> DB6 PIN -> 35 PC2
      18. // 2*16 LCD-Display -> DB7 PIN -> 34 PC3
      19. // im 4-Bit-Mode -> RS
      20. // -> RW
      21. // -> E PIN -> 53 PD0 INT0 FALLING RISING CHANGE
      22. pinMode(PIN, INPUT); //set the pin to input
      23. digitalWrite(PIN, HIGH); //use the internal pullup resistor
      24. PCintPort::attachInterrupt(PIN, blink, RISING); // attach a PinChange Interrupt to our pin on the rising edge
      25. DDRC = B00000000; // set PORTC (digital) to inputs
      26. vfehl = 0;
      27. vnix = 0;
      28. daktiv =0;
      29. }
      30. void loop()
      31. {
      32. if (CCx >= 1 && daktiv == 0)
      33. {
      34. //delay(150);
      35. CCx = 0;
      36. iper = 0;
      37. daktiv++;
      38. }
      39. if (CCx >= 1 && daktiv == 1)
      40. {
      41. delay(90);
      42. CCx = 0;
      43. iper = 0;
      44. daktiv++;
      45. }
      46. if (CCx >= 1 && daktiv == 2)
      47. {
      48. delay(60);
      49. CCx = 0;
      50. iper = 0;
      51. daktiv++;
      52. }
      53. if (CCx >= 1 && daktiv == 3)
      54. {
      55. delay(30);
      56. CCx = 0;
      57. iper = 0;
      58. daktiv++;
      59. }
      60. if (CCx >= 1 && daktiv == 4)
      61. {
      62. daktiv =0;
      63. if (CCx > 1400) CCx = 300;
      64. delay(30); // 30ms warten nach letztem interrupt
      65. //array neu=CCNible alt=C2Nible sind beide arrays gleich?
      66. CC2 = 67;
      67. for (int i=0; i <= CC2; i++)
      68. {
      69. if(CCNible[i] != C2Nible[i]) vfehl++;
      70. }
      71. CC2 = 68;
      72. if (vfehl > 0)
      73. {
      74. vfehl = 0;
      75. vnix = 0;
      76. //array kopieren
      77. for (int i=0; i <= CC2; i++)
      78. {
      79. C2Nible[i] = CCNible[i];
      80. }
      81. //Serial.print(" LCD Anzeige Änderung festgestellt: CCx= ");
      82. CCx = 0;
      83. //Ausgabe ASCII-Zeile
      84. for (int i=0; i <= CC2; i++)
      85. {
      86. byte CCNH1 = C2Nible[i];
      87. i++;
      88. byte CCNL1 = C2Nible[i];
      89. CCNH1 = CCNH1 << 4;
      90. byte CCLCD = CCNH1 | CCNL1;
      91. if (CCLCD == 192) CCLCD = 45;
      92. if (CCLCD == 1) CCLCD = 42;
      93. if (CCLCD > 126) CCLCD = 32;
      94. if (CCLCD < 32) CCLCD = 32;
      95. Serial.write(CCLCD);
      96. //Serial.print("-");
      97. }
      98. Serial.println(" ");
      99. iper = 0;
      100. } //ende vfehl>0
      101. else // vfehl=0
      102. {
      103. vnix++;
      104. if (vnix > 10)
      105. {
      106. //Serial.print(" 10x unverändert CCx= ");
      107. iper = 0;
      108. vnix =0;
      109. }
      110. CCx = 0;
      111. } //ende vfehl=0
      112. } // ende CC2 > 0
      113. } //ende void loop()
      114. void blink()
      115. {
      116. byte wertC = PINC;
      117. CCNible[CCx] = wertC;
      118. CCx++;
      119. iper++;
      120. }
      Alles anzeigen


      a25_lcd_mega2560.pl

      Perl-Quellcode

      1. #!/usr/bin/perl
      2. #
      3. print "a25_lcd_mega2560 vom 06.04.2015 \n";
      4. ($sec,$min,$hour,$mday,$mon,$year,$wday,$ydat,$isdst)=localtime();
      5. $jahr=$year;
      6. $monat=$mon+1;
      7. $tag=$mday;
      8. $jahr=$year;
      9. $jahr=$year +1900;
      10. if (length($monat) == 1) { $monat="0$monat"; }
      11. if(length($tag) == 1) { $tag="0$tag"; }
      12. if(length($hour) == 1) { $hour="0$hour"; }
      13. if(length($min) == 1) { $min="0$min"; }
      14. if(length($sec) == 1) { $sec="0$sec"; }
      15. $Xdatum=$tag.".".$monat.".".$jahr;
      16. $Xzeit=$hour.":".$min.":".$sec;
      17. @Tzeit[$is]=$Xzeit;
      18. $fname=">>a25_lcd_".$tag.$monat.$jahr;
      19. $is=0;
      20. open(SESAM, "< /dev/ttyACM0") || die "Eingabedatei /dev/ttyACM0 konnte nicht geöffnet werden";
      21. while ($Zeilen =<SESAM>)
      22. {
      23. @ka_zeile[$is] = $Zeilen;
      24. $is++;
      25. if ( $is > 10 )
      26. {
      27. open(SESAM2, $fname) || die "Ausgabedatei konnte nicht geöffnet werden";
      28. for($i=0; $i < $is; $i++)
      29. {
      30. printf SESAM2 @ka_zeile[$i];
      31. print @ka_zeile[$i];
      32. }
      33. close(SESAM2);
      34. $is=0;
      35. }
      36. }
      37. close(SESAM);
      38. print (" ende /dev/ttyACM0 lesen \n");
      Alles anzeigen


      Steckverbindung vom A25-Brenner LCD-Display zum Arduino und USB-Verbindung zum Raspi



      Gruß
      Jürgen
      Atmos D15P mit A25; LC und Belimo gesteuerte Luftklappe am Ventilator; UVR1611 mit CAN-I/O44 und BL-NET;
      2x1000l Puffer mit 2x10m² VRK und glykolfreie Solarthermie(Ost-West); WW-FWS; PV 3,2kW; Wasserenthärtung
      • 15

      • # 120459
      Hallo Jürgen,

      andere/mehr parameter am "neuen" A25 kann ich mir schon vorstellen.
      Aber andere Anzeigen ?

      Mein Display hat in der unteren Zeile die Möglichkeit zur Anzeige von 7 Sternen.
      Ansonsten wechseln in der oberen Zeile nacheinander die Temperaturanzeigen...
      AN, AUS, START, STOP, TV, TS, TSK.....
      Sieht für mich eher so aus, als dass es da keine Anzeigeunterschiede gibt.
      Evtl. Fehlermeldungen, die ich aber bisher (Klopf-Klopf) nicht hatte...

      Gruß
      Volker
      • 16

      • # 122964
      Hallo Jürgen,

      vielen Dank für Deine Unterstützung und die Programme.
      Nun mache ich meine ersten Gehversuche mit einem Arduino Mega 2560 und der IDE 1.7.11(wg. dem Ethernet-Shield 2). Diverse Testprogramme (inkl. Webserver) funktionieren...

      Problem: Es scheitert aktuell noch an dem PinChange-Thema in dem Sketch von Dir !
      Hier hast du vermutlich eine bestimmte Bibliothek benutzt ?
      Mit der "mitgelieferten" von Arduino "PinChangeInterrupt" funktioniert das Kompilieren
      erst garnicht....

      Nun ist Jugend-forscht gefragt...

      EDIT: Hab ein Beispiel "PinChangeInterrupt -How it Works" in der IDE gefunden und versuche Deinen Sketch da mal anzupassen

      EDIT: Hab eine aktuelle der von Dir genutzten Bibliothek gefunden.
      Nun funktioniert das Kompilieren, Hochladen und ein Test mit
      PIN53.
      Im nächsten Schritt hänge ich den Arduino mutig an den A25...

      Gruß
      Volker

      Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von ernie01 ()

      • 17

      • # 123169
      Hallo Jürgen,

      mit dem Lötkolben schnell mal an den A25...., dann den Arduino mit Sketch dran...

      Funktioniert !

      Kann nun über den "Seriellen Monitor" der Arduino-IDE beide Zeilen des A25 auslesen...
      Nun noch die vier Tasten ran bekommen und der ältere Herr muss nicht mehr
      so oft in den Heizkeller laufen....

      Letztlich möchte ich sämtliche Daten in einer eigenen Heizungssteuerung/Heizungs-
      regelung zusammenführen und auf einer Webpage darstellen...

      Nochmal vielen Dank für deine sehr gute Arbeit und deine Unterstützung.

      Gruß
      Volker
      • 18

      • # 123245
      Hallo Volker,

      sehr schön, das Durchhalten und Dranbleiben hat sich gelohnt, Gratulation.
      Die vier Tasten bekommst du sicher auch noch dran.

      Wenn sämtliche Daten in deiner eigenen Heizungssteuerung/Heizungs-
      regelung zusammengefüht hast und auf einer Webpage darstellen konntest,
      würde ich mich auch für deine Lösung der Weiterverarbeitung der A25-Brennerdaten interessieren,
      man lernt immer wieder dazu.

      Gruß
      Jürgen
      Atmos D15P mit A25; LC und Belimo gesteuerte Luftklappe am Ventilator; UVR1611 mit CAN-I/O44 und BL-NET;
      2x1000l Puffer mit 2x10m² VRK und glykolfreie Solarthermie(Ost-West); WW-FWS; PV 3,2kW; Wasserenthärtung
      • 19

      • # 123270
      Vielleicht könnte man die Regelung des A25 sogar anpassen. Also wenn die Kiste im Normalbetrieb läuft, geht alles gut. Aber ich glaube, das Startverhalten ist alles andere als optimal. Wenn die Kiste anläuft, also kurz nachdem die Flamme registriert wird, wird ja relativ bald schon gefördert. Die Regelung hat zwar eine Art Anlauf, so dass die Leistung, wie es in der Anleitung steht, gesteigert wird, bis der normale Förder-Pausen-Zyklus erreicht ist. Schaue ich mir die Flamme an, wenn der Kessel soweit hochgefahren ist, dass er anfängt, den Puffer zu laden, rust die Flamme erst einmal ziemlich, weil die Brennerschale ziemlich voll ist. Nach einigen Minuten hat sich das ganze normalisiert. Aber wenn der Startvorgang so optimiert werden könnte, dass die Flamme auch da immer die richtige Menge an Sauerstoff oder die richtige Menge nachgefördert wird, wäre das schön. Aber wäre das eigentlich Aufgabe einer Lambdaregelung?
      Viele Grüße
      Thomas

      Atmos P14/130 mit A25, Selbstbaupressluftreinigung und Laddomat, 850 l Puffer, Regelung mit UVR 63-H und ESR 21R + DK Flame Domo (Kaminofen) im Wohnzimmer.

      :lager:
      • 20

      • # 123273
      Hallo,

      das mit der Lambdaregelung ist so eine Sache. Bei Fallschachtbrennern eigentlich nicht zu realisieren, weil die Sonde immer erst auf was Gewesenes reagieren kann.
      Auch ist die Schneckenförderung nicht gleichmäßig.
      Die werkseitig mit Lambdasteuerung ausgestatteten Brenner haben alle eine Seiteneinschub-bzw. Unterschubfeuerung. Da läuft die Verbrennung wesentlich ruhiger und berechenbarer ab.

      Gruß, Michael
      Pelletskessel Ecolyzer Nennleistung 16 KW (vorm. Atmos D15 + Brötje Ölkessel), 800 ltr. Pufferspeicher von Solarbayer, 140 ltr. WW Speicher, 80 ltr. E-Speicher von Stiebel Eltron,
      Heizungsregelung KMS von OEG, LC zwecks visueller Verbrennungsüberwachung. Hydraulisch abgeglichene Heizungsanlage. Pumpe: Wilo stratos pico 25/1-4
      • 21

      • # 123591
      Hallo werte Herren,

      hier kommen wir wohl vom Thema ab.....
      Das Thema-Lambda-Regelung ist des Aufwandes sicherlich zu viel (mechanisch). Mir genügt die Lambda-Messung zur Info/Brennereinstellung völlig.
      Ein größeres Problem aktuell bei den Atmos-Pelletern ist das Feinstaubproblem (Aktueller Grenzwert). Meiner kann den Grenzwert (zumindest ohne
      Partikelfilter) nicht einhalten. Menno, nun fange ich schon selber an...

      Mir geht es darum ALLE Daten zur Heizung übersichtlich auf EINER Steuerung mit einer Webseite im Zugriff zu haben.
      Hierbei bin ich u.a. auf "smarthouse.com" (myscada) gelandet. Läuft auf dem Raspi mit allen möglichen Kommunikationswegen...(z. Zt. im Test bei mir)
      Auch auf "proview.se", "CoDeSys" u.s.w. habe ich u.a. mal reingeschaut...

      So ich was vorzeigbares habe, stelle ich es hier gern vor...

      Gruß
      Volker
      • 22

      • # 124854
      Hallo Jürgen,

      evtl. liest du hier ja noch....

      Beim Einsatz deiner Lösung habe ich folgendes Problem. Sh. Bild
      Alle paar Zeilen werden umplausible Daten ausgegeben.
      (H E5b #4< meistens aber 32( )

      Hast du evtl. eine Erklärung dafür ?

      Bildschirmfoto 2016-12-11 um 13.15.16.png

      Während der Kessel in Betrieb ist, wird mir nur die erste Zeile angezeigt (z.B. "AN TV 78 C-"). Die zweite Zeile mit den wechselnden Sternen
      (3 oder 4 Stück) wird nicht angezeigt (Bestätigt durch Auslesen der Zahlenwerte statt Darstellung ASCII-Code).

      Betätige ich die Menütasten, so werden immer beide Zeilen ausgegeben (z.B. Photozelle 0%).

      Vermutung: Sterne im Display werden nicht erkannt/ausgewertet....

      Dieser Beitrag wurde bereits 6 mal editiert, zuletzt von ernie01 ()

      • 23

      • # 124871
      Hallo Volker,

      zum Tracen und um mehr Informationen an verschiedenen Stellen im Sketch zu bekommen verwende ich
      zusätzliche Serial.print zum Anschauen zusätzlicher Daten. Das geht natürlich aufs timing und verfälscht etwas
      den Ablauf, deshalb wenn nicht mehr benötigt..auskommentieren oder im Sketch wieder entfernen.

      Du könntest vor die Ausgabe der ASCII-Zeile eine Hex-Zeile ausgeben dann siehst alle Zeichen im HEX-Code
      und kannst damit besser herausfinden, welche Zeichen nicht ausgegeben werden sollen.

      Also vor die //Ausgabe ASCII-Zeile eine Schleife zur Ausgabe der Display-Zeilen im Hex-Code einfügen.

      //Ausgabe HEX-Zeile
      for (int i=0; i <= CC2; i++)
      {
      byte CCNH1 = C2Nible;
      i++;
      byte CCNL1 = C2Nible[i];
      CCNH1 = CCNH1 << 4;
      byte CCLCD = CCNH1 | CCNL1;
      Serial.print(CCLCD, HEX);
      Serial.print("-");
      }
      Serial.println(" ");

      Für das Ausblenden (Filter) von Zeichen die nicht ausgegeben werden sind die beiden if-Zeilen in der ASCII-Zeilenschleife zuständig.
      if (CCLCD > 126) CCLCD = 32;
      if (CCLCD < 32) CCLCD = 32;

      Da werden die nicht gewünschten Zeichen in SPACE (ascii-code = 32) ausgegeben.
      An diesem Filter würde ich zuerst ansetzten.

      Mit Hilfe einer Ascii-Tabelle kannst dann prüfen, ob der hex-code darstellbare Zeichen sind,
      oder Zeichen sind, die nicht dargestellt werden können und mit Filter ausgeblendet werden müssen.

      Gruß
      Jürgen
      Atmos D15P mit A25; LC und Belimo gesteuerte Luftklappe am Ventilator; UVR1611 mit CAN-I/O44 und BL-NET;
      2x1000l Puffer mit 2x10m² VRK und glykolfreie Solarthermie(Ost-West); WW-FWS; PV 3,2kW; Wasserenthärtung
      • 24

      • # 125494
      Meister, das wird....

      Hier der erste Versuch der Ausgabe in einem Webbrowser (HTML).
      So können beliebige PC, Tablet, Handys genutzt werden.

      Den Arduino habe ich um eine Netzwerkkarte und den Sketch mit einem
      Webserver erweitert.
      Die 4 Bedientasten habe ich zwischenzeitlich auch "ausgeknobelt", aber
      alles braucht seine Zeit....
      Für die Kommunikation zu weiteren Systemen werkel ich an einer Modus TCP-
      Schnittstelle....


      Bildschirmfoto 2016-12-18 um 18.46.14.png

      Gruß Volker

    Webutation