სუპერ მარტივი Raspberry Pi 433MHz სახლის ავტომატიზაცია: 7 ნაბიჯი

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

ეს გაკვეთილი ერთ -ერთია იმ მრავალთა შორის, როდესაც საქმე ეხება Raspberry Pi– ს გამოყენებას სახლის უკაბელო მოწყობილობების გასაკონტროლებლად. სხვათა მსგავსად, ის გაჩვენებთ თუ როგორ გამოიყენოთ იაფი გადამცემი/მიმღები წყვილი, რომელიც თქვენს Pi- ზეა მიჯაჭვული, ჩვეულებრივ მოწყობილობებთან, რომლებიც მუშაობენ 433 მჰც რადიო სიხშირის დიაპაზონში. ის კონკრეტულად გაჩვენებთ, თუ როგორ ჩართოთ ან გამორთოთ ნებისმიერი ელექტრო მოწყობილობა თქვენი Pi- ს გამოყენებით, ბრძანებების გადაცემით 433 მჰც დისტანციური მართვის დენის სოკეტებზე.

რატომ შევქმენი ეს სახელმძღვანელო, თუ ამდენი უკვე არსებობს? ძირითადად იმიტომ, რომ თითქმის ყველა სხვა გაკვეთილი, რომელსაც მე წავაწყდი, ზედმეტად ართულებდა ყველაფერს, განსაკუთრებით პროგრამული უზრუნველყოფის მხრივ. მე შევამჩნიე, რომ ისინი დიდწილად ეყრდნობოდნენ მესამე მხარის ბიბლიოთეკებს, სკრიპტებს ან კოდის ამონარიდებს ყველა სამუშაოს შესასრულებლად. ბევრი არც კი განმარტავს, თუ რას აკეთებდა ძირითადი კოდი - ისინი უბრალოდ გკითხავდნენ ორი ან სამი პროგრამული უზრუნველყოფის გადატანას თქვენს Pi- ზე და ასრულებდა რამოდენიმე ბრძანებას, კითხვების გარეშე. მე ნამდვილად მინდოდა ვცადო და გამომეყენებინა ჩემი Pi, რათა ჩართო და გამორთო ელექტრო მოწყობილობები ჩემს სახლში 433MHz დისტანციური მართვის სოკეტების გამოყენებით, მაგრამ მინდოდა შემექმნა სისტემის ჩემი ვერსია, რომლის გაგებაც შემეძლო, იმედია აღმოფხვრის საჭიროებას გამოიყენეთ სხვისი ბიბლიოთეკები ან სკრიპტები.

ეს არის ის, რაც ეს გაკვეთილი არის. ამ სისტემის პროგრამული მხარე შედგება ორი ძალიან მარტივი პითონის სკრიპტისაგან - ერთი სიგნალების მისაღებად და ჩაწერისთვის, ხოლო ერთი ამ სიგნალების უკაბელო კვების ბლოკებზე გადასვლისთვის. სიგნალის ფაქტობრივი მიღება/გადაცემა ეყრდნობა მხოლოდ ადვილად გამოსაყენებელ RPi. GPIO ბიბლიოთეკას, რომელიც, ყოველ შემთხვევაში ჩემთვის, წინასწარ დაინსტალირებული იყო Raspbian– ით. ეს ბიბლიოთეკა ასევე შეიძლება პირდაპირ იმპორტირებული პითონში.

ამ პროექტისთვის დაგჭირდებათ:

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

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

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

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

[თუ გადაწყვეტთ რომელიმე ამ პროდუქტის ყიდვას, მე ძალიან ვაფასებ, თუკი თქვენ შეხვალთ ჩამონათვალში ზემოთ მოყვანილი ბმულების გამოყენებით - ამ გზით, მე ვიღებ მოგების მცირე წილს თქვენთვის ზედმეტი ღირებულების გარეშე!]

ნაბიჯი 1: მიმღების განყოფილების დაყენება

სანამ თქვენს Pi- ს გამოიყენებთ დისტანციური მართვის სოკეტებზე ბრძანებების გასაგზავნად, თქვენ უნდა იცოდეთ რა კონკრეტულ სიგნალებს რეაგირებენ ისინი. დისტანციური მართვის სოკეტების უმეტესობა აღჭურვილია ტელეფონით, რომლის საშუალებითაც შესაძლებელია კონკრეტული მოწყობილობების ჩართვა ან გამორთვა. რაც მე შევიძინე, ტელეფონს აქვს ოთხი რიგი დაწყვილებული ON/OFF ღილაკები, რომელთაგან თითოეული აგზავნის ON ან OFF სიგნალს კონკრეტულ სოკეტში.

ეს ბადებს კითხვას - როგორ ვიცით რომელი ღილაკები რომელ სოკეტს შეესაბამება? ეს ნამდვილად დამოკიდებულია თქვენს მოდელზე. ერთ -ერთი მთავარი მიზეზი, რის გამოც მე შევარჩიე სოკეტის განსაკუთრებული სტილი (შესავალში არის დაკავშირებული) არის ის, რომ ერთეულების კონფიგურაცია შესაძლებელია ფიზიკური გადამრთველით, რათა კონკრეტული სოკეტი რეაგირებდეს ტელეფონზე ჩართული/გამორთული ღილაკების კონკრეტულ ნაკრებზე. ეს ასევე ნიშნავს იმას, რომ თქვენ შეგიძლიათ გათიშოთ და გადაიტანოთ სოკეტები სახლის გარშემო, იცოდეთ რომ თითოეული ერთეული ყოველთვის პასუხობს ერთსა და იმავე ON/OFF სიგნალებს.

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

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

ზემოთ მოყვანილი სურათი საკმაოდ აჯამებს გაყვანილობას. მიმღების თითოეული პინი შეიძლება პირდაპირ შეუერთდეს Pi- ს შესაბამის პინს. მე ვიყენებ breadboard და jumper კაბელებს, რათა პროცესი ცოტა უფრო ელეგანტური გახდეს. გაითვალისწინეთ, რომ თქვენ შეგიძლიათ აირჩიოთ ნებისმიერი GPIO მონაცემთა პინი, რომ დაუკავშიროთ ცენტრალურ მიმღების ნებისმიერ პინს. ჩემს Pi სათაურზე გამოვიყენე პინი, რომელიც მონიშნულია როგორც „23“.

მნიშვნელოვანია: თუ თქვენ დააკავშირებთ ზემოთ გამოსახულებაში აღნიშნულ '3v3' პინს უფრო მაღალი ძაბვის პინზე Pi- ზე (მაგ. 5v), თქვენ ალბათ დააზიანებთ Pi- ს, რადგან GPIO ქინძისთავები ვერ იტანს ძაბვებს 3v3- ზე ზემოთ. ალტერნატიულად, თქვენ შეგიძლიათ ჩართოთ იგი 5 ვ -ით და დააყენოთ ძაბვის გამყოფი, რომ უსაფრთხო ძაბვა გაგზავნოთ მონაცემთა PIN- ზე.

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

ნაბიჯი 2: ამოიღეთ ტელეფონის კოდები

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

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

datetime– დან იმპორტი datetime

იმპორტი matplotlib.pyplot როგორც pyplot იმპორტი RPi. GPIO როგორც GPIO

RPi. GPIO და თარიღის ბიბლიოთეკები შედიოდა ჩემს Raspbian განაწილებაში, მაგრამ მე უნდა დამეყენებინა matplotlib ბიბლიოთეკა შემდეგნაირად:

sudo apt-get დააინსტალირეთ python-matplotlib

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

როდესაც ის გაშვებულია (ბრძანების 'python ReceiveRF.py') გამოყენებით, ის დააკონფიგურირებს განსაზღვრულ GPIO პინს მონაცემების შეყვანის სახით (ნაგულისხმევი პინი 23). შემდეგ ის მუდმივად აიღებს პინის სინჯს და შეაფასებს იღებს თუ არა ციფრულ 1 -ს ან 0. ეს გრძელდება განსაზღვრული ხანგრძლივობით (სტანდარტულად 5 წამი). როდესაც ეს დრო ამოიწურება, სკრიპტი შეწყვეტს მონაცემების ჩაწერას და დახურავს GPIO შეყვანას. შემდეგ იგი ასრულებს მცირე დამუშავებას და ასახავს მიღებულ შეყვანის მნიშვნელობას დროის მიხედვით. კიდევ ერთხელ, თუ თქვენ გაქვთ შეკითხვები იმის შესახებ, თუ რას აკეთებს სცენარი, თქვენ ალბათ თავად გაეცით პასუხი მას შემდეგ, რაც შეხედავთ როგორ მუშაობს იგი. მე შევეცადე კოდი მაქსიმალურად წაკითხული და მარტივი გამეხადა.

რა უნდა გააკეთოთ, ყურადღება მიაქციეთ, როდესაც სკრიპტი მიუთითებს, რომ მან ** ჩაწერა დაიწყო **. როგორც კი ეს შეტყობინება გამოჩნდება, თქვენ უნდა დააჭიროთ და დაიჭიროთ ტელეფონის ერთ -ერთი ღილაკი დაახლოებით ერთი წამის განმავლობაში. დარწმუნდით, რომ დაიჭირეთ იგი მიმღებთან ახლოს. სკრიპტის ჩაწერის დასრულების შემდეგ ის გამოიყენებს matplotlib სიგნალის გრაფიკული ტალღის ფორმას, რომელიც მან მიიღო ჩაწერის ინტერვალის დროს. გთხოვთ გაითვალისწინოთ, თუ თქვენს Pi– ს უკავშირდებით SSH კლიენტის გამოყენებით, როგორიცაა PuTTY, ასევე დაგჭირდებათ X11 პროგრამის გახსნა, რათა ტალღის ფორმა გამოჩნდეს. მე ვიყენებ xMing– ს ამისათვის (და სხვა საკითხებისთვის, როგორიცაა დისტანციური დესკტოპის შეყვანა ჩემს Pi– ში). იმისათვის, რომ ნაკვეთი გამოჩნდეს, უბრალოდ დაიწყეთ xMing სკრიპტის გაშვებამდე და დაელოდეთ შედეგების გამოჩენას.

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

ნაბიჯი 3: შედეგად მიღებული სიგნალის გადაწერა

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

1 = მოკლე_მომავალი

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

1111111111111010101011101

ახლა თქვენ უბრალოდ უნდა გაიმეოროთ ეს პროცესი თქვენი ტელეფონის სხვა ღილაკების შესაბამისი სიგნალების ჩაწერისა და ტრანსკრიფციისთვის და თქვენ დაასრულეთ პროცესის პირველი ნაწილი!

სანამ სიგნალების ხელახლა გაგზავნას გადამცემის გამოყენებით შეძლებთ, გასაკეთებელი კიდევ ცოტაა. 1 -ის ან 0 -ის შესაბამისი მაღლა და ვარდნას შორის დრო ძალიან მნიშვნელოვანია და თქვენ უნდა დარწმუნდეთ, რომ თქვენ იცით რამდენ ხანს გრძელდება სინამდვილეში „მოკლე_ზე“ან „გრძელი გასვლა“. ჩემი კოდებისთვის, იყო სამი ცალი დროული ინფორმაცია, რომელიც მჭირდებოდა ამონაწერი სიგნალების გამეორებისთვის:

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

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

• მოკლე_ გადადება = 0.00045
• long_delay = 0.00090 (ორჯერ მეტი ვიდრე "მოკლე")
• გაფართოებული_გვიანება = 0.0096

ნაბიჯი 4: გადამცემი მოწყობილობის დაყენება

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

ამ შემთხვევაში, ნორმალურია, რომ აპარატი ჩართოთ Pi- დან 5 ვ მიწოდებით, რადგან DATA pin არ გაუგზავნის სიგნალებს Pi- ს, მიიღებს მხოლოდ მათ. ასევე, 5 ვ ელექტროენერგიის მიწოდება უზრუნველყოფს უფრო მეტ გადაცემის დიაპაზონს, ვიდრე 3v3 წყაროს გამოყენებით. კიდევ ერთხელ, თქვენ შეგიძლიათ დააკავშიროთ DATA pin ნებისმიერ შესაბამის პინზე Pi- ზე. მე გამოვიყენე პინი 23 (იგივე რაც მიმღებისთვის).

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

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

ნაბიჯი 5: სიგნალების გადაცემა Pi- ს გამოყენებით

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

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

იმპორტის დრო

იმპორტი sys იმპორტი RPi. GPIO როგორც GPIO

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

a_on = '111111111111101010101011101'

a_off = '1111111111111010101010111 "b_on =' 1111111111101110101011101" b_off = '1111111111101110101010111 "c_on =' 1111111111101011101011101" c_off = '1111111111101011101010111 "d_on =' 1111111111101010111011101" d_off = '1111111111101010111010111 "short_delay = 0,00045 long_delay = 0,00090 extended_delay = 0,0096

აქ ჩვენ გვაქვს რვა კოდის სტრიქონი (ორი ჩემს ტელეფონში ჩართული/გამორთული ღილაკების თითოეული წყვილისთვის - შეიძლება გქონდეთ მეტი ან ნაკლები კოდი), რასაც მოჰყვება დროის სამი მონაცემი, ასევე განსაზღვრული ნაბიჯი 3. დაუთმეთ დრო, რომ დარწმუნდეთ, რომ გაქვთ სწორად შეიყვანეთ ეს ინფორმაცია.

მას შემდეგ რაც კმაყოფილი იქნებით სკრიპტში შესული კოდებით/დაგვიანებებით (სურვილისამებრ შეგიძლიათ გადაარქვათ კოდის სიმებიანი ცვლადები), თქვენ საკმაოდ მზად ხართ სისტემის გამოსაცდელად! სანამ ამას გააკეთებთ, გადახედეთ სკრიპტში transmit_code () ფუნქციას. სწორედ აქ ხდება გადამცემთან რეალური ურთიერთქმედება. ეს ფუნქცია ელოდება კოდის ერთ სტრიქონს არგუმენტის სახით გაგზავნას. შემდეგ ის ხსნის განსაზღვრულ პინს, როგორც GPIO გამომავალს და ატრიალებს კოდის სტრიქონის ყველა სიმბოლოს. შემდეგ ის ჩართავს ან გამორთავს გადამცემს დროის ინფორმაციის მიხედვით, რომელიც თქვენ შეიყვანეთ, რათა შეიქმნას ტალღის ფორმა, რომელიც შეესაბამება კოდის სტრიქონს. ის აგზავნის თითოეულ კოდს რამდენჯერმე (სტანდარტულად 10), რათა შეამციროს მისი გამოტოვების შანსი და ტოვებს გაფართოებულ_ყოველ კოდს თითოეულ ბლოკს შორის, ისევე როგორც ტელეფონს.

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

პითონი TransmitRF.py კოდი_1 კოდი_2…

თქვენ შეგიძლიათ გადაიტანოთ რამოდენიმე კოდის სტრიქონი სკრიპტის ერთი გაშვებით. მაგალითად, სოკეტების (a) და (b) და სოკეტის (c) გამორთვისთვის გაუშვით სკრიპტი შემდეგი ბრძანებით:

პითონი TransmitRF.py a_on b_on c_off

ნაბიჯი 6: შენიშვნა დროის სიზუსტეზე

როგორც აღვნიშნეთ, გადაცემულ ჩართულ/გამორთულ იმპულსებს შორის დრო საკმაოდ მნიშვნელოვანია. TransmitRF.py სკრიპტი იყენებს პითონის time.sleep () ფუნქციას ტალღების ფორმების შესაქმნელად პულსის სწორი ინტერვალებით, მაგრამ უნდა აღინიშნოს, რომ ეს ფუნქცია არ არის მთლად ზუსტი. ხანგრძლივობა, რისთვისაც ის იწვევს სკრიპტის ლოდინს შემდეგი ოპერაციის შესრულებამდე, შეიძლება დამოკიდებული იყოს პროცესორის დატვირთვაზე მოცემულ მომენტში. ეს არის კიდევ ერთი მიზეზი, რის გამოც TransmitRF.py აგზავნის თითოეულ კოდს რამდენჯერმე - მხოლოდ იმ შემთხვევაში, თუ time.sleep () ფუნქციას არ შეუძლია სწორად ააშენოს კოდის მოცემული მაგალითი.

მე პირადად არასოდეს მქონია პრობლემა time.sleep () კოდების გაგზავნისას. თუმცა მე ვიცი, რომ ჩემი time.sleep () ტენდენცია აქვს შეცდომა დაახლოებით 0.1ms. მე განვსაზღვრე ეს თანდართული SleepTest.py სკრიპტის გამოყენებით, რომელიც შეიძლება გამოყენებულ იქნას იმის დასადგენად, თუ რამდენად ზუსტია თქვენი Pi- ს time.sleep () ფუნქცია. ჩემი კონკრეტული დისტანციური მართვის სოკეტებისთვის, უმოკლესი შეფერხება, რომლის განხორციელებაც მჭირდებოდა იყო 0.45 წმ. როგორც ვთქვი, მე არ მქონია პრობლემები არასასურველი სოკეტებთან დაკავშირებით, ასე რომ, როგორც ჩანს, 0.45 ± 0.1ms საკმარისია.

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

ნაბიჯი 7: დასკვნა

ამ პროექტმა წარმოადგინა ნებისმიერი ელექტრული მოწყობილობის კონტროლის მეთოდი Raspberry Pi- ს და 433MHz დისტანციური მართვის სოკეტების გამოყენებით, აქცენტი გაკეთებულია სიმარტივეზე და გამჭვირვალობაზე. ეს არის ყველაზე ამაღელვებელი და მოქნილი პროექტი, რომლისთვისაც მე გამოვიყენე ჩემი Pi და არსებობს უსაზღვრო პროგრამები. აქ არის რამოდენიმე რამ რისი გაკეთებაც ახლა შემიძლია ჩემი პიის წყალობით:

• ჩართეთ ელექტრო გამათბობელი ჩემი საწოლის გვერდით, ჩემი მაღვიძარის ჩაქრობამდე ნახევარი საათით ადრე.
• გამოთიშეთ გამაცხელებელი ძილის შემდეგ ერთი საათის შემდეგ.
• აანთეთ ჩემი საწოლის შუქი, როდესაც მაღვიძარა ითიშება, რათა არ დავიძინო.
• და მრავალი სხვა…

ამ ამოცანების უმეტესობისთვის მე ვიყენებ crontab ფუნქციას Linux– ში. ეს გაძლევთ საშუალებას შექმნათ ავტომატური დაგეგმილი ამოცანები, რომ გაუშვათ TransmitRF.py სკრიპტი კონკრეტულ დროს. თქვენ ასევე შეგიძლიათ გამოიყენოთ Linux ბრძანებით ერთჯერადი დავალებების შესასრულებლად (რაც, ჩემთვის, ცალკე უნდა დაინსტალირებულიყო 'sudo apt-get install at'). მაგალითად, გამაცხელებელი რომ ჩავრთო დილით მაღვიძარას ჩაქრობამდე ნახევარი საათით, ყველაფერი რაც მჭირდება არის აკრიფოთ:

05:30 საათზე

პითონი TransmitRF.py c_on

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