Bomba intel·ligent per a màquines de cafè controlada pel sensor d'ultrasons Raspberry Pi i HC-SR04 i Cloud4RPi: 6 passos

2024 Autora: John Day | [email protected]. Última modificació: 2024-01-30 08:13

En teoria, cada vegada que aneu a la màquina de cafè per prendre la tassa del matí, només hi ha una possibilitat de cada vint per haver d’omplir el dipòsit d’aigua. A la pràctica, però, sembla que la màquina d'alguna manera troba una manera de posar-vos sempre aquesta tasca. Com més desitgeu cafè, més probabilitats teniu de rebre el temut missatge "omplir el dipòsit d'aigua". Els meus companys ho senten de la mateixa manera. Com que som els nerds que som, vam decidir implementar la tecnologia que posaria fi a això.

Subministraments

El nostre equipament

Disposem d’una màquina de cafè SAECO Aulika Focus. Fins avui, hem utilitzat una bomba de mà per omplir el dipòsit d’aigua de la màquina d’una ampolla d’aigua estàndard de 5 galons (19L).

Els nostres objectius

1. Utilitzeu una bomba elèctrica accionada per algun tipus de controlador o microordinador a través d’un relé.
2. Teniu una manera de mesurar el nivell d’aigua al dipòsit de la màquina de cafè perquè el nostre sistema sàpiga quan s’ha de tornar a omplir.
3. Disposar de mitjans per controlar el sistema, preferiblement en temps real des d’un dispositiu mòbil.
4. Rebeu notificacions (mitjançant Slack o un servei similar) si alguna cosa no funciona correctament amb el sistema.

Pas 1: triar l'equip

La Bomba

Una cerca ràpida a la web mostrarà diversos models de bombes elèctriques dissenyades per a l'ampolla d'aigua que trieu. Aquestes bombes solen controlar-se mitjançant un interruptor ON / OFF (per exemple, Hot Frost A12 o SMixx ХL-D2). Aquí teniu la bomba que vam triar per al nostre projecte.

El dispositiu de control

Hem provat diversos dispositius, però ens hem establert amb un Raspberry Pi a causa dels avantatges següents:

• Té un GPIO que ens permet connectar un sensor de proximitat
• És compatible amb Python

Hem instal·lat una versió nova de Raspbian Buster Lite i tot el necessari per executar Python 3.

Com alternem la bomba

Per controlar la potència, vam escollir un relé d’estat sòlid de potència mitjana (12V / 2A) adequat per al corrent altern. El relé connecta la bomba a la presa de corrent i es controla mitjançant el pin digital del Raspberry Pi.

Com comprovem el nivell de l'aigua

Per a nosaltres era important no alterar la construcció de la màquina de cafè, de manera que vam decidir utilitzar el sensor de proximitat per ultrasons HC-SR04 per mesurar el nivell de l’aigua.

Hem imprès en 3D una coberta personalitzada del dipòsit d’aigua amb dos forats per als emissors del sensor. Hem trobat fàcilment una biblioteca GitHub per al sensor. En aquest moment s’han acabat tots els preparatius.

Pas 2: Dissenyar el sistema

Lògica del sistema

El sistema està dissenyat tenint en compte la següent lògica simple:

• El sistema controla constantment la distància entre el sensor i la superfície de l’aigua.
• Sempre que un canvi de distància supera un valor llindar, el sistema envia informació al seu estat al núvol.
• Si la distància supera el valor màxim permès (el dipòsit està buit), el sistema activa la bomba i l’apaga un cop la distància és inferior al valor mínim permès.
• Sempre que canvia l’estat del sistema (per exemple, s’activa la bomba), informa el núvol.

En cas d'error, s'envia una notificació a un canal Slack.

Quan la màquina de cafè està inactiva, el sistema envia un servei al núvol amb dades de diagnòstic una vegada cada minut. A més, envia el seu estat al núvol cada 5 minuts.

Quan la bomba està activa, el sistema envia dades amb més freqüència, però no més d’una vegada cada mig segon.

enviació de def (núvol, variables, dist, error_code = 0, force = False): pump_on = is_pump_on () percent = calc_water_level_percent (dist) variables ['Distance'] ['value'] = dist variables ['WaterLevel'] [' valor '] = percentatge de variables [' PumpRelay '] [' value '] = pump_on variables [' Status '] [' value '] = calc_status (error_code, percent, pump_on)

actual = hora ()

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

Treballar amb la bomba

Definim les següents constants com a base per a la lògica de funcionament de la bomba.

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

# Bomba

START_PUMP = 1 STOP_PUMP = 0 PUMP_BOUNCE_TIME = 50 # mil·lisegons PUMP_STOP_TIMEOUT = 5 # segons

IMPORTANT: si utilitzeu el pin 4, no oblideu desactivar l'opció raspi-config 1-Wire per evitar conflictes.

A l’inici del programa, registrem una devolució de trucada i establim l’estat inicial a OFF.

A continuació, es mostra el codi de la funció que commuta la bomba:

def toggle_pump (value): 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, valor) # Inicia / Atura l’abocament

Tal com es defineix al codi d’inici anterior, quan el relé s’activa, es crida la següent devolució de trucada:

pump_on = False def pump_relay_handle (pin): pump_on global pump_on = GPIO.input (GPIO_PUMP) log_debug ("El relé de la bomba ha canviat a% d"% pump_on)

A la devolució de trucada, desem l’estat actual de la bomba en una variable. Al bucle principal de l’aplicació podem detectar el moment en què la bomba commuta com es mostra a continuació:

def is_pump_on (): pump_on global torna pump_on

si GPIO.event_detected (GPIO_PUMP):

is_pouring = is_pump_on () # … log_debug ('[!] Esdeveniment de la bomba detectat:% s'% ('Activat' si is_pouring else 'Off')) enviar (núvol, variables, distància, força = True)

Mesurament de la distància

És molt fàcil mesurar la distància cap a la superfície de l’aigua mitjançant un sensor de proximitat per ultrasons. Al nostre dipòsit, hem compartit un parell d’escriptures python que permeten provar un sensor.

En aplicacions reals, les lectures del sensor poden fluctuar a causa de l’efecte de rebot del sensor i de les oscil·lacions de l’aigua. En alguns casos, les lectures poden faltar completament. Hem implementat una classe BounceFilter que acumula N valors recents, descarta pics i calcula la mitjana de mesures restants. El procés de mesura s’implementa mitjançant el següent algorisme asíncron.

# Conserva les últimes lectures de mesures del sensor = Filtre de rebot (mida = 6, descart_count = 1)

reading_complete = threading. Event ()

def wait_for_distance ():

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

si no read_complete.wait (MAX_READING_TIMEOUT):

log_info ('Temps d'espera del sensor de lectura') retorna Cap retorna readings.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 ('Error intern:% s'% err) finalment: reading_complete.set ()

Podeu trobar la implementació completa del filtre a les fonts.

Pas 3: Gestió de situacions d'emergència

Què passa si el sensor es va cremar o va caure o apunta cap a una zona equivocada? Necessitàvem una manera d’informar d’aquests casos per poder fer accions manuals.

Si el sensor no proporciona lectures a distància, el sistema envia l’estat canviat al núvol i genera la notificació corresponent.

La lògica és il·lustrada pel següent codi.

distance = wait_for_distance () # Llegiu la profunditat actual de l'aigua si la distància és None: log_error ('Error de distància!') notification_in_background (calc_alert (SENSOR_ERROR)) enviar (núvol, variables, distància, error_code = SENSOR_ERROR, force = True)

Tenim un rang de nivell d’aigua operatiu que s’hauria de mantenir quan el sensor estigui al seu lloc. Provem si el nivell actual de l'aigua cau en aquest rang:

# Distància del sensor al nivell de l'aigua # basada en el dipòsit d'aigua de la màquina de cafè MIN_DISTANCE = 2 # cm MAX_DISTANCE = 8 # cm

# La distància està fora del rang esperat: no comenceu a abocar

si distància> MAX_DISTANCE * 2: log_error ("La distància està fora del rang:%.2f"% de distància) continua

Apagem la bomba si estava activa quan es va produir un error.

if is_pump_on () i prev_distance <STOP_PUMP_DISTANCE + DISTANCE_DELTA: log_error ("[!] Parada d'emergència de la bomba. No hi ha cap senyal d'un sensor de distància")

toggle_pump (STOP_PUMP)

També processem el cas quan l’ampolla es queda sense aigua. Comprovem si el nivell de l’aigua no canvia quan la bomba funciona. Si és així, el sistema espera 5 segons i després comprova si la bomba s'ha apagat. Si no ho fa, el sistema implementa l’aturada de la bomba d’emergència i envia una notificació d’error.

PUMP_STOP_TIMEOUT = 5 # secsemergency_stop_time = Cap

def set_emergency_stop_time (ara, is_pouring):

global emergency_stop_time emergency_stop_time = ara + PUMP_STOP_TIMEOUT si / is_pouring else Cap

def check_water_source_empty (ara):

torna Emergency_stop_time i ara> Emergency_stop_time

# --------- bucle principal -----------

si GPIO.event_detected (GPIO_PUMP): is_pouring = is_pump_on () set_emergency_stop_time (ara, is_pouring) # …

pump_disabled global

si check_water_source_empty (ara): log_error ('[!] Parada d'emergència de la bomba. / La font d'aigua està buida') toggle_pump (STOP_PUMP) pump_disabled = True

A la part superior es mostra un exemple d’un registre de missatges generat durant una parada d’emergència.

Pas 4: executar el sistema 24/7

El codi del dispositiu es depura i s’executa sense problemes. L'hem llançat com a servei, de manera que es reinicia si es reinicia el Raspberry Pi. Per comoditat, hem creat un Makefile que ajuda al desplegament, l'execució del servei i la visualització de registres.

. PHONY: instal·lar registre d’estat d’inici de parada d’execució desplegament MAIN_FILE: = coffee-pump / main.py SERVICE_INSTALL_SCRIPT: = service_install.sh SERVICE_NAME: = coffee-pump.service

instal·lar:

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

correr:

sudo python3 $ (MAIN_FILE)

començar:

sudo systemctl start $ (SERVICE_NAME)

estat:

estat sudo systemctl $ (SERVICE_NAME)

Atura:

sudo systemctl stop $ (SERVICE_NAME)

registre:

sudo journalctl -u coffee-pump - des d'avui

desplegar:

rsync -av sensor de bomba de cafè-configuració Makefile *.sh pi@XX. XX. XXX. XXX: ~ /

Podeu trobar aquest fitxer i tots els scripts necessaris al nostre dipòsit.

Pas 5: supervisió del núvol

Hem utilitzat Cloud4RPi per implementar un tauler de control. Primer vam afegir ginys per indicar els paràmetres essencials del sistema.

Per cert, el giny de la variable STATUS pot utilitzar diferents esquemes de colors en funció del seu valor (vegeu la imatge superior).

Hem afegit un widget de gràfics per mostrar dades dinàmiques. A la imatge següent podeu veure el moment en què la bomba es va encendre i apagar i els nivells d'aigua respectius.

Si analitzeu un període de temps més llarg, podreu veure els pics: aleshores la bomba funcionava.

Cloud4RPi també us permet establir diferents nivells de suavitzat.

Pas 6: funciona

Funciona! El tauler de control en la seva totalitat es veu com es mostra a continuació.

Actualment, la nostra bomba automàtica funciona des de fa diverses setmanes i només calia substituir les ampolles d’aigua. El codi complet del nostre projecte està disponible al nostre dipòsit de GitHub.