ปั๊มเครื่องชงกาแฟอัจฉริยะควบคุมโดย Raspberry Pi & HC-SR04 Ultrasonic Sensor และ Cloud4RPi: 6 ขั้นตอน

2024 ผู้เขียน: John Day | [email protected]. แก้ไขล่าสุด: 2024-01-30 13:04

ตามทฤษฎีแล้ว ทุกครั้งที่คุณไปที่เครื่องชงกาแฟเพื่อดื่มแก้วยามเช้า มีโอกาสเพียงหนึ่งในยี่สิบที่คุณจะต้องเติมน้ำในแท้งค์ อย่างไรก็ตาม ในทางปฏิบัติ ดูเหมือนว่าเครื่องจักรจะหาวิธีที่จะทำให้คุณทำงานบ้านนี้ได้เสมอ ยิ่งคุณต้องการกาแฟมากเท่าไหร่ คุณก็ยิ่งมีโอกาสได้รับข้อความ "เติมถังเก็บน้ำ" ที่หวั่นไหวมากขึ้นเท่านั้น เพื่อนร่วมงานของฉันรู้สึกแบบเดียวกันกับเรื่องนี้ เนื่องจากเราเป็นพวกเนิร์ด เราจึงตัดสินใจที่จะใช้เทคโนโลยีที่จะยุติเรื่องนี้

เสบียง

อุปกรณ์ของเรา

เรามีเครื่องชงกาแฟ SAECO Aulika Focus จนถึงทุกวันนี้ เราใช้ปั๊มมือเติมน้ำในแท้งค์ของตัวเครื่องจากขวดน้ำมาตรฐานขนาด 5 แกลลอน (19L)

เป้าหมายของเรา

1. ใช้ปั๊มไฟฟ้าที่ขับเคลื่อนด้วยคอนโทรลเลอร์บางชนิดหรือไมโครคอมพิวเตอร์ผ่านรีเลย์
2. มีวิธีวัดระดับน้ำในถังของเครื่องชงกาแฟเพื่อให้ระบบของเรารู้ว่าต้องเติมเมื่อใด
3. มีวิธีการควบคุมระบบโดยเฉพาะอย่างยิ่งในเวลาจริงจากอุปกรณ์มือถือ
4. รับการแจ้งเตือน (ผ่าน Slack หรือบริการที่คล้ายกัน) หากมีสิ่งผิดปกติเกิดขึ้นกับระบบ

ขั้นตอนที่ 1: การเลือกอุปกรณ์

ปั๊ม

การค้นหาเว็บอย่างรวดเร็วจะแสดงเครื่องสูบน้ำไฟฟ้าหลายรุ่นซึ่งออกแบบมาสำหรับขวดน้ำที่คุณเลือก ปั๊มดังกล่าวมักจะถูกควบคุมโดยสวิตช์เปิด/ปิด (เช่น Hot Frost A12 หรือ SMixx ХL-D2) นี่คือปั๊มที่เราเลือกสำหรับโครงการของเรา

อุปกรณ์ควบคุม

เราลองใช้อุปกรณ์หลายตัวแต่เลือกใช้ Raspberry Pi เนื่องจากข้อดีดังต่อไปนี้:

• มี GPIO ที่ช่วยให้เราต่อ Proximity Sensor ได้
• รองรับ Python

เราได้ติดตั้ง Raspbian Buster Lite เวอร์ชันใหม่และทุกอย่างที่จำเป็นในการรัน Python 3

เราสลับปั๊มอย่างไร

ในการควบคุมกำลังไฟฟ้า เราเลือกรีเลย์โซลิดสเตตกำลังปานกลาง (12V/2A) ที่เหมาะสำหรับกระแสสลับ รีเลย์เชื่อมต่อปั๊มกับเต้าเสียบและควบคุมโดยพินดิจิทัลของ Raspberry Pi

เราตรวจสอบระดับน้ำอย่างไร

เป็นสิ่งสำคัญสำหรับเราที่จะไม่เปลี่ยนแปลงโครงสร้างของเครื่องชงกาแฟ ดังนั้นเราจึงตัดสินใจใช้เซนเซอร์ตรวจจับความใกล้เคียงแบบอัลตราโซนิก HC-SR04 เพื่อวัดระดับน้ำ

เราพิมพ์ฝาถังเก็บน้ำแบบกำหนดเองแบบ 3 มิติพร้อมรูสองรูสำหรับตัวปล่อยของเซ็นเซอร์ เราพบไลบรารี GitHub สำหรับเซ็นเซอร์ได้อย่างง่ายดาย ณ จุดนี้การเตรียมทั้งหมดเสร็จสิ้น

ขั้นตอนที่ 2: การออกแบบระบบ

ลอจิกของระบบ

ระบบได้รับการออกแบบโดยคำนึงถึงตรรกะง่ายๆ ดังต่อไปนี้:

• ระบบจะตรวจสอบระยะห่างระหว่างเซ็นเซอร์กับผิวน้ำอย่างต่อเนื่อง
• เมื่อใดก็ตามที่การเปลี่ยนแปลงระยะทางเกินค่าเกณฑ์ ระบบจะส่งข้อมูลเกี่ยวกับสถานะไปยังคลาวด์
• หากระยะทางเกินค่าสูงสุดที่อนุญาต (ถังว่างเปล่า) ระบบจะเปิดใช้งานปั๊มและปิดเครื่องเมื่อระยะทางน้อยกว่าค่าต่ำสุดที่อนุญาต
• เมื่อใดก็ตามที่สถานะของระบบเปลี่ยนแปลง (เช่น ปั๊มทำงาน) ระบบจะแจ้งให้คลาวด์ทราบ

ในกรณีที่เกิดข้อผิดพลาด การแจ้งเตือนจะถูกส่งไปยังช่อง Slack

เมื่อเครื่องชงกาแฟไม่ได้ใช้งาน ระบบจะส่ง Ping ไปยังบริการคลาวด์พร้อมข้อมูลการวินิจฉัยทุกๆ นาที นอกจากนี้ยังส่งสถานะไปยังระบบคลาวด์ทุก 5 นาที

เมื่อปั๊มทำงาน ระบบจะส่งข้อมูลบ่อยขึ้นแต่ไม่เกินหนึ่งครั้งทุกครึ่งวินาที

def send(cloud, ตัวแปร, dist, error_code=0, force=False): pump_on = is_pump_on() เปอร์เซ็นต์ = calc_water_level_percent(dist) ตัวแปร['Distance']['value'] = dist variables['WaterLevel'][' ค่า'] = ตัวแปรเปอร์เซ็นต์['PumpRelay']['value'] = ตัวแปร pump_on['Status']['value'] = calc_status (รหัสข้อผิดพลาด เปอร์เซ็นต์ pump_on)

ปัจจุบัน = เวลา ()

โกลบอล last_sending_time ถ้าบังคับหรือปัจจุบัน - last_sending_time > MIN_SEND_INTERVAL: การอ่าน = cloud.read_data() cloud.publish_data(การอ่าน) last_sending_time = ปัจจุบัน

การทำงานกับปั๊ม

เรากำหนดค่าคงที่ต่อไปนี้เป็นฐานสำหรับตรรกะการทำงานของเครื่องสูบน้ำ

# หมุด GPIO (BCM) GPIO_PUMP = 4 GPIO_TRIGGER = 17 GPIO_ECHO = 27

#ปั๊ม

START_PUMP = 1 STOP_PUMP = 0 PUMP_BOUNCE_TIME = 50 # มิลลิวินาที PUMP_STOP_TIMEOUT = 5 # วินาที

สำคัญ: หากคุณกำลังจะใช้พิน 4 อย่าลืมปิดการใช้งานตัวเลือก 1-Wire raspi-config เพื่อหลีกเลี่ยงความขัดแย้ง

เมื่อเริ่มต้นโปรแกรม เราลงทะเบียนการโทรกลับและตั้งค่าสถานะเริ่มต้นเป็นปิด

นี่คือรหัสสำหรับฟังก์ชันที่สลับปั๊ม:

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, value) # เริ่ม/หยุดเท

ตามที่กำหนดไว้ในโค้ดเริ่มต้นด้านบน เมื่อรีเลย์เปิด การเรียกกลับต่อไปนี้จะเรียกว่า:

pump_on = False def pump_relay_handle (พิน): global pump_on pump_on = GPIO.input (GPIO_PUMP) log_debug ("รีเลย์ปั๊มเปลี่ยนเป็น %d" % pump_on)

ในการเรียกกลับ เราบันทึกสถานะปัจจุบันของปั๊มเป็นตัวแปร ในลูปหลักของแอปพลิเคชัน เราสามารถตรวจจับช่วงเวลาที่ปั๊มสลับดังแสดงด้านล่าง:

def is_pump_on(): global pump_on ส่งคืน pump_on

ถ้า GPIO.event_detected(GPIO_PUMP):

is_pouring = is_pump_on() # … log_debug('[!] ตรวจพบเหตุการณ์ของปั๊ม: %s' % ('On' if is_pouring else 'Off')) send(cloud, ตัวแปร, ระยะทาง, แรง=True)

การวัดระยะทาง

การวัดระยะห่างจากผิวน้ำทำได้ง่ายมากโดยใช้เซ็นเซอร์วัดระยะด้วยคลื่นเสียงความถี่สูง ในที่เก็บของเรา เราได้แชร์สคริปต์หลามสองสามตัวที่ให้คุณทดสอบเซ็นเซอร์ได้

ในการใช้งานจริง ค่าที่อ่านได้ของเซ็นเซอร์อาจผันผวนเนื่องจากผลกระทบของเซ็นเซอร์และการแกว่งของน้ำ ในบางกรณี การอ่านอาจขาดหายไปโดยสิ้นเชิง เราใช้คลาส BounceFilter ที่สะสมค่าล่าสุด N ค่า ละค่าสูงสุด และคำนวณค่าเฉลี่ยของการวัดที่เหลืออยู่ กระบวนการวัดดำเนินการโดยใช้อัลกอริทึมแบบอะซิงโครนัสต่อไปนี้

# เก็บค่าการอ่านค่าเซ็นเซอร์ล่าสุด = BounceFilter(size=6, discard_count=1)

reading_complete = threading. Event()

def wait_for_distance():

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

ถ้าไม่ read_complete.wait(MAX_READING_TIMEOUT):

log_info('การอ่านการหมดเวลาของเซ็นเซอร์') ส่งคืนไม่มีการอ่านค่ากลับ avg()

def read_distance():

ลอง: ค่า = hcsr04.raw_distance(sample_size=5) ปัดเศษ = ค่าถ้าค่าเป็น None else round(value, 1) readings.add(ปัดเศษ) ยกเว้น ข้อยกเว้นเป็น err: log_error('Internal error: %s' % err) ในที่สุด: reading_complete.set()

คุณสามารถค้นหาการใช้งานตัวกรองแบบเต็มได้ในแหล่งที่มา

ขั้นตอนที่ 3: การจัดการกับสถานการณ์ฉุกเฉิน

จะเกิดอะไรขึ้นหากเซ็นเซอร์ไหม้ หลุดออก หรือชี้ไปยังบริเวณที่ไม่ถูกต้อง เราต้องการวิธีรายงานกรณีดังกล่าวเพื่อให้เราสามารถดำเนินการโดยเจ้าหน้าที่ได้

หากเซ็นเซอร์ไม่สามารถอ่านระยะทางได้ ระบบจะส่งสถานะที่เปลี่ยนแปลงไปยังคลาวด์และสร้างการแจ้งเตือนที่เกี่ยวข้อง

ตรรกะแสดงโดยรหัสด้านล่าง

Distance = wait_for_distance() # อ่านความลึกของน้ำในปัจจุบันถ้าระยะทางเป็น None: log_error('Distance error!') notify_in_background(calc_alert(SENSOR_ERROR)) send(cloud, variables, distance, error_code=SENSOR_ERROR, force=True)

เรามีช่วงระดับน้ำที่ใช้งานได้ซึ่งควรรักษาไว้เมื่อเซ็นเซอร์อยู่ในตำแหน่ง เราทดสอบว่าระดับน้ำปัจจุบันอยู่ในช่วงนี้หรือไม่:

# ระยะห่างจากเซ็นเซอร์ถึงระดับน้ำ# ตามถังเก็บน้ำของเครื่องชงกาแฟ MIN_DISTANCE = 2 # cm MAX_DISTANCE = 8 # cm

# ระยะทางอยู่นอกช่วงที่คาดไว้: อย่าเริ่มเท

ถ้าระยะทาง > MAX_DISTANCE * 2: log_error('ระยะทางอยู่นอกช่วง: %.2f' % ระยะทาง) ดำเนินการต่อ

เราปิดปั๊มหากมีการใช้งานเมื่อเกิดข้อผิดพลาด

if is_pump_on() and prev_distance < STOP_PUMP_DISTANCE + DISTANCE_DELTA: log_error('[!] ปั๊มหยุดฉุกเฉิน ไม่มีสัญญาณจากเซ็นเซอร์วัดระยะทาง')

toggle_pump(STOP_PUMP)

นอกจากนี้เรายังดำเนินการกรณีที่น้ำขวดหมด เราตรวจสอบว่าระดับน้ำไม่เปลี่ยนแปลงเมื่อปั๊มทำงานหรือไม่ หากเป็นเช่นนั้น ระบบจะรอเป็นเวลา 5 วินาที จากนั้นตรวจสอบว่าปั๊มปิดอยู่หรือไม่ หากไม่เป็นเช่นนั้น ระบบจะทำการปิดปั๊มฉุกเฉินและส่งการแจ้งเตือนข้อผิดพลาด

PUMP_STOP_TIMEOUT = 5 # secsemergency_stop_time = ไม่มี

def set_emergency_stop_time (ตอนนี้ is_pouring):

ฉุกเฉินทั่วโลก_stop_time emergency_stop_time = ตอนนี้ + PUMP_STOP_TIMEOUT ถ้า / is_pouring อื่น ไม่มี

def check_water_source_empty (ตอนนี้):

ส่งคืน Emergency_stop_time และตอนนี้ > Emergency_stop_time

# --------- วงหลัก -----------

ถ้า GPIO.event_detected(GPIO_PUMP): is_pouring = is_pump_on() set_emergency_stop_time(ตอนนี้ is_pouring) # …

โกลบอล pump_disabled

ถ้า check_water_source_empty(ตอนนี้): log_error('[!] ปั๊มหยุดฉุกเฉิน / แหล่งน้ำว่างเปล่า') toggle_pump(STOP_PUMP) pump_disabled = True

ด้านบนคือตัวอย่างบันทึกข้อความที่สร้างขึ้นระหว่างการหยุดฉุกเฉิน

ขั้นตอนที่ 4: เรียกใช้ระบบ 24/7

รหัสบนอุปกรณ์ถูกดีบั๊กและทำงานโดยไม่มีปัญหา เราเปิดตัวเป็นบริการ ดังนั้นจะเริ่มต้นใหม่หากรีบูต Raspberry Pi เพื่อความสะดวก เราได้สร้าง Makefile ที่ช่วยในการปรับใช้ เรียกใช้บริการ และดูบันทึก

. PHONY: ติดตั้ง run start stop status log deploy MAIN_FILE:= coffee-pump/main.py SERVICE_INSTALL_SCRIPT:= service_install.sh SERVICE_NAME:= coffee-pump.service

ติดตั้ง:

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

วิ่ง:

sudo python3 $(MAIN_FILE)

เริ่ม:

sudo systemctl เริ่มต้น $(SERVICE_NAME)

สถานะ:

sudo systemctl สถานะ $(SERVICE_NAME)

หยุด:

sudo systemctl หยุด $(SERVICE_NAME)

บันทึก:

sudo journalctl -u ปั๊มกาแฟ -- ตั้งแต่วันนี้

ปรับใช้:

rsync -av ปั๊มกาแฟเซ็นเซอร์ตั้งค่า Makefile *.sh pi@XX. XX. XXX. XXX:~/

คุณสามารถค้นหาไฟล์นี้และสคริปต์ที่จำเป็นทั้งหมดในที่เก็บของเรา

ขั้นตอนที่ 5: การตรวจสอบระบบคลาวด์

เราใช้ Cloud4RPi เพื่อใช้งานแผงควบคุม ขั้นแรกเราได้เพิ่มวิดเจ็ตเพื่อระบุพารามิเตอร์ที่จำเป็นสำหรับระบบ

อย่างไรก็ตาม วิดเจ็ตสำหรับตัวแปร STATUS สามารถใช้รูปแบบสีต่างๆ ตามค่าของมันได้ (ดูภาพด้านบน)

เราได้เพิ่มวิดเจ็ตแผนภูมิเพื่อแสดงข้อมูลแบบไดนามิก ในภาพด้านล่าง คุณจะเห็นช่วงเวลาที่ปั๊มเปิดและปิด และระดับน้ำตามลำดับ

หากคุณวิเคราะห์ช่วงเวลาที่ยาวขึ้น คุณจะเห็นค่าสูงสุด นั่นคือเวลาที่ปั๊มทำงาน

Cloud4RPi ยังให้คุณตั้งค่าระดับการปรับให้เรียบที่แตกต่างกันได้

ขั้นตอนที่ 6: มันใช้งานได้

มันได้ผล! แผงควบคุมทั้งหมดมีลักษณะดังแสดงด้านล่าง

ปัจจุบัน ปั๊มอัตโนมัติของเราทำงานมาหลายสัปดาห์แล้ว และสิ่งที่เราต้องทำคือเปลี่ยนขวดน้ำ รหัสเต็มสำหรับโครงการของเรามีอยู่ในที่เก็บ GitHub ของเรา