Kapasitiewe Touch Mood/Ambilight: 8 stappe

2024 Outeur: John Day | [email protected]. Laas verander: 2024-01-30 07:29

Hierdie instruksies is 'n vinnige beskrywing van my ervaring met die skep van 'n multifunksionele moodlight. 'N Basiese kennis van elektroniese stroombane word verwag. Die projek is nog nie afgehandel nie, 'n bietjie funksie en aanpassings moet gedoen word, maar dit is reeds funksioneel. As julle entoesiasties is oor hierdie instruksies, sal ek dit opdateer. In die hart van die stelsel is 'n Arduino. Dit verwerk die invoer vanaf USB of elk van die Kapasitiewe aanraaksingange en beheer die RGB -lig. Hierdie instruksies word in drie afdelings verdeel:- Die kapasitiewe aanraakgedeelte dek die onsigbare invoerknoppies- Die moodlight-afdeling dek die beheer van die moodlight- Die ambilight-afdeling dek insette deur die seriële poort, verwerking van RGB-waardes wat deur 'n rekenaarprogram gegenereer word om die ligte te beheer Disclaimer: Elektronika kan gevaarlik wees; u is self verantwoordelik vir enige skade. Sommige kode word van forums afgehaal en bevat moontlik nie die naam van die eienaar nie. Laat weet my asseblief, ek voeg u naam by.

Stap 1: Itemlys

Die volgende komponente is nodig vir hierdie instruksies:- Arduino+USB-kabel- Broodbord- Rekenaarvoeding- 3x RGB-stroke, kyk na dealextreme.com.- 3x TIP120 FET's, soos https://uk.farnell.com/stmicroelectronics/tip120 /darlington-transistor-to-220/dp/9804005- 'n Klomp weerstande (6 * 10 kiloOhm, 3 * 2 megaOhm)-Baie draad. - Gereedskap Kapasitiewe aanraking- Metaalringe vir grondplate- Koperdraad of bord- Iets om in te bou (soos 'n boekrak:)

Stap 2: Kapasitiewe aanraking - Basics & Circuit

Aangesien ek my boekrakke geverf het, het ek ook die geleentheid gehad om dit 'op te gradeer'. Ek wou die bui beheer deur middel van onsigbare aanraking. Aanvanklik was my plan om 'n toegewyde IC hiervoor te gebruik (soos die Atmel QT240). Maar toe kom ek op 'n bladsy wat verduidelik dat die Arduino 'n kapasitiewe sensor deur sagteware kan naboots. Gevoeligheid word beheer deur die weerstande wat voor elke pen gevind word. Dit kan wissel van 1 MegaOhm (absolute aanraking) tot 40 MegaOhm (12-24 duim weg), afhangende van of absolute of naby aanraking nodig is (ek het uiteindelik 2M Ohm-weerstande gebruik). Eksperimenteer met die waardes totdat die sensor na wense gedra. Dit is 'n goeie idee om 'n geleidende oppervlak te plaas (geskei deur 'n dun, nie-geleidende stuk) wat aan die kringe se grond aan die agterkant van elke spiraal gekoppel is. Op hierdie manier sal die sensors meer stabiel en minder beïnvloed word deur geraas, en meer foto's oor die installering van die sensors in 'n boekrak. Daar word ook 'n prop geïnstalleer om later maklik met die stroombaan te skakel. Vuller word gebruik om alles te verberg, en daarna kan hulle geverf word.

Stap 3: Kapasitiewe aanraking - kode en toetsing

Die volgende bronkode kan op die Arduino gebruik word vir ontfouting, kyk na die waardes met die arduino seriële monitor. Ses waardes word gegenereer. Die eerste is 'n maatstaf vir die prestasie van die stelsel. Die tweede tot sesde is die waargenome waardes op elke pen. Die waardes moet styg as u u vinger nader. As dit nie die geval is nie, kyk dan na slegte verbindings en inmenging. Die weerstandswaardes kan verander word om sensitiwiteit te bepaal. Deur die implementering van 'n as-dan-struktuur wat by 'n sekere logiese grenswaarde geaktiveer word, kan 'n skakelaar gemaak word. Dit sal gebruik word in die finale arduino-kode. Meer inligting, voorgestel om te lees: https://www.arduino.cc/playground/Main/CapSense--- Arduino CapTouch Debugging Code ---#sluit leegte-opstelling () in {CapSense cs_2_3 = CapSense (2, 4); // 10M weerstand tussen penne 2 en 4, pen 4 is sensorpen, voeg draad by, foilCapSense cs_2_4 = CapSense (2, 7); // 10M weerstand tussen penne 2 en 7, pen 7 is sensorpen, voeg draad by, foilCapSense cs_2_5 = CapSense (2, 8); // 10M weerstand tussen penne 2 en 8, pen 8 is sensorpen, voeg draad by, foilCapSense cs_2_6 = CapSense (2, 12); // 10M weerstand tussen penne 2 en 12, pen 12 is sensorpen, voeg draad by, foilCapSense cs_2_7 = CapSense (2, 13); // 10M weerstand tussen penne 2 en 13, pen 13 is sensorpen, voeg draad by, foilvoid -opstelling () {Serial.begin (9600);} leemte -lus () {lang begin = millis (); lang totaal1 = cs_2_3.capSense (30); lang totaal2 = cs_2_4.capSense (30); lang totaal3 = cs_2_5.capSense (30); lang totaal4 = cs_2_6.capSense (30); lang totaal5 = cs_2_7.capSense (30); Serial.print (millis () - begin); // kyk na prestasie in millisekondes Serial.print ("\ t"); // tabkarakter vir ontfouting met winding spacing Serial.print (totaal1); // druk sensor uitset 1 Serial.print ("\ t"); Reeks.afdruk (totaal2); // druk sensor uitset 2 Serial.print ("\ t"); Reeks.afdruk (totaal3); // druk sensor uitset 3 Serial.print ("\ t"); Serial.print (totaal4); // druk sensor uitset 4 Serial.print ("\ t"); Serial.println (totaal5); // druk sensor uitset 5 vertraging (10); // willekeurige vertraging om data tot seriële poort te beperk} --- EINDE ---

Stap 4: Mood Light - Basics & Circuit

Nou is dit tyd om die uitsetgedeelte van die stelsel te bou. Die arduino se PWM -penne sal gebruik word om elke kleur te beheer. PWM beteken Pulse Width Modulation, deur 'n pen baie vinnig aan en af te skakel, word die LED's gedemp van 0 tot 255. Elke pen word versterk deur 'n VOO. Op die oomblik het die stelsel slegs een kanaal per kleur, wat beteken dat alle RGB -stroke tegelyk beheer word en 3 PWM -penne nodig is (een vir elke kleur). In die toekoms wil ek elkeen van my vier RGB -stroke beheer. Dit beteken 4*3 = 12 PWM -penne (en waarskynlik 'n Arduino Mega). Ok, tyd vir 'n paar skemas! Dit (sien prentjie) is 'n basiese voorstelling van die stroombaan (maak binnekort 'n mooier). Die kapasitiewe sensors is ook ingesluit (groen deel). Eintlik is daar drie komponente wat verduidelik moet word:- FETT Dit is die versterker waaroor ek gepraat het. Dit het 'n poort, 'n bron en 'n drein. Dit versterk die sintuie 'n klein stroom op die hek (gekoppel aan die Arduino) en maak die weg oop vir die RGB -strook wat op 12 volt aangedryf word. Bron moet op +12V wees, dreineer op GND (grond). Kontroleer die spesifikasieblad van u VOO vir die presiese pinout. Elke RGB -kanaal moet voor sy eie VOO geplaas word. In hierdie sin werk dit soos 'n Arduino-beheerde skakelaar.- RGB-strook Hierdie 12 volt RGB-strook is van die algemene anode (+) tipe. Dit beteken dat die gewone draad aan +12V gekoppel moet word en dat die stroom deur elk van die verskillende kleurkanale gesink word. Die strook bevat weerstande, dus moenie daaroor bekommerd wees nie!- Weerstande Drie 10k weerstande sorg dat die VOO nie aanskakel as hulle nie aangeskakel moet word nie. Drie ander beperk die maksimum stroom wat die VOO sal dreineer. Die boonste drie weerstande is reeds in die RGB -strook. Ek het USB -kabels aan die RGB -stroke gesoldeer, sodat ek dit maklik modulêr kan koppel. Stekke van 'n ou hub word op my broodbord geplaas. Gebruik 'n ou rekenaarvoeding vir sap, 12V om die RGB -strook aan te dryf en uiteindelik 5V vir die stroombaan as u wil hê dat dit sonder die USB -kabel moet werk.

Stap 5: Mood Light - Kode en beheer

Die bui lig word beheer deur die kapasitiewe sensors. Ek het vir eers net sensors 2 en 3 vir kleurverandering geprogrammeer. Die ander sensors het nog geen funksie nie. Hier is die kode: --- Arduino Mood Control Code ---#bevat const boolean invert = true; const long timeout = 10000; // Kapasitiewe sensorverklaringCapSense In1 = CapSense (2, 4); // 2M weerstand tussen penne 4 en 2, pen 2 is sensorpen, voeg draad by, foilCapSense In2 = CapSense (2, 7); // 2M weerstand tussen penne 4 & 6, pen 6 is sensorpen, voeg draad by, foilCapSense In3 = CapSense (2, 8); // 2M weerstand tussen penne 4 & 8, pen 8 is sensorpen, voeg draad by, foilCapSense In4 = CapSense (2, 12); // 2M weerstand tussen penne 4 en 8, pen 8 is sensorpen, voeg draad by, foilCapSense In5 = CapSense (2, 13); // 2M weerstand tussen penne 4 & 8, pen 8 is sensorpen, voeg draad, foelie toe // PWM Pin declarationsint PinR1 = 3; int PinG1 = 5; int PinB1 = 6; // Other variablesint Color1 = 128; // begin met 'n rooi kleur, helderheid 1 = 255; // begin met volle helderheid in RedValue1, GreenValue1, BlueValue1; // Die opstel van die RGB -komponente () {// stel sensor se tydsberekeningwaardes in1.set_CS_AutocaL_Millis (time -out); In2.set_CS_AutocaL_Millis (time -out); In3.set_CS_AutocaL_Millis (time -out); In4.set_CS_AutocaL_Millis (time -out); In5.set_CS_AutocaL_Millis (time -out);} leemte lus () {lang begin = millis (); lang totaal1 = In1.capSense (30); lang totaal2 = In2.capSense (30); lang totaal3 = In3.capSense (30); lang totaal4 = In4.capSense (30); lang totaal5 = In5.capSense (30); as (totaal2> 150) {Kleur1 ++; // verhoog die kleur as (Kleur1> 255) {// Kleur1 = 0; }} anders as (totaal3> 200) {Kleur1--; // verminder die kleur as (Kleur1 <0) {// Kleur1 = 255; } // skakel hue om in rgb hueToRGB (kleur1, helderheid1); // skryf kleure na PWM -penne analogWrite (PinR1, RedValue1); analogWrite (PinG1, GreenValue1); analogWrite (PinB1, BlueValue1);} // funksie om 'n kleur na sy rooi, groen en blou komponente om te skakel.void hueToRGB (int hue, int brightness) {unsigned int scaledHue = (hue * 6); ongetekende int segment = scaledHue / 256; // segment 0 tot 5 rondom die kleurwiel ongeteken int segmentOffset = scaledHue - (segment * 256); // posisie binne die segment ongetekende int kompliment = 0; ongetekende int prev = (helderheid * (255 - segmentOffset)) / 256; ongetekende int volgende = (helderheid * segmentOffset) / 256; as (inverteer) {helderheid = 255-helderheid; kompliment = 255; prev = 255-prev; volgende = 255-volgende; } skakelaar (segment) {case 0: // rooi RedValue1 = helderheid; GreenValue1 = volgende; BlueValue1 = kompliment; breek; geval 1: // geel RedValue1 = prev; GreenValue1 = helderheid; BlueValue1 = kompliment; breek; geval 2: // groen RedValue1 = kompliment; GreenValue1 = helderheid; BlueValue1 = volgende; breek; saak 3: // siaan RedValue1 = kompliment; GreenValue1 = vorige; BlueValue1 = helderheid; breek; geval 4: // blou RedValue1 = volgende; GreenValue1 = kompliment; BlueValue1 = helderheid; breek; geval 5: // magenta standaard: RedValue1 = helderheid; GreenValue1 = kompliment; BlueValue1 = vorige; breek; }} --- EINDE ---

Stap 6: Ambi Light - Arduino -kant

Dit is natuurlik heeltemal cool om die bui van u rekenaar te kan beheer. Byvoorbeeld om 'n ambilight of 'n klankbeheerde disco te skep. Hierdie afdeling fokus op die ambilight -gedeelte, in die toekoms sal ek meer funksionaliteit byvoeg. Wel, daar is geen ekstra stroombane nie, want dit is alles beskikbaar in die Arduino. Wat ons gaan gebruik, is die seriële kommunikasie -vermoëns en 'n paar 'Processing 1.0' -sagteware. Sluit u arduino aan op u rekenaar met 'n USB-kabel (as u sketse daarheen opgelaai het, is dit alreeds). Vir die arduino moet u 'n ekstra kode byvoeg vir seriële kommunikasie. Die kode sal oorskakel na die luistermodus en die kapasitiewe sensors draai, solank dit RGB -waardes van die rekenaar ontvang. Dit stel dan die RGB -waardes op die PWM -penne. Dit is vir eers my finale kode, kyk self na die veranderinge: --- Arduino Ambilight-kode ---#sluit const boolean invert = true in; const long timeout = 10000; long commStart = 0; char val; // Kapasitiewe sensorverklaring CapSense In1 = CapSense (2, 4); // 2M weerstand tussen penne 4 en 2, pen 2 is sensorpen, voeg draad by, foilCapSense In2 = CapSense (2, 7); // 2M weerstand tussen penne 4 & 6, pen 6 is sensorpen, voeg draad by, foilCapSense In3 = CapSense (2, 8); // 2M weerstand tussen penne 4 & 8, pen 8 is sensorpen, voeg draad by, foilCapSense In4 = CapSense (2, 12); // 2M weerstand tussen penne 4 en 8, pen 8 is sensorpen, voeg draad by, foilCapSense In5 = CapSense (2, 13); // 2M weerstand tussen penne 4 & 8, pen 8 is sensorpen, voeg draad, foelie toe // PWM Pin declarationsint PinR1 = 3; int PinG1 = 5; int PinB1 = 6; // Other variablesint Color1 = 128; // begin met 'n rooi kleur, helderheid 1 = 255; // begin met volle helderheid in RedValue1, GreenValue1, BlueValue1; // Die opstel van die RGB -komponente () {Serial.begin (9600); // begin met reekskommunikasie // stel sensor se tydsberekeningwaardes in In..set_CS_AutocaL_Millis (time -out); In2.set_CS_AutocaL_Millis (time -out); In3.set_CS_AutocaL_Millis (time -out); In4.set_CS_AutocaL_Millis (time -out); In5.set_CS_AutocaL_Millis (time -out);} leemte lus () {lang begin = millis (); lang totaal1 = In1.capSense (30); lang totaal2 = In2.capSense (30); lang totaal3 = In3.capSense (30); lang totaal4 = In4.capSense (30); lang totaal5 = In5.capSense (30); if (Serial.available ()) {// As data beskikbaar is om te lees, val = Serial.read (); // lees dit en stoor dit in val commStart = millis (); if (val == 'S') {// As begin char ontvang word, terwyl (! Serial.available ()) {} // Wag tot die volgende waarde. RedValue1 = Serial.read (); // Sodra beskikbaar, ken toe. terwyl (! Serial.available ()) {} // Dieselfde as hierbo. GreenValue1 = Serial.read (); terwyl (! Serial.available ()) {} BlueValue1 = Serial.read (); } Serial.print (RedValue1); Serial.print (GreenValue1); Serial.println (BlueValue1); } anders if ((millis () - commStart)> 1000) {if (total2> 150) {Color1 ++; // verhoog die kleur as (Kleur1> 255) {// Kleur1 = 0; }} anders as (totaal3> 200) {Kleur1--; // verminder die kleur as (Kleur1 <0) {// Kleur1 = 255; }} hueToRGB (Kleur1, Helderheid1); } analogWrite (PinR1, RedValue1); analogWrite (PinG1, GreenValue1); analogWrite (PinB1, BlueValue1);} // funksie om 'n kleur na sy rooi, groen en blou komponente om te skakel.void hueToRGB (int hue, int brightness) {unsigned int scaledHue = (hue * 6); ongetekende int segment = scaledHue / 256; // segment 0 tot 5 rondom die kleurwiel ongeteken int segmentOffset = scaledHue - (segment * 256); // posisie binne die segment ongetekende int kompliment = 0; ongetekende int prev = (helderheid * (255 - segmentOffset)) / 256; ongetekende int volgende = (helderheid * segmentOffset) / 256; as (inverteer) {helderheid = 255-helderheid; kompliment = 255; prev = 255-prev; volgende = 255-volgende; } skakelaar (segment) {case 0: // rooi RedValue1 = helderheid; GreenValue1 = volgende; BlueValue1 = kompliment; breek; geval 1: // geel RedValue1 = prev; GreenValue1 = helderheid; BlueValue1 = kompliment; breek; geval 2: // groen RedValue1 = kompliment; GreenValue1 = helderheid; BlueValue1 = volgende; breek; saak 3: // siaan RedValue1 = kompliment; GreenValue1 = vorige; BlueValue1 = helderheid; breek; geval 4: // blou RedValue1 = volgende; GreenValue1 = kompliment; BlueValue1 = helderheid; breek; geval 5: // magenta standaard: RedValue1 = helderheid; GreenValue1 = kompliment; BlueValue1 = vorige; breek; }} --- EINDE ---

Stap 7: Ambi Light - rekenaarkant

Aan die kant van die rekenaar word 'n Processing 1.0 -skets uitgevoer, sien processing.org. Hierdie klein (ietwat morsige) program bereken elke keer die gemiddelde skermkleur en stuur dit na die seriële poort. Dit is nog baie basies en dit kan 'n paar aanpassings gebruik, maar dit werk baie goed! Ek sal dit in die toekoms opdateer vir verskeie afsonderlike RGB -stroke en skermafdelings. U kan dit ook self doen, die taal is redelik eenvoudig. Hier is die kode: --- Verwerking 1.0-kode --- invoerverwerking.reeks.*; Invoer java.awt. AWTException; invoer java.awt. Robot; invoer java.awt. Rectangle; invoer java.awt.image. BufferedImage; PImage screenShot; Serial myPort; statiese openbare leemte hoof (String args ) {PApplet.main (nuwe string {"--present", "shooter"});} leegte opstelling () {size (100, 100); // grootte (skerm.wydte, skerm.hoogte); // Druk 'n lys met die seriële poorte vir ontfoutingsdoeleindes: println (Serial.list ()); // Ek weet dat die eerste poort in die reekslys op my mac // altyd my FTDI -adapter is, dus maak ek Serial.list () [0] oop. // Op Windows -masjiene maak dit gewoonlik COM1 oop. // Maak die poort oop wat u gebruik. String portName = Serial.list () [0]; myPort = new Serial (this, portName, 9600);} void draw () {// image (screenShot, 0, 0, breedte, hoogte); screenShot = getScreen (); kleur kleur = kleur (0, 0, 0); kleur = color (screenShot); //myPort.write(int(red(kleur))++ ','+int (groen (kleur))+','+int (blou (kleur))+13); //myPort.write(int(red(kleur)))); //myPort.write (','); //myPort.write(int(green(kleur)))); //myPort.write (','); //myPort.write(int(blue(kleur)))); //myPort.write(13); fill (kleur); rect (30, 20, 55, 55);} kleur kleur (PImage img) {int cols = (img.width); int rye = (afbeeld.hoogte); int dimensie = (img.width*img.thight); int r = 0; int g = 0; int b = 0; img.loadPixels (); // Ga elke pixel langs (dimensie) vir (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/(dimensie/2); int mean_g = g/(dimensie/2); int mean_b = b/(dimensie/2); kleur gemiddelde_clr = kleur (gemiddelde_r, gemiddelde_g, gemiddelde_b); myPort.write ('S'); myPort.write (mean_r); myPort.write (gemiddelde_g); myPort.write (mean_b); return (mean_clr);} PImage getScreen () {GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment (); GraphicsDevice gs = ge.getScreenDevices (); DisplayMode -modus = gs [0].getDisplayMode (); Reghoekgrense = nuwe reghoek (0, 0, mode.getWidth (), mode.getHeight ()); BufferedImage lessenaar = nuwe BufferedImage (mode.getWidth (), mode.getHeight (), BufferedImage. TYPE_INT_RGB); probeer {desktop = new Robot (gs [0]). createScreenCapture (perke); } catch (AWTException e) {System.err.println ("Skermopname misluk."); } terugkeer (nuwe prentjie (tafelblad));} --- EINDE ---

Stap 8: Resultaat

En dit is die resultaat, dit is eintlik aan die onderkant van my bed. Ek moet nog die lap vervang, dit versprei die lig meer. Meer foto's daaroor binnekort. Ek hoop dat u van hierdie instruksies hou, en ek hoop ook dat dit 'n basis is vir u eie kreatiwiteit. Weens tydsbeperkings het ek dit baie vinnig geskryf. Miskien moet u basiese kennis van arduino/elektronika hê om dit te verstaan, maar ek is van plan om dit in die toekoms by te werk as dit goed ontvang word.