Smart kaffemaskinpump styrd av Raspberry Pi & HC-SR04 ultraljudssensor och Cloud4RPi: 6 steg

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:42

I teorin, varje gång du går till kaffemaskinen för din morgonkopp, finns det bara en tjugotal chans att du måste fylla vattentanken. I praktiken verkar det dock som om maskinen på något sätt hittar ett sätt att alltid lägga den här orken på dig. Ju mer du vill ha kaffe, desto mer sannolikt är det att du får det fruktade meddelandet "fyll vattentanken". Mina kollegor tycker likadant om detta. Eftersom vi är nördarna bestämde vi oss för att implementera den teknik som skulle göra slut på detta.

Tillbehör

Vår utrustning

Vi har en SAECO Aulika Focus kaffemaskin. Fram till denna dag använde vi en handpump för att fylla maskinens vattentank från en standardvattenflaska på 5 liter (19 liter).

Våra mål

1. Använd en elektrisk pump som drivs av någon form av en styrenhet eller en mikrodator genom ett relä.
2. Ha ett sätt att mäta vattennivån i kaffemaskinens tank så att vårt system vet när det ska fyllas på.
3. Har medel för att styra systemet, helst i realtid från en mobil enhet.
4. Få aviseringar (via Slack eller en liknande tjänst) om något går fel med systemet.

Steg 1: Välja utrustning

Pumpen

En snabb webbsökning visar flera elektriska pumpmodeller som är designade för din valda vattenflaska. Sådana pumpar styrs vanligtvis av en ON/OFF-omkopplare (till exempel Hot Frost A12 eller SMixx ХL-D2). Här är pumpen vi valde för vårt projekt.

Kontrollenheten

Vi försökte flera enheter men bestämde oss för en Raspberry Pi på grund av följande fördelar:

• Den har en GPIO som gör att vi kan ansluta en närhetssensor
• Den stöder Python

Vi installerade en ny version av Raspbian Buster Lite och allt som krävs för att köra Python 3.

Hur vi växlar pumpen

För att styra effekten valde vi ett medium -effekt (12V/2A) halvledarrelä lämpligt för växelström. Reläet ansluter pumpen till uttaget och styrs av Raspberry Pi: s digitala stift.

Hur vi kontrollerar vattennivån

Det var viktigt för oss att inte ändra kaffemaskinens konstruktion, så vi bestämde oss för att använda HC-SR04 Ultrasonic närhetssensor för att mäta vattennivån.

Vi 3d-tryckt ett anpassat vattentanklock med två hål för sensorns sändare. Vi hittade enkelt ett GitHub-bibliotek för sensorn. Vid denna tidpunkt var alla förberedelser färdiga.

Steg 2: Designa systemet

Systemets logik

Systemet är utformat med följande enkla logik i åtanke:

• Systemet övervakar ständigt avståndet mellan sensorn och vattenytan.
• När en förändring i avstånd går över ett tröskelvärde skickar systemet information om sitt tillstånd till molnet.
• Om avståndet går över det högsta tillåtna värdet (tanken är tom), aktiverar systemet pumpen och stänger av den när avståndet är mindre än det lägsta tillåtna värdet.
• När systemets tillstånd ändras (till exempel pumpen aktiveras) informerar det molnet.

I händelse av ett fel skickas ett meddelande till en Slack -kanal.

När kaffemaskinen är inaktiv pingar systemet molntjänsten med diagnosdata en gång i minuten. Dessutom skickar den sin status till molnet var 5: e minut.

När pumpen är aktiv skickar systemet data oftare men inte mer än en gång var halv sekund.

def send (moln, variabler, dist, error_code = 0, force = False): pump_on = is_pump_on () procent = calc_water_level_percent (dist) variabler ['Distance'] ['value'] = dist variables ['WaterLevel'] [' värde '] = procent variabler [' PumpRelay '] [' värde '] = pump_on variabler [' Status '] [' värde '] = calc_status (error_code, procent, pump_on)

aktuell = 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

Arbeta med pumpen

Vi definierar följande konstanter som en bas för pumpdriftlogik.

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

# Pump

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

VIKTIGT: Om du ska använda Pin 4, glöm inte att inaktivera alternativet 1-Wire raspi-config för att undvika konflikter.

Vid programmets start registrerar vi ett återuppringning och ställer ut ursprungsläget till AV.

Här är koden för funktionen som växlar pumpen:

def toggle_pump (värde): 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ärde) # Starta/sluta hälla

Som definierat i startkoden ovan kallas följande återuppringning 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 ("Pumprelä ändrat till % d" % pump_on)

I återuppringningen sparar vi pumpens nuvarande tillstånd till en variabel. I programmets huvudslinga kan vi upptäcka det ögonblick då pumpen växlar enligt nedan:

def is_pump_on (): global pump_on return pump_on

om GPIO.event_detected (GPIO_PUMP):

is_pouring = is_pump_on () #… log_debug ('[!] Pumphändelse upptäckt: % s' % ('On' if is_pouring else 'Off')) send (moln, variabler, distans, kraft = True)

Mätning av avståndet

Det är ganska enkelt att mäta avståndet mot vattenytan med en ultraljudsavståndssensor. I vårt förråd delade vi ett par python -skript som låter dig testa en sensor.

I verkliga applikationer kan sensoravläsningar fluktuera på grund av sensorns studsande effekt och vattensvängningar. I vissa fall kan avläsningar saknas helt. Vi implementerade en BounceFilter -klass som ackumulerar N senaste värden, kasserar toppar och beräknar genomsnittet av återstående mätningar. Mätprocessen implementeras med följande asynkrona algoritm.

# Sparar de sista sensormätningarna läsningar = BounceFilter (storlek = 6, discard_count = 1)

reading_complete = threading. Event ()

def wait_for_distance ():

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

om inte läsning_komplett. vänta (MAX_READING_TIMEOUT):

log_info ('Lässensor timeout') return Inga returavläsningar. avg ()

def read_distance ():

försök: värde = hcsr04.raw_distance (sample_size = 5) avrundat = värde om värdet är Ingen annan runda (värde, 1) avläsningar.add (avrundad) utom Undantag som fel: log_error ('Internt fel: % s' % err) äntligen: reading_complete.set ()

Du kan hitta filterets fullständiga implementering i källorna.

Steg 3: Hantering av nödsituationer

Vad händer om sensorn brann ut, faller av eller pekar på fel område? Vi behövde ett sätt att rapportera sådana fall så att vi kan vidta manuella åtgärder.

Om sensorn inte ger avståndsmätningar skickar systemet den ändrade statusen till molnet och genererar en motsvarande avisering.

Logiken illustreras av koden nedan.

distance = wait_for_distance () # Läs det aktuella vattendjupet om avståndet är None: log_error ('Distance error!') notify_in_background (calc_alert (SENSOR_ERROR)) send (cloud, variables, distance, error_code = SENSOR_ERROR, force = True)

Vi har ett operativt vattennivåintervall som bör bibehållas när sensorn är på plats. Vi testar om den aktuella vattennivån faller inom detta område:

# Avstånd från sensorn till vattennivån # baserat på kaffemaskinens vattentank MIN_DISTANCE = 2 # cm MAX_DISTANCE = 8 # cm

# Avståndet ligger utanför förväntat område: börja inte hälla

om avstånd> MAX_DISTANCE * 2: log_error ('Avståndet är utanför intervallet: %.2f' % avstånd) fortsätt

Vi stänger av pumpen om den var aktiv när ett fel uppstod.

if is_pump_on () och prev_distance <STOP_PUMP_DISTANCE + DISTANCE_DELTA: log_error ('[!] Pumpens nödstopp. Ingen signal från en distanssensor')

växlingspump (STOP_PUMP)

Vi behandlar också fallet när flaskan tar slut på vatten. Vi kontrollerar om vattennivån inte ändras när pumpen går. I så fall väntar systemet i 5 sekunder och kontrollerar sedan om pumpen har stängts av. Om det inte gör det, genomför systemet nödstoppspumpen och skickar ett felmeddelande.

PUMP_STOP_TIMEOUT = 5 # secsemergency_stop_time = Ingen

def set_emergency_stop_time (nu, is_pouring):

global emergency_stop_time emergency_stop_time = nu + PUMP_STOP_TIMEOUT om / is_pouring annat Ingen

def check_water_source_empty (nu):

returnera emergency_stop_time och nu> emergency_stop_time

# --------- huvudslinga -----------

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

global pump_avaktiverad

if check_water_source_empty (nu): log_error ('[!] Pumpens nödstopp. / Vattenkällan är tom') toggle_pump (STOP_PUMP) pump_disabled = True

Ovan är ett exempel på en meddelandelogg som genererades under ett nödstopp.

Steg 4: Kör systemet 24/7

Koden på enheten felsöks och körs utan problem. Vi lanserade den som en tjänst, så den startar om om Raspberry Pi startas om. För enkelhets skull skapade vi en Makefile som hjälper till med distribution, drift av tjänsten och visning av loggar.

. PHONY: installera kör start start stopp status log distribuera MAIN_FILE: = kaffe-pump/main.py SERVICE_INSTALL_SCRIPT: = service_install.sh SERVICE_NAME: = kaffe-pump.service

Installera:

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

springa:

sudo python3 $ (MAIN_FILE)

Start:

sudo systemctl start $ (SERVICE_NAME)

status:

sudo systemctl status $ (SERVICE_NAME)

sluta:

sudo systemctl stopp $ (SERVICE_NAME)

logga:

sudo journalctl -u kaffepump -sedan idag

distribuera:

rsync -av kaffepumpsensorinställning Makefile *.sh pi@XX. XX. XXX. XXX: ~/

Du kan hitta den här filen och alla nödvändiga skript i vårt arkiv.

Steg 5: Molnövervakning

Vi använde Cloud4RPi för att implementera en kontrollpanel. Vi lade först till widgets för att ange systemets väsentliga parametrar.

Förresten, widgeten för STATUS -variabeln kan använda olika färgscheman baserat på dess värde (se bilden ovan).

Vi lade till en diagramwidget för att visa dynamiska data. På bilden nedan kan du se det ögonblick som pumpen slogs PÅ och AV och respektive vattennivåer.

Om du analyserar en längre tidsperiod kan du se toppar - det var då pumpen var igång.

Cloud4RPi låter dig också ställa in olika utjämningsnivåer.

Steg 6: It's Works

Det fungerar! Kontrollpanelen i sin helhet ser ut som visas nedan.

För närvarande har vår automatiska pump varit igång i flera veckor och allt vi behövde göra är att byta vattenflaskor. Hela koden för vårt projekt är tillgänglig i vårt GitHub -arkiv.