Interaktív érintésmentes fény: 7 lépés (képekkel)

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

Sziasztok! Szeretném megosztani itt azt a projektet, amelyen dolgozom. Egyetemi projektem során inspirációt kaptam a kapacitív érintésérzékelés kísérletezésére. Ezt a technológiát utasítások segítségével ismertem meg, és az itt és az internet más helyeiről tanult dolgokat felhasználva saját érintésmentes vezérlőt építettem, amellyel különböző RGB értékeket keverve érdekes világos színeket hozok létre.

Kezdetnek, amikor elkezdtem ezt a projektet, szinte semmit sem tudtam sem az elektronikáról, sem a kapacitív érintésérzékelésről.

Néhány problémát, amelyekbe korán belefutottam, a valójában történtek félreértése okozta. Szóval egy rövid bevezető abból, hogy hogyan értem:

A kapacitív érzékelő több összetevőt használ, elsősorban:

Kondenzátor (ebben a projektben alumínium fóliát használunk, de lehetséges vezetőképes folyadékok stb.), vezetékek (természetesen az elektronikája)

és ellenállás, bármi, ami 10 MOhm alatt van, túl kicsi ellenállás a közvetlen érintéshez.

A működés módja az A és B pont közötti időbeli különbség mérése. A kezdőcsaptól jelet küld a végponthoz, az időtartamot időzítővel mérik. Az ellenállás értékének csökkentésével (ha egy kondenzátort (ebben az esetben a kezét) közelebb helyez az érzékelő kondenzátorához (az alumínium fólia), ez az idő lerövidül, az időkülönbség az, amit az érzékelő visszaad értékként).

Mivel az érzékelőt kapacitív felületek befolyásolják, az adatok zavarosak lehetnek. Ez nagyrészt megoldható a kondenzátor helyes szigetelésével és földeléssel is (később megmutatom, hogyan).

Tehát most már nem tudunk elkezdeni minden szükséges anyag leltározását:

1. lépés: Mire van szükségünk?

Elektronika:

1. 2 x 22M Ohm + ellenállások (minél nagyobb az ellenállás értéke, minél távolabb reagál az érzékelő, én személy szerint 22M Ohm -ot használtam, a minimális adat, amit megtapasztaltam, 10M Ohm volt)

2. 3x 330 Ohm ellenállások

3. Vezetékek

4. Kenyeretábla

5. Áramköri lap (az enyémben folytonos rézcsíkok voltak)

6. Több közös Cathode RGB LED (én 8 -at használtam, de több vagy kevesebb is lehet, attól függően, hogy mennyi fényt szeretne)

7. Alumínium fólia

8. Kapaszkodó pakolás

9. Arduino Uno

10. Szalag

Az ügy:

1. Fa 50 x 50 x 1,8 CM MDF -et használtam (bármit igazán használhat. Ez a kívánt hatástól és az Ön rendelkezésére álló szerszámoktól függ)

2. 50 x 50 x 0,3 CM (vagy bármilyen más átlátszó/áttetsző anyagot, például rizspapírt) használt akril plexi

3. Csiszolópapír (finom csiszolópapír)

4. Fa ragasztó

5. vén (nem kötelező)

6. Akril ragasztó

Eszközök:

Huzalcsupaszító

Forrasztópáka + ón

Stanley kés

fúró

Fűrész (asztali fűrészt használtam)

2. lépés: Prototípus:

Most már mindenünk megvan, és elkezdhetjük a prototípus készítését, hogy lássuk, hogyan működik:

Előkészítő munka:

Vágjon ki négy téglalapot az alumíniumfóliából (az enyémek kb. 10 cm -es 5 cm -esek), csomagolja be őket fóliába, hogy szigetelje őket a közvetlen érintéstől, és ragasszon egy drótot az alumíniumfóliára. Csak egy lecsupaszított végét ragasztottam a fóliának (amíg érintkeznek).

Annak érdekében, hogy az alumínium biztonságosan szigetelt legyen, fóliába csomagoltam és papírok között vasaltam (csak néhány másodpercig, hogy ne olvadjon el teljesen).

Ezután állítsa be az áramkört a képen látható módon.

A 4 -es tüskét mindkét érzékelő küldőcsapjaként használják, míg a fogadócsapok a 2 -es és az 5 -ös tűket. Használhat több küldőcsapot, de ez problémát okoz, mivel nincsenek tökéletesen szinkronban.

használja ezt a beállítást hibakeresési célokra, mielőtt mindent összeforraszt, hogy megbizonyosodjon arról, hogy minden valóban a tervezett módon működik.

3. lépés: Kód:

Most már mindenünk megvan, és elkezdhetjük az érzékelők hibakeresését.

A kódom használatához töltse le a kapacitív érzékelő könyvtárat az Arduino -ból, és telepítse azt a referenciaoldal utasításai szerint: Kattintson rám

A kód: (Nem vagyok nagyszerű a kódolásban, ezért ha tudod, hogyan kell ezt jobban csinálni, akkor tedd meg)

#include // importálja a kódkönyvtárat

CapacitiveSensor cs_4_2 = Kapacitív érzékelő (4, 2); // Küldési pin = 4, fogadás 2 és 5 CapacitiveSensor cs_4_5 = CapacitiveSensor (4, 5); const int redPin = 11; const int greenPin = 10; const int bluePin = 9; const int számIndexR = 10; // tömb mérete const int numIndexG = 10; int színR = 0; int színG = 0; úszószínB = 0; int indexR [számindexR]; int posIndexR = 0; hosszú összesenR = 0; // hosszúnak kell lennie, mert a tömböm összessége nagy volt egy egész számhoz. int átlagR = 0; int indexG [számIndexG]; int posIndexG = 0; hosszú összesenG = 0; int átlagG = 0; void setup () {pinMode (redPin, OUTPUT); pinMode (greenPin, OUTPUT); pinMode (bluePin, OUTPUT); for (int thisIndexR = 0; thisIndexR <numIndexR; thisIndexR ++) {// a tömböt 0 indexR [ezIndexR] = 0 értékre állítja; } for (int thisIndexG = 0; thisIndexG = 4500) {// korlátozza az érzékelő értékeit egy használható maximumra, ez nem minden ellenállási érték esetében azonos, és környezetenként is eltérhet, és ezt módosítania kell a saját igényeit. összesen1 = 4500; } if (összesen2> = 4500) {összesen2 = 4500; } totalR = totalR - indexR [posIndexR]; // ez itt egy tömböt hoz létre, amely folyamatosan hozzáadja az érzékelő kimenetét és előállítja az átlagot. indexR [posIndexR] = összesen1; totalR = totalR + indexR [posIndexR]; posIndexR = posIndexR + 1; if (posIndexR> = numIndexR) {posIndexR = 0; } átlagosR = összesenR / számIndexR; // a nyers adatok helyett az átlagot használjuk a kimenet kiegyenlítésére, kissé lelassítja a folyamatot, de nagyon szép sima folyást is létrehoz. totalG = totalG - indexG [posIndexG]; indexG [posIndexG] = összesen2; totalG = totalG + indexG [posIndexG]; posIndexG = posIndexG + 1; if (posIndexG> = numIndexG) {posIndexG = 0; } átlagosG = összesenG / számIndexG; ha (átlagos R> = 2000) {// nem akarjuk, hogy a ledek folyamatosan változtassák az értéküket, hacsak nem a kezedből érkezik be, így ez biztosítja, hogy az összes alacsonyabb környezeti értéket ne vegyük figyelembe. colorR = térkép (átlagos R, 1000, 4500, 255, 0); analogWrite (redPin, colorR); } else if (átlagosR = 1000) {colorG = map (átlagosG, 1000, 4500, 255, 0); analogWrite (zöldPin, színG); } else if (átlagG <= 1000) {colorG = 255; analogWrite (zöldPin, színG); } if (colorR <= 125 && colorG <= 125) {// B egy kicsit másképp működik, mert csak 2 érzékelőt használtam, így mindkét érzékelőn leképeztem B -t colorB = map (colorR, 255, 125, 0, 127,5) + map (színG, 255, 125, 0, 127,5); analogWrite (bluePin, colorB); } else {colorB = térkép (colorR, 255, 125, 127,5, 0) + térkép (colorG, 255, 125, 127,5, 0); ha (színB> = 255) {színB = 255; } if (colorB <= 0) {colorB = 0; } analogWrite (kékPin, színB); } Serial.print (millis () - start); // ez hibakeresési célokra szolgál Serial.print ("\ t"); Soros.nyomat (colorR); Serial.print ("\ t"); Soros.nyomat (colorG); Serial.print ("\ t"); Soros.println (színB); késleltetés (1); }

Ez a kód a nyers adatok kinyerését az érzékelőből (ezek az adatok mindig kissé szabálytalanok lesznek az érzékelőt befolyásoló különböző tényezők miatt), és folyamatosan helyezi a nyers adatokat egy tömbbe, amikor a tömb eléri a maximális értéket (az én esetemben 10) kitisztítja az utolsó értéket, és újat ad hozzá. Minden egyes hozzáadott érték kiszámítja az átlagos értéket, és új változóba helyezi. Ez az átlagos változó egy érték 0 és 255 közötti értékre való leképezésére szolgál, ezt az értéket írjuk az RGB csapokhoz, hogy növeljük az egyes csatornák fényerejét (az RG és B csatornák).

Ha most feltölti a kódot az arduino -ba, és megnyitja a soros monitort, akkor az RGB -értékek alacsonyabbnak kell lennie, amikor a kezét az egyes érzékelők fölé helyezi, és a LED fény színe is megváltozik.

4. lépés: Most az esetre:

Eset: Az ügyet az egyetemen elérhető eszközök segítségével készítettem, így ez a munkafolyamat nem mindenki számára alkalmazható. Azonban nincs semmi különös ebben, az egyik oldalon egy lyukra van szükség az USB -port beillesztéséhez, de ez csak egy nyitott tetejű doboz.

A méretek a következők:

15 x 15 CM az átlátszó felső részhez

és

15 x 8 CM a fa alaphoz (a fa vastagsága nekem 1,8 CM volt).

Asztali fűrésszel vágtam le egy MDF -tányért a megfelelő méretűre, amire szükségem volt (ez 4 panel 15 x 8 CM és 1 15 x 15 CM alaplap), majd a sarkokat 45 fokos szögbe vágtam. Az összes alkatrészt faragasztóval és bilincsekkel ragasztottam össze (hagyja legalább 30 percig száradni), ugyanezt az eljárást alkalmaztam a plexiüvegeknél is, de speciális fűrészlappal.

Az egyik faoldal közepén egy lyuknak kell lennie az arduino USB csatlakozó magasságában, hogy lehetővé tegye az arduino csatlakoztatását.

Alapját furnérral fejeztem be. Mindkét oldal felületén valamivel nagyobb darabokra vágtam.

Ezt ragasztottam rá, majd mindkét oldalon 30 percig szorítottam (jobb, ha külön -külön csinálod, hogy meggyőződj róla, hogy nem csúszik, és miután megszáradt, levágtam, ami kilógott.

A kupakot Acryl -hez ragasztóval ragasztottam össze, Acryfix néven.

Ne feledje, hogy ha akril plexiüveget használ, akkor a ragasztó kissé feloldja a plexit, ezért legyen a lehető legpontosabb és gyors (pár perc alatt megszárad, de másodpercek alatt levegőnek van kitéve).

A kupak befejezéséhez homokfúvóval lefagytam a kockát, de finom csiszolópapírt is használhat, csak sokkal több időbe telik, hogy egyenletes legyen. Ne feledje azonban, ha csiszolópapírt használ, akkor annak finom szemcséjűnek kell lennie, és a részeket a ragasztó eljárás után is össze kell ragasztania (így nem töri meg véletlenül nagy nyomás hatására)

Annak érdekében, hogy a kupak ne csússzon túl sokat, a fa kocka szélére ragasztottam pár apró fa rudat.

5. lépés: A végeredménynek valahogy így kell kinéznie:

6. lépés: Forrasztás

Ha van áramköri lapja, akkor elkezdheti forrasztani az összes alkatrészt ugyanazzal a beállítással, mint a kenyérlap.

Az áramköri lapom folyamatos rézcsíkokkal rendelkezik a könnyű használat érdekében.

Minden érzékelőnél levágtam egy kis négyzetet az ellenállások és vezetékek forrasztásához.

A küldővezetékek (a 4. tűből az egyes érzékelőkhöz vezető vezetékek) egymás után forrasztva vannak egy külön négyzetre, 1 vezetékkel, amely a 4 -es tűbe kerül.

Hosszú téglalapot tartottam, hogy rögtönzött ledcsíkot készítsek (mérje meg, hogy illeszkedjen a kupak belsejébe, de az alap széleihez). A LED -eket csak egymás után forraszthatja (ne feledje a képen, hogy véletlenül forrasztottam a LED -eket és ellenállásokat az áramköri lap rossz oldalán, a rézcsíkoknak mindig az alsó oldalon kell lenniük).

Ha befejezte az egyes alkatrészek forrasztását, illessze őket a tokba. Nem forrasztottam össze az egyes vezetékeket, így szükség esetén könnyen kicserélhetem őket.

Ideje mindent beilleszteni az alapba: Ez nagyjából a legegyszerűbb lépés, az arduino -t először az USB -porton kell elhelyezni a tok hátoldalán lévő lyukon keresztül. Most adja hozzá az érzékelőket, és győződjön meg arról, hogy az érzékelőfólia mindkét oldalon a fához illeszkedik, a talajfólia egyenesen hozzá. Ha minden jól illeszkedik, csatlakoztassa az RGB LED -eket a megfelelő csapokhoz (9, 10, 11), és hagyja, hogy támaszkodjon az alap széleire.

7. lépés: Készen vagyunk

Ha mindezt kihagyta, most kapjon működőképes lámpát kapacitív érintő színkeveréssel. Érezd jól magad!