Kapacitivno razpoloženje na dotik/Ambilight: 8 korakov

2024 Avtor: John Day | [email protected]. Nazadnje spremenjeno: 2024-01-30 12:09

Ta pouk je hiter zapis mojih izkušenj pri ustvarjanju večnamenske luči razpoloženja. Pričakuje se nekaj osnovnih znanj o elektronskih vezjih. Projekt se še ni končal, treba je dodati nekaj funkcionalnosti in prilagoditve, vendar je že funkcionalen. Če ste navdušeni nad tem navodilom, ga bom posodobil. V središču sistema je Arduino. Obdeloval bo vhod iz USB -ja ali vsakega od kapacitivnih vhodov na dotik in upravljal lučko RGB. Ta navodila so razdeljena na tri razdelke:- kapacitivni odsek na dotik pokriva nevidne vhodne gumbe- odsek moodlight pokriva krmiljenje moodlight- oddelek ambilight pokriva vnos preko serijskih vrat in obdeluje vrednosti RGB, ki jih ustvari računalniški program za nadzor luči. Izjava o omejitvi odgovornosti: Elektronika je lahko nevarna, sami ste odgovorni za nastalo škodo. Nekatera koda je zbrana na forumih in morda ne vsebuje imena lastnika. Sporočite mi in dodal bom vaše ime.

1. korak: Seznam elementov

Za to navodilo so potrebne naslednje komponente:- kabel Arduino+USB- plošča- računalniški napajalnik- 3x RGB trakovi, poglejte dealextreme.com.- 3x TIP120 FET, na primer https://uk.farnell.com/stmicroelectronics/tip120 /darlington-tranzistor-to-220/dp/9804005- kup uporov (6 * 10 kiloOhm, 3 * 2 megaOhm)-veliko žice. - Orodja Kapacitivni dotik- Kovinski obroči za talne plošče- Bakrena žica ali plošča- Nekaj, v kar se lahko vgradi (kot knjižna polica:)

2. korak: Kapacitivni dotik - osnove in vezje

Ker sem slikal svoje knjižne police, sem imel priložnost, da jih tudi »nadgradim«. Želel sem nadzorovati razpoloženje s pomočjo nevidnega dotika. Sprva sem nameraval za to uporabiti namenski IC (na primer Atmel QT240). Potem pa sem naletel na stran, ki pojasnjuje, da lahko Arduino s programsko opremo posnema kapacitivni senzor. Elektronsko vezje je na sliki, senzor je spiralna bakrena žica (samo enostavnost je prikazana). Občutljivost nadzirajo upori, ki jih najdemo pred vsakim zatičem. Lahko segajo od 1 MegaOhm (absolutni dotik) do 40 MegaOhm (12-24 palcev stran), odvisno od tega, ali je potreben absolutni ali skoraj dotik (na koncu sem uporabil 2M Ohm upor). Eksperimentirajte z vrednostmi, dokler se senzor ne obnaša kot želite. Dobro je namestiti nekaj prevodne površine (ločene s tankim neprevodnim kosom), ki je na zadnji strani vsake spirale priključena na ozemljitev vezja. Tako bodo senzorji bolj stabilni in nanje manj vpliva hrup. Nekaj več slik o namestitvi senzorjev na knjižno polico. Za lažjo povezavo s tokokrogom je kasneje nameščen tudi vtič. Polnilo se uporablja za skrivanje vsega, nato pa so pripravljeni za barvanje.

3. korak: kapacitivni dotik - koda in testiranje

Naslednjo izvorno kodo lahko uporabite za odpravljanje napak v Arduinu, preverite vrednosti s serijskim monitorjem arduino. Ustvari se šest vrednosti. Prvi je merilo učinkovitosti sistema. Od druge do šeste so zaznane vrednosti na vsakem zatiču. Ko se približate prstu, se morajo vrednosti povečati. V nasprotnem primeru preverite, ali so povezave in motnje slabe. Vrednosti upora lahko spremenite, da določite občutljivost. Z uvedbo strukture če-potem, ki se aktivira pri določenem logičnem pragu, lahko izvedete preklop. To bo uporabljeno v končni kodi arduino. Več informacij, predlaganih v branje: https://www.arduino.cc/playground/Main/CapSense--- Koda za odpravljanje napak Arduino CapTouch ---#include void setup () {CapSense cs_2_3 = CapSense (2, 4); // 10M upor med zatičema 2 in 4, pin 4 je senzorski pin, dodajte žico, folijoCapSense cs_2_4 = CapSense (2, 7); // 10M upor med nožicama 2 in 7, pin 7 je pin senzorja, dodaj žico, folijoCapSense cs_2_5 = CapSense (2, 8); // 10M upor med nožicama 2 in 8, pin 8 je pin senzorja, dodajte žico, folijoCapSense cs_2_6 = CapSense (2, 12); // 10M upor med nožicama 2 in 12, pin 12 je senzorski pin, dodaj žico, folijoCapSense cs_2_7 = CapSense (2, 13); // 10M upor med nožicama 2 in 13, pin 13 je pin senzorja, dodajte žico, foilvoid setup () {Serial.begin (9600);} void loop () {long start = millis (); dolga skupaj1 = cs_2_3.capSense (30); dolga skupaj2 = cs_2_4.capSense (30); dolg skupaj3 = cs_2_5.capSense (30); dolg skupaj4 = cs_2_6.capSense (30); dolga skupaj5 = cs_2_7.capSense (30); Serial.print (millis () - začetek); // preverjanje delovanja v milisekundah Serial.print ("\ t"); // znak tabulatorja za odpravljanje napak v razmiku med vrsticami Serial.print (skupaj1); // tiskanje izhoda senzorja 1 Serial.print ("\ t"); Serijski.tisk (skupaj2); // izhod senzorja tiskanja 2 Serial.print ("\ t"); Serijski.tisk (skupaj3); // izhod senzorja za tiskanje 3 Serial.print ("\ t"); Serijski.tisk (skupaj4); // izhod senzorja za tiskanje 4 Serial.print ("\ t"); Serial.println (skupaj5); // tiskanje izhoda senzorja 5 zakasnitev (10); // poljubna zakasnitev za omejitev podatkov na serijska vrata} --- END ---

4. korak: Mood Light - osnove in vezje

Zdaj je čas za izgradnjo izhodnega dela sistema. Arduinovi zatiči PWM bodo uporabljeni za nadzor vsake barve. PWM pomeni Pulse Width Modulation, z zelo hitrim vklopom in izklopom zatiča se lučke zatemnijo od 0 do 255. Vsak pin bo ojačan s FET. Zaenkrat ima sistem samo en kanal na barvo, kar pomeni, da bodo vsi trakovi RGB krmiljeni hkrati in potrebni so 3 zatiči PWM (po en za vsako barvo). V prihodnosti si želim nadzorovati vsakega od štirih trakov RGB. To pomeni 4*3 = 12 PWM nožic (in verjetno Arduino Mega). Ok, čas je za nekaj shem! Ta (glej sliko) je osnovni prikaz vezja (kmalu bo lepši). Priloženi so tudi kapacitivni senzorji (zeleni del). V bistvu je treba pojasniti tri komponente:- FETTo je ojačevalnik, o katerem sem govoril. Ima vrata, vir in odtok. Omogoča zaznavanje majhnega toka na vratih (povezanih z Arduinom) in odpira pot RGB traku, ki deluje na 12 voltov. Vir mora biti na +12V, odtok na GND (ozemljitev). Za natančen izpis preverite list s specifikacijami vašega FET. Vsak RGB kanal je treba postaviti pred svoj FET. V tem smislu deluje kot stikalo, ki ga upravlja Arduino.- RGB trak Ta 12-voltni RGB trak je tipa skupne anode (+). To pomeni, da je treba skupno žico priključiti na +12V, tok pa potone skozi vsak ločen barvni kanal. Trak ima vgrajene upore, zato ne skrbite!- Upori Trije 10k upori bodo poskrbeli, da se FET ne bo vklopil, ko se ne bi smel vklopiti. Tri druge bodo omejile največji tok, ki ga FET izčrpa. Zgornji trije upori so že v traku RGB, kable USB sem spajkal na trakove RGB, tako da jih lahko enostavno modularno povežem. Vtiči iz starega vozlišča so postavljeni na mojo ploščo. Uporabite stari računalniški napajalnik za sok, 12V za napajanje RGB traku in na koncu 5V za vezje, če želite, da deluje brez kabla USB.

5. korak: Mood Light - Koda in nadzor

Svetlobo razpoloženja nadzirajo kapacitivni senzorji. Za zdaj sem programiral samo senzorje 2 in 3 za spreminjanje barve. Drugi senzorji zaenkrat še ne delujejo. Tu je koda: --- Arduino Mood Control Code ---#vključuje const boolean invert = true; const long timeout = 10000; // deklaracija kapacitivnega senzorjaCapSense In1 = CapSense (2, 4); // 2M upor med zatičema 4 in 2, pin 2 je senzorski pin, dodajte žico, folijo Capense In2 = CapSense (2, 7); // 2M upor med zatičema 4 in 6, pin 6 je pin senzorja, dodajte žico, folijoCapSense In3 = CapSense (2, 8); // 2M upor med zatičema 4 in 8, pin 8 je senzorski pin, dodajte žico, folijoCapSense In4 = CapSense (2, 12); // 2M upor med zatičema 4 in 8, pin 8 je senzorski pin, dodajte žico, folijoCapSense In5 = CapSense (2, 13); // 2M upor med nožicama 4 in 8, pin 8 je senzorski pin, dodaj žico, folijo // PWM deklaracije pin PinR1 = 3; int PinG1 = 5; int PinB1 = 6; // Druge spremenljivkeint Color1 = 128; // pričnemo pri rdeči barvi Brightness1 = 255; // pri polni svetlostiint RedValue1, GreenValue1, BlueValue1; // RGB componentsvoid setup () {// nastavi vrednosti časovne omejitve senzorja In1.set_CS_AutocaL_Millis (časovna omejitev); In2.set_CS_AutocaL_Millis (časovna omejitev); In3.set_CS_AutocaL_Millis (časovna omejitev); In4.set_CS_AutocaL_Millis (časovna omejitev); In5.set_CS_AutocaL_Millis (časovna omejitev);} void loop () {dolg začetek = millis (); dolga skupaj1 = In1.capSense (30); dolga skupaj2 = In2.capSense (30); dolga skupaj3 = In3.capSense (30); dolga skupaj4 = In4.capSense (30); dolga skupaj5 = In5.capSense (30); če (skupaj2> 150) {Barva1 ++; // povečanje barve if (Color1> 255) {// Color1 = 0; }} else if (skupaj3> 200) {Color1--; // zmanjšamo barvo, če (Color1 <0) {// Color1 = 255; } // pretvorimo odtenek v rgb hueToRGB (barva1, svetlost1); // zapisujemo barve na zatiče PWM analogWrite (PinR1, RedValue1); analogWrite (PinG1, GreenValue1); analogWrite (PinB1, BlueValue1);} // funkcija za pretvorbo barve v njene rdeče, zelene in modre komponente.void hueToRGB (int hue, int svetlost) {unsigned int scaledHue = (hue * 6); nepodpisani int segment = scaledHue / 256; // segment 0 do 5 okoli barvnega kolesa unsigned int segmentOffset = scaledHue - (segment * 256); // položaj v segmentu unsigned int compliment = 0; brez podpisa int prev = (svetlost * (255 - segmentOffset)) / 256; brez podpisa int naslednji = (svetlost * segmentOffset) / 256; if (obrni) {svetlost = 255-svetlost; kompliment = 255; prev = 255-prev; naslednji = 255-naslednji; } stikalo (segment) {primer 0: // rdeča RedValue1 = svetlost; GreenValue1 = naslednji; BlueValue1 = kompliment; prekiniti; primer 1: // rumena RedValue1 = prev; GreenValue1 = svetlost; BlueValue1 = kompliment; prekiniti; primer 2: // zelena RedValue1 = kompliment; GreenValue1 = svetlost; BlueValue1 = naslednji; prekiniti; primer 3: // modra RedValue1 = kompliment; GreenValue1 = prev; BlueValue1 = svetlost; prekiniti; primer 4: // modra RedValue1 = naslednji; GreenValue1 = kompliment; BlueValue1 = svetlost; prekiniti; primer 5: // magenta privzeto: RedValue1 = svetlost; GreenValue1 = kompliment; BlueValue1 = prev; prekiniti; }} --- KONEC ---

Korak 6: Ambi Light - Arduino stran

Seveda bi bilo popolnoma kul, če bi lahko upravljali svetlobo razpoloženja iz računalnika. Na primer za ustvarjanje ambiliata ali zvočno vodene diskoteke. Ta razdelek se osredotoča na del ambilight, v prihodnosti bom dodal več funkcionalnosti. Nobenega dodatnega vezja ni, ker je vse na voljo v Arduinu. Uporabili bomo zmogljivosti serijske komunikacije in nekaj programske opreme "Processing 1.0". Arduino priključite na računalnik s kablom USB (če ste nanj nalagali skice, je že). Za arduino je treba dodati še dodatno kodo za serijsko komunikacijo. Koda bo preklopila v način poslušanja, pri čemer se kapacitivni senzorji obračajo, dokler iz računalnika prejmejo vrednosti RGB. Nato nastavi vrednosti RGB na zatiče PWM. To je moja zadnja koda, za spremembe preverite sami: --- Koda Arduino Ambilight ---#vključuje const boolean invert = true; const long timeout = 10000; long commStart = 0; char val; // Deklaracija kapacitivnega senzorja CapSense In1 = CapSense (2, 4); // 2M upor med zatičema 4 in 2, pin 2 je senzorski pin, dodajte žico, folijo Capense In2 = CapSense (2, 7); // 2M upor med zatičema 4 in 6, pin 6 je pin senzorja, dodajte žico, folijoCapSense In3 = CapSense (2, 8); // 2M upor med zatičema 4 in 8, pin 8 je senzorski pin, dodajte žico, folijoCapSense In4 = CapSense (2, 12); // 2M upor med zatičema 4 in 8, pin 8 je senzorski pin, dodajte žico, folijoCapSense In5 = CapSense (2, 13); // 2M upor med nožicama 4 in 8, pin 8 je senzorski pin, dodaj žico, folijo // PWM deklaracije pin PinR1 = 3; int PinG1 = 5; int PinB1 = 6; // Druge spremenljivkeint Color1 = 128; // začnemo pri rdeči barvi Brightness1 = 255; // pri polni svetlostiint RedValue1, GreenValue1, BlueValue1; // RGB componentsvoid setup () {Serial.begin (9600); // zaženemo serijsko komunikacijo // nastavimo vrednosti časovne omejitve senzorja In1.set_CS_AutocaL_Millis (časovna omejitev); In2.set_CS_AutocaL_Millis (časovna omejitev); In3.set_CS_AutocaL_Millis (časovna omejitev); In4.set_CS_AutocaL_Millis (časovna omejitev); In5.set_CS_AutocaL_Millis (časovna omejitev);} void loop () {dolg začetek = millis (); dolga skupaj1 = In1.capSense (30); dolga skupaj2 = In2.capSense (30); dolga skupaj3 = In3.capSense (30); dolga skupaj4 = In4.capSense (30); dolga skupaj5 = In5.capSense (30); if (Serial.available ()) {// Če so podatki na voljo za branje, val = Serial.read (); // preberemo in shranimo v val commStart = millis (); if (val == 'S') {// Če je sprejet začetni znak, medtem ko (! Serial.available ()) {} // Počakajte do naslednje vrednosti. RedValue1 = Serial.read (); // Ko bo na voljo, dodelite. while (! Serial.available ()) {} // Enako kot zgoraj. GreenValue1 = Serial.read (); medtem ko (! Serial.available ()) {} BlueValue1 = Serial.read (); } Serial.print (RedValue1); Serial.print (GreenValue1); Serial.println (BlueValue1); } else if ((millis () - commStart)> 1000) {if (total2> 150) {Color1 ++; // povečanje barve if (Color1> 255) {// Color1 = 0; }} else if (skupaj3> 200) {Color1--; // zmanjšamo barvo if (Color1 <0) {// Color1 = 255; }} hueToRGB (Barva1, Svetlost1); } analogWrite (PinR1, RedValue1); analogWrite (PinG1, GreenValue1); analogWrite (PinB1, BlueValue1);} // funkcija za pretvorbo barve v njene rdeče, zelene in modre komponente.void hueToRGB (int hue, int svetlost) {unsigned int scaledHue = (hue * 6); nepodpisani int segment = scaledHue / 256; // segment 0 do 5 okoli barvnega kolesa unsigned int segmentOffset = scaledHue - (segment * 256); // položaj v segmentu unsigned int compliment = 0; brez podpisa int prev = (svetlost * (255 - segmentOffset)) / 256; brez podpisa int naslednji = (svetlost * segmentOffset) / 256; if (obrni) {svetlost = 255-svetlost; kompliment = 255; prev = 255-prev; naslednji = 255-naslednji; } stikalo (segment) {primer 0: // rdeča RedValue1 = svetlost; GreenValue1 = naslednji; BlueValue1 = kompliment; prekiniti; primer 1: // rumena RedValue1 = prev; GreenValue1 = svetlost; BlueValue1 = kompliment; prekiniti; primer 2: // zelena RedValue1 = kompliment; GreenValue1 = svetlost; BlueValue1 = naslednji; prekiniti; primer 3: // modra RedValue1 = kompliment; GreenValue1 = prev; BlueValue1 = svetlost; prekiniti; primer 4: // modra RedValue1 = naslednji; GreenValue1 = kompliment; BlueValue1 = svetlost; prekiniti; primer 5: // magenta privzeto: RedValue1 = svetlost; GreenValue1 = kompliment; BlueValue1 = prev; prekiniti; }} --- KONEC ---

7. korak: Ambi Light - računalniška stran

Na strani računalnika se izvaja skica Processing 1.0, glejte processing.org. Ta mali (nekoliko neurejen) program v vsakem trenutku izračuna povprečno barvo zaslona in to pošlje v serijska vrata. Zaenkrat je še zelo osnovni in bi lahko uporabil nekaj prilagoditev, vendar deluje zelo dobro! V prihodnosti ga bom posodobil za več ločenih RGB trakov in odsekov zaslona. To lahko storite tudi sami, jezik je precej preprost. Tu je koda: --- obdelava kode 1.0 --- uvoz processing.serial.*; Uvoz java.awt. AWTException; uvoz java.awt. Robot; uvoz java.awt. Rectangle; uvoz java.awt.image. BufferedImage; PImage screenShot; Serial myPort; static public void main (String args ) {PApplet.main (new String {"--present", "shooter"});} void setup () {size (100, 100); //size(screen.width, screen.height); // Natisnite seznam serijskih vrat za namene odpravljanja napak: println (Serial.list ()); // Vem, da so prva vrata na serijskem seznamu na mojem računalniku // vedno moj adapter FTDI, zato odprem Serial.list () [0]. // Na strojih Windows to običajno odpre COM1. // Odprite vsa vrata, ki jih uporabljate. Niz portName = Serial.list () [0]; myPort = new Serial (this, portName, 9600);} void draw () {// image (screenShot, 0, 0, width, height); screenShot = getScreen (); barva kleur = barva (0, 0, 0); kleur = barva (posnetek zaslona); //myPort.write(int(red(kleur))+ ','+int (zelena (kleur))+','+int (modra (kleur))+13); //myPort.write(int(red(kleur))); //myPort.write (','); //myPort.write(int(green(kleur))); //myPort.write (','); //myPort.write(int(blue(kleur))); //myPort.write(13); polnilo (kleur); rect (30, 20, 55, 55);} barva barve (slika PImage) {int cols = (img.width); int vrstice = (img.height); int dimenzija = (img.width*img.height); int r = 0; int g = 0; int b = 0; img.loadPixels (); // Ga elke pixel langs (dimenzija) za (int i = 0; i <(dimenzija/2); i ++) {r = r+((img.pixels >> 16) & 0xFF); g = g + ((imp. piksli >> 8) & 0xFF); b = b + (img.pixel & 0xFF);} int mean_r = r/(dimenzija/2); int mean_g = g/(dimenzija/2); int mean_b = b/(dimenzija/2); barva srednji_clr = barva (povprečni_r, srednji_g, srednji_b); myPort.write ('S'); myPort.write (srednji_r); myPort.write (srednji_g); myPort.write (mean_b); return (mean_clr);} PImage getScreen () {GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment (); GraphicsDevice gs = ge.getScreenDevices (); Način DisplayMode = gs [0].getDisplayMode (); Meje pravokotnika = nov pravokotnik (0, 0, mode.getWidth (), mode.getHeight ()); Namizje BufferedImage = novo BufferedImage (mode.getWidth (), mode.getHeight (), BufferedImage. TYPE_INT_RGB); poskusite {desktop = new Robot (gs [0]). createScreenCapture (meje); } catch (AWTException e) {System.err.println ("Zajem zaslona ni uspel."); } return (nova slika PImage (namizje));} --- END ---

8. korak: Rezultat

In to je rezultat, dejansko je na spodnji strani moje postelje. Še vedno moram zamenjati krpo, ki bo bolj razpršila svetlobo. Več slik o tem kmalu. Upam, da vam je ta pouk všeč in upam, da je tudi osnova za vašo ustvarjalnost. Zaradi časovnih omejitev sem jo napisal zelo hitro. Morda boste morali imeti nekaj osnovnega znanja o arduinu/elektroniki, da ga razumete, vendar ga nameravam v prihodnosti posodobiti, če bo dobro sprejet.