Luz interativa sem toque: 7 etapas (com imagens)

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:38

Olá a todos! Eu gostaria de compartilhar o projeto em que estou trabalhando aqui. Eu me inspirei para experimentar o sensor de toque capacitivo por meio de um projeto em minha universidade. Eu descobri essa tecnologia por meio de instructables e usei as coisas que aprendi aqui e em outros lugares na internet para construir meu próprio controlador touch-less, que uso para misturar diferentes valores RGB para criar cores de luz interessantes.

Para começar, quando comecei este projeto, eu não sabia quase nada sobre eletrônica ou sensor de toque capacitivo.

Alguns problemas que enfrentei no início foram causados por não entender o que realmente acontece. Então, uma breve introdução de como eu o entendo:

Um sensor capacitivo usa vários componentes, principalmente:

Um capacitor (neste projeto usamos folha de alumínio, mas também é possível usar fluidos condutores etc), fios (claro, sua eletrônica)

e um resistor, qualquer coisa abaixo de 10 MOhm é uma resistência muito pequena para mais do que toque direto.

a maneira como funciona é medindo a diferença de tempo entre o ponto A e o ponto B. Do pino inicial, ele envia um sinal para um pino final, o tempo que leva é medido com um cronômetro. Ao diminuir o valor da resistência (movendo um capacitor (neste caso, sua mão) para mais perto do capacitor do sensor (a folha de alumínio), este tempo encurta, a diferença de tempo é o que o sensor retorna como um valor.

Devido ao sensor ser afetado por superfícies capacitivas, os dados podem ser extremamente erráticos devido à interferência. Isso pode ser resolvido em grande parte isolando corretamente o capacitor e também usando um aterramento (mostrarei como mais tarde).

Então, agora que está fora do caminho, podemos começar a inventariar todas as coisas de que precisamos:

Etapa 1: O que precisamos?

Eletrônicos:

1. 2 x 22M Ohm + resistores (quanto maior o valor da resistência, mais longe o sensor reage, eu pessoalmente usei 22M Ohm, o mínimo para obter dados utilizáveis que experimentei foi de 10M Ohm)

2. 3 resistores de 330 Ohm

3. Fios

4. Placa de ensaio

5. Placa de circuito (a minha tinha tiras de cobre contínuas)

6. Múltiplos LEDs RGB catódicos comuns (usei 8, mas você pode ter mais ou menos depende de quanta luz você deseja)

7. Folha de alumínio

8. Filme plástico

9. Arduino Uno

10. Fita

O caso:

1. Madeira Usei 50 x 50 x 1,8 CM MDF (você pode usar qualquer coisa realmente. Depende do efeito que você deseja e das ferramentas que você tem à sua disposição)

2. Plexiglas acrílico eu usei 50 x 50 x 0,3 CM (ou qualquer outro material transparente / translúcido como papel de arroz)

3. Lixa (lixa fina)

4. cola de madeira

5. Veneer (opcional)

6. Cola acrílica

Ferramentas:

Descascador de fios

Ferro de soldar + lata

faca Stanley

furar

Serra (usei uma serra de mesa)

Etapa 2: Prototipagem:

Agora temos tudo e podemos começar a fazer um protótipo para ver como funciona:

Trabalho preparatório:

Corte 4 retângulos da folha de alumínio (os meus têm cerca de 10 cm por 5 cm), embrulhe-os em filme plástico para isolá-los do toque direto e prenda um fio na folha de alumínio. Acabei de prender uma ponta despojada na folha (contanto que permaneçam em contato).

Para ter certeza de que o alumínio está isolado com segurança, embrulhei em filme plástico e passei-o entre papéis (apenas por alguns segundos para que não derreta completamente).

Em seguida, configure o circuito como visto na imagem.

O pino 4 é usado como um pino de envio para ambos os sensores, enquanto os pinos de recepção são os pinos 2 e 5. Você pode usar vários pinos de envio, mas isso causa problemas, pois eles não estão perfeitamente sincronizados.

use esta configuração para fins de depuração antes de soldar tudo junto, para se certificar de que tudo realmente funciona como pretendido.

Etapa 3: Código:

Agora temos tudo e podemos começar a depurar os sensores.

Para usar meu código, você deve baixar a biblioteca de detecção capacitiva do Arduino e instalá-la de acordo com as instruções fornecidas pela página de referência: Clique aqui

O código: (não sou muito bom em codificação, então, se você souber como fazê-lo melhor, faça-o)

#include // importe a biblioteca de código

CapacitiveSensor cs_4_2 = CapacitiveSensor (4, 2); // Enviar pino = 4, receber são 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; // tamanho do array const int numIndexG = 10; cor intR = 0; cor intG = 0; float colorB = 0; int indexR [numIndexR]; int posIndexR = 0; longo totalR = 0; // precisa ser longo porque o total do meu array era muito grande para um inteiro. média interna R = 0; int indexG [numIndexG]; int posIndexG = 0; longo totalG = 0; média intG = 0; void setup () {pinMode (redPin, OUTPUT); pinMode (greenPin, OUTPUT); pinMode (bluePin, OUTPUT); for (int thisIndexR = 0; thisIndexR <numIndexR; thisIndexR ++) {// define a matriz como 0 indexR [thisIndexR] = 0; } for (int thisIndexG = 0; thisIndexG = 4500) {// limitar os valores do sensor a um máximo utilizável, isso não é o mesmo para todos os valores de resistor e também pode diferir um pouco de ambiente para ambiente, você pode precisar ajustar isso para suas próprias necessidades. total1 = 4500; } if (total2> = 4500) {total2 = 4500; } totalR = totalR - indexR [posIndexR]; // isso aqui cria uma matriz que adiciona continuamente uma saída de sensor e produz a média. indexR [posIndexR] = total1; totalR = totalR + indexR [posIndexR]; posIndexR = posIndexR + 1; if (posIndexR> = numIndexR) {posIndexR = 0; } médiaR = totalR / numIndexR; // usamos a média em vez dos dados brutos para suavizar a saída, isso torna o processo um pouco mais lento, mas também cria um fluxo suave muito bom. totalG = totalG - indexG [posIndexG]; indexG [posIndexG] = total2; totalG = totalG + indexG [posIndexG]; posIndexG = posIndexG + 1; if (posIndexG> = numIndexG) {posIndexG = 0; } médiaG = totalG / numIndexG; if (averageR> = 2000) {// não queremos que os leds mudem constantemente de valor, a menos que haja uma entrada de sua mão, então isso garante que todas as leituras ambientais inferiores não sejam levadas em consideração. corR = mapa (médiaR, 1000, 4500, 255, 0); analogWrite (redPin, colorR); } else if (averageR = 1000) {colorG = map (averageG, 1000, 4500, 255, 0); analogWrite (greenPin, colorG); } else if (averageG <= 1000) {colorG = 255; analogWrite (greenPin, colorG); } if (colorR <= 125 && colorG <= 125) {// B funciona um pouco diferente porque eu usei apenas 2 sensores, então mapeei B em ambos os sensores colorB = map (colorR, 255, 125, 0, 127.5) + map (corG, 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 (colorB <= 0) {colorB = 0; } analogWrite (bluePin, colorB); } Serial.print (millis () - início); // isso é para fins de depuração Serial.print ("\ t"); Serial.print (colorR); Serial.print ("\ t"); Serial.print (colorG); Serial.print ("\ t"); Serial.println (colorB); atraso (1); }

O que este código faz é extrair os dados brutos do sensor (esses dados sempre serão ligeiramente erráticos devido a todos os diferentes fatores que afetam o sensor) e ele coloca os dados brutos continuamente em uma matriz, quando a matriz atinge seu valor máximo (no meu caso 10) elimina o último valor e adiciona um novo. Cada vez que um valor é adicionado, ele calcula o valor médio e o coloca em uma nova variável. Esta variável média é usada para mapear um valor para um valor de 0 a 255, este é o valor que escrevemos nos pinos RGB para aumentar o brilho de cada canal (os canais sendo R G e B).

Agora, se você carregar seu código para o arduino e abrir o monitor serial, deverá ver os valores RGB mais baixos quando você passar a mão sobre cada sensor e também a cor da luz do led deve mudar.

Etapa 4: agora para o caso:

O caso: Eu fiz o caso usando ferramentas disponíveis na minha universidade, então este fluxo de trabalho não é aplicável para todos. No entanto, não há nada de muito especial nele, ele precisa de um orifício em um lado para a porta USB passar, mas, fora isso, é apenas uma caixa com a tampa aberta.

As dimensões são as seguintes:

15 x 15 CM para o topo transparente

e

15 x 8 CM para a base de madeira (a espessura da madeira era 1,8 CM para mim).

Usei uma serra de mesa para cortar uma placa de MDF nas dimensões corretas que eu precisava (que são 4 painéis de 15 x 8 CM e 1 painel de solo de 15 x 15 CM), depois cortei os cantos em um ângulo de 45 graus. Todas as peças que colei com cola de madeira e pinças (deixe secar pelo menos 30 minutos), usei o mesmo procedimento para o Plexiglas mas com uma lâmina de serra especial.

Um dos lados de madeira deve ter um orifício no centro na altura do plugue USB do arduino para permitir que o arduino seja conectado.

Terminei a base com verniz. Cortei em pedaços ligeiramente maiores do que a superfície de cada lado.

Colei isso, depois fixei 30 minutos para cada lado (melhor fazer individualmente para que não escorregue e depois de secar cortei o que sobrou.

Colei a tampa usando uma cola específica para Acryl chamada Acryfix.

Esteja ciente de que se você usar Plexiglass acrílico, a cola dissolve um pouco o Plexiglass, então seja o mais preciso e rápido possível (seca em alguns minutos, mas exposta ao ar em segundos).

Para finalizar a tampa, polvilhei o cubo com um jato de areia, mas você também pode usar uma lixa fina, só que leva muito mais tempo para ficar uniforme. No entanto, preste atenção se você usar uma lixa, ela precisa ter uma granulação fina e também colar as partes após o procedimento de glaceamento (para não quebrá-la acidentalmente aplicando muita pressão)

Para garantir que a tampa não deslize muito, colei algumas pequenas barras de madeira nas bordas do cubo de madeira.

Etapa 5: o resultado final deve ser semelhante a este:

Etapa 6: Soldar

Se você tem uma placa de circuito, pode começar a soldar todas as peças usando a mesma configuração da sua placa de ensaio.

Minha placa de circuito tem tiras de cobre contínuas para facilitar o uso.

Para cada sensor, cortei um pequeno quadrado para soldar os resistores e os fios.

Os fios de envio (os fios que vão do pino 4 para cada sensor) são soldados em sequência a um quadrado separado, com 1 fio que vai para o pino 4.

Guardei um retângulo comprido para fazer uma tira improvisada de led (meça de forma que caiba dentro da tampa mas nas bordas da base). Você pode simplesmente soldar os leds em seqüência um após o outro (lembre-se na imagem que eu acidentalmente soldei os leds e os resistores do lado errado da placa de circuito, as tiras de cobre devem estar sempre na parte inferior).

Quando terminar de soldar as peças individuais, encaixe-as na caixa. Não soldei meus fios individuais, então posso trocá-los facilmente, se necessário.

Hora de encaixar tudo na base: esta é a etapa mais fácil, o arduino precisa ser colocado primeiro com a porta USB através do orifício na parte traseira do gabinete. Agora adicione os sensores, certifique-se de que a folha do sensor se encaixa na madeira em ambos os lados, com a folha do solo diretamente contra ela. Quando tudo se encaixar bem, conecte os leds RGB nos pinos certos (9, 10, 11) e deixe-os encostar nas bordas da base.

Etapa 7: Pronto

Se você seguiu com tudo isso, agora deve ter uma luz de trabalho com combinação de cores de toque capacitivo. Divirta-se!