Luce touchless interattiva: 7 passaggi (con immagini)

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:03

Ciao a tutti! Vorrei condividere qui il progetto a cui sto lavorando. Ho avuto l'ispirazione per sperimentare il rilevamento tattile capacitivo attraverso un progetto nella mia università. Ho scoperto questa tecnologia attraverso istruttori e ho usato le cose che ho imparato qui e da altri posti su Internet per costruire il mio controller touch-less, che uso per fondere diversi valori RGB per creare colori chiari interessanti.

Per cominciare, quando ho iniziato questo progetto non sapevo quasi nulla né di elettronica né di sensori tattili capacitivi.

Alcuni problemi che ho riscontrato all'inizio sono stati causati da un malinteso su ciò che accade realmente. Quindi una breve introduzione da come l'ho capito:

Un sensore capacitivo utilizza più componenti, principalmente:

Un condensatore (in questo progetto usiamo un foglio di alluminio, ma è anche possibile utilizzare fluidi conduttivi, ecc.), fili (ovviamente, la sua elettronica)

e un resistore, qualsiasi cosa sotto i 10 MOhm è una resistenza troppo piccola per più del tocco diretto.

il modo in cui funziona è misurando una differenza di tempo tra il punto A e il punto B. Dal pin iniziale invia un segnale a un pin finale, il tempo impiegato viene misurato con un timer. Diminuendo il valore della resistenza (spostando un condensatore (in questo caso la mano) più vicino al condensatore del sensore (il foglio di alluminio) questo tempo si accorcia, la differenza di tempo è ciò che il sensore restituisce come valore.

Poiché il sensore è influenzato da superfici capacitive, i dati possono essere estremamente irregolari a causa delle interferenze. Questo può essere risolto in gran parte isolando correttamente il condensatore e anche utilizzando una massa (mostrerò come più avanti).

Quindi ora che è fuori mano possiamo iniziare a fare l'inventario di tutte le cose di cui abbiamo bisogno:

Passaggio 1: di cosa abbiamo bisogno?

Elettronica:

1. 2 x 22 M Ohm + resistori (più grande è il valore di resistenza più lontano reagisce il sensore, personalmente ho usato 22 M Ohm, il minimo per ottenere dati utilizzabili che ho riscontrato era 10 M Ohm)

2. 3 resistenze da 330 Ohm

3. Fili

4. Tagliere

5. Circuito stampato (il mio aveva strisce di rame continue)

6. Più LED RGB a catodo comune (io ne ho usati 8, ma puoi averne più o meno dipende da quanta luce vuoi)

7. Foglio di alluminio

8. Avvolgere l'involucro

9. Arduino Uno

10. Nastro

Il caso:

1. Legno Ho usato MDF 50 x 50 x 1,8 CM (puoi usare davvero qualsiasi cosa. Dipende dall'effetto che vuoi e dagli strumenti che hai a disposizione)

2. Plexiglas acrilico Ho usato 50 x 50 x 0,3 cm (o qualsiasi altro materiale trasparente/traslucido come la carta di riso)

3. Carta vetrata (carta vetrata fine)

4. Colla per legno

5. impiallacciatura (opzionale)

6. Colla acrilica

Utensili:

Spelafili

Saldatore + stagno

Coltello Stanley

trapano

Sega (ho usato una sega da banco)

Fase 2: Prototipazione:

Ora abbiamo tutto e possiamo iniziare a realizzare un prototipo per vedere come funziona:

Lavoro di preparazione:

Ritagliare 4 rettangoli dal foglio di alluminio (i miei misurano circa 10 cm per 5 cm), avvolgerli nella pellicola per isolarli dal contatto diretto e attaccare un filo al foglio di alluminio. Ho solo attaccato un'estremità spogliata alla pellicola (fintanto che rimangono in contatto).

Per assicurarmi che l'alluminio sia isolato in modo sicuro, l'ho avvolto nella pellicola trasparente e l'ho stirato tra i fogli (solo per pochi secondi in modo che non si sciolga completamente).

Quindi imposta il circuito come mostrato nell'immagine.

Il pin 4 viene utilizzato come pin di invio per entrambi i sensori, mentre i pin di ricezione sono i pin 2 e 5. È possibile utilizzare più pin di invio ma causa problemi poiché non sono perfettamente sincronizzati.

usa questa configurazione per scopi di debug prima di saldare tutto insieme, per assicurarti che tutto funzioni veramente come previsto.

Passaggio 3: codice:

Ora abbiamo tutto e possiamo iniziare a eseguire il debug dei sensori.

Per utilizzare il mio codice devi scaricare la libreria di rilevamento capacitivo da Arduino e installarla secondo le indicazioni fornite dalla pagina di riferimento: Cliccami

Il codice: (non sono bravo a programmare, quindi se sai come farlo meglio per favore fallo)

#include //importa la libreria di codici

CapacitiveSensor cs_4_2 = CapacitiveSensor(4, 2); //Invia pin = 4, ricevi sono 2 e 5 CapacitiveSensor cs_4_5 = CapacitiveSensor(4, 5); const int redPin = 11; const int greenPin = 10; const int bluePin = 9; const int numIndexR = 10; // dimensione dell'array const int numIndexG = 10; int colorR = 0; int colorG = 0; colore floatB = 0; int indiceR [numIndiceR]; int posIndexR = 0; lungo totaleR = 0; //deve essere lungo perché il totale del mio array era troppo grande per un numero intero. int media R = 0; int indiceG [numIndiceG]; int posIndexG = 0; lungo totaleG = 0; int mediaG = 0; void setup() { pinMode(redPin, OUTPUT); pinMode(GreenPin, OUTPUT); pinMode(bluePin, OUTPUT); for (int thisIndexR = 0; thisIndexR < numIndexR; thisIndexR++) { //imposta l'array su 0 indexR [thisIndexR] = 0; } for (int thisIndexG = 0; thisIndexG = 4500){ // limita i valori del sensore a un massimo utilizzabile, questo non è lo stesso per ogni valore del resistore e potrebbe anche differire leggermente da un ambiente all'altro potresti aver bisogno di modificarlo per le proprie esigenze. totale1 = 4500; } if (totale2 >= 4500){ totale2 = 4500; } totaleR = totaleR - indiceR[posIndexR]; //questo qui crea un array che aggiunge continuamente un'uscita del sensore e produce la media. indexR[posIndexR] = totale1; totaleR = totaleR + indiceR[posIndexR]; posIndexR = posIndexR + 1; if (posIndexR >= numIndexR){ posIndexR = 0; } mediaR = totaleR / numeroIndiceR; // usiamo la media invece dei dati grezzi per appianare l'output, rallenta leggermente il processo ma crea anche un flusso regolare davvero piacevole. totaleG = totaleG - indiceG[posIndexG]; indexG[posIndexG] = totale2; totaleG = totaleG + indiceG[posIndexG]; posIndexG = posIndexG + 1; if (posIndexG >= numIndexG){ posIndexG = 0; } mediaG = totaleG / numIndiceG; if (averageR >= 2000){ // non vogliamo che i led cambino costantemente valore a meno che non ci sia un input dalla tua mano, quindi questo assicura che tutte le letture ambientali inferiori non vengano prese in considerazione. colorR = map(mediaR, 1000, 4500, 255, 0); analogWrite (redPin, colorR); } else if (mediaR = 1000){ colorG = map(mediaG, 1000, 4500, 255, 0); analogWrite (greenPin, colorG); } else if (mediaG <= 1000){ colorG = 255; analogWrite (greenPin, colorG); } if (colorR <= 125 && colorG <= 125){ //B funziona in modo leggermente diverso perché ho usato solo 2 sensori, quindi ho mappato B su entrambi i sensori colorB = map(colorR, 255, 125, 0, 127.5) + map (colore G, 255, 125, 0, 127,5); analogWrite (bluePin, colorB); } else{ colorB = map(colorR, 255, 125, 127.5, 0) + map(colorG, 255, 125, 127.5, 0); if (colorB>= 255){ colorB = 255; } if (coloreB <= 0){ coloreB = 0; } analogWrite (bluePin, colorB); } Serial.print(millis() - inizio); //questo è per scopi di debug Serial.print("\t"); Serial.print(colorR); Serial.print("\t"); Serial.print(colorG); Serial.print("\t"); Serial.println(coloreB); ritardo(1); }

Ciò che fa questo codice è estrarre i dati grezzi dal sensore (questi dati saranno sempre leggermente irregolari a causa di tutti i diversi fattori che influenzano il sensore) e inserisce i dati grezzi continuamente in un array, quando l'array raggiunge il valore massimo (nel mio caso 10) elimina l'ultimo valore e ne aggiunge uno nuovo. Ogni volta che viene aggiunto un valore, calcola il valore medio e lo inserisce in una nuova variabile. Questa variabile media viene utilizzata per mappare un valore su un valore da 0 a 255, questo è il valore che scriviamo sui pin RGB per aumentare la luminosità di ogni canale (i canali sono R G e B).

Ora se carichi il tuo codice su arduino e apri il monitor seriale dovresti vedere i valori RGB più bassi quando passi la mano su ciascun sensore anche il colore della luce del led dovrebbe cambiare.

Passaggio 4: ora per il caso:

Il caso: ho realizzato il caso utilizzando gli strumenti disponibili tramite la mia università, quindi questo flusso di lavoro non è applicabile a tutti. Tuttavia non c'è niente di troppo speciale in questo, ha bisogno di un foro su un lato per far passare la porta USB, ma a parte questo è solo una scatola aperta.

Le dimensioni sono le seguenti:

15 x 15 CM per il piano trasparente

e

15 x 8 CM per la base in legno (lo spessore del legno per me era di 1,8 CM).

Ho usato una sega da tavolo per tagliare un piatto di MDF nelle dimensioni corrette di cui avevo bisogno (che è 4 pannelli 15 x 8 CM e 1 pannello di terra 15 x 15 CM), dopo di che ho tagliato gli angoli in un angolo di 45 gradi. Tutte le parti le ho incollate usando colla per legno e fascette (lasciate asciugare almeno 30 minuti), ho usato lo stesso procedimento per il plexiglas ma con una lama speciale.

1 dei lati in legno dovrebbe avere un foro al centro all'altezza della presa USB di arduino per consentire il collegamento di arduino.

Ho finito la base di con impiallacciatura. L'ho tagliato a pezzi leggermente più grandi della superficie di ogni lato.

Questo l'ho incollato su di esso, poi l'ho bloccato 30 minuti per lato (meglio farlo individualmente in modo da assicurarti che non scivoli e dopo che si è asciugato ho tagliato quello che sporgeva.

Il tappo l'ho incollato insieme utilizzando una colla specifica per Acryl chiamata Acryfix.

Tieni presente che se usi il plexiglas acrilico, la colla dissolve un po' il plexiglas, quindi sii il più preciso e veloce possibile (si asciuga in un paio di minuti, ma viene esposto all'aria in pochi secondi).

Per rifinire il tappo ho glassato il cubo con una sabbiatrice ma puoi anche usare carta vetrata fine ci vuole solo molto più tempo per renderlo uniforme. Fai attenzione però se usi la carta vetrata, deve essere a grana fine e anche incollare le parti insieme dopo la procedura di glassa (in modo da non romperla accidentalmente applicando molta pressione)

Per assicurarmi che il tappo non scivoli molto ho incollato un paio di barrette di legno sui bordi del cubo di legno.

Passaggio 5: il risultato finale dovrebbe essere simile a questo:

Passaggio 6: saldatura

Se disponi di un circuito stampato, puoi iniziare a saldare tutte le parti insieme utilizzando la stessa configurazione della breadboard.

Il mio circuito ha strisce di rame continue per facilità d'uso.

Per ogni sensore ho tagliato un quadratino a cui saldare le resistenze e i fili.

I fili di invio (i fili che vanno dal pin 4 a ciascun sensore) sono saldati in sequenza a un quadrato separato, con 1 filo che va nel pin 4.

Ho tenuto un lungo rettangolo per creare una striscia led improvvisata (misuralo in modo che si adatti all'interno del cappuccio ma sui bordi della base). Puoi semplicemente saldare i led in sequenza uno dopo l'altro (tieni presente nell'immagine che ho accidentalmente saldato i led e le resistenze sul lato sbagliato del circuito, le strisce di rame dovrebbero essere sempre sul lato inferiore).

Quando hai finito di saldare insieme le singole parti, inseriscile nella custodia. Non ho saldato i miei singoli fili insieme, quindi posso cambiarli facilmente se necessario.

È ora di inserire tutto nella base: questo è praticamente il passaggio più semplice, l'arduino deve essere posizionato prima con la porta USB attraverso il foro sul retro della custodia. Ora aggiungi i sensori, assicurati che la pellicola del sensore aderisca al legno su entrambi i lati, con la lamina di terra dritta contro di essa. Quando tutto si incastra bene, collega i led RGB ai pin giusti (9, 10, 11) e lascialo appoggiare sui bordi della base.

Passaggio 7: abbiamo finito

Se hai seguito tutto questo, ora dovresti avere una luce funzionante con miscelazione cromatica tattile capacitiva. Divertiti!