Milzu gaismas diode - Ādama Savage izsekošana: 13 soļi (ar attēliem)

2024 Autors: John Day | [email protected]. Pēdējoreiz modificēts: 2024-01-30 10:54

Šeit jūs atradīsit milzu gaismas diodes atveidojumu, kas paredzēts, lai darbotos kā Twitter, YouTube un Twitch brīdinājuma lampiņa. Man galvenais mērķis ir sniegt brīdinājumu, kad ir Ādama Savage un pārbaudītās komandas tvīti, videoklipi vai raustīšanās straumes, un godīgi sakot, pāris citi cilvēki, kuriem sekoju, piemēram, Roberts Kovans, Mārtiņš Mehāniķis un citi.

Acīmredzot es savā tālrunī vai klēpjdatorā varētu izmantot twitter, twitch utt., Bet no tik daudziem pakalpojumiem un paziņojumiem ir tik daudz brīdinājumu, ka es tos visus izslēdzu, kā arī tālrunis pāriet klusuma režīmā pēc 22:00, jo tas darbosies arī ar Man ir arī Webhooks, kas ir konfigurēts, lai saņemtu atjauninājumus no dažām Biq Query tabulām, kas ir saistītas ar darbu, lai informētu mani, vai tās ir atjauninātas ar pietiekamu ierakstu skaitu katru dienu.

Adafruit ir pakalpojums ar nosaukumu Adafruit IO, kuru es gribēju izmēģināt, un visu gadu esmu domājis mēģināt risināt ESP8266, dzirdot dažus labus vārdus par Wemos D1 Mini 3. izlaidumu. Tas viss sāka sanākt kopā, kad es atradu Astro73 izstrādāts gaismas diožu dizains. Es sāku ar to un nedaudz pārstrādāju to mērogā, kā arī pievienoju spiedpogu pamatnei un dažas citas kosmētiskas izmaiņas. Remiksu varat atrast šeit

Turklāt to tagad var vadīt ar balsi, izmantojot Alexa, kā arī IFTTT alexa sprūda vārda parādīšanās.

1. solis: Sastāvdaļas

Ja vēlaties izveidot vienu no šīm detaļām, detaļu saraksts ir diezgan mazs un arī lēti. Ja jums nav jāgaida, jūs varat iegādāties galvenās detaļas no ārzemēm, kā arī vēl vairāk samazināt izmaksas. Tomēr galvenā sastāvdaļa ir Giant LED korpuss un pamatne. Ja jums ir 3D printeris, tad viss ir gatavs, ja nē, dažas tiešsaistes printera firmas drukās detaļas. Ir tikai 3, tāpēc arī tiem jābūt diezgan lētiem.

1. Wemos D1 Mini R3

2. Neopixel 8 LED

3. Apdrukāta pamatne un kājas melnā PETG krāsā

4. Iespiests objektīvs un gaismas turētājs caurspīdīgā PLA

5. Spiedpogas slēdzis 12 mm kvadrāts x1

6. Apaļa spiedpogas uzgalis x1

7. USB vads un adapteris barošanai

8. Pogas galva M3x20

9. M3 Rieksts

10. M2x8mm skrūve x2

11. M2 uzgrieznis x2

12. Daži melni, sarkani un dzelteni vadi

13. 300-500 omu rezistors

14. Neliels gaiss

Jūs varat izmantot citas ESP ierīces vai pat Huzzah, taču korpuss ir paredzēts mini, kuram ir montāžas atveres un nav nepieciešams to pielīmēt.

2. darbība: rīki

Lai to izveidotu un izveidotu, jums būs nepieciešams

1. 3D printeris

2. 1,5 mm un 2 mm sešstūra atslēga

3. Lodāmurs un lodētava

4. Raidītāji

5. knaibles

6. Humora izjūta

7. Skalpelis apgriešanai

3. darbība. Prasības kodam

Tāpēc, pirms mēs iedziļināmies būvē, es izklāstīšu dažas prasības, kuras es vēlējos tajā iekļaut. Lielāko daļu no tiem es biju domājis pirms darba uzsākšanas, un es ieskicēju dažas plūsmas, lai noskaidrotu, ko es izmēģināšu. Turpinot, es atklāju dažas problēmas ar pakalpojumiem, kurus vēlējos risināt.

Prasības.

Es gribēju, lai gaismas diode man rādītu, kad tika ievietots jauns tvīts vai videoklips, kā arī izrādās, kad tiek palaists īpašs Twitch kanāls. Es arī vēlējos, lai brīdinājums tiktu turpināts, līdz es to atceltu, lai, ja es kādu laiku būtu prom, es zinātu, kas noticis, kamēr biju prom. Es arī vēlējos, lai tas būtu konfigurējams Wi-Fi piekļuvei, nepārspīlējot arī programmatūru. Pēdējā lieta, kas parādījās arī papildus atbildes sniegšanai uz notikumiem tiešraidē, man bija nepieciešama, lai ik pēc 15 minūtēm pārbaudītu tai ievadīto datu statusu

Līdz ar pamatiem, nākamā lieta bija noskaidrot, kā katra daļa tiks izpildīta. Tālāk varat redzēt manas idejas par to, kura daļa tiktu apstrādāta ar kāda veida programmatūru vai platformu.

1. Adafruit IO, to izmanto, lai iestatītu brīdinājumu plūsmas, kontu varat iegūt šeit

Es to izmantošu kā ziņojumu rindas pakalpojumu, kur es nosūtīšu tam ziņojumus no IFTTT, un pēc tam Giant LED saņem šos ziņojumus, lai tas varētu uz tiem iedarboties.

2. IFTTT, https://ifttt.com/ un tas tiek izmantots, lai skenētu izvēlētos Twitter, YouTube un Twitch kanālus un pēc tam nosūta notikumu Adafruit IO

3. ESP8266 kods, lai lasītu šīs plūsmas, un tas tiek ierakstīts ESP8266, izmantojot standarta Arduino IDE (v1.8.8)

4. Arduino kods, ielādēts ESP8266, lai lasītu Adafruit IO plūsmas un iedegtu Neopixel

5. Arduino kods, lai nolasītu spiedpogu, lai notīrītu brīdinājumu

6. Esiet spējīgs konfigurēt WiFi adapteri bez ESP atkārtotas ierakstīšanas, un tam es izmantoju Tzapu WiFi pārvaldnieka bibliotēku, https://github.com/tzapu/WiFiManager, lai gan iestatīšanas opcijās bija jāveic nelielas izmaiņas, lai pielāgotos Adafruit IO bibliotēkas.

4. darbība. Adafruit IO iestatīšana

Šis ir pirmais solis, jo jums būs nepieciešamas šeit izveidotās piekļuves atslēgas, kā arī jāizveido plūsmas, uz kurām IFTTT nosūtīs notikumus. Jūs varat izveidot gan šo, gan IFTTT kontu un gandrīz visu nokārtot un strādāt, pirms pāriet uz šī projekta Arduino daļu.

Tā vietā, lai kopētu adafruit piemērus, pamatus varat atrast šeit https://learn.adafruit.com/gmailbox/adafruit-io-se…, kas ļaus jums iestatīt.

Tad GIANT gaismas diodei arī būs jāpievieno noklusējuma kanāliem šādas plūsmas

1. krāsa - tas ļauj mums attālināti mainīt krāsu, izmantojot kaut ko līdzīgu Alexa

2. raustīšanās

3. twitterfan

4. youtubefan

Tad jums arī jāizveido jauna grupa, ja vēl neesat izsaucis ievadi, tad šajā grupā izveidojiet arī plūsmu ar nosaukumu digitālā. Tas ļaus mums redzēt arī pogas nospiešanas efektu, ja vēlējāmies paplašināt šīs ierīces izmantošanu citiem mērķiem.

Ja jūs arī vēlaties šajā brīdī spēlēt ar informācijas paneli, lai jūs varētu pievienot šīs plūsmas informācijai un kļūdu meklēšanai.

5. darbība. IFTTT iestatīšana

Varat arī sekot Adafruit ceļvedim šeit, https://learn.adafruit.com/gmailbox/ifttt-setup. Pēc tam varat atlasīt Twitter, YouTube un twitch darbības, lai iestatītu savus skatīšanās sarakstus, un pēc tam tos nosūtīt uz attiecīgajām plūsmām. Es pievienoju vienkāršu video, lai jūs varētu redzēt, cik ātri tas var notikt.

Turklāt, ja vēlaties ar balsi vadīt Alexa LED krāsu, tagad ir Amazon Alexa sīklietotne. Lai iestatītu vienu no šiem, atlasiet lietotni un izvēlieties vārdu zils, pēc tam pievienojiet to Adafruit plūsmai, kuru esat iestatījis, ko sauc par krāsu, un ievadiet 0000ff kā datus, kas jānosūta uz šo kanālu. Jūs varētu arī nodot papildu komandas GIANT LED, piemēram, atiestatīt vai pārstartēt, ja vēlaties.

Iestatot IFTTT aktivizētāju, jums jāizvēlas nosūtītie dati, un to IFTTT sauc par "sastāvdaļām". Pirmais gabals, kas mums nepieciešams, ir “Lietotājvārds”, pēc tam atstarpe un pēc tam “CreatedAt”

Mēs izvēlamies abus vienumus, lai, kad dati nonāk ESP8266, mēs varētu noteikt, vai tas ir jauns tvīts un vai tas atšķiras no iepriekšējiem to pašu lietotāju tvītiem. Jūs varat redzēt, kas tam vajadzētu patikt no pievienotā attēla.

6. darbība: ESP8266 dēļu uzstādīšana Arduino IDE

Šeit lietas ir nedaudz sarežģītākas, un to sakārtošana var aizņemt nedaudz vairāk laika. Papildus ESP8266 jums ir nepieciešamas arī Adafruit IO bibliotēkas, un jūs varat sekot šai rokasgrāmatai.

learn.adafruit.com/gmailbox/arduino-setup

Šeit ir arī vienkāršs skaidrojums, kā pievienot ESP8266 plates

Neaizmirstiet pārliecināties, vai jūsu Arduino IDE ir arī jaunākā versija, un šī raksta laikā es izmantoju 1.8.8.

Vēl viena mūsu izmantotā bibliotēka ir SimpleTimer, jo tas ļaus mums iestatīt fona taimeri, lai mēs varētu periodiski pārbaudīt plūsmas, norādījumus par to var atrast vietnē Simpletimer https://playground.arduino.cc/Code/SimpleTimer# Lejupielādēt

7. darbība: WiFi pārvaldnieka bibliotēkas instalēšana

Lai mēs varētu iegūt WiFi iestatīšanas attālo konfigurāciju, mēs izmantosim Tzapu Wifi Manger, sīkāku informāciju par to un to, kā instalēt bibliotēkas, varat atrast šeit, github.com/tzapu/WiFiManager

Šī ir diezgan vienkārša ārējo bibliotēku instalēšana, un šī opcija jau ir jūsu Arduino IDE rīku sadaļas Bibliotēkas pārvaldība sadaļā.

8. solis: ESP8266 kods - ar atkļūdošanas drukāšanu

// Šis kods satur drukas paziņojumus, lai jūs varētu pārraudzīt tā darbību, izmantojot seriālo monitoru

// Pamatojoties uz Adafruit IO RGB LED izvades piemēru // Adafruit iegulda laiku un resursus, nodrošinot šo atvērtā pirmkoda kodu. // Lūdzu, atbalstiet Adafruit un atvērtā pirmkoda aparatūru, iegādājoties // produktus no Adafruit! // // Autors: Todd Treece, Adafruit Industries // Autortiesības (c) 2016-2017 Adafruit Industries // Licencēts saskaņā ar MIT licenci. // // Viss iepriekš minētais teksts ir jāiekļauj jebkurā pārdalē. // izmanto vienkāršo taimeri https://playground.arduino.cc/Code/SimpleTimer#Do… // https://playground.arduino.cc/Code/SimpleTimer#Do… // pārējais Ajax Jones kods https:// rotaļlaukums.arduino.cc/Code/SimpleTimer#Do // https://playground.arduino.cc/Code/SimpleTimer#Do… // ******************* ******* konfigurācija **********************************/ #define IO_USERNAME "jūsu IO Lietotājvārds "#define IO_KEY" jūsu IO atslēga "// atstājiet tukšu, jo mēs tos iegūsim, izmantojot Wifi pārvaldnieku. Šķiet, ka tas darbojas labi šādā veidā #define WIFI_SSID" "#define WIFI_PASS" "// mēs to neiekļaujam kā AdafruitIO iekļaut tā versiju // #include //https://github.com/esp8266/Arduino // nepieciešama bibliotēkai #include #include #include "WiFiManager.h" //https://github.com/tzapu/WiFiManager # iekļaut SimpleTimer taimeri; #include "AdafruitIO_WiFi.h" AdafruitIO_WiFi io (IO_USERNAME, IO_KEY, WIFI_SSID, WIFI_PASS); // ************************ NeoPixel konfigurācijas ********************** ********* // #include "Adafruit_NeoPixel.h" #define PIXEL_PIN 5 #define PIXEL_COUNT 8 int NUM_LEDS = PIXEL_COUNT; #define PIXEL_TYPE NEO_GRB + NEO_KHZ800 Adafruit_NeoPixel pixels = Adafruit_NeoPixel (PIXEL_COUNT, PIXEL_PIN, PIXEL_TYPE); // Galvenās krāsas un noklusējuma krāsa ilgi default_color = 865554; garš RED_color = 2689027; // sarkans #290803 garš GREEN_color = 865554; // zaļš #0d3512 garš BLUE_color = 856117; // zils #0d1035 garš PURPLE_color = 2364968; // violets #241628 garš BRIGHTRED_color = 15990784; // spilgti sarkans #f40000 // ------------------------------------------ ----------------------------------------------- //laiks ideja ņemta no https://www.safaribooksonline.com/library/view/arduino-cookbook-2nd/9781449321185/ch12.html https://playground.arduino.cc/Code/SimpleTimer#Do… https:// rotaļu laukums. arduino.cc/Code/SimpleTimer#Do… const long oneSecond = 1000; // sekunde ir tūkstoš milisekundes konst garš viensMinute = oneSecond * 60; const ilgi piecas minūtes = viena minūte * 5; const garš piecpadsmit minūtes = piecas minūtes * 3; const long oneHour = piecpadsmit minūtes * 4; // Twitter lietotāji, kuri mums patīk visvairāk, un tie mirgos, un visi citi mūsu izvēlētie tvīti vienkārši mainīs krāsu String SuperTweet = {"ajaxjones", "donttrythis", "prodnose", "testcom"}; Stīgu SuperTuber = {"pārbaudīts", "cowan", "marty"}; // iestata brīdinājuma statusu, lai mēs varētu turpināt mirgot gaismas diodes galvenajā cilpas boolā WHIZZY_TWEET = false; bool WHIZZY_TUBER = nepatiess; bool WHIZZY_TWITCH = nepatiess; // Saglabā pēdējo tvītu un youtube, lai mēs ik pa brīdim varētu pārbaudīt pakalpojumu, lai vēlreiz pārbaudītu String lasttweet = ""; String lasttube = ""; String lasttwitch = ""; // digitālā tapa 5, šī ir poga, ko mēs izmantojam, lai atiestatītu brīdinājuma krāsas #define BUTTON_PIN 4 // pogas stāvoklis, kas nav īsti izmantots, jo mēs meklējam pogu uz pārtraukuma bool current = false; bool last = nepatiess; // iestatiet "krāsu" plūsmu, lai mēs varētu pēc pieprasījuma pārbaudīt un nosūtīt krāsas vai izmantot Alexa trigeri AdafruitIO_Feed *color = io.feed ("krāsa"); // iestatīt 'twitterfan' plūsmu - Blue AdafruitIO_Feed *twitter = io.feed ("twitterfan"); // iestatīt plūsmu 'youtubefan' - Red AdafruitIO_Feed *youtube = io.feed ("youtubefan"); // iestatīt 'twitch' plūsmu - Purple AdafruitIO_Feed *twitch = io.feed ("twitch"); // iestatīt 'digitālo' plūsmu AdafruitIO_Feed *digital = io.feed ("input.digital"); // ------------------------------------------------ ---------------------------------------- void setup () {// iestatiet pogas tapu kā ievadi, mēs izmantojam INPUT_PULLUP, jo mums nav jāizmanto ārējie rezistori pinMode (BUTTON_PIN, INPUT_PULLUP); // Pievienojiet ISR vektoram pārtraukumu pogai attachInterrupt (digitalPinToInterrupt (BUTTON_PIN), handleInterrupt, FALLING); // Sāciet sēriju un gaidiet, līdz tiek atvērts seriālais monitors, pēc tam izveidojiet savienojumu ar io.adafruit.com Serial.begin (115200); kamēr (! Seriāls); // neopikseļu sākuma pikseļi.begin (); // Iestatiet sākotnējo stāvokli sarkanā krāsā, lai mēs zinātu, ka esam bezsaistē un strādājam setAll (0xf4, 0x00, 0x00); // sarkans // testēšanai tas parādīs WiFi WiFi statusu.printDiag (Serial); WiFiManager wifiManager; // iestatīt atzvanīšanu, kas tiek izsaukts, izveidojot savienojumu ar iepriekšējo WiFi, neizdodas, un nonāk piekļuves punkta režīmā wifiManager.setAPCallback (configModeCallback); // atiestatīt saglabātos iestatījumus, un komentēt šo nākamo rindu, lai piespiestu pārbaudīt WiFi pārvaldnieku, lai varētu izveidot savienojumu // izmantojot tālruni vai planšetdatoru, lai meklētu parādāmo Giant LED tīklu //wifiManager.resetSettings (); // nosaka taimautu, līdz konfigurācijas portāls tiek izslēgts // noderīgs, lai to visu mēģinātu vēlreiz vai pārietu gulēt // sekundēs wifiManager.setTimeout (240); if (! wifiManager.autoConnect ("GIANT LED")) {Serial.println (F ("neizdevās izveidot savienojumu un nokļūt taimautā")); // atiestatīt un mēģināt vēlreiz kavēšanās (3000); ESP.reset (); kavēšanās (1000); } // pārbaudei mēs varam redzēt, vai mums ir pareizie akreditācijas dati, lai izveidotu savienojumu //Serial.println (WiFi. SSID ()); //Serial.println(WiFi.psk());//WiFi.begin(WIFI_SSID, WIFI_PASS); // while (WiFi.status ()! = WL_CONNECTED) {// delay (500); //Sērijas.druka ("."); //} Serial.println (); Serial.println (F ("WiFi pieslēgts")); Serial.println (F ("IP adrese:")); Serial.println (WiFi.localIP ()); // tagad mēs izveidojam savienojumu ar IO pakalpojumu Serial.print (F ("Savienojuma izveide ar Adafruit IO")); io.connect (); // iestatīt ziņojumu apstrādātāju 'krāsu' plūsmai. color-> onMessage (handleMessage); // iestatīt ziņojumu apstrādātāju plūsmai 'twitterfan'. twitter-> onMessage (twitterMessage); // iestatīt ziņojumu apstrādātāju plūsmai 'youtubefan'. youtube-> onMessage (youtubeMessage); // iestatīt ziņu apstrādātāju plūsmai 'twitch'. twitch-> onMessage (twitchMessage); // gaidīt savienojumu, kamēr (io.status () <AIO_CONNECTED) {Serial.print (F (".")); kavēšanās (500); } // mēs esam savienoti Serial.println (); Serial.println (io.statusText ()); //Serial.println(sizeof(SuperTweet)); //Serial.println(sizeof(SuperTweet[0])); // Izdrukājiet to Twitter kontu sarakstu, kurus mēs gaidām (baits idx = 0; idx <sizeof (SuperTweet) / sizeof (SuperTweet [0]); idx ++) {Serial.print (F ("SuperTweet [")); Sērijas nospiedums (idx); Sērijas.druka ("] = '"); Sērijas nospiedums (SuperTweet [idx]); Serial.println ("" "); } // Izdrukājiet to YouTube kontu sarakstu, kurus mēs gaidām (baits idx = 0; idx get (); // pieprasiet plūsmu esošos stāvokļus, tāpēc jums būs jānospiež atiestatīšana, kad tā sāk darboties youtube -> get (); twitter-> get (); twitch-> get (); jo (int i = 0; i get (); twitter-> get (); twitch-> get (); Serial.print ("iegūt tweets"); Serial.print ("uptime (s):"); Serial.println (millis () / 1000);} // ---------------- -------------------------------------------------- ----------------------- void loop () {// io.run (); ir nepieciešams visām skicēm. io.run (); taimeris. palaist (); ja (WHIZZY_TWEET == true) {RunningLights (0x0d, 0x10, 0x35, 250);} if (WHIZZY_TUBER == true) {RunningLights (0x29, 0x08, 0x03, 250);} if (WHIZZY_TWITCH == true) {RunningLights (0x24, 0x16, 0x28, 250);}}} // --------------------------------- -------------------------------------------------- ------ // iestatiet pārtraukumu, lai notīrītu brīdinājumu, kad tiek nospiesta poga, un pārbaudiet interneta tukšuma rokturiInterrupt () {WHIZZY_TWEET = nepatiesa; WHIZZY_TUBER = nepatiess; WHIZZY_TWITCH = nepatiess; pašreizējais = taisnība; // nosūtīt pašreizējo stāvokli uz adafruit io plūsmu 'input.digital', lai mēs to varētu redzēt digitāli-> save (current); par (int i = 0; i ")); Serial.print (pašreizējais); Serial.print (F (" un noklusējuma krāsa ")); Serial.println (noklusējuma_krāsa); current = false; digitāls-> saglabāt (pašreizējais)); while (WiFi.status ()! = WL_CONNECTED) {delay (500); setAll (0xeb, 0xfb, 0x03); // Yellow ebfb03}} // -------------- -------------------------------------------------- ------------------------- // tas tiek izsaukts ikreiz, kad pienāk "twitter" ziņojums-iestatiet LED uz Blue void twitterMessage (AdafruitIO_Data *dati) {Stīgu tweeter = (dati-> uzString ()); tweeter.toLowerCase (); if ((lasttweet! = Tweeter) && (tweeter! = "")) {Lasttweet = tweeter; setAll (0x0d, 0x10, 0x35); // Iestatiet tvīta zilo krāsu Serial.print (F ("Tweet:")); Serial.print (tweeter); // pārbaudiet, vai nav iecienīts tweeter (baits idx = 0; idx = 0) {// Ļauj izveidot tweets whizzy #0d1035 WHIZZY_TWEET = true; Serial.print ("by"); Serial.print (SuperTweet [idx]);}} Serial.println ("");}} //------ -------------------------------------------------- ---------------------------- // tuber.toLowerCase (); ja ((lasttube! = bumbuļi) && (bumbuļi! = "")) {lasttube = bumbuļi; setAll (0x29, 0x08,0x03); // Iestatīt youtube sarkano krāsu 290803 Serial.print (F ("Youtube:"))); Serial.println (bumbuļi); // pārbaudiet, vai nav iecienīts Youtuber (baits idx = 0; idx = 0) {// Ļaujiet viņu videoklipiem kļūt satriecošiem #0d1035 WHIZZY_TUBER = true; Serial.print ("līdz"); Sērijas nospiedums (SuperTuber [idx]); }} Serial.println (""); }} // ---------------------------------------------- ------------------------------------------- // tas tiek izsaukts ikreiz, kad a pienāk ziņojums “raustīties” - iestatiet gaismas diode uz PURPLE void twitchMessage (AdafruitIO_Data *dati) {String twitch = (dati-> toString ()); twitch.toLowerCase (); ja ((lasttwitch! = twitch) && (twitch! = "")) {lasttwitch = twitch; setAll (0x24, 0x16, 0x28); // Iestatīt raustīšanās violetu krāsu #241628 Serial.print (F ("Twitch:")); Serial.println (raustīšanās); // Nav jāpārbauda favorīts Twitcher, mēs sekojam tikai vienam WHIZZY_TUBER = true; Serial.println (""); }} // ---------------------------------------------- ------------------------------------------- // šī funkcija tiek izsaukta ikreiz tiek saņemts “krāsu” ziņojums // kas iestatīs noklusējuma krāsu startēšanas laikā, pamatojoties uz pēdējo krāsu plūsmas vērtību void handleMessage (AdafruitIO_Data *dati) {// izdrukāt RGB vērtības un heksadecimālo vērtību Serial.print (F ("Saņemta HEX vērtība: ")); Serial.println (dati-> vērtība ()); gara krāsa = dati-> toNeoPixel (); // noklusējuma_krāsa = krāsa; Serial.print (F ("Saņemtais HEX garš:")); Serial.println (krāsa); par (int i = 0; i <PIXEL_COUNT; ++ i) {pixels.setPixelColor (i, krāsa); } showStrip (); } // ----------------------------------------------- ------------------------------------------ anulēts RunningLights (baits sarkans, baits zaļš, baits zils, int WaveDelay) {int Position = 0; par (int j = 0; j <NUM_LEDS; j ++) {Pozīcija ++; // = 0; // Pozīcija + likme; par (int i = 0; i <NUM_LEDS; i ++) {setPixel (i, ((sin (i + Position) * 127 + 128) / 255) * sarkans, ((sin (i + Position) * 127 + 128) / 255)*zaļa, ((sin (i + pozīcija)*127 + 128) / 255)*zila); } showStrip (); kavēšanās (WaveDelay); }} // ---------------------------------------------- ------------------------------------------- // Neopikselu rutīnas void setAll (baits sarkans, baits zaļš, baits zils) {par (int i = 0; i getConfigPortalSSID ()); // ievadīts konfigurācijas režīms, iestatiet Neo Pixel uz purpursarkanu #241628 = 2364968 // setAll (0x24, 0x16, 0x28); setAll (0xeb, 0xfb, 0x03); // dzeltens ebfb03}

9. solis: visu kopā lodēt

Viss šajā dizainā ir pielodēts kopā, un tam vajadzētu būt diezgan viegli pārvaldāmam. Esmu izmantojis 3 dažādu krāsu vadus, lai atvieglotu lietas, un pirmā lieta ir izmērīt vadu neopikselim uz WEMOS. Es tos pinu un uzliku nelielu karstuma saraušanās gabalu un pēc tam lodēju, kā parādīts attēlā, lai tas gulētu lēcā.

Poga bija blakus un cieši iederēsies pamatnē. Viena pogas puse iet uz Gnd, un tā ir savīti kopā ar neopikseļa zemējuma vadu. Pēc tam es tos konservēju un lodēju kā vienu WEMOS zemes tapā.

Neopikseļa barošanas vads iet uz 5 V PIn. Neopikseļa signāla vads jeb Di (dati) ir pielodēts pie Wemos tapas kā D1. Ir dažas vietnes, kurās tiek ieteikts sērijveidā ievietot 300–500 omu rezistoru, taču pagaidām man nav bijis nekādu problēmu, tāpēc pagaidām tas ir tikai tiešs savienojums.

Lai nodrošinātu labu praksi un pēc tādu vietņu ieteikumiem kā Adafruit, es neopikselim sērijveidā ar Di līniju ievietoju 330R rezistoru. Tas ir, lai novērstu gredzena pirmās gaismas diodes izlaišanu no burvju laumiņām un to vienkārši izdarītu, nogriežot vadu un ievietojot pretestību. Jūs varat sagriezt rezistoru diezgan īsu un vienkārši ievietot stīpu katrā galā un darīt to pašu ar vadu.

Otrs pogas vads iet tieši uz tapu D2. Nav nepieciešams pievilkšanas rezistors, jo tas tiek apstrādāts programmatūrā, liekot PULLUP komandu pret šo tapu.

Tas būtībā ir viss.

10. solis: 3D drukāšana

Šeit ir pievienoti STL faili, kurus mēs izmantojam Giant LED. Faili ir astro73 remikss/pārstrādāts, un jūs varat arī paņemt visus failus no vietnes

Kājām un pamatnei es izmantoju Sunlu PETG+ kvēldiegu, kas patiešām labi darbojas ar Prusa i3, un es izmantoju vai nu 10, vai 20% žirozes pildījumu.

Gaismas diodei es izmantoju Sunlu caurspīdīgu PLA un apmēram 10% piepildījumu ar koncentrisku augšējo un apakšējo slāni.

Ar katru es izmantoju tikai krājuma Prusa PET un Prusa PLA iestatījumus programmā Slic3r, un tie visi ir izdevušies labi. Man uz kājām ir mazliet stīgas, bet es vienkārši uz tām uzliku pūšamo degli un aukla pazūd:)

11. solis: milzu LED montāža

Visi gabali patiešām viegli sader kopā, jums ir jāpiespiež M3 uzgrieznis pamatnē, lai skrūve varētu turēt lietu kopā. Jums arī vispirms jāpievieno NeoPixel pie WEMOS caur kājām. Es domāju, kā ievietot dažus savienotājus, bet nolēmu, ka nākotnē tas nesadalīsies.

Objektīvs ir tikai piespiežams kājām, un tās savukārt ir pieskrūvētas pie pamatnes ar vienu M3x20 mm skrūvi. Jums, iespējams, vajadzēs palaist nazi ap pogas atveres iekšpusi, lai tas labi un brīvi kustētos. Wemos tiek turēts ar 2 M2x8 ligzdas skrūvēm, kas ieskrūvētas no apakšas.

Lai pabeigtu, varat pielīmēt filca gabalu uz pamatnes, lai vajadzības gadījumā apturētu slīdēšanu.

12. solis: Uzstādīšanas un ekspluatācijas instrukcijas

Kad viss ir gatavs un augšupielādētā programmatūra izmanto kādu USB strāvu, un GIANT gaismas diodei vajadzētu parādīties, un gaismas diode kļūs SARKANA un pēc tam mainīsies uz dzeltenu krāsu. Tas parāda, ka tas ir izslēgts un gaida wifi konfigurāciju. Izmantojot tālruni vai līdzīgu, meklējiet GIANT LED wifi tīklu un izveidojiet savienojumu, un jūs saņemsiet WiFi pārvaldnieka ekrānu. Tas būs skenējis jūsu vietējo teritoriju, un jūs vienkārši ievadīsit savu wifi informāciju, ESP tiks atsāknēts un tagad būsit tiešsaistē ar zaļu gaismu. Tas arī šajā brīdī izveidos savienojumu ar IO, un iedegsies brīdinājuma gaismas, jo tas vēl nav redzējis iepriekšējos ziņojumus. Nospiediet pogu pāris reizes, un GIANT LED tagad ir gatava atjauninājumu saņemšanai.

Šajā brīdī varat doties uz Adafruit IO informācijas paneli un katrai plūsmai pievienot dažus datus un redzēt, kā gaismas ieslēdzas brīdinājuma režīmā.

Izklaidējieties!

13. solis: ko vēl var darīt milzu LED

Kad esat apguvis šāda dizaina pamatus un ar IFTTT, varat to izmantot daudzām lietām. Gmail iesūtnes brīdinājums ir vienkāršs, un, tā kā Adafruit darbojas arī ar Webhooks, citas programmas var arī nosūtīt datus uz to. Pašlaik man tiek iestatīts viens, lai darba projekta ietvaros izsekotu dažām lielo vaicājumu datu augšupielādēm.

Arī ar pogu jūs varat to izmantot, lai signalizētu arī par citiem GIANT gaismas diodēm. Jūs varētu būt viens dažādās mājās un izmantot to kā tālvadības indikatoru, lai otra puse spiestu pogu, lai atceltu apgaismojumu.

Šeit ir noderīga saite uz tīmekļa aizķeres metodi datu nosūtīšanai uz plūsmu. Šajā gadījumā tas izmanto IFTTT sīklietotni, bet jūs varat tikpat viegli izmantot CURL metodi ar python.

io.adafruit.com/blog/notebook/2018/11/26/f…

Patiesībā ir pat iespējams ievietot OLED 128x32 bāzē, lai papildinātu gaismas diodi ar kādu teksta saturu, un es šobrīd pie tā strādāju, un atjaunināšu STL un piegādāšu kodu, lai ar to izmantotu IO.