Monitor de Tensão do Termopar do Aquecedor de Água Quente

Sobre este projeto

Sistema de monitoramento de luz piloto do aquecedor de água quente

Visão geral

Etapa 1:prepare seu Raspberry Pi

Etapa 2:Prepare seu Arduino

Etapa 3:Conecte o Arduino à fonte de tensão

Etapa 4:conecte o Arduino ao Raspberry Pi

Etapa 5:o Arduino transmite a medição da tensão

Etapa 6:Raspberry Pi recebe a medição de tensão

Etapa 7:enviar a notificação

Etapa 8:conecte tudo

Etapa 9:execute o programa Python

• Crie um script que dê início ao seu programa Python.
• Edite o crontab raiz para executar automaticamente o seu script no momento da inicialização. Edite os caminhos do diretório conforme apropriado para o seu Raspberry Pi e onde você salvou o programa Python.
• Para editar o crontab:
  sudo crontab -e
• Adicione uma linha para executar o script de 'início' quando o Raspberry Pi for reiniciado:
  @reboot sh /home/pi/hotwater/run_HotWaterNotifier.sh>> / home / pi / hotwater /logs/HotWaterNotifier.log 2> &1
• Para executar manualmente (antes de ter a configuração do crontab)
  Primeiro execute o processo (execute seu script run_HotWaterNotifier.sh)
  Em seguida, digite ctrl-Z para suspender o seu processo
  Em seguida, digite bg uma ou duas vezes para enviar o processo para segundo plano
  Digite rejeitar , isso permite que o processo continue em execução após o logoff
• Para ver se o processo ainda está em execução
  ps aux | grep -i HotWater

Código

• Código Arduino
• Código Phython
• Script para iniciar o código Python

Código Arduino Arduino

 / ******************************* ************************************************ HotWaterHeater mede a tensão vindo do termopar do aquecedor de água. Usa sinalização para enviar esta medição do sensor de tensão para o Raspberry Pi. *************************************************** *************************** /// double ReferenceVoltage =5.0; // referência voltagedouble não utilizada ReferenceVoltage =1.1; int OUTPUT_PIN =9; int INTRA_DIGIT_WAIT =20; int BETWEEN_DIGIT_WAIT =50; ////////////////////////// //////////////////////////////////////////////////////// ///// a função de configuração é executada uma vez quando você pressiona reset ou liga o painel ////////////////////////////////// /////////////////////////////////////////////////// void setup ( ) {// inicializa o pino digital LED_BUILTIN como uma saída. pinMode (LED_BUILTIN, OUTPUT); pinMode (OUTPUT_PIN, OUTPUT); // define o pino digital 9 como saída analogReference (INTERNAL); Serial.begin (9600); // abre a porta serial, define a taxa de dados para 9600 bps} /////////////////////////////////////////// ////////////////////////////////////////////////// A função de loop é executada e de novo para sempre.// Meça a voltagem no pino de entrada.// Em seguida, envie essa leitura para o Raspberry Pi //////////////////////////// //////////////////////////////////////////////////////// /// void loop () {int pinInput; dupla tensão; pinInput =analogRead (A0); // Probe Input Serial.print ("PinInputA0 ="); Serial.print (pinInput); // O Arduino ADC é um conversor de dez bits, o que significa que o valor de saída variará de 0 a 1023 tensão =(pinInput * ReferenceVoltage) / 1023; Serial.print (", voltagemA0 ="); Serial.println (voltagem); // Nota:uma leitura de 5 =5,38 mV sendNumberSignal (pinInput, OUTPUT_PIN, INTRA_DIGIT_WAIT, BETWEEN_DIGIT_WAIT); // Execute a verificação uma vez a cada 30 segundos de atraso (30000);} / ********************************** ********************************************* * Sinalizar um número em um único fio. * * Para cada dígito, envie uma série de pulsos. * Há também um pulso inicial. * Cada pulso se parece com:__ / 20ms \ __ 20ms__ * 20 + 20ms entre as bordas crescentes dentro do mesmo dígito * * Entre os dígitos:__ / 20ms \ __ 20ms__ 50ms___ * 20 + 20 + 50ms entre os dígitos ********* *************************************************** ****************** / void sendNumberSignal (int número, int pin, int intraDigitWait, int betweenDigitWait) {int dezenas =número / 10; unidades internas =número% 10; Serial.print ("Sinalização:"); Serial.println (número); // debugging //////// //Serial.print("tens:"); //Serial.println(tens); //Serial.print("ones:"); //Serial.println(ones); //Serial.print("millis:"); //Serial.println (millis ()); // debugging //////// //Serial.println("send dezenas "); //Serial.print("millis:"); //Serial.println (millis ()); // envia o número das dezenas sendPulse (pin, intraDigitWait); para (int i =0; i  
 Código Phython  Python  
 Este código recebe sinais do Arduino. Ele interpreta os sinais em uma leitura de tensão. Em seguida, ele decide se a tensão está muito baixa. Se a tensão estiver muito baixa, ele envia e-mails e textos. 
 ####################################### ########################################################### HotWaterNotifier.py # Monitore o pino de entrada e receba sinais de um Arduino. # Decodifique os sinais em medições numéricas do sensor de tensão. # Quando a leitura da tensão recebida é muito baixa, isso indica que a # luz piloto está apagada. Quando isso ocorrer por 5 medições consecutivas, assuma que # a luz piloto está realmente apagada. Envie e-mails / textos e registre o tempo. # Envie um e-mail / texto apenas a cada seis horas. ## Isso foi escrito para Python 2.7. Podem ser necessárias pequenas alterações para Python 3. #################################################################################################### ############# Import smtplibimport RPi.GPIO as GPIOimport osimport os.pathimport timeimport os.pathimport ####################### Import smtplibimport RPi.GPIO asimport datetimeimport stringimport loggingimport sys # Input GPIO para receber sinais do ArduinoGPIO_Alert =16 # Quantas horas esperar entre emailsemailWaitHours =6 # Leitura do sensor de baixa tensão. # Menor ou igual a isto é low voltage.lowSensorReading =1 # Uma vez que muitos baixos leituras do sensor são alcançadas, envie o alertmaxLowVoltageCount =5 # para numeração GPIO, escolha 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) #declare variável global ########################################## ######################################################### Configure o logger. ## ############################################################### #################################### 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 (formatador) 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 ## ############################################################### #################################### Função para enviar e-mails / textos ##################### ############################################################### ############# Def send_email_alert ():# permite gravar na variável global global lastEmailSentTime # verifique se passou tempo suficiente desde o último e-mail nowTime =datetime.datetime.now () emailWaitDelta =datetime .timedelta (hours =emailWaitHours) limitTime =nowTime - emailWaitDelta #se tempo suficiente tiver passado, envie o e-mail. se lastEmailSentTime for None ou limitTime> lastEmailSentTime:logger.info ('Sending email alert ...') HOST ="smtp.gmail.com" PORT =587 SUBJECT ="Alerta de aquecedor de água quente" #Este deve ser um objeto de lista para endereços múltiplos TO =["[email protected]", "[email protected]"] #TO =["[email protected]"] FROM ="[email protected]" PWD ="XXXXXXXXXXXXXX" text =" Baixa tensão medida no aquecedor de água quente "#O campo para é unido em 1 string aqui. #Isso é exibido para o destinatário em seu e-mail. BODY =string.join (("de:% s"% FROM, "to:% s"% "," .join (TO), "Assunto:% s"% SUBJECT, "", texto), "\ 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 exceto Exception as e:logger.exception ('Exceção capturada enviando email. Tentando novamente em 6 horas') #defina o tempo para que um email não seja enviado por 6 horas lastEmailSentTime =nowTime else:logger.info (' Não enviando e-mail. Último e-mail enviado em:'+ lastEmailSentTime.strftime ("% Y-% m-% d% H:% M:% S")) ################# ############################################################### ############# Receber sinais do Arduino. # Um número é composto por dois dígitos. (um dígito de dezena e um dígito de uma) # O Arduino sempre transmite um número, consistindo de 2 dígitos. # Os sinais recebidos são uma série de pulsos altos no pino de entrada. # O método waitReceiveNumber () conta os pulsos altos e [contagem -1] é # o valor do dígito. # Cada dígito é precedido por 1 pulso. ## 70 ms máx. entre as bordas do sinal dentro do mesmo dígito # as bordas ascendentes separadas por menos de 70ms são o mesmo dígito # se maiores do que 70 ms e, em seguida, passar para o próximo dígito # 200 ms significa que o número está completo ####################################### ########################################################### Def waitReceiveNumber (GPIO_Alert ):lastSignalTime =datetime.datetime (2000,1,1,0,0,0,0) isTens =True isFirstIteration =True tensValue =0 onesValue =0 receivedEdge =Nenhum #Menos de 70ms entre os pulsos:este é o mesmo dígito ainda sendo transmitido # Incrementa o valor do dígito atual #Mais de 70ms:muda para o próximo dígito singleDigitMilliseconds =datetime.timedelta (milissegundos =70) #Se este tempo limite for alcançado, é o fim do número wholeNumberWaitTime =200 # espere aqui até que uma borda ascendente seja detectada # logger.info ('Waiting on GPIO pin:' + str (GPIO_Alert)) while True:#Arduino envia um pulso quando você pisca , inicie o Raspberry Pi em segundo lugar. #O Arduino deve inicializar mais rápido no caso de queda de energia. if isFirstIteration:receivedEdge =GPIO.wait_for_edge (GPIO_Alert, GPIO.RISING, timeout =-1) #wait indefinidamente até um pulso inicial else:receivedEdge =GPIO.wait_for_edge (GPIO_Alert, GPIO.RISING, timeout =wholeNumberWaitTime) até waitTime ms #calcular as métricas de tempo para este sinal signalTime =datetime.datetime.now () signalInterval =signalTime - lastSignalTime lastSignalTime =signalTime #debugging:logger.info ('signalInterval:' + str (signalInterval.total_seconds () * 1000 )) #determine qual dígito incrementar se (signalInterval  =singleNumbers:para uns isTens =False onesValue + =1 else:#isOnes # não pode mudar para o próximo dígito, então o número está completo. #Isso não deveria acontecer. Assim que o número for concluído, # a espera deve expirar e o receivedEdge deve ser Nenhum. return ((tensValue -1) * 10) + (onesValue -1) else:# tempo limite, então o número está completo. return ((tensValue -1) * 10) + (onesValue -1) ######################################## ########################################################## O método principal # ############################################################### ###################################### Def main ():logger.info ('Iniciando HotWaterNotifier') referenceVoltage =1.1 lowVoltageCount =0 try:enquanto True:#Isso irá bloquear até receber sinais do Arduino. #Só retornará quando um número completo for recebido. sensorReading =waitReceiveNumber (GPIO_Alert) #calular a tensão da leitura do sensor Arduino tensão =(sensorReading * referenceVoltage) / 1023; logger.info ('sensorReading:' + str (sensorReading) + ', voltage:' + str (voltage)) if sensorReading <=lowSensorReading:lowVoltageCount + =1 #increment if lowVoltageCount> =maxLowVoltageCount:logger.info ('Alerta de baixa tensão ') send_email_alert () lowVoltageCount =0 # redefina o contador porque enviamos um alerta mais:lowVoltageCount =0 # redefina o contador porque uma boa voltagem foi recebida, exceto KeyboardInterrupt:logger.info (' Teclado interrompido recebido ') GPIO.cleanup () # limpar GPIO em CTRL + C sair de GPIO.cleanup () # limpar GPIO ###################################### ################################################ O teste método de e-mail ########################################################## ########################################### Def testEmail ():logger.info ('Iniciando HotWaterNotifier') referenceVoltage =1.1 lowVoltageCount =0 tentativa:send_email_alert () except KeyboardInterrupt:logger.info ('Teclado interrompido recebido') GPIO.cleanup () # limpar GPIO em CTRL + C sair GPIO.cleanup () # limpar GPIO ######### ############### ################################################################ ################ Uma variável global ############################################################################################################################################################################ ######################################################## ('HotWaterNotifier') ################################################################################################# ############################################# Chame o método principal. ## Chame testEmail () aqui se você deseja testar a capacidade de e-mail. ################################################### ############################################### If __name __ =="__main__":main () 
 
 Script para iniciar o código Python  SH  
 Este é o script que o crontab chama para iniciar o código Python 
 #! / Bin / bash # run_HotWaterNotifier.sh # Inicie o notifiercd / home / pi / hotwatersudo python HotWaterNotifier.py