პითონის დაწყება ESP8266 და ESP32: 6 ნაბიჯი

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

Bacground

ESP8266 და მისი უმცროსი უფროსი ძმა ESP32 არის იაფი Wi-Fi მიკროჩიპები სრული TCP/IP სტეკით და მიკრო კონტროლერის შესაძლებლობებით. ESP8266 ჩიპი პირველად შემქმნელთა საზოგადოების ყურადღების ცენტრში მოექცა 2014 წელს. მას შემდეგ, დაბალი ფასი (<5 აშშ დოლარი), მისი Wi-Fi შესაძლებლობები, ჩაშენებული ფლეშ მეხსიერება 1 ან 4 მბ და მრავალფეროვანი ხელმისაწვდომი განვითარება დაფები, გააკეთა ESP ჩიპი ერთ-ერთი ყველაზე პოპულარული მიკროკონტროლი WiFi და IoT წვრილმანი პროექტებისთვის.

MicroPython არის მზარდი და ეფექტური დანერგვა სულ უფრო პოპულარული პითონის პროგრამირების ენაზე, რომელიც მოიცავს პითონის სტანდარტული ბიბლიოთეკის მცირე ქვეჯგუფს და ოპტიმიზირებულია მიკროკონტროლერებზე მუშაობისთვის.

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

MiPy-ESP პროექტი

ჯერ კიდევ 2015 წელს ჩემი პირველი პროექტები ESP8266– ით დაიწყო ESP-01 ჩიპით Arudions– ის გამოყენებით სერიული კავშირის ჩიპი AT ბრძანებების გასაშვებად. ამის შემდეგ, მომდევნო წლების განმავლობაში მე გამოვიყენე Arduino ბირთვი ESP8266– ისთვის ჩიპების დაპროგრამებისთვის C ++ ენით. ეს მშვენივრად მუშაობს, მაგრამ პითონის მოყვარულთათვის პითონ 3 -ის MicroPython დანერგვის ჩემი აღმოჩენა დიდი სიახლე იყო.

MiPy-ESP პროექტი არის მოქნილი ჩარჩო, რომელიც იყენებს MicroPython– ს სრულფასოვანი Python IoT პროექტებისთვის ESP- ოჯახის მიკრო კონტროლერებზე.

ჩარჩო შემუშავებულია LeGarage ტექნიკური კომიტეტის პროგრამული უზრუნველყოფის შემქმნელი გუნდის მიერ (LG-TC-SWDT-01), რომლის მიზანია შეცვალოს უკვე დამკვიდრებული C ++ კოდი ჩვენი მიკროკონტროლერის პროგრამებისთვის.

პროექტი ითვალისწინებს ძირითად მახასიათებლებს, როგორიცაა

• ქსელთან კავშირის პროცედურები
• ჩიპის წვდომის წერტილის ვებ სერვერი (მონაცემების I/O მონაცემებისთვის wifi კავშირისთვის და ჩიპის ვებგვერდების მომსახურებისთვის)
• MQTT ფუნქციები
• ჟურნალი/გამართვა
• მიკროკონტროლერის ღონისძიებების დაგეგმვა
• აპარატურის I/O რუტინები

ერთი ძირითადი კომპაქტური კოდის სკრიპტით (main.py), ყველა გლობალური კონფიგურაციით (config.py).

ეს მიკტოკონტროლერის კოდი მუშაობს ჩიპური კავშირების მძლავრი შენარჩუნებით WiFi ქსელთან და MQTT ბროკერებთან. არსებული აპარატურის MicroPython მოდულები შეიძლება ადვილად ინტეგრირებული იყოს სისტემაში.

MiPy-ESP ჩარჩო გახდა ჩვენი ჰობის ელექტრონული IoT პროექტების ხერხემალი, რომელიც მოიცავს ESP- ოჯახის ოჯახის მიკროკონტროლებს. ის გამოცდილია რამდენიმე ESP- ოჯახის დაფაზე, როგორიცაა NodeMCU, Wemos და Lolin დაფები.

შემდეგი სახელმძღვანელო არის სახელმძღვანელო იმის შესახებ, თუ როგორ უნდა დაიწყოთ ESP ოჯახის მიკროკონტროლერებით და MicroPython– ით MiPy-ESP ჩარჩოს გამოყენებით.

ნაბიჯი 1: Wemos D1 Mini ESP8266 დაფა

MiPy-ESP ჩარჩო მუშაობს უმეტეს ESP8266 მიკროკონტროლერებთან.

Wemos D1 მინი განვითარების დაფა დაფუძნებულია ESP-8266EX ჩიპზე. 2.5 x 3.5 სმ -ის ნაკვალევზე, მას აქვს 4 მბ ფლეშ მეხსიერება, 11 ციფრული შეყვანის/გამომავალი ქინძისთავები, ყველა ქინძისთავები მხარს უჭერს შეწყვეტას, PWM, I2C, SPI, სერიული და 1 ანალოგური შეყვანა 3.3V მაქსიმალური შეყვანისას, შეუძლია იმუშაოს 5V ენერგიაზე, აქვს მიკრო USB კავშირი და თავსებადია პურის დაფასთან. დაბალმა ფასმა და მისმა მცირე ზომამ აქცია ჩემი საყვარელი ESP დაფა.

გარდა ამისა, დაფის D1 მინი პრო ვერსია გააჩნია გარე ანტენის დასაკავშირებლად, რაც მნიშვნელოვნად გაზრდის კავშირის დიაპაზონს (+100 მ დიაპაზონი). ამას რომ დავამატოთ, დაფას ასევე გააჩნია ყუთის გარეთ არსებული გაფართოების დაფები მსგავსი კომპაქტური ზომით.

ნაბიჯი 2: ემზადებით MicroPython– ისთვის ESP ჩიპზე

ამ პირველ ნაბიჯში თქვენ

• შეაერთეთ ESP დაფა USB- ის საშუალებით თქვენს კომპიუტერს
• დააინსტალირეთ Esptool პროგრამა ჩიპის მოციმციმედ
• წაშალეთ ჩიპის მეხსიერება
• დააინსტალირეთ ჩიპი MicroPython firmware– ით
• დააინსტალირეთ Rshell ბრძანების ხაზის ურთიერთქმედების გასააქტიურებლად თქვენს ჩიპთან
• დააინსტალირეთ mpy-cross (.py ფაილების ორობაში შესადგენად)

დაფის კომპიუტერთან USB დაფების საშუალებით ჩაშენებული USB სერიული პორტით UART ხელმისაწვდომი გახდება თქვენი კომპიუტერისთვის და არის უმარტივესი ვარიანტი დასაწყებად. USB კავშირის გარეშე დაფებისთვის, FTDI მოდული USB სერიულით შეიძლება გამოყენებულ იქნას გარე სამყაროსთან დაკავშირებული მოციმციმე GPIO ქინძისთავების დასაკავშირებლად, მაგრამ ეს არ არის გათვალისწინებული ამ სახელმძღვანელოში.

MicroPython– ისთვის, რომელიც იყენებს MiPy-ESP კოდს, ჩიპის ფლეშ ზომაზე მინიმალური მოთხოვნაა 1 მბ. ასევე არის სპეციალური დაფა დაფებისთვის 512 კბ, მაგრამ ამას არ აქვს ფაილური სისტემის მხარდაჭერა, რაზეც MiPy-ESP არის დამოკიდებული.

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

Esptool პროგრამული უზრუნველყოფის შესახებ ინფორმაცია შეგიძლიათ იხილოთ Esptool GitHub საცავში. თუ გსურთ გამოიყენოთ Windows/Linux/OSX (MAC), ზემოთ მოცემული ბმული ასევე მოიცავს ამას. პითონის პაკეტის დაყენება შესაძლებელია

pip დააინსტალირეთ esptool

Linux– ის მომხმარებლებისთვის, Esptool– ის პაკეტები ინახება Debian– სა და Ubuntu– სთვის, ასევე შესაძლებელია მათი დაყენება

sudo apt დააინსტალირეთ esptool

წაშალეთ ESP ფლეშ მეხსიერება Esptool– ის გამოყენებით, თქვენ წაშლით ESP ფლეშ მეხსიერებას ბრძანებით

esptool.py --port /dev /ttyUSB0 erase_flash

MicroPyton firmware იტვირთება.bin ფაილში, რომლის გადმოწერაც შესაძლებელია MicroPython ვებგვერდიდან.

რეპოს მიმდინარე პროექტის მთავარი ფილიალი შემოწმებულია და მუშაობს Micropython v.1.12. MiPY-ESP ჩარჩოს წარმატების უზრუნველსაყოფად, გადმოწერეთ ფაილი 'esp8266-20191220-v1.12.bin' ამ ბმულიდან და ჩაწერეთ firmware ჩიპზე ბრძანებით:

esptool.py --port /dev /ttyUSB0-baud 460800 write_flash --flash_size = აღმოაჩინე 0 esp8266-20191220-v1.12.bin

Rshell პაკეტი იძლევა ბრძანების ხაზის ურთიერთქმედებას თქვენს ჩიპზე დაყენებულ თქვენს MicroPython გარემოსთან. ეს შეგიძლიათ იხილოთ ამ ბმულზე. Rshell არის მარტივი ჭურვი, რომელიც მუშაობს მასპინძელზე და იყენებს MicroPython– ის ნედლეულ – REPL– ს, რომ გამოაგზავნოს პითონის ფრაგმენტები დაფაზე, ფაილური სისტემის ინფორმაციის მისაღებად და ფაილების კოპირებისთვის MicroPython– ის ფაილური სისტემიდან. REPL ნიშნავს წაკითხული შეაფასეთ ბეჭდვის მარყუჟი და არის სახელი, რომელიც მოცემულია ინტერაქტიული MicroPython მოთხოვნით, რომლის წვდომა შეგიძლიათ ESP8266– ზე. REPL– ის გამოყენება უმარტივესი გზაა თქვენი კოდის შესამოწმებლად და ბრძანებების გასაშვებად. დააინსტალირეთ Rshell ბრძანებით:

sudo pip დააინსტალირეთ rshell

Mpy-cross შემდგენლის MicroPython- ის დაყენება შეიძლება გამოყენებულ იქნას ascii.py ფაილებით, რომლებიც ჩატვირთულია ჩიპის ფაილურ სისტემაში. MicroPython ასევე განსაზღვრავს.mpy ფაილების კონცეფციას, რომელიც არის ორობითი კონტეინერის ფაილის ფორმატი, რომელიც შეიცავს წინასწარ შედგენილ კოდს და რომლის იმპორტირებაც შესაძლებელია.py მოდულის მსგავსად.. Py ფაილების.mpy შედგენით, მეტი RAM მეხსიერება იქნება ხელმისაწვდომი თქვენი გაშვებული კოდისთვის - და ეს საჭიროა MiPy -ESP ჩარჩოს ფუნქციონირების ძირითადი მოდულის მისაღებად.

MiPy-ESP კოდის განსახორციელებლად, mpy-cross MicroPython ჯვრის შემდგენელი ადგენს.py სკრიპტებს.mpy– მდე ჩიპის ატვირთვის წინ. დააინსტალირეთ mpy-cross პაკეტი ამ ბმულის ინსტრუქციით. ალტერნატიულად, mpy-cross ბრძანება შეიძლება დაინსტალირდეს Python pip ბრძანებით ან გაუშვას mpy-cross საქაღალდის ბილიკიდან, თუ აქ დააკლონ MicroPython საცავი GitHub– დან.

ახლა თქვენ გაქვთ MicroPython და ყველა საჭირო ინსტრუმენტი დაინსტალირებული თქვენი პირველი MiPy-ESP პროექტის მშენებლობის დასაწყებად

ნაბიჯი 3: დაწყება MiPy-ESP– ით

ამ ნაბიჯში თქვენ

ჩამოტვირთეთ MyPy-ESP ჩარჩო

MiPy-ESP ჩარჩოს ჩამოტვირთვა MiPy-ESP პროექტი შეგიძლიათ იხილოთ GitHub– ში ამ კოდის საცავში. GitHub– დან შეგიძლიათ ჩამოტვირთოთ საცავის ფაილის სტრუქტურა, ან მოახდინოთ მისი კლონირება თქვენს კომპიუტერში

git კლონი

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

ნაბიჯი 4: MiPy-ESP ჩარჩო არქიტექტურა

ამ ნაბიჯში თქვენ

გაეცანით MiPy-ESP კოდის მუშაობას

MiPy-ESP კოდის არქიტექტურა

პითონის ყველა ჩარჩო მოდული ნაპოვნია MiPY-ESP კოდის საცავის /src საქაღალდეში. Src/core საქაღალდე შეიცავს ძირითად მოდულებს, რომლებიც შედის ყველა პროექტში. Src/drivers საქაღალდეში არის მოდულების შერჩევა სხვადასხვა აპარატურისთვის, რომელიც დაკავშირებულია თქვენს ჩიპთან. Src/utilities საქაღალდე შეიცავს სურვილისამებრ სასარგებლო მოდულებს, რომლებიც უნდა შეიტანოთ თქვენს პროექტში.

ფაილები main.py და config.py გვხვდება src/ საქაღალდეში. ეს არის ძირითადი ფაილების შესწორება თქვენი პროექტის შესაქმნელად:

config.py:

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

main.py:

ეს არის მიკროკონტროლერის კოდის მთავარი სკრიპტი. იგი შეიცავს პროგრამის სპეციფიკურ კოდს ჩარჩოში. ჩიპის ჩატვირთვისას, main.py გადის და იმპორტირებს პროექტზე დამოკიდებული ყველა მოდულს მოცემული შეყვანის საშუალებით config.py ფაილიდან. ზემოთ მოყვანილი დიაგრამა გვიჩვენებს main.py სკრიპტის განლაგებას.

ზემოთ მოყვანილი ფიგურა აღწერს main.py– ს მუშაობას:

1. ჩატვირთვისას, კოდი ცდილობს ჩიპის Wi-Fi ქსელთან დაკავშირებას ადრე გამოყენებული ქსელები და მათი პაროლები (დაშიფრული ჩიპზე) ინახება ფლეშ მეხსიერებაში. ქსელის SSID და მათი პაროლები შეიძლება იყოს მითითებული ფაილში wifi.json ფორმატში {" SSID1 ":" პაროლი "," SSID ":" პაროლი 2 "}. ამ ფაილში მოცემული ქსელები ინახება, პაროლები დაშიფრულია და ფაილი წაიშლება ჩატვირთვისას.
2. თუ უკვე არ არის ცნობილი ქსელები, კოდი ადგენს წვდომის წერტილს (AP) ვებ სერვერს ჩიპის AP სერვერის SSID და პაროლი მითითებულია config.py ფაილში. ჩიპის SSID– ზე შესვლისას, ვებ – გვერდი Wi-Fi– ზე შესასვლელად ემსახურება 192.168.4.1. გამოვლენილი ქსელები ნაჩვენებია მენიუში, ან SSID– ის ხელით შეყვანა (ფარული ქსელები) Wi-Fi პაროლთან ერთად რა ჩიპის Wi-Fi– ს წარმატებული კავშირის შემდეგ, AP სერვერი ითიშება და main.py კოდი განაგრძობს მის შემდგომ ნაბიჯებს.

3. Main.py– ის დაყენების განყოფილებაში,

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

4. კოდი გადადის მთავარ მიკროკონტროლერის მარყუჟში,

   • ქსელისა და MQTT საბროკერო კავშირების უწყვეტი შემოწმება,
   • MQTT ხელმოწერები,
   • აპარატურა I/O
   • და დაგეგმილი სამუშაოები.
   • დაკარგული ქსელის ან MQTT საბროკერო კავშირის შემთხვევაში, კოდი ცდილობს ხელახლა დამკვიდრებას.

ნაბიჯი 5: თქვენი პროექტის კოდის მომზადება

ამ ნაბიჯში თქვენ

• გაეცანით MiPy-ESP საცავის ფაილის სტრუქტურას
• მოამზადეთ თქვენი პროექტის კოდი ჩიპის ატვირთვისთვის

საცავის საქაღალდის სტრუქტურა ზემოთ ფიგურა აღწერს საცავის საქაღალდის სტრუქტურას და ჩამოთვლის ჩარჩოს მიმდინარე მოდულებს. თქვენი პროექტი არის ეტაპები src/ საქაღალდეში. ძირითადი MiPy-ESP ჩარჩო მოდულები განთავსებულია src/core, სურვილისამებრ სასარგებლო მოდულებში src/utilities და ტექნიკის მოდულები src/მძღოლებში.

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

პროექტის კოდის დადგმა თქვენი პროექტის კონკრეტული კოდი უნდა განთავსდეს src/ საქაღალდეში. უკვე არსებობს, არის main.py და config.py ფაილები, რომელთა რედაქტირებაც შეგიძლიათ. ასევე დააკოპირეთ სასურველი პროექტის კომუნალური მომსახურება src/utilities და src/drivers src/ - დან.

იმ შემთხვევაში თუ გსურთ ჩიპს მიაწოდოთ ცნობილი Wi-Fi ქსელები და პაროლები, დაამატეთ ფაილი wifi.json src/.

შედგენა და მომზადება ატვირთვისათვის გათვალისწინებული მაკიაჟი შეიძლება გამოყენებულ იქნას ჩიპზე გადასატანი ფაილების მოსამზადებლად.py ფაილების შედგენაში / src, ძირითადი მოდულების შედგენა და შედგენილი ფაილების გადატანა ახალ საქაღალდეში სახელწოდებით build / ბრძანებით

გააკეთე აშენება

ჩამონტაჟებული ფაილები მზად არის ჩიპის ფაილურ სისტემაში ასატვირთად. ნაგულისხმევად, main.py და config.py არ არის შედგენილი ორობითი, რათა მათზე ადვილად წვდომა განლაგებული ჩიპების შემოწმებისთვის. ბრძანება:

გაწმინდე

წაშლის აღნაგობა/ საქაღალდე და მისი შინაარსი.

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

ამ განყოფილებაში თქვენ

• ატვირთეთ მომზადებული ფაილები მშენებლობაში/ ბოლო განყოფილებიდან
• გაშვებული კოდის დაწყება და მონიტორინგი

აშენების/ ფაილების ატვირთვა Rshell– ით

ატვირთეთ ყველა ფაილი /შექმენით დირექტორია ESP ჩიპში Rshell– ის გამოყენებით. მიკროკონტროლერთან USB- თან დაკავშირებული, აშენებიდან/ საქაღალდედან დაიწყეთ Rshell ბრძანებით

rshell -p /dev /ttyUSB0

შემდეგ შეამოწმეთ ჩიპის ფაილები (ასეთის არსებობის შემთხვევაში)

ls /დაფა

ჩიპზე არსებული ყველა ფაილის წაშლა შესაძლებელია

rm /pyboard/*.*

დააკოპირეთ ყველა პროექტის ფაილი ჩიპში/ ჩიპში:

cp *. * /დაფა

შემდეგ დაიწყეთ ინტერაქტიული პითონის ტერმინალი ბრძანებით

გამეორება

ახლა თქვენ შეგიძლიათ მოიძიოთ პითონის ბრძანებები ან შეიტანოთ მოდულები და დააკვირდეთ ჩიპების სერიულ გამომუშავებას MiPy-ESP logger მოდულიდან.

გადატვირთეთ ჩიპი გადატვირთვის ღილაკზე დაჭერით, ან ბრძანების სტრიქონიდან

ძირითადი იმპორტი

ან

იმპორტის მანქანა

და მერე

მანქანა. გადატვირთვა ()

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

იმედია ეს უნდა დაგეწყოთ.