Todas las entradas de: jadiaz

Matriz 8×8

Las matrices LEDs 8×8 son sumamente conocidas. Su nombre se debe a que están compuestas por 64 LEDs dispuestos en forma de cuadrado con 8 columnas de 8 LEDs cada una.

Matriz LED cátodo común y ánodo común

Las matrices de LEDs pueden ser de dos tipos: ánodo común o cátodo común.

Matriz cátodo común: los terminales negativos (cátodos) de todos los LEDs de cada fila están conectados juntos. Lo mismo ocurre con los pines positivos (ánodos) de cada columna.

Matriz ánodo común: las conexiones son contrarias, es decir, los ánodos se conectan a las filas y los cátodos a las columnas.

Puedes notar que solo se cuenta con 16 pines para controlar la matriz, 8 para las columnas y 8 para las filas.

¿Cómo manejar una matriz LED?

En una matriz no es posible controlar todos los LEDs como si fueran independientes. Esto pasa porque solo se dispone de los pines correspondientes a filas y columnas.

Si se aplican valores de alto (HIGH) y bajo (LOW) a varias columnas y filas, respectivamente, se encenderán todos los LEDs de las intersecciones.

Para poder mostrar gráficos correctamente es necesario realizar un barrido por filas o columnas. Se iluminará sólo una fila a la vez.

Por ejemplo, si quieres mostrar un corazón son necesarios 8 pasos, uno por cada fila.

¿Pero esto no muestra solo una fila a la vez?

Pues no.

Las actualizaciones se realizan suficientemente rápido y con ayuda del efecto de persistencia visual el ojo humano no es capaz de notar el instante donde los LEDs se apagan.

Circuito integrado MAX7219 y MAX7221

Controlar una matriz de 8×8 implica utilizar 16 señales digitales y refrescar la imagen de una forma constante. Es por eso que en lugar de utilizar un Arduino directamente, emplearemos el circuito integrado MAX7219 o MAX7221 para esta tarea.

Los circuitos integrados MAX7219 y MAX7221 son casi iguales. Eso significa que son fácilmente intercambiables uno por el otro. De ahora en adelante me referiré al MAX7219, aunque todo es igual de válido para el MAX7221.

El MAX7219 es un circuito integrado que facilita el control de LEDs. Es usado principalmente en pantallas de 7 segmentos, paneles de LEDs industriales y como controlador de matriz de LED con Arduino.

Entre sus ventajas:

  • Interfaz de control serie: con tan solo 3 pines podemos controlar toda una matriz de LEDs.
  • Circuito externo simple: requiere pocos componentes externos.
  • Conexión en cascada: se pueden conectar varios MAX7219 en cascada. De esta forma se puede controlar varias matrices LEDs utilizando solo 3 pines de la placa Arduino.

Módulos de matriz LED con Arduino basados en MAX7219

Existen módulos de matrices LEDs para Arduino con el circuito montado. Existen de una única matriz o de varias.

Los que están compuestos por varias matrices utilizan un MAX7219 por cada una, y estos están conectados tal y como vimos en el esquema anterior. Es decir, que se conectan todos los MAX7219 en cascada.

Los módulos simples, no vienen diseñados para este tipo de acople, pero cuentan con dos conectores: uno de entrada y uno de salida. Esto nos permite conectar varios módulos en cascada.

El conector de entrada cuenta con los pines VCC y GND que son utilizados para alimentar el módulo. Además, están los pines DIN, CS y CLK que son utilizados para la comunicación.

En algunos módulos el pin CS es nombrado como LOAD.

El conector de salida es idéntico al de entrada. La única diferencia es que se ha sustituido el pin DIN por el pin DOUT. Este segundo conector es el que permite conectar varios módulos en cascada.

Como conectar un módulo matriz LED con Arduino

Para usar un módulo de matriz de LED para Arduino basado en MAX7219 es necesario conectar el pin VCC, al pin +5V de la placa y unir los pines GND del módulo y el Arduino. Los pines DIN, CLK y CS se conectan a tres pines digitales del Arduino.

Aquí puedes ver cómo queda la conexión de un Arduino UNO con un módulo simple.

El orden de los pines puede cambiar de un módulo a otro, por lo tanto, es importante que revises la nomenclatura antes de realizar la conexión.

Librería MAX7219 con Arduino

Existen muchas de librerías para módulos de matriz LED con Arduino. Aquí vas a ver la biblioteca MD_MAX72xx que te permite hacer maravillas con tu cartel digital.

Ya sabes como conectar un modulo de matriz de LED con Arduino basado en MAX7219, ahora solo queda aprender a programar su código.

Una de las ventajas de esta librería es que si conectas cuatro módulos en cascada los puedes usar como si fueran una matriz de 8 pixeles de altura y 32 de ancho.

Instalar librería MAX7219 con Arduino

Comencemos instalando la librería.

Para esto tienes que abrir el Gestor de Librerías que se encuentra en Herramientas/Administrar Bibliotecas…

Una vez abierto el Gestor de Librerías busca MD_MAX72 e instala la librería.

Listo ya tienes la librería instalada.

Funciones principales de la librería MD_MAX72xx

Como todas las librerías para Arduino, la MDMAX72xx tiene un montón de funcionalidades que pueden hacer muchas cosas.

De momento, las funciones y método más interesantes para nosotros son las siguientes.

Función MD_MAX72XX()

Esta sentencia es llamada constructor. Se usa para crear un objeto MD_MAX72XX. Simboliza los módulos de matrices LEDs que conectas al Arduino.

Permite controlar los módulos con cualquier pin digital.

Donde:

  • pinDIN: es el pin digital del Arduino que se conecta al pin DIN del módulo.
  • pinCLK: es el pin digital del Arduino que se conecta al pin CLK del módulo.
  • El resto de las variables cumplen la misma función que en la sobrecarga anterior.

En ambas sobrecargas el argumento hardware puede tomar cualquiera de los siguientes valores:

  • MD_MAX72XX::GENERIC_HW: hardware genérico.
  • MD_MAX72XX::FC16_HW: para el uso de módulos tipo FC-16.
  • MD_MAX72XX::PAROLA_HW: para el uso de módulos tipo Parola.
  • MD_MAX72XX::ICSTATION_HW: para el uso de módulos tipo ICStation.
  • MD_MAX72XX::DR0CR0RR0_HW *
  • MD_MAX72XX::DR0CR0RR1_HW *
  • MD_MAX72XX::DR0CR1RR0_HW: equivalente a  GENERIC_HW.
  • MD_MAX72XX::DR0CR1RR1_HW *
  • MD_MAX72XX::DR1CR0RR0_HW: equivalente a FC16_HW.
  • MD_MAX72XX::DR1CR0RR1_HW *
  • MD_MAX72XX::DR1CR1RR0_HW: equivalente a PAROLA_HW.
  • MD_MAX72XX::DR1CR1RR1_HW: equivalente a ICSTATION_HW.

* Estos valores se utilizan cuando se conectan matrices en cascada y no corresponden ninguno de los estándares. Para la conexión propuesta anteriormente (la de tres módulos simples con Arduino UNO) es necesario utilizar MD_MAX72XX::DR0CR0RR1_HW.

Función control()

Esta función permite configurar algunos parámetros de control en los módulos de matrices LED basados en MAX7219. Puede ser utilizada para establecer la intensidad del brillo de los LEDs o poner el módulo en modo de bajo consumo.

Primera sobrecarga: admite dos argumentos y permite configurar un parámetro en todos los módulos:

Donde:

  • param: es el parámetro a modificar.
  • value: es el valor a aplicar al parámetro indicado.

Segunda sobrecarga: admite tres argumentos y permite configurar el parámetro de un solo módulo.

Donde:

  • mat: es un entero entre 0 y la cantidad de módulos conectados. Indica el módulo a configurar.
  • param: es el parámetro a modificar.
  • value: es el valor a aplicar al parámetro indicado.

Tercera sobrecarga: permite aplicar la configuración a un intervalo de módulos.

Donde:

  • matIni: inicio del intervalo de módulos.
  • matFin: fin del intervalo de módulos.
  • param: parámetro a modificar.
  • value: valor a aplicar al parámetro indicado.

En todas las sobrecargas el argumento param puede tener varios valores. Los más importantes son:

  • MD_MAX72XX::TEST: activa o desactiva el modo de prueba. Cuando se activa (value = true) se encienden todos los LEDs para comprobar que ninguno esté dañado.
  • MD_MAX72XX::SHUTDOWN: activar o desactivar el modo de bajo consumo.
  • MD_MAX72XX::INTENSITY: permite especificar el brillo de los leds. El valor de value tiene que estar entre 0-15, donde 0 apaga los LEDs y 15 es el brillo máximo.
  • MD_MAX72XX::UPDATE: Permite habilitar o deshabilitar la actualización automática.

Cuando la auto-actualización está deshabilitada es necesario ejecutar la función update() para que los cambios sean mostrados en la matriz.

Función getColumnCount()

Esta función permite conocer el número total de columnas, es decir, retorna la cantidad de matices multiplicada por 8.

Función clear()

Esta función permite “limpiar” la información de las matrices, en otras palabras, apaga todos los LEDs de las matrices.

Primera sobrecarga: no requiere argumentos y limpia todas las matrices.

Segunda sobrecarga: permite limpiar un intervalo de matrices.

Donde:

  • matIni: inicio del intervalo de matrices a limpiar.
  • matFin: fin del intervalo de matrices a limpiar.

Función setColumn()

Esta función permite establecer el estado de una columna de LEDs.

Primera sobrecarga: recibe tres parámetros y permite establecer el estado de una columna indicando su matriz:

Donde:

  • mat: es un entero que indica la matriz a modificar.
  • col: es un entero entre 0 y 7 que indica la columna a modificar.
  • estado: es un entero de 8 bits que indica los LEDs a encender. Cada bit puesto a 1 indica que se encenderá su LED correspondiente.

Segunda sobrecarga: recibe dos parámetros y también permite establecer un nuevo estado en una columna. La diferencia con la sobrecarga anterior es que en este caso se asume que las matrices forman una matriz más extensa.

Eso significa que si se emplean dos matrices es como si se utilizara una matriz de 8 filas y 16 columnas. Donde las columnas 0-7 se corresponden con la primera matriz y las columnas 8-15 con la segunda.

Donde:

  • col: es un entero que indica la columna a modificar. El valor de col debe estar entre 0 y la cantidad de columnas entre todos los módulos, es decir, que si utilizas tres matices col puede tener valores entre 0 y 23.
  • value: es un entero de 8 bits que indica los LEDs a encender. Cada bit puesto a 1 indica que se encenderá su LED correspondiente.

Función setPoint()

Esta función permite encender o apagar un LED indicando su fila y columna.

Donde:

  • fila: indica la fila en que se ubica el LED. Es un valor entre 0 y 7.
  • col: indica la columna del LED. Es un valor entre 0 y la cantidad de columnas total.
  • estado: indica si el LED se debe encender o apagar.

Función setRow()

Esta función permite establecer el estado de una fila de LEDs.

Primera sobrecarga: necesita tres argumentos y permite establecer el estado de una fila correspondiente a una matriz en particular.

Donde:

  • mat: es un entero que indica sobre qué matriz actuar.
  • fil: es un entero entre 0 y 7 que indica la fila a modificar
  • estado: es un entero de 8 bits con el nuevo estado de la fila. Los bits puestos a uno indican los LEDs que se encenderán.

La segunda sobrecarga solo necesita dos argumentos y establece un nuevo estado en la fila indicada para todas las matrices.

Donde:

  • fil: es un entero entre 0 y 7 que indica la fila a modificar
  • estado: es un entero de 8 bits con el nuevo estado de la fila. Los bits puestos a uno indican los LEDs que se encenderán.

Tercera sobrecarga: admite cuatro argumentos y permite establecer el estado de una fila en un intervalo de matrices.

Donde:

  • matIni: es un entero que indica la primera matriz del intervalo.
  • matFin: es un entero que indica la última matriz del intervalo.
  • fil: es un entero entre 0 y 7 que indica la fila a modificar.
  • estado: es un entero de 8 bits con el nuevo estado de la fila. Los bits puestos a uno indican los LEDs que se encenderán.

Función transform()

Esta función permite aplicar transformaciones a la información mostrada en las matrices, es decir, que permite rotar, desplazar o invertir los LEDs en la matriz.

Primera sobrecarga: admite dos argumentos y permite aplicar una transformación al contenido de una sola matriz.

Donde:

  • mat: matriz a la que se le aplicará la transformación.
  • trans: tipo de transformación a aplicar.

Segunda sobrecarga: admite tres argumentos y permite realizar una transformación a un intervalo de matrices.

Donde:

  • matIni: es un entero que indica la primera matriz del intervalo.
  • matFin: es un entero que indica la última matriz del intervalo.
  • trans: tipo de transformación a aplicar.

Tercera sobrecarga: admite un solo parámetro y permite aplicarle una transformación a todas las matrices.

Donde:

  • trans: tipo de transformación a aplicar.

En la siguiente tabla tienes el conjunto de transformaciones que puedes realizar con la función transform().

Valor Transformación
MD_MAX72XX::TSL Desplazar un píxel a la izquierda
MD_MAX72XX::TSR Desplazar un píxel a la derecha
MD_MAX72XX::TSU Desplazar un píxel hacia arriba
MD_MAX72XX::TSD Desplazar un píxel hacia abajo
MD_MAX72XX::TFLR Voltear de derecha a izquierda
MD_MAX72XX::TFUD Voltear de arriba hacia abajo
MD_MAX72XX::TRC Rotar 90 grados en sentido horario
MD_MAX72XX::TINV Invertir píxeles

Función setChar()

Esta función permite dibujar un carácter empezando en una columna específica.

Donde:

  • col: columna donde comienza el carácter.
  • c: carácter a mostrar.
  • w: valor retornado por setChar(). Indica cuantas columnas ocupa el carácter dibujado.

Función update()

La función update() actualiza el contenido de la matriz cuando la auto-actualización ha sido deshabilitada.

Primera sobrecarga: no recibe parámetros y actualiza el estado de todas las matrices conectadas.

Segunda sobrecarga: admite un parámetro y actualiza solo el estado de la matriz indicada.

Donde:

  • mat: es el número de la matriz a actualizar.

Ya conoces cómo conectar un módulo de matriz de LED con Arduino basados en MAX7219 y cómo utilizar las funciones de la librería MD_MAX72xx para controlarla, por lo tanto, ya estas en condiciones de empezar a trabajar.

Motor paso a paso 28BYJ-48

Objetivos

  • Montar un pequeño motor paso a paso 28BYJ-48 con su adaptador.
  • Escribir un primer programa de control muy sencillo.

Material requerido

 arduino
  • Arduino Uno o similar. Esta sesión acepta cualquier otro modelo de Arduino.
 Img_3_4
  •  Una Protoboard.
 Img_3_6-300x185
  • Algunos cables de Protoboard.
  • Motor paso a paso 28BYJ-48 y adaptador

Motor paso a paso

Vamos a usar un pequeño motor paso a paso unipolar, muy común en el mundo Arduino por su pequeño tamaño y bajo coste, el 28BYJ-48 y el adaptador  que suele venir con él, basado en el chip ULN2003A.

Veremos en primer lugar las características que presenta y después montaremos un pequeño circuito básico, para mover el motor.

Es un motor unipolar con las siguientes características:

  • Tensión nominal de entre 5V y 12 V.
  • 4 Fases.
  • Resistencia 50 Ω.
  • Par motor de 34 Newton / metro más o menos 0,34 Kg por cm.
  • Consumo de unos 55 mA.
  • 8 pasos por vuelta.
  • Reductora de 1 / 64.

Es decir, que como es de 4 pasos (Steps), u 8 medios pasos  (O half Steps) por vuelta y usa una reductora de 1 /64, necesitamos dar 8 * 64 = 512 impulsos para completar un giro completo a medios pasos.

  • Hay 4 bobinas, si las excitamos de una en una tenemos 4 pasos x 64=256 pasos por vuelta. Pero también podemos excitar la bobina mediante medios pasos, que es el ejemplo que vamos a hacer y por eso a medios pasos una vuelta son 8 * 64 = 512 impulsos

Este es su diagrama de conexión de bobinas, y además marca los colores del cable en función de su conexión interna.

El motor presenta un conector al extremo en el que podemos pinchar cables de protoboard si hay que moverlo directamente, o bien para conectarlo a su adaptador.

Fijaros que su consumo es muy bajo, de unos 55 mA, dentro del rango que nuestro USB proporciona a Arduino (Siempre que no intentemos alimentarlo con un pin) y lo alimentaremos mediante la breakboard típica que le acompaña,  que suele usar un integrado del tipo ULN2003A que es un array de transistores Darlington, que soporta hasta 500 mA y que ya dispone de un conector para el motor y de unos pines (IN1 – IN4) para conectar a nuestro Arduino.

El módulo cuenta con todos los componentes necesarios para funcionar sin necesidad de elementos adicionales, entre ellos diodos de protección y un regulador LM7805 que suministra 5V a la parte lógica del integrado L298N. Cuenta con jumpers de selección para habilitar cada una de las salidas del módulo (A y B). La salida A esta conformada por OUT1 y OUT2 y la salida B por OUT3 y OUT4. Los pines de habilitación son ENA y ENB respectivamente.

En la parte inferior se encuentran los pines de control del módulo, marcados como IN1, IN2, IN3 e IN4.

Conectando el motor 28BYJ-48

Pues usando la breakboard es muy sencillo. Conectad el motor primero a su conector, tiene una posición para impedir que lo coloques al revés y después vamos a colocar las 4 fases a nuestro Arduino de modo que podamos excitarlas de forma independiente.

Es importante que entendáis la idea de que vamos a ir excitando cada una de las fases (O varias simultáneamente) en secuencia levantando a HIGH el pin de Arduino correspondiente.

Para conectar vuestro Arduino usad la siguiente tabla:

ARDUINO 12 11 10 9
BREAKOUT IN1 IN2 IN3 IN4

Conectad  GND y Vcc a los pines correspondientes del adaptador.

El programa de control

Mientras que los motores CC normales, están diseñados para que al alimentarlos giren de forma continua, un motor paso a paso está diseñado para girar un pasito cada vez que alimentas una de las fases.

Por eso nuestro programa tendrá que gestionar la secuencia en la que excitamos las bobinas para que el motor vaya avanzando de forma continua.

En un motor de 4 fases como este que vamos a usar hay tres maneras de hacer esta secuencia como veíamos en la sesión anterior.

Excitando dos bobinas cada vez (Suele ser lo que recomienda el fabricante)

PASO BOBINA A BOBINA B BOBINA C BOBINA D
1 ON ON OFF OFF
2 OFF ON ON OFF
3 OFF OFF ON ON
4 ON OFF OFF ON

Tendríamos máximo par, buena velocidad y alto consumo.

Excitando solo una bobina cada vez (Se le llama wave drive):

PASO BOBINA A BOBINA B BOBINA C BOBINA D
1 ON OFF OFF OFF
2 OFF ON OFF OFF
3 OFF OFF ON OFF
4 OFF OFF OFF ON

Que produciría un par menor (Porque solo se activa una bobina en lugar de dos) y consumo bajo.

O podríamos dar medios pasos así:

PASO BOBINA A BOBINA B BOBINA C BOBINA D
1 ON OFF OFF OFF
2 ON ON OFF OFF
3 OFF ON OFF OFF
4 OFF ON ON OFF
5 OFF OFF ON OFF
6 OFF OFF ON ON
7 OFF OFF OFF ON
8 ON OFF OFF ON

El movimiento es más suave y lento que con los métodos anteriores, y el consumo y el par es también intermedio.

Vamos a definir unos arrays con estas tablas para secuenciar el movimiento. Por ejemplo en el caso de usar medios pasos el array sería algo así:

int paso [ 8 ][ 4 ] =
   {  {1, 0, 0, 0},
      {1, 1, 0, 0},
      {0, 1, 0, 0},
      {0, 1, 1, 0},
      {0, 0, 1, 0},
      {0, 0, 1, 1},
      {0, 0, 0, 1},
      {1, 0, 0, 1}
   };

Nuestro programa  recorrerá el array y alimentara las bobinas de acuerdo a los valores que presenta. Empecemos con algunas definiciones:

#define IN1  12
#define IN2  11
#define IN3  10
#define IN4  9

int steps_left=4095;
boolean direction = true;
int steps = 0 // Define el paso actual

Los defines indican a que pines de nuestro Arduino vamos a conectar cada una de los terminales de las bobinas del motor. Después algunas variables para control y un array que representa la secuencia. El setup es bastante sencillo

void setup()
   { 
     pinMode(IN1, OUTPUT);
     pinMode(IN2, OUTPUT);
     pinMode(IN3, OUTPUT);
     pinMode(IN4, OUTPUT);
   }

Ahora vamos a definir una función llamada stepper()  que avanza un paso cada vez que la invocamos, en realidad medio paso dada la matriz de excitación y que controle en que punto de la secuencia estamos.

Así, el programa principal quedaría:

void loop()
   { 
   while(steps_left>0)
        { 
           stepper() ;     // Avanza un paso
           steps_left-- ;  // Un paso menos
           delay (1) ;
        }
     delay(300);
     direction =! direction; //Invertimos dir
     steps_left = 4095;
   }

El 28BYJ-48 tiene 64 pasos por vuelta y un reductor interno con una relación de 1/64. En conjunto hacen 4096 pasos por vuelta.

Usamos steps_left para definir el número de pasos que queremos girar, y por eso mientras queden pasos pendientes seguimos en el while, que lo que hace es avanzar un paso, disminuir el número de pasos pendientes y hacer un delay que controla la velocidad de giro.

Cuando acaba el while, hacemos un delay para poder apreciar el final e invertimos el valor de direction para cambiar la dirección de giro. Vamos con el método stepper que parece más complicada:

void stepper()            //Avanza un paso
   {  digitalWrite( IN1, paso[steps][ 0] );
      digitalWrite( IN2, paso[steps][ 1] );
      digitalWrite( IN3, paso[steps][ 2] );
      digitalWrite( IN4, paso[steps][ 3] );
      
     if(direction) 
             steps++; 
       else 
             steps--; 
     steps = (steps+8)%8;
   }

Usamos la variable steps para saber en cuál de los 8 estados posibles de la matriz estamos y escribimos en las bobinas los valores que corresponden a esa situación.

Para controlar la dirección de giro y el valor de steps:

  • si giramos en la dirección digamos positiva, hay que ir incrementando steps para mantener el giro.
  • si el giro es contrario hay que ir decrementando para que lea el array al revés.

A medida que vamos incrementando steps, queremos que cuando pase de 7 vuelva a 0 y esto se consigue haciendo

steps = steps % 8

Es decir tomando el modulo (resto) con respecto a 8, pero si lo vamos decrementando, alcanzaremos valores negativos, y el módulo de algo negativo sigue siendo negativo, lo que no nos vale, porque necesitamos que  el siguiente valor a 0 sea 7 y no -1.

Esto es lo que conseguimos haciendo:

steps = (steps + 8) % 8 ;
  • También podrías hacerlo así:
    if (steps>7)
        steps=0 ;
    if (steps<0)
        steps=7 ;

El resultado es un motor girando primero en una dirección y después en la contraria.