Arduino კონტროლი wifi-ით. Arduino-ს გაკვეთილები: მოწყობილობების კონტროლი სმარტფონიდან დუიმებისთვის

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

მაგრამ ახლა კიდევ ერთმა ჩინურმა პროდუქტმა დაიპყრო ბაზარი; შეგიძლიათ დააკავშიროთ თქვენი საკუთარი wi-fi jammer esp8266 Arduino დაფას ან სხვა სისტემას და მიიღებთ სტაბილურ კავშირს სხვა უპირატესობებთან ერთად. მოდით გავარკვიოთ arduino uno wi-fi და ღირს თუ არა ამ მოდულის ყიდვა, ასევე რა არის რეალურად მსგავსი მიკროკონტროლერი arduino wi-fi-ზე.

ხელმისაწვდომი Wi-Fi მოდულები Arduino-სთვის

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

ამრიგად, arduino wi-fi esp8266 ახლა ითვლება ყველაზე ხელმისაწვდომ მოდულად ბაზარზე, ისევე როგორც ყველა მისი ძმა. ამგვარად, უცხოურ საიტებზე ფასი იწყება 2 დოლარიდან, რაც საშუალებას გაძლევთ შეიძინოთ ეს მოდულები პარტიაში და არ მოგიწიოთ მათი ათასჯერ გადატვირთვა, ფუნქციონირების შესანარჩუნებლად კონტაქტების ხელახალი გაყიდვა.

თავდაპირველად, ეს Arduino wi-fi მოდული გამოიყენებოდა ძირითადად, როგორც arduino wi-fi ფარი, რადგან ეს იყო ყველაზე იაფი ვარიანტი და არანაირად არ ჩამოუვარდებოდა თავდაპირველს. მოწყობილობა მართლაც თითქმის ლეგენდარულია, რადგან მის ფასს არ აქვს მნიშვნელოვანი ნაკლოვანებები. არსებობს მრავალი ბიბლიოთეკა, მათ შორის მომხმარებლის ბიბლიოთეკები და ასევე მხარს უჭერს მუშაობას სერიული ავტობუსებით და უმარტივესი AT და AT+ ბრძანებებით. ამის წყალობით, არ არის საჭირო ცნობილი C99-ის რაიმე სემანტიკის შესწავლა, როგორც ეს ხშირად ხდება სხვა მესამე მხარის მიკროკონტროლერებთან.

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

1. პროცესორი არის 160 MHz, მაგრამ არის 32-ბიტიანი, რაც გარკვეულ კვალს ტოვებს შესრულებაზე. მაგრამ უნდა გვახსოვდეს, რომ მოდული კვლავ გამოიყენება Arduino დაფებთან ერთად, რომლებიც თავად ჭრიან მაღალ სიხშირეებს და ჭამს რესურსების უმეტეს ნაწილს გაურკვეველი მიზეზების გამო.
2. მწარმოებელმა, რომელმაც გამოუშვა esp8266 wi-fi მოდული, არ შეაჩერა საინტერესო პროექტები და ახლა არის დადასტურებული ხარისხის მიკროკონტროლერების მთელი ხაზი.
3. თანამედროვე ქსელის უსაფრთხოების სტანდარტები. რა თქმა უნდა, WPA და WPA2 აღარ არის ისეთი უსაფრთხო, როგორც ჩვენ გვსურს, მაგრამ მათი ყოფნა არ შეიძლება არ გვსიამოვნებდეს ასეთ იაფ კონტროლერში.
4. 16 გამომავალი პორტი, მათ შორის 10-ბიტიანი, რაც საშუალებას გაძლევთ ექსპერიმენტი გააკეთოთ დაფაზე.

რაც მთავარია, ყუთში ნახავთ 4 მეგაბაიტამდე მუდმივ მეხსიერებას, რაც დამოკიდებულია დაფის ტიპზე, და ეს მნიშვნელოვნად ამარტივებს მუშაობას დიდ ბიბლიოთეკებთან და ზოგიერთ მედია ფაილთანაც კი. ბოლოს და ბოლოს, Arduino-ს უმეტეს დაფებზე 1 მეგაბაიტიც კი მიუწვდომელ ფუფუნებად ითვლება.

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

როგორ დააკავშიროთ Wi-Fi მოდული Arduino-სთან

მოდით შევხედოთ esp8266 esp 12e-ს დაკავშირებას და რა არის esp8266 wi-fi uart ხიდი. ყოველივე ამის შემდეგ, ეს არის მოდულის კავშირი და კონფიგურაცია, რომელიც ბადებს ყველაზე მეტ კითხვას.

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

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

ზემოთ აღწერილი კაბელის დასაკავშირებელი ქინძისთავები სტანდარტულია, მაგრამ სიმძლავრე მოდის Arduino-დან 3.3 ვოლტიანი პინით. მნიშვნელოვანია გვახსოვდეს, რომ დაფის მიერ მიწოდებული მაქსიმალური დენი არ შეიძლება დაყენდეს 150 mA-ზე ზემოთ, ხოლო esp8266 esp 07 და esp8266 witty cloud wi-fi მოდული arduino-სთვის საჭიროებს 240 mA-ს.

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

კავშირის კიდევ ერთი ვარიანტი მოცემულია ქვემოთ. მნიშვნელოვანია - RX-TX კონტაქტები დაკავშირებულია ჯვარედინით. ვინაიდან ESP8266 მოდულის სიგნალის დონეებია 3.3V, ხოლო Arduino არის 5V, ჩვენ უნდა გამოვიყენოთ რეზისტენტული ძაბვის გამყოფი სიგნალის დონის გადასაყვანად.

Wi-Fi მოდულის რეგისტრაცია Arduino-ში

მოგეხსენებათ, სათანადო გამოცდილებით, შეგიძლიათ esp8266 ex 12e ფარი დააწყოთ სმარტფონთან, მაგრამ დამწყებთათვის Arduino სისტემაში esp8266 esp 12-ის რეგისტრაცია იწვევს სირთულეებს. სინამდვილეში, საკმარისია მოდულის დაკავშირება და მისი ფუნქციონირების შემოწმება გამართვის მენიუს მეშვეობით რამდენიმე სტანდარტული AT ბრძანების გაცემით.

მაგალითად, შეგიძლიათ დაამატოთ მოციმციმე სტანდარტული LED-ით (დაკავშირების სქემისთვის ზემოთ):

#define TXD 1 // GPIO1/TXD01 void setup() ( pinMode (TXD, OUTPUT); ) void loop () ( digitalWrite (TXD, HIGH); delay (1000); digitalWrite (TXD, LOW); delay (1000) ;)

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

საკმარისია USB-UART გადამყვანი, რადგან esp8266 არ იყენებს Arduino-ს „ტვინს“ და მისი ფლეშ მეხსიერება სავსებით საკმარისია რამდენიმე ძირითადი ბიბლიოთეკისა და პროგრამული უზრუნველყოფის შესანახად. შესაბამისად, აზრი არ აქვს დამატებითი თანხის დახარჯვას დამხმარე დაფაზე, თუ თქვენ შეგიძლიათ უბრალოდ შეაერთოთ იგი კონვერტორზე და შემდგომ გამოიყენოთ იგი პროექტში. ამავდროულად, დამხმარე დენის წყაროს შეერთებით და შეშფოთების გარეშე, რომ მონაცემები შეწყვეტს გადაცემას ყველაზე გადამწყვეტ მომენტში, სისტემის სიმძლავრის ნაკლებობის გამო.

Მნიშვნელოვანი ჩანაწერი! ბოლო სქემისთვის, ჩვენ ჩვეულებისამებრ ავტვირთავთ ესკიზს Arduino-ზე, მაგრამ რადგან ESP8266 მოდული დაკავშირებულია 0 და 1 ქინძისთავებთან, პროგრამირება შეუძლებელი ხდება. შემდგენელი აჩვენებს შეცდომას. გათიშეთ ESP8266-ზე მიმავალი სადენები 0 და 1 ქინძისთავებიდან, გააკეთეთ პროგრამირება და შემდეგ დააბრუნეთ ქინძისთავები თავის ადგილზე და დააჭირეთ გადატვირთვის ღილაკს Arduino-ზე.

ESP8266 ჩიპი არის ერთ-ერთი ყველაზე პოპულარული ინსტრუმენტი უკაბელო კომუნიკაციების ორგანიზებისთვის ჭკვიანი სახლის პროექტებში. უკაბელო კონტროლერის გამოყენებით, თქვენ შეგიძლიათ მოაწყოთ კომუნიკაცია WiFi ინტერფეისის საშუალებით, რაც უზრუნველყოფს Arduino-ს პროექტებს ინტერნეტით წვდომით და მონაცემების დისტანციური მართვისა და შეგროვების შესაძლებლობით. ისეთი პოპულარული დაფები, როგორიცაა WeMos და NodeMcu, ისევე როგორც უამრავი ხელნაკეთი პროექტი, შეიქმნა ESP8266-ის საფუძველზე. ამ სტატიაში ჩვენ გავარკვევთ, თუ რა არის ESP82266, როგორია მისი ჯიშები და როგორ ვიმუშაოთ ESP8266-თან Arduino IDE-ში.

ESP8266 არის მიკროკონტროლერი WiFi ინტერფეისით, რომელსაც აქვს ფლეშ მეხსიერებიდან პროგრამების შესრულების უნარი. მოწყობილობა 2014 წელს გამოუშვა ჩინური კომპანია Espressif-ის მიერ და თითქმის მაშინვე გახდა პოპულარული.

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

• მხარს უჭერს Wi-Fi პროტოკოლებს 802.11 b/g/n WEP, WPA, WPA2;
• აქვს 14 შემავალი და გამომავალი პორტი, SPI, I2C, UART, 10 ბიტიანი ADC;
• მხარს უჭერს გარე მეხსიერებას 16 მბ-მდე;
• საჭირო კვების წყაროა 2.2-დან 3.6 ვ-მდე, მიმდინარე მოხმარება 300 mA-მდეა, არჩეული რეჟიმიდან გამომდინარე.

მნიშვნელოვანი მახასიათებელია მომხმარებლის არასტაბილური მეხსიერების არარსებობა ჩიპზე. პროგრამა შესრულებულია გარე SPI ROM-დან, პროგრამის საჭირო ელემენტების დინამიური დატვირთვის გამოყენებით. შიდა პერიფერიულ მოწყობილობებზე წვდომა შესაძლებელია არა დოკუმენტაციის, არამედ ბიბლიოთეკების ნაკრების API-დან. მწარმოებელი მიუთითებს RAM-ის სავარაუდო რაოდენობაზე - 50 კბ.

ESP8266 დაფის მახასიათებლები:

• მოსახერხებელი კავშირი კომპიუტერთან - USB კაბელის საშუალებით, რომელიც იკვებება მასზე;
• ჩაშენებული 3.3 ვ ძაბვის გადამყვანის არსებობა;
• 4 მბ ფლეშ მეხსიერების არსებობა;
• ჩაშენებული ღილაკები გადატვირთვისა და ციმციმისთვის;
• ყველა პორტი გადაყვანილია დაფაზე ორი სავარცხლის გამოყენებით 2,5 მმ სიგრძით.

ESP8266 მოდულის გამოყენების სფეროები

• ავტომატიზაცია;
• სხვადასხვა სისტემები ჭკვიანი სახლისთვის: უსადენო კონტროლი, უკაბელო სოკეტები, ტემპერატურის კონტროლი, სიგნალიზაციის სისტემების დამატება;
• მობილური ელექტრონიკა;
• ტეგის ID;
• საბავშვო სათამაშოები;
• ბადის ქსელები.

esp8266 pinout

ESP8266 მოდულის უამრავი სახეობაა. ფიგურაში ნაჩვენებია ზოგიერთი მათგანი. ყველაზე პოპულარული ვარიანტია ESP 01.

პროგრამის შესრულება უნდა განისაზღვროს GPIO0, GPIO2 და GPIO15 პორტების მდგომარეობით, როდესაც ელექტრომომარაგება დასრულდება. შეიძლება განვასხვავოთ ორი მნიშვნელოვანი რეჟიმი - როდესაც კოდი შესრულებულია UART-დან (GPIO0 = 0, GPIO2 = 1 და GPIO15 = 0) ფლეშ ბარათის გასანათებლად და როდესაც ის შესრულებულია გარე ROM-დან (GPIO0 = 1, GPIO2 = 1. და GPIO15 = 0) სტანდარტულ რეჟიმში.

ESP01-ის პინი ნაჩვენებია სურათზე.

საკონტაქტო აღწერა:

• 1 – მიწა, 8 – სიმძლავრე. დოკუმენტაციის მიხედვით, ძაბვა მიეწოდება 3.6 ვ-მდე - ეს მნიშვნელოვანია გასათვალისწინებელი Arduino-სთან მუშაობისას, რომელიც ჩვეულებრივ მიეწოდება 5 ვ.
• 6 – RST, საჭიროა მიკროკონტროლერის გადატვირთვისთვის, როდესაც მასზე დაბალი ლოგიკური დონეა გამოყენებული.
• 4 – CP_PD, ასევე გამოიყენება მოწყობილობის ენერგიის დაზოგვის რეჟიმში დასაყენებლად.
• 7 და 0 – RXD0 და TXD0, ეს არის აპარატურის UART, რომელიც საჭიროა მოდულის გასანათებლად.
• 2 – TXD0, ამ პინთან არის დაკავშირებული LED, რომელიც ანათებს, როდესაც GPIO1-ზე ლოგიკური დონე დაბალია და როდესაც მონაცემები გადაიცემა UART-ით.
• 5 – GPIO0, შემავალი და გამომავალი პორტი, ასევე საშუალებას გაძლევთ დააყენოთ მოწყობილობა პროგრამირების რეჟიმში (როდესაც პორტი დაკავშირებულია დაბალ ლოგიკურ დონეზე და გამოიყენება ძაბვა).
• 3 – GPIO2, შემავალი და გამომავალი პორტი.

ძირითადი განსხვავებები Arduino-სა და ESP8266-ს შორის

• ESP8266-ს აქვს უფრო დიდი რაოდენობით ფლეშ მეხსიერება, ხოლო ESP8266-ს არ აქვს არასტაბილური მეხსიერება;
• ESP8266 პროცესორი უფრო სწრაფია ვიდრე Arduino;
• ESP8266 აქვს Wi-Fi;
• ESP8266 მოიხმარს უფრო მეტ დენს ვიდრე Arduino;

ESP8266 პროგრამირება Arduino IDE-ში

esp8266 განვითარების ნაკრები მოიცავს:

• შემდგენელი GNU Compiler კოლექციიდან.
• ბიბლიოთეკები, WiFi, TCP/IP პროტოკოლის სტეკები.
• კონტროლერის პროგრამაში ინფორმაციის ჩატვირთვის საშუალება.
• ოპერაციული IDE.

თავდაპირველად, ESP8266 მოდულები მიეწოდება მწარმოებლის firmware-ს. მისი დახმარებით თქვენ შეგიძლიათ აკონტროლოთ მოდული გარე მიკროკონტროლერიდან და იმუშაოთ Wi-Fi-ით, როგორც მოდემი. ასევე არსებობს მრავალი სხვა მზა პროგრამული უზრუნველყოფა. ზოგიერთი მათგანი საშუალებას გაძლევთ დააკონფიგურიროთ მოდულის მოქმედება WEB ინტერფეისის გამოყენებით.

შეიძლება დაპროგრამდეს Arduino IDE-დან. მისი დახმარებით შეგიძლიათ მარტივად დაწეროთ ესკიზები და ატვირთოთ ისინი ESP8266-ზე, გამოანათოთ ESP8266 და არ დაგჭირდეთ თავად Arduino დაფა. Arduino IDE მხარს უჭერს ყველა სახის ESP8266 მოდულს.

ამჟამად, შემდეგი ფუნქციები შეიძლება განხორციელდეს ESP8266-ისთვის:

• Wiring ენის ძირითადი ფუნქციები. თქვენ შეგიძლიათ მართოთ GPIO პორტები ისევე, როგორც პინები Arduino დაფაზე: pinMode, digitalRead, digitalWrite, analogWrite. analogRead(A0) ბრძანება საშუალებას გაძლევთ წაიკითხოთ ADC მნიშვნელობები. analogWrite (pin, value) ბრძანების გამოყენებით, შეგიძლიათ PWM დაუკავშიროთ სასურველ GPIO გამომავალს. როდესაც მნიშვნელობა=0, PWM გამორთულია, მაქსიმალური მნიშვნელობა აღწევს 1023-ის ტოლ მუდმივობას. attachInterrupt და detachInterrupt ფუნქციების გამოყენებით, შეგიძლიათ შეწყვიტოთ ნებისმიერ GPIO პორტზე 16-ის გარდა.
• დრო და შეფერხება. millis და micros ბრძანებების გამოყენებით შეგიძლიათ დააბრუნოთ ms და μs, რომლებიც გავიდა დაწყებიდან. დაყოვნება საშუალებას გაძლევთ შეაჩეროთ პროგრამის შესრულება სასურველი დროით. ასევე, დაყოვნების (…) ფუნქცია საშუალებას გაძლევთ შეინარჩუნოთ ნორმალური Wi-Fi მუშაობა, თუ ესკიზი შეიცავს დიდ ელემენტებს, რომელთა შესრულებას 50 ms-ზე მეტი სჭირდება. Yield() არის delay(0) ფუნქციის ანალოგი.
• Serial და Serial1 (UART0 და UART1). ESP8266-ზე სერიული მუშაობა Arduino-ზე მუშაობის მსგავსია. მონაცემთა ჩაწერა და კითხვა ბლოკავს კოდის შესრულებას, თუ 128-ბაიტიანი FIFO და 256-ბაიტიანი პროგრამული უზრუნველყოფის ბუფერი სავსეა. სერიული ობიექტი იყენებს აპარატურას UART0, შეგიძლიათ დააყენოთ ქინძისთავები GPIO15 (TX) და GPIO13 (RX) GPIO1(TX) და GPIO3(RX) ნაცვლად. ამისათვის Serial.begin(); თქვენ უნდა დარეკოთ Serial.swap();. ანალოგიურად, Serial1 იყენებს UART1, რომელიც მუშაობს გადაცემისთვის. ამისათვის საჭირო პინი არის GPIO2.
• მაკრო PROGMEM. მისი მოქმედება ჰგავს Arduino-ს. საშუალებას გაძლევთ გადაიტანოთ მხოლოდ წაკითხული მონაცემები და სიმებიანი მუდმივები ფლეშ მეხსიერებაში. ამავდროულად, ESP8266 არ ინახავს იგივე მუდმივებს, რაც იწვევს ფლეშ მეხსიერების დამატებით ხარჯვას.
• I2C. I2C ავტობუსთან მუშაობამდე ავტობუსები შეირჩევა Wire.pins(int sda, int scl) ფუნქციის გამოყენებით.
• SPI, OneWire – სრულად მხარდაჭერილი.

გამოიყენეთ esp8266 Arduino-სთან WiFi-ით კომუნიკაციისთვის

Arduino-სთან დაკავშირებამდე მნიშვნელოვანია გვახსოვდეს, რომ ESP8266-ის მიწოდების ძაბვა არ შეიძლება იყოს 3.6-ზე მაღალი, ხოლო Arduino-ზე ძაბვა არის 5 ვ. თქვენ უნდა დააკავშიროთ 2 მიკროკონტროლერი რეზისტენტული გამყოფების გამოყენებით. მოდულის დაკავშირებამდე, თქვენ უნდა გაეცნოთ არჩეული ESP8266-ის პინუტს. ESP8266-01-ის კავშირის დიაგრამა ნაჩვენებია ფიგურაში.

3.3 ვ Arduino-დან Vcc&CH_PD-მდე ESP8266 მოდულზე, დამიწება Arduino-დან მიწამდე ESP8266-დან, 0 – TX, 1 – RX.

სტაბილური მუშაობის შესანარჩუნებლად, ESP8266 მოითხოვს 3.3 ვ მუდმივი ძაბვის წყაროს და მაქსიმალური დენი 250 mA. თუ ელექტროენერგია მოდის USB-TTL კონვერტორიდან, შეიძლება მოხდეს გაუმართაობა და გაუმართაობა.

ESP8266-ისთვის Wi-Fi ბიბლიოთეკასთან მუშაობა ჩვეულებრივი ფარის ბიბლიოთეკის მსგავსია. არსებობს რამდენიმე მახასიათებელი:

• mode(m) – სამი რეჟიმიდან ერთის ასარჩევად: კლიენტი, წვდომის წერტილი ან ორივე რეჟიმი ერთდროულად.
• softAP(ssid) – საჭიროა ღია წვდომის წერტილის შესაქმნელად.
• softAP(ssid, პაროლი) – ქმნის წვდომის წერტილს პაროლით, რომელიც უნდა შედგებოდეს მინიმუმ 8 სიმბოლოსგან.
• WiFi.macAddress(mac) და WiFi.softAPmacAddress(mac) – განსაზღვრავს MAC მისამართს.
• WiFi.localIP() და WiFi.softAPIP() – IP მისამართის განსაზღვრა.
• printDiag (სერიული); – საშუალებას მოგცემთ გაიგოთ დიაგნოსტიკური მონაცემები.
• WiFiUDP – კლიენტის რეჟიმში მულტიკასტის პაკეტების გაგზავნისა და მიღების მხარდაჭერა.

სამუშაო შესრულებულია შემდეგი ალგორითმის მიხედვით:

• USB-TTL USB-თან და ESP-თან დაკავშირება.
• გაშვება Arduino IDE.
• ინსტრუმენტების მენიუში აირჩიეთ საჭირო პორტი, დაფა, სიხშირე და ფლეშ მეხსიერების ზომა.
• ფაილი - მაგალითები - ESP8266WiFi - WiFiWebServer.
• ჩაწერეთ ესკიზზე Wi-Fi ქსელის SSID და პაროლი.
• დაიწყეთ კოდის შედგენა და ატვირთვა.
• დაელოდეთ firmware პროცესის დასრულებას, გათიშეთ GPIO0 მიწიდან.
• დააყენეთ სიჩქარე 115200-ზე.
• მოხდება კავშირი და IP მისამართი ჩაიწერება.
• გახსენით ბრაუზერი, შეიყვანეთ IP/gpio/1 ნომერი მისამართების ზოლში
• შეხედეთ პორტის მონიტორს; თუ LED არის დაკავშირებული GPIO2 გამომავალთან, ის უნდა აანთოს.

NodeMCU დაფუძნებული esp8266-ზე

NodeMCU არის პლატფორმა, რომელიც დაფუძნებულია esp8266 მოდულზე. გამოიყენება მიკროსქემის დისტანციურად გასაკონტროლებლად ინტერნეტის გამოყენებით Wi-Fi-ის საშუალებით. დაფა არის მცირე ზომის, კომპაქტური, იაფი და აქვს USB კონექტორი წინა მხარეს. ახლოს არის ღილაკები მიკროკონტროლერის გამართვისა და გადატვირთვისთვის. ასევე დამონტაჟებულია ESP8266 ჩიპი. მიწოდების ძაბვა არის 5-დან 12 ვ-მდე, მიზანშეწონილია მიწოდება 10 ვ-ზე მეტი.

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

• D1 და D2 - I2C/ TWI ინტერფეისისთვის;
• D5-D8 - SPI ინტერფეისისთვის;
• D9, D10 – UART-ისთვის;
• D1-D10 – შეუძლია იმუშაოს როგორც PWM.

პლატფორმას აქვს თანამედროვე API ტექნიკის შეყვანისა და გამოსვლისთვის. ეს საშუალებას გაძლევთ შეამციროთ ნაბიჯების რაოდენობა მოწყობილობასთან მუშაობისას და მისი დაყენებისას. NodeMCU firmware-ის დახმარებით თქვენ შეგიძლიათ გამოიყენოთ სრული ოპერაციული პოტენციალი მოწყობილობის სწრაფი განვითარებისთვის.

WeMos დაფუძნებული esp8266-ზე

WeMos არის სხვა ტიპის პლატფორმა, რომელიც დაფუძნებულია esp8266 მიკროკონტროლერზე. შესაბამისად, არის Wi-Fi მოდული, მხარდაჭერილია Arduino IDE და არის კონექტორი გარე ანტენისთვის. დაფას აქვს 11 ციფრული შეყვანა/გამომავალი, რომელიც (გარდა D0-ისა) მხარს უჭერს შეწყვეტას/pwm/I2C/ერთ მავთულს. მიწოდების მაქსიმალური ძაბვა აღწევს 3.3 ვ. ასევე არის USB კონექტორი პლატფორმაზე. ანალოგური შეყვანა 1 მაქსიმალური ძაბვით 3.2 ვ.

მოდულთან მუშაობისთვის, თქვენ უნდა დააინსტალიროთ CH340 დრაივერი და დააკონფიგურიროთ Arduino IDE ESP8266-ისთვის. ამისათვის თქვენ უნდა დაამატოთ მისამართი http://arduino.esp8266.com/stable/package_esp8266com_index.json პარამეტრების მენიუში "დამატებითი ბმული დაფის მენეჯერისთვის".

ამის შემდეგ, თქვენ უნდა იპოვოთ esp8266 by ESP8266 პაკეტი და დააინსტალიროთ იგი. შემდეგ ინსტრუმენტების მენიუდან უნდა აირჩიოთ Wemos D1 R2 მიკროკონტროლერი და ჩაწეროთ სასურველი ესკიზი.

დასკვნები ESP8266-ზე

ESP8266 ჩიპზე დაფუძნებული დაფებით, შეგიძლიათ დაამატოთ დიდი ინტერნეტ შესაძლებლობები თქვენს პროექტებს, რაც მათ ბევრად უფრო ინტელექტუალურს გახდის. დისტანციური მართვა, მონაცემთა შეგროვება და ანალიზი სერვერზე, ხმის დამუშავება და გამოსახულების დამუშავება - ეს ყველაფერი ხელმისაწვდომი ხდება მაშინ, როცა ჩვენს პროექტს WiFi-ის საშუალებით ვუკავშირდებით ინტერნეტს. შემდეგ სტატიებში ჩვენ უფრო დეტალურად განვიხილავთ, თუ როგორ შეგიძლიათ დაპროგრამოთ esp8266-ზე დაფუძნებული მოწყობილობები, ასევე ყურადღება მიაქციოთ ისეთ პოპულარულ დაფებს, როგორიცაა WeMos და NodeMcu.

ნაწილი 1: ESP8266-ის მომზადება

რატომ ეს სტატია? ჰაბზე უკვე არის არაერთი სტატია ESP-ის სხვადასხვა კონფიგურაციებში გამოყენების შესახებ, მაგრამ რატომღაც დეტალების გარეშე, თუ როგორ არის ზუსტად ყველაფერი დაკავშირებული, ციმციმი და დაპროგრამებული. მაგალითად, "ავიღე ESP, ორი AA ბატარეა, DHT22, ჩავყარე ყუთში, ვაკანკალებდი ერთი საათის განმავლობაში და თერმომეტრი მზად არის!" შედეგად, უცნაური აღმოჩნდება: ისინი, ვინც უკვე მუშაობენ ESP-თან, ვერ ხედავენ რაიმე უჩვეულოს გაკეთებულში და ვისაც სწავლა სურს, არ ესმის საიდან დაიწყოს. ამიტომ, გადავწყვიტე დამეწერა დეტალური სტატია იმის შესახებ, თუ როგორ არის დაკავშირებული ESP და ციმციმები, როგორ დავაკავშირო ის Arduino-სთან და გარე სამყაროსთან და რა პრობლემები შემხვდა გზაზე. მე ვაძლევ ლინკებს Aliexpress-ზე მხოლოდ კომპონენტების ფასებისა და გარეგნობის შესახებ წარმოდგენის მიზნით.

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

კვება

მუშაობისთვის, ESP8266 მოითხოვს ძაბვას 3.3 ვ და დენი მინიმუმ 300 mA. სამწუხაროდ, Arduino Uno-ს არ შეუძლია უზრუნველყოს ასეთი დენი, ისევე როგორც USB-UART გადამყვანები (პროგრამატორები), როგორიცაა FT232RL, ვერ უზრუნველყოფენ მას - მათი ლიმიტი არის დაახლოებით 50 mA. ეს ნიშნავს, რომ მოგიწევთ ცალკე კერძების ორგანიზება. და უკეთესი იქნებოდა, თუ Arduino-მაც 3.3V-დან იმუშავა, რათა თავიდან აიცილოთ ისეთი პრობლემები, როგორიცაა: "მე მივაყენე ხუთ ვოლტიანი სიგნალი ESP მოდულის RX პინზე, რატომ აქვს დამწვარი პლასტმასის სუნი?"

არსებობს სამი გამოსავალი.

2. შეიძინეთ მზა მოდული ძაბვის რეგულატორით, რომელიც ამცირებს 5V-ს 3.3V-მდე. ალბათ ეს არის ყველაზე მოსახერხებელი ვარიანტი.

3. მოდული თავად შეაგროვეთ AMS1117 რეგულატორიდან და ერთი 22 μF ტანტალის კონდენსატორიდან.

მე ავირჩიე მესამე ვარიანტი, რადგან ხშირად მჭირდება 3.3 ვ, ხარბი ვარ და მომწონს რეგულატორების ჩაშენება პირდაპირ დენის წყაროებში.

AMS1117-ით ყველაფერი მარტივია: თუ მას ტექსტთან ერთად აყენებთ, მაშინ ფეხებზე ძაბვა იზრდება მარცხნიდან მარჯვნივ: 0 (Gnd), 3.3V (Vout), 5V (Vin).
ნულსა და გამომავალს შორის გჭირდებათ 22 μF ტანტალის კონდენსატორი (ინსტრუქციის მიხედვით, რა მოხდება, თუ ელექტროლიტურს დააინსტალირებთ - არ მაქვს გადამოწმებული). ტანტალის SMD კონდენსატორს აქვს პლუსი, სადაც არის ზოლები. SMD კომპონენტების პატარა ამაზრზენი შედუღება სრულიად არ არის განკუთვნილი ასეთი ბარბაროსობისთვის და:

დარწმუნდით, რომ შეამოწმეთ გამომავალი ძაბვა. თუ ის საგრძნობლად ნაკლებია 3,3 ვ-ზე (მაგალითად, 1,17 ვ) - შედუღების შემდეგ რეგულატორი გაცივდეს და შეამოწმეთ კონტაქტები. თუ თქვენ მოათავსებთ 22 μF-ზე დიდ კონდენსატორს, მულტიმეტრმა შეიძლება აჩვენოს უფრო მაღალი ძაბვა.

რატომ AMS1117? იგი ფართოდ გამოიყენება. თქვენ შეგიძლიათ იპოვოთ იგი თითქმის ყველგან, თუნდაც Arduino Uno-ში, ჩვეულებრივ AMS1117-5.0.
თუ იცით მსგავსი ზომების და ფასის, კიდევ უფრო ადვილი გამოსაყენებელი, დაწერეთ.

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

დაკავშირება ESP8266

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

იმისათვის, რომ ჩიპი დაიწყოს, თქვენ უნდა დააკავშიროთ VCC და CH_P 10 kOhm რეზისტორის საშუალებით. თუ ეს ასე არ არის, მაშინ 1-20 kOhm დიაპაზონიდან რომელიმე გამოდგება. გარდა ამისა, კონკრეტულად 07 მოდელი ასევე მოითხოვს, რომ GPIO15 (GND-თან ყველაზე ახლოს) იყოს "დამიწებული" (ეს არ ჩანს სურათზე, რადგან კავშირი არის მეორე მხარეს).

ახლა ვიღებთ USB-UART ადაპტერს, გადავრთავთ 3.3 ვ-ზე და ვუერთებთ RX-ს TX-ს, TX-ს RX-ს და GND-ს მიწაზე (ჩემთვის გადაცემა ამის გარეშე არასტაბილურია). თუ არ შეგიძლიათ გადახვიდეთ 3.3 ვ-ზე, მაშინ შეგიძლიათ გამოიყენოთ მარტივი რეზისტორული ძაბვის გამყოფი: შეაერთეთ ESP RX TX ადაპტერთან 1 kOhm წინააღმდეგობით, ხოლო ESP RX მიწასთან 2 kOhm-ით. არსებობს მრავალი უფრო რთული და საიმედო გზა 3.3V და 5V-ის დასაკავშირებლად, მაგრამ ამ შემთხვევაში ეს გამოდგება.

და ჩვენ ვუკავშირდებით 9600 სიჩქარით საჭირო COM პორტის საშუალებით (შეგიძლიათ იხილოთ მოწყობილობის მენეჯერში).

მე ვიყენებ SecureCRT-ს, Putty-იც შესაფერისია და Linux-ის მცოდნეებმა უკვე იციან რა გააკეთონ და სად ეძებონ.

(AT+RST აღადგენს ჩიპს)

თუ არაფერი მოხდა - გამორთეთ - ჩართეთ დენი, თუ მაინც არაფერი მოხდა - შეამოწმეთ TX/RX შესატყვისი, სცადეთ მათი გადაწყობა ან ჩიპზე შედუღება.

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

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

ზოგჯერ COM პორტის ნომერი იცვლება. Linux-ზე ეს შეიძლება მოგვარდეს udev-ის გამოყენებით.

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

დასაწყისში, ჩიპი თბება, მაგრამ თუ ის ნამდვილად ცხელა და აგრძელებს გათბობას, გათიშეთ და შეამოწმეთ ყველა კავშირი. +3.3V რომ არ მივიდეს კეისამდე, რომ 5V არსად არ მოვიდეს, რომ ადაპტერის „დამიწება“ ჩიპის „მიწას“ დაუკავშირდეს. ლითონის ეკრანის მქონე მოდელები ძალიან ძნელად იწვება (მაგრამ შეუძლებელი არაფერია), ასევე არსებობს პრეტენზია ეკრანის გარეშე მოდელებზე და ამბობენ, რომ მცირე შეცდომაც კი შეიძლება იყოს ბოლო ჩიპის ცხოვრებაში. მაგრამ მე ეს არ შემიმოწმებია.

Firmware

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

ასევე დაგჭირდებათ NodeMCU flasher და LuaLoader (ეს უკანასკნელი არჩევითია; არსებობს სხვა კლიენტები ამ firmware-თან მუშაობისთვის).

გამორთეთ ჩიპი. ჩვენ ვუკავშირებთ GPIO0-ს მიწასთან და ჩართავთ ჩიპს:

თუ არაფერი მოხდა და AP MAC/STA MAC ველები ცარიელია, კვლავ შეამოწმეთ, რომ GPIO0 ადგილზეა.
თუ firmware დაიწყო, მაგრამ იყინება, გადახედეთ Log ჩანართს, რატომღაც ამ კონკრეტულმა ჩიპმა უარი თქვა FT232RL-ზე ციმციმზე, მაგრამ PL2303HX-ზე უპრობლემოდ ციმციმდა 576000 სიჩქარით. PL2303HX მითითებულ ვერსიაში. არ აქვს გადამრთველი 3.3V-ზე გამოსაყენებლად საჭიროა პლასტმასის კორპუსის გახსნა და მავთულის შედუღება 5V-დან 3.3V-მდე, არის ვარიანტები ხუთი გამომავალით: 3.3, 5, TX, RX, Gnd.

გთხოვთ გაითვალისწინოთ: STA MAC შეიცვალა. მეეჭვება, რომ ფლეშერმა არასწორად აჩვენა, მაგრამ გადამოწმებაა საჭირო.

ძალისხმევისა და ნერვების დაზოგვის მიზნით, შეგიძლიათ აიღოთ მზა ან ნახევრად მზა ვერსია.

არის ერთჯერადი გადამყვანები მოსახერხებელი გაყვანილობით.
ჭამე

ბევრი სხვა წვრილმანის მსგავსად, მე რეგულარულად ვიყენებ AVR მიკროკონტროლერებს სხვადასხვა ჰობის პროექტებისთვის. და Arduino-ს კონცეფციის წყალობით, ეს ხელნაკეთობები ახლა ასევე ელეგანტურ იერს იძენს. მართლაც, დაახლოებით 300-400 რუბლისთვის ვიღებთ მინიატურულ მრავალშრიან დაფას ნიღბით, აბრეშუმის ეკრანზე ბეჭდვით და მიკროკონტროლერისთვის მთლიანად განაწილებული პერიფერიებით (და SMD ვერსიაში!). მე არც კი ვსაუბრობ იგივე "Arduino" სერიის ყველა სახის დანამატის მოდულზე: სენსორებზე, კონტროლერებზე, დისპლეებზე და დამატებითი პერიფერიული მოწყობილობების მთელ კომპლექტზე, რაც ძალიან გვჭირდება. და ისევ, ყველაფერი ასევე იაფია და შესანიშნავი შესრულებით. მუხლზე რაიმეს განზავება და დალევა პრაქტიკულად აღარ არის საჭირო.

მაგრამ ყველა ეს სხვადასხვა სამოყვარულო ხელნაკეთობა ბუნებრივად მოითხოვს წინასწარი პროგრამირება.და შემდგომში, სხვადასხვა გაუმჯობესებით, ეს ხელნაკეთობები მუდმივად საჭიროა reflash. ნათელია, რომ უფრო მოსახერხებელია ამის გაკეთება დისტანციურად, ვიდრე მათი გამუდმებით მიტანა ჩვეულებრივ პროგრამისტთან. ზოგადად, იგივე Arduino პლატფორმის წყალობით, აქ ბევრი ვარიანტია: Bluetooth, ZigBee, რადიო არხი თქვენი პირადი პროტოკოლით, IR და თუნდაც Wi-Fi. ყველა მათგანი საშუალებას გაძლევთ დაამყაროთ უკაბელო კონტაქტი თქვენს მიკროკონტროლერთან. მაგრამ ჩვენ ყურადღებას გავამახვილებთ ბოლო ვარიანტზე. არსებობს ოთხი ძირითადი მიზეზი:

1: თანამედროვე, ნივთების ინტერნეტი!

2: ყველა ბინაში არის უკაბელო როუტერი, დაარეგისტრირეთ თქვენი მოწყობილობები სახლის ქსელში და ვოილაში!

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

4: არის ESP8266 ჩიპების შესანიშნავი სერია, რომელზედაც არც ისე ადვილია ამ ყველაფრის განხორციელება.

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

ვარაუდობენ, რომ მკითხველი უკვე იცნობს "Arduino" მოდულებს (ფარებს) და ESP8266-ის კავშირს და პროგრამულ უზრუნველყოფას. ფაქტობრივად, ინტერნეტში გამოქვეყნდა უამრავი მასალა, სადაც ახსნილია ამ მოწყობილობებთან მუშაობის საფუძვლები და არ მინდა აქ გავიმეორო. დამწყებთათვის, სტატიის ბოლოს მოცემულია ამ საკითხებზე სასარგებლო ბმულების სია, სადაც შეგიძლიათ იპოვოთ უამრავი ინფორმაცია იმის შესახებ, თუ რატომ არ მუშაობს ეს ყველაფერი თქვენთვის. ჩემი, როგორც ყოფილი ელექტრონიკის ინჟინრის გამოცდილებიდან, შემიძლია პასუხისმგებლობით განვაცხადო, რომ პრობლემების 99% შემდეგნაირად მთავრდება:

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

2. კვების პრობლემები. არ მიაწოდოთ 5 ვოლტი ენერგია, სადაც საჭიროა 3.3. ზოგჯერ ეს იწვევს ESP8266-დან კვამლის გამოსვლას. თუმცა, მეორე მხრივ, ის უპრობლემოდ ითვისებს ლოგიკურ სიგნალებს ხუთვოლტიანი მოწყობილობებიდან.

3. საკმარისი ელექტრომომარაგების პრობლემები. ESP8266-ს ეშმაკური ხასიათი აქვს და ზოგჯერ შეუძლია მოიხმაროს თითქმის სამასი მილიამპერი, თუმცა მანამდე ის ოცდაათით დაკმაყოფილდებოდა. შესაბამისად, Arduino დაფის სუსტი 3.3 ვოლტიანი სტაბილიზატორი, რომელსაც თქვენ უყოყმანოდ დაუკავშირეთ, მაშინვე ეცემა მიკროსკოპულ მნიშვნელობებამდე. და ვერ ხვდები, რატომ მუშაობს ხანდახან, ხან არა.

4. დაბნეულობა დასკვნებთან. ყოველთვის შეამოწმეთ რომელი სიგნალები სად მიდის. RXD მიმღები უნდა დაუკავშირდეს TXD გადამცემს, ასევე TXD RXD-ს, მაგრამ MOSI უნდა დაუკავშირდეს MOSI-ს, MISO კი MISO-ს და ა.შ.

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

6. პროგრამული პრობლემები. ვინაიდან ცალკეული მომხმარებლებისთვის პროგრამული უზრუნველყოფა იწერება ერთიდაიგივე ენთუზიასტების მიერ, თავად firmware-ში არსებული ხარვეზები და შეცდომები პერიოდულად ჩნდება იმავე პროგრამული უზრუნველყოფის ვერსიების განახლებისას. მას მკურნალობენ შესაბამისი ფორუმების, ზოგჯერ ინგლისურენოვანი ფორუმების სეირნობით. ზოგიერთი ამხანაგიც კი ამტკიცებდა, რომ ESP ჩიპი თავისთავად ისეთივე ნესტიანია, როგორც ამინდი სანკტ-პეტერბურგში, მაგრამ, მეორეს მხრივ, ასევე არსებობს მოსაზრება, რომ 2014 წლიდან (მისი პირველი გამოშვების წელი) სიტუაცია მკვეთრად გაუმჯობესდა ( ამინდისგან განსხვავებით).

7. იდუმალი ხარვეზები. ეს იშვიათი, მაგრამ ნერვების მომშლელი ფენომენია. მაგალითად, ერთი "არდუინოს" მოწყობილობა დისტანციურად ვერ შევკერე. უფრო სწორად, მუშაობდა, მაგრამ შეცდომებით. მაგრამ ის მუშაობდა შეცდომების გარეშე, თუ პროგრამისტის კაბელი ეკიდა მასზე (მაგრამ თავად პროგრამისტის გარეშე). „აჰა“, ვუთხარი ჩემს თავს და დავადე 15 pF კონდენსატორი მონაცემთა პინსა და საათის პინს შორის. ყველაფერი მუშაობდა. მაგრამ დღე მოკლა.

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


კონტროლერისთვის ავიღოთ ლამაზი მინიატურული Arduino Nano დაფა ATmega328P ქვით. ეს დაფა კარგად ჯდება მექანიკურ მკლავში.


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

უმარტივესი ვარიანტი, რა თქმა უნდა, ჩაშენებული ჩამტვირთველია. ეს არის FLASH-ში წინასწარ რეგისტრირებული მეხსიერება, პროგრამა, რომელიც იღებს კოდს გარკვეული პროტოკოლის გამოყენებით (მაგალითად, უმარტივესი UART-ის გამოყენებით) და იყენებს სპეციალურ ბრძანებებს მის ჩასაწერად ჩატვირთული პროგრამის ადგილას. ასე მუშაობს, მაგალითად, თავად ARDUINO IDE ჩამტვირთველი. გადატვირთვის ან დაწყების შემდეგ, ჩამტვირთველი ელოდება გარკვეული დროის განმავლობაში მონაცემების მიღებას და თუ არ დაელოდება, იწყებს პროგრამის შესრულებას ნულოვანი მისამართიდან. თუ მონაცემები მოდის, ის წერს პროგრამის განყოფილებაში. შემდეგი გადატვირთვის შემდეგ, დატვირთული პროგრამა იწყებს შესრულებას. შეიძლება დეტალურად არაზუსტად აღვწერე, მაგრამ ეს არის მისი არსი. შედეგად, ჩვენ გვჭირდება მხოლოდ სამი პინი პროგრამირებისთვის: RTD მიმღები, RESET და GND. ზოგადად, TRD გადამცემი ასევე გამოიყენება ჩაწერილი პროგრამის შესამოწმებლად, მაგრამ მარტივი საჩვენებელი აპლიკაციებისთვის (არა ატომური ელექტროსადგურისთვის), შემოწმება შეიძლება გამოტოვდეს.

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

მეორე ვარიანტი არის პროგრამირება SPI სერიული ინტერფეისით. აქ შიდა ჩამტვირთველი არ არის და ჩვენ პროგრამირებას ვაგზავნით სპეციალური ბრძანებების და შემდეგ მონაცემების ზემოაღნიშნული ინტერფეისის საშუალებით. აქ უკვე გვაქვს გარე ჩამტვირთველი, მაგრამ მაინც უნდა დავწეროთ. გადაცემის დროს, გარდა RESET-ისა და GND-ისა, გამოიყენება ოთხი დამატებითი პინი: MOSI, MISO - მონაცემები, SLK სინქრონიზაცია, CS - კრისტალების შერჩევა. მაგრამ ზოგადად თქვენ ასევე შეგიძლიათ წაშალოთ MISO და CS. მონაცემები მხოლოდ მიიღება (მაშინ არ იქნება პროგრამის გადამოწმება) და ჩვენ უკვე გვაქვს მხოლოდ ერთი კრისტალი.

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

უკაბელო არხის ასაშენებლად, როგორც უკვე აღვნიშნეთ, მე ავირჩიე ამჟამად ძალიან ფართოდ ცნობილი ESP8266 ჩიპი - მიკროკონტროლერი, უფრო სწორად, მთელი SoC (System-on-Chip) ჩინური მწარმოებლის Espressif-ისგან Wi-Fi ინტერფეისით. გარდა Wi-Fi-ისა, გამოირჩევა გარე ფლეშ მეხსიერებიდან პროგრამების შესრულების შესაძლებლობით. კონკრეტულად ჩემი პროექტისთვის ავიღე ESP8266-07 ბორტზე 512 KB მეხსიერებით.

ზოგადად, ნებისმიერი ESP8266 შესაფერისია, სადაც არის დამატებითი ფეხები SPI-ს განსახორციელებლად. ამიტომ, უმარტივესი ESP8266-01 არ მოგვწონს, რადგან მას აქვს ძალიან ცოტა ქინძისთავები I/O პორტებისთვის. მაგრამ მეორეს მხრივ, მათ შორის ფასში სხვაობა ას რუბლზე ნაკლებია და ისინი თანაბრად ხელმისაწვდომია. ისე, დიდი გამართვის დაფები ESP-ით, სადაც პერიფერიული მოწყობილობების თაიგული გამოყოფილია მოხერხებულობისთვის, ასევე არ არის შესაფერისი ჩვენთვის, რადგან ისინი არ ჯდება იქ, სადაც ჩვენ გვინდა, რომ ჩავრთოთ ისინი, ჩვენს მექანიკურ ხელში.

ზოგადად იდეის გლობალური არსი შემდეგი იყო. მიკროკონტროლერში ჩატვირთული პროგრამის კორპუსი გადადის კომპიუტერიდან ESP-ზე უსადენოდ WI-FI-ით (თქვენი სახლის ქსელის ფარგლებში). და ESP უკვე წერს ამ პროგრამას სადენზე SPI ინტერფეისის გამოყენებით პირდაპირ მიკროკონტროლერის FLASH მეხსიერებაში. შემდეგ ის ბუნებრივად აღადგენს მას და საშუალებას აძლევს დატვირთულ პროგრამას შეასრულოს. გარდა ამისა, ESP-ს უნდა ჰქონდეს დამოუკიდებელი ბლოკი, რომელიც ასევე მართავს მონაცემთა გაცვლას მიკროკონტროლერთან, ვინაიდან ჩვენ გვინდა არა მხოლოდ დაპროგრამება, არამედ მონაცემების გაცვლაც. განსაკუთრებით MechArm პროექტისთვის, პროგრამის ჩაწერის შემდეგ, ჩვენ ასევე გადავცემთ საკონტროლო სიგნალებს სერვოებს, რათა ეს მკლავი მოძრაობდეს. ამიტომ, თავად ESP-ზე მიზანშეწონილია დავაყენოთ TCP სერვერი პროგრამის გადასატანად და UDP სერვერი MechArm-ის სამართავად. შესაბამისად, ეს სერვერები უერთდებიან სახლის ქსელს და ყურადღებით უსმენენ, არის თუ არა იქ ვინმე, ვისაც სურს ახალი კოდის ატვირთვა MechaArm-ში ან ვინმესთვის გადაცემა.

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

რა პროგრამულ უზრუნველყოფას გამოვიყენებთ:

კომპიუტერისთვის ყველაფერი დავწერე JAVA, IntelliJ IDEA გარემოში. მაგრამ პრინციპში, თქვენ შეგიძლიათ გამოიყენოთ ნებისმიერი რამ, ჩვენთვის მთავარია დავწეროთ კლიენტი, რომელიც გამოგიგზავნით პროგრამას AVR-ის გამორთვისთვის ESP8266-ზე.

AVR-ს პროგრამებს ვწერ ATMEL STUDIO-ში, C-ზე, იშვიათად ასამბლერში. მე არ ვიყენებ Arduino-ს ესკიზებს პრინციპულად; თითქმის ნებისმიერი საჭირო ბიბლიოთეკა შეიძლება დაიწეროს დაახლოებით ერთ საათში და მისი მუშაობის სრული გაგებით. მე ვცადე ესკიზები, მაგრამ სანამ არ გაქვთ ოპერაციული სისტემა AVR-ზე, ესკიზები წაართმევს თქვენს მეგობარს პერიფერიულ მოწყობილობებს და რეგულარულად შეფერხდება. დიახ, თავად Arduino IDE, ATMEL STUDIO-სთან შედარებით, რა თქმა უნდა ძალიან პრიმიტიული რამ არის. მაგრამ აქ კითხვა, რა თქმა უნდა, საკამათოა: ჰუმანიტარულ მეცნიერებათა სტუდენტებსა და სკოლის მოსწავლეებს, ალბათ, ესკიზებით უფრო მხიარული და ადვილი იქნება.

ESP8266-ის დასაპროგრამებლად გამოვიყენე NodeMCU firmware და პროგრამები დავწერე Lua-ში. არა, მე მინდა დავწერო Java და C, მაგრამ ისინი არ არის ხელმისაწვდომი ESP-ზე. ლუა არ არის ძნელი გამოსაყენებელი ენა ჩვენი ამოცანის შესასრულებლად, მისი დაუფლება ნამცხვარია. და რეალურად პროგრამების გადმოსაწერად და ESP-ზე მათი გამართვისთვის, მე ავიღე IDE ESPlorer. საშინაო უფასო პროდუქტი (თუმცა შეგიძლიათ შეწიროთ ავტორს), რომელიც, რა თქმა უნდა, ვერ შეედრება ზემოხსენებულ გარემოს, მაგრამ როგორც ამბობენ საჩუქარ ცხენს... მაგრამ იმისათვის, რომ გამოიყენოთ ESPlorer და დაწეროთ LUA-ში, ჩვენ ჯერ უნდა შევცვალოთ ძირითადი პროგრამული უზრუნველყოფა ESP8266 ჩიპში (მოწოდებული მწარმოებლისგან) ახალზე. NODE MCU PyFlasher პროგრამა დაგვეხმარება ამ საქმეში. ვგულისხმობ, ეს ხელს შეუწყობს მის განახლებას. ჩვენ თვითონ შევქმნით firmware-ს და მივიღებთ მას შემქმნელების ვებსაიტზე: NodeMCU. და მეტი შეგიძლიათ წაიკითხოთ ამ პროცესის შესახებ

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

რა თქმა უნდა, შეგიძლიათ უბრალოდ აიღოთ მზა firmware, რომელთაგან უკვე ბევრია ინტერნეტში, მაგრამ მე ამას არ გირჩევთ. თუ მხოლოდ იმიტომ, რომ ზოგიერთს არ აქვს ბიტის ოპერაციების მხარდაჭერა (და ჩვენ გვჭირდება ისინი) და არ აკონტროლებს მონაცემთა გადაცემის სიჩქარეს SPI-ის საშუალებით.
შესაბამისად, ისინი გადაცემულია ნაგულისხმევად 40 MHz სიჩქარით, გაყოფილი მცირე კოეფიციენტზე და, შესაბამისად, AVR-ს არ აქვს დრო მათი გადამუშავებისთვის.

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

ახლა ჩვენ გვაქვს firmware და ჩვენ უნდა ჩავტვირთოთ ის ESP8266-ში ბაზის ნაცვლად. ამისთვის ჩვენ გვჭირდება მარტივი USB - UART ადაპტერი.

ჩვენ ვუკავშირებთ ფეხებს TXD-ს RXD-ს, ხოლო RXD-ს TXD-ს, ვაკეთებთ საერთო ნიადაგს, მაგრამ არ გამოვიყენოთ, როგორც ჩანდა, მოსახერხებელი 3.3 ვ დენის გამომავალი ადაპტერზე. უმეტეს შემთხვევაში, ESP8266 მთლიანად ამოწურავს მას. ამიტომ, ჩვენ მას ცალ-ცალკე ვკვებავთ. შემდეგ ESP-ს გადავრთავთ პროგრამირების რეჟიმში (GP0 მიწაზე, თუ ვინმეს დაავიწყდა) და გავუშვით NODE MCU PyFlasher.

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

საჭირო პროგრამული უზრუნველყოფის შეძენის შემდეგ, ჩვენ ახლა შეგვიძლია დავწეროთ და გავმართოთ პროგრამები LUA ენაზე (ასევე არის MicroPython, მაგრამ მე არ გამომიყენებია) NODE MCU-ის ძალიან მოსახერხებელი API-ების გამოყენებით. ჩვენ გავუშვით ადრე ნახსენები ESPlorer.

ჩვენ ასევე ვაკონფიგურირებთ ESP8266-თან მუშაობისთვის და ვაყენებთ სერიული კავშირის პარამეტრებს. ყველაფერი საკმაოდ მარტივია და ბევრჯერ არის აღწერილი ინტერნეტში.

ახლა ჩვენ ვწერთ პროგრამას LUA-ში, რომელსაც შემდეგ ჩავტვირთავთ ESP8266-ში:

Lua ჩამტვირთველი AVR-სთვის დაწერილი ESP8266-ზე

ფუნქცია InstrProgrammingEnable () -- ინსტრუქცია MC-სთვის "პროგრამირების ჩართვა" p=0 ხოლო p<31 do p=p+1 pin=8 gpio.write(pin, gpio.LOW) spi.send(1, 0xAC,0x53) read = spi.recv(1, 8) spi.send(1,0,0) gpio.write(pin, gpio.HIGH) if (string.byte(read)== 83) then print("connection established") p=33 if(p==31) then print("no connection") end end end end ფუნქცია ProgrammingDisable() pin=2--ESET-ის ბოლო FOR MK gpio.mode(pin, gpio.INPUT) pin=8 gpio.mode(pin, gpio.INPUT) pin=5--CLK MASTER for SPI gpio.mode(pin, gpio. INPUT) pin=6--MISO MASTER SPI-სთვის gpio.mode(pin, gpio.INPUT) pin=7--MOSI MASTER SPI-სთვის gpio.mode(pin, gpio.INPUT) დასასრული ფუნქცია ProgrammingEnable() pin=2-- RESET FOR MK gpio.mode(pin, gpio.OUTPUT) gpio.write(pin, gpio.LOW) pin=2--POZITIV FOR 4MSEC RESET FOR MK gpio.mode(pin, gpio.OUTPUT) gpio .write(pin, gpio.HIGH) tmr.delay(4) gpio.mode(pin, gpio.OUTPUT) gpio.write(pin, gpio.LOW) tmr.delay(25000) დასასრული ფუნქცია InstrFlashErase() pin=8 gpio.write(pin, gpio.LOW) spi.send(1,0xAC,0x80,0,0) gpio.write(pin, gpio.HIGH) tmr.delay(15000) pin=2--reset FOR MK gpio.mode(pin, gpio.OUTPUT) gpio.write(pin, gpio.HIGH) tmr.delay(20000) gpio.write(pin, gpio.LOW) print("FLASH წაშლილია") InstrProgrammingEnable () დასასრული ფუნქცია InstrStorePAGE (H, მისამართი, მონაცემები) pin=8 gpio.write(pin, gpio.LOW) spi.send(1,H,0,address,data) gpio.write(pin, gpio.HIGH) tmr.delay(500) დასასრული ფუნქცია InstrWriteFLASH (გვერდი_მისამართი_დაბალი, გვერდი_მისამართი_მაღალი) pin=8 gpio.write(pin, gpio.LOW) spi.send(1.0x4C,page_address_high,page_address_low,0) gpio.write(pin, gpio.HIGH) tmr.delay(5000)-- ზოგჯერ ფლეშ არ არის რეგისტრირებული, როდესაც დაბალი ლატენტური დასასრული ფუნქციის პროგრამირება (სასარგებლო დატვირთვა) pin=8--CS MASTER SPI-სთვის gpio.mode(pin, gpio.OUTPUT, gpio.PULLUP) pin=4--LED ნათურები ჩართულია დაბალ gpio.mode(pin, gpio.OUTPUT) gpio.write(pin, gpio. LOW) print(string.len(payload)) page_count = 7 -- ჩაწერეთ 1 კილობაიტი k =0 ,page_count ,1 do--გვერდების რაოდენობა i=0 , 127, 2 do-- -1 მისამართი = i/ 2 data=payload:byte(i+1+128*k) თუ მონაცემები == nil მაშინ data = 0xff end InstrStorePAGE(0x40,მისამართი,მონაცემები) -- tmr.delay(100)-- წინააღმდეგ შემთხვევაში დროულად არ ჩაწერეთ მონაცემები = payload:ბაიტი(i+1+1+128*k) თუ მონაცემები == ნული, მაშინ მონაცემები = 0xff ბოლოს InstrStorePAGE(0x48,მისამართი,მონაცემები) -- tmr.delay(100) ბოლოს page_address_low=bit.band(k ,3 )*64 -- 3 არის ორობითი 11 page_address_high=k/4+frame1024*2 tmr.delay(1000) InstrWriteFLASH(page_address_low,page_address_high) tmr.wdclr() ბოლოს pin=4--LED gpio.mode.(pin, gpio. OUTPUT) gpio.write(pin, gpio.HIGH) დასასრული --მთავარი ბლოკი wifi.setmode(wifi.STATION) --wifi.sta.config("ქსელის სახელი","პაროლი") -- დააყენეთ თქვენი წვდომის წერტილის SSID და პაროლი station_cfg=() tmr.delay(30000) station_cfg.ssid=" ქსელის სახელი" tmr.delay(30000) station_cfg.pwd="პაროლი" tmr.delay(30000) wifi.sta.config(station_cfg) tmr.delay(30000) wifi.sta.connect() tmr.delay(1000000) ბეჭდვა (wifi.sta.status()) print(wifi.sta.getip()) ხოლო (wifi.sta.status()~=1) გააკეთე if(wifi.sta.status()==5) შემდეგ შესვენება ბოლომდე sv=net.createServer(net.TCP,30) tmr.delay(100) print("SERVER READY") sv:listen(4000,function(c) c:on("receive", ფუნქცია(c, payload) ბეჭდვა (payload) if (payload =="program\r\n") then c:send("ready\r\n") print("ready for program\r\n") spi.setup(1, spi.MASTER , spi.CPOL_LOW, spi.CPHA_LOW, spi.DATABITS_8,320,spi.FULLDUPLEX) ProgrammingEnable () tmr.delay(100) InstrProgrammingEnable () tmr.delay(100) InstrFlashErase() tmr-10.delay -გადაცემული ფრეიმების რაოდენობა st=net.createServer(net.TCP,30) st:listen(4001,ფუნქცია(c) c:on("receive", ფუნქცია(c, payload) tmr.wdclr() პროგრამირება (payload ) frame1024=frame1024+1 end) end) end if (payload =="data\r\n") შემდეგ c:send("ready\r\n") print("ready for data\r\n") srv = net.createServer(net.UDP) tmr.delay(1000) pin=10 gpio.write(pin, gpio.HIGH) uart.setup(0,9600,8,0,1,0) srv:listen(5000) srv :on("receive", ფუნქცია(srv, pl) pl=pl*1 --print(pl) uart.write(0,pl) tmr.wdclr() end) end if (payload =="stop\r \ n") შემდეგ if(st~=nil) შემდეგ st:close() frame1024=0 ProgrammingDisable () print("stop program") დასასრული if(srv~=nil) შემდეგ srv:close() print("stop data" ") დასასრული ბოლოს დასასრული) დასასრული) დასასრული)

სადაც შესაბამისი ფუნქციები აკეთებენ შემდეგს:

ფუნქცია InstrProgrammingEnable()– აყენებს მიკროკონტროლერს პროგრამირების რეჟიმში SPI-ით გაგზავნილი სპეციალური ბრძანებით.

ფუნქცია ProgrammingEnable()- უბრალოდ გადატვირთეთ AVR 25 ms-ით პროგრამირების დაწყებამდე

ფუნქცია ProgrammingDisable()– პროგრამირების დასრულების შემდეგ გადავიყვანთ SPI პინებს ESP8266-ში უმოქმედო მდგომარეობაში, რათა ხელი არ შეგვიშალონ მიკროკონტროლერზე კოდის შესრულებისას (იქ გამოყენების შემთხვევაში)

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

ფუნქცია InstrStorePAGE (H, მისამართი, მონაცემები)– ეს ბრძანება წერს პროგრამის ბაიტს მიკროკონტროლერის შიდა ბუფერში. მაგრამ ეს არ არის თავად ფლეშ ჩანაწერი, რადგან ფლეშ აქ იწერება გვერდი-გვერდ, თითოეული 128 ბაიტი.

ფუნქცია InstrWriteFLASH (გვერდი_მისამართი_დაბალი, გვერდი_მისამართი_მაღალი)– მაგრამ ეს არის ფლეშ ჩანაწერი და ამას დრო სჭირდება, ყურადღება მიაქციეთ დროის დაყოვნებას 5000 μs.

ფუნქციის პროგრამირება (სასარგებლო დატვირთვა)– ყველაზე დიდი და ყველაზე მნიშვნელოვანი ფუნქცია, რომელიც იყენებს ზემოთ მოცემულ ფუნქციებს. ის იღებს გადაცემულ პროგრამას 1024 ბაიტის ნაწილებად, ყოფს მათ ბაიტებად და აგენერირებს მისამართებს, შემდეგ აგზავნის მათ მიკროკონტროლერს შიდა ბუფერში და ყოველი 128 ბაიტის შემდეგ ის ინიციალიზებს ფლეშ ჩაწერას. შემდეგ ის იღებს მომდევნო კილობაიტ კოდს და იმეორებს ოპერაციას, ბუნებრივია, მისამართებში ოფსეტურით, რათა შემდგომში ჩაიწეროს და არა გადაწერა. თავიდან ვცადე მთელი პროგრამების გადატანა, მაგრამ როცა ESP8266 აჭარბებს 6 კილობაიტს, ხელმისაწვდომი მეხსიერება უბრალოდ ამოიწურება და ის იშლება. ერთი კილობაიტი აღმოჩნდა ყველაზე მოსახერხებელი ერთეული, რადგან ის ლამაზად იყოფა ნაწილებად და მოხერხებულად გადაიცემა TCP-ის საშუალებით (ჩვენ ჯერ კიდევ უნდა მივიღოთ იგი კომპიუტერიდან). უფრო დიდი ზომა ასევე არ არის საჭირო, TCP, როგორც მოგეხსენებათ, მიმდინარე ვერსიაში ზღუდავს გადაცემულ პაკეტს 1500 ბაიტამდე (მაგრამ რატომღაც მე გადამიგზავნეს 1440, როგორც ჩანს).

როგორც ჩანს, არაფერი რთული, მაგრამ რამდენიმე ხაფანგის გადალახვა იყო საჭირო.

დარეგისტრირდით უკაბელო ქსელში.

პირველი ჩვენ ვქმნით TCP სერვერს, რომელიც უსმენს სამ ბრძანებას:

1. "პროგრამა" (ჩვენ დავპროგრამებთ),

2. „მონაცემები“ (ჩვენ გავცვლით მონაცემებს),

3. „გაჩერდი“ (ჩვენ ვაჩერებთ ყველაფერს).

თუ ჩვენ ვპროგრამირებთ, ჩვენ ჯერ SPI-ის ინიციალიზებას ვაკეთებთ და ვქმნით სხვა TCP სერვერს, რომელიც იღებს მონაცემებს (პროგრამის კოდი არის firmware) თითო კილობაიტზე და იძახებს მიკროკონტროლერის პროგრამირების ფუნქციებს მისთვის. მე მესმის, რომ მეორე სერვერის შექმნა სულელურად გამოიყურება, მაგრამ ეს აუცილებლობაა, რადგან ადგილობრივი API მხარს უჭერს მხოლოდ ერთი სოკეტის შექმნას და ჩვენ უნდა გამოვყოთ "პროგრამა" და "მონაცემების" ბრძანებები რეალურად გადაცემული მონაცემებით. რადგან ისინი არ გამოირჩევიან თვალით, არის ბაიტები და აქ არის ბაიტები.

თუ ჩვენ არ გვსურს დაპროგრამება, მაგრამ მონაცემების გაცვლა, ჩვენს შემთხვევაში მათ მიკროკონტროლერზე გაგზავნა, მაშინ ჯერ "მონაცემთა" სტრიქონს ვაგზავნით TCP-ის საშუალებით. ამის საპასუხოდ შეიქმნება UDP სერვერი (შეგახსენებთ, რომ ჩვენ ვაკონტროლებთ დინამიურად მექანიკური მკლავით და არ გვჭირდება შეფერხება TCP პაკეტების ფორმირებაში და ზოგადად ცუდი მანერაა ერთი ბაიტის გაგზავნა. მთელი TCP ჩარჩო). და ჩვენი UDP datagrams იქნება პატარა და გენერირებული სწრაფად.

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

ისე, "stop" ბრძანების შემდეგ ზემოხსენებული სერვერები (პირველის გარდა) ხურავს კავშირებს და მთავარი სერვერი ისევ გადადის "პროგრამის" და "მონაცემების" ბრძანებების მოლოდინში.

ვინაიდან SPI ინტერფეისი ემულირებულია ESP8266-ის პროგრამულ უზრუნველყოფაში, შეგიძლიათ გამოიყენოთ ნებისმიერი ხელმისაწვდომი I/O პორტი CS, CLK, MISO, MOSI, RESET (AVR-სთვის) სიგნალებისთვის და არა ჩემს ჩამტვირთველში მითითებული. გარდა ამისა, აღმოჩნდა, რომ CS და MISO, პრინციპში, ასევე შეიძლება გათიშული იყოს ამ შემთხვევაში; ის მათ გარეშე იმუშავებს. ისე, ერთი პინი გამოიყენება ESP8266 დაფაზე ჩაშენებული LED-ისთვის, რომ ზოგჯერ ციმციმებს და აჩვენებს, რომ პროგრამა ჯერ კიდევ ცოცხალია.

არ არსებობს შემოწმებები ჩაწერის შეცდომებზე (გარდა AVR-ზე პირველი მოთხოვნისა, მაგრამ ეს ინფორმაცია უბრალოდ ნაჩვენებია კონსოლზე), EEPROM არ არის დაპროგრამებული, 32 KB-ზე მეტი არ არის დაწერილი - მოკლედ, ჯერ კიდევ არსებობს რამეზე მუშაობა. SPI გაცვლის სიჩქარე არის დაახლოებით 115 Kbit, რამდენიმე წამში ყველაფერი ციმციმდება, დაახლოებით როგორც ჩვეულებრივი სერიული პროგრამისტი, როგორიცაა ISP500).

აიღეთ კოდი, შეიყვანეთ თქვენი ქსელები და პაროლები, შეადგინეთ იგი ESplorer-ზე, დაარქვით „init“ (ისე, რომ ის გადატვირთვისას დაიწყოს) და გაგზავნეთ ESP8266-ზე. უნდა იმუშაოს. უკაბელო პროგრამისტად მუშაობის გაგებით, მინიმუმ.

ახლა ჩვენ შევეხებით საკონტროლო მხარეს - პერსონალურ კომპიუტერს.

არსებითად, ჩვენ უნდა ავიღოთ HEX ფორმატის ფაილი, რომელშიც გადაიყვანება თქვენი პროგრამები ATMEL STUDIO გარემოში და გავაგზავნოთ WI-FI-ით ჩვენთვის ცნობილ სოკეტში (ამ შემთხვევაში, 4000). მცირე დაჭერა არის ის, რომ ჩვენ გვჭირდება ბინარული BIN ფაილი გადასატანად და ATMEL STUDIO მხოლოდ HEX-ს გვაწვდის. აქ ორი გამოსავალია; ან გადააკეთეთ იგი BIN ფორმატში სპეციალური გადამყვანი პროგრამით, როგორიცაა WinHex, ან გააკეთეთ ეს თქვენს პროგრამაში. ჯერ არ გამიკეთებია, მაგრამ რთული არ ჩანს, სათაური უნდა მოწყვიტო და სხვა რამ გააკეთო.

შედეგად, ჩამტვირთავი პროგრამა დავწერე JAVA-ში (ძირითადად იმიტომ, რომ სხვა არაფერი ვიცი), ვმუშაობდი უბრალოდ შესანიშნავ და უფასო IntelliJ IDEA გარემოში. ის ქმნის TCP კლიენტს, რომელიც ეძებს სერვერს, რომელიც მუშაობს ESP8266-ზე. თუ იპოვის, დაუკავშირდება და უგზავნის ამა და ამ მისამართზე მდებარე ფაილს. კოდი არის ქვემოთ.

JAVA ფაილის ჩამომტვირთველი მუშაობს კომპიუტერის მხარეს

java.io.* იმპორტი; იმპორტი java.net.*; იმპორტი java.util.ArrayList; იმპორტი java.util.List; საჯარო კლასის ქსელი ( საჯარო სტატიკური void main (სტრიქონი არგები) (ახალი Http_client (4000); )) კლასი Http_client აფართოებს Thread ( int port; String s; String Greetings_from_S; Http_client(int port)( this.port = port; start(); ) public void run() ( //192.168.1.113 არის ESP8266-ის მისამართი on ჩემი ქსელი. მაგრამ ზოგადად, თქვენ სწავლობთ როუტერთან კომუნიკაციიდან // სჯობს ის გახადოთ სტატიკური, როუტერებს შეუძლიათ ამის გაკეთება (Socket socket = new Socket("192.168.1.113", პორტი)) ( PrintWriter pw = ახალი PrintWriter(new OutputStreamWriter(socket.getOutputStream()),true); pw.println("პროგრამა");// მისალმებები SERVER System.out.println("პროგრამა"); ​​BufferedReader br = new BufferedReader(ახალი InputStreama (socket.getInputStream())); Greetings_from_S = br.readLine(); System.out.println(Greetings_from_S); if(Greetings_from_S.equals("ready")) (სცადეთ (ფაილი ფაილი = ახალი ფაილი("d:BlinkOUT .bin"); // ატვირთული ფაილის მისამართი. /1024;System.out.println(frames); int residy = data.length%1024; for (int i = 0; i< frames;i++) { for (int k = 0; k< (1024); k++) { data_buffer[k] = data; } sendingChunk(data_buffer); } byte data_buffer2= new byte; for (int i = 0; i < residy;i++) { data_buffer2[i] = data; } sendingChunk(data_buffer2); pw.println("stop");// System.out.println("stop program"); } catch (Exception e) { System.out.println(e); } } } catch (Exception e) { System.out.println(e); } } public void sendingChunk (byte data_buffer){ try (Socket socket = new Socket("192.168.1.113", 4001)){ BufferedOutputStream bos = new BufferedOutputStream((socket.getOutputStream())); bos.write(data_buffer); bos.flush(); System.out.println(data_buffer.length); } catch (Exception e) { System.out.println(e); } } }

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

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

ერთადერთი ის არის, რომ მის გასაშვებად თქვენ უნდა დააინსტალიროთ JAVA Runtime გარემო თქვენს კომპიუტერში. მაგრამ მე ჩვეულებრივ ვიწყებ პირდაპირ IntelliJ IDEA-დან, რადგან იქ ყოველთვის შეგიძლიათ კონსოლში ნახოთ რა ხდება (მაგრამ აქ საჭიროა JAVA გარემოც). თუმცა, რა თქმა უნდა, GUI უფრო ჭკვიანურად უნდა გაკეთდეს. ანუ ფანჯარა, სადაც გამოჩნდება ფაილის გზა, ფანჯარაში პორტის ნომრების შეცვლის შესაძლებლობა და, ასევე, სხვა საჭირო ნივთები. და შეაგროვეთ ეს ყველაფერი შესრულებადი ფაილის სახით.

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

ამ შემთხვევაში ჩვენ უნდა ვაკონტროლოთ ოთხი სერვო. ესენი არიან.

ასეთი დრაივი კონტროლდება მართკუთხა პულსებით 20 ms (50 Hz) პერიოდის განმავლობაში, 2-დან 4 პროცენტამდე სამუშაო ციკლით. ანუ 2% არის სრული შემობრუნება ერთი მიმართულებით, 4% მეორეში. ამოცანა მხოლოდ AVR-ში ჩაშენებული PWM-ისთვისაა.

ერთი სერვო გამოიყენება მარცხნივ-მარჯვნივ მოძრაობისთვის; მეორე საკუთარ თავზე - საკუთარი თავისგან; მესამე არის ზემოთ და ქვემოთ; მეოთხე არის თავად კლანჭი, რომელიც უნდა შეკუმშოს და გაშალოს. ყველაფერი დაწერილია C-ში და შედგენილია HEX ფაილში ATMEL STUDIO-ში. პროგრამის ოდნავ უცნაური გარეგნობა განპირობებულია იმით, რომ თავდაპირველად ხელი კონტროლდებოდა მავთულხლართებით დაკავშირებულ კლავიატურაზე მიკროკონტროლერთან. მაგრამ მავთულები წარსულის საგანია; ჩვენ შემდგომი განვითარება გვჭირდება.

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

აქ არის თავად კოდი, რომელსაც ჩვენ ვწერთ Arduino Nano-ს ESP8266-07-ის გამოყენებით.

MechArm კონტროლის პროგრამა AVRmega328P მიკროკონტროლერისთვის

#define F_CPU 16000000 #include #შეიცავს // სტანდარტული რიცხვები #include #შეიცავს // მათემატიკა #შეიცავს //სტანდარტული I/O #include #შეიცავს #შეიცავს //სტანდარტული შესაძლებლობები #define UART_BAUD_RATE 115200 // T1 მრიცხველი ადგენს დროის ინტერვალს 20ms-მდე #define COUNTER1_OFF TCCR1B=0b00000000 // CS02 CS01 CS00 - 000 - გამორთულია; 001 გამყოფის გარეშე; 010 გამყოფი 8-ით; 011 -64; 100 -256; 101 -1024 #define COUNTER1_ON TCCR1B=0b00000011 // მრიცხველი T0 აყენებს საკონტროლო პულსის სიგანეს სერვოებისთვის PB0 და PB1 #define COUNTER0_OFF TCCR0B=0b00000000 // CS02 -d CS000CS0; 001 გამყოფის გარეშე; 010 გამყოფი 8-ით; 011 -64; 100 -256; 101 -1024 #define COUNTER0_ON TCCR0B=0b00000100 // მრიცხველი T2 აყენებს საკონტროლო პულსის სიგანეს სერვოსთვის РБ2(PD6) და РВ3(PD7) #define COUNTER2_OFF TCCR2B=0b0000000CS2B0000000000; 001 გამყოფის გარეშე; 010 გამყოფი 8-ით; 011 -64; 100 -256; 101 -1024 #define COUNTER2_ON TCCR2B=0b00000110 volatile uint16_t period_20ms; არასტაბილური uint8_t კლავიატურის მდგომარეობა; არასტაბილური uint8_t start_position ; არასტაბილური int8_t ნომერი_სერვო; ISR(USART_RX_vect) // შეფერხება UART-ისთვის (კლავიატურის_მდგომარეობა=UDR0; დაბრუნება; ) ISR(TIMER0_COMPA_vect) // სერვო РВ0 სამართავი პულსის სიგანე ( PORTB &=~(1<<0); TIMSK0&=~(1<
პროგრამის არსი ნათლად ჩანს ტექსტიდან და კომენტარებიდან. ჩვენ ვიყენებთ მრიცხველ T1-ს 20 ms-ის ნიმუშის პერიოდისთვის და მრიცხველებს T0, T2 PWM სიგნალების გასაცემად I/O პორტის ოთხ ხაზზე, ვინაიდან ამ ორი მრიცხველიდან თითოეულს შეუძლია იმუშაოს ორ მოწყობილობაზე.
პროგრამა ადგენს სერვოების საწყის პოზიციებს მთვლელი რეგისტრების OCR0A, OCR0B, OCR2A, OCR2B ჩატვირთვით. ასევე შემოღებულია შეზღუდვის მუდმივები, რადგან ჩვენ ყოველთვის არ გვჭირდება 180 გრადუსიანი დიაპაზონი. კარგად, მაშინ, UART-ის შეწყვეტით, პროგრამა იჭერს ESP8266-ის მიერ გამოგზავნილ რიცხვს (1-დან 8-მდე) და თარგმნის მას ბრძანებაში შესაბამისი სერვო დისკისთვის. ოთხი დისკია, თითოეული მუშაობს ორი მიმართულებით, ამიტომ მთელი რიცხვები ერთიდან რვამდე საკმაოდ საკმარისია. რიცხვის არჩევის შემდეგ, ზემოაღნიშნული მრიცხველის რეგისტრების შიგთავსი იზრდება ან მცირდება, შესაბამისად იცვლება საკონტროლო პულსის მუშაობის ციკლი და არჩეული სერვოს ბრუნვის კუთხე. ის დისკები, რომლებიც ჩვენ არ ავირჩიეთ, ინარჩუნებენ ბრუნვის კუთხის ძველ მნიშვნელობას (რადგან შესაბამისი რეგისტრების შინაარსი, თუმცა განახლებული, არ შეცვლილა) და აგრძელებენ მექანიკური მკლავის შენარჩუნებას იმავე მდგომარეობაში.

ახლა ჩვენ მხოლოდ უნდა დავწეროთ საკონტროლო პროგრამა, ვაპატიოთ ტავტოლოგია, ვაკონტროლოთ მექანიკური მკლავი პირდაპირ კომპიუტერიდან WI-FI-ის საშუალებით.
კოდი ასევე იწერება JAVA-ში, მაგრამ ოდნავ გაუმჯობესებულია. არის GUI და ESP8266 პორტის ნომრების და ქსელის მისამართის რედაქტირების შესაძლებლობა.

რაც იქ ხდება, ფანჯრიდან ჩანს. მე არ ვაძლევ პროგრამის ტექსტს აქ (ის ხელმისაწვდომია აქ

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

ჩვენ გავარკვევთ მას ყველაზე იაფი და პოპულარული WiFi მოდულის საფუძველზე ESP8266-01. თქვენ შეგიძლიათ შეიძინოთ ESP8266-01 WiFi მოდული ჩვენს ვებგვერდზე.

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

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

მაშ ასე, დავიწყოთ და ჯერ გადავხედოთ WiFi მოდულის ქინძისთავებს ESP8266-01.

VCC- მოდულის კვების წყარო 3V-დან 3.6V-მდე

GND- Დედამიწა.

RST- გადატვირთეთ გამომავალი, რომელიც პასუხისმგებელია მოდულის გადატვირთვაზე.

CH_PD- "ჩიპის გამორთვა", როდესაც მას მიეწოდება ელექტროენერგია, მოდულის მუშაობა გააქტიურებულია.

TX- მონაცემთა გადაცემა (UART ინტერფეისი)

RX- მონაცემთა მიღება (UART ინტერფეისი)

GPIO0

GPIO2- ზოგადი დანიშნულების I/O პორტი

GPIO0 და GPIO2 პინები ზუსტად იგივე ციფრული პინებია, რომლებთანაც ჩვენ ვმუშაობთ Arduino დაფებზე სხვადასხვა სენსორებთან დასაკავშირებლად და ისინი გამოიყენება ESP8266-01 მოდულის შიდა WiFi მიკროკონტროლერზე დამოუკიდებელი ოპერაციის განხორციელების შემთხვევაში.

ESP8266-01 მოდულის საიმედოდ ჩასართავად გამოიყენეთ გარე სტაბილიზირებული 3.3 ვ დენის წყარო და უმჯობესია არ სცადოთ ენერგიის აღება თქვენი Arduino დაფიდან, რადგან მოდული მოიხმარს დენს 215 mA-მდე და ეს შეიძლება ცუდად დასრულდეს თქვენი გამართვის დაფისთვის. სად ვიშოვო სტაბილიზებული 3.3V დენის წყარო, იმედია არ არის თქვენთვის პრობლემა, თორემ აშკარად ნაადრევია ამ მოდულთან გამკლავება. მაგალითად, მე მომწონს ამ 3.3V და 5.0V YWRobot დენის მოდულის გამოყენება პურის დაფებზე სქემების სწრაფად ასაწყობად, რაც საშუალებას გაძლევთ სწრაფად მიიღოთ 3.3V ან 5V სტაბილიზებული ძაბვა დაფის შესაბამის დენის ბილიკებზე.

პლიუსის დაკავშირება (+) ჩვენი 3.3 ვ დენის წყაროდან ქინძისთავამდე VCCმოდული ESP8266-01 და მინუს (-) მიიტანეთ კვების წყარო გამოსავალზე GND. ამ მდგომარეობაში მოდულის წითელი LED ჩაირთვება, რაც გვაძლევს სიგნალს, რომ ელექტროენერგია სწორად არის დაკავშირებული. იმისათვის, რომ მოდული გააქტიურდეს, ასევე აუცილებელია პლუსის დაკავშირება (+) კვების წყარო გამომავალი CH_PDმოდული ESP8266-01 და მიზანშეწონილია ამის გაკეთება პირდაპირ 10 kOhm რეზისტორის საშუალებით. ახლა, როდესაც ჩართავთ დენს, მოდულზე წითელი LED უნდა აანთოს და ლურჯი LED სწრაფად უნდა აციმციმდეს რამდენჯერმე. თუ ასე დაგემართათ, მაშინ ყველაფერი კარგადაა, ყველაფერი სწორად დააკავშირეთ და თქვენი მოდული მუშაობს. წინააღმდეგ შემთხვევაში, ხელახლა შეამოწმეთ კავშირი ან შეცვალეთ მოდული, რადგან ის დიდი ალბათობით არ მუშაობს.

Განაგრძე. ESP8266 WiFi მოდულთან მუშაობისთვის ჩვენ გვჭირდება USB-UART ადაპტერი. არსებობს სხვადასხვა გადამყვანები, მაგალითად: FT232RL, CP2102, PL2303. მაგრამ ჩვენ ვივარაუდებთ, რომ თქვენ არ გაქვთ ასეთი გადამყვანები და ჩვენ გამოვიყენებთ Arduino დაფას USB-UART ადაპტერად. ამისთვის გამოვიყენებ Arduino NANO დაფას, მაგრამ თქვენ შეგიძლიათ გამოიყენოთ ნებისმიერი სხვა თქვენს განკარგულებაში. კავშირი ნებისმიერ დაფაზე იდენტურია. ჩვენ ვაკეთებთ კავშირს შემდეგი სქემის მიხედვით.

მოდით შევხედოთ რა გავაკეთეთ აქ. გთხოვთ, დაუყოვნებლივ გაითვალისწინოთ, რომ ჩვენ დავაკავშირეთ ქინძისთავები Arduino დაფაზე ჯემპრით RSTდა GND. ეს მანიპულაცია გამორთავს მიკროკონტროლერს და გვაძლევს საშუალებას, რომ ჩვენი Arduino დაფიდან შევქმნათ ნამდვილი USB-UART ადაპტერი.

ვინაიდან ჩვენ ვკვებავთ ESP8266-01 WiFi მოდულს ცალკე გარე კვების წყაროდან, გახსოვდეთ, რომ ჩვენს პროექტებში ყოველთვის უნდა დავაკავშიროთ ყველა კვების წყაროს მიწა. ამიტომ ჩვენ ვაკავშირებთ გამომავალს GND Arduino დაფები ადგილზე (-) ჩვენი გარე 3.3V კვების წყარო, რომელიც შექმნილია ESP8266-01 მოდულის კვებისათვის.

დასკვნა TXდააკავშირეთ თქვენი Arduino დაფა პინთან TX ESP8266-01 მოდული. ეს ხაზი გადასცემს მონაცემებს WiFi მოდულიდან Arduino დაფაზე. ნებისმიერს, ვინც იცნობს UART ინტერფეისს, შეიძლება გაინტერესებდეს: "მაგრამ როგორ შეიძლება ასე იყოს? ყველგან ასწავლიდნენ, რომ TX უნდა დაუკავშირდეს RX-ს. TX გადასცემს ინფორმაციას და RX იღებს." და მართალი იქნებით. ასეა, TX ყოველთვის დაკავშირებულია RX-თან, მაგრამ იმ შემთხვევაში, როდესაც Arduino-სგან ვამზადებთ UART ადაპტერს, აუცილებელია მოწყობილობების პირდაპირ დაკავშირება. ჩათვალეთ ეს წესის გამონაკლისად.

ხაზი RXჩვენ ასევე ვუკავშირდებით თქვენს Arduino დაფას პირდაპირ ხაზთან RX ESP8266-01 მოდული. ეს ხაზი გადასცემს ინფორმაციას Arduino დაფიდან WiFi მოდულის დაფაზე. მაგრამ ჩვენ ამ კავშირს ვაკეთებთ ეგრეთ წოდებული ძაბვის გამყოფის საშუალებით, რომელიც შედგება ორი რეზისტორისგან, ნომინალური მნიშვნელობებით 1 kOhm და 2 kOhm. ჩვენ უნდა შევამციროთ ძაბვა ამ ხაზზე ორი რეზისტორის გამოყენებით (ძაბვის გამყოფი), რადგან Arduino დაფა გადასცემს ლოგიკურ სიგნალს 5 ვ ძაბვით, ხოლო WiFi მოდული მუშაობს 3.3 ვ ძაბვით. ლოგიკური სიგნალის გადასაყვანად შეგვეძლო გამოვიყენოთ სპეციალური ლოგიკური დონის გადამყვანი დაფა, რაც, რა თქმა უნდა, უფრო სწორი იქნებოდა, მაგრამ კიდევ ერთხელ, დავუშვათ, რომ თქვენ არ გაქვთ, და ჩვენ მოგვიწია უფრო მარტივი მარშრუტის გავლა და ამის გაკეთება ძაბვის გამყოფი.

ჩვენ ახლა დავაკავშირეთ ყველაფერი, რაც საჭიროა შემდგომი მუშაობისთვის, მაგრამ ჯერ კიდევ გვაქვს კიდევ 3 პინი გამოუყენებელი ( GPIO0, GPIO2და RST) ზე WiFi მოდული ESP8266-01. WiFi მოდულის სტაბილური მუშაობისთვის, დარჩენილი გამოუყენებელი ქინძისთავები პოზიტივისკენ უნდა გადავიყვანოთ (+) მოდულის ელექტროგადამცემი ხაზები 10 kOhm რეზისტორების მეშვეობით.

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

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

ზოგადად, ჩვენ დავასრულეთ კავშირი. ახლა ჩვენ უნდა მოვამზადოთ Arduino IDE პროგრამა ESP8266-01 WiFi მოდულთან მუშაობისთვის. ამისათვის ჩვენ უნდა გადმოვწეროთ და დავაინსტალიროთ Arduino IDE-ში საჭირო არქივი ბიბლიოთეკებით, მაგალითებით და ESP დაფებით, რაც შემდგომში საშუალებას მოგვცემს ატვირთოთ ესკიზები პირდაპირ ESP8266-01 მოდულის მიკროკონტროლერზე, შევცვალოთ firmware და ა.შ. ამ სტატიის მიზნებისთვის, ჩვენ, სავარაუდოდ, არ დაგვჭირდება ეს პარამეტრები, მაგრამ მეჩვენება, რომ მას შემდეგ რაც გავარკვევთ, როგორ დავაკავშიროთ მოდული, პროცედურა სწორი იქნება, თუ დაუყოვნებლივ გადმოვწერთ ყველაფერს, რაც საჭიროა Arduino IDE-სთან მუშაობისთვის. . აქ ყველაფერი პრინციპში მარტივია.

გაუშვით პროგრამა Arduino IDEდა გადადით მენიუში "ფაილი" - "პარამეტრები"

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

ინსტალაციის დასრულების შემდეგ. ჩვენ გადატვირთეთ Arduino IDE და ვხედავთ, თუ როგორ გამოჩნდა ახალი ESP დაფები "ინსტრუმენტები" - "დაფები" მენიუში. Სულ ეს არის. ჩვენ დავასრულეთ Arduino IDE-ს დაყენება. ჩვენ ჯერ არ გვჭირდება ეს პარამეტრები, მაგრამ სამომავლო სამუშაოებში მათ გარეშე ვერ შევძლებთ.

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

ასე რომ, ჩვენ ვუკავშირებთ ჩვენს Arduino დაფას USB კაბელის საშუალებით კომპიუტერთან. და ენერგიის გარე წყარო, რომელიც ძალას აძლევს WiFi მოდული ESP8266-01ჯერ არ არის საჭირო მისი ჩართვა. ჩვენ გავუშვით Arduino IDE პროგრამა, აირჩიეთ ჩვენი Arduino დაფა "Tools" მენიუდან, ჩემს შემთხვევაში ეს არის Arduino NANO და თქვენ ირჩევთ თქვენსას. ასევე, არ დაგავიწყდეთ აირჩიოთ პორტი, რომელსაც ჩვენი Arduino უკავშირდება. იმედია გესმით ეს ყველაფერი და იცით როგორ გააკეთოთ ეს.

ღია პორტის მონიტორინგი "ინსტრუმენტები" - "პორტის მონიტორი". პორტის სიჩქარის არჩევა 74880 (ამ სიჩქარით იწყება მოდული) და აირჩიეთ “NL & CR” სიაში მარცხნივ

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

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

პორტის სწორი სიჩქარის ასარჩევად, ჩვენ უბრალოდ შევცვლით პორტის სიჩქარეს და გამოგიგზავნით სიმბოლოებს პორტში (ველი ზედა და გაგზავნის ღილაკი) ATსანამ პასუხს არ მივიღებთ კარგი. თუ ცდილობთ სიმბოლოების გაგზავნას ახლავე ATპორტამდე 74880 სიჩქარით, პასუხად მიიღებთ კიდევ ერთ ან ორ უაზრო სიმბოლოს.

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

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

ვიმედოვნებ, რომ ყველაფერი კარგად არის და თქვენ აირჩიეთ სწორი სიჩქარე. სხვათა შორის, თუ ცდილობთ WiFi მოდულის გამორთვას და ჩართვას ისევ სწორი სიჩქარის არჩევის შემდეგ, მაშინ იმავე საწყისი ინფორმაციის ნაცვლად, რომელიც სწორად იყო ნაჩვენები 74880 ბაუდის სიჩქარით, პირიქით, იხილეთ პერსონაჟების შერეული ნაკრები, მაგრამ ბოლოს ნახავთ სიტყვას "მზადაა". მაგრამ ჩვენ გვაქვს შესაძლებლობა ვნახოთ ეს საწყისი ინფორმაცია ნორმალური ფორმით, სწორი სიჩქარით; ამისათვის საჭიროა მოდული პროგრამულად გადატვირთოთ AT ბრძანების გამოყენებით. AT+RST.

თქვენი ESP8266-01 WiFi მოდულის firmware ვერსიის გასარკვევად, თქვენ უნდა გაგზავნოთ ბრძანება პორტის მონიტორზე AT+GMRდა პასუხად მიიღებთ დაახლოებით შემდეგ ინფორმაციას:

ESP8266-01 WiFi მოდულს შეუძლია იმუშაოს როგორც წვდომის წერტილის, ასევე კლიენტის რეჟიმში. იმისათვის, რომ მოდულმა ერთდროულად იმუშაოს ყველა რეჟიმში, გაგზავნეთ ბრძანება პორტის მონიტორზე AT+CWMODE=3და საპასუხოდ უნდა მიიღოთ კარგი.

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

მაგალითად, ჩვენ ვიცით მესამე წვდომის წერტილის პაროლი და მასთან დასაკავშირებლად ვასრულებთ ბრძანებას AT+CWJAP="სახელი","პაროლი", ჩემს შემთხვევაში ეს ბრძანება ასე გამოიყურება AT+CWJAP="dsl_unlim_512_home","11111111", რაზეც მივიღებთ წარმატებულ პასუხს:

ბრძანების პარამეტრები იწერება ESP8266-01 WiFi მოდულის ფლეშ მეხსიერებაში და თუ მოდულს გამოვრთავთ და ისევ ჩავრთავთ, ის ავტომატურად დაუკავშირდება ამ წვდომის წერტილს. შეხედე, შემთხვევით, ბრძანებაში სივრცე არ დაუშვა, თორემ პასუხს მიიღებ შეცდომა. გთხოვთ გაითვალისწინოთ, რომ firmware-ის უახლეს ვერსიებში რეკომენდებულია ბრძანების გამოყენება AT+CWJAP_CUR, ანუ ბრძანება ასე გამოიყურება AT+CWJAP_CUR="სახელი","პაროლი".თუ მოულოდნელად დაგვავიწყდა, რომელ წვდომის წერტილთან არის დაკავშირებული ჩვენი მოდული, უნდა გავგზავნოთ ბრძანება AT+CWJAP?ან AT+CWJAP_CUR?და პასუხად მივიღებთ წვდომის წერტილს, რომელზეც ამჟამად არის დაკავშირებული WiFi მოდული.

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