Atmosferă tactilă capacitivă / Ambilight: 8 pași

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:47

Acest instructable este o scriere rapidă a experienței mele creând o lumină de dispoziție multifuncțională. Se așteaptă unele cunoștințe de bază despre circuitele electronice. Proiectul nu s-a finalizat încă, trebuie adăugate unele funcționalități și modificări, dar este deja funcțional. Dacă sunteți entuziasmați de acest lucru instructiv, îl voi actualiza. În centrul sistemului este un Arduino. Acesta va procesa intrarea de pe USB sau fiecare dintre intrările tactile capacitive și va controla lumina RGB. Acest instructable este împărțit în trei secțiuni: - Secțiunea tactilă capacitivă acoperă butoanele de intrare invizibile - Secțiunea moodlight acoperă controlul luminii mood-Secțiunea ambilight acoperă intrarea prin portul serial, procesând valorile RGB generate de un program de computer pentru a controla luminile. Declinare de responsabilitate: Electronica poate fi periculoasă, tu însuți ești responsabil pentru orice daune produse. Unele coduri sunt colectate de pe forumuri și este posibil să nu conțină numele proprietarului său. Vă rog să-mi spuneți și vă voi adăuga numele.

Pasul 1: Lista articolelor

Următoarele componente sunt necesare pentru acest instructabil: - Arduino + cablu USB - Breadboard- Sursă de alimentare pentru computer- 3 benzi RGB, verificați dealextreme.com.- 3 FET-uri TIP120, cum ar fi https://uk.farnell.com/stmicroelectronics/tip120 / darlington-transistor-to-220 / dp / 9804005- O grămadă de rezistențe (6 * 10 kiloOhm, 3 * 2 megaOhm) - O mulțime de sârmă. - Instrumente Atingere capacitivă - Inele metalice pentru plăci de bază - Sârmă sau placă de cupru - Ceva în care să se construiască (ca un raft de cărți:)

Pasul 2: atingere capacitivă - elemente de bază și circuit

De când îmi pictam rafturile, am avut ocazia să le „actualizez” și. Am vrut să controlez lumina stării de spirit prin intermediul unei atingeri invizibile. La început, planul meu era să folosesc un IC dedicat pentru acest lucru (cum ar fi Atmel QT240). Dar apoi am dat peste o pagină care explică faptul că Arduino poate emula un senzor capacitiv prin software. Circuitul electronic poate fi găsit în imagine, senzorul este un fir de cupru spiralat (doar unul este prezentat pentru simplitate). Sensibilitatea este controlată de rezistențele găsite înaintea fiecărui pin. Pot varia de la 1 MegaOhm (atingere absolută) la 40 MegaOhm (12-24 inch distanță), în funcție de necesitatea unei atingeri absolute sau aproape (am ajuns să folosesc rezistențe de 2M Ohm). Experimentați cu valorile până când senzorul se comportă așa cum doriți. Este o idee bună să instalați o suprafață conductoare (separată de o piesă subțire neconductoare) conectată la solul circuitelor din spatele fiecărei spirale. În acest fel, senzorii vor fi mai stabili și mai puțin influențați de zgomot. Unele mai multe imagini despre instalarea senzorilor într-un raft de cărți. Este instalat și un conector pentru o conexiune ușoară cu circuitul ulterior. Fillerul este folosit pentru a ascunde totul, iar după aceea sunt gata de vopsit.

Pasul 3: Capacitive Touch - Cod și testare

Următorul cod sursă poate fi utilizat pe Arduino pentru depanare, verificați valorile cu monitorul serial arduino. Sunt generate șase valori. Prima este o măsură a performanței sistemului. De la a doua la a șasea sunt valorile detectate pe fiecare pin. Valorile ar trebui să crească la apropierea degetului. Dacă nu, verificați dacă există conexiuni și interferențe defecte. Valorile rezistenței pot fi modificate pentru a determina sensibilitatea. Prin implementarea unei structuri if-then care este activată la un anumit prag logic, se poate face o comutare. Acest lucru va fi utilizat în codul arduino final. Mai multe informații, sugerate pentru a citi: https://www.arduino.cc/playground/Main/CapSense--- Arduino CapTouch Debugging Code --- # include void setup () {CapSense cs_2_3 = CapSense (2, 4); // 10M rezistență între pinii 2 și 4, pinul 4 este pinul senzorului, adăugați sârmă, folie CapSense cs_2_4 = CapSense (2, 7); // 10M rezistență între pinii 2 și 7, pinul 7 este pinul senzorului, adăugați sârmă, folie CapSense cs_2_5 = CapSense (2, 8); // 10M rezistență între pinii 2 și 8, pinul 8 este pinul senzorului, adăugați sârmă, folie CapSense cs_2_6 = CapSense (2, 12); // 10M rezistență între pinii 2 și 12, pinul 12 este pinul senzorului, adăugați sârmă, folie CapSense cs_2_7 = CapSense (2, 13); // Rezistența de 10 M între pinii 2 și 13, pinul 13 este pinul senzorului, adăugați fir, configurați foilvoid () {Serial.begin (9600);} bucla void () {start lung = milis (); lung total1 = cs_2_3.capSense (30); lung total2 = cs_2_4.capSense (30); lung total3 = cs_2_5.capSense (30); lung total4 = cs_2_6.capSense (30); lung total5 = cs_2_7.capSense (30); Serial.print (millis () - start); // verificați performanța în milisecunde Serial.print ("\ t"); // caracter tab pentru depanarea depanării Serial.print (total1); // imprimare ieșire senzor 1 Serial.print ("\ t"); Serial.print (total2); // imprimare ieșire senzor 2 Serial.print ("\ t"); Serial.print (total3); // ieșire senzor de imprimare 3 Serial.print ("\ t"); Serial.print (total4); // ieșire senzor de imprimare 4 Serial.print ("\ t"); Serial.println (total5); // imprimare ieșire senzor 5 întârziere (10); // întârziere arbitrară pentru a limita datele la portul serial} --- END ---

Pasul 4: Mood Light - Noțiuni de bază și circuit

Acum este timpul să construim partea de ieșire a sistemului. Pinii PWM ai arduino-ului vor fi folosiți pentru a controla fiecare culoare. PWM înseamnă modularea lățimii impulsurilor, prin pornirea și oprirea rapidă a unui pin, ledurile vor fi estompate de la 0 la 255. Fiecare pin va fi amplificat de un FET. Deocamdată, sistemul are un singur canal pe culoare, ceea ce înseamnă că toate benzile RGB vor fi controlate simultan și sunt necesare 3 pini PWM (unul pentru fiecare culoare). În viitor, vreau să pot controla fiecare dintre cele patru benzi RGB. Asta înseamnă 4 * 3 = 12 pini PWM (și probabil un Arduino Mega). Bine, este timpul pentru câteva scheme! Aceasta (a se vedea imaginea) este o reprezentare de bază a circuitului (va face unul mai frumos în curând). Sunt incluși și senzorii capacitivi (partea verde). Practic, există trei componente care trebuie explicate: - FET Acesta este amplificatorul despre care vorbeam. Are o Poartă, o Sursă și un canal de scurgere. Amplifică simțurile un mic curent pe poartă (conectat la Arduino) și deschide drumul pentru banda RGB care este acționată pe 12 volți. Sursa ar trebui să fie pe + 12V, să se scurgă pe GND (la sol). Verificați foaia de specificații a FET-ului pentru identificarea exactă. Fiecare canal RGB ar trebui poziționat înainte de propriul FET. În acest sens, acționează ca un comutator controlat Arduino. - Bandă RGB Această bandă RGB de 12 volți este de tip anod comun (+). Adică, cablul comun ar trebui să fie conectat la + 12V și curentul să fie scufundat prin fiecare dintre canalele de culoare separate. Banda a încorporat rezistențe, așa că nu vă faceți griji în legătură cu asta! Alți trei vor limita curentul maxim pe care FET-ul îl va scurge. Primele trei rezistențe sunt deja în banda RGB. Am lipit cabluri USB pe benzile RGB, astfel încât să le pot conecta modular cu ușurință. Fișele dintr-un hub vechi sunt așezate pe panoul meu de verificare. Folosiți o sursă de alimentare a computerului veche pentru suc, 12V pentru alimentarea benzii RGB și eventual 5V pentru circuit dacă doriți să ruleze fără cablul USB.

Pasul 5: Mood Light - Cod și control

Lumina de dispoziție este controlată de senzorii capacitivi. Deocamdată, am programat doar senzorii 2 și 3 pentru schimbarea culorii. Ceilalți senzori nu au nicio funcție încă. Iată codul: --- Arduino Mood Control Code --- # include const boolean invert = true; const long timeout = 10000; // Declarație senzor capacitiv CapSense In1 = CapSense (2, 4); // Rezistența 2M între pinii 4 și 2, pinul 2 este pinul senzorului, adăugați fir, folie CapSense In2 = CapSense (2, 7); // Rezistența 2M între pinii 4 și 6, pinul 6 este pinul senzorului, adăugați fir, folie CapSense In3 = CapSense (2, 8); // Rezistența 2M între pinii 4 și 8, pinul 8 este pinul senzorului, adăugați sârmă, folie CapSense In4 = CapSense (2, 12); // Rezistor 2M între pinii 4 și 8, pinul 8 este pinul senzorului, adăugați fir, folie CapSense In5 = CapSense (2, 13); // Rezistența 2M între pinii 4 și 8, pinul 8 este pinul senzorului, adăugați fir, folie // PWM Pin declarațiiint PinR1 = 3; int PinG1 = 5; int PinB1 = 6; // Alte variabileint Culoare1 = 128; // începeți cu un roșu ca culoarea Luminozitate1 = 255; // începe cu luminozitate maximă: RedValue1, GreenValue1, BlueValue1; // Componentele RGB evită configurarea () {// setează valorile expirării senzorului In1.set_CS_AutocaL_Millis (expirare); In2.set_CS_AutocaL_Millis (timeout); In3.set_CS_AutocaL_Millis (timeout); In4.set_CS_AutocaL_Millis (timeout); In5.set_CS_AutocaL_Millis (timeout);} void loop () {start lung = millis (); lung total1 = In1.capSense (30); lung total2 = In2.capSense (30); lung total3 = In3.capSense (30); lung total4 = In4.capSense (30); lung total5 = In5.capSense (30); if (total2> 150) {Color1 ++; // creșteți culoarea dacă (Color1> 255) {// Color1 = 0; }} else if (total3> 200) {Color1--; // diminuați culoarea dacă (Color1 <0) {// Color1 = 255; } // converti nuanta in rgb hueToRGB (Color1, Brightness1); // scrie culori la pinii PWM analogWrite (PinR1, RedValue1); analogWrite (PinG1, GreenValue1); analogWrite (PinB1, BlueValue1);} // funcție pentru a converti o culoare în componentele sale roșu, verde și albastru. nesemnat int segment = scaledHue / 256; // segmentează de la 0 la 5 în jurul roții de culoare nesemnat int segmentOffset = scaledHue - (segment * 256); // poziția în cadrul segmentului unsigned int compliment = 0; unsigned int prev = (luminozitate * (255 - segmentOffset)) / 256; unsigned int next = (luminozitate * segmentOffset) / 256; dacă (inversează) {luminozitate = 255-luminozitate; compliment = 255; prev = 255-prev; next = 255-next; } comutator (segment) {caz 0: // roșu RedValue1 = luminozitate; GreenValue1 = next; BlueValue1 = compliment; pauză; caz 1: // galben RedValue1 = prev; GreenValue1 = luminozitate; BlueValue1 = compliment; pauză; caz 2: // verde RedValue1 = compliment; GreenValue1 = luminozitate; BlueValue1 = next; pauză; caz 3: // cyan RedValue1 = compliment; GreenValue1 = prev; BlueValue1 = luminozitate; pauză; caz 4: // albastru RedValue1 = next; GreenValue1 = compliment; BlueValue1 = luminozitate; pauză; caz 5: // magenta implicit: RedValue1 = luminozitate; GreenValue1 = compliment; BlueValue1 = prev; pauză; }}--- SFÂRȘIT ---

Pasul 6: Ambi Light - Arduino Side

Desigur, ar fi total mișto să poți controla lumina de dispoziție de pe computer. De exemplu pentru a crea o ambilight sau o discotecă controlată de sunet. Această secțiune se concentrează pe partea ambilight, în viitor voi adăuga mai multe funcționalități. Ei bine, nu există circuite suplimentare, deoarece toate sunt disponibile în Arduino. Ceea ce vom folosi este capacitățile de comunicare în serie și unele programe software „Processing 1.0”. Conectați-vă arduino-ul la computer printr-un cablu USB (dacă încărcați schițe pe el, acesta este deja). Pentru arduino, trebuie să adăugați un cod suplimentar pentru comunicarea în serie. Codul va trece la modul de ascultare, rotind senzorii capacitivi atâta timp cât primește valori RGB de la computer. Apoi setează valorile RGB la pinii PWM. Acesta este codul meu final deocamdată, verificați singur modificările: --- Arduino Ambilight Code --- # include const boolean invert = true; const long timeout = 10000; long commStart = 0; char val; // Capacitive sensor statementCapSense In1 = CapSense (2, 4); // Rezistența 2M între pinii 4 și 2, pinul 2 este pinul senzorului, adăugați fir, folie CapSense In2 = CapSense (2, 7); // Rezistența 2M între pinii 4 și 6, pinul 6 este pinul senzorului, adăugați fir, folie CapSense In3 = CapSense (2, 8); // Rezistența 2M între pinii 4 și 8, pinul 8 este pinul senzorului, adăugați sârmă, folie CapSense In4 = CapSense (2, 12); // Rezistor 2M între pinii 4 și 8, pinul 8 este pinul senzorului, adăugați fir, folie CapSense In5 = CapSense (2, 13); // Rezistența 2M între pinii 4 și 8, pinul 8 este pinul senzorului, adăugați fir, folie // PWM Pin declarațiiint PinR1 = 3; int PinG1 = 5; int PinB1 = 6; // Alte variabileint Culoare1 = 128; // începeți cu un roșu ca culoarea Luminozitate1 = 255; // începe cu luminozitate maximă: RedValue1, GreenValue1, BlueValue1; // Componentele RGB evită configurarea () {Serial.begin (9600); // începe comunicarea în serie // setați valorile expirării senzorului In1.set_CS_AutocaL_Millis (expirare); In2.set_CS_AutocaL_Millis (timeout); In3.set_CS_AutocaL_Millis (timeout); In4.set_CS_AutocaL_Millis (timeout); In5.set_CS_AutocaL_Millis (timeout);} void loop () {start lung = millis (); lung total1 = In1.capSense (30); lung total2 = In2.capSense (30); lung total3 = In3.capSense (30); lung total4 = In4.capSense (30); lung total5 = In5.capSense (30); if (Serial.available ()) {// Dacă datele sunt disponibile pentru citire, val = Serial.read (); // citiți-l și stocați-l în val commStart = millis (); if (val == 'S') {// Dacă caracterul de pornire este primit, în timp ce (! Serial.available ()) {} // Așteptați până la următoarea valoare. RedValue1 = Serial.read (); // Odată disponibil, atribuiți. while (! Serial.available ()) {} // La fel ca mai sus. GreenValue1 = Serial.read (); while (! Serial.available ()) {} BlueValue1 = Serial.read (); } Serial.print (RedValue1); Serial.print (GreenValue1); Serial.println (BlueValue1); } else if ((millis () - commStart)> 1000) {if (total2> 150) {Color1 ++; // creșteți culoarea dacă (Color1> 255) {// Color1 = 0; }} else if (total3> 200) {Color1--; // diminuați culoarea dacă (Color1 <0) {// Color1 = 255; }} hueToRGB (Culoare1, Luminozitate1); } analogWrite (PinR1, RedValue1); analogWrite (PinG1, GreenValue1); analogWrite (PinB1, BlueValue1);} // funcție pentru a converti o culoare în componentele sale roșu, verde și albastru. nesemnat int segment = scaledHue / 256; // segmentează de la 0 la 5 în jurul roții de culoare nesemnat int segmentOffset = scaledHue - (segment * 256); // poziția în cadrul segmentului unsigned int compliment = 0; unsigned int prev = (luminozitate * (255 - segmentOffset)) / 256; unsigned int next = (luminozitate * segmentOffset) / 256; dacă (inversează) {luminozitate = 255-luminozitate; compliment = 255; prev = 255-prev; next = 255-next; } comutator (segment) {caz 0: // roșu RedValue1 = luminozitate; GreenValue1 = next; BlueValue1 = compliment; pauză; caz 1: // galben RedValue1 = prev; GreenValue1 = luminozitate; BlueValue1 = compliment; pauză; caz 2: // verde RedValue1 = compliment; GreenValue1 = luminozitate; BlueValue1 = next; pauză; caz 3: // cyan RedValue1 = compliment; GreenValue1 = prev; BlueValue1 = luminozitate; pauză; caz 4: // albastru RedValue1 = next; GreenValue1 = compliment; BlueValue1 = luminozitate; pauză; caz 5: // magenta implicit: RedValue1 = luminozitate; GreenValue1 = compliment; BlueValue1 = prev; pauză; }}--- SFÂRȘIT ---

Pasul 7: Ambi Light - Partea computerului

Pe partea laterală a computerului se execută o schiță Processing 1.0, consultați processing.org. Acest program mic (oarecum dezordonat) calculează culoarea medie a ecranului în fiecare clipă și îl trimite la portul serial. Este foarte de bază încă și ar putea folosi unele modificări, dar funcționează foarte bine! Îl voi actualiza în viitor pentru mai multe benzi RGB separate și secțiuni de ecran. Ai putea face asta și tu, limba este destul de simplă. Iată codul: --- Procesare 1.0 Cod --- import processing.serial. *; Import java.awt. AWTException; import java.awt. Robot; import java.awt. Rectangle; import 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); // Imprimați o listă a porturilor seriale, în scopuri de depanare: println (Serial.list ()); // Știu că primul port din lista de seriale de pe mac // este întotdeauna adaptorul meu FTDI, așa că deschid Serial.list () [0]. // Pe mașinile Windows, aceasta deschide în general COM1. // Deschideți orice port este cel pe care îl utilizați. String portName = Serial.list () [0]; myPort = new Serial (this, portName, 9600);} void draw () {// image (screenShot, 0, 0, width, height); screenShot = getScreen (); culoare kleur = culoare (0, 0, 0); kleur = color (screenShot); //myPort.write(int(red(kleur))+ ',' + int (green (kleur)) + ',' + int (blue (kleur)) + 13); //myPort.write(int(red(kleur))); //myPort.write (','); //myPort.write(int(green(kleur))); //myPort.write (','); //myPort.write(int(blue(kleur))); //myPort.write(13); umplere (kleur); rect (30, 20, 55, 55);} culoare culoare (PImage img) {int cols = (img.width); int lines = (img.height); dimensiunea int = (img.width * img.height); int r = 0; int g = 0; int b = 0; img.loadPixels (); // Ga elke pixel langs (dimension) for (int i = 0; i <(dimension / 2); i ++) {r = r + ((img.pixels >> 16) & 0xFF); g = g + ((img.pixels >> 8) & 0xFF); b = b + (img.pixels & 0xFF);} int mean_r = r / (dimensiune / 2); int mean_g = g / (dimensiune / 2); int mean_b = b / (dimensiune / 2); culoare mean_clr = culoare (mean_r, mean_g, mean_b); myPort.write („S”); myPort.write (mean_r); myPort.write (mean_g); myPort.write (mean_b); return (mean_clr);} PImage getScreen () {GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment (); GraphicsDevice gs = ge.getScreenDevices (); Mod DisplayMode = gs [0].getDisplayMode (); Limite de dreptunghi = new Rectangle (0, 0, mode.getWidth (), mode.getHeight ()); BufferedImage desktop = new BufferedImage (mode.getWidth (), mode.getHeight (), BufferedImage. TYPE_INT_RGB); încercați {desktop = new Robot (gs [0]). createScreenCapture (limite); } catch (AWTException e) {System.err.println ("Captura ecranului a eșuat."); } return (PImage nouă (desktop));} --- END ---

Pasul 8: Rezultat

Și acesta este rezultatul, este de fapt în partea de jos a patului meu. Încă trebuie să înlocuiesc pânza, va difuza mai mult lumina. Mai multe imagini despre asta în curând. Sper să vă placă acest instructable și sper, de asemenea, să fie o bază pentru propria dvs. creativitate. Din cauza constrângerilor de timp, am scris-o foarte repede. S-ar putea să aveți nevoie de cunoștințe de bază despre arduino / electronică pentru ao înțelege, dar intenționez să îl actualizez în viitor dacă este bine primit.