Smart kaffemaskinpumpe kontrollert av Raspberry Pi og HC-SR04 ultralydssensor og Cloud4RPi: 6 trinn

2024 Forfatter: John Day | [email protected]. Sist endret: 2024-01-30 11:22

I teorien, hver gang du går til kaffemaskinen for morgenkoppen, er det bare en av tjue sjanser du må fylle vanntanken. I praksis ser det imidlertid ut til at maskinen på en eller annen måte finner en måte å alltid legge denne plikten på deg. Jo mer du vil ha kaffe, desto mer sannsynlig er det at du får den fryktede meldingen "fyll vannbeholderen". Mine kolleger føler det samme om dette. Som de nerdene vi er, bestemte vi oss for å implementere teknologien som ville sette en stopper for dette.

Rekvisita

Vårt utstyr

Vi har en SAECO Aulika Focus kaffemaskin. Fram til i dag brukte vi en håndpumpe for å fylle maskinens vanntank fra en standard 5 liter (19 liter) vannflaske.

Våre mål

1. Bruk en elektrisk pumpe drevet av en slags kontroller eller en mikrodatamaskin gjennom et relé.
2. Ha en måte å måle vannivået i kaffemaskinens tank, slik at systemet vårt vet når det skal fylles på igjen.
3. Har midler til å kontrollere systemet, helst i sanntid fra en mobil enhet.
4. Motta varsler (gjennom Slack eller en lignende tjeneste) hvis noe går galt med systemet.

Trinn 1: Velge utstyr

Pumpen

Et raskt websøk vil vise flere elektriske pumpemodeller designet for din valgfrie vannflaske. Slike pumper styres vanligvis med en PÅ/AV-bryter (for eksempel Hot Frost A12 eller SMixx ХL-D2). Her er pumpen vi valgte for prosjektet vårt.

Kontrollenheten

Vi prøvde flere enheter, men slo oss ned på en Raspberry Pi på grunn av følgende fordeler:

• Den har en GPIO som lar oss koble til en nærhetssensor
• Den støtter Python

Vi installerte en ny versjon av Raspbian Buster Lite og alt som kreves for å kjøre Python 3.

Hvordan vi bytter pumpen

For å kontrollere strømmen valgte vi et medium -power (12V/2A) solid state relé egnet for vekselstrøm. Reléet kobler pumpen til uttaket og styres av Raspberry Pi's digitale pinne.

Hvordan sjekker vi vannstanden

Det var viktig for oss å ikke endre kaffemaskinens konstruksjon, så vi bestemte oss for å bruke HC-SR04 ultralyd nærhetssensor for å måle vannivået.

Vi 3d-trykte et tilpasset vanntankdeksel med to hull for sensorens sendere. Vi fant enkelt et GitHub-bibliotek for sensoren. På dette tidspunktet var alle forberedelsene ferdige.

Trinn 2: Designe systemet

Systemets logikk

Systemet er designet med følgende enkle logikk i tankene:

• Systemet overvåker konstant avstanden mellom sensoren og vannoverflaten.
• Når en endring i avstand går over en terskelverdi, sender systemet informasjon om tilstanden til skyen.
• Hvis avstanden går over den maksimalt tillatte verdien (tanken er tom), aktiverer systemet pumpen og slår den av når avstanden er mindre enn den minste tillatte verdien.
• Når systemets tilstand endres (for eksempel pumpen aktiveres), informerer den skyen.

I tilfelle en feil, sendes et varsel til en Slack -kanal.

Når kaffemaskinen er inaktiv, pinger systemet skytjenesten med diagnosedata en gang hvert minutt. I tillegg sender den sin tilstand til skyen hvert 5. minutt.

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

def send (sky, variabler, dist, error_code = 0, force = False): pump_on = is_pump_on () prosent = calc_water_level_percent (dist) variabler ['Distance'] ['value'] = dist variables ['WaterLevel'] [' verdi '] = prosentvariabler [' PumpRelay '] [' verdi '] = pumpe_variabler [' Status '] [' verdi '] = kalk_status (feilkode, prosent, pumpe_på)

nåvæ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

Arbeider med pumpen

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

# 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

VIKTIG: Hvis du skal bruke Pin 4, ikke glem å deaktivere alternativet 1-Wire raspi-config for å unngå konflikter.

Ved oppstart av programmet registrerer vi et tilbakeringing og setter starttilstanden til AV.

Her er koden for funksjonen som bytter pumpen:

def toggle_pump (verdi): 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, verdi) # Start/Stopp hell

Som definert i oppstartskoden ovenfor, kalles følgende tilbakeringing når reléet slås PÅ:

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

I tilbakeringingen lagrer vi pumpens nåværende tilstand til en variabel. I programmets hovedsløyfe kan vi oppdage øyeblikket når pumpen veksler 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 ('[!] Pumpehendelse oppdaget: % s' % ('On' if is_pouring else 'Off')) send (sky, variabler, distanse, force = True)

Måling av avstanden

Det er ganske enkelt å måle avstanden mot vannoverflaten ved hjelp av en ultralyd nærhetssensor. I vårt depot delte vi et par python -skript som lar deg teste en sensor.

I virkelige applikasjoner kan sensoravlesninger svinge på grunn av sensorens hoppende effekt og vannsvingninger. I noen tilfeller kan avlesninger mangle helt. Vi implementerte en BounceFilter -klasse som akkumulerer N nylige verdier, forkaster topper og beregner gjennomsnittet av gjenværende målinger. Måleprosessen implementeres av følgende asynkrone algoritme.

# Beholder de siste sensormålingene = 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 lesing_komplett.venter (MAX_READING_TIMEOUT):

log_info ('Tidsavbrudd for lesesensor') retur Ingen returavlesninger. avg ()

def read_distance ():

prøv: verdi = hcsr04.raw_distance (sample_size = 5) avrundet = verdi hvis verdien er Ingen andre runde (verdi, 1) avlesninger. legg til (avrundet) unntatt Unntak som feil: log_error ('Intern feil: % s' % err) endelig: reading_complete.set ()

Du kan finne filterets fulle implementering i kildene.

Trinn 3: Håndtering av nødssituasjoner

Hva om sensoren brant ut, eller falt av eller peker på et feil område? Vi trengte en måte å rapportere slike saker på, slik at vi kan iverksette manuelle tiltak.

Hvis sensoren ikke gir avstandsmålinger, sender systemet den endrede statusen til skyen og genererer en tilsvarende melding.

Logikken er illustrert med koden nedenfor.

distance = wait_for_distance () # Les gjeldende vanndybde hvis avstanden er Ingen: log_error ('Distance error!') notify_in_background (calc_alert (SENSOR_ERROR)) send (cloud, variables, distance, error_code = SENSOR_ERROR, force = True)

Vi har et operativt vannstandsområde som bør opprettholdes når sensoren er på plass. Vi tester om gjeldende vannstand faller i dette området:

# Avstand fra sensoren til vannstanden # basert på kaffemaskinens vanntank MIN_DISTANCE = 2 # cm MAX_DISTANCE = 8 # cm

# Avstand er utenfor forventet område: ikke begynn å helle

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

Vi slår av pumpen hvis den var aktiv da det oppstod en feil.

hvis is_pump_on () og prev_distance <STOP_PUMP_DISTANCE + DISTANCE_DELTA: log_error ('[!] Nødstopp av pumpen. Ingen signal fra en distansesensor')

vekselpumpe (STOP_PUMP)

Vi behandler også saken når flasken går tom for vann. Vi sjekker om vannstanden ikke endres når pumpen går. I så fall venter systemet i 5 sekunder og kontrollerer deretter om pumpen er slått av. Hvis den ikke har det, implementerer systemet nødpumpestopp og sender en feilmelding.

PUMP_STOP_TIMEOUT = 5 # secsemergency_stop_time = Ingen

def set_emergency_stop_time (nå, is_pouring):

global emergency_stop_time emergency_stop_time = nå + PUMP_STOP_TIMEOUT hvis / er_tømming annet Ingen

def check_water_source_empty (nå):

returner emergency_stop_time og nå> emergency_stop_time

# --------- hovedsløyfe -----------

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

global pumpe_deaktivert

if check_water_source_empty (nå): log_error ('[!] Nødstopp av pumpen. / Vannkilden er tom') toggle_pump (STOP_PUMP) pump_disabled = True

Over er et eksempel på en meldingslogg generert under et nødstopp.

Trinn 4: Kjøre systemet 24/7

Koden på enheten er feilsøket og kjører uten problemer. Vi lanserte den som en tjeneste, så den starter på nytt hvis Raspberry Pi startes på nytt. For enkelhets skyld opprettet vi en Makefile som hjelper med distribusjon, drift av tjenesten og visning av logger.

. PHONY: installer kjøre start stopp status logg distribusjon MAIN_FILE: = kaffe-pumpe/main.py SERVICE_INSTALL_SCRIPT: = service_install.sh SERVICE_NAME: = kaffe-pumpe.service

installere:

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

løpe:

sudo python3 $ (MAIN_FILE)

start:

sudo systemctl start $ (SERVICE_NAME)

status:

sudo systemctl status $ (SERVICE_NAME)

Stoppe:

sudo systemctl stopp $ (SERVICE_NAME)

Logg:

sudo journalctl -u kaffepumpe -siden i dag

utplassere:

rsync -av kaffepumpesensoroppsett Makefile *.sh pi@XX. XX. XXX. XXX: ~/

Du finner denne filen og alle nødvendige skript i vårt depot.

Trinn 5: Cloud Monitoring

Vi brukte Cloud4RPi for å implementere et kontrollpanel. Vi la først til widgets for å indikere systemets viktige parametere.

Forresten, widgeten for STATUS -variabelen kan bruke forskjellige fargevalg basert på verdien (se bildet ovenfor).

Vi la til en kart widget for å vise dynamiske data. På bildet nedenfor kan du se øyeblikket pumpen slo seg PÅ og AV og de respektive vannstandene.

Hvis du analyserer et lengre tidsrom, kan du se topper - det var da pumpen var i gang.

Cloud4RPi lar deg også angi forskjellige utjevningsnivåer.

Trinn 6: It's Works

Det fungerer! Kontrollpanelet i sin helhet ser ut som vist nedenfor.

For øyeblikket har vår automatiske pumpe gått i flere uker, og alt vi trengte å gjøre er å bytte vannflasker. Hele koden for prosjektet vårt er tilgjengelig i vårt GitHub -depot.