Slimme koffiemasjienpomp wat beheer word deur Raspberry Pi en HC-SR04 Ultrasoniese sensor en Cloud4RPi: 6 stappe

2024 Outeur: John Day | [email protected]. Laas verander: 2024-01-30 07:25

In teorie, elke keer as u na u koffiemasjien gaan vir u oggendbeker, is daar slegs 'n een-uit-twintig kans dat u die watertenk moet vul. In die praktyk blyk dit egter dat die masjien op een of ander manier 'n manier vind om hierdie taak altyd op u te plaas. Hoe meer u koffie wil hê, hoe groter is die kans dat u die gevreesde boodskap van die “watertenk vul” kry. My kollegas voel dieselfde hieroor. Omdat ons die nerds is, het ons besluit om die tegnologie te implementeer wat 'n einde hieraan sou maak.

Voorrade

Ons toerusting

Ons het 'n SAECO Aulika Focus koffiemasjien. Tot vandag toe gebruik ons 'n handpomp om die watertenk van die masjien uit 'n standaard waterbottel van 5 liter (19 liter) te vul.

Ons doelwitte

1. Gebruik 'n elektriese pomp wat deur 'n kontroleerder of 'n mikrorekenaar deur 'n relais aangedryf word.
2. Het u 'n manier om die watervlak in die tenk van die koffiemasjien te meet, sodat ons stelsel weet wanneer dit gevul moet word.
3. Beskik oor die stelsel, verkieslik intyds vanaf 'n mobiele toestel.
4. Ontvang kennisgewings (via Slack of 'n soortgelyke diens) as iets verkeerd loop met die stelsel.

Stap 1: Kies die toerusting

Die Pomp

'N Vinnige soektog op die internet sal verskeie modelle vir elektriese pompe wys wat ontwerp is vir u waterbottel. Sulke pompe word gewoonlik beheer deur 'n AAN/UIT-skakelaar (byvoorbeeld Hot Frost A12 of SMixx ХL-D2). Hier is die pomp wat ons vir ons projek gekies het.

Die beheertoestel

Ons het verskeie toestelle probeer, maar het ons op 'n Raspberry Pi gevestig weens die volgende voordele:

• Dit het 'n GPIO waarmee ons 'n nabyheidssensor kan koppel
• Dit ondersteun Python

Ons het 'n nuwe weergawe van Raspbian Buster Lite geïnstalleer en alles wat nodig is om Python 3 uit te voer.

Hoe ons die pomp kan skakel

Om die krag te beheer, het ons 'n medium -krag (12V/2A) relais in vaste toestand geskik vir wisselstroom gekies. Die relais verbind die pomp met die uitlaat en word beheer deur die Raspberry Pi se digitale pen.

Hoe ons die watervlak nagaan

Dit was vir ons belangrik om nie die konstruksie van die koffiemasjien te verander nie, daarom het ons besluit om die HC-SR04 Ultrasoniese nabyheidssensor te gebruik om die watervlak te meet.

Ons het 'n pasgemaakte watertenkbedekking met twee gate vir die sensor se emitters in 3D gedruk. Ons het maklik 'n GitHub-biblioteek vir die sensor gevind. Op hierdie punt was alle voorbereidings klaar.

Stap 2: Ontwerp die stelsel

Stelsel se logika

Die stelsel is ontwerp met die volgende eenvoudige logika in gedagte:

• Die stelsel monitor voortdurend die afstand tussen die sensor en die wateroppervlak.
• Elke keer as 'n afstandsverandering 'n drempelwaarde oorskry, stuur die stelsel inligting oor die toestand na die wolk.
• As die afstand die maksimum toegelate waarde oorskry (die tenk is leeg), aktiveer die stelsel die pomp en skakel dit af sodra die afstand minder as die minimum toegelate waarde is.
• Elke keer as die toestand van die stelsel verander (byvoorbeeld, die pomp word geaktiveer), stel dit die wolk in kennis.

In die geval van 'n fout, word 'n kennisgewing na 'n Slack -kanaal gestuur.

As die koffiemasjien ledig is, stuur die stelsel een keer per minuut die wolkdiens met diagnostiese data. Boonop stuur dit sy toestand elke 5 minute na die wolk.

As die pomp aktief is, stuur die stelsel meer gereeld, maar nie meer as een keer elke halfsekonde nie.

def send (cloud, variables, dist, error_code = 0, force = False): pump_on = is_pump_on () percent = calc_water_level_percent (dist) variables ['Distance'] ['value'] = dist variables ['WaterLevel'] [' waarde '] = persentasie veranderlikes [' PumpRelay '] [' waarde '] = pomp_on veranderlikes [' Status '] [' waarde '] = calc_status (error_code, persent, pomp_on)

huidige = tyd ()

globale laaste_sending_tyd as krag of huidige - laaste_sending_tyd> MIN_SEND_INTERVAL: lesings = wolk.lees_data () wolk.publish_data (lesings) laaste_sending_tyd = huidige

Werk met die pomp

Ons definieer die volgende konstantes as 'n basis vir die pomplogika.

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

# Pomp

START_PUMP = 1 STOP_PUMP = 0 PUMP_BOUNCE_TIME = 50 # millisekondes PUMP_STOP_TIMEOUT = 5 # sekondes

BELANGRIK: as u Pin 4 gaan gebruik, moet u nie vergeet om die 1-Wire raspi-config-opsie uit te skakel om konflik te voorkom nie.

By die aanvang van die program registreer ons 'n terugbel en stel die aanvanklike toestand op UIT.

Hier is die kode vir die funksie wat die pomp skakel:

def toggle_pump (waarde): as pump_disabled: terugkeer as is_pump_on ()! = waarde: log_debug ("[x] % s" % ('START' as waarde anders 'STOP')) GPIO.setup (GPIO_PUMP, GPIO. OUT) GPIO.uitvoer (GPIO_PUMP, waarde) # Begin/stop giet

Soos gedefinieer in die opstartkode hierbo, word die volgende terugbel genoem wanneer die relais AAN skakel:

pump_on = Onwaar def pump_relay_handle (pin): global pump_on pump_on = GPIO.input (GPIO_PUMP) log_debug ("Pump relay verander na % d" % pump_on)

In die terugbel stoor ons die huidige toestand van die pomp in 'n veranderlike. In die hooflus van die toepassing kan ons die oomblik opspoor wanneer die pomp skakel soos hieronder getoon:

def is_pump_on (): globale pomp_op terug pomp_on

as GPIO.event_detected (GPIO_PUMP):

is_pouring = is_pump_on () # … log_debug ('[!] Pompgebeurtenis opgespoor: % s' % ('Aan' as ander 'af' is))) stuur (wolk, veranderlikes, afstand, krag = Waar)

Meet die afstand

Dit is redelik maklik om die afstand na die wateroppervlak te meet met behulp van 'n ultrasoniese nabyheidssensor. In ons bewaarplek het ons 'n paar python -skrifte gedeel waarmee u 'n sensor kan toets.

In werklike toepassings kan sensorlesings wissel as gevolg van die weerkaatsingseffek van die sensor en watertoestande. In sommige gevalle kan lesings heeltemal ontbreek. Ons het 'n BounceFilter -klas geïmplementeer wat N onlangse waardes versamel, pieke weggooi en die gemiddelde van die oorblywende metings bereken. Die meetproses word geïmplementeer deur die volgende asinchrone algoritme.

# Hou die laaste sensormetingslesings = BounceFilter (grootte = 6, weggooi_getal = 1)

reading_complete = threading. Event ()

def wait_for_distance ():

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

indien nie lees_volledig.wag (MAX_READING_TIMEOUT):

log_info ('Timeout vir leessensor') terugkeer Geen lesings teruggee nie.avg ()

def read_distance ():

probeer: waarde = hcsr04.raw_distance (sample_size = 5) afgerond = waarde as die waarde niks anders is nie (waarde, 1) lesings.add (afgerond) behalwe Uitsondering as fout: log_error ('Interne fout: % s' % err) uiteindelik: reading_complete.set ()

U kan die volledige implementering van die filter in die bronne vind.

Stap 3: Hantering van noodsituasies

Wat as die sensor uitgebrand of afgeval het of na 'n verkeerde gebied wys? Ons het 'n manier nodig om sulke gevalle aan te meld, sodat ons handmatig kan optree.

As die sensor nie afstandmetings lewer nie, stuur die stelsel die gewysigde status na die wolk en genereer 'n ooreenstemmende kennisgewing.

Die logika word geïllustreer deur die onderstaande kode.

distance = wait_for_distance () # Lees die huidige waterdiepte as afstand Geen is: log_error ('Distance error!') notify_in_background (calc_alert (SENSOR_ERROR)) send (cloud, variables, distance, error_code = SENSOR_ERROR, force = True)

Ons het 'n operasionele watervlakbereik wat gehandhaaf moet word wanneer die sensor op sy plek is. Ons toets of die huidige watervlak in hierdie reeks val:

# Afstand van die sensor tot die watervlak # gebaseer op die watertenk van die koffiemasjien MIN_DISTANCE = 2 # cm MAX_DISTANCE = 8 # cm

# Afstand is buite die verwagte bereik: moenie begin stort nie

as afstand> MAX_DISTANCE * 2: log_error ('Distance is out of range: %.2f' % distance) continue

Ons skakel die pomp af as dit aktief was toe 'n fout opduik.

if is_pump_on () en prev_distance <STOP_PUMP_DISTANCE + DISTANCE_DELTA: log_error ('[!] Noodstop van die pomp. Geen sein van 'n afstandsensor nie')

skakelpomp (STOP_PUMP)

Ons verwerk die saak ook as die bottel nie meer water het nie. Ons kyk of die watervlak nie verander as die pomp loop nie. As dit die geval is, wag die stelsel 5 sekondes en kyk dan of die pomp afgeskakel is. As dit nie die geval is nie, implementeer die stelsel noodpompstop en stuur 'n foutkennisgewing.

PUMP_STOP_TIMEOUT = 5 # seksemergency_stop_time = Geen

def set_emergency_stop_time (nou, is_storting):

globale emergency_stop_time emergency_stop_time = nou + PUMP_STOP_TIMEOUT as / is_storting anders Geen

def check_water_source_empty (nou):

stuur noodstop_tyd terug en nou> noodstop_tyd

# --------- hooflus -----------

as GPIO.event_detected (GPIO_PUMP): is_pouring = is_pump_on () set_emergency_stop_time (nou, is_pouring) # …

globale pomp_gedeaktiveer

if check_water_source_empty (nou): log_error ('[!] Noodstop van die pomp. / Waterbron is leeg') toggle_pump (STOP_PUMP) pump_disabled = True

Hierbo is 'n voorbeeld van 'n boodskaplogboek wat tydens 'n noodstop gegenereer is.

Stap 4: Begin die stelsel 24/7

Die kode op die toestel is ontfout en loop sonder probleme. Ons het dit as 'n diens begin, sodat dit weer begin as die Raspberry Pi herlaai word. Vir die gemak het ons 'n Makefile geskep wat help met die implementering, die uitvoer van die diens en die lees van logboeke.

. PHONY: installeer run start stop stop logboek implement MAIN_FILE: = koffie-pomp/main.py SERVICE_INSTALL_SCRIPT: = service_install.sh SERVICE_NAME: = koffie-pomp.service

installeer:

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

hardloop:

sudo python3 $ (MAIN_FILE)

begin:

sudo systemctl begin $ (SERVICE_NAME)

status:

sudo systemctl status $ (SERVICE_NAME)

stop:

sudo systemctl stop $ (SERVICE_NAME)

Meld:

sudo journalctl -u koffie -pomp -sedert vandag

ontplooi:

rsync -av koffie-pomp sensor-opstelling Makefile *.sh pi@XX. XX. XXX. XXX: ~/

U kan hierdie lêer en al die vereiste skrifte in ons bewaarplek vind.

Stap 5: Wolkmonitering

Ons het Cloud4RPi gebruik om 'n bedieningspaneel te implementeer. Ons het eers widgets bygevoeg om die noodsaaklike parameters van die stelsel aan te dui.

Terloops, die widget vir die STATUS -veranderlike kan verskillende kleurskemas gebruik op grond van die waarde daarvan (sien die prent hierbo).

Ons het 'n grafiek -widget bygevoeg om dinamiese data te vertoon. In die onderstaande prentjie kan u die oomblik sien waarop die pomp AAN en UIT en die onderskeie watervlakke aanskakel.

As u 'n langer tydsduur ontleed, kan u pieke sien - dit was toe die pomp aan die gang was.

Met Cloud4RPi kan u ook verskillende gladde vlakke instel.

Stap 6: Dit werk

Dit werk! Die bedieningspaneel in sy geheel lyk soos hieronder getoon.

Tans werk ons outomatiese pomp al 'n paar weke en al wat ons hoef te doen is om waterbottels te vervang. Die volledige kode vir ons projek is beskikbaar in ons GitHub -bewaarplek.