Pompa inteligentă a mașinii de cafea controlată de senzorul cu ultrasunete Raspberry Pi și HC-SR04 și Cloud4RPi: 6 pași

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:43

În teorie, de fiecare dată când mergi la aparatul de cafea pentru ceașca de dimineață, există doar o șansă de unu la douăzeci să umple rezervorul de apă. Cu toate acestea, în practică, se pare că aparatul găsește cumva o modalitate de a pune întotdeauna această corvoadă asupra ta. Cu cât doriți mai multă cafea, cu atât aveți mai multe șanse să primiți mesajul temut „umpleți rezervorul de apă”. Colegii mei simt la fel în acest sens. Fiind tocilarii care suntem, am decis să implementăm tehnologia care ar pune capăt acestui lucru.

Provizii

Echipamentul nostru

Avem un aparat de cafea SAECO Aulika Focus. Până în prezent, am folosit o pompă manuală pentru a umple rezervorul de apă al mașinii dintr-o sticlă de apă standard de 5 galoane (19L).

Telurile noastre

1. Utilizați o pompă electrică acționată de un fel de controler sau de un microcomputer printr-un releu.
2. Aveți o modalitate de a măsura nivelul apei din rezervorul mașinii de cafea, astfel încât sistemul nostru să știe când să o reumple.
3. Au mijloace pentru a controla sistemul, de preferință în timp real de pe un dispozitiv mobil.
4. Primiți notificări (prin Slack sau un serviciu similar) dacă ceva nu merge bine cu sistemul.

Pasul 1: Alegerea echipamentului

Pompa

O căutare rapidă pe web va afișa mai multe modele de pompe electrice concepute pentru sticla dvs. de apă la alegere. Astfel de pompe sunt de obicei controlate de un comutator ON / OFF (de exemplu, Hot Frost A12 sau SMixx ХL-D2). Iată pompa pe care am ales-o pentru proiectul nostru.

Dispozitivul de control

Am încercat mai multe dispozitive, dar ne-am instalat pe un Raspberry Pi datorită următoarelor avantaje:

• Are un GPIO care ne permite să conectăm un senzor de proximitate
• Suportă Python

Am instalat o versiune nouă a Raspbian Buster Lite și tot ce este necesar pentru a rula Python 3.

Cum comutăm pompa

Pentru a controla puterea, am ales un releu de stare solidă de putere medie (12V / 2A) potrivit pentru curent alternativ. Releul conectează pompa la priză și este controlat de pinul digital al Raspberry Pi.

Cum verificăm nivelul apei

Pentru noi a fost important să nu modificăm construcția aparatului de cafea, așa că am decis să folosim senzorul de proximitate cu ultrasunete HC-SR04 pentru a măsura nivelul apei.

Am imprimat în 3D un capac personalizat al rezervorului de apă cu două găuri pentru emițătoarele senzorului. Am găsit cu ușurință o bibliotecă GitHub pentru senzor. În acest moment toate pregătirile au fost terminate.

Pasul 2: Proiectarea sistemului

Logica sistemului

Sistemul este proiectat având în vedere următoarea logică simplă:

• Sistemul monitorizează constant distanța dintre senzor și suprafața apei.
• Ori de câte ori o modificare a distanței depășește o valoare prag, sistemul trimite informații despre starea sa către cloud.
• Dacă distanța depășește valoarea maximă admisă (rezervorul este gol), sistemul activează pompa și o oprește odată ce distanța este mai mică decât valoarea minimă admisă.
• Ori de câte ori se schimbă starea sistemului (de exemplu, pompa se activează), acesta informează norul.

În caz de eroare, o notificare este trimisă către un canal Slack.

Când aparatul de cafea este inactiv, sistemul trimite serviciul cloud cu date de diagnosticare o dată pe minut. În plus, își trimite starea în cloud la fiecare 5 minute.

Când pompa este activă, sistemul trimite date mai frecvent, dar nu mai mult de o dată la jumătate de secundă.

trimitere def (cloud, variabile, dist, error_code = 0, force = False): pump_on = is_pump_on () percent = calc_water_level_percent (dist) variables ['Distance'] ['value'] = dist variables ['WaterLevel'] [' valoare '] = variabile procentuale [' PumpRelay '] [' valoare '] = variabile pump_on [' Status '] [' valoare '] = calc_status (error_code, percent, pump_on)

curent = ora ()

global last_sending_time if force or current - last_sending_time> MIN_SEND_INTERVAL: readings = cloud.read_data () cloud.publish_data (readings) last_sending_time = current

Lucrul cu pompa

Definim următoarele constante ca bază pentru logica funcționării pompei.

# Pini GPIO (BCM) GPIO_PUMP = 4 GPIO_TRIGGER = 17 GPIO_ECHO = 27

# Pompa

START_PUMP = 1 STOP_PUMP = 0 PUMP_BOUNCE_TIME = 50 # milisecunde PUMP_STOP_TIMEOUT = 5 # secunde

IMPORTANT: Dacă aveți de gând să utilizați Pinul 4, nu uitați să dezactivați opțiunea 1-Wire raspi-config pentru a evita conflictele.

La pornirea programului, înregistrăm un apel invers și setăm starea inițială la OFF.

Iată codul pentru funcția care comută pompa:

def toggle_pump (valoare): if pump_disabled: return if is_pump_on ()! = value: log_debug ("[x]% s"% ('START' if value else 'STOP')) GPIO.setup (GPIO_PUMP, GPIO. OUT) GPIO.output (GPIO_PUMP, valoare) # Start / Stop turning

După cum este definit în codul de pornire de mai sus, atunci când releul se aprinde, se apelează următorul apel invers:

pump_on = False def pump_relay_handle (pin): global pump_on pump_on = GPIO.input (GPIO_PUMP) log_debug ("Releul pompei a fost schimbat în% d"% pump_on)

În callback, salvăm starea curentă a pompei într-o variabilă. În bucla principală a aplicației, putem detecta momentul în care pompa comută după cum se arată mai jos:

def is_pump_on (): pump_on global return pump_on

dacă GPIO.event_detected (GPIO_PUMP):

is_pouring = is_pump_on () # … log_debug ('[!] Eveniment pompă detectat:% s'% ('Activat' dacă is_pouring else 'Off')) trimite (nor, variabile, distanță, forță = Adevărat)

Măsurarea distanței

Este destul de ușor să măsurați distanța față de suprafața apei cu ajutorul unui senzor de proximitate cu ultrasunete. În depozitul nostru, am împărtășit câteva scripturi python care vă permit să testați un senzor.

În aplicații reale, citirile senzorilor pot fluctua din cauza efectului de săritură al senzorului și a oscilațiilor apei. În unele cazuri, citirile pot lipsi complet. Am implementat o clasă BounceFilter care acumulează N valori recente, elimină vârfurile și calculează media măsurătorilor rămase. Procesul de măsurare este implementat de următorul algoritm asincron.

# Păstrează ultimele măsurători ale senzorului citiri = BounceFilter (dimensiune = 6, discard_count = 1)

reading_complete = threading. Event ()

def wait_for_distance ():

reading_complete.clear () thread = threading. Thread (target = read_distance) thread.start ()

dacă nu reading_complete.wait (MAX_READING_TIMEOUT):

log_info ('Citire expirare senzor') return Niciun return returnings.avg ()

def read_distance ():

try: value = hcsr04.raw_distance (sample_size = 5) rounded = value if value is None else round (value, 1) readings.add (rounded) except Exception as err: log_error ('Eroare internă:% s'% eroare) în sfârșit: reading_complete.set ()

Puteți găsi implementarea completă a filtrului în surse.

Pasul 3: Tratarea situațiilor de urgență

Ce se întâmplă dacă senzorul a ars, a căzut sau a arătat către o zonă greșită? Aveam nevoie de o modalitate de a raporta astfel de cazuri, astfel încât să putem lua măsuri manuale.

Dacă senzorul nu reușește să furnizeze citiri la distanță, sistemul trimite starea modificată în cloud și generează o notificare corespunzătoare.

Logica este ilustrată de codul de mai jos.

distance = wait_for_distance () # Citiți adâncimea curentă a apei dacă distanța este None: log_error ('Distance error!') notification_in_background (calc_alert (SENSOR_ERROR)) send (cloud, variabile, distance, error_code = SENSOR_ERROR, force = True)

Avem un interval de nivel operațional al nivelului apei care ar trebui menținut atunci când senzorul este la locul său. Testăm dacă nivelul curent al apei se încadrează în acest interval:

# Distanța de la senzor la nivelul apei # bazată pe rezervorul de apă al aparatului de cafea MIN_DISTANCE = 2 # cm MAX_DISTANCE = 8 # cm

# Distanța este în afara intervalului de așteptare: nu începeți să turnați

dacă distanță> MAX_DISTANCE * 2: log_error („Distanța este în afara intervalului:%.2f”% distanță) continua

Oprim pompa dacă era activă când a apărut o eroare.

if is_pump_on () și prev_distance <STOP_PUMP_DISTANCE + DISTANCE_DELTA: log_error ('[!] Oprire de urgență a pompei. Fără semnal de la un senzor de distanță')

toggle_pump (STOP_PUMP)

De asemenea, procesăm cazul când sticla rămâne fără apă. Verificăm dacă nivelul apei nu se schimbă când pompa funcționează. Dacă da, sistemul așteaptă 5 secunde și apoi verifică dacă pompa s-a oprit. Dacă nu, sistemul implementează oprirea de urgență a pompei și trimite o notificare de eroare.

PUMP_STOP_TIMEOUT = 5 # secsemergency_stop_time = Niciuna

def set_emergency_stop_time (acum, is_pouring):

global emergency_stop_time emergency_stop_time = acum + PUMP_STOP_TIMEOUT dacă / is_pouring else None

def check_water_source_empty (acum):

returnează Emergency_stop_time și acum> Emergency_stop_time

# --------- bucla principală -----------

dacă GPIO.event_detected (GPIO_PUMP): is_pouring = is_pump_on () set_emergency_stop_time (acum, is_pouring) # …

global pump_disabled

if check_water_source_empty (now): log_error ('[!] Oprire de urgență a pompei. / Sursa de apă este goală') toggle_pump (STOP_PUMP) pump_disabled = True

Mai sus este un exemplu de jurnal de mesaje generat în timpul unei opriri de urgență.

Pasul 4: Rularea sistemului 24/7

Codul de pe dispozitiv este depanat și rulează fără probleme. L-am lansat ca serviciu, deci repornește dacă Raspberry Pi este repornit. Pentru comoditate, am creat un Makefile care ajută la implementare, rularea serviciului și vizualizarea jurnalelor.

. PHONY: instalați jurnalul de pornire a opririi rulați implementarea MAIN_FILE: = coffee-pump / main.py SERVICE_INSTALL_SCRIPT: = service_install.sh SERVICE_NAME: = coffee-pump.service

instalare:

chmod + x $ (SERVICE_INSTALL_SCRIPT) sudo./$(SERVICE_INSTALL_SCRIPT) $ (MAIN_FILE)

alerga:

sudo python3 $ (MAIN_FILE)

start:

sudo systemctl începe $ (SERVICE_NAME)

stare:

sudo systemctl status $ (SERVICE_NAME)

Stop:

sudo systemctl stop $ (SERVICE_NAME)

Buturuga:

sudo journalctl -u coffee-pump --de azi

implementa:

rsync -av senzor pompa cafea-setup Makefile *.sh pi@XX. XX. XXX. XXX: ~ /

Puteți găsi acest fișier și toate scripturile necesare în depozitul nostru.

Pasul 5: Monitorizare în cloud

Am folosit Cloud4RPi pentru a implementa un panou de control. Mai întâi am adăugat widgeturi pentru a indica parametrii esențiali ai sistemelor.

Apropo, widgetul pentru variabila STATUS poate utiliza diferite scheme de culori pe baza valorii sale (vezi imaginea de mai sus).

Am adăugat un widget grafic pentru a afișa date dinamice. În imaginea de mai jos puteți vedea momentul în care pompa a pornit și oprit și nivelurile de apă respective.

Dacă analizați un interval de timp mai lung, puteți vedea vârfuri - atunci pompa funcționa.

Cloud4RPi vă permite, de asemenea, să setați diferite niveluri de netezire.

Pasul 6: funcționează

Functioneaza! Panoul de control în întregime arată așa cum se arată mai jos.

În prezent, pompa noastră automată funcționează de câteva săptămâni și tot ce trebuie să facem este să înlocuim sticlele de apă. Codul complet pentru proiectul nostru este disponibil în depozitul nostru GitHub.