დისტანციური მართვის ტაიმერი NodeMCU– ით: 14 ნაბიჯი

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

აქ ჩვენ შევქმნით ტაიმერს NodeMCU და Adafruit– ის გამოყენებით. ჩვენ ვაჩვენებთ ჩვენს ტაიმერს LED ზოლით და ჩვენ გვექნება საშუალება გავაკონტროლოთ იგი ტელეფონის ან კომპიუტერის გამოყენებით!

Ჩვენი მიზანი:

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

მარაგები

აპარატურა:

• NodeMCU ESP 8266
• Adafruit NeoPixel LED ზოლები

ბიბლიოთეკები:

• ადაფრუტ_ნეოპიქსელი. თ
• ადაფრუტი IO_WiFi.h

სხვა:

ღირსეული WiFi კავშირი

ნაბიჯი 1: მოდით შევქმნათ არხი ადაფრუტში

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

ახლა მოდით შევქმნათ ახალი არხი

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

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

ნაბიჯი 2: ახლა მოდით შევქმნათ დაფა

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

ნაბიჯი 3: მიიღეთ ჩვენი გასაღები

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

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

შეინახეთ ეს გასაღები სადმე, ჩვენ მოგვიანებით დაგვჭირდება.

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

ნაბიჯი 4: გახსენით არხის წაკითხვის მაგალითი

ახლა გავხსნათ ჩვენი Arduino IDE და დავიწყოთ კოდირების პროცესი. უპირველეს ყოვლისა, ჩვენ გვჭირდება Adafruit IO Arduino ბიბლიოთეკის დაყენება.

არ იცით ბიბლიოთეკების დაყენება? ეს არის დიდი მეგზური ადაფრუტის მიერ: არდუინოს ბიბლიოთეკები

ადაფრუტი გთავაზობთ უამრავ წინასწარ მომზადებულ მაგალითს, რომ გამოვიყენოთ და ვისწავლოთ. ერთ -ერთი ასეთი მაგალითია: adafruitio_21_feed_read. თქვენ შეგიძლიათ ნახოთ ეს მაგალითი აქ: ფაილი - მაგალითები Adafruit IO Arduino adafruitio_21_feed_read

(მაპატიეთ სურათზე ჩემი ჰოლანდიური ინტერფეისი)

ნაბიჯი 5: მოდით შევქმნათ ჩვენი კავშირი

თუ თქვენ წარმატებით გახსენით adafruitio_21_feed_read ესკიზი, თქვენ უნდა ნახოთ 2 ჩანართი თქვენს ესკიზში: adafruitio_21_feed_read და config.h. ესკიზი გაკეთდა ისე, რომ ჩვენ შევძლოთ დაკავშირება იმ საკვებთან, რომელიც ჩვენ გავაკეთეთ 1 -ლი ნაბიჯიდან.

ამ არხთან დასაკავშირებლად ჩვენ უნდა შეავსოთ რამდენიმე დეტალი ჩვენი WiFi და Adafruit ანგარიშის შესახებ,

მოდით ვიმოგზაუროთ config.h– ზე, აქ ჩვენ შეავსებთ შემდეგ დეტალებს:

თქვენი Adafruit მომხმარებლის სახელი:

#განსაზღვრეთ IO_USERNAME "joopert"

თქვენი ადაფრუტის გასაღები:

#განსაზღვრეთ IO_KEY "1234567890abcdefghijklmnop"

თქვენი WiFi სახელი:

#განსაზღვრეთ WIFI_SSID "MyWifi"

და თქვენი WiFi პაროლი:

#განსაზღვრეთ WIFI_PASS "aVerySecretPassword"

ახლა დავუბრუნდეთ adafruitio_21_feed_read ჩანართს და შეავსოთ:

თქვენი Adafruit მომხმარებლის სახელი … ისევ:

#განსაზღვრეთ FEED_OWNER "joopert"

დაბოლოს, თქვენი საკვების სახელი (ჩვენ გავაკეთეთ ნაბიჯი 1 -დან):

AdafruitIO_Feed *sharedFeed = io.feed ("ტაიმერი", FEED_OWNER);

ნაბიჯი 6: შეამოწმეთ კავშირი Adafruit IO– სთან

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

Adafruit IO დაკავშირებულია

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

ნაბიჯი 7: მოდით LED

ახლა დროა ჩართოთ ჩვენი LED ზოლები!

შეაერთეთ თქვენი LED ზოლი D5 PIN- თან (თუ ვერ იპოვით D5 დაუკავშირეთ სხვა PIN კოდს და შეცვალეთ LED_PIN კოდი).

განსაზღვრეთ LED ზოლები

შემდეგი კოდი დაამატებს NeoPixel ბიბლიოთეკას (შეიტყვეთ მეტი ამ ბიბლიოთეკის შესახებ აქ: https://learn.adafruit.com/adafruit-neopixel-uberguide/arduino-library-use) და დარწმუნდით, რომ ჩვენმა Arduino- მ იცის სად არის ჩვენი LED ზოლები და რამდენი ნათურა აქვს. თუ თქვენს LED ზოლს აქვს განსხვავებული სპეციფიკაციები, შეცვალეთ იგი კოდში.

დაამატეთ შემდეგი კოდი ზემოთ void setup ().

// შექმენით NeoPixel კავშირი #მოიცავს #ifdef _AVR_ #მოიცავს #endif

#განსაზღვრეთ LED_PIN D5 // სად არის დაკავშირებული LED ზოლები?

#განსაზღვრეთ LED_COUNT 30 // რამდენი პიქსელი აქვს მას?

#განსაზღვრეთ სიკაშკაშე 50 // NeoPixel სიკაშკაშე, 0 (წთ) 255 (მაქს)

Adafruit_NeoPixel ზოლები (LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);

ჩართეთ LED ზოლები

ახლა ჩვენ დავიწყებთ ჩვენი LED ზოლის და დააყენეთ სიკაშკაშე (სიკაშკაშე 0 -დან 255 -მდე იზრდება, მაგრამ მე გირჩევთ 50… 255 მართლაც ნათელია).

დაამატეთ შემდეგი კოდი void setup- ში ():

ზოლები. დაწყება (); // ინიციალიზაცია NeoPixel ზოლის ობიექტი (საჭირო) strip.show (); // გამორთეთ ყველა პიქსელი ASAP strip.setBrightness (50); // დააყენეთ BRIGHTNESS დაახლოებით 1/5 (მაქსიმ = 255)

ledsOn (); // მოუწოდებს ფუნქციას ჩართოს თითოეული LED სათითაოდ

აანთეთ შუქი

შესაძლოა თქვენ უკვე შეამჩნიეთ, რომ ჩვენ ვიძახებთ ფუნქციას, რომელიც ჯერ არ არსებობს, ეს იქნება ჩვენი კოდირების შემდეგი ნაწილი. თუ ჩვენ გვინდა ჩვენი შუქების ჩართვა, ჩვენ უნდა შევქმნათ "მარყუჟისათვის", რომელიც თითოეულ LED- ს სათითაოდ ჩართავს (არ ვიცი რა არის loop? შეამოწმეთ აქ: www.arduino.cc/reference/ en/ენა/სტრუქტურა/კონტროლი-სტრუქტურა/for/).

ახლა ჩვენ შევქმნით ფუნქციას: ledsOn ();

დაამატეთ შემდეგი კოდი ქვემოთ void handleMessage ():

void ledsOn () {for (int i = 0; i <strip.numPixels (); i ++) {// ზოლის თითოეული პიქსელისთვის… strip.setPixelColor (i, 0, 0, 255); // პიქსელის ფერის დაყენება ლურჯზე strip.show (); // ზოლის განახლება შესატყვისი}}

ატვირთვა

ახლა არის სახალისო ნაწილი, მოდით ატვირთოთ ჩვენი კოდი NodeMCU– ში … თუ ყველაფერი სწორად მუშაობს, თქვენი LED ზოლები ახლა მთლიანად ცისფერი უნდა გახდეს!

პიქსელები არ გამოჩნდება?: დაუკავშირეთ ლენტი მარჯვენა PIN- კოდს? ან იქნებ თქვენი ინტერნეტ კავშირი დაიკარგა.

მხოლოდ რამდენიმე პიქსელი არ გამოჩნდება?: შეამოწმეთ სწორად დაადგინეთ პიქსელების რაოდენობა!

ნაბიჯი 8: დაამატეთ დრო ტაიმერს

ახლა ჩვენ ვაპირებთ დავრწმუნდეთ, რომ ჩვენი ტაიმერი რეალურად… კარგად… ჯერ, რაღაც.

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

თუ თქვენ დაინტერესებული ხართ როგორ მუშაობს ეს, შეგიძლიათ ნახოთ ეს სტატია:

მოდით დავამატოთ კოდი Millis ():

განათავსეთ ეს კოდი ბათილად დაყენების ზემოთ ()

ხელმოუწერელი გრძელი წინამილის = 0; // შეინახავს ბოლოს LED ზოლის განახლების დროს ინტერვალი = 1000; // ჩვენი ტაიმერის ინტერვალი (მილიწამები)

და ეს კოდი ჩავდოთ ბათილ მარყუჟში ():

ხელმოუწერელი გრძელი მიმდინარემილის = მილილი ();// დაიწყე TIMER RYTHM ****************************************** ********* if (currentMillis - previousMillis> = ინტერვალი) {previousMillis = currentMillis;

// დასრულდება TIMER RYTHM ****************************************** ***********

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

ნაბიჯი 9: დათვლა

ამ ნაბიჯში: ჩვენ შევასრულებთ ფუნქციას, რომელიც დარწმუნდება, რომ ყოველ წამს (ან თქვენს მიერ მითითებულ ინტერვალს) ჩვენ გამორთეთ ერთი LED ზოლის ბოლოს, სანამ ჩვენი LED- ები არ გამორთულია.

ჩვენ შევქმნით "int" ზედა სახელწოდებით "leds". ეს მოგვიანებით გეტყვით ჩვენს ტაიმერს, რამდენი led უნდა გამორთოს.

დაამატეთ შემდეგი კოდი ზემოთ void setup ():

int leds = LED_COUNT-1; // ითვლის რამდენი პიქსელი უნდა იყოს განათებული

ახლა დავამატოთ ფუნქცია 'ტაიმერი ();', ეს იქნება სინათლის გამორთვა ყოველ წამს

დაამატეთ შემდეგი კოდი ქვემოთ void ledsOn ():

void timer () {strip.setPixelColor (leds, 0, 0, 0);

if (leds> -1) {leds--; } else {blinkie (); }}

ჩვენ გვსურს მომხმარებელს მივცეთ გარკვეული გამოხმაურება, რომ ტაიმერი კეთდება მას შემდეგ, რაც ყველა შუქი დაიწვა. 'Blinkie ();' LED- ები წითლად აციმციმდება ტაიმერის დასრულების შემდეგ!

დაამატეთ შემდეგი კოდი ზემოთ void setup ():

int blink სტატუსი = 1; // ეუბნება blinkie (); სველი ფუნქცია, როდესაც შუქი უნდა იყოს ჩართული ან გამორთული

დაამატეთ შემდეგი კოდი ქვემოთ void timer ():

void blinkie () {if (blinkStatus == 1) {

blinkStatus = 0; ზოლები. ნათელი (); } else {blinkStatus = 1; for (int i = 0; i <strip.numPixels (); i ++) {// თითოეული პიქსელისთვის ზოლში… strip.setPixelColor (i, 255, 0, 0); // დააყენეთ პიქსელის ფერი (RAM- ში) strip.show (); // განაახლეთ ზოლები შესატყვისად}}}}

დაბოლოს, ჩვენ უნდა გამოვიძახოთ ფუნქცია ჩვენს ბათილ მარყუჟში ();

გახსოვთ TIMER RYTHM, რომელიც ჩვენ დავამატეთ მე –8 ნაბიჯში? ამ if განცხადებაში ჩვენ გამოვიძახებთ ფუნქციის ტაიმერს ();.

TIMER RYTHM ახლა ასე უნდა გამოიყურებოდეს:

// დაიწყე TIMER RYTHM ****************************************** *********

if (currentMillis - previousMillis> = ინტერვალი) {previousMillis = currentMillis; ტაიმერი (); strip.show ();} // ბოლოს TIMER RYTHM ************************************ ******************

ახლა ატვირთეთ ეს კოდი!

ახლა თქვენი LED ზოლი უნდა გამორთოთ 1 LED ყოველ წამში და დახუჭოთ წითლად, როდესაც ის დასრულდება…

ახლა მოდით ეს დედამთილი დისტანციურად მართოთ!

ნაბიჯი 10: გახადეთ ის დისტანციურად კონტროლირებადი: ნაწილი I

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

კვლავ გახსნილი გაქვთ თქვენი Adafruit ჩანართი? მოდით ვიმოგზაუროთ io.adafruit.com– ზე და გადავიდეთ ტაიმერის ინტერფეისის დაფაზე და შევქმნათ ახალი ბლოკი: TOGGLE

1. შეაერთეთ გადამრთველი TIMER არხთან
2. დააყენეთ ჩართული მნიშვნელობა: 1
3. დააყენეთ OFF მნიშვნელობა: 0

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

თქვენ ასევე შეგიძლიათ დაასახელოთ Toggle სახელი, თუ გსურთ, შესაძლოა: 'ჩართვა/გამორთვა გადართვა'

ახლა დავუბრუნდეთ Arduino IDE- ს

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

გახსენით სერიული მონიტორი ატვირთვის დასრულების შემდეგ და რამდენჯერმე დააჭირეთ ღილაკს Adafruit– ის საინფორმაციო დაფაზე. ჩვენ ახლა უნდა ვნახოთ მსგავსი რამ ჩვენს სერიულ მონიტორზე:

მიღებული <- 0 მიღებული <- 1 მიღებული <- 0 მიღებული <- 1 მიღებული <- 1 მიღებული <- 0

ეს ნიშნავს, რომ ჩვენ შეგვიძლია რეალურად გავაგზავნოთ კონტროლი ჩვენს NodeMCU– ში!

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

ნაბიჯი 11: გახადეთ ის დისტანციურად კონტროლირებადი: ნაწილი II

ახლა დარჩა რაღაცის გაკეთება ჩვენი მიღებული კონტროლით.

ამისათვის ჩვენ უნდა შევცვალოთ ჩვენი TIMER RYTHM if განცხადება void loop (); ოდნავ.

ჩვენ ვეტყვით ჩვენს NodeMCU- ს, რომ ტაიმერი უნდა დაიწყოს მხოლოდ მას შემდეგ, რაც მივიღებთ '1' (რაც ნიშნავს: ON) ადაფრუტიდან.

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

დაამატეთ შემდეგი კოდი ზემოთ void setup ():

int adaData; // აგროვებს მონაცემებს, რომელსაც ადაფრუტი გვიგზავნის

მოდით, რეალურად შევაგროვოთ ეს მონაცემები

დაამატეთ შემდეგი კოდი INSIDE void handleMessage ():

adaData = data-> toInt ();

მოდით შევცვალოთ ჩვენი ბათილი მარყუჟი ();

TIMER RYTHM ახლა ასე უნდა გამოიყურებოდეს:

// დაიწყე TIMER RYTHM ****************************************** ********* if (currentMillis - previousMillis> = ინტერვალი) {previousMillis = currentMillis; if (adaData == 0) {Serial.println ("არ ვარ გაშვებული"); } else if (adaData == 1) {ქრონომეტრი (); } strip.show (); } // დასრულება TIMER RYTHM ***************************************** *************

ატვირთეთ თქვენი კოდი…

ახლა თქვენ უნდა შეგეძლოთ ტაიმერის ჩართვა და გამორთვა ადაფრუტში გადამრთველის გამოყენებით!

ნაბიჯი 12: ითამაშეთ გარშემო! ჩვენ დავასრულეთ … ან ვართ?

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

თუ გსურთ გააგრძელოთ ცოტა ხნით, მომდევნო რამდენიმე ნაბიჯში ჩვენ დავამატებთ RESET ღილაკს ჩვენი ტაიმერისთვის!

ნაბიჯი 13: დამატებითი: შექმენით მომენტალური ღილაკი

დავუბრუნდეთ ჩვენს დაფას. ახლა ჩვენ გვსურს კვლავ შევქმნათ ახალი ბლოკი.

1. შექმენით მომენტალური ღილაკი
2. შეაერთეთ იგი „ტაიმერის“არხთან
3. დააყენეთ პრესის მნიშვნელობა: 2
4. ამოიღეთ გამოშვების მნიშვნელობა
5. მიეცი მას ლამაზი ფერი!

მოხერხებულად მომენტალურ ღილაკს უკვე ჰქვია "გადატვირთვა"!

მას შემდეგ რაც შექმნით ამ ბლოკს, შეამოწმეთ იგი, ღილაკი მუშაობს თუ მიიღებთ:

მიღებული <- 2

თქვენს სერიულ მონიტორზე.

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

ნაბიჯი 14: დამატებითი: დაამატეთ გადატვირთვის ფუნქცია

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

დაამატეთ შემდეგი კოდი ქვემოთ void blinkie ():

void rerun () {leds = LED_COUNT; ledsOn (); }

ახლა დარჩა მხოლოდ ჩვენი ფუნქციის გამოძახება, ამისათვის ჩვენ უნდა შევცვალოთ TIMER RYTHM ბოლოჯერ

TIMER RYTHM ახლა ასე უნდა გამოიყურებოდეს:

// დაიწყე TIMER RYTHM ****************************************** ********* if (currentMillis - previousMillis> = ინტერვალი) {previousMillis = currentMillis if (adaData == 0) {Serial.println ("არ ვარ გაშვებული"); } else if (adaData == 1) {ქრონომეტრი (); } else if (adaData == 2) {გამეორება (); } strip.show (); } // დასრულება TIMER RYTHM ***************************************** *************

ატვირთეთ თქვენი კოდი…

ახლა თქვენ ასევე უნდა შეგეძლოთ ტაიმერის გადატვირთვა ღილაკზე დაჭერით!