Kapacitív Touch Mood/Ambilight: 8 lépés

2024 Szerző: John Day | [email protected]. Utoljára módosítva: 2024-01-30 09:44

Ez az oktatható gyors leírás a multifunkcionális hangulatfény létrehozásával kapcsolatos tapasztalataimról. Elvárják az elektronikus áramkörök alapszintű ismereteit. A projekt még nem fejeződött be, néhány funkciót és módosítást el kell végezni, de már működik. Ha srácok lelkesednek ezért az utasításért, frissítem. A rendszer középpontjában egy Arduino áll. Feldolgozza az USB -ről vagy a kapacitív érintőbemenetekről érkező bemeneteket, és vezérli az RGB fényt. Ez az utasítás három részre oszlik:- A kapacitív érintőképernyő lefedi a láthatatlan beviteli gombokat- A moodlight szakasz a hangulatvilágítás vezérlését- Az ambilight rész a soros porton keresztül történő bemenetet foglalja magában, a számítógépes program által generált RGB értékeket dolgozza fel a fények vezérlésére.. Jogi nyilatkozat: Az elektronika veszélyes lehet, az esetleges károkért maga felel. Néhány kódot fórumokból gyűjtenek össze, és előfordulhat, hogy nem tartalmazzák a tulajdonos nevét. Kérem, tudassa velem, és hozzáadom a nevét.

1. lépés: Elemlista

A következő összetevőkre van szükség ehhez az utasításhoz:- Arduino+USB kábel- Kenyérsütőlap- Számítógép tápegysége- 3x RGB csík, nézze meg a dealextreme.com oldalt.- 3x TIP120 FET, például https://uk.farnell.com/stmicroelectronics/tip120 /darlington-transistor-to-220/dp/9804005- Egy csomó ellenállás (6 * 10 kiloOhm, 3 * 2 megaOhm)-Sok vezeték. - Eszközök Kapacitív érintés- Fémgyűrűk a földelőlapokhoz- Rézhuzal vagy lemez- Valami, amibe bele lehet építeni (például egy könyvespolc:)

2. lépés: Kapacitív érintés - alapok és áramkör

Mivel a könyvespolcaimat festettem, lehetőségem volt azokat is „frissíteni”. Láthatatlan érintéssel akartam irányítani a hangulatfényt. Eleinte az volt a tervem, hogy erre egy dedikált IC -t használok (mint például az Atmel QT240). De aztán egy oldalra bukkantam, amely elmagyarázza, hogy az Arduino szoftverrel képes kapacitív érzékelőt emulálni. Az elektronikus áramkör megtalálható a képen, az érzékelő spirálozott rézhuzal (az egyszerűség kedvéért csak az egyik látható). Az érzékenységet a minden csap előtt található ellenállások szabályozzák. Ezek 1 MegaOhm (abszolút érintés) és 40 MegaOhm (12-24 hüvelyk távolságra) között változhatnak, attól függően, hogy szükség van-e abszolút vagy közeli érintésre (végül 2M ohmos ellenállásokat használtam). Kísérletezzen az értékekkel, amíg az érzékelő a kívánt módon nem viselkedik. Jó ötlet valamilyen vezető felületet felszerelni (elválasztva egy vékony, nem vezető darabból), amely az áramkörök földeléséhez van csatlakoztatva minden spirál hátulján. Így az érzékelők stabilabbak lesznek, és kevésbé befolyásolják a zajokat. Még néhány kép az érzékelők könyvespolcra történő telepítéséről. Dugasz is van felszerelve, hogy a későbbiekben könnyen csatlakoztatható legyen az áramkörhöz. A töltőanyagot mindent elrejtik, és utána készen állnak a festésre.

3. lépés: Kapacitív érintés - kód és tesztelés

A következő forráskód használható az Arduino -n hibakereséshez, ellenőrizze az értékeket az arduino soros monitorral. Hat érték jön létre. Az első a rendszer teljesítményének mérése. A második -hatodik minden érzékelt érték. Az értékeknek emelkedniük kell, amikor közeledik az ujjához. Ha nem, ellenőrizze a hibás csatlakozásokat és interferenciát. Az ellenállás értékei megváltoztathatók az érzékenység meghatározásához. Egy bizonyos logikai küszöbértéknél aktivált if-then szerkezet megvalósításával válthat. Ezt fogják használni a végső arduino kódban. További információ, amelyet érdemes elolvasni: https://www.arduino.cc/playground/Main/CapSense--- Arduino CapTouch hibakeresési kód ---#include void setup () {CapSense cs_2_3 = CapSense (2, 4); // 10M ellenállás a 2 -es és 4 -es tűk között, a 4 -es tű az érzékelő csapja, vezetéket kell hozzáadni, fóliaCapSense cs_2_4 = CapSense (2, 7); // 10M ellenállás a 2 -es és 7 -es csapok között, a 7 -es tű az érzékelő csapja, vezetéket kell hozzáadni, fóliaCapSense cs_2_5 = CapSense (2, 8); // 10M ellenállás a 2 -es és 8 -as érintkezők között, a 8 -as tű az érzékelő csapja, vezetéket kell hozzáadni, fóliaCapSense cs_2_6 = CapSense (2, 12); // 10M ellenállás a 2 -es és 12 -es tűk között, a 12 -es tű az érzékelő csapja, vezetéket kell hozzáadni, fóliaCapSense cs_2_7 = CapSense (2, 13); // 10M ellenállás a 2 -es és 13 -as érintkezők között, a 13 -as tű az érzékelő csapja, vezeték hozzáadása, fóliamentes beállítás () {Serial.begin (9600);} void loop () {long start = millis (); hosszú összesen1 = cs_2_3.capSense (30); hosszú összesen2 = cs_2_4.capSense (30); hosszú összesen3 = cs_2_5.capSense (30); hosszú összesen4 = cs_2_6.capSense (30); hosszú összesen5 = cs_2_7.capSense (30); Soros.nyomtatás (millis () - kezdés); // a teljesítmény ellenőrzése ezredmásodpercben Serial.print ("\ t"); // tab karakter debug windown spacing Serial.print (total1); // nyomtatásérzékelő kimenet 1 Serial.print ("\ t"); Sorozatnyomat (összesen2); // nyomtatási érzékelő 2. kimenete Serial.print ("\ t"); Sorozatnyomat (összesen3); // nyomtatási érzékelő kimenete 3 Serial.print ("\ t"); Sorozatnyomat (összesen4); // nyomtatási érzékelő 4 -es kimenete Serial.print ("\ t"); Soros.println (összesen5); // nyomtatási érzékelő kimenet 5 késleltetése (10); // tetszőleges késleltetés az adatok soros portra történő korlátozására} --- END ---

4. lépés: Hangulatfény - alapok és áramkör

Itt az ideje, hogy felépítse a rendszer kimeneti részét. Az arduino PWM csapjait fogják használni az egyes színek vezérléséhez. A PWM impulzusszélesség -modulációt jelent, egy tű gyors be- és kikapcsolásával a LED -ek 0 -ról 255 -re halványulnak. Minden tűt FET erősít. Jelenleg a rendszernek csak egy csatornája van színenként, ami azt jelenti, hogy az összes RGB csíkot egyszerre kell vezérelni, és 3 PWM csap szükséges (egy minden színhez). A jövőben szeretném tudni vezérelni mind a négy RGB csíkomat. Ez azt jelenti, hogy 4*3 = 12 PWM csap (és valószínűleg egy Arduino Mega). Rendben, itt az ideje néhány rajznak! Ez (lásd a képet) az áramkör alapvető ábrázolása (hamarosan szebb lesz). A kapacitív érzékelők is tartoznak (zöld rész). Alapvetően három összetevőt kell magyarázni:- FETEz az erősítő, amiről beszéltem. Kapuja, forrása és lefolyója van. Ez felerősíti az érzékelést egy kis árammal a kapun (az Arduino -hoz csatlakoztatva), és megnyitja az utat a 12 voltos RGB szalag előtt. A forrásnak +12 V -on kell lennie, a GND -n (föld) kell lefolyni. Ellenőrizze a FET specifikációs lapon a pontos kioldást. Minden RGB csatornát a saját FET előtt kell elhelyezni. Ebben az értelemben úgy működik, mint egy Arduino vezérelt kapcsoló.- RGB szalag Ez a 12 voltos RGB szalag a közös anód (+) típusú. Ez azt jelenti, hogy a közös vezetéket +12 V -ra kell csatlakoztatni, és az áramot el kell vezetni az egyes színcsatornákon. A szalag ellenállásokat tartalmaz, ezért ne aggódjon!- Ellenállások Három 10 ezer ellenállás gondoskodik arról, hogy a FET ne kapcsoljon be, amikor nem kellene bekapcsolniuk. Három másik korlátozza a maximális áramot, amelyet a FET elvezet. Az első három ellenállás már az RGB szalagban van. Az RGB csíkokhoz forrasztottam az USB -kábeleket, hogy modulárisan könnyen csatlakoztathassam őket. Egy régi hub csatlakozóit helyezem el a kenyértáblámra. Használjon régi számítógép tápegységet a gyümölcslé számára, 12 V -ot az RGB szalag táplálásához, és végül 5 V -ot az áramkörhöz, ha azt szeretné, hogy az USB -kábel nélkül működjön.

5. lépés: Hangulatfény - kód és vezérlés

A hangulatfényt a kapacitív érzékelők vezérlik. Egyelőre csak a 2. és 3. érzékelőt programoztam a színváltáshoz. A többi érzékelőnek még nincs funkciója. Itt van a kód: --- Arduino Mood Control Code ---#include const boolean invert = true; const long timeout = 10000; // Kapacitív érzékelő nyilatkozatCapSense In1 = CapSense (2, 4); // 2M ellenállás a 4 -es és 2 -es csapok között, a 2 -es tű az érzékelő csapja, vezetéket kell hozzáadni, fóliaCapSense In2 = CapSense (2, 7); // 2M ellenállás a 4 és 6 érintkezők között, a 6 érintkező az érzékelő csapja, vezetéket kell hozzáadni, fóliaCapSense In3 = CapSense (2, 8); // 2M ellenállás a 4 -es és 8 -as érintkezők között, a 8 -as tű az érzékelő csapja, vezetéket kell hozzáadni, fóliaCapSense In4 = CapSense (2, 12); // 2M ellenállás a 4 -es és 8 -as érintkezők között, a 8 -as tű az érzékelő csapja, vezetéket kell hozzáadni, fóliaCapSense In5 = CapSense (2, 13); // 2M ellenállás a 4 -es és 8 -as érintkezők között, a 8 -as tű az érzékelő csapja, huzal hozzáadása, fólia // PWM Pin deklarációkint PinR1 = 3; int PinG1 = 5; int PinB1 = 6; // Egyéb változókint Color1 = 128; // vörös színnel kezdjük, mint a színfényesség Brightness1 = 255; // teljes fényerővel induljon RedValue1, GreenValue1, BlueValue1; // Az RGB komponensek nem rendelkeznek beállítással () {// érzékelői időtúllépési értékek beállítása In1.set_CS_AutocaL_Millis (timeout); In2.set_CS_AutocaL_Millis (időtúllépés); In3.set_CS_AutocaL_Millis (időtúllépés); In4.set_CS_AutocaL_Millis (időtúllépés); In5.set_CS_AutocaL_Millis (timeout);} void loop () {long start = millis (); hosszú összesen1 = In1.capSense (30); hosszú összesen2 = In2.capSense (30); hosszú összesen3 = In3.capSense (30); long total4 = In4.capSense (30); hosszú összesen5 = In5.capSense (30); ha (összesen2> 150) {Szín1 ++; // növelje a színt, ha (Szín1> 255) {// Szín1 = 0; }} else if (összesen3> 200) {Szín1--; // a szín csökkentése, ha (Szín1 <0) {// Szín1 = 255; } // konvertálja a színárnyalatot rgb -re hueToRGB (Szín1, Fényerő1); // színek írása a PWM pins -hez analogWrite (PinR1, RedValue1); analogWrite (PinG1, GreenValue1); analogWrite (PinB1, BlueValue1);} // függvény, amely egy színt vörös, zöld és kék komponenssé alakít át. érvénytelen hueToRGB (int színárnyalat, int fényerő) {unsigned int scaledHue = (színárnyalat * 6); unsigned int szegmens = scaledHue / 256; // szegmens 0 -tól 5 -ig a színkör körül unsigned int segmentOffset = scaledHue - (szegmens * 256); // pozíció a szegmensen belül unsigned int kompliment = 0; unsigned int prev = (fényerő * (255 - szegmenseltolás)) / 256; unsigned int next = (fényerő * szegmenseltolás) / 256; if (invert) {fényerő = 255-fényerő; bók = 255; prev = 255-előzmény; következő = 255-következő; } kapcsoló (szegmens) {eset 0: // piros RedValue1 = fényerő; GreenValue1 = következő; BlueValue1 = bók; szünet; 1. eset: // sárga RedValue1 = prev; GreenValue1 = fényerő; BlueValue1 = bók; szünet; 2. eset: // zöld RedValue1 = bók; GreenValue1 = fényerő; BlueValue1 = következő; szünet; 3. eset: // ciánkék RedValue1 = bók; GreenValue1 = előzmény; BlueValue1 = fényerő; szünet; 4. eset: // kék RedValue1 = next; GreenValue1 = bók; BlueValue1 = fényerő; szünet; 5. eset: // bíbor alapértelmezett: RedValue1 = fényerő; GreenValue1 = bók; BlueValue1 = előző; szünet; }} --- VÉGE ---

6. lépés: Ambi Light - Arduino Side

Természetesen teljesen jó lenne, ha a hangulatfényt a számítógépről vezérelhetné. Például ambilight vagy hangvezérelt diszkó létrehozásához. Ez a rész az ambilight részre összpontosít, a jövőben több funkciót adok hozzá. Nos, nincs további áramkör, mert mindez elérhető az Arduino -ban. A soros kommunikációs képességeket és néhány "Processing 1.0" szoftvert fogunk használni. Csatlakoztassa az arduinóját a számítógéphez USB-kábellel (ha vázlatokat töltött fel, akkor már az). Az arduino esetében hozzá kell adni néhány extra kódot a soros kommunikációhoz. A kód hallgatás üzemmódba kapcsol, és addig kapcsolja a kapacitív érzékelőket, amíg RGB értékeket kap a számítógéptől. Ezután beállítja az RGB értékeket a PWM csapokra. Ez az utolsó kódom egyelőre, ellenőrizze a változtatásokat: --- Arduino Ambilight Code ---#include const boolean invert = true; const long timeout = 10000; long commStart = 0; char val; // Kapacitív érzékelő nyilatkozatCapSense In1 = CapSense (2, 4); // 2M ellenállás a 4 -es és 2 -es csapok között, a 2 -es tű az érzékelő csapja, vezetéket kell hozzáadni, fóliaCapSense In2 = CapSense (2, 7); // 2M ellenállás a 4 és 6 érintkezők között, a 6 érintkező az érzékelő csapja, vezetéket kell hozzáadni, fóliaCapSense In3 = CapSense (2, 8); // 2M ellenállás a 4 -es és 8 -as érintkezők között, a 8 -as tű az érzékelő csapja, vezetéket kell hozzáadni, fóliaCapSense In4 = CapSense (2, 12); // 2M ellenállás a 4 -es és 8 -as érintkezők között, a 8 -as tű az érzékelő csapja, vezetéket kell hozzáadni, fóliaCapSense In5 = CapSense (2, 13); // 2M ellenállás a 4 -es és 8 -as érintkezők között, a 8 -as tű az érzékelő csapja, huzal hozzáadása, fólia // PWM Pin deklarációkint PinR1 = 3; int PinG1 = 5; int PinB1 = 6; // Egyéb változókint Color1 = 128; // vörös színnel kezdjük, mint a színfényesség Brightness1 = 255; // teljes fényerővel induljon RedValue1, GreenValue1, BlueValue1; // Az RGB komponensek nem rendelkeznek beállítással () {Serial.begin (9600); // soros kommunikáció indítása // érzékelő időtúllépési értékeinek beállítása In1.set_CS_AutocaL_Millis (timeout); In2.set_CS_AutocaL_Millis (időtúllépés); In3.set_CS_AutocaL_Millis (időtúllépés); In4.set_CS_AutocaL_Millis (időtúllépés); In5.set_CS_AutocaL_Millis (timeout);} void loop () {long start = millis (); hosszú összesen1 = In1.capSense (30); hosszú összesen2 = In2.capSense (30); hosszú összesen3 = In3.capSense (30); long total4 = In4.capSense (30); hosszú összesen5 = In5.capSense (30); if (Serial.available ()) {// Ha az adatok olvashatók, val = Serial.read (); // olvassa el és tárolja val commStart = millis (); if (val == 'S') {// Ha a kezdő karakter beérkezett, a (! Serial.available ()) {} // Várja meg a következő értéket. RedValue1 = Sorozat.olvasás (); // Ha rendelkezésre áll, rendeljen hozzá. while (! Serial.available ()) {} // Ugyanaz, mint fent. GreenValue1 = Sorozat.olvasás (); while (! Serial.available ()) {} BlueValue1 = Serial.read (); } Serial.print (RedValue1); Serial.print (GreenValue1); Serial.println (BlueValue1); } else if ((millis () - commStart)> 1000) {if (összesen2> 150) {Szín1 ++; // növelje a színt, ha (Szín1> 255) {// Szín1 = 0; }} else if (összesen3> 200) {Szín1--; // a szín csökkentése, ha (Szín1 <0) {// Szín1 = 255; }} hueToRGB (Szín1, Fényerő1); } analogWrite (PinR1, RedValue1); analogWrite (PinG1, GreenValue1); analogWrite (PinB1, BlueValue1);} // függvény, amely egy színt vörös, zöld és kék komponenssé alakít át. érvénytelen hueToRGB (int színárnyalat, int fényerő) {unsigned int scaledHue = (színárnyalat * 6); unsigned int szegmens = scaledHue / 256; // szegmens 0 -tól 5 -ig a színkör körül unsigned int segmentOffset = scaledHue - (szegmens * 256); // pozíció a szegmensen belül unsigned int kompliment = 0; unsigned int prev = (fényerő * (255 - szegmenseltolás)) / 256; unsigned int next = (fényerő * szegmenseltolás) / 256; if (invert) {fényerő = 255-fényerő; bók = 255; prev = 255-prev; következő = 255-következő; } kapcsoló (szegmens) {eset 0: // piros RedValue1 = fényerő; GreenValue1 = következő; BlueValue1 = bók; szünet; 1. eset: // sárga RedValue1 = prev; GreenValue1 = fényerő; BlueValue1 = bók; szünet; 2. eset: // zöld RedValue1 = bók; GreenValue1 = fényerő; BlueValue1 = következő; szünet; 3. eset: // ciánkék RedValue1 = bók; GreenValue1 = előző; BlueValue1 = fényerő; szünet; 4. eset: // kék RedValue1 = next; GreenValue1 = bók; BlueValue1 = fényerő; szünet; 5. eset: // bíbor alapértelmezett: RedValue1 = fényerő; GreenValue1 = bók; BlueValue1 = előző; szünet; }} --- VÉGE ---

7. lépés: Ambi Light - számítógépes oldal

A számítógép oldalán egy Processing 1.0 vázlat fut, lásd: processing.org. Ez a kis (kissé rendetlen) program minden pillanatban kiszámítja az átlagos képernyőszínt, és elküldi ezt a soros portra. Ez még nagyon alapvető, és némi csípést is használhat, de nagyon jól működik! A jövőben frissíteni fogom több különálló RGB csík és képernyőszakasz esetén. Ezt saját maga is megteheti, a nyelv meglehetősen egyszerű. Íme a kód: --- Processing 1.0 Code --- 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); // méret (képernyő.szélesség, képernyő.magasság); // Nyomtassa ki a soros portok listáját hibakeresés céljából: println (Serial.list ()); // Tudom, hogy a Mac sorozatom soros listájának első portja // mindig az FTDI adapter, ezért megnyitom a Serial.list () [0] mappát. // Windows gépeken ez általában megnyitja a COM1 -et. // Nyissa meg a használt portot. String portName = Sorozat.lista () [0]; myPort = new Serial (this, portName, 9600);} void draw () {// image (screenShot, 0, 0, width, height); screenShot = getScreen (); szín kleur = szín (0, 0, 0); kleur = szín (képernyőkép); //sajatport.write(int(red(kleur))+ ','+int (zöld (kleur))+','+int (kék (kleur))+13); //sajatport.write(int(red(kleur))); //sajatport.write (','); //sajatport.write(int(green(kleur))); //sajatport.write (','); //sajatport.write(int(blue(kleur))); //sajatport.write (13); kitölt (kleur); rect (30, 20, 55, 55);} szín szín (PImage img) {int cols = (img.width); int sorok = (img.magasság); int dimenzió = (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.pixel >> 8) & 0xFF); b = b + (kép átlag_klr = szín (átlag_r, átlag_g, átlag_b); myPort.write ('S'); myPort.write (átlag_r); myPort.write (átlag_g); myPort.write (mean_b); return (mean_clr);} PImage getScreen () {GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment (); GraphicsDevice gs = ge.getScreenDevices (); DisplayMode mód = gs [0].getDisplayMode (); Téglalap határok = new Téglalap (0, 0, mode.getWidth (), mode.getHeight ()); BufferedImage desktop = new BufferedImage (mode.getWidth (), mode.getHeight (), BufferedImage. TYPE_INT_RGB); try {desktop = new Robot (gs [0]). createScreenCapture (határok); } catch (AWTException e) {System.err.println ("A képernyő rögzítése nem sikerült."); } return (új PImage (asztali));} --- END ---

8. lépés: Eredmény

És ez az eredmény, valójában az ágyam alján található. Még ki kell cserélnem a kendőt, jobban eloszlatja a fényt. További képek erről hamarosan. Remélem tetszik ez az oktatható, és remélem, hogy ez is a kreativitás alapja. Az idő szűkössége miatt nagyon gyorsan megírtam. Lehet, hogy rendelkeznie kell bizonyos alapvető arduino/elektronikai ismeretekkel a megértéséhez, de azt tervezem, hogy a jövőben frissítem, ha jól fogadják.