Modo de toque capacitivo / Ambilight: 8 etapas

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

Este instrutível é um rápido relato da minha experiência na criação de um moodlight multifuncional. Alguns conhecimentos básicos de circuitos eletrônicos são esperados. O projeto ainda não terminou, algumas funcionalidades adicionais e ajustes precisam ser feitos, mas já está funcional. Se vocês são entusiastas deste instrutível, irei atualizá-lo. No coração do sistema está um Arduino. Ele irá processar a entrada de USB ou cada uma das entradas de toque capacitivo e controlar a luz RGB. Este instrutível é dividido em três seções: - A seção de toque capacitivo cobre os botões de entrada invisíveis- A seção moodlight cobre o controle do moodlight- A seção ambilight cobre a entrada por porta serial, processando valores RGB gerados por um programa de computador para controlar as luzes. Isenção de responsabilidade: a eletrônica pode ser perigosa, você mesmo é responsável por qualquer dano causado. Alguns códigos são coletados de fóruns e podem não conter o nome de seu proprietário. Por favor, me avise e eu adicionarei seu nome.

Etapa 1: Lista de Itens

Os seguintes componentes são necessários para esta instrução: - Cabo Arduino + USB - Placa de ensaio - Fonte de alimentação do computador - 3x tiras RGB, verifique dealextreme.com.- 3x TIP120 FETs, como https://uk.farnell.com/stmicroelectronics/tip120 / darlington-transistor-to-220 / dp / 9804005- Um monte de resistores (6 * 10 kiloOhm, 3 * 2 megaOhm) - Muitos fios. - Ferramentas Toque capacitivo - Anéis de metal para placas de aterramento - Fio ou placa de cobre - Algo para embutir (como uma estante:)

Etapa 2: Toque capacitivo - Noções básicas e circuito

Como estava pintando minhas estantes, tive a oportunidade de "atualizá-las" também. Eu queria controlar o moodlight por meio de um toque invisível. No início, meu plano era usar um IC dedicado para isso (como o Atmel QT240). Mas então me deparei com uma página explicando que o Arduino pode emular um sensor capacitivo por software. O circuito eletrônico pode ser encontrado na imagem, o sensor é um fio de cobre em espiral (apenas um é mostrado para simplificar). A sensibilidade é controlada pelos resistores encontrados antes de cada pino. Eles podem variar de 1 MegaOhm (toque absoluto) a 40 MegaOhm (12-24 polegadas de distância), dependendo se o toque absoluto ou próximo é necessário (acabei usando resistores de 2M Ohm). Experimente com os valores até que o sensor se comporte como desejado. É uma boa ideia instalar alguma superfície condutora (separada por uma peça fina não condutora) conectada ao aterramento dos circuitos na parte de trás de cada espiral. Dessa forma, os sensores ficarão mais estáveis e menos influenciados por ruídos. Mais algumas fotos sobre a instalação dos sensores em uma estante. Um plugue também é instalado para facilitar a conexão com o circuito posteriormente. O filler é usado para esconder tudo, e depois disso estão prontos para serem pintados.

Etapa 3: Toque capacitivo - Código e teste

O código-fonte a seguir pode ser usado no Arduino para depuração, verifique os valores com o monitor serial do arduino. Seis valores são gerados. O primeiro é uma medida do desempenho do sistema. Da segunda à sexta são os valores detectados em cada pino. Os valores devem aumentar ao se aproximar de seu dedo. Caso contrário, verifique se há conexões ruins e interferências. Os valores do resistor podem ser alterados para determinar a sensibilidade. Ao implementar uma estrutura if-then que é ativada em um determinado limite lógico, uma troca pode ser feita. Isso será usado no código arduino final. Mais informações, sugeridas para ler: https://www.arduino.cc/playground/Main/CapSense--- Arduino CapTouch Debugging Code --- # include void setup () {CapSense cs_2_3 = CapSense (2, 4); // resistor de 10M entre os pinos 2 e 4, pino 4 é o pino do sensor, adicionar fio, foilCapSense cs_2_4 = CapSense (2, 7); // resistor de 10M entre os pinos 2 e 7, pino 7 é o pino do sensor, adicionar fio, foilCapSense cs_2_5 = CapSense (2, 8); // resistor de 10M entre os pinos 2 e 8, pino 8 é o pino do sensor, adicionar fio, foilCapSense cs_2_6 = CapSense (2, 12); // resistor de 10M entre os pinos 2 e 12, pino 12 é o pino do sensor, adicionar fio, foilCapSense cs_2_7 = CapSense (2, 13); // resistor de 10M entre os pinos 2 e 13, o pino 13 é o pino do sensor, adicionar fio, foilvoid setup () {Serial.begin (9600);} void loop () {long start = millis (); longo total1 = cs_2_3.capSense (30); longo total2 = cs_2_4.capSense (30); longo total3 = cs_2_5.capSense (30); longo total4 = cs_2_6.capSense (30); longo total5 = cs_2_7.capSense (30); Serial.print (millis () - início); // verifica o desempenho em milissegundos Serial.print ("\ t"); // caractere de tabulação para espaçamento de janela de depuração Serial.print (total1); // imprime a saída do sensor 1 Serial.print ("\ t"); Serial.print (total2); // imprime a saída do sensor 2 Serial.print ("\ t"); Serial.print (total3); // imprime a saída do sensor 3 Serial.print ("\ t"); Serial.print (total4); // imprime a saída do sensor 4 Serial.print ("\ t"); Serial.println (total5); // imprime a saída do sensor 5 delay (10); // atraso arbitrário para limitar os dados à porta serial} --- END ---

Etapa 4: Luz do humor - Noções básicas e circuito

Agora é hora de construir a parte de saída do sistema. Os pinos PWM do arduino serão usados para controlar cada cor. PWM significa modulação por largura de pulso, ao ligar e desligar um pino muito rapidamente os leds serão escurecidos de 0 a 255. Cada pino será amplificado por um FET. Por enquanto, o sistema possui apenas um canal por cor, o que significa que todas as faixas RGB serão controladas de uma vez e 3 pinos PWM são necessários (um para cada cor). No futuro, quero ser capaz de controlar cada uma das minhas quatro faixas RGB. Isso significa 4 * 3 = 12 pinos PWM (e provavelmente um Arduino Mega). Ok, é hora de alguns esquemas! Esta (veja a imagem) é uma representação básica do circuito (logo tornará um mais agradável). Os sensores capacitivos também estão incluídos (parte verde). Basicamente, há três componentes que precisam ser explicados: - FETEste é o amplificador de que estava falando. Possui um Portal, uma Fonte e um Dreno. Amplifica os sentidos de uma pequena corrente no gate (conectado ao Arduino) e abre caminho para a faixa RGB que é acionada em 12 volts. A fonte deve estar em + 12V, drenar em GND (Terra). Verifique a folha de especificações de seu FET para a pinagem exata. Cada canal RGB deve ser posicionado antes de seu próprio FET. Nesse sentido, ele está agindo como uma chave controlada pelo Arduino.- Faixa RGBEsta faixa RGB de 12 volts é do tipo ânodo comum (+). O que significa que o fio comum deve ser conectado a + 12 V e a corrente é drenada por cada um dos canais de cor separados. A tira incorporou resistores, então não se preocupe com isso! - Resistores Três resistores de 10k garantirão que o FET não ligue quando não deveriam ligar. Três outros limitarão a corrente máxima que o FET drenará. Os três resistores superiores já estão na faixa RGB. Soldei os cabos USB às faixas RGB para que possa conectá-los modularmente com facilidade. Plugues de um hub antigo são colocados em minha placa de ensaio. Use uma fonte de alimentação de computador antigo para o juice, 12 V para alimentar a faixa RGB e, eventualmente, 5 V para o circuito se quiser que funcione sem o cabo USB.

Etapa 5: Luz do humor - Código e controle

A luz ambiente é controlada pelos sensores capacitivos. Por enquanto, programei apenas os sensores 2 e 3 para mudança de cor. Os outros sensores ainda não funcionam. Aqui está o código: --- Arduino Mood Control Code --- # include const boolean invert = true; const long timeout = 10000; // Declaração do sensor capacitivoCapSense In1 = CapSense (2, 4); // resistor de 2M entre os pinos 4 e 2, pino 2 é o pino do sensor, adicionar fio, foilCapSense In2 = CapSense (2, 7); // resistor de 2M entre os pinos 4 e 6, pino 6 é o pino do sensor, adicionar fio, foilCapSense In3 = CapSense (2, 8); // resistor de 2M entre os pinos 4 e 8, o pino 8 é o pino do sensor, adicionar fio, foilCapSense In4 = CapSense (2, 12); // resistor de 2M entre os pinos 4 e 8, o pino 8 é o pino do sensor, adicionar fio, foilCapSense In5 = CapSense (2, 13); // 2M resistor entre os pinos 4 e 8, o pino 8 é o pino do sensor, adicionar fio, folha // PWM Pin declarationsint PinR1 = 3; int PinG1 = 5; int PinB1 = 6; // Outras variáveisint Color1 = 128; // começa em um vermelho como a cor Brightness1 = 255; // inicia com brilho totalint RedValue1, GreenValue1, BlueValue1; // O RGB componentsvoid setup () {// define os valores de timeout do sensor In1.set_CS_AutocaL_Millis (timeout); In2.set_CS_AutocaL_Millis (tempo limite); In3.set_CS_AutocaL_Millis (tempo limite); In4.set_CS_AutocaL_Millis (tempo limite); In5.set_CS_AutocaL_Millis (tempo limite);} loop void () {início longo = millis (); longo total1 = In1.capSense (30); longo total2 = In2.capSense (30); longo total3 = In3.capSense (30); longo total4 = In4.capSense (30); longo total5 = In5.capSense (30); if (total2> 150) {Color1 ++; // incrementa a cor if (Color1> 255) {// Color1 = 0; }} else if (total3> 200) {Color1--; // decrementa a cor if (Color1 <0) {// Color1 = 255; } // converter matiz para rgb hueToRGB (Color1, Brightness1); // escreve cores nos pinos PWM analogWrite (PinR1, RedValue1); analogWrite (PinG1, GreenValue1); analogWrite (PinB1, BlueValue1);} // função para converter uma cor em seus componentes Vermelho, Verde e Azul.void hueToRGB (int matiz, int brilho) {unsigned int scaledHue = (matiz * 6); segmento interno sem sinal = scaledHue / 256; // segmento 0 a 5 em torno da roda de cores unsigned int segmentOffset = scaledHue - (segment * 256); // posição dentro do segmento unsigned int compliment = 0; sem sinal int prev = (brilho * (255 - segmentOffset)) / 256; unsigned int next = (brilho * segmentOffset) / 256; if (inverter) {brilho = 255-brilho; elogio = 255; prev = 255-prev; próximo = 255 próximo; } switch (segmento) {case 0: // red RedValue1 = brilho; GreenValue1 = próximo; BlueValue1 = elogio; pausa; caso 1: // amarelo RedValue1 = prev; GreenValue1 = brilho; BlueValue1 = elogio; pausa; caso 2: // verde RedValue1 = elogio; GreenValue1 = brilho; BlueValue1 = próximo; pausa; caso 3: // ciano RedValue1 = elogio; GreenValue1 = prev; BlueValue1 = brilho; pausa; caso 4: // azul RedValue1 = próximo; GreenValue1 = elogio; BlueValue1 = brilho; pausa; case 5: // magenta padrão: RedValue1 = brilho; GreenValue1 = elogio; BlueValue1 = prev; pausa; }}--- FIM ---

Etapa 6: Ambi Light - Lado do Arduino

Claro, seria muito legal poder controlar a luz ambiente do seu computador. Por exemplo, para criar um ambilight ou uma discoteca com som controlado. Esta seção se concentra na parte do ambilight, no futuro adicionarei mais funcionalidades. Bem, não há circuitos adicionais porque estão todos disponíveis no Arduino. O que vamos usar são os recursos de comunicação serial e alguns softwares 'Processing 1.0'. Conecte seu arduino ao computador por um cabo USB (se você estava enviando esboços para ele, ele já está). Para o arduino, teremos que adicionar algum código extra para comunicação serial. O código passará para o modo de escuta, desligando os sensores capacitivos desde que receba os valores RGB do computador. Em seguida, ele define os valores RGB para os pinos PWM. Este é meu código final por enquanto, verifique você mesmo as alterações: --- Arduino Ambilight Code --- # include const boolean invert = true; const long timeout = 10000; long commStart = 0; char val; // Declaração do sensor capacitivoCapSense In1 = CapSense (2, 4); // resistor de 2M entre os pinos 4 e 2, pino 2 é o pino do sensor, adicionar fio, foilCapSense In2 = CapSense (2, 7); // resistor de 2M entre os pinos 4 e 6, pino 6 é o pino do sensor, adicionar fio, foilCapSense In3 = CapSense (2, 8); // resistor de 2M entre os pinos 4 e 8, o pino 8 é o pino do sensor, adicionar fio, foilCapSense In4 = CapSense (2, 12); // resistor de 2M entre os pinos 4 e 8, o pino 8 é o pino do sensor, adicionar fio, foilCapSense In5 = CapSense (2, 13); // 2M resistor entre os pinos 4 e 8, o pino 8 é o pino do sensor, adicionar fio, folha // PWM Pin declarationsint PinR1 = 3; int PinG1 = 5; int PinB1 = 6; // Outras variáveisint Color1 = 128; // começa em um vermelho como a cor Brightness1 = 255; // inicia com brilho totalint RedValue1, GreenValue1, BlueValue1; // Os componentes RGB evitam a configuração () {Serial.begin (9600); // inicia a comunicação serial // define os valores de tempo limite do sensor In1.set_CS_AutocaL_Millis (tempo limite); In2.set_CS_AutocaL_Millis (tempo limite); In3.set_CS_AutocaL_Millis (tempo limite); In4.set_CS_AutocaL_Millis (tempo limite); In5.set_CS_AutocaL_Millis (tempo limite);} loop void () {início longo = millis (); longo total1 = In1.capSense (30); longo total2 = In2.capSense (30); longo total3 = In3.capSense (30); longo total4 = In4.capSense (30); longo total5 = In5.capSense (30); if (Serial.available ()) {// Se os dados estiverem disponíveis para leitura, val = Serial.read (); // leia e armazene em val commStart = millis (); if (val == 'S') {// Se o caractere inicial for recebido, while (! Serial.available ()) {} // Espere até o próximo valor. RedValue1 = Serial.read (); // Assim que estiver disponível, atribua. while (! Serial.available ()) {} // O mesmo que acima. GreenValue1 = Serial.read (); while (! Serial.available ()) {} BlueValue1 = Serial.read (); } Serial.print (RedValue1); Serial.print (GreenValue1); Serial.println (BlueValue1); } else if ((millis () - commStart)> 1000) {if (total2> 150) {Color1 ++; // incrementa a cor if (Color1> 255) {// Color1 = 0; }} else if (total3> 200) {Color1--; // decrementa a cor if (Color1 <0) {// Color1 = 255; }} hueToRGB (Color1, Brightness1); } analogWrite (PinR1, RedValue1); analogWrite (PinG1, GreenValue1); analogWrite (PinB1, BlueValue1);} // função para converter uma cor em seus componentes Vermelho, Verde e Azul.void hueToRGB (int matiz, int brilho) {unsigned int scaledHue = (matiz * 6); segmento interno sem sinal = scaledHue / 256; // segmento 0 a 5 em torno da roda de cores unsigned int segmentOffset = scaledHue - (segment * 256); // posição dentro do segmento unsigned int compliment = 0; sem sinal int prev = (brilho * (255 - segmentOffset)) / 256; unsigned int next = (brilho * segmentOffset) / 256; if (inverter) {brilho = 255-brilho; elogio = 255; prev = 255-prev; próximo = 255 próximo; } switch (segmento) {case 0: // red RedValue1 = brilho; GreenValue1 = próximo; BlueValue1 = elogio; pausa; caso 1: // amarelo RedValue1 = prev; GreenValue1 = brilho; BlueValue1 = elogio; pausa; caso 2: // verde RedValue1 = elogio; GreenValue1 = brilho; BlueValue1 = próximo; pausa; caso 3: // ciano RedValue1 = elogio; GreenValue1 = prev; BlueValue1 = brilho; pausa; caso 4: // azul RedValue1 = próximo; GreenValue1 = elogio; BlueValue1 = brilho; pausa; case 5: // magenta padrão: RedValue1 = brilho; GreenValue1 = elogio; BlueValue1 = prev; pausa; }}--- FIM ---

Etapa 7: Ambi Light - lado do computador

Na lateral do computador, um esboço do Processing 1.0 é executado, consulte processing.org. Este pequeno programa (um tanto confuso) calcula a cor de tela média a cada instante e a envia para a porta serial. É muito básico ainda e poderia precisar de alguns ajustes, mas funciona muito bem! Vou atualizá-lo no futuro para várias tiras RGB e seções de tela separadas. Você também pode fazer isso, a linguagem é bastante direta. Aqui está o código: --- 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); //size(screen.width, screen.height); // Imprime uma lista das portas seriais, para fins de depuração: println (Serial.list ()); // Eu sei que a primeira porta na lista serial no meu mac // é sempre meu adaptador FTDI, então eu abro Serial.list () [0]. // Em máquinas Windows, isso geralmente abre COM1. // Abra qualquer porta que você está usando. String portName = Serial.list () [0]; myPort = new Serial (this, portName, 9600);} void draw () {// imagem (screenShot, 0, 0, largura, altura); screenShot = getScreen (); cor kleur = cor (0, 0, 0); kleur = cor (screenShot); //myPort.write(int(red(kleur))+ ',' + int (green (kleur)) + ',' + int (blue (kleur)) + 13); //myPort.write(int(red(kleur))); //myPort.write (','); //myPort.write(int(green(kleur))); //myPort.write (','); //myPort.write(int(blue(kleur))); //myPort.write(13); encher (kleur); rect (30, 20, 55, 55);} cor da cor (imagem img) {int cols = (img.width); linhas int = (img.height); dimensão int = (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.pixels >> 8) & 0xFF); b = b + (img.pixels & 0xFF);} int média_r = r / (dimensão / 2); int média_g = g / (dimensão / 2); int média_b = b / (dimensão / 2); cor mean_clr = cor (mean_r, mean_g, mean_b); myPort.write ('S'); myPort.write (mean_r); myPort.write (mean_g); myPort.write (mean_b); return (mean_clr);} PImage getScreen () {GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment (); GraphicsDevice gs = ge.getScreenDevices (); Modo DisplayMode = gs [0].getDisplayMode (); Limites do retângulo = novo Retângulo (0, 0, mode.getWidth (), mode.getHeight ()); BufferedImage desktop = novo BufferedImage (mode.getWidth (), mode.getHeight (), BufferedImage. TYPE_INT_RGB); tente {desktop = novo robô (gs [0]). createScreenCapture (limites); } catch (AWTException e) {System.err.println ("Falha na captura de tela."); } return (new PImage (desktop));} --- END ---

Etapa 8: Resultado

E este é o resultado, na verdade está embaixo da minha cama. Ainda preciso trocar o pano, vai difundir mais a luz. Mais fotos em breve. Espero que gostem deste instrutível e também espero que seja uma base para sua própria criatividade. Por causa das limitações de tempo, escrevi muito rapidamente. Você pode precisar ter algum conhecimento básico de arduino / eletrônica para entendê-lo, mas pretendo atualizá-lo no futuro se for bem recebido.