Hue Magic: 4 ნაბიჯი (სურათებით)

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

მოგესალმებით ოსტატები!

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

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

ნაბიჯი 1: რა გჭირდებათ ამ პროექტის შესაქმნელად

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

• 1 (ან მეტი) Philips Hue ფერის ნათურა და Hue Bridge
• 1 Wemos D1 მინი ან მსგავსი esp8266 დაფუძნებული მიკროკონტროლერი
• 1 (არდუინო) სენსორული სენსორი (მაგ. TTP223R)
• 1 (არდუინო) წამიერი ღილაკი
• 1 10uF კონდენსატორი
• 1 RGB led (საერთო ანოდის ტიპი)
• 5 რეზისტორი (10, 22 და 47 Ohm, 2x 10K Ohm)
• 2 პატარა პროტოტიპი PCB (2x3 დიუმიანი ან დაახლოებით 5x7 სმ უნდა იყოს საკმარისად დიდი)
• ზოგიერთი (მხტუნავი) მავთული
• soldering რკინის
• ჯადოსნური ჯოხი (შეგიძლიათ შეიძინოთ როგორც მზა სათამაშოების მაღაზიაში, ან შეგიძლიათ თავად გააკეთოთ)
• მუყაოს ან ხისგან დამზადებული პატარა ყუთი (შეიძლება იყოს არსებული ყუთი, მაგრამ თქვენ ასევე შეგიძლიათ ააწყოთ ყუთი ნულიდან რა თქმა უნდა)
• რაღაც ფირზე
• რამდენიმე წებო და/ან კაკალი და ჭანჭიკები, რათა დააინსტალიროთ PCB ყუთში.
• სურვილისამებრ: შესაფუთი ქაღალდი ყუთისთვის

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

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

ნაბიჯი 2: ყუთი და ჯოხი

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

როდესაც ხელახლა აპირებთ არსებულ ყუთს, ერთადერთი რაც თქვენ უნდა გააკეთოთ არის ორი ხვრელის გაკეთება ყუთის ზედა ნაწილში: 1 პატარა ხვრელი (ზომა 5 მმ = 0.2 ) RGB led- ისთვის და უფრო დიდი ხვრელი (დაახლოებით 12- შეხების სენსორისთვის 14 მმ ან დაახლოებით 0.5”).

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

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

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

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

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

ნაბიჯი 3: აპარატურა შიგნით

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

• მავთულები Wemos D1 Mini– სა და RGB led– ს შორის უნდა იყოს საკმარისად გრძელი, ასე რომ RGB led შეიძლება დამონტაჟდეს იმ ხვრელში, რომელიც თქვენ გააკეთეთ ყუთის სახურავში.
• იგივე ითვლის მავთულხლართებს, რომლებიც მიმაგრებულია მომენტალურ გადამრთველზე და შეხების სენსორზე, რადგან ისინი ხელმისაწვდომი უნდა იყოს სახურავის სხვა ხვრელის მეშვეობით.
• მომენტალური გადამრთველის ღილაკი უნდა იყოს მიბმული სენსორული სენსორის ქვედა მხარეს (არა მგრძნობიარე მხარეზე), ისე, რომ ღილაკი დააბრუნოთ მომენტალურ გადამრთველზე სენსორული სენსორის თავზე (იხ. სურათი). სენსორული სენსორი დამონტაჟებულია მომენტალური გადამრთველის თავზე, რათა გამოავლინოს თითის მიერ დაჭერილი ღილაკები, ამ შემთხვევაში ღილაკის დაჭერა იგნორირებული იქნება. მხოლოდ ღილაკზე დაჭერით ჯადოსნური ჯოხი (რომელიც არ უნდა იყოს გამტარი, ამიტომ პლასტმასი და ხე კარგად არის), ჯადოსნური ციკლი დაიწყება.
• მიამაგრეთ მომენტალური ღილაკი შეხების სენსორით თავზე არც თუ ისე ღრმად სახურავის ხვრელის ქვემოთ, რადგან ჯადოსნური ჯოხი უნდა მიუახლოვდეს მას, რათა მაგია ამოძრავდეს.
• დარწმუნდით, რომ დააკვირდით კონდენსატორის პოლარობას მისი შედუღების დროს. თუ თქვენ დააბრუნებთ პოზიტიურ და უარყოფით მიმართულებებს, კონდენსატორი სავარაუდოდ გამოუშვებს ჯადოსნურ კვამლს და თქვენს წრეს სამუდამო ძილში ჩააგდებს.
• დააწებეთ, დააწებეთ და ან დააწებეთ ბატარეის დამჭერი და PCB (ები) ადგილზე. ის არ უნდა იყოს სისუფთავე, რადგან ის არ იქნება მხედველობაში. ეს უბრალოდ უნდა იყოს მტკიცებულება.

გადადით პროგრამულ უზრუნველყოფაზე!

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

დარწმუნდით, რომ გაქვთ უახლესი (უფასო) Arduino პროგრამული უზრუნველყოფის რედაქტორი, რომლის გადმოწერა შეგიძლიათ https://www.arduino.cc/en/Main/Software. Wemos D1 mini- ისა და ESP8266 დაფუძნებული დაფების მხარდაჭერის დასამატებლად, გადადგით შემდეგი ნაბიჯები:

• ინსტალაციის შემდეგ, დაიწყეთ Arduino პროგრამული უზრუნველყოფა და გახსენით პარამეტრების ფანჯარა.
• შეიყვანეთ https://arduino.esp8266.com/stable/package_esp8266com_index.json "დამატებითი დაფის მენეჯერის URL" ველში. თქვენ შეგიძლიათ დაამატოთ მრავალი URL, გამოყავით ისინი მძიმეებით.
• გახსენით დაფების მენეჯერი ინსტრუმენტებიდან> დაფის მენიუდან და დააინსტალირეთ esp8266 პლატფორმა (და არ დაგავიწყდეთ ინსტალაციის შემდეგ შეარჩიოთ თქვენი ESP8266 დაფა ინსტრუმენტებიდან> დაფის მენიუდან. "LOLIN (WEMOS) D1 R2 & mini" საუკეთესოდ მუშაობს Wemos D1 mini v2 და v3 დაფები.

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

Arduino– ს რედაქტორში გახსენით ახალი ფაილი (ფაილი> ახალი) და დააკოპირეთ/ჩასვით ქვემოთ მოცემული კოდი ახლახანს გახსნილ ფანჯარაში. უბრალოდ გადაწერეთ ხაზები, რომლებიც უკვე არის ახალ ფანჯარაში (void setup და void loop).

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

პირველი რაც უნდა გააკეთოთ არის 34 -ე ხაზის ip მისამართის შეცვლა (Arduino– ს რედაქტორში კოდის რიცხვები დანომრილია) თქვენი Hue ხიდის ip მისამართში. თუ არ იცით თქვენი Hue Bridge IP მისამართი, ეწვიეთ https://discovery.meethue.com/ და სწორი IP მისამართი ის დაუყოვნებლივ გამოჩნდება თქვენს ბრაუზერში. IP მისამართი არის წერტილოვანი ნომერი, რომელსაც წინ უძღვის "შიდა მისამართი".

Hue ნათურებთან კომუნიკაციისთვის, თქვენ უნდა შექმნათ Hue API მომხმარებელი Wemos D1 mini– სთვის, ასე რომ Wemos– ს შეუძლია დაუკავშირდეს Hue შუქს Hue API– ს საშუალებით. ამისათვის მიჰყევით ინსტრუქციას https://developers.meethue.com/develop/get-started-2/ და დააკოპირეთ/ჩასვით გენერირებული (საკმაოდ გრძელი) მომხმარებლის სახელი Arduino კოდის ფანჯარაში. უბრალოდ შეცვალეთ ყველა "YOUR HUE API USERNAME" გენერირებული API მომხმარებლის სახელით.

შემდეგ თქვენ უნდა აირჩიოთ სწორი Hue შუქი ფერის შესაცვლელად. Hue API– ში ყველა შუქს აქვს ნომერი, ასე რომ თქვენ უნდა გაარკვიოთ ის რიცხვი, რომელიც შეესაბამება იმ შუქს, რომლის გამოყენებაც გსურთ ამ პროექტისთვის. ერთ -ერთი ყველაზე მარტივი გზა იმის გასარკვევად, თუ რომელი რიცხვი აქვს კონკრეტულ შუქს, არის ჩამოტვირთოთ Hue Viewer აპლიკაცია Android ან iOS- ისთვის. შეცვალეთ ტექსტი "YOUUR LIGHT NUMBER" სწორი ნომრით Arduino კოდის ფანჯარაში ყველგან.

ბოლო რაც უნდა გააკეთოთ არის დააყენოთ Wemos თქვენს wifi ქსელთან დასაკავშირებლად. ეს კეთდება Wemos– ის კოდის ატვირთვით და თქვენს ლეპტოპზე გადადით სხვა wifi ქსელში: „AutoConnectAP“- ზე. თქვენი ბრაუზერი აჩვენებს გვერდს, სადაც შეგიძლიათ დაამატოთ თქვენი wifi ქსელის SSID (სახელი) და პაროლი, რომელსაც Wemos კონტროლერი გამოიყენებს თქვენს wifi ქსელთან დასაკავშირებლად (და Hue ხიდი).

შენიშვნა: თუ კოდის ატვირთვა ჩვენს Wemos D1 mini– ზე USB– ის საშუალებით არ მუშაობს, შეიძლება დაგჭირდეთ დრაივერის ჩამოტვირთვა USB ჩიპისთვის Wemos– ზე. დრაივერი თქვენი პლატფორმისთვის (Windows, Mac) შეგიძლიათ ჩამოტვირთოთ

ახლა თქვენ მზად ხართ შეამოწმოთ თქვენი შემოქმედება!

// ESP8266 Hue Magic Wand // Richard van Kampen - 2018 // ეს კოდი შემოწმებულია Wemos D1 mini– ზე, მაგრამ ალბათ ასევე იმუშავებს სხვა ESP8266 დაფუძნებულ განვითარების დაფებზე // Wemos D1 mini– ს და სხვა ESP8266 დაფების მხარდაჭერის დასამატებლად Arduino– ს რედაქტორთან მიმართეთ შემდეგ ნაბიჯებს: // - დაიწყეთ Arduino და გახსენით Preferences ფანჯარა. // - შეიყვანეთ https://arduino.esp8266.com/stable/package_esp8266com_index.json დამატებითი დაფის მენეჯერის მისამართების ველში. თქვენ შეგიძლიათ დაამატოთ მრავალი URL, გამოყავით ისინი მძიმეებით. // - გახსენით დაფების მენეჯერი ინსტრუმენტებიდან> დაფის მენიუდან და დააინსტალირეთ esp8266 პლატფორმა (და არ დაგავიწყდეთ თქვენი ESP8266 დაფის არჩევა ინსტრუმენტებიდან> დაფის მენიუ ინსტალაციის შემდეგ). // გამოყენებული ბიბლიოთეკები: #მოიცავს "ESP8266WiFi.h" // ESP8266 ძირითადი WiFi ბიბლიოთეკა #მოიცავს "DNSServer.h" // ადგილობრივი DNS სერვერი გამოიყენება ყველა მოთხოვნის გადამისამართებისთვის WiFiManager კონფიგურაციის პორტალზე, თუ WIFI პარამეტრები (SSID, პაროლი) არ აქვს ჯერ არ არის დადგენილი #მოიცავს "ESP8266WebServer.h" // ადგილობრივი ვებ სერვერი, რომელიც ემსახურებოდა WiFiManager კონფიგურაციის პორტალს #მოიცავს "WiFiManager.h" // WiFi კონფიგურაციის ჯადოსნური ბიბლიოთეკა, თუ ჯერ კიდევ არ არის დაინსტალირებული მიმართეთ https://github.com/tzapu/WiFiManager #install-through-ბიბლიოთეკის მენეჯერი #მოიცავს "RestClient.h" // https://github.com/fabianofranca/ESP8266RestClient, საჭიროა Philips Hue API- ს გამოსაყენებლად (იხ. https://developers.meethue.com/develop/ ტონი-აპი/). #მოიცავს "ArduinoJson.h" // https://github.com/bblanchon/ArduinoJson, საჭიროა Hue API პასუხის გაანალიზება, გთხოვთ დააინსტალიროთ 5.x ვერსია ბიბლიოთეკის მენეჯერის მეშვეობით Arduino– ში (მენიუ "ესკიზი"> ბიბლიოთეკის ჩართვა> მართვა ბიბლიოთეკები> მოძებნეთ ArduinoJson და შეცვალეთ ვერსია უახლესი 5.x). ვერსია 6 (ამჟამად ბეტაშია) შეცდომას უშვებს. // ცვლადები და init: სიმებიანი პასუხი; const int redPin = 13; // Wemos– ზე ეს არის d7 const int greenPin = 12; // Wemos– ზე ეს არის d6 const int bluePin = 14; // Wemos– ზე ეს არის d5 const int touch სენსორი = 5; // Wemos– ზე ეს არის d1 const int გააქტიურებაPin = 4; // Wemos– ზე ეს არის d2 bool გააქტიურება = HIGH; bool touch = LOW; const char* aan_restore; int bri_restore; ორმაგი x_restore; ორმაგი y_restore; ორმაგი x_magic; ორმაგი y_magic; bool first = true; ხელმოუწერელი ხანგრძლივი სტარტი მილი; ხელმოუწერელი გრძელი მიმდინარემილისი; ხელმოუწერელი ხანგრძლივობის მილი; RestClient client = RestClient ("192.168.178.23"); // "თქვენი Hue Bridge IP მისამართი" // თუ არ იცით თქვენი Hue Bridge IP მისამართი, ეწვიეთ https://discovery.meethue.com და ის დაუყოვნებლივ გამოჩნდება თქვენს ბრაუზერში. IP მისამართი არის წერტილოვანი ნომერი, რომელსაც წინ უძღვის "interioripaddress" void setup () {analogWriteRange (255); სერიული.დაწყება (9600); // დაიწყეთ გამორთული LED- ით. pinMode (აქტივაციის PIN, INPUT_PULLUP); pinMode (touchSensor, INPUT); startMillis = millis (); checkWand (); } void loop () {// არაფერია გასაკეთებელი, დატოვე ცარიელი…} void checkWand () {int rgbColour [3]; // ჯეიმს ჰარტონის RGB ფერის კოდი, https://gist.github.com/jamesotron/766994 // დაიწყეთ წითელით. rgbColour [0] = 255; rgbColour [1] = 0; rgbColour [2] = 0; გააქტიურება = digitalRead (activationPin); // LOW ნიშნავს კვერთხის გამოყენებას. touch = digitalRead (touchSensor); // HIGH ნიშნავს, რომ თითი გამოიყენება კვერთხის ნაცვლად, რაც ასე არ უნდა იყოს. while (გააქტიურება == LOW && შეხება == LOW) {// აირჩიეთ ფერები გაზრდისა და შემცირებისათვის. for (int decColour = 0; decColour <3; decColour += 1) {int incColour = decColour == 2? 0: decColour + 1; // = სამმაგი ოპერატორი, ნიშნავს: int incColour; if (decColour == 2) {incColour = 0;} else {incColour = decColour +1;} // გადაკვეთეთ ორი ფერი for (int i = 0; i <255; i += 1) {rgbColour [decColour] -= 1; rgbColour [incColour] += 1; // როგორც ჩვენს RGB led- ს აქვს კათოდის ნაცვლად საერთო ანოდი (ასე რომ, ჩვენ გვჭირდება დაკავშირება +3.3V მიწასთან ნაცვლად), ჩვენ გვჭირდება RGB– ის ინვერსიული მნიშვნელობები: int red = 255 - rgbColour [0]; მწვანე მწვანე = 255 - rgb ფერი [1]; int ლურჯი = 255 - rgb ფერი [2]; analogWrite (redPin, წითელი); analogWrite (greenPin, მწვანე); analogWrite (bluePin, ლურჯი); დაგვიანება (8); გააქტიურება = digitalRead (activationPin); if (გააქტიურება == HIGH) {// HIGH ნიშნავს კვერთხის მოხსნას. goto stopColorCycling; }}}} stopColorCycling: currentMillis = millis (); durationMillis = (მიმდინარეMillis - startMillis); if (ხანგრძლივობა Milis> 1000) {RGBtoxy (rgbColour [0], rgbColour [1], rgbColour [2]); } else {// დააყენეთ Wemos ძილის რეჟიმში: ESP.deepSleep (0); }} void RGBtoxy (int წითელი, მწვანე მწვანე, ლურჯი) {// იხილეთ https://developers.meethue.com/documentation/color-conversions-rgb-xy ორმაგი R = რუკა (წითელი, 0, 255, 0, 1000); რ /= 1000; ორმაგი G = რუკა (მწვანე, 0, 255, 0, 1000); გ /= 1000; ორმაგი B = რუკა (ლურჯი, 0, 255, 0, 1000); B /= 1000; R = (R> 0.04045f)? ძალა ((R + 0.055f) / (1.0f + 0.055f), 2.4f): (R / 12.92f); G = (G> 0.04045f)? ძალა ((G + 0.055f) / (1.0f + 0.055f), 2.4f): (G / 12.92f); B = (B> 0.04045f)? ძალა ((B + 0.055f) / (1.0f + 0.055f), 2.4f): (B / 12.92f); ორმაგი X = R * 0.649926f + G * 0.103455f + B * 0.197109f; ორმაგი Y = R * 0.234327f + G * 0.743075f + B * 0.022598f; ორმაგი Z = R * 0.0000000f + G * 0.053077f + B * 1.035763f; ორმაგი x = X / (X + Y + Z); ორმაგი y = Y / (X + Y + Z); // კონვერტაცია სრულად არ დასრულებულა, მაგრამ ალბათ საკმარისად კარგი იმისთვის, რისი მიღწევაც გვინდა, ასე რომ დატოვეთ ეს და გამოაგზავნეთ XY მნიშვნელობები ნათურაზე: sendtoHue (x, y); } void sendtoHue (ორმაგი a, ორმაგი b) {// ფაქტობრივი ფერის შეცვლა კვერთხის მაგიიდან, თუ (პირველი) {// პირველი გავლა: მიიღეთ ნათურის ამჟამინდელი მდგომარეობა getCurrentValues (); } // შემდეგ გააგზავნე ჯადოსნური ჯოხის ფერები: // დაელოდე შელოცვა: დიდხანს დაელოდე; x_magic = a; y_magic = b; // ნათურა ჯადოსნური ჯოხის ფერით: რეაქცია = ""; int temp = შემთხვევითი (2, 9); const char* მდგომარეობა = "ჭეშმარიტი"; for (int i = 1; i <= temp; i ++) {// შექმნა char მასივი, რათა გამოგზავნოთ ხიდი: String temp_body1 = "{" on / ":" + String (state) + ", \" bri / ": 220, / "xy \": [" + სიმებიანი (x_magic) +", " + სიმებიანი (y_magic) +"], / "გადასვლის დრო \": 1} "; int str_len1 = temp_body1.length () + 1; char post_body1 [str_len1]; temp_body1.toCharArray (post_body1, str_len1); // ახლა ჩვენ გვაქვს post_body1 როგორც char მასივი; // დასვენების ზარის განხორციელება: int statusCodePut1 = client.put ("/api/YOUR HUE API USERNAME/lights/YOUR LIGHT NUMBER/state", post_body1, & answer); ლოდინი = შემთხვევითი (100, 600); დაგვიანება (ლოდინი); if (მდგომარეობა == "ჭეშმარიტი") {მდგომარეობა = "ყალბი"; } else {state = "true"; }} // შეამცირეთ სიკაშკაშე …: რეაქცია = ""; temp = შემთხვევითი (4, 17); // შექმნა char მასივი, რათა გამოაგზავნოთ ხიდი: String temp_body2 = "{" on / ": true, \" bri / ": 154, \" გარდამავალი დრო / ":" + სიმებიანი (temp) + "}"; int str_len2 = temp_body2.length () + 1; char post_body2 [str_len2]; temp_body2.toCharArray (post_body2, str_len2); // ახლა ჩვენ გვაქვს post_body2 როგორც char მასივი; // დაისვენე ზარი: int statusCodePut2 = client.put ("/api/YOUR HUE API USERNAME/lights/YOUR LIGHT NUMBER/state", post_body2, & answer); ლოდინი = შემთხვევითი (1000, 2500); დაგვიანება (ლოდინი); //.. და კვლავ გახადე ნათელი: პასუხი = ""; temp = შემთხვევითი (4, 17); // შექმენით char მასივი, რომ გაიგზავნოთ ხიდი: String temp_body3 = "{" bri_inc / ": 100, \" გარდამავალი დრო / ":}"; int str_len3 = temp_body3.length () + 1; char post_body3 [str_len3]; temp_body3.toCharArray (post_body3, str_len3); // ახლა ჩვენ გვაქვს post_body3 როგორც char მასივი; // დასვენების ზარის განხორციელება: int statusCodePut3 = client.put ("/api/YOUR HUE API USERNAME/lights/YOUR LIGHT NUMBER/state", post_body3, & answer); ლოდინი = შემთხვევითი (2500, 5000); // დაელოდეთ 2-5 წამი დაგვიანებით (დაელოდეთ); // და დაუბრუნდით ძველ მნიშვნელობას: პასუხი = ""; // შექმნა char მასივი, რათა გამოაგზავნოთ ხიდი: String temp_body4 = "{" on / ":" + String (aan_restore) + ", \" bri / ":" + String (bri_restore) + ", \" xy / ": [" + სიმებიანი (x_restore) +", " + სიმებიანი (y_restore) +"], / "გარდამავალი დრო \": " + სიმებიანი (20) +"} "; int str_len4 = temp_body4.length () + 1; char post_body4 [str_len4]; temp_body4.toCharArray (post_body4, str_len4); // ახლა ჩვენ გვაქვს post_body4 როგორც char მასივი; // დასვენების ზარის განხორციელება: int statusCodePut4 = client.put ("/api/YOUR HUE API USERNAME/lights/YOUR LIGHT NUMBER/state", post_body4, & answer); ESP.deepSleep (0); // ისევ დასაძინებლად… } unsigned int getCurrentValues () {connectWifi (); // პირველი დაკავშირება Wifi პასუხთან = ""; // დასვენების ზარის განხორციელება: int statusCodeGet = client.get ("/api/YOUR HUE API USERNAME/lights/YOUR LIGHT NUMBER", & answer); Serial.print ("სტატუსის კოდი სერვერიდან GET- ის შემდეგ:"); Serial.println (statusCodeGet); Serial.print ("პასუხის ორგანო სერვერიდან:"); Serial.println (პასუხი); StaticJsonBuffer jsonBuffer; // ჯსონის პასუხის გაანალიზება // ობიექტის ხის ფესვი. // // ეს არის მითითება JsonObject– ზე, ფაქტობრივი ბაიტები // jsonBuffer– ის შიგნით არის ობიექტის ხის ყველა სხვა კვანძთან ერთად. // მეხსიერება თავისუფლდება, როდესაც jsonBuffer გადის ფარგლებს გარეთ. JsonObject & root = jsonBuffer.parseObject (პასუხი); JsonObject & state = root ["state"]; // ტესტირება თუ წარმატებული იქნება ანალიზი. if (! root.success ()) {Serial.println ("parseObject () ვერ მოხერხდა"); } // მნიშვნელობების მიღება. aan_restore = მდგომარეობა ["ჩართული"]; Serial.println (aan_restore); bri_restore = მდგომარეობა ["bri"]; x_restore = მდგომარეობა ["xy"] [0]; y_restore = მდგომარეობა ["xy"] [1]; პირველი = ყალბი;} void connectWifi () {// ლოკალური ინტიალიზაცია.მას შემდეგ რაც დასრულდება მისი ბიზნესი, არ არის საჭირო მისი შენარჩუნება WiFiManager wifiManager– ის გარშემო; // პარამეტრების გადატვირთვა - ტესტირებისთვის: //wifiManager.resetSettings (); // დააყენეთ გამოძახება, რომელიც წინა WiFi– თან დაკავშირებისას იძახება და ვერ ხერხდება და შედის წვდომის წერტილის რეჟიმში wifiManager.setAPCallback (configModeCallback); // იძენს ssid და pass და ცდილობს დაკავშირებას // თუ არ აკავშირებს იწყებს წვდომის წერტილს მითითებული სახელით // აქ "AutoConnectAP" // და გადადის ბლოკირების მარყუჟში ელოდება კონფიგურაციას თუ (! wifiManager.autoConnect ()) {Serial.println ("დაკავშირება ვერ მოხერხდა და დროის გასვლა მოხდა"); // გადატვირთეთ და სცადეთ ხელახლა, ან იქნებ ჩაწეროთ ღრმა ძილში ESP.reset (); დაგვიანება (1000); } // თუ აქ მოხვედით დაუკავშირდით WiFi Serial.println ("დაკავშირებულია … ჰო:)"); Serial.print ("დაკავშირებულია:"); Serial.println (WiFi. SSID ()); Serial.print ("IP მისამართი:"); Serial.println (WiFi.localIP ()); // თქვენი ESP (Wemos) მინიჭებული IP მისამართი // დაბეჭდეთ მიღებული სიგნალის სიძლიერე: long rssi = WiFi. RSSI (); Serial.print ("სიგნალის სიძლიერე (RSSI):"); Serial.println (rssi); } void configModeCallback (WiFiManager * myWiFiManager) {Serial.println ("კონფიგურაციის რეჟიმში შესული"); Serial.println (WiFi.softAPIP ()); // თუ თქვენ იყენებთ ავტომატურად გენერირებულ SSID- ს, დაბეჭდეთ Serial.println (myWiFiManager-> getConfigPortalSSID ()); }