ჭკვიანი ყავის აპარატის ტუმბო, რომელსაც აკონტროლებს Raspberry Pi & HC-SR04 ულტრაბგერითი სენსორი და Cloud4RPi: 6 ნაბიჯი

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:17

თეორიულად, ყოველ ჯერზე, როცა დილის ჭიქაზე ყავის აპარატთან მიდიხართ, მხოლოდ ოციდან ერთი შანსია, რომ წყლის ავზი შეავსოთ. პრაქტიკაში, როგორც ჩანს, მანქანა რატომღაც პოულობს გზას, რომ ეს სამუშაო ყოველთვის თქვენზე დააყენოს. რაც უფრო მეტად გსურთ ყავა, მით უფრო სავარაუდოა, რომ მიიღებთ საშინელ შეტყობინებას "შეავსეთ წყლის ავზი". ჩემი კოლეგებიც იმავეს ფიქრობენ ამაზე. ვიყოთ ისეთები, ვინც ვართ, ჩვენ გადავწყვიტეთ განვახორციელოთ ტექნოლოგია, რომელიც ამას ბოლო მოეღება.

მარაგები

ჩვენი აპარატურა

ჩვენ გვაქვს SAECO Aulika Focus ყავის აპარატი. დღემდე, ჩვენ ვიყენებდით ხელის ტუმბოს აპარატის წყლის ავზის შესავსებად სტანდარტული 5 გალონიანი (19 ლ) წყლის ბოთლიდან.

ჩვენი მიზნები

1. გამოიყენეთ ელექტრული ტუმბო, რომელსაც მართავს რაიმე სახის კონტროლერი ან მიკროკომპიუტერი რელეს საშუალებით.
2. გქონდეთ საშუალება გაზომოთ წყლის დონე ყავის აპარატის ავზში, რათა ჩვენმა სისტემამ იცოდეს როდის უნდა შეავსოს იგი.
3. აქვს საშუალება გააკონტროლოს სისტემა, სასურველია რეალურ დროში მობილური მოწყობილობიდან.
4. მიიღეთ შეტყობინებები (Slack– ის ან მსგავსი სერვისის საშუალებით), თუ რამე არასწორია სისტემაში.

ნაბიჯი 1: აღჭურვილობის არჩევა

ტუმბო

ინტერნეტში სწრაფი ძებნა აჩვენებს ელექტრული ტუმბოს რამდენიმე მოდელს, რომელიც შექმნილია თქვენი არჩევანის წყლის ბოთლისთვის. ასეთი ტუმბოები ჩვეულებრივ კონტროლდება ON/OFF გადამრთველით (მაგალითად, Hot Frost A12 ან SMixx ХL-D2). აქ არის ტუმბო, რომელიც ავირჩიეთ ჩვენი პროექტისთვის.

კონტროლერის მოწყობილობა

ჩვენ ვცადეთ რამდენიმე მოწყობილობა, მაგრამ დავამყარეთ Raspberry Pi შემდეგი უპირატესობების გამო:

• მას აქვს GPIO, რომელიც საშუალებას გვაძლევს დავუკავშიროთ სიახლოვის სენსორი
• ის მხარს უჭერს პითონს

ჩვენ დავაინსტალირეთ Raspbian Buster Lite– ის ახალი ვერსია და ყველაფერი, რაც საჭიროა Python 3 – ის გასაშვებად.

როგორ ვთიშავთ ტუმბოს

სიმძლავრის გასაკონტროლებლად, ჩვენ შევარჩიეთ საშუალო სიმძლავრის (12V/2A) მყარი რელე, რომელიც შეეფერება ალტერნატიულ დენს. რელე აკავშირებს ტუმბოს გამოსავალს და აკონტროლებს Raspberry Pi- ს ციფრული პინი.

როგორ ვამოწმებთ წყლის დონეს

ჩვენთვის მნიშვნელოვანი იყო ყავის აპარატის კონსტრუქციის შეცვლა, ამიტომ გადავწყვიტეთ გამოვიყენოთ HC-SR04 ულტრაბგერითი სიახლოვის სენსორი წყლის დონის გასაზომად.

ჩვენ 3D ბეჭდვით გამოვართვით წყლის ავზის საფარი ორი ხვრელით სენსორის გამცემი. ჩვენ ადვილად ვიპოვნეთ GitHub ბიბლიოთეკა სენსორისთვის. ამ ეტაპზე ყველა მზადება დასრულდა.

ნაბიჯი 2: სისტემის შემუშავება

სისტემის ლოგიკა

სისტემა შექმნილია შემდეგი მარტივი ლოგიკის გათვალისწინებით:

• სისტემა მუდმივად აკონტროლებს მანძილს სენსორსა და წყლის ზედაპირს შორის.
• როდესაც მანძილის ცვლილება გადალახავს ზღურბლს, სისტემა ღრუბელში აგზავნის ინფორმაციას თავისი მდგომარეობის შესახებ.
• თუ მანძილი გადააჭარბებს მაქსიმალურ დასაშვებ მნიშვნელობას (ავზი ცარიელია), სისტემა ააქტიურებს ტუმბოს და გამორთავს მას შემდეგ, რაც მანძილი იქნება მინიმალურ დასაშვებ მნიშვნელობაზე ნაკლები.
• როდესაც სისტემის მდგომარეობა იცვლება (მაგალითად, ტუმბო აქტიურდება), ის აცნობებს ღრუბელს.

შეცდომის შემთხვევაში შეტყობინება იგზავნება Slack არხზე.

როდესაც ყავის მანქანა უმოქმედოა, სისტემა ყოველ წუთში ერთხელ უგზავნის ღრუბლის სერვისს დიაგნოსტიკური მონაცემებით. გარდა ამისა, ის აგზავნის თავის მდგომარეობას ღრუბელში ყოველ 5 წუთში.

როდესაც ტუმბო აქტიურია, სისტემა აგზავნის მონაცემებს უფრო ხშირად, მაგრამ არა უმეტეს ნახევარ წამში ერთხელ.

def send (ღრუბელი, ცვლადები, dist, error_code = 0, ძალა = ყალბი): pump_on = is_pump_on () პროცენტი = calc_water_level_percent (dist) ცვლადები ['მანძილი'] ['მნიშვნელობა'] = dist ცვლადები ['WaterLevel'] [' მნიშვნელობა '] = პროცენტული ცვლადი [' PumpRelay '] [' მნიშვნელობა '] = ცვლადი_სატუმბი [' სტატუსი '] [' მნიშვნელობა '] = 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 # წამი

მნიშვნელოვანია: თუ თქვენ აპირებთ გამოიყენოთ Pin 4, ნუ დაგავიწყდებათ გამორთოთ 1-Wire raspi-config ვარიანტი კონფლიქტების თავიდან ასაცილებლად.

პროგრამის გაშვებისას ჩვენ ვრეგისტრირებთ უკუკავშირს და საწყის მდგომარეობას ვაყენებთ OFF.

აქ არის კოდი იმ ფუნქციისთვის, რომელიც ჩართავს ტუმბოს:

def toggle_pump (მნიშვნელობა): თუ pump_disabled: დაბრუნება is_pump_on ()! = მნიშვნელობა: log_debug ("[x] % s" % ('START' თუ მნიშვნელობა სხვა 'STOP')) GPIO.setup (GPIO_PUMP, GPIO. OUT) GPIO.output (GPIO_PUMP, მნიშვნელობა) # ჩამოსხმის დაწყება/შეჩერება

როგორც განსაზღვრულია ზემოთ გაშვების კოდში, როდესაც სარელეო ჩართულია, შემდეგ გამოძახებას ეწოდება:

pump_on = მცდარი def pump_relay_handle (pin): გლობალური pump_on pump_on = GPIO.input (GPIO_PUMP) log_debug ("ტუმბოს რელე შეიცვალა % d" % pump_on)

უკუკავშირში, ჩვენ ვინახავთ ტუმბოს ამჟამინდელ მდგომარეობას ცვლადში. აპლიკაციის მთავარ მარყუჟში ჩვენ შეგვიძლია გამოვავლინოთ ის მომენტი, როდესაც ტუმბო გადადის როგორც ქვემოთ მოცემულია:

def is_pump_on (): გლობალური pump_on დაბრუნების pump_on

თუ GPIO.event_detected (GPIO_PUMP):

is_pouring = is_pump_on () #… log_debug ('[!] ტუმბოს მოვლენა აღმოჩენილია: % s' % ('On' if is apouring else 'Off')) გაგზავნა (ღრუბელი, ცვლადები, მანძილი, ძალა = ჭეშმარიტი)

მანძილის გაზომვა

საკმაოდ ადვილია წყლის ზედაპირთან მანძილის გაზომვა ულტრაბგერითი სიახლოვის სენსორის გამოყენებით. ჩვენს საცავში ჩვენ გავუზიარეთ პითონის რამდენიმე სკრიპტი, რომელიც საშუალებას გაძლევთ შეამოწმოთ სენსორი.

რეალურ პროგრამებში, სენსორების კითხვა შეიძლება მერყეობდეს სენსორის ამომავალი ეფექტისა და წყლის რხევების გამო. ზოგიერთ შემთხვევაში, წაკითხვა შეიძლება მთლიანად დაკარგული იყოს. ჩვენ განვახორციელეთ BounceFilter კლასი, რომელიც აგროვებს N ბოლო მნიშვნელობებს, აგდებს მწვერვალებს და ითვლის დარჩენილი გაზომვების საშუალო მაჩვენებელს. გაზომვის პროცესი ხორციელდება შემდეგი ასინქრონული ალგორითმით.

# ინახავს ბოლო სენსორის გაზომვებს = BounceFilter (ზომა = 6, discard_count = 1)

Read_complete = threading. ღონისძიება ()

def wait_for_distance ():

კითხვის_მთავარი. გასაგები () ძაფი = ძაფისებრი. ძაფი (სამიზნე = წაკითხული_ მანძილი) ძაფი. დაწყება ()

თუ არ კითხულობთ_დაასრულეთ. დაელოდეთ (MAX_READING_TIMEOUT):

log_info ("კითხვის სენსორის დროის ამოწურვა") დაბრუნება არ არის დაბრუნებული წაკითხვა. avg ()

def read_distance ():

ცადე: value = hcsr04.raw_distance (sample_size = 5) მომრგვალებული = მნიშვნელობა თუ მნიშვნელობა არ არის სხვა მრგვალი (მნიშვნელობა, 1) საკითხები. დამატება (მომრგვალებული) გამონაკლისის გარდა err: log_error ('შიდა შეცდომა: % s' % err) საბოლოოდ: reading_complete.set ()

თქვენ შეგიძლიათ იპოვოთ ფილტრის სრული განხორციელება წყაროებში.

ნაბიჯი 3: გადაუდებელი სიტუაციების მართვა

რა მოხდება, თუ სენსორი დაიწვა, დაეცა ან არასწორ უბანზე მიუთითებს? ჩვენ გვჭირდებოდა ასეთი შემთხვევების შეტყობინების საშუალება, რათა შეგვეძლო ხელით მოქმედება.

თუ სენსორი ვერ უზრუნველყოფს მანძილის კითხვას, სისტემა აგზავნის შეცვლილ სტატუსს ღრუბელში და ქმნის შესაბამის შეტყობინებას.

ლოგიკა ილუსტრირებულია ქვემოთ მოყვანილი კოდით.

მანძილი = დაელოდეთ_ მანძილს () # წაიკითხეთ წყლის ამჟამინდელი სიღრმე, თუ მანძილი არ არის: log_error ('Distance error!') notify_in_background (calc_alert (SENSOR_ERROR)) გაგზავნა (ღრუბელი, ცვლადები, მანძილი, შეცდომის კოდი = SENSOR_ERROR, force = True)

ჩვენ გვაქვს წყლის დონის ოპერატიული დიაპაზონი, რომელიც უნდა შენარჩუნდეს, როდესაც სენსორი თავის ადგილზეა. ჩვენ ვამოწმებთ, არის თუ არა წყლის ამჟამინდელი დონე ამ დიაპაზონში:

# მანძილი სენსორიდან წყლის დონემდე # ყავის აპარატის წყლის ავზზე დაყრდნობით MIN_DISTANCE = 2 # სმ MAX_DISTANCE = 8 # სმ

# მანძილი მოსალოდნელი დიაპაზონის მიღმაა: არ დაიწყოთ ჩამოსხმა

თუ მანძილი> MAX_DISTANCE * 2: log_error ('მანძილი არ არის დიაპაზონში: %.2f' % მანძილი) გაგრძელდება

ჩვენ ვთიშავთ ტუმბოს, თუ ის აქტიური იყო შეცდომის დროს.

თუ is_pump_on () და pre_distance <STOP_PUMP_DISTANCE + DISTANCE_DELTA: log_error ('

გადართვა_ ტუმბო (STOP_PUMP)

ჩვენ ასევე ვამუშავებთ იმ შემთხვევას, როდესაც ბოთლი ამოიწურება. ჩვენ ვამოწმებთ, რომ წყლის დონე არ იცვლება, როდესაც ტუმბო მუშაობს. თუ ასეა, სისტემა ელოდება 5 წამს და შემდეგ ამოწმებს თუ არა ტუმბო გამორთული. თუ არა, სისტემა ახორციელებს ტუმბოს გადაუდებელ გამორთვას და აგზავნის შეცდომის შეტყობინებას.

PUMP_STOP_TIMEOUT = 5 # secsemergency_stop_time = არცერთი

def set_emergency_stop_time (ახლა, გადმოდის):

გლობალური გადაუდებელი_ გაჩერების დრო საგანგებო_სტო_ დრო = ახლა + PUMP_STOP_TIMEOUT თუ / სხვას არ ასხამს

def check_water_source_empty (ახლა):

დააბრუნეთ გადაუდებელი_ გაჩერების დრო და ახლა> საგანგებო_სადგურის_დრო

# --------- მთავარი მარყუჟი -----------

თუ GPIO.event_detected (GPIO_PUMP): is_pouring = is_pump_on () set_emergency_stop_time (now, is_pouring) #…

გლობალური ტუმბო გამორთულია

თუ check_water_source_empty (ახლა): log_error ('

ზემოთ მოცემულია საგანგებო გაჩერების დროს წარმოქმნილი შეტყობინებების ჟურნალის მაგალითი.

ნაბიჯი 4: სისტემის გაშვება 24/7

მოწყობილობის კოდი გამართულია და მუშაობს უპრობლემოდ. ჩვენ დავიწყეთ ის, როგორც სერვისი, ასე რომ, ის განახლდება თუ Raspberry Pi გადატვირთულია. მოხერხებულობისთვის, ჩვენ შევქმენით Makefile, რომელიც ეხმარება განლაგებას, სერვისის გაშვებას და ჟურნალების ნახვას.

. PHONY: ინსტალაციის გაშვება დაწყების გაჩერების სტატუსის ჟურნალი განლაგება 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 საცავში.