El sistema de control de luces de 8 canales con teclado PS/2 y Arduino es un proyecto que combina la versatilidad de la plataforma Arduino con la comodidad de un teclado estándar PS/2 para controlar la iluminación de hasta ocho canales diferentes.
Este sistema permite a los usuarios encender y apagar luces individuales o grupos de luces mediante la entrada de comandos desde el teclado PS/2. Utilizando el Arduino como el cerebro del sistema, el teclado se conecta al microcontrolador a través de un adaptador PS/2 y se programa para interpretar los comandos del usuario.
Tal vez pueda interesarte proyectos en arduino, pic, robótica, telecomunicaciones, suscribete en http://www.youtube.com/user/carlosvolt?sub_confirmation=1 mucho videos con código fuentes completos y diagramas
Cada canal de luz está conectado a una salida del Arduino, lo que permite un control independiente sobre cada uno. Los usuarios pueden asignar teclas específicas del teclado a cada canal, lo que facilita la personalización y la operación intuitiva del sistema.
Además, este proyecto es altamente escalable, lo que significa que se pueden agregar más canales de luz fácilmente simplemente agregando más salidas al Arduino y asignando nuevas teclas desde el teclado PS/2.
El sistema de control de luces de 8 canales con teclado PS/2 y Arduino ofrece una solución flexible y accesible para controlar la iluminación en diversos entornos, desde sistemas de iluminación domésticos hasta aplicaciones de escenarios y espectáculos.
Componentes electrónicos
Arduino Nano
El Arduino Nano es una placa pequeña, completa y compatible con la placa de pruebas basada en el ATmega328 (Arduino Nano 3.x). Tiene más o menos la misma funcionalidad del Arduino Duemilanove, pero en un paquete diferente. Solo carece de un conector de alimentación de CC y funciona con un cable USB Mini-B en lugar de uno estándar.
| Microcontrolador | ATmega328 |
| Arquitectura | AVR |
| Tensión de funcionamiento | 5 V |
| Memoria flash | 32 KB de los cuales 2 KB utiliza el gestor de arranque |
| SRAM | 2 KB |
| Velocidad de reloj | 16 MHz |
| Pines analógicos IN | 8 |
| EEPROM | 1 KB |
| Corriente CC por pines de E / S | 40 mA (pines de E / S) |
| Voltaje de entrada | 7-12 V |
| Pines de E / S digitales | 22 (6 de los cuales son PWM) |
| Salida PWM | 6 |
| El consumo de energía | 19 mA |
| Tamaño de PCB | 18 x 45 mm |
| Peso | 7 g |
Diagrama de pines
Pines hembra
Pines macho
Zócalo para arduino nano
Un diodo led de 5 mm
Ocho resistores
Cables Dupont
Circuito impreso (pcb)
Archivo gerber —> pcb
Conector PS/2
Características
Interfaz estándar PS/2;
La fuente de alimentación debe ser de 5V CC;
4 orificios de montaje de tornillos cuyo diámetro es de 2,2mm
Fácil de usar
Interfaz
Interfaz de control:Un total de cuatro pines (GND, VCC, DAT, CLK), GND a tierra, VCC es la fuente de alimentación, DAT es el pin de entrada y salida de datos, CLK es el pin de señal de reloj.
Un teclado PS/2
Módulo relay de 8 canales (Opcional)
Características
Permite controlar el encendido/apagado de equipos de alta potencia (electrodomésticos). Funciona perfectamente con Arduino, Pic o cualquier otro sistema digital.
Dentro de la gran variedad de proyectos que podemos realizar con Arduino, podemos llegar a desear controlar componentes de alto voltaje o alto amperaje, como bombillas o bombas de agua, los cuales no pueden ser manejados directamente con Arduino. En estos casos es necesario utilizar Relays o Reles, estos dispositivos permiten controlar cargas de alto voltaje con una señal pequeña.
El modulo posee 8 Relays de alta calidad, capaces de manejar cargas de hasta 250V/10A. Cada canal posee aislamiento eléctrico por medio de un optoacoplador y un led indicador de estado. Su diseño facilita el trabajo con Arduino, al igual que con muchos otros sistemas como Raspberry Pi, ESP8266 (NodeMCU y Wemos), Teensy y Pic. Este modulo Relay activa la salida normalmente abierta (NO: Normally Open) al recibir un “0” lógico (0 Voltios) y desactiva la salida con un “1” lógico (5 voltios). Para la programación de Arduino y Relays se recomienda el uso de timers con la función “millis()” y de esa forma no utilizar la función “delay” que impide que el sistema continue trabajando mientras se activa/desactiva un relay.
Entre las cargas que se pueden manejar tenemos: bombillas de luz, luminarias, motores AC (220V), motores DC, solenoides, electroválvulas, calentadores de agua y una gran variedad de actuadores más. Se recomienda realizar y verificar las conexiones antes de alimentar el circuito, también es una buena práctica proteger el circuito dentro de un case.
Datos técnicos
8 canales independientes
8 Relevadores (Relays) de 1 polo 2 tiros
El voltaje de la bobina del relé es de 5 VDC
Led indicador para cada canal (enciende cuando la bobina del relé esta activa)
Activado mediante corriente: el circuito de control debe proveer una corriente de 15 a 20 mA
Puede controlado directamente por circuito lógicos
Terminales de conexión de tornillo (clemas)
Terminales de entrada de señal lógica con headers macho de 0.1″.
Puede controlado directamente por circuito lógicos
Alimentación y consumo
La forma mas sencilla de alimentar este módulo es desde Vcc y GND de la placa Arduino, manteniendo el Jumper en su lugar, con lo que JD-Vcc = Vcc. Esta conexión tiene dos limitaciones importantes:
Se pierde la aislación eléctrica que brindan los optoacopladores, lo que aumenta la posibilidad de daño al Arduino si hay algún problema con las cargas de los relés.
La corriente consumida por las bobinas de los relés debe ser provista por la placa Arduino. Cada bobina consume unos 90 mA y las cuatro juntas suman 360 mA. Si a esto le sumamos los consumos que pueden tener otras salidas, estamos muy cerca de los 500 mA que puede suministrar un puerto USB. En este caso se debería alimentar al Arduino con una fuente externa, lo que aumenta el limite de corriente a 1 A (en el caso de la Arduino UNO).
La forma mas segura es remover el jumper y alimentar la placa de relés con dos fuentes: la de la placa Arduino conectada a Vcc y una segunda fuente, con el positivo a JD-Vcc y el negativo a GND, sin estar éste unido a la placa Arduino. Esta conexión tiene como ventajas:
Hay completa aislación entre la carga y el Arduino.
Todo el consumo de los relés es tomado de la segunda fuente y no del Arduino o el puerto USB.
Entradas
Las entradas a la placa pueden conectarse directamente a las salidas digitales de la placa Arduino. La única precaución a tener en cuenta es que cuando Arduino arranca al ser alimentado, los pines se configuran como entradas automáticamente y puede ocurrir que, por un brevísimo lapso de tiempo entre el arranque y la correcta configuración de estos pines como salidas, las entradas de control al módulo de relé queden en un estado indeterminado. Esto se puede evitar conectando en cada entrada un pull-up con una resistencia de 10K a Vcc, lo que asegura un estado ALTO durante el arranque.
Circuito
Código Fuente
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 |
#include "ps2_Keyboard.h"//Instalar librería ps2KeyboardHost #include "ps2_AnsiTranslator.h" #include "ps2_SimpleDiagnostics.h" int pin4 = 4; int pin5 = 5; int pin6 = 6; int pin7 = 7; int pin8 = 8; int pin9 = 9; int pin10 = 10; int pin11 = 11; int estadoPin4 = 0; int estadoPin5 = 0; int estadoPin6 = 0; int estadoPin7 = 0; int estadoPin8 = 0; int estadoPin9 = 0; int estadoPin10 = 0; int estadoPin11 = 0; typedef ps2::SimpleDiagnostics<254> Diagnostics_; static Diagnostics_ diagnostics; static ps2::AnsiTranslator<Diagnostics_> keyMapping(diagnostics); static ps2::Keyboard<3,2,1, Diagnostics_> ps2Keyboard(diagnostics); static ps2::KeyboardLeds lastLedSent = ps2::KeyboardLeds::none; void setup() { Serial.begin(9600); pinMode(pin4, OUTPUT); pinMode(pin5, OUTPUT); pinMode(pin6, OUTPUT); pinMode(pin7, OUTPUT); pinMode(pin8, OUTPUT); pinMode(pin9, OUTPUT); pinMode(pin10, OUTPUT); pinMode(pin11, OUTPUT); digitalWrite(pin4, LOW); digitalWrite(pin5, LOW); digitalWrite(pin6, LOW); digitalWrite(pin7, LOW); digitalWrite(pin8, LOW); digitalWrite(pin9, LOW); digitalWrite(pin10, LOW); digitalWrite(pin11, LOW); ps2Keyboard.begin(); keyMapping.setNumLock(true); ps2Keyboard.awaitStartup(); diagnostics.reset(); //Encendemos el led del teclado(Bloq Num) ps2Keyboard.sendLedStatus(ps2::KeyboardLeds::numLock); lastLedSent = ps2::KeyboardLeds::numLock; } void loop() { diagnostics.setLedIndicator<LED_BUILTIN>(); ps2::KeyboardOutput scanCode = ps2Keyboard.readScanCode(); if (scanCode == ps2::KeyboardOutput::garbled) { keyMapping.reset(); } else if (scanCode != ps2::KeyboardOutput::none) { char buf[2]; buf[1] = '\0'; buf[0] = keyMapping.translatePs2Keycode(scanCode); if (buf[0] == '\r') {//Se cumple si es la tecla enter Serial.println(); } else if (buf[0] >= ' ') { // Se cumple si es un caracter Serial.write(buf); //Tecla 1 if (buf[0] == '1'){ if(estadoPin4 ==0){//Si la variable estado2 es igual a 0 se cumple esta condición digitalWrite(pin4, HIGH); Serial.println("Relay 1 activado"); estadoPin4 =1;//Asignamos el valor 1 a la variable "estadoPin4" } else{ digitalWrite(pin4, LOW); Serial.println("Relay 1 desactivado"); estadoPin4 =0; } } //Tecla 2 if (buf[0] == '2'){ if(estadoPin5 ==0){//Si la variable estado2 es igual a 0 se cumple esta condición digitalWrite(pin5, HIGH); Serial.println("Relay 2 activado"); estadoPin5 =1;//Asignamos el valor 1 a la variable "estadoPin5" } else{ digitalWrite(pin5, LOW); Serial.println("Relay 2 desactivado"); estadoPin5 =0; } } //Tecla 3 if (buf[0] == '3'){ if(estadoPin6 ==0){//Si la variable estado2 es igual a 0 se cumple esta condición digitalWrite(pin6, HIGH); Serial.println("Relay 3 activado"); estadoPin6 =1;//Asignamos el valor 1 a la variable "estadoPin6" } else{ digitalWrite(pin6, LOW); Serial.println("Relay 3 desactivado"); estadoPin6 =0; } } //Tecla 4 if (buf[0] == '4'){ if(estadoPin7 ==0){//Si la variable estado2 es igual a 0 se cumple esta condición digitalWrite(pin7, HIGH); Serial.println("Relay 4 activado"); estadoPin7 =1;//Asignamos el valor 1 a la variable "estadoPin7" } else{ digitalWrite(pin7, LOW); Serial.println("Relay 4 desactivado"); estadoPin7 =0; } } //Tecla 5 if (buf[0] == '5'){ if(estadoPin8 ==0){//Si la variable estado2 es igual a 0 se cumple esta condición digitalWrite(pin8, HIGH); Serial.println("Relay 5 activado"); estadoPin8 =1;//Asignamos el valor 1 a la variable "estadoPin8" } else{ digitalWrite(pin8, LOW); Serial.println("Relay 5 desactivado"); estadoPin8 =0; } } //Tecla 6 if (buf[0] == '6'){ if(estadoPin9 ==0){//Si la variable estado2 es igual a 0 se cumple esta condición digitalWrite(pin9, HIGH); Serial.println("Relay 6 activado"); estadoPin9 =1;//Asignamos el valor 1 a la variable "estadoPin9" } else{ digitalWrite(pin9, LOW);; Serial.println("Relay 6 desactivado"); estadoPin9 =0; } } //Tecla 7 if (buf[0] == '7'){ if(estadoPin10 ==0){//Si la variable estado2 es igual a 0 se cumple esta condición digitalWrite(pin10, HIGH); Serial.println("Relay 7 activado"); estadoPin10 =1;//Asignamos el valor 1 a la variable "estadoPin10" } else{ digitalWrite(pin10, LOW);; Serial.println("Relay 7 desactivado"); estadoPin10 =0; } } //Tecla 8 if (buf[0] == '8'){ if(estadoPin11 ==0){//Si la variable estado2 es igual a 0 se cumple esta condición digitalWrite(pin11, HIGH); Serial.println("Relay 8 activado"); estadoPin11 =1;//Asignamos el valor 1 a la variable "estadoPin11" } else{ digitalWrite(pin11, LOW); Serial.println("Relay 8 desactivado"); estadoPin11 =0; } } } //Verifica el estado de los taclas Bloq Num y Bloq Mayús para activarlas o desactivarlas desde el mismo teclado ps2::KeyboardLeds newLeds = (keyMapping.getCapsLock() ? ps2::KeyboardLeds::capsLock : ps2::KeyboardLeds::none) | (keyMapping.getNumLock() ? ps2::KeyboardLeds::numLock : ps2::KeyboardLeds::none); if (newLeds != lastLedSent) { ps2Keyboard.sendLedStatus(newLeds); lastLedSent = newLeds; } } } |
Código fuente con lógica invertida para módulo relay de 8 canales
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 |
#include "ps2_Keyboard.h"//Instalar librería ps2KeyboardHost #include "ps2_AnsiTranslator.h" #include "ps2_SimpleDiagnostics.h" int pin4 = 4; int pin5 = 5; int pin6 = 6; int pin7 = 7; int pin8 = 8; int pin9 = 9; int pin10 = 10; int pin11 = 11; int estadoPin4 = 0; int estadoPin5 = 0; int estadoPin6 = 0; int estadoPin7 = 0; int estadoPin8 = 0; int estadoPin9 = 0; int estadoPin10 = 0; int estadoPin11 = 0; typedef ps2::SimpleDiagnostics<254> Diagnostics_; static Diagnostics_ diagnostics; static ps2::AnsiTranslator<Diagnostics_> keyMapping(diagnostics); static ps2::Keyboard<3,2,1, Diagnostics_> ps2Keyboard(diagnostics); static ps2::KeyboardLeds lastLedSent = ps2::KeyboardLeds::none; void setup() { Serial.begin(9600); pinMode(pin4, OUTPUT); pinMode(pin5, OUTPUT); pinMode(pin6, OUTPUT); pinMode(pin7, OUTPUT); pinMode(pin8, OUTPUT); pinMode(pin9, OUTPUT); pinMode(pin10, OUTPUT); pinMode(pin11, OUTPUT); digitalWrite(pin4, HIGH); digitalWrite(pin5, HIGH); digitalWrite(pin6, HIGH); digitalWrite(pin7, HIGH); digitalWrite(pin8, HIGH); digitalWrite(pin9, HIGH); digitalWrite(pin10, HIGH); digitalWrite(pin11, HIGH); ps2Keyboard.begin(); keyMapping.setNumLock(true); ps2Keyboard.awaitStartup(); diagnostics.reset(); //Encendemos el led del teclado(Bloq Num) ps2Keyboard.sendLedStatus(ps2::KeyboardLeds::numLock); lastLedSent = ps2::KeyboardLeds::numLock; } void loop() { diagnostics.setLedIndicator<LED_BUILTIN>(); ps2::KeyboardOutput scanCode = ps2Keyboard.readScanCode(); if (scanCode == ps2::KeyboardOutput::garbled) { keyMapping.reset(); } else if (scanCode != ps2::KeyboardOutput::none) { char buf[2]; buf[1] = '\0'; buf[0] = keyMapping.translatePs2Keycode(scanCode); if (buf[0] == '\r') {//Se cumple si es la tecla enter Serial.println(); } else if (buf[0] >= ' ') { // Se cumple si es un caracter Serial.write(buf); //Tecla 1 if (buf[0] == '1'){ if(estadoPin4 ==0){//Si la variable estado2 es igual a 0 se cumple esta condición digitalWrite(pin4, LOW); Serial.println("Relay 1 activado"); estadoPin4 =1;//Asignamos el valor 1 a la variable "estadoPin4" } else{ digitalWrite(pin4, HIGH); Serial.println("Relay 1 desactivado"); estadoPin4 =0; } } //Tecla 2 if (buf[0] == '2'){ if(estadoPin5 ==0){//Si la variable estado2 es igual a 0 se cumple esta condición digitalWrite(pin5, LOW); Serial.println("Relay 2 activado"); estadoPin5 =1;//Asignamos el valor 1 a la variable "estadoPin5" } else{ digitalWrite(pin5, HIGH); Serial.println("Relay 2 desactivado"); estadoPin5 =0; } } //Tecla 3 if (buf[0] == '3'){ if(estadoPin6 ==0){//Si la variable estado2 es igual a 0 se cumple esta condición digitalWrite(pin6, LOW); Serial.println("Relay 3 activado"); estadoPin6 =1;//Asignamos el valor 1 a la variable "estadoPin6" } else{ digitalWrite(pin6, HIGH); Serial.println("Relay 3 desactivado"); estadoPin6 =0; } } //Tecla 4 if (buf[0] == '4'){ if(estadoPin7 ==0){//Si la variable estado2 es igual a 0 se cumple esta condición digitalWrite(pin7, LOW); Serial.println("Relay 4 activado"); estadoPin7 =1;//Asignamos el valor 1 a la variable "estadoPin7" } else{ digitalWrite(pin7, HIGH); Serial.println("Relay 4 desactivado"); estadoPin7 =0; } } //Tecla 5 if (buf[0] == '5'){ if(estadoPin8 ==0){//Si la variable estado2 es igual a 0 se cumple esta condición digitalWrite(pin8, LOW); Serial.println("Relay 5 activado"); estadoPin8 =1;//Asignamos el valor 1 a la variable "estadoPin8" } else{ digitalWrite(pin8, HIGH); Serial.println("Relay 5 desactivado"); estadoPin8 =0; } } //Tecla 6 if (buf[0] == '6'){ if(estadoPin9 ==0){//Si la variable estado2 es igual a 0 se cumple esta condición digitalWrite(pin9, LOW); Serial.println("Relay 6 activado"); estadoPin9 =1;//Asignamos el valor 1 a la variable "estadoPin9" } else{ digitalWrite(pin9, HIGH);; Serial.println("Relay 6 desactivado"); estadoPin9 =0; } } //Tecla 7 if (buf[0] == '7'){ if(estadoPin10 ==0){//Si la variable estado2 es igual a 0 se cumple esta condición digitalWrite(pin10, LOW); Serial.println("Relay 7 activado"); estadoPin10 =1;//Asignamos el valor 1 a la variable "estadoPin10" } else{ digitalWrite(pin10, HIGH);; Serial.println("Relay 7 desactivado"); estadoPin10 =0; } } //Tecla 8 if (buf[0] == '8'){ if(estadoPin11 ==0){//Si la variable estado2 es igual a 0 se cumple esta condición digitalWrite(pin11, LOW); Serial.println("Relay 8 activado"); estadoPin11 =1;//Asignamos el valor 1 a la variable "estadoPin11" } else{ digitalWrite(pin11, HIGH); Serial.println("Relay 8 desactivado"); estadoPin11 =0; } } } //Verifica el estado de los taclas Bloq Num y Bloq Mayús para activarlas o desactivarlas desde el mismo teclado ps2::KeyboardLeds newLeds = (keyMapping.getCapsLock() ? ps2::KeyboardLeds::capsLock : ps2::KeyboardLeds::none) | (keyMapping.getNumLock() ? ps2::KeyboardLeds::numLock : ps2::KeyboardLeds::none); if (newLeds != lastLedSent) { ps2Keyboard.sendLedStatus(newLeds); lastLedSent = newLeds; } } } |
PROYECTO RECOMENDADO
Video en https://youtu.be/ODE9nOFCAws