Thermoelement-Spannungswächter für Warmwasserbereiter

Über dieses Projekt

Überwachungssystem für Warmwasserbereiter-Kontrollleuchten

Herkömmliche Gas-Warmwasserbereiter unterhalten eine Kontrolllampe rund um die Uhr. Diese Kontrolllampe erhitzt ein Thermoelement, das eine kleine Spannung (bis zu 30 Millivolt) erzeugt. Diese Spannung wird vom Warmwasser-Heizungsthermostat verwendet, um ein Gasventil offen zu halten. Wenn die Kontrolllampe erlischt, stoppt die Spannung und das Gasventil wird automatisch geschlossen.

Bei meinem Warmwasserbereiter geht die Kontrolllampe gelegentlich aus. Da dies nur ca. 3 mal im Jahr vorkommt, möchte ich den teuren Warmwasserbereiter nicht ersetzen. Ich habe versucht, das Thermoelement zu ersetzen, aber das hat das Problem nicht gelöst.

Meine Lösung:Überwachen Sie die vom Thermoelement erzeugte Spannung. Wenn es auf Null fällt, senden Sie SMS und E-Mails, damit ich die Kontrolllampe wieder anzünden kann. Denken Sie daran, dass hier keine Gefahr eines Gaslecks besteht, da das Gasventil geschlossen wird, wenn die Thermoelementspannung auf Null sinkt.

Übersicht

Ein Raspberry Pi Zero WH wird verwendet, um E-Mails und Texte zu senden, wenn die Kontrollleuchte erlischt. Da der Raspberry Pi keine Möglichkeit zur Spannungsmessung hat, wird ein Arduino Nano verwendet, um die Spannung vom Thermoelement zu überwachen.

Arduinos haben Analog-Digital-Wandler (ADCs), die eine Spannung lesen und in eine Zahl zwischen 0 und 1023 umwandeln können. In diesem Projekt liest der Arduino die Spannung vom Thermoelement und übermittelt diesen Wert an den Raspberry Pi. Der Raspberry Pi empfängt den Spannungswert und interpretiert ihn. Wenn der Wert zu niedrig ist, gehen wir davon aus, dass die Kontrolllampe erloschen ist und senden Benachrichtigungen.

Schritt 1:Bereiten Sie Ihren Raspberry Pi vor

Bringen Sie den Raspberry Pi in Ihrem Netzwerk zum Laufen (Sie können mein anderes Projekt für Anweisungen dazu überprüfen).

Erstellen Sie ein Python-Programm, das Spannungswerte vom Arduino empfängt. Das Programm durchläuft eine Schleife und sendet Benachrichtigungen, wenn der Spannungswert zu niedrig ist. Quellcode ist beigefügt.

Schritt 2:Bereiten Sie Ihr Arduino vor

Ich habe billige chinesische Arduino Nanos gekauft, daher brauchte ich einige Versuche, um diese mit meinem Windows 10-Computer zum Laufen zu bringen.

Laden Sie den Arduino mit einer Skizze, um alle 30 Sekunden die Spannung an seinem Eingangspin zu messen. Der Arduino kann Spannungen zwischen 0 und einer Referenzspannung messen. Als Referenzspannung kann man 1,1V oder 5V wählen. Da das Thermoelement nur maximal 30 Millivolt ausgibt, verwenden wir die 1,1 V Referenzspannung für eine höhere Auflösung. Der Arduino ADC gibt 0 für 0 V und 1023 für 1,1 V aus. Wie bereits erwähnt, gibt das Thermoelement maximal 30 Millivolt aus, sodass der Messwert 28 oder weniger beträgt.

Schritt 3:Verbinden Sie das Arduino mit der Spannungsquelle

Das Thermoelement sendet über ein Koaxialkabel Spannung an den Warmwasserbereiter-Thermostat. Die Außenseite des Drahtes ist positiv.

Schneiden Sie den Draht etwa 5 Zoll vom Warmwasser-Heizungsthermostat entfernt ab. Schneiden Sie die Außenseite des Koaxialkabels etwas zurück, damit das mittlere Kabel zugänglich ist. Zerstören Sie nicht die Isolierung auf dem mittleren Draht. Wir möchten nicht, dass der mittlere Draht zur Außenseite des Koaxialdrahts kurzgeschlossen wird.

Verbinden Sie das Kabel so, dass es die positive Spannung an den Warmwasserbereiter-Thermostat und an den Arduino-Eingangsstift liefert. Ich habe den Eingangspin A0 verwendet. Die negative Seite der Spannungsquelle sollte mit der Masse des Arduino verbunden werden, sowie die negative Seite des Warmwasserbereiter-Thermostats.

Ich habe 1 Fuß lange Drähte mit Krokodilklemmen an den Enden verwendet, um die Verbindungen herzustellen.

Schritt 4:Verbinden Sie den Arduino mit dem Raspberry Pi

Unser auf dem Arduino ausgeführter Sketch überträgt die Spannungsnummer vom ADC zum Raspberry Pi. Der Arduino sendet das Signal als Ausgang von seinem digitalen Pin 9.

Arduinos senden Signale bei +5V. Der Raspberry Pi kann nur einen 3V-Eingang empfangen. Daher muss zwischen Arduino und Raspberry Pi ein Spannungsteiler vorhanden sein. Dadurch wird die Spannung von 5 V auf etwa 2,8 V reduziert.

Ein Spannungsteiler ist ein System von Widerständen, die die Eingangsspannung reduzieren.

Die Ausgangsspannung wird durch die Spannungsteilerbeziehung bestimmt.

Man kann nicht einen einzelnen Widerstand verwenden, um die Spannung zu reduzieren, da, wenn kein Strom fließt, die Spannung auf beiden Seiten des Widerstands Vin (5 V) beträgt. Die Verwendung eines Spannungsteilers reduziert die Spannung auch im stromlosen Zustand.

Die Erdungsdrähte von allem müssen angeschlossen werden. Siehe Anschlussplan.

Schritt 5:Arduino überträgt die Spannungsmessung

Alle 30 Sekunden erhält die Arduino-Skizze die Spannungsmessung vom ADC und überträgt die Nummer an den Raspberry Pi. Ich entschied mich, ein primitives Single-Wire-Signalsystem von Arduino Pin 9 bis Raspberry Pi Pin 16 zu verwenden.

Schritt 6:Raspberry Pi empfängt die Spannungsmessung

Der Raspberry Pi verwendet ein Python-Programm mit einer Endlosschleife, um auf steigende Flanken an Pin 16 zu hören. Wenn eine steigende Flanke erkannt wird, wird davon ausgegangen, dass das Arduino mit der Übertragung einer Zahl begonnen hat.

Signalsystem
Übermitteln Sie eine zweistellige Zahl (zB:"12"). Jeder Ziffer geht ein positiver Impuls voraus, der an Pin 16 empfangen wird. Nachfolgende positive Impulse, die um weniger als 20 Millisekunden (ms) getrennt sind, erhöhen den Wert dieser Ziffer. Eine Pause von mehr als 40 ms zeigt an, dass diese Ziffer abgeschlossen ist und die nächste Ziffer beginnt. Eine weitere Pause über 40 ms zeigt an, dass die zweite Ziffer vollständig ist. Die gesamte zweistellige Zahl ist nun vollständig.

Im Python-Code, der auf dem Raspberry Pi läuft, wird die vom Arduino empfangene Nummer von der Methode zurückgegeben, die die Signale vom Arduino interpretiert. Anderer Python-Code entscheidet, ob eine Benachrichtigung gesendet werden muss oder nicht. Dann kehrt der Code zum Warten auf die nächste steigende Flanke an Pin 16 zurück.

Schritt 7:Senden Sie die Benachrichtigung

Wenn die Spannung zu niedrig ist, erhöhen Sie den niedrigen Zählerstand. Ein niedriger Zählwert wird beibehalten, um Fehlalarme zu vermeiden. Wenn der niedrige Zählerstand 5 erreicht, war die Spannung seit 5 Messungen niedrig. Jede Messung ist 30 Sekunden auseinander. Senden Sie die Benachrichtigung und setzen Sie den niedrigen Zählerstand zurück. Benachrichtigungen werden mit smtplib und einem Gmail-Konto gesendet. Beim Senden der Benachrichtigung wird ein Zeitstempel im Python-Code gespeichert. Die nächste Benachrichtigung wird 6 Stunden lang nicht gesendet.

Um SMS-Benachrichtigungen zu senden, habe ich eine Funktion verwendet, die die meisten Mobilfunkanbieter bieten:die Möglichkeit, ihren Benutzern eine SMS zu senden. Beispiel:für Verizon:[email protected] sendet eine SMS an diese Nummer.

Gmail
Ich habe ein neues Gmail-Konto erstellt, um die Benachrichtigungen zu senden. Zuerst habe ich die Sicherheitseinstellungen für dieses Gmail-Konto so konfiguriert, dass der Zugriff „weniger sicher“ ist, damit der Python-Code E-Mails senden kann. Nach einigen Monaten kann Gmail diesen weniger sicheren Zugriff jedoch deaktivieren. Ich habe festgestellt, dass Google Mail es vorzieht, dass Nutzer App-Passwörter verwenden.

App-Passwort einrichten
https://support.google.com/accounts/answer/185833

Schritt 8:Alles verbinden

Verbinden Sie den Arduino mit dem Thermoelementdraht der Warmwasserheizung und über den Spannungsteiler mit dem Raspberry Pi. (Der obere Teil meines Spannungsteilers verwendet zwei Widerstände mit insgesamt 550 Ohm - weil das die Widerstände sind, die ich zur Hand hatte.) Schalten Sie das Arduino ein und es beginnt, die Spannung zu messen und alle 30 Sekunden Signale an den Raspberry Pi zu senden.

Schritt 9:Führen Sie das Python-Programm aus

• Erstellen Sie ein Skript, das Ihr Python-Programm startet.
• Bearbeiten Sie die Root-Crontab, um Ihr Skript beim Booten automatisch auszuführen. Bearbeiten Sie die Verzeichnispfade entsprechend Ihrem Raspberry Pi und wo Sie das Python-Programm gespeichert haben.
• Um die Crontab zu bearbeiten:
  sudo crontab -e
• Fügen Sie eine Zeile hinzu, um Ihr 'Kick-Off'-Skript auszuführen, wenn der Raspberry Pi neu gestartet wird:
  @reboot sh /home/pi/hotwater/run_HotWaterNotifier.sh>> /home/pi/hotwater /logs/HotWaterNotifier.log 2>&1
• Um manuell auszuführen (bevor Sie das Crontab-Setup haben)
  Führen Sie zuerst den Prozess aus (führen Sie Ihr run_HotWaterNotifier.sh-Skript aus)
  Geben Sie dann ctrl-Z um Ihren Prozess zu unterbrechen
  Geben Sie dann bg . ein ein- oder zweimal, um den Vorgang in den Hintergrund zu senden
  Geben Sie disown ein , so kann der Prozess nach dem Abmelden weiterlaufen
• Um zu sehen, ob der Prozess noch läuft
  ps aux | grep -i Heißwasser

Code

• Arduino-Code
• Phython-Code
• Skript zum Starten des Python-Codes

Arduino-CodeArduino

/******************************** ********************************************* HotWaterHeater Misst die Spannung kommt vom Thermoelement des Warmwasserbereiters. Verwendet Signalisierung, um diese Spannungssensormessung an den Raspberry Pi zu senden. ************************************************* ************************* ///doppelte Referenzspannung =5,0; //unbenutzte Referenzspannungdouble ReferenceVoltage =1.1;int OUTPUT_PIN =9;int INTRA_DIGIT_WAIT=20;int BETWEEN_DIGIT_WAIT=50;///////////////////////// //////////////////////////////////////////////// ///// die Setup-Funktion wird einmal ausgeführt, wenn Sie Reset drücken oder das Board einschalten //////////////////////////////// //////////////////////////////////////////////void setup( ) {// Initialisieren Sie den digitalen Pin LED_BUILTIN als Ausgang. pinMode (LED_BUILTIN, AUSGANG); pinMode (OUTPUT_PIN, OUTPUT); // setzt den digitalen Pin 9 als Ausgang analogReference (INTERNAL); Serial.begin (9600); // öffnet serielle Schnittstelle, setzt Datenrate auf 9600 bps}//////////////////////////////////////////////////////// /////////////////////////////////////////// Die Loop-Funktion läuft über und für immer wieder. // Messen Sie die Spannung am Eingangspin. // Senden Sie dann diesen Messwert an den Raspberry Pi ////////////////////////// //////////////////////////////////////////////// ///void loop () { Int pinInput; doppelte Spannung; pinInput =analogRead (A0); // Sondeneingang Serial.print ( "PinInputA0 ="); Serial.print (pinInput); // Der Arduino ADC ist ein Zehn-Bit-Wandler, was bedeutet, dass der Ausgangswert von 0 bis 1023 reicht Spannung =(pinInput * ReferenceVoltage) / 1023; Serial.print (", voltageA0="); Serial.println (Spannung); // Hinweis:ein Messwert von 5 =5,38 mV sendNumberSignal (pinInput, OUTPUT_PIN, INTRA_DIGIT_WAIT, BETWEEN_DIGIT_WAIT); // Führen Sie die Prüfung alle 30 Sekunden aus Verzögerung (30000);}/************************************ ***************************************** * Eine Zahl auf a Signal signalisieren Einzeldraht. * * Senden Sie für jede Ziffer eine Reihe von Impulsen. * Es gibt auch einen anfänglichen Anstoßimpuls. * Jeder Impuls sieht wie folgt aus:__/ 20ms \__20ms__ * 20+20ms zwischen steigenden Flanken innerhalb derselben Ziffer * * Zwischen Ziffern:__/ 20ms \__20ms__ 50ms___ * 20+20+50ms zwischen Ziffern ********* ************************************************* ******************/void sendNumberSignal(int number, int pin, int intraDigitWait, int betweenDigitWait) { int tens =number/10; int Einsen =Zahl % 10; Serial.print ( "Signalisierung:"); Serial.println (Nummer); // Debugging //////// //Serial.print("Zehner:"); //Seriell.println (Zehner); //Serial.print("ones:"); //Seriell.println (Einsen); //Serial.print("Millis:"); //Seriell.println(millis()); // Debugging //////// //Serial.println("sende Zehner"); //Serial.print("Millis:"); //Seriell.println(millis()); // sende die Zehnerzahl sendPulse (pin, intraDigitWait); for (int i=0; i 
Phython-CodePython 
 Dieser Code empfängt Signale vom Arduino. Es interpretiert die Signale in einen Spannungswert. Es entscheidet dann, ob die Spannung zu niedrig ist. Wenn die Spannung zu niedrig ist, sendet es E-Mails und SMS.
################################## ############################################## HotWaterNotifier.py# Überwachen Sie den Eingangspin und empfangen Sie Signale von einem Arduino. # Decodieren Sie die Signale in numerische Spannungssensormessungen. # Wenn die empfangene Spannung zu niedrig ist, zeigt dies an, dass die # Kontrolllampe aus ist. Wenn dies bei 5 Messungen hintereinander auftritt, gehen Sie davon aus, dass# die Kontrolllampe wirklich aus ist. Senden Sie E-Mails/Texte und notieren Sie die Zeit.# Senden Sie nur alle sechs Stunden eine E-Mail/Text.## Dies wurde für Python 2.7 geschrieben. Für Python 3 sind möglicherweise geringfügige Änderungen erforderlich.######################################## ######################################import smtplibimport RPi.GPIO als GPIOimport osimport os.pathimport timeimport datetimeimport stringimport loggingimport sys#Input GPIO zum Empfangen von Signalen vom ArduinoGPIO_Alert=16# Wie viele Stunden warten zwischen E-MailssemailWaitHours=6# Niederspannungssensormessung.# Kleiner oder gleich dieser ist Niederspannung.lowSensorReading=1# Einmal so viele niedrig Sensormesswerte erreicht ist, senden Sie den alertmaxLowVoltageCount=5# für die GPIO-Nummerierung, wählen Sie BCMGPIO.setmode(GPIO.BCM)GPIO.setup(GPIO_Alert, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)lastEmailSentTime =datetime.datetime(2000,1, 1,0,0,0,0) #globale Variable deklarieren#################################### ############################################ Logger einrichten.## ################################################ ###########################def setup_custom_logger(name):formatter =Logging.Formatter(fmt='%(asctime)s %(levelname )-8s %( message)s', datefmt='%Y-%m-%d %H:%M:%S') handler =Logging.FileHandler('HotWaterLog.txt', mode='a') handler.setFormatter(formatter) screen_handler =Logging.StreamHandler(stream=sys.stdout) screen_handler.setFormatter(formatter) logger =Logging.getLogger(name) logger.setLevel(logging.DEBUG) logger.addHandler(handler) logger.addHandler(screen_handler) return logger## ################################################ ############################ Funktion zum Versenden von E-Mails/SMS################ ################################################ #############def send_email_alert():# Erlaube das Schreiben in die globale Variable global lastEmailSentTime # prüfe, ob seit der letzten E-Mail genügend Zeit vergangen ist nowTime =datetime.datetime.now() emailWaitDelta =datetime .timedelta(hours=emailWaitHours) limitTime =nowTime - emailWaitDelta #wenn genug Zeit vergangen ist, sende die E-Mail. if lastEmailSentTime is None or limitTime> lastEmailSentTime:logger.info('Sending email alert...') HOST ="smtp.gmail.com" PORT =587 SUBJECT ="Warmwasserbereiter" #Dies sollte ein Listenobjekt sein für mehrere Adressen TO =["[email protected]", "[email protected]"] #TO =["[email protected]"] FROM ="[email protected]" PWD ="XXXXXXXXXXXXXX" text =" Niederspannung am Warmwasserbereiter gemessen" #Das Feld "to" wird hier zu einer Zeichenfolge zusammengefügt. #Dies wird dem Empfänger in seiner E-Mail angezeigt. BODY =string.join(("von:%s" %FROM, "bis:%s" %", ".join(TO), "Betreff:%s" %BETREFF, " ", Text), "\r \n") try:s =smtplib.SMTP(HOST,PORT) s.set_debuglevel(1) s.ehlo() s.starttls() s.login(FROM, PWD) s.sendmail(FROM,TO,BODY) s.quit ausser Ausnahme as e:logger.Exception('Ausnahme beim Senden einer E-Mail-Datei erwischt. In 6 Stunden wird es erneut versucht') #setze die Zeit so, dass 6 Stunden lang keine E-Mail gesendet wird lastEmailSentTime =nowTime else:logger.info(' E-Mail wird nicht gesendet. Letzte E-Mail gesendet am:' + lastEmailSentTime.strftime("%Y-%m-%d %H:%M:%S"))############## ################################################ ############### Empfangen von Signalen vom Arduino.# Eine Zahl besteht aus zwei Ziffern. (eine Zehnerstelle und eine Einerstelle)# Der Arduino überträgt immer eine Zahl, die aus 2 Ziffern besteht.# Die empfangenen Signale sind eine Reihe von High-Impulsen am Eingangspin.# Die Methode waitReceiveNumber() zählt die High-Impulse und der [count -1] ist# der Wert der Ziffer.# Jeder Ziffer geht 1 Impuls voraus.## 70 ms max. zwischen Signalflanken innerhalb derselben Ziffer# steigende Flanken mit einem Abstand von weniger als 70 ms sind dieselbe Ziffer# falls größer als 70 ms, dann zur nächsten Ziffer gehen# 200 ms bedeutet, dass die Nummer vollständig ist################################## ##############################################def waitReceiveNumber(GPIO_Alert ) gerade gesendet wird # Wert der aktuellen Ziffer erhöhen #Mehr als 70ms:zur nächsten Ziffer wechseln singleDigitMilliseconds =datetime.timedelta(milliseconds=70) #Wenn dieser Timeout erreicht ist, ist es das Ende der Zahl WholeNumberWaitTime =200 # hier warten bis eine steigende Flanke erkannt wird #logger.info('Waiting on GPIO pin:' + str(GPIO_Alert)) während True:#Arduino sendet beim Flashen einen Puls starten Sie den Raspberry Pi als zweites. #Der Arduino sollte bei einem Stromausfall schneller booten. if isFirstIteration:ReceivedEdge =GPIO.wait_for_edge(GPIO_Alert, GPIO.RISING, timeout=-1) #warten Sie ewig bis ein Kick-Off-Puls kommt else:ReceivedEdge =GPIO.wait_for_edge(GPIO_Alert, GPIO.RISING, timeout=wholeNumberWaitTime) #wait bis waitTime ms #berechnen Sie die Timing-Metriken für dieses Signal signalTime =datetime.datetime.now() signalInterval =signalTime - lastSignalTime lastSignalTime =signalTime #debugging:logger.info('signalInterval:' + str(signalInterval.total_seconds() * 1000 )) #bestimmen, welche Ziffer erhöht werden soll, wenn (signalInterval =singleNumberMilliseconds:if isTens:#shift to ones isTens =False onesValue+=1 else:#isOnes #kann nicht zur nächsten Ziffer wechseln, daher ist die Zahl vollständig. #Das sollte nicht passieren. Sobald die Nummer fertig ist, sollte #die Wartezeit ablaufen und ReceivedEdge sollte None sein. return ((tensValue -1)*10) + (onesValue -1) else:#timeout, also Zahl ist vollständig. Rückgabe ((TensValue -1)*10) + (OnesValue -1)################################## ############################################## Die Hauptmethode# ################################################ ############################def main():logger.info('Starting HotWaterNotifier') referenceVoltage =1.1 lowVoltageCount=0 try:while True:#Dies wird blockiert, bis es Signale vom Arduino empfängt. #Es wird nur zurückgegeben, wenn eine vollständige Nummer eingegangen ist. sensorReading =waitReceiveNumber(GPIO_Alert) #berechne die Spannung von der Arduino-Sensorlesespannung =(sensorReading * referenceVoltage) / 1023; logger.info('sensorReading:' + str(sensorReading) + ', voltage:' + str(volt)) if sensorReading <=lowSensorReading:lowVoltageCount+=1 #increment if lowVoltageCount>=maxLowVoltageCount:logger.info('Niederspannungsalarm ') send_email_alert() lowVoltageCount=0 #Zähler zurücksetzen weil wir eine Warnung gesendet haben else:lowVoltageCount=0 #Zähler zurücksetzen weil eine gute Spannung empfangen wurde außer KeyboardInterrupt:logger.info('Tastaturinterrupt empfangen') GPIO.cleanup() # GPIO bereinigen bei STRG+C beenden GPIO.cleanup() # GPIO bereinigen################################ ################################################ Die Prüfung E-Mail-Methode################################################ ###############################def testEmail():logger.info('Starting HotWaterNotifier') referenceVoltage =1.1 lowVoltageCount=0 try:send_email_alert() außer KeyboardInterrupt:logger.info('Tastaturinterrupt empfangen') GPIO.cleanup() # GPIO bereinigen bei STRG+C beenden GPIO.cleanup() # GPIO bereinigen######## ############ ################################################ ########## Eine globale Variable#################################### ########################################### Einrichten eines Protokolldateiloggers =setup_custom_logger ('HotWaterNotifier')############################################ ################################### Rufen Sie die Hauptmethode auf.## Rufen Sie stattdessen hier testEmail() auf, wenn Sie die E-Mail-Fähigkeit testen möchten.########################################## ####################################if __name__=="__main__":main()
 
Skript zum Starten des Python-CodesSH 
 Dies ist das Skript, das crontab aufruft, um den Python-Code zu starten
#!/bin/bash# run_HotWaterNotifier.sh# Starten Sie die notifiercd /home/pi/hotwatersudo python HotWaterNotifier.py