Slimme koffiemachinepomp bestuurd door Raspberry Pi & HC-SR04 ultrasone sensor en Cloud4RPi - Ajarnpa

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:16

In theorie, elke keer dat je naar de koffiemachine gaat voor je ochtendkopje, is er maar een kans van één op twintig dat je het waterreservoir moet vullen. In de praktijk lijkt het er echter op dat de machine op de een of andere manier een manier vindt om dit karwei altijd bij je te dragen. Hoe meer je koffie wilt, hoe groter de kans dat je de gevreesde melding "vul het waterreservoir" krijgt. Mijn collega's denken daar net zo over. Als nerds die we zijn, hebben we besloten om de technologie te implementeren die hier een einde aan zou maken.

Benodigdheden

Onze apparatuur

Wij hebben een SAECO Aulika Focus koffiezetapparaat. Tot op de dag van vandaag gebruikten we een handpomp om het waterreservoir van de machine te vullen met een standaard waterfles van 5 gallon (19L).

Onze doelen

1. Gebruik een elektrische pomp aangedreven door een soort controller of een microcomputer via een relais.
2. Een manier hebben om het waterniveau in de tank van de koffiemachine te meten, zodat ons systeem weet wanneer het moet worden bijgevuld.
3. Beschikken over middelen om het systeem te besturen, bij voorkeur in realtime vanaf een mobiel apparaat.
4. Ontvang meldingen (via Slack of een vergelijkbare dienst) als er iets misgaat met het systeem.

Stap 1: De apparatuur kiezen

De pomp

Een snelle zoekopdracht op het web toont verschillende modellen elektrische pompen die zijn ontworpen voor uw waterfles naar keuze. Dergelijke pompen worden meestal aangestuurd door een AAN/UIT-schakelaar (bijvoorbeeld Hot Frost A12 of SMixx ХL-D2). Dit is de pomp die we voor ons project hebben gekozen.

Het controller-apparaat

We hebben verschillende apparaten geprobeerd, maar zijn uitgekomen op een Raspberry Pi vanwege de volgende voordelen:

• Het heeft een GPIO waarmee we een naderingssensor kunnen aansluiten
• Het ondersteunt Python

We hebben een nieuwe versie van Raspbian Buster Lite geïnstalleerd en alles wat nodig is om Python 3 uit te voeren.

Hoe we de pomp wisselen

Om het vermogen te regelen, hebben we een halfvermogen (12V / 2A) solid-state relais gekozen dat geschikt is voor wisselstroom. Het relais verbindt de pomp met het stopcontact en wordt bestuurd door de digitale pin van de Raspberry Pi.

Hoe we het waterpeil controleren

Het was belangrijk voor ons om de constructie van de koffiemachine niet te veranderen, dus besloten we de HC-SR04 ultrasone naderingssensor te gebruiken om het waterniveau te meten.

We hebben een aangepaste watertankafdekking met twee gaten voor de zenders van de sensor 3D-geprint. We vonden gemakkelijk een GitHub-bibliotheek voor de sensor. Op dit punt waren alle voorbereidingen voltooid.

Stap 2: Het systeem ontwerpen

Systeemlogica

Het systeem is ontworpen met de volgende eenvoudige logica in gedachten:

• Het systeem bewaakt continu de afstand tussen de sensor en het wateroppervlak.
• Telkens wanneer een verandering in afstand een drempelwaarde overschrijdt, stuurt het systeem informatie over de status naar de cloud.
• Als de afstand de maximaal toegestane waarde overschrijdt (de tank is leeg), activeert het systeem de pomp en schakelt deze uit zodra de afstand kleiner is dan de minimaal toegestane waarde.
• Telkens wanneer de status van het systeem verandert (de pomp wordt bijvoorbeeld geactiveerd), informeert het de cloud.

Bij een fout wordt een melding naar een Slack-kanaal gestuurd.

Wanneer de koffiemachine inactief is, pingt het systeem eenmaal per minuut de cloudservice met diagnostische gegevens. Bovendien stuurt het elke 5 minuten zijn status naar de cloud.

Als de pomp actief is, verzendt het systeem vaker gegevens, maar niet vaker dan eens per halve seconde.

def send(cloud, variabelen, dist, error_code=0, force=False): pump_on = is_pump_on() procent = calc_water_level_percent(dist) variabelen['Distance']['value'] = dist variabelen['WaterLevel'][' value'] = procent variabelen['PumpRelay']['value'] = pump_on variabelen['Status']['value'] = calc_status(error_code, percent, pump_on)

huidige = tijd()

globale last_sending_time indien geforceerd of actueel - last_sending_time > MIN_SEND_INTERVAL: metingen = cloud.read_data() cloud.publish_data(metingen) last_sending_time = huidig

Werken met de pomp

We definiëren de volgende constanten als basis voor de pompwerkingslogica.

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

# Pomp

START_PUMP = 1 STOP_PUMP = 0 PUMP_BOUNCE_TIME = 50 # milliseconden PUMP_STOP_TIMEOUT = 5 # sec

BELANGRIJK: Als u Pin 4 gaat gebruiken, vergeet dan niet om de 1-Wire raspi-config optie uit te schakelen om conflicten te voorkomen.

Bij het opstarten van het programma registreren we een callback en zetten we de beginstatus op OFF.

Hier is de code voor de functie die de pomp schakelt:

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, waarde) # Start/stop met gieten

Zoals gedefinieerd in de opstartcode hierboven, wanneer het relais AAN wordt gezet, wordt de volgende terugroepactie aangeroepen:

pump_on = False def pump_relay_handle(pin): global pump_on pump_on = GPIO.input(GPIO_PUMP) log_debug("Pomprelais gewijzigd in %d" % pump_on)

In de callback slaan we de huidige status van de pomp op in een variabele. In de hoofdlus van de toepassing kunnen we het moment detecteren waarop de pomp schakelt, zoals hieronder weergegeven:

def is_pump_on(): global pump_on retourpomp_on

indien GPIO.event_detected (GPIO_PUMP):

is_pouring = is_pump_on() # … log_debug('[!] Pompgebeurtenis gedetecteerd: %s' % ('Aan' if is_pouring else 'Uit')) send(cloud, variabelen, afstand, force=True)

De afstand meten

Het is vrij eenvoudig om de afstand tot het wateroppervlak te meten met behulp van een ultrasone naderingssensor. In onze repository hebben we een aantal python-scripts gedeeld waarmee je een sensor kunt testen.

In echte toepassingen kunnen sensormetingen fluctueren vanwege het stuiterende effect van de sensor en wateroscillaties. In sommige gevallen kunnen metingen volledig ontbreken. We hebben een BounceFilter-klasse geïmplementeerd die N recente waarden verzamelt, pieken weggooit en het gemiddelde van de resterende metingen berekent. Het meetproces wordt geïmplementeerd door het volgende asynchrone algoritme.

# Houdt de laatste sensormetingen bij = BounceFilter(size=6, throw_count=1)

reading_complete = threading. Event()

def wait_for_distance():

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

indien niet reading_complete.wait(MAX_READING_TIMEOUT):

log_info('Time-out sensor uitlezing') return Geen return readings.avg()

def read_distance():

try: value = hcsr04.raw_distance(sample_size=5) afgerond = waarde als waarde Geen anders is round(value, 1) readings.add(afgerond) uitzondering Uitzondering als err: log_error('Interne fout: %s' % err) eindelijk: reading_complete.set()

U vindt de volledige implementatie van het filter in de bronnen.

Stap 3: Omgaan met noodsituaties

Wat als de sensor doorbrandt, eraf valt of naar een verkeerd gebied wijst? We hadden een manier nodig om dergelijke gevallen te melden, zodat we handmatig actie kunnen ondernemen.

Als de sensor geen afstandsmetingen geeft, stuurt het systeem de gewijzigde status naar de cloud en genereert een bijbehorende melding.

De logica wordt geïllustreerd door de onderstaande code.

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

We hebben een operationeel waterniveaubereik dat moet worden gehandhaafd wanneer de sensor op zijn plaats zit. We testen of het huidige waterpeil in dit bereik valt:

# Afstand van de sensor tot het waterniveau# gebaseerd op het waterreservoir van de koffiemachine MIN_DISTANCE = 2 # cm MAX_DISTANCE = 8 # cm

# Afstand valt buiten verwacht bereik: begin niet met gieten

if distance > MAX_DISTANCE * 2: log_error('Distance is out of range: %.2f' % distance) doorgaan

We zetten de pomp uit als deze actief was toen er een fout optrad.

if is_pump_on() and prev_distance < STOP_PUMP_DISTANCE + DISTANCE_DELTA: log_error('[!] Noodstop van de pomp. Geen signaal van een afstandssensor')

toggle_pump(STOP_PUMP)

We verwerken ook de zaak wanneer de fles zonder water komt te zitten. We controleren of het waterpeil niet verandert als de pomp draait. Als dit het geval is, wacht het systeem 5 seconden en controleert vervolgens of de pomp is uitgeschakeld. Als dit niet het geval is, implementeert het systeem een noodstop van de pomp en stuurt het een foutmelding.

PUMP_STOP_TIMEOUT = 5 # secsemergency_stop_time = Geen

def set_emergency_stop_time (nu, is_pouring):

global emergency_stop_time emergency_stop_time = nu + PUMP_STOP_TIMEOUT als / is_pouring else Geen

def check_water_source_empty(nu):

return emergency_stop_time en nu > emergency_stop_time

# --------- Hoofdlus -----------

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

global pump_disabled

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

Hierboven ziet u een voorbeeld van een berichtenlogboek dat wordt gegenereerd tijdens een noodstop.

Stap 4: Het systeem 24/7 laten draaien

De code op het apparaat is gedebugd en werkt zonder problemen. We hebben het gelanceerd als een service, dus het herstart als de Raspberry Pi opnieuw wordt opgestart. Voor het gemak hebben we een Makefile gemaakt die helpt bij de implementatie, het uitvoeren van de service en het bekijken van logboeken.

. PHONY: installeren uitvoeren start stop statuslogboek implementeren MAIN_FILE:= coffee-pump/main.py SERVICE_INSTALL_SCRIPT:= service_install.sh SERVICE_NAME:= coffee-pump.service

installeren:

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

loop:

sudo python3 $(MAIN_FILE)

begin:

sudo systemctl start $(SERVICE_NAME)

toestand:

sudo systemctl-status $(SERVICE_NAME)

stop:

sudo systemctl stop $(SERVICE_NAME)

log:

sudo journalctl -u coffee-pump --sinds vandaag

aanwenden:

rsync -av coffee-pump sensor-setup Makefile *.sh pi@XX. XX. XXX. XXX:~/

U vindt dit bestand en alle benodigde scripts in onze repository.

Stap 5: Cloudbewaking

We hebben Cloud4RPi gebruikt om een controlepaneel te implementeren. We hebben eerst widgets toegevoegd om de essentiële systeemparameters aan te geven.

Trouwens, de widget voor de STATUS-variabele kan verschillende kleurenschema's gebruiken op basis van zijn waarde (zie de afbeelding hierboven).

We hebben een grafiekwidget toegevoegd om dynamische gegevens weer te geven. In de onderstaande afbeelding ziet u het moment waarop de pomp AAN en UIT ging en de respectieve waterstanden.

Als u een langere tijdspanne analyseert, kunt u pieken zien - toen draaide de pomp.

Met Cloud4RPi kunt u ook verschillende afvlakkingsniveaus instellen.

Stap 6: Het werkt

Het werkt! Het bedieningspaneel ziet er in zijn geheel uit zoals hieronder weergegeven.

Momenteel draait onze automatische pomp al enkele weken en hoeven we alleen nog maar de waterflessen te vervangen. De volledige code voor ons project is beschikbaar in onze GitHub-repository.