How to Control an Actuator with a Keypad

Cómo controlar un actuador con un teclado

Josh Nigh
Josh Nigh
PA Engineer

A veces nuestros proyectos necesitan un plus de seguridad. Este puede ser el caso en una variedad de aplicaciones diferentes, como mecanismos de bloqueo de puertas, prevención del uso inseguro o no autorizado de maquinaria o, cada vez más especializados, accesorios de salas de escape. En este artículo, lo guiaremos a través del ensamblaje de un actuador de teclado y repasaremos cómo puede proteger con contraseña el funcionamiento de su actuador lineal.

Esto es lo que usaremos:

Cableado de su actuador

Primero, comenzaremos con el cableado. Para poder extender y retraer su actuador, necesitaremos usar ambos canales de nuestro módulo de relé de 2 canales. De esta manera, cuando el Relé Uno está activo, la corriente fluirá en una dirección y cuando el Relé Dos está activo, la corriente fluirá en la dirección opuesta. Si ninguno o ambos relés están activos, no fluirá corriente al actuador. Para lograr esto, necesitaremos realizar las siguientes conexiones.

Relés para el actuador y la fuente de alimentación

  • +12 V a NC1 (terminal normalmente cerrado en el relé uno) (cable blanco).
  • -12 V a NO1 (terminal normalmente abierto en el relé uno) (cable negro).
  • NC1 a NC2 (cable puente azul).
  • NO1 a NO2 (cable puente verde).
  • COMÚN1 al actuador (cable marrón del actuador).
  • COMÚN2 al actuador (cable azul del actuador).

Arduino al Teclado y al Módulo de Relé

  • Conecte los pines 1-8 del teclado a los pines 2-9 del Arduino (en ese orden).
  • Arduino Pin 10 a IN1 en el módulo de relé.
  • Arduino Pin 11 a IN2 en el módulo de relé.
  • Arduino 5V a VCC en módulo de relé.
  • Arduino GND a GND en módulo de relé.
  • Ánodo del zumbador (cable más largo) al pin 12 (opcional).
  • Cátodo del zumbador (cable más corto) a GND (opcional).
    Arduino al Teclado y al Módulo de Relé

    Codificando su proyecto

    Ahora que hemos realizado todas nuestras conexiones, estamos listos para el código. El propósito de este código es leer las entradas de un teclado, buscar la entrada correcta de 5 dígitos y operar nuestros relés en consecuencia. También hay un código para un timbre opcional que proporciona retroalimentación. Si no desea utilizar el timbre, simplemente no puede adjuntarlo y dejar el código como está. Si necesita utilizar el pin del timbre para otra cosa, elimine o comente todo el código utilizado para las funciones del timbre o "bip".

    En el código siguiente, encontrará comentarios en casi todas las líneas (texto gris claro que sigue a "//"). Estos comentarios describirán lo que está sucediendo en el boceto, así como las modificaciones que puede realizar. También desglosaremos algunas secciones importantes aquí para una explicación más detallada.

    [cta-contenido]

    ¡Utilice nuestros microcontroladores Arduino para obtener opciones ilimitadas de control de su actuador!

    Explorar Arduino

    Código de configuración

    En nuestro código de configuración, definiremos nuestro zumbador y pines de relé como salidas. El zumbador comenzará en BAJO y los relés comenzarán en ALTO. Esto hará que todos estén inactivos cuando encendamos nuestro Arduino por primera vez. También ejecutaremos la función “retract()” una vez para que Arduino sepa el estado correcto del actuador.

     void setup() //se ejecuta una vez al inicio
     {
     digitalWrite(buzzer, LOW);//desactiva el zumbador
     digitalWrite(relay1,HIGH);//desactiva el relé1 
    digitalWrite(relay2,HIGH);//desactiva el relé2
     para(int i=10;i<14;i++)
     {
     pinMode(i,OUTPUT);//establece los pines 10 - 13 como salidas
     }
    
    
     Serial.begin(9600);//Inicia el monitor serie a una velocidad de 9600 baudios (solo para depuración)
     retract();//retrae el actuador al inicio si aún no lo está. comente esto si no desea que el actuador se retraiga al inicio
     Serial.println("READY");//nos informa que el monitor serie se está ejecutando
     }
    

    Código del teclado

    Para este boceto estamos utilizando la biblioteca Keypad.h. Esta biblioteca contiene las funciones que estamos usando para recibir entradas desde nuestro teclado. Para utilizar esta biblioteca, necesitamos crear una matriz bidimensional para mapear los caracteres de nuestro teclado. Esto se puede lograr, primero, definiendo el número de filas y el número de columnas que hay en el teclado. Luego, hacemos nuestra matriz con cada carácter del teclado. Nuestro teclado tiene cuatro filas, cuatro columnas y ocho pines de salida. Hay un pin para cada fila y un pin para cada columna. Mostramos esto en nuestro código creando una matriz " rowPins " que contiene las entradas digitales conectadas a los pines de la fila y una matriz " colPins " que contiene las entradas digitales conectadas a los pines de la columna. Cuando presionamos una tecla, conectamos uno de los pines de fila con uno de los pines de columna. Por ejemplo, si presionamos el botón 2, estamos creando un circuito cerrado entre el pin de la fila uno y el pin dos de la columna.

     char clave personalizada; //ingreso de caracteres presionando el teclado 
    FILAS de bytes constantes = 4; //cuatro filas
     byte constante COLS = 4; //cuatro columnas
    
     charkeys[ROWS][COLS] = { //diseña tu "mapa de teclas" aquí
     {'1', '2', '3', 'A'},
     {'4', '5', '6', 'B'},
     {'7', '8', '9', 'C'},
     {'*', '0', '#', 'D'}
     };
     bytes filaPins[FILAS] = {2, 3, 4, 5}; //conectar a los pines de fila del teclado
     byte colPins[COLS] = {6, 7, 8, 9}; //conectar a los pines de columna del teclado
     Teclado personalizado ( makeKeymap (teclas), pines de fila, pines de columna, FILAS, COLS); //inicializa una instancia de la clase NewKeypad

    Código de acceso

    En este ejemplo para el control seguro del actuador lineal, nuestro código de acceso tiene 5 dígitos, por lo que definimos “ Passcode_Length ” como “6”. Esto se debe a que necesitamos un espacio adicional para un carácter nulo. Si desea cambiar la longitud del código de acceso, simplemente cambie el 6 a un número que sea mayor en uno que la longitud del código deseada. Después de eso, cambie el valor de " Código de acceso " a los caracteres que desee (establecido en "12345" de forma predeterminada).

    El carácter asociado con cada tecla presionada se almacenará en la matriz " Entrada ". Una vez que esa matriz contenga 5 caracteres, comparará el valor de " Entrada " y " Código de acceso " para ver si tenemos el código de acceso correcto. Si los valores son iguales, nuestro código le indicará al Arduino que extienda o retraiga el actuador (dependiendo del estado actual del actuador). Si el código de acceso es incorrecto, el pin del timbre subirá tres veces rápidamente y luego bajará. En cualquier caso, luego se llamará a la función " clearInput() " para borrar la matriz de entrada y dejar espacio para una nueva entrada.

    Código de extensión y retracción

    Tenemos dos funciones muy similares en este código " void extend() " y " void retract() ". Cuando se llama, void extend() escribirá el Relé Uno en nivel bajo, haciéndolo activo. Esto cerrará un circuito y aplicará un voltaje positivo al actuador. El relé permanecerá activo durante el tiempo asignado a “ const int extendTime ”. (establecido en 25.000 milisegundos de forma predeterminada). La función void retract() hará exactamente lo mismo, excepto que utilizará el relé dos para invertir el voltaje en lugar del relé uno.

     void extend()//extender el actuador
     {
     pitido largo();
     Serial.println("EXTENDIENDO...");
     digitalWrite(relay2,HIGH);//se asegura de que el relé2 no esté activo
     escritura digital(relé1,BAJO);//activa el relé1
     retraso(extenderTiempo);
     digitalWrite(relay1,HIGH);//desactiva el relé1
     Serial.println("TERMINADO EXTENDIDO");
     extendido = verdadero; //le dice al arduino que el actuador está extendido
     pitido largo();
     }
    
     void retract()//extender el actuador
     {
     pitido largo();
     Serial.println("RETIRANDO..."); 
    digitalWrite(relay1,HIGH);//se asegura de que el relé1 no esté activo
     escritura digital(relé2,BAJO);//activa el relé2
     retraso(retractTime);
     digitalWrite(relay2,HIGH);//desactiva el relé2
     Serial.println("RETIRANDO HECHO");
     extendido = falso; //le dice al arduino que el actuador está retraído
     pitido largo();
     }

    Últimos retoques

    Una vez que hayamos realizado todas nuestras conexiones y cargado nuestro código, deberíamos tener un sistema de control de actuador funcional protegido con contraseña. Si tiene problemas cuando lo configura por primera vez, intente usar la herramienta de monitor serie en el IDE de Arduino. Esto puede ser extremadamente útil para determinar si sus problemas se deben a un código, cableado o componentes defectuosos.

    Este código también se puede modificar más allá de simplemente cambiar el código de acceso. Es posible que desee considerar cambiar su tablero de relés con un escudo MegaMoto para poder tener control de velocidad o usar un actuador con retroalimentación de efecto Hall para control de posición.

    ¡Esperamos que este artículo haya sido útil! Si tiene alguna pregunta sobre este, cualquier otro actuador lineal controlado remotamente, o desea compartir su proyecto con nosotros, no dude en llamarnos o enviarnos un correo electrónico .