Modo táctil capacitivo / Ambilight: 8 pasos

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:45

Este instructivo es una reseña rápida de mi experiencia al crear una luz ambiental multifuncional. Se espera algún conocimiento básico de circuitos electrónicos. El proyecto aún no ha terminado, se deben agregar algunas funciones y ajustes, pero ya es funcional. Si están entusiasmados con este instructable, lo actualizaré. En el corazón del sistema hay un Arduino. Procesará la entrada desde USB o cada una de las entradas táctiles capacitivas y controlará la luz RGB. Este instructable se divide en tres secciones: - La sección táctil capacitiva cubre los botones de entrada invisibles - La sección de luz de ambiente cubre el control de la luz de ambiente - La sección de ambilight cubre la entrada por puerto serie, procesando los valores RGB generados por un programa de computadora para controlar las luces Descargo de responsabilidad: la electrónica puede ser peligrosa, usted mismo es responsable de cualquier daño causado. Parte del código se recopila de foros y es posible que no contenga el nombre de su propietario. Por favor avíseme y agregaré su nombre.

Paso 1: Lista de artículos

Los siguientes componentes son necesarios para este instructable: - Arduino + cable USB- Placa de pruebas- Fuente de alimentación de la computadora- 3 tiras RGB, echa un vistazo a dealextreme.com.- 3 FETs TIP120, como https://uk.farnell.com/stmicroelectronics/tip120 / darlington-transistor-to-220 / dp / 9804005- Un montón de resistencias (6 * 10 kiloOhm, 3 * 2 megaOhm) - Mucho cable. - Herramientas Tacto capacitivo - Anillos metálicos para placas de tierra - Alambre o placa de cobre - Algo para construirlo (como una estantería:)

Paso 2: Tacto capacitivo - Conceptos básicos y circuito

Como estaba pintando mis estanterías, tuve la oportunidad de 'actualizarlas' también. Quería controlar la luz ambiental mediante un toque invisible. Al principio, mi plan era usar un IC dedicado para esto (como el Atmel QT240). Pero luego me encontré con una página que explica que el Arduino puede emular un sensor capacitivo por software. El circuito electrónico se puede encontrar en la imagen, el sensor es un cable de cobre en espiral (solo se muestra uno por simplicidad). La sensibilidad está controlada por las resistencias que se encuentran antes de cada pin. Pueden variar desde 1 MegaOhm (toque absoluto) hasta 40 MegaOhm (12-24 pulgadas de distancia) dependiendo de si se necesita un toque absoluto o cercano (terminé usando resistencias de 2M Ohm). Experimente con los valores hasta que el sensor se comporte como desee. Es una buena idea instalar alguna superficie conductora (separada por una pieza delgada no conductora) conectada a la tierra de los circuitos en la parte posterior de cada espiral. De esta manera los sensores serán más estables y menos influenciados por el ruido. Algunas imágenes más sobre la instalación de los sensores en una estantería. También se instala un enchufe para facilitar la conexión con el circuito más adelante. El relleno se usa para ocultar todo, y luego están listos para ser pintados.

Paso 3: Tacto capacitivo - Código y prueba

El siguiente código fuente se puede usar en Arduino para depurar, verifique los valores con el monitor serial arduino. Se generan seis valores. La primera es una medida del rendimiento del sistema. Del segundo al sexto son los valores detectados en cada pin. Los valores deberían aumentar al acercarse a su dedo. Si no es así, compruebe si hay malas conexiones e interferencias. Los valores de la resistencia se pueden cambiar para determinar la sensibilidad. Al implementar una estructura si-entonces que se activa en un cierto umbral lógico, se puede realizar un cambio. Esto se utilizará en el código arduino final. Más información, sugerida para leer: https://www.arduino.cc/playground/Main/CapSense--- Código de depuración de Arduino CapTouch --- # include void setup () {CapSense cs_2_3 = CapSense (2, 4); // Resistencia de 10M entre los pines 2 y 4, el pin 4 es el pin del sensor, agregar cable, foilCapSense cs_2_4 = CapSense (2, 7); // Resistencia de 10M entre los pines 2 y 7, el pin 7 es el pin del sensor, agregar cable, foilCapSense cs_2_5 = CapSense (2, 8); // Resistencia de 10M entre los pines 2 y 8, el pin 8 es el pin del sensor, agregar cable, foilCapSense cs_2_6 = CapSense (2, 12); // Resistencia de 10M entre los pines 2 y 12, el pin 12 es el pin del sensor, agregar cable, foilCapSense cs_2_7 = CapSense (2, 13); // Resistencia de 10M entre los pines 2 y 13, el pin 13 es el pin del sensor, agregar cable, foilvoid setup () {Serial.begin (9600);} void loop () {long start = millis (); long total1 = cs_2_3.capSense (30); long total2 = cs_2_4.capSense (30); long total3 = cs_2_5.capSense (30); long total4 = cs_2_6.capSense (30); long total5 = cs_2_7.capSense (30); Serial.print (millis () - inicio); // verifica el rendimiento en milisegundos Serial.print ("\ t"); // carácter de tabulación para el espaciado de ventanas de depuración Serial.print (total1); // imprime la salida del sensor 1 Serial.print ("\ t"); Serial.print (total2); // imprime la salida del sensor 2 Serial.print ("\ t"); Serial.print (total3); // imprime la salida del sensor 3 Serial.print ("\ t"); Serial.print (total4); // imprime la salida del sensor 4 Serial.print ("\ t"); Serial.println (total5); // imprime la salida del sensor 5 delay (10); // retraso arbitrario para limitar los datos al puerto serie} --- FIN ---

Paso 4: Luz de estado de ánimo - Conceptos básicos y circuito

Ahora es el momento de construir la parte de salida del sistema. Los pines PWM de arduino se utilizarán para controlar cada color. PWM significa Modulación de ancho de pulso, al encender y apagar un pin muy rápidamente los leds se atenuarán de 0 a 255. Cada pin será amplificado por un FET. Por ahora, el sistema tiene solo un canal por color, lo que significa que todas las tiras RGB se controlarán a la vez y se necesitan 3 pines PWM (uno para cada color). En el futuro, quiero poder controlar cada una de mis cuatro tiras RGB. Eso significa 4 * 3 = 12 pines PWM (y probablemente un Arduino Mega). ¡Ok, es hora de algunos esquemas! Esta (ver imagen) es una representación básica del circuito (pronto será una mejor). También se incluyen los sensores capacitivos (parte verde). Básicamente hay tres componentes que hay que explicar: - FET Este es el amplificador del que estaba hablando. Tiene una Puerta, una Fuente y un Drenaje. Amplifica los sentidos con una pequeña corriente en la puerta (conectada al Arduino) y abre el camino para la tira RGB que funciona con 12 voltios. La fuente debe estar en + 12V, el drenaje en GND (Tierra). Consulte la hoja de especificaciones de su FET para conocer la configuración exacta. Cada canal RGB debe colocarse antes de su propio FET. En este sentido, está actuando como un interruptor controlado por Arduino.- Tira RGB Esta tira RGB de 12 voltios es del tipo ánodo común (+). Es decir, que el cable común debe conectarse a + 12V y la corriente se absorbe a través de cada uno de los canales de color separados. La tira tiene resistencias incorporadas, ¡así que no se preocupe por eso! - Resistencias Tres resistencias de 10k se asegurarán de que el FET no se encienda cuando se supone que no deben encenderse. Otros tres limitarán la corriente máxima que drenará el FET. Las tres resistencias superiores ya están en la tira RGB. Soldeé cables USB a las tiras RGB para poder conectarlos modularmente fácilmente. Se colocan enchufes de un hub viejo en mi tablero. Use una fuente de alimentación de computadora vieja para el jugo, 12V para alimentar la tira RGB y eventualmente 5V para el circuito si desea que funcione sin el cable USB.

Paso 5: Luz de estado de ánimo - Código y control

La luz ambiental está controlada por sensores capacitivos. Por ahora, solo programé los sensores 2 y 3 para el cambio de color. Los otros sensores aún no funcionan. Aquí está el código: --- Código de control de estado de ánimo de Arduino --- # incluye const boolean invert = true; const long timeout = 10000; // Declaración del sensor capacitivo CapSense In1 = CapSense (2, 4); // Resistencia de 2M entre los pines 4 y 2, el pin 2 es el pin del sensor, agregar cable, foilCapSense In2 = CapSense (2, 7); // Resistencia de 2M entre los pines 4 y 6, el pin 6 es el pin del sensor, agregar cable, foilCapSense In3 = CapSense (2, 8); // Resistencia de 2M entre los pines 4 y 8, el pin 8 es el pin del sensor, agregar cable, foilCapSense In4 = CapSense (2, 12); // Resistencia de 2M entre los pines 4 y 8, el pin 8 es el pin del sensor, agregar cable, foilCapSense In5 = CapSense (2, 13); // Resistencia de 2M entre los pines 4 y 8, el pin 8 es el pin del sensor, agregar cable, lámina // Declaraciones de pin PWMint PinR1 = 3; int PinG1 = 5; int PinB1 = 6; // Otras variablesint Color1 = 128; // comienza en un rojo como colorint Brightness1 = 255; // comienza con el brillo máximoint RedValue1, GreenValue1, BlueValue1; // El componente RGB evita setup () {// establece los valores de tiempo de espera del sensor In1.set_CS_AutocaL_Millis (timeout); In2.set_CS_AutocaL_Millis (tiempo de espera); In3.set_CS_AutocaL_Millis (tiempo de espera); In4.set_CS_AutocaL_Millis (tiempo de espera); In5.set_CS_AutocaL_Millis (tiempo de espera);} void loop () {inicio largo = millis (); total1 largo = In1.capSense (30); long total2 = In2.capSense (30); long total3 = In3.capSense (30); long total4 = In4.capSense (30); long total5 = In5.capSense (30); si (total2> 150) {Color1 ++; // incrementa el color if (Color1> 255) {// Color1 = 0; }} más si (total3> 200) {Color1--; // decrementa el color if (Color1 <0) {// Color1 = 255; } // convierte el tono a rgb hueToRGB (Color1, Brightness1); // escribe colores en los pines PWM analogWrite (PinR1, RedValue1); analogWrite (PinG1, GreenValue1); analogWrite (PinB1, BlueValue1);} // función para convertir un color a sus componentes rojo, verde y azul. void hueToRGB (int matiz, int brillo) {unsigned int scaledHue = (matiz * 6); segmento int sin firmar = scaledHue / 256; // segmento 0 a 5 alrededor de la rueda de colores unsigned int segmentoOffset = scaledHue - (segmento * 256); // posición dentro del segmento unsigned int compliment = 0; unsigned int prev = (brillo * (255 - segmentoOffset)) / 256; unsigned int next = (brillo * segmentoOffset) / 256; if (invertir) {brillo = 255-brillo; cumplido = 255; prev = 255-prev; siguiente = 255-siguiente; } cambiar (segmento) {caso 0: // rojo RedValue1 = brillo; GreenValue1 = siguiente; BlueValue1 = cumplido; rotura; caso 1: // amarillo RedValue1 = prev; GreenValue1 = brillo; BlueValue1 = cumplido; rotura; caso 2: // verde RedValue1 = cumplido; GreenValue1 = brillo; BlueValue1 = siguiente; rotura; caso 3: // cian RedValue1 = cumplido; GreenValue1 = anterior; BlueValue1 = brillo; rotura; caso 4: // azul RedValue1 = siguiente; GreenValue1 = cumplido; BlueValue1 = brillo; rotura; caso 5: // magenta predeterminado: RedValue1 = brillo; GreenValue1 = cumplido; BlueValue1 = anterior; rotura; }}--- FIN ---

Paso 6: Ambi Light - Lado de Arduino

Por supuesto, sería genial poder controlar la luz ambiental desde tu computadora. Por ejemplo, para crear un ambilight o una discoteca con control de sonido. Esta sección se enfoca en la parte ambilight, en el futuro agregaré más funcionalidad. Bueno, no hay circuitos adicionales porque todo está disponible en el Arduino. Lo que vamos a utilizar son las capacidades de comunicación en serie y algún software 'Processing 1.0'. Conecte su arduino a su computadora con un cable USB (si estaba cargando bocetos, ya lo está). Para el arduino, tendremos que agregar un código adicional para la comunicación en serie. El código cambiará al modo de escucha, apagando los sensores capacitivos siempre que reciba valores RGB de la computadora. Luego establece los valores RGB en los pines PWM. Este es mi código final por ahora, verifique los cambios usted mismo: --- Código Arduino Ambilight --- # include const boolean invert = true; const long timeout = 10000; long commStart = 0; char val; // Declaración del sensor capacitivo CapSense In1 = CapSense (2, 4); // Resistencia de 2M entre los pines 4 y 2, el pin 2 es el pin del sensor, agregar cable, foilCapSense In2 = CapSense (2, 7); // Resistencia de 2M entre los pines 4 y 6, el pin 6 es el pin del sensor, agregar cable, foilCapSense In3 = CapSense (2, 8); // Resistencia de 2M entre los pines 4 y 8, el pin 8 es el pin del sensor, agregar cable, foilCapSense In4 = CapSense (2, 12); // Resistencia de 2M entre los pines 4 y 8, el pin 8 es el pin del sensor, agregar cable, foilCapSense In5 = CapSense (2, 13); // Resistencia de 2M entre los pines 4 y 8, el pin 8 es el pin del sensor, agregar cable, lámina // Declaraciones de pin PWMint PinR1 = 3; int PinG1 = 5; int PinB1 = 6; // Otras variablesint Color1 = 128; // comienza en un rojo como colorint Brightness1 = 255; // comienza con el brillo máximoint RedValue1, GreenValue1, BlueValue1; // Los componentes RGB void setup () {Serial.begin (9600); // iniciar la comunicación en serie // establecer los valores de tiempo de espera del sensor In1.set_CS_AutocaL_Millis (tiempo de espera); In2.set_CS_AutocaL_Millis (tiempo de espera); In3.set_CS_AutocaL_Millis (tiempo de espera); In4.set_CS_AutocaL_Millis (tiempo de espera); In5.set_CS_AutocaL_Millis (tiempo de espera);} void loop () {inicio largo = millis (); total1 largo = In1.capSense (30); long total2 = In2.capSense (30); long total3 = In3.capSense (30); long total4 = In4.capSense (30); long total5 = In5.capSense (30); if (Serial.available ()) {// Si hay datos disponibles para leer, val = Serial.read (); // leerlo y almacenarlo en val commStart = millis (); if (val == 'S') {// Si se recibe el carácter inicial, while (! Serial.available ()) {} // Espere hasta el próximo valor. RedValue1 = Serial.read (); // Una vez disponible, asigne. while (! Serial.available ()) {} // Igual que arriba. 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 el color if (Color1> 255) {// Color1 = 0; }} else if (total3> 200) {Color1--; // decrementa el color if (Color1 <0) {// Color1 = 255; }} hueToRGB (Color1, Brillo1); } analogWrite (PinR1, RedValue1); analogWrite (PinG1, GreenValue1); analogWrite (PinB1, BlueValue1);} // función para convertir un color a sus componentes rojo, verde y azul. void hueToRGB (int matiz, int brillo) {unsigned int scaledHue = (matiz * 6); segmento int sin firmar = scaledHue / 256; // segmento 0 a 5 alrededor de la rueda de colores unsigned int segmentoOffset = scaledHue - (segmento * 256); // posición dentro del segmento unsigned int compliment = 0; unsigned int prev = (brillo * (255 - segmentoOffset)) / 256; unsigned int next = (brillo * segmentoOffset) / 256; if (invertir) {brillo = 255-brillo; cumplido = 255; prev = 255-prev; siguiente = 255-siguiente; } cambiar (segmento) {caso 0: // rojo RedValue1 = brillo; GreenValue1 = siguiente; BlueValue1 = cumplido; rotura; caso 1: // amarillo RedValue1 = prev; GreenValue1 = brillo; BlueValue1 = cumplido; rotura; caso 2: // verde RedValue1 = cumplido; GreenValue1 = brillo; BlueValue1 = siguiente; rotura; caso 3: // cian RedValue1 = cumplido; GreenValue1 = anterior; BlueValue1 = brillo; rotura; caso 4: // azul RedValue1 = siguiente; GreenValue1 = cumplido; BlueValue1 = brillo; rotura; caso 5: // magenta predeterminado: RedValue1 = brillo; GreenValue1 = cumplido; BlueValue1 = anterior; rotura; }}--- FIN ---

Paso 7: Ambi Light - Lado de la computadora

En el costado de la computadora se ejecuta un boceto de Processing 1.0, consulte Processing.org. Este pequeño (algo desordenado) programa calcula el color promedio de la pantalla en cada instante y lo envía al puerto serie. Es muy básico hasta ahora y podría necesitar algunos ajustes, ¡pero funciona muy bien! Lo actualizaré en el futuro para múltiples tiras RGB y secciones de pantalla separadas. También puede hacerlo usted mismo, el lenguaje es bastante sencillo. Aquí está el 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 una lista de los puertos seriales, con fines de depuración: println (Serial.list ()); // Sé que el primer puerto en la lista serial en mi mac // es siempre mi adaptador FTDI, entonces abro Serial.list () [0]. // En máquinas con Windows, esto generalmente abre COM1. // Abra el puerto que esté usando. String portName = Serial.list () [0]; myPort = new Serial (this, portName, 9600);} void draw () {// image (captura de pantalla, 0, 0, ancho, alto); screenShot = getScreen (); color kleur = color (0, 0, 0); kleur = color (captura de pantalla); //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); llenar (kleur); rect (30, 20, 55, 55);} color color (PImage img) {int cols = (img.width); int filas = (img.height); int dimensión = (img.width * img.height); int r = 0; int g = 0; int b = 0; img.loadPixels (); // Ga el tamaño de píxeles (dimensión) para (int i = 0; i <(dimensión / 2); i ++) {r = r + ((img.pixels >> 16) & 0xFF); g = g + ((img.pixeles >> 8) & 0xFF); b = b + (img.pixels & 0xFF);} int mean_r = r / (dimension / 2); int mean_g = g / (dimension / 2); int mean_b = b / (dimension / 2); color mean_clr = color (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 (); Límites de rectángulo = new Rectangle (0, 0, mode.getWidth (), mode.getHeight ()); BufferedImage desktop = new BufferedImage (mode.getWidth (), mode.getHeight (), BufferedImage. TYPE_INT_RGB); intente {escritorio = nuevo Robot (gs [0]). createScreenCapture (límites); } catch (AWTException e) {System.err.println ("Falló la captura de pantalla"); } return (nueva PImage (escritorio));} --- FIN ---

Paso 8: Resultado

Y este es el resultado, en realidad está en el lado inferior de mi cama. Todavía necesito reemplazar el paño, difundirá más la luz. Más fotos sobre eso pronto. Espero que les guste este instructivo y también espero que sea una base para su propia creatividad. Debido a las limitaciones de tiempo, lo escribí muy rápido. Es posible que deba tener algunos conocimientos básicos de arduino / electrónica para comprenderlo, pero planeo actualizarlo en el futuro si es bien recibido.