Pompa Mesin Kopi Cerdas Dikendalikan oleh Sensor Ultrasonik Raspberry Pi & HC-SR04 dan Cloud4RPi: 6 Langkah

2024 Pengarang: John Day | [email protected]. Terakhir diubah: 2024-01-30 09:55

Secara teori, setiap kali Anda pergi ke mesin kopi untuk minum kopi di pagi hari, hanya ada satu dari dua puluh kemungkinan Anda harus mengisi tangki air. Namun, dalam praktiknya, tampaknya mesin itu entah bagaimana menemukan cara untuk selalu memberikan tugas ini pada Anda. Semakin banyak Anda menginginkan kopi, semakin besar kemungkinan Anda menerima pesan "isi tangki air" yang menakutkan. Rekan-rekan saya merasakan hal yang sama tentang hal ini. Menjadi kutu buku, kami memutuskan untuk menerapkan teknologi yang akan mengakhiri ini.

Perlengkapan

Peralatan kami

Kami memiliki mesin kopi SAECO Aulika Focus. Sampai hari ini, kami menggunakan pompa tangan untuk mengisi tangki air mesin dari botol air standar 5 Galon (19L).

Tujuan kita

1. Gunakan pompa listrik yang digerakkan oleh semacam pengontrol atau komputer mikro melalui relai.
2. Memiliki cara untuk mengukur ketinggian air di tangki mesin kopi sehingga sistem kami tahu kapan harus mengisi ulang.
3. Memiliki sarana untuk mengontrol sistem, sebaiknya secara real-time dari perangkat seluler.
4. Terima pemberitahuan (melalui Slack atau layanan serupa) jika ada yang tidak beres dengan sistem.

Langkah 1: Memilih Peralatan

Pompa

Pencarian web cepat akan menunjukkan beberapa model pompa listrik yang dirancang untuk botol air pilihan Anda. Pompa semacam itu biasanya dikendalikan oleh sakelar ON/OFF (misalnya, Hot Frost A12 atau SMixx L-D2). Inilah pompa yang kami pilih untuk proyek kami.

Perangkat Pengontrol

Kami mencoba beberapa perangkat tetapi memilih Raspberry Pi karena keuntungan berikut:

• Ini memiliki GPIO yang memungkinkan kita untuk menghubungkan sensor jarak
• Ini mendukung Python

Kami menginstal versi baru Raspbian Buster Lite dan semua yang diperlukan untuk menjalankan Python 3.

Bagaimana Kami Mengaktifkan Pompa

Untuk mengontrol daya, kami memilih relai solid state berdaya sedang (12V/2A) yang cocok untuk arus bolak-balik. Relai menghubungkan pompa ke stopkontak dan dikendalikan oleh pin digital Raspberry Pi.

Bagaimana Kami Memeriksa Ketinggian Air

Penting bagi kami untuk tidak mengubah konstruksi mesin kopi, jadi kami memutuskan untuk menggunakan sensor proximity Ultrasonic HC-SR04 untuk mengukur ketinggian air.

Kami mencetak 3d penutup tangki air khusus dengan dua lubang untuk pemancar sensor. Kami dengan mudah menemukan perpustakaan GitHub untuk sensor. Pada titik ini semua persiapan telah selesai.

Langkah 2: Merancang Sistem

Logika Sistem

Sistem ini dirancang dengan logika sederhana berikut dalam pikiran:

• Sistem secara konstan memonitor jarak antara sensor dan permukaan air.
• Setiap kali perubahan jarak melewati nilai ambang batas, sistem mengirimkan informasi tentang statusnya ke cloud.
• Jika jarak melewati nilai maksimum yang diizinkan (tangki kosong), sistem akan mengaktifkan pompa dan mematikannya setelah jarak kurang dari nilai minimum yang diizinkan.
• Setiap kali status sistem berubah (misalnya, pompa aktif), ia memberi tahu cloud.

Jika terjadi kesalahan, pemberitahuan dikirim ke saluran Slack.

Saat mesin kopi dalam keadaan idle, sistem melakukan ping ke layanan cloud dengan data diagnostik setiap menit sekali. Selain itu, ia mengirimkan statusnya ke cloud setiap 5 menit.

Saat pompa aktif, sistem mengirimkan data lebih sering tetapi tidak lebih dari sekali setiap setengah detik.

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

saat ini = waktu()

global last_sending_time jika force atau current - last_sending_time > MIN_SEND_INTERVAL: readings = cloud.read_data() cloud.publish_data(readings) last_sending_time = current

Bekerja dengan Pompa

Kami mendefinisikan konstanta berikut sebagai dasar untuk logika operasi pompa.

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

# Pompa

START_PUMP = 1 STOP_PUMP = 0 PUMP_BOUNCE_TIME = 50 # milidetik PUMP_STOP_TIMEOUT = 5 # detik

PENTING: Jika Anda akan menggunakan Pin 4, jangan lupa untuk menonaktifkan opsi 1-Wire raspi-config untuk menghindari konflik.

Saat memulai program, kami mendaftarkan panggilan balik dan mengatur status awal ke OFF.

Berikut kode untuk fungsi yang mengaktifkan pompa:

def toggle_pump(nilai): if pump_disabled: kembalikan if is_pump_on() != nilai: log_debug("[x] %s" % ('START' jika nilai lain 'STOP')) GPIO.setup(GPIO_PUMP, GPIO. OUT) GPIO.output(GPIO_PUMP, nilai) # Mulai/Berhenti menuangkan

Seperti yang didefinisikan dalam kode startup di atas, saat relai AKTIF, callback berikut dipanggil:

pump_on = False def pump_relay_handle(pin): global pump_on pump_on = GPIO.input(GPIO_PUMP) log_debug("Pump relay berubah menjadi %d" % pump_on)

Dalam panggilan balik, kami menyimpan status pompa saat ini ke variabel. Dalam loop utama aplikasi, kami dapat mendeteksi momen ketika pompa mati seperti yang ditunjukkan di bawah ini:

def is_pump_on(): global pump_on kembali pump_on

jika GPIO.event_detected(GPIO_PUMP):

is_pouring = is_pump_on() # … log_debug('[!] Kejadian pompa terdeteksi: %s' % ('On' if is_pouring else 'Off')) send(cloud, variabel, distance, force=True)

Mengukur Jarak

Cukup mudah untuk mengukur jarak ke permukaan air menggunakan sensor jarak ultrasonik. Di repositori kami, kami membagikan beberapa skrip python yang memungkinkan Anda menguji sensor.

Dalam aplikasi nyata, pembacaan sensor dapat berfluktuasi karena efek pantulan sensor dan osilasi air. Dalam beberapa kasus, pembacaan bisa hilang sama sekali. Kami menerapkan kelas BounceFilter yang mengakumulasi N nilai terbaru, membuang puncak, dan menghitung rata-rata pengukuran yang tersisa. Proses pengukuran diimplementasikan dengan algoritma asinkron berikut.

# Menyimpan pembacaan sensor terakhir = BounceFilter(size=6, membuang_count=1)

read_complete = threading. Event()

def wait_for_distance():

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

jika tidak read_complete.wait(MAX_READING_TIMEOUT):

log_info('Reading sensor timeout') mengembalikan Tidak ada kembali readings.avg()

def read_distance():

coba: nilai = hcsr04.raw_distance(sample_size=5) rounded = nilai jika nilainya Tidak ada lagi round(value, 1) readings.add(rounded) kecuali Pengecualian sebagai err: log_error('Internal error: %s' % err) akhirnya: read_complete.set()

Anda dapat menemukan implementasi penuh filter di sources.

Langkah 3: Menangani Situasi Darurat

Bagaimana jika sensor terbakar, atau jatuh, atau menunjuk ke area yang salah? Kami membutuhkan cara untuk melaporkan kasus tersebut sehingga kami dapat mengambil tindakan manual.

Jika sensor gagal memberikan pembacaan jarak, sistem mengirimkan status yang diubah ke cloud dan menghasilkan pemberitahuan yang sesuai.

Logikanya diilustrasikan oleh kode di bawah ini.

distance = wait_for_distance() # Baca kedalaman air saat ini jika jaraknya Tidak ada: log_error('Distance error!') notify_in_background(calc_alert(SENSOR_ERROR)) send(cloud, variabel, distance, error_code=SENSOR_ERROR, force=True)

Kami memiliki rentang level air operasional yang harus dipertahankan saat sensor berada di tempatnya. Kami menguji apakah ketinggian air saat ini turun dalam kisaran ini:

# Jarak dari sensor ke ketinggian air# berdasarkan tangki air mesin kopi MIN_DISTANCE = 2 # cm MAX_DISTANCE = 8 # cm

# Jarak di luar jangkauan yang diharapkan: jangan mulai mengalir

jika jarak > MAX_DISTANCE * 2: log_error('Jarak di luar jangkauan: %.2f' % jarak) lanjutkan

Kami mematikan pompa jika aktif saat terjadi kesalahan.

if is_pump_on() dan prev_distance < STOP_PUMP_DISTANCE + DISTANCE_DELTA: log_error('[!] Pemberhentian darurat pompa. Tidak ada sinyal dari sensor jarak')

toggle_pump(STOP_PUMP)

Kami juga memproses kasus ketika botol kehabisan air. Kami memeriksa apakah ketinggian air tidak berubah saat pompa bekerja. Jika demikian, sistem menunggu selama 5 detik dan kemudian memeriksa apakah pompa telah mati. Jika belum, maka sistem akan melakukan emergency pump shutdown dan mengirimkan notifikasi error.

PUMP_STOP_TIMEOUT = 5 # detiksemergency_stop_time = Tidak ada

def set_emergency_stop_time(sekarang, is_pouring):

global emergency_stop_time emergency_stop_time = sekarang + PUMP_STOP_TIMEOUT jika / sedang_menuangkan yang lain Tidak ada

def check_water_source_empty(sekarang):

kembali emergency_stop_time dan sekarang > emergency_stop_time

# --------- loop utama -----------

jika GPIO.event_detected(GPIO_PUMP): is_pouring = is_pump_on() set_emergency_stop_time(sekarang, is_pouring) # …

global pump_disabled

if check_water_source_empty(now): log_error('[!] Pompa berhenti darurat. / Sumber air kosong') toggle_pump(STOP_PUMP) pump_disabled = Benar

Di atas adalah contoh log pesan yang dibuat selama pemberhentian darurat.

Langkah 4: Menjalankan Sistem 24/7

Kode pada perangkat di-debug dan berjalan tanpa masalah. Kami meluncurkannya sebagai layanan, jadi restart jika Raspberry Pi di-boot ulang. Untuk kenyamanan, kami membuat Makefile yang membantu penerapan, menjalankan layanan, dan melihat log.

. PHONY: install run start stop status log deploy MAIN_FILE:= coffee-pump/main.py SERVICE_INSTALL_SCRIPT:= service_install.sh SERVICE_NAME:= coffee-pump.service

Install:

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

Lari:

sudo python3 $(MAIN_FILE)

Mulailah:

sudo systemctl start $(SERVICE_NAME)

status:

sudo systemctl status $(SERVICE_NAME)

berhenti:

sudo systemctl stop $(SERVICE_NAME)

catatan:

sudo journalctl -u coffee-pump --sejak hari ini

menyebarkan:

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

Anda dapat menemukan file ini dan semua skrip yang diperlukan di repositori kami.

Langkah 5: Pemantauan Cloud

Kami menggunakan Cloud4RPi untuk mengimplementasikan panel kontrol. Kami pertama-tama menambahkan widget untuk menunjukkan parameter penting sistem.

Omong-omong, widget untuk variabel STATUS dapat menggunakan skema warna yang berbeda berdasarkan nilainya (lihat gambar di atas).

Kami menambahkan widget bagan untuk menampilkan data dinamis. Pada gambar di bawah ini Anda dapat melihat saat pompa ON dan OFF dan ketinggian air masing-masing.

Jika Anda menganalisis rentang waktu yang lebih lama, Anda dapat melihat puncaknya - saat itulah pompa sedang bekerja.

Cloud4RPi juga memungkinkan Anda untuk mengatur level perataan yang berbeda.

Langkah 6: Berhasil

Berhasil! Panel kontrol secara keseluruhan terlihat seperti gambar di bawah ini.

Saat ini, pompa otomatis kami telah berjalan selama beberapa minggu dan yang perlu kami lakukan hanyalah mengganti botol air. Kode lengkap untuk proyek kami tersedia di repositori GitHub kami.