Smart kaffemaskinepumpe styret af Raspberry Pi & HC-SR04 ultralydssensor og Cloud4RPi: 6 trin

2024 Forfatter: John Day | [email protected]. Sidst ændret: 2024-01-30 08:27

I teorien er der hver gang du går til kaffemaskinen til din morgenkop, kun en en-i-tyve chance for at du skal fylde vandtanken. I praksis ser det imidlertid ud til, at maskinen på en eller anden måde finder en måde at altid lægge denne opgave på dig. Jo mere du vil have kaffe, jo mere sandsynligt er det, at du får den frygtede meddelelse om "fyld vandtanken". Mine kolleger har det på samme måde med dette. Da vi er de nørder, vi besluttede at implementere den teknologi, der ville gøre en ende på dette.

Forbrugsvarer

Vores udstyr

Vi har en SAECO Aulika Focus kaffemaskine. Indtil denne dag brugte vi en håndpumpe til at fylde maskinens vandtank fra en standard 5 Gallon (19L) vandflaske.

Vores mål

1. Brug en elektrisk pumpe drevet af en slags controller eller en mikrocomputer gennem et relæ.
2. Hav en måde at måle vandstanden i kaffemaskinens tank, så vores system ved, hvornår det skal genopfyldes.
3. Har midler til at styre systemet, helst i realtid fra en mobil enhed.
4. Modtag meddelelser (via Slack eller en lignende service), hvis noget går galt med systemet.

Trin 1: Valg af udstyr

Pumpen

En hurtig websøgning viser flere elektriske pumpemodeller designet til din vandflaske efter eget valg. Sådanne pumper styres normalt med en ON/OFF-kontakt (f.eks. Hot Frost A12 eller SMixx ХL-D2). Her er pumpen, vi valgte til vores projekt.

Controller -enheden

Vi forsøgte flere enheder, men aftalte på en Raspberry Pi på grund af følgende fordele:

• Den har en GPIO, der giver os mulighed for at tilslutte en nærhedssensor
• Det understøtter Python

Vi installerede en ny version af Raspbian Buster Lite og alt, hvad der kræves for at køre Python 3.

Sådan skifter vi pumpen

For at styre strømmen valgte vi et medium -power (12V/2A) solid state relæ egnet til vekselstrøm. Relæet forbinder pumpen med stikkontakten og styres af Raspberry Pi's digitale pin.

Sådan kontrollerer vi vandstanden

Det var vigtigt for os ikke at ændre kaffemaskinens konstruktion, så vi besluttede at bruge HC-SR04 ultralydssensor til at måle vandstanden.

Vi 3d-printede et brugerdefineret vandtankdæksel med to huller til sensorens emittere. Vi fandt let et GitHub-bibliotek til sensoren. På dette tidspunkt var alle forberedelser færdige.

Trin 2: Design af systemet

Systemets logik

Systemet er designet med følgende enkle logik i tankerne:

• Systemet overvåger konstant afstanden mellem sensoren og vandoverfladen.
• Når en ændring i afstand går over en tærskelværdi, sender systemet oplysninger om sin tilstand til skyen.
• Hvis afstanden går over den maksimalt tilladte værdi (tanken er tom), aktiverer systemet pumpen og slukker den, når afstanden er mindre end den tilladte minimumsværdi.
• Når systemets tilstand ændres (f.eks. Aktiveres pumpen), informerer den skyen.

I tilfælde af en fejl sendes en meddelelse til en Slack -kanal.

Når kaffemaskinen er inaktiv, pinger systemet cloudtjenesten med diagnosedata en gang hvert minut. Derudover sender den sin tilstand til skyen hvert 5. minut.

Når pumpen er aktiv, sender systemet data oftere, men ikke mere end en gang hvert halve sekund.

def send (sky, variabler, dist, error_code = 0, force = False): pump_on = is_pump_on () procent = calc_water_level_percent (dist) variabler ['Distance'] ['værdi'] = dist variabler ['WaterLevel'] [' værdi '] = procentvariabler [' PumpRelay '] [' værdi '] = pumpe_variabler [' Status '] [' værdi '] = calc_status (fejlkode, procent, pumpeon)

nuværende = tid ()

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

Arbejde med pumpen

Vi definerer følgende konstanter som en base for pumpedriftslogik.

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

# Pumpe

START_PUMP = 1 STOP_PUMP = 0 PUMP_BOUNCE_TIME = 50 # millisekunder PUMP_STOP_TIMEOUT = 5 # sekunder

VIGTIGT: Hvis du vil bruge Pin 4, skal du ikke glemme at deaktivere 1-Wire raspi-config-indstillingen for at undgå konflikter.

Ved programmets opstart registrerer vi et tilbagekald og sætter den oprindelige tilstand til OFF.

Her er koden til den funktion, der skifter pumpen:

def toggle_pump (værdi): 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, værdi) # Start/Stop hældning

Som defineret i opstartskoden ovenfor, kaldes følgende opkald, når relæet tændes:

pump_on = Falsk def pump_relay_handle (pin): global pump_on pump_on = GPIO.input (GPIO_PUMP) log_debug ("Pumpe relæ ændret til % d" % pump_on)

I tilbagekaldelsen gemmer vi pumpens aktuelle tilstand til en variabel. I programmets hovedsløjfe kan vi registrere det øjeblik, hvor pumpen skifter som vist nedenfor:

def is_pump_on (): global pump_on return pump_on

hvis GPIO.event_detected (GPIO_PUMP):

is_pouring = is_pump_on () #… log_debug ('[!] Pumpehændelse registreret: % s' % ('On' if is_pouring else 'Off')) send (cloud, variabler, distance, force = True)

Måling af afstanden

Det er ret let at måle afstanden mod vandoverfladen ved hjælp af en ultralydssensor. I vores depot delte vi et par python -scripts, der giver dig mulighed for at teste en sensor.

I virkelige applikationer kan sensoraflæsninger svinge på grund af sensorens hoppende effekt og vandoscillationer. I nogle tilfælde kan aflæsninger helt mangle. Vi implementerede en BounceFilter -klasse, der akkumulerer N nylige værdier, kasserer toppe og beregner gennemsnittet af de resterende målinger. Måleprocessen implementeres ved følgende asynkrone algoritme.

# Beholder de sidste sensormålinger læsninger = BounceFilter (størrelse = 6, discard_count = 1)

reading_complete = threading. Event ()

def wait_for_distance ():

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

hvis ikke læsning_komplet.venter (MAX_READING_TIMEOUT):

log_info ('Reading sensor timeout') return None return return.avg ()

def read_distance ():

prøv: værdi = hcsr04.raw_distance (sample_size = 5) afrundet = værdi, hvis værdien er Ingen anden runde (værdi, 1) aflæsninger. tilføj (afrundet) undtagen Undtagelse som fejl: log_error ('Intern fejl: % s' % fejl) endelig: reading_complete.set ()

Du kan finde filterets fulde implementering i kilderne.

Trin 3: Håndtering af nødsituationer

Hvad hvis sensoren brændte ud, eller faldt af eller peger på et forkert område? Vi havde brug for en måde at rapportere sådanne sager på, så vi kan handle manuelt.

Hvis sensoren ikke giver afstandsmålinger, sender systemet den ændrede status til skyen og genererer en tilsvarende meddelelse.

Logikken illustreres af nedenstående kode.

distance = wait_for_distance () # Læs den aktuelle vanddybde, hvis afstanden er None: log_error ('Distance error!') notify_in_background (calc_alert (SENSOR_ERROR)) send (cloud, variabler, distance, error_code = SENSOR_ERROR, force = True)

Vi har et operationelt vandstandsområde, der bør opretholdes, når sensoren er på plads. Vi tester, om det aktuelle vandniveau falder i dette område:

# Afstand fra sensoren til vandstanden # baseret på kaffemaskinens vandtank MIN_DISTANCE = 2 # cm MAX_DISTANCE = 8 # cm

# Afstand er uden for forventet område: start ikke med at hælde

hvis afstand> MAX_DISTANCE * 2: log_error ('Distance er uden for område: %.2f' % distance) fortsætter

Vi slukker pumpen, hvis den var aktiv, da der opstod en fejl.

hvis is_pump_on () og prev_distance <STOP_PUMP_DISTANCE + DISTANCE_DELTA: log_error ('[!] Nødstop af pumpen. Intet signal fra en afstandssensor')

skiftepumpe (STOP_PUMP)

Vi behandler også sagen, når flasken løber tør for vand. Vi kontrollerer, om vandstanden ikke ændres, når pumpen kører. I så fald venter systemet i 5 sekunder og kontrollerer derefter, om pumpen er slukket. Hvis den ikke har det, implementerer systemet nødpumpens nedlukning og sender en fejlmeddelelse.

PUMP_STOP_TIMEOUT = 5 # secsemergency_stop_time = Ingen

def set_emergency_stop_time (nu, er_pouring):

global emergency_stop_time emergency_stop_time = nu + PUMP_STOP_TIMEOUT hvis / er_udgydelse andet Ingen

def check_water_source_empty (nu):

returner emergency_stop_time og nu> emergency_stop_time

# --------- hovedsløjfe -----------

hvis GPIO.event_detected (GPIO_PUMP): is_pouring = is_pump_on () set_emergency_stop_time (nu, is_pouring) # …

global pumpe_deaktiveret

hvis check_water_source_empty (nu): log_error ('[!] Nødstop af pumpen. / Vandkilde er tom') toggle_pump (STOP_PUMP) pump_disabled = True

Ovenfor er et eksempel på en meddelelseslog genereret under et nødstop.

Trin 4: Kørsel af systemet 24/7

Koden på enheden debugges og kører uden problemer. Vi lancerede det som en service, så det genstarter, hvis Raspberry Pi genstartes. For nemheds skyld har vi oprettet en Makefile, der hjælper med implementering, drift af tjenesten og visning af logfiler.

. PHONY: installer kør start stop status log implement MAIN_FILE: = kaffe-pumpe/main.py SERVICE_INSTALL_SCRIPT: = service_install.sh SERVICE_NAME: = kaffe-pump.service

installere:

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

løb:

sudo python3 $ (MAIN_FILE)

Start:

sudo systemctl start $ (SERVICE_NAME)

status:

sudo systemctl status $ (SERVICE_NAME)

hold op:

sudo systemctl stop $ (SERVICE_NAME)

log:

sudo journalctl -u kaffepumpe -siden i dag

indsætte:

rsync -av kaffe-pumpe sensor-opsætning Makefile *.sh pi@XX. XX. XXX. XXX: ~/

Du kan finde denne fil og alle de nødvendige scripts i vores lager.

Trin 5: Cloudovervågning

Vi brugte Cloud4RPi til at implementere et kontrolpanel. Vi tilføjede først widgets for at angive systemets væsentlige parametre.

Forresten kan widgeten til STATUS -variablen bruge forskellige farveskemaer baseret på dens værdi (se billedet ovenfor).

Vi tilføjede en diagramwidget til visning af dynamiske data. På billedet herunder kan du se det øjeblik, hvor pumpen blev tændt og slukket og de respektive vandniveauer.

Hvis du analyserer et længere tidsinterval, kan du se toppe - det var da pumpen kørte.

Cloud4RPi giver dig også mulighed for at indstille forskellige udjævningsniveauer.

Trin 6: Det virker

Det virker! Kontrolpanelet ser i sin helhed ud som vist herunder.

I øjeblikket har vores automatiske pumpe kørt i flere uger, og alt, hvad vi skulle gøre, er at udskifte vandflasker. Den fulde kode til vores projekt er tilgængelig i vores GitHub -depot.