Archivo de la categoría: Diseños

Ampliar la cantidad de entradas de Arduino

Para expandir la capacidad de entradas digitales se utilizan registros de desplazamiento (Shift Register en inglés) con entradas en paralelo y salida serie.

Para este ejemplo, utilizamos tres pines digitales de la placa Arduino en conjunto con el circuito integrado 74HC165 (puede ser, también, 74LS165), que nos aportará 8 entradas.

Diagrama de pines:

Se pueden conectar varios de estos chips en cadena, lo que le nos aporta 16, 24, 32 o más entradas, sin usar ningún pin digital adicional de Arduino, simplemente conectando la salida QH de un registro a la entrada de datos serie SER del otro.

En el diagrama que sigue se ve cómo es la conexión completa de dos 74HC165. Los conjuntos de llaves de corredera, llamados DIP Switch en inglés, representan a las diversas entradas que se podrían ingresar. Si son llaves que se cierran (pulsadores, microswitches, relés, salidas de colector abierto), corresponde el circuito tal como se lo ve, con un resistor de polarización (pull-up) conectado a +5V. Si se trata de salidas digitales de otros chips y placas con salidas compatible con lógica TTL, no es necesario colocar el resistor.

Con línea de puntos se indica la conexión para continuar la cadena indefinidamente. La señal CLK (pata 2) va unida entre chips, e igual la señal SH/LD (pata 1), con la única salvedad de que hay que leer la hoja de datos del microcontrolador (según cuál sea) para saber cuántas entradas de este tipo de chip TTL HC se le pueden conectar a una salida digital de Arduino.

La tabla que sigue, y el diagrama interno del chip, los agrego para ofrecer más información y mejor comprensión del funcionamiento. Se pueden encontrar más detalles en su hoja de datos.

Diagrama de tiempo

La señal SH/LD se mantiene en ALTO durante las operaciones de desplazamiento. Un pulso a BAJO en este pin ingresa nuevos datos desde las entradas al registro de desplazamiento. Cuando el pulso vuelve a ALTO, queda todo dispuesto para aplicar pulsos de CLK y desplazar uno a uno los bits del registro hacia la salida serie QH. Si hemos usado un solo chip 74HC165, con 8 pulsos se habrán leído todas las entradas a través de QH (luego de haberlo conectado a una entrada digital del Arduino). Cada chip adicional requiere 8 pulsos más. En los programas se puede entender claramente cómo se ingresan los datos a variables dentro de nuestro microcontrolador.

Leer una de las entradas del 74HC165 – Diseño del programa:

■ Se aplica un pulso de alto a bajo y luego de regreso a alto en SH/LD, y así las entradas ingresan al registro de desplazamiento (condición “LOAD”, o de carga).

■ Aplicar a la salida CLK la cantidad de pulsos necesarios, desplazando los datos, para que el bit que deseamos leer quede ubicado en la línea de salida QH.

■ Leer el valor del pin digital de entrada del Arduino.

Primer programa de prueba

Este programa lee de a un pin e indica su estado en el LED incluido en el Arduino UNO, pin 13 = LED_BUILTIN. Para determinar qué entrada queremos leer para conocer su estado, se lo indicamos tipeando los números 1 a 8 desde el teclado de la computadora a la que esté conectado el Arduino por USB.

Incluso, usando comparaciones con IF se podría elegir como comando cualquier caracter. Puede ser “a”, “b”, “c”, o “A”, “B”, “C”, o lo que usted elija. Si la entrada proviene de sensores de puertas o ventanas abiertas, o de luces encendidas, se puede usar, por ejemplo, “C” para cocina, “B” para baño, “P” para pasillo, “p” para patio, “E” para entrada, “H” para una habitación y “h” para otra habitación. Y así. Además, estas letras de comando se pueden enviar a través de un módulo Bluetooth HC-06 o HC-05 y controlar desde el teléfono celular, recibiendo la respuesta por el mismo medio.

En este programa —para simplificar— se eligió tipear un número desde el teclado para leer cada entrada. Lo más interesante es la función que lee las entradas y las desplaza hacia la salida. Se le envía como parámetro un valor numérico y entero de 1 a 8, y devuelve un 1 o un 0 según el estado de la entrada. No es difícil ampliar el código hasta la cantidad de entradas que desee.

Agregando esta función a su programa, puede usarla del modo que usted quiera.

Utilizamos este circuito, que es el mismo que servirá para todos los programas excepto el de manejo por SPI, que requiere conectar dos señales del circuito a las entradas MOSI y SCLK de esta interfaz, como luego veremos.

Disculpen si tiene un aspecto un poco antiestético, pero ocurre que es difícil cablear un conjunto de llavecitas DIP al chip 74HC165 con el programa de dibujo sin hacer cruces de cables, y que sea todo visible. Ya verán en la foto que el circuito real, en la protoboard, quedó más prolijo.

Programa para leer de a una entrada

/* Este programa no requiere el uso de bibliotecas */

int pinCargarDatos  = 8;  // Pin SH/LD: desplazar-cargar en paralelo del 165
int pinDato         = 11;  // Pin QH: salida serie del 165
int pinClock        = 12;  // Pin CLK: clock del 165

// esta funcion devuelve 1 o 0 segun el estado del pin
int leeBit(int pinLeer){
    int valorBit;
    // Pulso de carga paralela, guarda estado de las entradas
    digitalWrite(pinCargarDatos, LOW);
    digitalWrite(pinCargarDatos, HIGH);  // pulso carga datos

    // Lee el valor de bits de la salida QH del 74HC165
     for(int i = 0; i < pinLeer; i++) 
     {
        valorBit = digitalRead(pinDato); // leer el pin deseado
        digitalWrite(pinClock, HIGH);
        digitalWrite(pinClock, LOW); // pulso desplaza datos
     }
    return(valorBit);
}

void setup()
{
   Serial.begin(9600);

    // Inicializar los pines digitales
    pinMode(LED_BUILTIN, OUTPUT);
    pinMode(pinCargarDatos, OUTPUT);
    pinMode(pinClock, OUTPUT);
    pinMode(pinDato, INPUT);
    digitalWrite(pinClock, LOW);
    digitalWrite(LED_BUILTIN, LOW);
}

void loop()
{
  int numeroPin;
  char datoSerie;
  if (Serial.available() > 0) // espero el caracter tipeado
  {
    datoSerie = Serial.read();  // lo leo
    numeroPin = 8-(datoSerie-48)+1; // char ASCII en numero
    if (leeBit(numeroPin) == 1) { digitalWrite(LED_BUILTIN,HIGH); } 
      else { digitalWrite(LED_BUILTIN,LOW); }
  }
}

/* Este programa no requiere el uso de bibliotecas */

int pinCargarDatos = 8; // Pin SH/LD: desplazar-cargar en paralelo del 165

int pinDato = 11; // Pin QH: salida serie del 165

int pinClock = 12; // Pin CLK: clock del 165

// esta funcion devuelve 1 o 0 segun el estado del pin

int leeBit(int pinLeer){

int valorBit;

// Pulso de carga paralela, guarda estado de las entradas

digitalWrite(pinCargarDatos, LOW);

digitalWrite(pinCargarDatos, HIGH); // pulso carga datos

// Lee el valor de bits de la salida QH del 74HC165

for(int i = 0; i < pinLeer; i++)

{

valorBit = digitalRead(pinDato); // leer el pin deseado

digitalWrite(pinClock, HIGH);

digitalWrite(pinClock, LOW); // pulso desplaza datos

}

return(valorBit);

}

void setup()

{

Serial.begin(9600);

// Inicializar los pines digitales

pinMode(LED_BUILTIN, OUTPUT);

pinMode(pinCargarDatos, OUTPUT);

pinMode(pinClock, OUTPUT);

pinMode(pinDato, INPUT);

digitalWrite(pinClock, LOW);

digitalWrite(LED_BUILTIN, LOW);

}

void loop()

{

int numeroPin;

char datoSerie;

if (Serial.available() > 0) // espero el caracter tipeado

{

datoSerie = Serial.read(); // lo leo

numeroPin = 8-(datoSerie-48)+1; // char ASCII en numero

if (leeBit(numeroPin) == 1) { digitalWrite(LED_BUILTIN,HIGH); }

else { digitalWrite(LED_BUILTIN,LOW); }

}

Segundo ejemplo: ingresar todas las entradas a variables

El siguiente programa permite listar en el Monitor Serie el estado de los pines de entrada del circuito del ejemplo, o de una cadena de chips para ampliar 16, 24, 32 o más entradas. Tampoco necesita biblioteca. El listado se actualiza cada vez que cambia una entrada. Los comentarios explican en detalle su funcionamiento.

/* SN74HC165N_shift_reg
 * Traducido y modificado de https://playground.arduino.cc/
 * Programa para ingresar valores de 8 bits desde un 74HC165
 * (registro de desplazamiento entrada paralela/salida serie.
 * Este programa demuestra la lectura de 8 estados digitales
 * de un registro de desplazamiento 74HC165 usando solamente
 * 3 pines digitales del Arduino.
 * Se pueden conectar en cadena mas chips uniendo la salida serie
 * (pin QH) de un registro de desplazamiento a la entrada serie
 * (pin SER) del siguiente.
 * Por supuesto usted puede conectar en cadena tantos chips como
 * quiera y seguir usando solo 3 pines de Arduino (aunque hay que
 * ingresarlos en diferente variables unsigned long).
*/

// Definir la cantidad de chips que estan conectados en cadena.
#define CANTIDAD_CHIP   1

// Ancho de los datos (cuantas lineas de entrada).
#define ANCHO_DATOS  CANTIDAD_CHIP * 8

// Ancho del pulso para cargar el registro de desplazamiento
#define ANCHO_PULSO  5

// Espera opcional entre lecturas del registro de desplazamiento
#define ESPERA_DEL_CICLO 1

// Debera cambiar "int" a "long" si la cantidad
// CANTIDAD_CHIP es mayor que 2
#define TIPO_VAL_BYTES unsigned int

int pinCargarDatos  = 8;  // Pin SH/LD: desplazar-cargar en paralelo del 165
int pinDato         = 11; // Pin QH: salida serie del 165
int pinClock        = 12; // Pin CLK: clock del 165

TIPO_VAL_BYTES valoresPin;
TIPO_VAL_BYTES viejosValoresPin;

// Esta funcion es una rutina de "desplazamiento hacia adentro" que
// lee datos en serie desde el registro de desplazamiento de los chips
// y arma el estado de los pines en un unsigned integer (o long integer)
TIPO_VAL_BYTES lee_registros_desplaz()
{
    long valorBit;
    TIPO_VAL_BYTES valorBytes = 0;

    // Pulso de carga paralela para guardar el estado de las entradas
    digitalWrite(pinCargarDatos, LOW);  // pulso carga datos a BAJO
    delayMicroseconds(ANCHO_PULSO);     // duracion pulso
    digitalWrite(pinCargarDatos, HIGH); // pulso carga datos a ALTO

    // Lazo que lee el valor de cada bit de la salida serie del 74HC165
     for(int i = 0; i < ANCHO_DATOS; i++)
    {
        valorBit = digitalRead(pinDato);

        // poner el bit correspondiente en valorBytes
        valorBytes |= (valorBit << ((ANCHO_DATOS-1) - i));

        // Pulso de Clock (el flanco de subida desplaza el siguiente bit).
        digitalWrite(pinClock, HIGH);
        delayMicroseconds(ANCHO_PULSO);
        digitalWrite(pinClock, LOW);
    }
    return(valorBytes);
}

// Mostrar la lista de datos con su estado
void mostrar_valores_pines()
{
    Serial.print("Estado pines:\r\n");

    for(int i = 0; i < ANCHO_DATOS; i++)
    {
        Serial.print("  Pin-");
        Serial.print(i);
        Serial.print(": ");

        if((valoresPin >> i) & 1)
            Serial.print("ALTO");
        else
            Serial.print("BAJO");

        Serial.print("\r\n");
    }
    Serial.print("\r\n");
}

void setup()
{
    Serial.begin(9600);

    // Inicializar los pines digitales
    pinMode(pinCargarDatos, OUTPUT);
    pinMode(pinClock, OUTPUT);
    pinMode(pinDato, INPUT);

    digitalWrite(pinClock, LOW); // inicializa CLK en BAJO
    digitalWrite(pinCargarDatos, LOW); // inicializa carga datos a BAJO

    // Leer y mostrar los estados de los pines la 1ra vez
    valoresPin = lee_registros_desplaz();
    mostrar_valores_pines();
    viejosValoresPin = valoresPin;
}

void loop()
{
    // Lee el estado de todos los bytes
    valoresPin = lee_registros_desplaz();

    // Si hay un cambio de estado, muestra los que cambiaron
    if(valoresPin != viejosValoresPin)
    {
        Serial.print("*Detectado cambio de valor de Pin*\r\n");
        mostrar_valores_pines();
        viejosValoresPin = valoresPin;
    }

    delay(ESPERA_DEL_CICLO);
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

/* SN74HC165N_shift_reg

* Traducido y modificado de https://playground.arduino.cc/

* Programa para ingresar valores de 8 bits desde un 74HC165

* (registro de desplazamiento entrada paralela/salida serie.

* Este programa demuestra la lectura de 8 estados digitales

* de un registro de desplazamiento 74HC165 usando solamente

* 3 pines digitales del Arduino.

* Se pueden conectar en cadena mas chips uniendo la salida serie

* (pin QH) de un registro de desplazamiento a la entrada serie

* (pin SER) del siguiente.

* Por supuesto usted puede conectar en cadena tantos chips como

* quiera y seguir usando solo 3 pines de Arduino (aunque hay que

* ingresarlos en diferente variables unsigned long).

// Definir la cantidad de chips que estan conectados en cadena.

#define CANTIDAD_CHIP 1

// Ancho de los datos (cuantas lineas de entrada).

#define ANCHO_DATOS CANTIDAD_CHIP * 8

// Ancho del pulso para cargar el registro de desplazamiento

#define ANCHO_PULSO 5

// Espera opcional entre lecturas del registro de desplazamiento

#define ESPERA_DEL_CICLO 1

// Debera cambiar "int" a "long" si la cantidad

// CANTIDAD_CHIP es mayor que 2

#define TIPO_VAL_BYTES unsigned int

int pinCargarDatos = 8; // Pin SH/LD: desplazar-cargar en paralelo del 165

int pinDato = 11; // Pin QH: salida serie del 165

int pinClock = 12; // Pin CLK: clock del 165

TIPO_VAL_BYTES valoresPin;

TIPO_VAL_BYTES viejosValoresPin;

// Esta funcion es una rutina de "desplazamiento hacia adentro" que

// lee datos en serie desde el registro de desplazamiento de los chips

// y arma el estado de los pines en un unsigned integer (o long integer)

TIPO_VAL_BYTES lee_registros_desplaz()

{

long valorBit;

TIPO_VAL_BYTES valorBytes = 0;

// Pulso de carga paralela para guardar el estado de las entradas

digitalWrite(pinCargarDatos, LOW); // pulso carga datos a BAJO

delayMicroseconds(ANCHO_PULSO); // duracion pulso

digitalWrite(pinCargarDatos, HIGH); // pulso carga datos a ALTO

// Lazo que lee el valor de cada bit de la salida serie del 74HC165

for(int i = 0; i < ANCHO_DATOS; i++)

{

valorBit = digitalRead(pinDato);

// poner el bit correspondiente en valorBytes

valorBytes |= (valorBit << ((ANCHO_DATOS-1) - i));

// Pulso de Clock (el flanco de subida desplaza el siguiente bit).

digitalWrite(pinClock, HIGH);

delayMicroseconds(ANCHO_PULSO);

digitalWrite(pinClock, LOW);

}

return(valorBytes);

}

// Mostrar la lista de datos con su estado

void mostrar_valores_pines()

{

Serial.print("Estado pines:\r\n");

for(int i = 0; i < ANCHO_DATOS; i++)

{

Serial.print(" Pin-");

Serial.print(i);

Serial.print(": ");

if((valoresPin >> i) & 1)

Serial.print("ALTO");

else

Serial.print("BAJO");

Serial.print("\r\n");

}

Serial.print("\r\n");

}

void setup()

{

Serial.begin(9600);

// Inicializar los pines digitales

pinMode(pinCargarDatos, OUTPUT);

pinMode(pinClock, OUTPUT);

pinMode(pinDato, INPUT);

digitalWrite(pinClock, LOW); // inicializa CLK en BAJO

digitalWrite(pinCargarDatos, LOW); // inicializa carga datos a BAJO

// Leer y mostrar los estados de los pines la 1ra vez

valoresPin = lee_registros_desplaz();

mostrar_valores_pines();

viejosValoresPin = valoresPin;

}

void loop()

{

// Lee el estado de todos los bytes

valoresPin = lee_registros_desplaz();

// Si hay un cambio de estado, muestra los que cambiaron

if(valoresPin != viejosValoresPin)

{

Serial.print("*Detectado cambio de valor de Pin*\r\n");

mostrar_valores_pines();

viejosValoresPin = valoresPin;

}

delay(ESPERA_DEL_CICLO);

}

El Monitor Serie mostrará este mensaje, y se renovará cada vez que se cambie el valor de una entrada.

Biblioteca ShiftIn

Esta es una biblioteca que permite leer 8 o más entradas. Y también, si bien la biblioteca tiene una función que define 4 pines, se pueden usar sólo 3 pines al Arduino. Además, se puede conectar en cadena varios registros de desplazamiento utilizando la misma cantidad de pines digitales, o sea 3. El cableado es con la misma configuración que en el diagrama de protoboard mostrado arriba.

Instalación fácil (importar zip)

La forma más fácil de instalar esta biblioteca es descargar la última versión y luego importarla. No tiene que descomprimirlo. Simplemente abra su IDE de Arduino y navegue a Programa > Incluir Librería > Añadir Biblioteca .ZIP… y luego seleccione el archivo zip, que puede bajar desde aquí.

Instalación manual

Por supuesto también se puede instalar esta biblioteca manualmente. Para hacerlo, descargue la versión más reciente y descomprímala. Luego tiene que copiar la carpeta ShiftIn (NO la carpeta ShiftIn-x.y.z) y colocarla en la carpeta de la biblioteca Arduino:

Windows: Documentos\Arduino\libraries\
Mac and Linux: Documents/Arduino/libraries/

Después de esto solo hay que reiniciar el IDE de Arduino.

Uso de ShiftIn

Si ha instalado esta biblioteca, puede incluirla navegando a Programa > Incluir Librería > ShiftIn. Esto agregará la línea #include <ShiftIn.h> a su programa (por supuesto, también puede escribir esta línea manualmente).

Ahora se puede usar esta biblioteca:

/*
  Este programa es ejemplo de la libreria ShiftIn.h
  que se encuentra aqui https://github.com/InfectedBytes/ArduinoShiftIn
*/
#include <ShiftIn.h>
// Inicia una instancia de ShiftIn un 1 chip.
// El numero define la cantidad de chips 74HC165 conectados en serie
// Si usted arma un circuit con 2 chips debe escribir: ShiftIn<2> shift;

ShiftIn<1> shift;

void setup() {
// iniciar serie. El programa muestra en Monitor Serie
  Serial.begin(9600);
  
// declar pines: 
// pLoadPin (SH/LD = 8), clockEnablePin (CLK INB = 9), 
// dataPin (SER = 11), clockPin (CLK = 12)
// si bien la librería usa 4 pines solo usamos 3
// no hace falta usar CLK INB en el circuito, va a GND
  shift.begin(8, 9, 11, 12);
}

void displayValues() {
  for(int i = 0; i < shift.getDataWidth(); i++)
    Serial.print( shift.state(i) ); // obtiene el estado de la entrada i
  Serial.println();
}

void loop() {
// lee los valores. Retorna VERDADERO
// si alguna entrada ha cambiado y
// muestra los valores en Monitor Serie
  if(shift.update()) 
    displayValues();
  delay(1);
}

Este programa es ejemplo de la libreria ShiftIn.h

que se encuentra aqui https://github.com/InfectedBytes/ArduinoShiftIn

#include <ShiftIn.h>

// Inicia una instancia de ShiftIn un 1 chip.

// El numero define la cantidad de chips 74HC165 conectados en serie

// Si usted arma un circuit con 2 chips debe escribir: ShiftIn<2> shift;

ShiftIn<1> shift;

void setup() {

// iniciar serie. El programa muestra en Monitor Serie

Serial.begin(9600);

// declar pines:

// pLoadPin (SH/LD = 8), clockEnablePin (CLK INB = 9),

// dataPin (SER = 11), clockPin (CLK = 12)

// si bien la librería usa 4 pines solo usamos 3

// no hace falta usar CLK INB en el circuito, va a GND

shift.begin(8, 9, 11, 12);

}

void displayValues() {

for(int i = 0; i < shift.getDataWidth(); i++)

Serial.print( shift.state(i) ); // obtiene el estado de la entrada i

Serial.println();

}

void loop() {

// lee los valores. Retorna VERDADERO

// si alguna entrada ha cambiado y

// muestra los valores en Monitor Serie

if(shift.update())

displayValues();

delay(1);

}

Los datos en el Monitor Serie se verán así:

Si usted necesita usar dos shift registers, sólo tiene que cambiar la declaración de ShiftIn<1> shift; a ShiftIn<2> shift;, y así sucesivamente.

El diagrama para 2 chips – 16 entradas es este:

Detalle de las funciones de la biblioteca ShiftIn

Dependiendo de la cantidad de chips, esta biblioteca utilizará diferentes tipos de datos. Si solo está utilizando un chip, el tipo ShiftType será un unsigned byte (uint8_t). Para dos chips será un unsigned int (uint16_t). Para tres o cuatro chips será un unsigned long (uint32_t) y para 5 a 8 chips será un unsigned long long (uint64_t). La biblioteca todavía no maneja más de ocho chips.

Esta función debe ser llamada en la función de configuración. Se utiliza para indicar a la biblioteca los pines que debe usar.

void begin(int ploadPin, int clockEnablePin, int dataPin, int clockPin)

GetPulseWidth() define el retardo para el pin de clock en microsegundos. Este valor está fijado en 5 us y en general no habrá necesidad de cambiarlo, aunque teniendo en cuenta el tiempo de programa transcurrido entre la ejecución de el inicio del pulso y de su final, puede ser tan pequeño como 1 us, incluso 0.

uint8_t getPulseWidth()
void setPulseWidth(uint8_t value)

Retorna la cantidad de entradas (bits en el estado)
uint16_t getDataWidth()

Retornan VERDADERO si ha cambiado alguna entrada durante la última lectura.
boolean hasChanged()
boolean hasChanged(int i) // lo mismo de arriba, pero solo para la entrada i

Retornan el estado completo del actual y el último grupo de bits
ShiftType getCurrent()
ShiftType getLast()

Retornan el estado de una sola entrada en el grupo actual de bits y el último grupo de bits
boolean state(int i)
boolean last(int i)

Indica cuando una entrada ha cambiado. En el ejemplo de los esquemas, se ha presionado o se ha soltado un pulsador
boolean pressed(int id) // no estaba presionado en la última lectura, pero ahora sí
boolean released(int id) // estaba presionado en la última lectura, pero ahora fue liberado

Esta función (la función para actualizar) debe ser llamada una vez por cada grupo de bits. Leerá todos los valores de los shift registers y retornará el nuevo estado.
ShiftType read()

Esta función es básicamente la misma que la función read, pero retorna VERDADERO si ha cambiado de estado alguna entrada, y FALSO en el caso contrario
boolean update()

Ingresando datos por SPI

Conectando el 74HC165 a la interfaz SPI se puede leer rápidamente 8 entradas digitales, ingresando los 8 bits en una sola instrucción de SPI. Se los puede encadenar para leer 16, 24, 32 o más entradas a la vez.

Podría usarse, por ejemplo, para examinar la configuración de un interruptor DIP de 8 interruptores (donde se fijaría la configuración del dispositivo).

En el 74HC165 se tiene que pulsar el pin de «cargar» (pin 1 del chip) para que el registro ingrese las entradas externas en sus registros internos.

La habilitación del chip, en esta prueba, es fija. El pin de activación de chip (/CLK INH) está a tierra, ya que el chip también puede funcionar estando siempre habilitado. Tenga en cuenta que la línea MISO siempre está activa, por lo que no es posible compartir este chip con otros dispositivos SPI utilizando el hardware SPI. Se puede solucionar agregando un circuito selector, pero no lo describiré en este artículo ya que si necesita usar otro dispositivo SPI, puede utilizar los otros ejemplos de programa, sin necesidad de SPI.

Código de programa

Es fácil de leer desde el registro. La biblioteca SPI se ocupará de todo.

Los pasos importantes son (dentro de la función de bucle):

1. Aplique un pulse al pin de carga paralela para cargar el registro desde las entradas.
2. Haga una transferencia SPI para leer el registro del chip.

Si desea leer más de 8 interruptores, simplemente use más registros, conecte en paralelo los pines 1, 2 y 15 de los chips, y la salida de cada chip «anterior» en la secuencia (QH) a la entrada del siguiente (SER).

Para leer cuatro bancos de interruptores, se cambia la sección de lectura del programa:

digitalWrite(LATCH, LOW);
digitalWrite(LATCH, HIGH);
bancoEntradas1 = SPI.transfer(0);
bancoEntradas2 = SPI.transfer(0);
bancoEntradas3 = SPI.transfer(0);
bancoEntradas4 = SPI.transfer(0);

NOTA: OBSERVE QUE HAY QUE CAMBIAR, EN EL DIAGRAMA DEL PROTOBOARD DE ARRIBA, LOS PINES QUE IBAN A SALIDA DIGITAL 11 Y SALIDA DIGITAL 12 DEL ARDUINO. LA CONEXIÓN QUE ESTABA EN 12 SE DEBE PASAR A 13, Y LA QUE ESTABA EN 11 SE DEBE PASAR A 12.

/* Programa Demo para leer desde 74HC165
   Autor: Nick Gammon
   Fecha: 23 Marzo 2013

   Conexiones para Uno y similares:
   Chip pin 1 (SH/LD)  conectado a LATCH (8) queda igual
   Chip pin 2 (CLK)   conectado a SCK (13) antes en 12
   Chip pin 9 (QH)   conectado a MISO (12) antes en 11

   Conexiones para Mega2560:
   Chip pin 1 (SH/LD)  conectado a LATCH (8)
   Chip pin 2 (CLK)   conectado a (52)
   Chip pin 9 (QH)   conectado a (50)
*/

#include <SPI.h>

const byte LATCH = 8;

void setup()
{
  SPI.begin();
  Serial.begin(9600);
  Serial.println ("Comienza la prueba de entradas");
  pinMode(LATCH, OUTPUT);
  digitalWrite(LATCH, HIGH);
}

byte bancoEntradas1;
// agregar declaracion: byte bancoEntradas2;
// agregar declaracion: byte bancoEntradas3;
// agregar declaracion: byte bancoEntradas4;
byte bancoEntradas1Viejo; // estado previo

void loop()
{
  digitalWrite (LATCH, LOW);
  digitalWrite (LATCH, HIGH); // pulso en carga paralela
  bancoEntradas1 = SPI.transfer(0);
  //  donde se debe agregar: bancoEntradas2 = SPI.transfer(0);
  //  donde se debe agregar: bancoEntradas3 = SPI.transfer(0);
  //  donde se debe agregar: bancoEntradas4 = SPI.transfer(0);
  
  byte mascara = 1;
  for (int i = 1; i <= 8; i++) {
    if ((bancoEntradas1 & mascara) != (bancoEntradas1Viejo & mascara))
      {
      Serial.print ("Llave ");
      Serial.print (i);
      Serial.print (" ahora ");
      Serial.println ((bancoEntradas1 & mascara) ? "cerrada" : "abierta");
      }  // fin de "el bit ha cambiado"
    mascara <<= 1;  
    }  // final para cada bit
  
  bancoEntradas1Viejo = bancoEntradas1;
  delay (10);
}

/* Programa Demo para leer desde 74HC165

Autor: Nick Gammon

Fecha: 23 Marzo 2013

Conexiones para Uno y similares:

Chip pin 1 (SH/LD) conectado a LATCH (8) queda igual

Chip pin 2 (CLK) conectado a SCK (13) antes en 12

Chip pin 9 (QH) conectado a MISO (12) antes en 11

Conexiones para Mega2560:

Chip pin 1 (SH/LD) conectado a LATCH (8)

Chip pin 2 (CLK) conectado a (52)

Chip pin 9 (QH) conectado a (50)

#include <SPI.h>

const byte LATCH = 8;

void setup()

{

SPI.begin();

Serial.begin(9600);

Serial.println ("Comienza la prueba de entradas");

pinMode(LATCH, OUTPUT);

digitalWrite(LATCH, HIGH);

}

byte bancoEntradas1;

// agregar declaracion: byte bancoEntradas2;

// agregar declaracion: byte bancoEntradas3;

// agregar declaracion: byte bancoEntradas4;

byte bancoEntradas1Viejo; // estado previo

void loop()

{

digitalWrite (LATCH, LOW);

digitalWrite (LATCH, HIGH); // pulso en carga paralela

bancoEntradas1 = SPI.transfer(0);

// donde se debe agregar: bancoEntradas2 = SPI.transfer(0);

// donde se debe agregar: bancoEntradas3 = SPI.transfer(0);

// donde se debe agregar: bancoEntradas4 = SPI.transfer(0);

byte mascara = 1;

for (int i = 1; i <= 8; i++) {

if ((bancoEntradas1 & mascara) != (bancoEntradas1Viejo & mascara))

{

Serial.print ("Llave ");

Serial.print (i);

Serial.print (" ahora ");

Serial.println ((bancoEntradas1 & mascara) ? "cerrada" : "abierta");

} // fin de "el bit ha cambiado"

mascara <<= 1;

} // final para cada bit

bancoEntradas1Viejo = bancoEntradas1;

delay (10);

}

Resultados en Monitor Serie. Muestra una indicación del estado al inicio, y luego lista cada cambio que se produce en las entradas:

Otras opciones

Por último, existen dos librerías relacionadas, llamadas bitBangedSPI y bitBangedSPIfast, que permiten operar las múltiples entradas desde 74HC165 con un SPI implementado por software, y dejar libre el módulo SPI de hardware para otros dispositivos. Entiendo que es lo que hicimos con los programas de ejemplo anteriores, pero les dejo la inquietud de investigarlos y probarlos.

Arduino: ampliar cantidad de salidas digitales con 74HC595

Deja un comentario

A veces un Arduino queda corto de pines, y se nos presenta la necesidad de ampliar la cantidad de salidas digitales. La manera más usual es con un registro de desplazamiento (Shift Register, en inglés), que convierte los datos en serie en salidas paralelas. Esto será de utilidad en aquellas placas como Arduino UNO, Nano, Micro, etc, que a veces resultan un poco limitados en este sentido.

El chip 74HC595 —para algunos un misterioso integrado de 16 patas que viene incluido en muchos kits de inicio para Arduino— tiene una ventaja esencial ante otros chips del mismo tipo: tiene un registro que mantiene el dato en los pines de salida sin variación mientras se desplazan los datos dentro del chip.

Adicionalmente, tiene la posibilidad de desconectar las salidas de este registro de los pines de salida del chip, por medio de la entrada de control OE (Ouput Enable = Habilitación de Salidas), dejándolos en un estado de alta impedancia, o tercer estado. No usaremos esta opción aquí, pero en futuros artículos veremos la importancia de esta posibilidad.

Otro chip opcional para este uso, aunque de 16 bits y también con registro de salida, es el circuito integrado 74LS673, pero es más difícil de encontrar en el mercado.

Al utilizar el circuito integrado 74HC595, ocupamos solamente 3 salidas digitales en la placa Arduino, pero obtenemos 8 salidas digitales adicionales. Este 3 x 8 en pines no parece una gran mejora (ganamos 5 salidas), pero si se agregan más chips, la ampliación puede llegar a ser importante.

Poniendo más chips conectados en serie se pueden obtener otras 8 salidas más por cada chip agregado, y la cantidad de pines ocupados en el Arduino sigue igual: solamente tres. Con tres chips tendremos 24 salidas, con 8 chips tendremos 64, y con 32 chips tendremos una ampliación de 256 nuevas salidas.

Para calcular la cantidad de salidas que obtendremos, hay que multiplicar la cantidad de chips por 8.

En teoría, se puede poner una cantidad indefinida de chips en serie y obtener centenares de salidas adicionales. Sólo se debe tener en cuenta que los datos no se desplazan instantáneamente, debido a los tiempos de programa. Supongamos una cantidad de 32 bytes a poner en las salidas de 32 chips —256 bits—. Colocar todos esos datos en los registros de salida de 32 chips 74HC595 implica un tiempo que puede ser sustancial y prohibitivo para algunas aplicaciones que requieren salidas con variaciones rápidas, sin que importe si se cambia un único bit en las salidas, o los 256 bits juntos. Para aplicaciones sin tiempos críticos, como encendido de leds, artefactos a través de relés, displays de segmentos o control de motores, no existe ningún problema de tiempos.

La mayoría de los chips de registro de desplazamiento pueden manejarse elevadas frecuencias en MHz para el desplazamiento, todos superan la máxima velocidad de envío de datos en serie de un Atmega328P, ya que para hacerlo debemos usar una secuencia de instrucciones de programa. Algunas hojas de datos nos muestran frecuencias de desplazamiento de 100 MHz, 36 MHz, y similares. Un Arduino estándar, con cristal de 16 MHz, y aún más teniendo que usar una secuencia de instrucciones para enviar cada bit, no superará nunca esas frecuencias para el desplazamiento de los datos. De modo que no se nos presentarán problemas de límite de velocidad al usar estos chips.

Registro de desplazamiento 74HC595

Descripción de pines:

Las salidas son Q0 a Q7 (pata 15, y de 1 a 7), y las tres entradas que van conectadas a las salidas de la placa Arduino son DS = entrada de datos (14), SCTP, para ingresar un pulso que deja fijos los datos en el registro de salida (12), y SHCP, que es el pulso de reloj, o clock, que hace desplazar los datos en el registro de desplazamiento (11).

Estas son las señales más importantes de comprender y profundizar.

Luego está la entrada de voltaje de 5V (16), la conexión a tierra (8), y Q7S (9), la salida que se utiliza para continuar la conexión de más chips en serie.

La hoja de datos (datasheet) permite ver con más detalle los datos del chip.

Por la entrada de reloj SHCP se ingresan pulsos que indican el tiempo preciso en que debe ocurrir el ingreso de bits por la entrada DS, y el desplazamiento en el registro.

La entrada de datos es DS.

Y la señal SCTP es un pulso que traspasa los datos del registro de desplazamiento al de salida, y de allí a las salidas digitales.

Las línea SHCP es la señal de reloj. La segunda línea, DS, es la secuencia de datos que queremos hacer llegar a las salidas Q1-Q7.

Con el pulso de reloj el registro de desplazamiento del 74HC595 desplaza los que entraron anteriormente hacia el interior del registro e ingresa el valor que hayamos puesto en el pin de Arduino que está conectado a su entrada DS. Este bit es parte de la secuencia de datos de 8 bits (o sea que este suceso ocurrirá 8 veces).

Para el primer pulso el bit 0, para el segundo pulso el bit 1, y así sucesivamente hasta completar los 8 bits de un byte.

En ese momento los datos del registro de desplazamiento aún no estarán en las salidas, es necesario que la señal STCP reciba un pulso. Cuando STCP sube de nivel bajo a nivel alto, los datos que tenemos en el registro de desplazamiento pasan a estar disponibles en las salidas Q0 – Q7.

En el ejemplo del gráfico de tiempos de arriba, estamos poniendo a nivel ALTO (HIGH) el bit que aparecerá en Q7, y en nivel BAJO (LOW) el resto.

El manejo de las líneas de Arduino

En principio y para mejor comprensión deberíamos dar una mirada a la función shiftOut(). Esta función se ocupará de ir poniendo de a un bit por vez en la salida del Arduino hasta completar los 8 bits del byte que vamos a transferir.

La función shiftOut()

Sintaxis: shiftOut (pinDato, pinClock, ordenBits, valor)

Desplaza un byte de datos (llamado valor) de a un bit por vez hacia el pin indicado en pinDato. Según lo que se indique en el parámetro ordenBits de la función, el desplazamiento comienza desde el bit más significativo (es decir, el que se ubica más a la izquierda en un byte, en la representación estándar) o el menos significativo (más a la derecha). Cada bit se escribe hacia un pin de datos (pinDato), y después se genera un pulso en el pin de reloj en pinClock (alto, luego bajo), lo que indica que el bit está disponible.

Nota: hay que asegurarse que el pin de reloj (pinClock) esté preparado en valor BAJO antes de la llamada a shiftOut(). Por ejemplo, con una llamada a digitalWrite(pinClock, LOW).

Esta es una implementación que utiliza software. Veremos también más adelante la forma de usar la biblioteca SPI, que provee una implementación por hardware más rápida, aunque debemos recordar que solo funciona en los pines definidos para esta interfaz.

Parámetros de la función shiftOut():

■ pinDato: el pin en el que se coloca cada bit
■ pinClock: el pin para producir el pulso una vez que se haya establecido el valor correcto en pinDato
■ ordenBits: indica en qué orden se desplazarán los bits hacia el pin de salida; ya sea MSBFIRST o LSBFIRST (el bit más significativo primero, o el bit menos significativo primero)
■ valor: los datos a desplazar. (formato byte)

Circuito de ejemplo:

AMPLIAR EL DIAGRAMA

Código de ejemplo:

Supongamos que deseamos poner en los pines de salida un byte con el valor B10101010, o sea así:

/****************************************************************/
// Código que muestra como concretar la salida de un byte
/****************************************************************/

int pinDato = 9;      // Pin conectado a DS pin 14 de 74HC595
int pinClock = 12;  // Pin conectado a SHCP pin 11 de 74HC595
int pinRegistro = 11;  // Pin conectado a STCP pin 12 de 74HC595

byte datos;

void setup() {
  // configura los pines de salida que se usan en el bucle principal
  pinMode(pinRegistro, OUTPUT);
  pinMode(pinClock, OUTPUT);
  pinMode(pinDato, OUTPUT);
  digitalWrite(pinRegistro, LOW);
}

void loop() {
  // enviamos un dato con el bit 7 (MSB) en 1
  // y el bit 0 (LSB) en 0 para comprobar si
  // usamos la direccion correcta (MSBFIRST)
  
  datos = B10101010;

   shiftOut(pinDato, pinClock, MSBFIRST, datos);
  // enviamos el dato y pulsamos para que pase
  // al registro de salida y lo podamos ver
  digitalWrite(pinRegistro,HIGH); // pulso ALTO
  digitalWrite(pinRegistro,LOW); // pulso BAJO
}

/****************************************************************/

// Código que muestra como concretar la salida de un byte

/****************************************************************/

int pinDato = 9; // Pin conectado a DS pin 14 de 74HC595

int pinClock = 12; // Pin conectado a SHCP pin 11 de 74HC595

int pinRegistro = 11; // Pin conectado a STCP pin 12 de 74HC595

byte datos;

void setup() {

// configura los pines de salida que se usan en el bucle principal

pinMode(pinRegistro, OUTPUT);

pinMode(pinClock, OUTPUT);

pinMode(pinDato, OUTPUT);

digitalWrite(pinRegistro, LOW);

}

void loop() {

// enviamos un dato con el bit 7 (MSB) en 1

// y el bit 0 (LSB) en 0 para comprobar si

// usamos la direccion correcta (MSBFIRST)

datos = B10101010;

shiftOut(pinDato, pinClock, MSBFIRST, datos);

// enviamos el dato y pulsamos para que pase

// al registro de salida y lo podamos ver

digitalWrite(pinRegistro,HIGH); // pulso ALTO

digitalWrite(pinRegistro,LOW); // pulso BAJO

}

Más programas de ejemplo:

/****************************************************************/
// Código para mostrar el avance de un contador
// en el registro de desplazamiento 74HC595 
/****************************************************************/

int pinDato = 9;      // Pin conectado a DS pin 14 de 74HC595
int pinClock = 12;  // Pin conectado a SHCP pin 11 de 74HC595
int pinRegistro = 11;  // Pin conectado a STCP pin 12 de 74HC595

void setup() {
  // configura los pines a la salida porque se usan en el bucle principal
  pinMode (pinDato, OUTPUT);
  pinMode (pinClock, OUTPUT);
  pinMode (pinRegistro, OUTPUT);
}

void loop() {
  // rutina que cuenta de 0 a 255
  for (int j = 0; j <256; j++) {
    // pone a BAJO pinRegistro y lo mantiene bajo durante el tiempo que este transmitiendo
    digitalWrite(pinRegistro, LOW);
    // envia el dato
    shiftOut(pinDato, pinClock, MSBFIRST, j);
    // retorna el pinRegistro ALTO para sacar los datos hacia las salidas
    digitalWrite(pinRegistro, HIGH);
    delay(200); // breve espera para poder ver el conteo
  }
}

/****************************************************************/

// Código para mostrar el avance de un contador

// en el registro de desplazamiento 74HC595

/****************************************************************/

int pinDato = 9; // Pin conectado a DS pin 14 de 74HC595

int pinClock = 12; // Pin conectado a SHCP pin 11 de 74HC595

int pinRegistro = 11; // Pin conectado a STCP pin 12 de 74HC595

void setup() {

// configura los pines a la salida porque se usan en el bucle principal

pinMode (pinDato, OUTPUT);

pinMode (pinClock, OUTPUT);

pinMode (pinRegistro, OUTPUT);

}

void loop() {

// rutina que cuenta de 0 a 255

for (int j = 0; j <256; j++) {

// pone a BAJO pinRegistro y lo mantiene bajo durante el tiempo que este transmitiendo

digitalWrite(pinRegistro, LOW);

// envia el dato

shiftOut(pinDato, pinClock, MSBFIRST, j);

// retorna el pinRegistro ALTO para sacar los datos hacia las salidas

digitalWrite(pinRegistro, HIGH);

delay(200); // breve espera para poder ver el conteo

}

/****************************************************************/
// Código que muestra la salida de una secuencia de datos 
/****************************************************************/

int pinDato = 9;      // Pin conectado a DS pin 14 de 74HC595
int pinClock = 12;  // Pin conectado a SHCP pin 11 de 74HC595
int pinRegistro = 11;  // Pin conectado a STCP pin 12 de 74HC595

byte datos;

void setup() {
  // configura los pines de salida que se usan en el bucle principal
  pinMode(pinRegistro, OUTPUT);
  pinMode(pinClock, OUTPUT);
  pinMode(pinDato, OUTPUT);
  digitalWrite(pinRegistro, LOW);
}

void loop() {
  // enviamos un dato con el bit 7 (MSB) en 1
  // y el bit 0 (LSB) en 0 para comprobar si
  // usamos la direccion correcta (MSBFIRST)
  datos = B10101010;
  shiftOut(pinDato, pinClock, MSBFIRST, datos);
  // enviamos el dato y pulsamos para que pase
  // al registro de salida y lo podamos ver
  digitalWrite(pinRegistro,HIGH); // pulso ALTO
  digitalWrite(pinRegistro,LOW); // pulso BAJO
  delay(3000); // esperamos para poder ver el dato
  
  // ahora encendemos el bit 0 (LSB) y 
  // dejamos los otros tal como estaban
  datos = B10101011;
  shiftOut(pinDato, pinClock, MSBFIRST, datos);
  // enviamos el dato y pulsamos para que pase
  // al registro de salida y podamos ver
  digitalWrite(pinRegistro,HIGH); // pulso ALTO
  digitalWrite(pinRegistro,LOW); // pulso BAJO
  delay(3000); // esperamos para poder ver el dato

  // este dato enciende los 4 bits mas significativos
  datos = B11110000;
  shiftOut(pinDato, pinClock, MSBFIRST, datos);
  // enviamos el dato y pulsamos para que pase
  // al registro de salida y podamos ver
  digitalWrite(pinRegistro,HIGH); // pulso ALTO
  digitalWrite(pinRegistro,LOW); // pulso BAJO
  delay(3000); // esperamos para poder ver el dato

  // este dato enciende los 4 bits menos significativos
  datos = B00001111;
  shiftOut(pinDato, pinClock, MSBFIRST, datos);
  // enviamos el dato y pulsamos para que pase
  // al registro de salida y podamos ver
  digitalWrite(pinRegistro,HIGH); // pulso ALTO
  digitalWrite(pinRegistro,LOW); // pulso BAJO
  delay(3000); // esperamos para poder ver el dato
}

/****************************************************************/

// Código que muestra la salida de una secuencia de datos

/****************************************************************/

int pinDato = 9; // Pin conectado a DS pin 14 de 74HC595

int pinClock = 12; // Pin conectado a SHCP pin 11 de 74HC595

int pinRegistro = 11; // Pin conectado a STCP pin 12 de 74HC595

byte datos;

void setup() {

// configura los pines de salida que se usan en el bucle principal

pinMode(pinRegistro, OUTPUT);

pinMode(pinClock, OUTPUT);

pinMode(pinDato, OUTPUT);

digitalWrite(pinRegistro, LOW);

}

void loop() {

// enviamos un dato con el bit 7 (MSB) en 1

// y el bit 0 (LSB) en 0 para comprobar si

// usamos la direccion correcta (MSBFIRST)

datos = B10101010;

shiftOut(pinDato, pinClock, MSBFIRST, datos);

// enviamos el dato y pulsamos para que pase

// al registro de salida y lo podamos ver

digitalWrite(pinRegistro,HIGH); // pulso ALTO

digitalWrite(pinRegistro,LOW); // pulso BAJO

delay(3000); // esperamos para poder ver el dato

// ahora encendemos el bit 0 (LSB) y

// dejamos los otros tal como estaban

datos = B10101011;

shiftOut(pinDato, pinClock, MSBFIRST, datos);

// enviamos el dato y pulsamos para que pase

// al registro de salida y podamos ver

digitalWrite(pinRegistro,HIGH); // pulso ALTO

digitalWrite(pinRegistro,LOW); // pulso BAJO

delay(3000); // esperamos para poder ver el dato

// este dato enciende los 4 bits mas significativos

datos = B11110000;

shiftOut(pinDato, pinClock, MSBFIRST, datos);

// enviamos el dato y pulsamos para que pase

// al registro de salida y podamos ver

digitalWrite(pinRegistro,HIGH); // pulso ALTO

digitalWrite(pinRegistro,LOW); // pulso BAJO

delay(3000); // esperamos para poder ver el dato

// este dato enciende los 4 bits menos significativos

datos = B00001111;

shiftOut(pinDato, pinClock, MSBFIRST, datos);

// enviamos el dato y pulsamos para que pase

// al registro de salida y podamos ver

digitalWrite(pinRegistro,HIGH); // pulso ALTO

digitalWrite(pinRegistro,LOW); // pulso BAJO

delay(3000); // esperamos para poder ver el dato

}

El envío de datos en una función propia

El programa anterior repite varias veces un código idéntico para el envío del dato. Es la opción perfecta para convertir esta parte repetida del código en una función propia. Además de reducir la longitud de comandos del programa y hacerlo mucho más legible, creamos una función que nos servirá para cualquier otro programa que envíe dato a un integrado 74HC55. El funcionamiento del envío de datos en este programa a continuación produce exactamente la misma secuencia y funcionamiento del programa.

/****************************************************************/
// Código que muestra la salida de una secuencia de datos utilizando
// una funcion creada por nosotros para ponerlos en el 74HC595
/****************************************************************/

int pinDato = 9;      // Pin conectado a DS pin 14 de 74HC595
int pinClock = 12;  // Pin conectado a SHCP pin 11 de 74HC595
int pinRegistro = 11;  // Pin conectado a STCP pin 12 de 74HC595

void setup() {
  // configura los pines de salida que se usan en el bucle principal
  pinMode(pinRegistro, OUTPUT);
  pinMode(pinClock, OUTPUT);
  pinMode(pinDato, OUTPUT);
  digitalWrite(pinRegistro, LOW);
}

void loop() {
// enviamos un dato con el bit 7 (MSB) en 1
// y el bit 0 (LSB) en 0 para comprobar si
// usamos la direccion correcta (MSBFIRST)
  SalidaDatos(B10101010);  
  delay(3000); // esperamos para ver el dato

// ahora encendemos el bit 0 (LSB) y 
// dejamos los otros tal como estaban
  SalidaDatos(B10101011);  
  delay(3000); // esperamos para ver el dato

// este dato enciende los 4 bits mas significativos
  SalidaDatos(B11110000);  
  delay(3000); // esperamos para ver el dato

// este dato enciende los 4 bits menos significativos
  SalidaDatos(B00001111);  
  delay(3000); // esperamos para ver el dato
}

/* nuestra funcion */
void SalidaDatos(int dato) {
// enviamos el dato
  shiftOut(pinDato, pinClock, MSBFIRST, dato);
// emitimos un pulso para que pase
// al registro de salida y lo podamos ver
  digitalWrite(pinRegistro,HIGH); // pulso ALTO
  digitalWrite(pinRegistro,LOW); // pulso BAJO
}

/****************************************************************/

// Código que muestra la salida de una secuencia de datos utilizando

// una funcion creada por nosotros para ponerlos en el 74HC595

/****************************************************************/

int pinDato = 9; // Pin conectado a DS pin 14 de 74HC595

int pinClock = 12; // Pin conectado a SHCP pin 11 de 74HC595

int pinRegistro = 11; // Pin conectado a STCP pin 12 de 74HC595

void setup() {

// configura los pines de salida que se usan en el bucle principal

pinMode(pinRegistro, OUTPUT);

pinMode(pinClock, OUTPUT);

pinMode(pinDato, OUTPUT);

digitalWrite(pinRegistro, LOW);

}

void loop() {

// enviamos un dato con el bit 7 (MSB) en 1

// y el bit 0 (LSB) en 0 para comprobar si

// usamos la direccion correcta (MSBFIRST)

SalidaDatos(B10101010);

delay(3000); // esperamos para ver el dato

// ahora encendemos el bit 0 (LSB) y

// dejamos los otros tal como estaban

SalidaDatos(B10101011);

delay(3000); // esperamos para ver el dato

// este dato enciende los 4 bits mas significativos

SalidaDatos(B11110000);

delay(3000); // esperamos para ver el dato

// este dato enciende los 4 bits menos significativos

SalidaDatos(B00001111);

delay(3000); // esperamos para ver el dato

}

/* nuestra funcion */

void SalidaDatos(int dato) {

// enviamos el dato

shiftOut(pinDato, pinClock, MSBFIRST, dato);

// emitimos un pulso para que pase

// al registro de salida y lo podamos ver

digitalWrite(pinRegistro,HIGH); // pulso ALTO

digitalWrite(pinRegistro,LOW); // pulso BAJO

}

Diagrama para salida de 16 bits con dos 74HC595

No hay diferencia importante entre los circuitos de cada chip, se ven idénticos; el único cambio es de dónde recibe la información de entrada en DS cada uno: el primero desde la salida digital 11 del Arduino, el segundo desde la salida Q7S del primero. Y así se podría continuar la cadena, agregando de a 8 bits a las salidas. Como se puede observar en el diagrama, las señales de control y clock, STCP y SHCP, de los pines 11 y 12 de los 74HC595, se repiten en paralelo en ambos chips, y así continuaría en toda la cadena si se agregasen más salidas, como se puede ver en el diagrama mostrado más arriba con 4 chips 74HC395.

Programa de ejemplo para 16 bits:

// ****************************************************************
// Enviar 16 bits de datos a dos chips 74HC595
// La función shiftOut escribe en la salida de a 1 byte (8 bits), 
// si queremos enviar 16 bits se requiere que la operación 
// se haga en dos pasos para enviar los dos bytes
// ****************************************************************

int pinDato = 9;      // Pin conectado a DS pin 14 de 74HC595
int pinClock = 12;  // Pin conectado a SHCP pin 11 de 74HC595
int pinRegistro = 11;  // Pin conectado a STCP pin 12 de 74HC595
int datosALTO = B11001100;
int datosBAJO = B11110000;

void setup() {
  // configura los pines como salida
  pinMode (pinDato, OUTPUT);
  pinMode (pinClock, OUTPUT);
  pinMode (pinRegistro, OUTPUT);
}

void loop() {
// envia la parte alta del byte
  shiftOut(pinDato, pinClock, MSBFIRST, datosALTO);

// envia la parte baja del byte
  shiftOut(pinDato, pinClock, MSBFIRST, datosBAJO);

// emitimos un pulso para que pase
// al registro de salida y lo podamos ver
  digitalWrite(pinRegistro,HIGH); // pulso ALTO
  digitalWrite(pinRegistro,LOW); // pulso BAJO
}

// ****************************************************************

// Enviar 16 bits de datos a dos chips 74HC595

// La función shiftOut escribe en la salida de a 1 byte (8 bits),

// si queremos enviar 16 bits se requiere que la operación

// se haga en dos pasos para enviar los dos bytes

// ****************************************************************

int pinDato = 9; // Pin conectado a DS pin 14 de 74HC595

int pinClock = 12; // Pin conectado a SHCP pin 11 de 74HC595

int pinRegistro = 11; // Pin conectado a STCP pin 12 de 74HC595

int datosALTO = B11001100;

int datosBAJO = B11110000;

void setup() {

// configura los pines como salida

pinMode (pinDato, OUTPUT);

pinMode (pinClock, OUTPUT);

pinMode (pinRegistro, OUTPUT);

}

void loop() {

// envia la parte alta del byte

shiftOut(pinDato, pinClock, MSBFIRST, datosALTO);

// envia la parte baja del byte

shiftOut(pinDato, pinClock, MSBFIRST, datosBAJO);

// emitimos un pulso para que pase

// al registro de salida y lo podamos ver

digitalWrite(pinRegistro,HIGH); // pulso ALTO

digitalWrite(pinRegistro,LOW); // pulso BAJO

}

En próximas notas veremos estos circuitos controlados por la biblioteca SPI, en otra el uso del chip serie a paralelo 74LS673 para obtener 16 salidas y en otra nota veremos el uso de un chip paralelo a serie 74HC165 para obtener una ampliación de 8 entradas.

ARTÍCULOS RELACIONADOS:

■ Arduino: Entradas y salidas – Manipulación de puertos
■ Ingresar lectura de varios sensores a través de un único pin analógico
■ Arduino UNO R3 – Conectándolo al mundo exterior

Ingresar lectura de varios sensores a través de un único pin analógico

1 respuesta

Cuando queremos crear un robot que distinga el blanco del negro sobre una superficie, se realiza esa detección con sensores infrarrojos reflectivos. Si la necesidad de determinar las ubicaciones debajo del sensor requiere precisión, hay que usar conjuntos de varios sensores, y sus salidas conectarlas a varios pines de entrada de un microcontrolador.

Por ejemplo, para seguidores de línea veloces (velocistas) tenemos la opción de utilizar un sensor como el de la imagen de arriba, el QTR-8A, fabricado por Pololu. O un conjunto sensor similar hecho por nosotros con, por ejemplo, un conjunto de CNY-70.

La mayoría de las veces los microcontroladores que usamos para controlar un robot tienen una cantidad limitada de pines de entrada y salida, y si tenemos que usar uno de éstos por cada sensor infrarrojo tendremos problemas para añadir funcionalidades a nuestro robot: comunicación serie, acelerómetros, giroscopios, I2C, sensores de distancia, detectores de choque, pulsadores o llaves, motores, tacómetros, leds, etc.

En los robots seguidores de línea el mínimo es dos sensores infrarrojos, aunque con esta cantidad el robot seguidor se moverá oscilando, y es muy posible que se escape en curvas cerradas o cruces de líneas. En los robots de Sumo se necesitan 4, incluso más si es un diseño más sofisticado, y en los seguidores de línea velocistas suele colocarse una hilera de 6 sensores o más.

Esto lleva al uso de demasiado pines de entrada en nuestro micro. Se podría utilizar algún tipo de multiplexor (como el CD74HC4067) para ir leyendo cíclicamente los sensores, pero eso significa el uso adicional de al menos 3 líneas, necesarias para seleccionar las entradas del multiplexor si se trata de un conjunto desde 6 y hasta 8 sensores, o 4 líneas adicionales si tenemos hasta 16 sensores. (Esta cantidad de sensores no es excesiva en un robot medianamente operativo y desarrollado.)

Pero veremos una manera de leer varios sensores de infrarrojos usando sólo un pin analógico del microcontrolador.

La idea es vieja: convertir la activación de los sensores en una selección de resistores que aportan cada uno diferentes corrientes, y que al sumarse entregan una salida combinada, con valores diferentes de voltaje. A esta configuración se le llama “resistor ladder” (escala de resistores) y lo que construimos es, en concreto, un convertidor digital a analógico.

Al usar varias resistencias, dependiendo de la entrada que se active, el pin del micro recibe una tensión distinta. Si el conjunto de resistores está bien diseñado, se puede determinar cuál es la entrada que se ha activado.

Con sensores basados en led infrarrojos y fototransistores, la señal obtenida será analógica y relacionada con la luz que se refleja, a menos que los sectores blanco y negro sean muy definidos y que no haya luz ambiente que interfiera. Para convertir estos valores intermedios a ceros y unos utilizamos un chip CMOS inversor Schmitt trigger 40106 o 74HC14, y en sus salidas ponemos resistencias en serie de distintos valores, que al final de la cadena se unen a un punto en común.

Desde ese punto se tomará el valor de la tensión utilizando una entrada analógica, y si está bien calculado el conjunto de resistencias, el valor analógico será distinto dependiendo del sensor que se haya activado. De ese modo, en el caso de un seguidor de líneas, conoceremos la posición del robot respecto al curso que debe seguir.

La ventaja es que tener varios sensores CNY70, o un conjunto QTR-8A ya no es un problema, porque podemos leer todos los valores con un único pin de nuestro microcontrolador, y dejar el resto libre para otras funciones.

Recordemos que la conversión de analógico a digital dentro del módulo de un microcontrolador lleva tiempo. Por cada sensor que se lee con los pines analógicos se produce una pausa, ya que la lectura de un convertidor de analógico a digital (ADC) típico tarda un tiempo en completarse. Si se conectan y leen por separado, a este retardo hay que multiplicarlo por la cantidad de sensores.

Sin embargo, con esta solución sólo se hace UNA lectura analógica.

Como vamos a usar un inversor schmitt trigger, y éste sólo nos da una señal alta (5V) o baja (0V) en su salida, con las resistencias siempre vamos a obtener los mismos resultados de tensión, aunque cambiemos de entorno (pistas de competición, o caseras con distinta iluminación), por tanto no hay necesidad de calibrar.

Y utilizando las resistencias correctas, sólo es necesario tener un ADC de 8 bits (0-255) para medir el voltaje (en tramos de 0,02V aproximadamente) con una referencia de 5V. En un Arduino el ADC tiene 4 veces más resolución, ya que su conversión es de 10 bits, o sea que entrega valores digitales entre 0 y 1023.

Pondremos como ejemplo 8 sensores infrarrojos que leen una superficie que tiene fondo blanco (que devuelve un valor cercano a 0), y la línea de color negro (que es cuando devuelve un voltaje mayor). Como inversor schmitt trigger se puede usar un 40106 o un 74HCT14. Ambos tienen 6 entradas/salidas. Como se necesitan 2 entradas más para llegar a las 8 del sensor, debemos usar un segundo chip inversor. También se necesitan 8 diodos y 9 resistores.

La salida de cada CNY-70, o de cada elemento del conjunto QTR-8A, va dirigida a una de las entradas de uno de los inversores. La salida correspondiente de ese inversor va a un diodo de señal como el 1N914 o 1N4148. Esto es necesario, ya que al estar unidas todas las salidas del otro lado de los resistores, con los diodos se evita que si una salida está a 5V, y otra a 0V, se derive una corriente entre ellas.

Después del diodo viene el resistor, que dependiendo de su valor hará que la tensión en el punto de unión caiga más, o menos. El valor del resistor debe ser único, diferente del de otros sensores, para que cada caída de tensión sea distinta.

Finalmente se unen todas las salidas a otro resistor para crear lo que se denomina un divisor de tensión. La línea que va al pin analógico del microcontrolador se debe conectar en ese punto, para que éste pueda medir el voltaje total y diferenciar qué sensor o sensores se activan.

Este resistor de terminación al que se une el resto va, en su otro extremo, a la alimentación (Vcc).

Esta configuración está diseñada para poder leer un fondo blanco con una línea negra, siempre y cuando los sensores nos den un valor cercano a 0 cuando leen el fondo blanco, y un valor mucho mayor cuando leen la línea negra. Si se necesita cambiar este comportamiento, se puede conectar la resistencia final a masa e invertir los diodos.

Ahora que ya recibimos distintas tensiones en el pin analógico del microcontrolador, dependiendo de los sensores que estén activos o no, debemos plantearnos cuántas mediciones posibles podemos obtener.

Como trabajamos en el ejemplo de un seguidor velocista, se pueden dar los siguientes casos:

Todos los sensores leen el fondo blanco.
Un sensor lee la línea negra y el resto el fondo blanco.
Dos sensores leen la línea negra y el resto el fondo blanco.

Con esta combinatoria, para conocer las variaciones debemos multiplicar el número de sensores por 2. En total tenemos 16 mediciones posibles (y diferentes) para todos los estados en que pueden estar los sensores.

He aquí un esquema con los distintos estados, el voltaje resultante (según una simulación) y el valor del ADC llevado a 8 bits:

Para un robot de Sumo ya no vale el cálculo anterior, ya que habría 7 combinaciones posibles de sus 4 sensores, y el fondo es negro con una línea blanca:

Ahora sólo queda medir una primera vez los diferentes valores de los sensores, y luego programar en nuestro microcontrolador una tabla con esos valores, para utilizar luego en las comparaciones del programa. Esta lista de valores servirá para siempre. Por supuesto, como los valores de los resistores tienen un margen de error, y la caída de tensión sobre los diodos no suele ser siempre el mismo, sólo podremos hablar de valores orientativos y únicamente podemos obtener los valores correctos midiéndolos directamente con un tester, o conectando el circuito al microcontrolador y que éste nos los informe a través del puerto COM y un monitor serie.

VL53L0X: Sensor de distancia que mide por la velocidad de la luz (Time-of-Fly)

1 respuesta

El VL53L0X es un producto novedoso basado en el sistema FlightSense de la empresa ST Microelectronics. Es una tecnología innovadora que permite medir distancia con independencia de la reflectividad del objetivo.

En lugar de calcular la distancia midiendo la cantidad de luz reflejada desde el objeto (en lo que influye significativamente el color y tipo de superficie), el VL53L0X mide con precisión el tiempo que tarda la luz en viajar desde el objeto más cercano y volver reflejada hasta el sensor (un proceso llamado Time-of-Fly, o Tiempo de vuelo).

Debido a que utiliza una fuente de luz con un haz muy estrecho, es bueno para determinar la distancia de solamente la superficie que está directamente delante. A diferencia de los sonares ultrasónicos que hacen rebotar sus ondas de sonido, en este caso el «cono» de la detección es muy estrecho. A diferencia de los sensores de distancia IR que intentan medir la cantidad de luz que regresa, el VL53L0x es mucho más preciso y no tiene problemas de linealidad o «imágenes dobles», en las que no se puede saber si un objeto está muy lejos o muy cerca.

Puede medir distancia con un alcance de hasta 2 m.

El control del procesador y la lectura de los resultados se realizan por medio de una interfaz I2C.

Características clave

Emisor infrarrojo: 940 nm
Distancia: hasta 2000 mm
Dirección I2C: Programable
Fuente de luz VCSEL (Vertical-cavity surface-emitting laser = Láser de emisión de superficie de cavidad vertical)
Sensor de rango con avanzado microcontrolador
El chip mide sólo 4,4 x 2,4 x 1,0 mm
Medición de distancia rápida y precisa
Mide rango absoluto hasta 2 m.
El rango reportado es independiente de la reflectividad del objetivo
Compensación óptica cruzada integrada avanzada para simplificar la selección del vidrio de cobertura
Seguro para el ojo humano
Dispositivo láser de clase 1 que cumple con la última norma IEC 60825-1: 2014 – 3ª edición
Fácil integración por el sistema de montaje de soldadura del chip
No tiene óptica adicional
Fuente de alimentación individual
Regulador de voltaje integrado en la plaqueta
Interfaz I2C para control de dispositivos y transferencia de datos
Pines de entrada salida de uso general Xshutdown (para reinicio) e Interrupt (interrupción)
Dirección I2C programable

Conexión con Arduino

VCC (en algunos fabricantes VIN) es la fuente de alimentación, el módulo acepta de 3 a 5V de alimentación. Use el mismo voltaje en el que se basa la lógica del microcontrolador. Para la mayoría de los Arduinos es 5V.
Conecte GND a tierra/alimentación común (marcado también GND en el Arduino).
Conecte el pin SCL al pin SCL (señal de reloj I2C en su Arduino. En un Arduino UNO también se conoce como pin A5, aunque está disponible del lado de los pines digitales. En un Mega es el digital 21 y en un Leonardo es el digital 3.
Conecte el pin SDA al pin SDA (datos I2C) en su Arduino. En un Arduino UNO también se conoce como pin A4, en un Mega es el digital 20 y en un Leonardo es el digital 2.

Los pines adicionales son:

GPIO1: este es un pin que usa el sensor para indicar que están listos los datos. Es útil para cuando se realiza una detección continua. Tenga en cuenta que no hay ajuste de nivel en este pin, es posible que no se pueda leer el voltaje de nivel lógico de 2,8V en un microcontrolador de 5V (podríamos en un Arduino UNO, pero no es seguro). La biblioteca de Adafruit no hace uso de este pin, pero está ahí para usuarios avanzados.

XSHUT – es el pin de apagado/reinicio para el sensor. Por defecto es alto. Hay un diodo de cambio de nivel para que se pueda usar la lógica de 3,3 – 5 V en este pin. Cuando el pin va a nivel bajo, el sensor entra en modo de apagado.

Abra el IDE de Arduino. Mantenga siempre actualizado a la última versión.

Abra en el menú HERRAMIENTAS la opción ADMINISTRAR BIBLIOTECAS.

Búsqueda y carga en el IDE Arduino de la biblioteca del VL53L0X

La elección ADMINISTRAR BIBLIOTECAS abrirá la siguiente ventana del Gestor de Bibliotecas:

En esa ventana tenemos, en la parte superior derecha una ventana de editor con la leyenda «Filtre su búsqueda…«, donde debemos escribir el nombre del dispositivo:

Esta búsqueda nos ofrece varias bibliotecas. Para Arduino UNO y relacionados tenemos la de Adafruit y la de Pololu. En artículos en la web recomiendan la de Pololu, porque es más simple que la del otro fabricante. De todos modos, podemos instalar ambas. No hay conflictos en esto. El botón que dice «Instalar» aparece cuando se coloca el puntero del mouse en la biblioteca elegida. Si no aparece, es porque ya está instalada. Si no fuese así, recurra a el enlace «More info» y descargue la biblioteca desde el sitio GitHub, en formato ZIP, y proceda a instalarla con las instrucciones que ofrecen AQUÍ.

El gestor nos indicará que la biblioteca está lista con un cartel remarcado «INSTALLED».

Las bibliotecas quedan listas para ser utilizadas. La que corresponde a Pololu se llama VL53L0X, mientras que la de Adafruit se llama igual y está dentro de todas las bibliotecas de este fabricante, que llevan su nombre comercial como prefijo.

Dirección para el bus I2C

La dirección por defecto de I2C es 0x29, pero recuerde que es posible programar esta dirección en el VL53L0X. Con la biblioteca Adafruit, hay dos maneras de establecer la nueva dirección. Durante la inicialización, en lugar de llamar a lox.begin(), se llama a lox.begin(0x30) para establecer la dirección en 0x30. O se puede, más adelante, llamar a lox.setAddress(0x30) en cualquier momento. Es importante realizar esta operación con una sola placa VL53L0X conectada al bus I2C, o todas quedarán cambiadas.

Programas de prueba

«Continuous», de Pololu
(Este ejemplo muestra cómo usar el «modo continuo» para tomar mediciones de distancia con el VL53L0X. La información se muestra en la pantalla emergente del Monitor Serie, que debe estar fijado en 9600 baudios.)

/* This example shows how to use continuous mode to take
range measurements with the VL53L0X. It is based on
vl53l0x_ContinuousRanging_Example.c from the VL53L0X API.

The range readings are in units of mm. */

#include <Wire.h>
#include <VL53L0X.h>

VL53L0X sensor;

void setup()
{
  Serial.begin(9600);
  Wire.begin();

  sensor.init();
  sensor.setTimeout(500);

  // Start continuous back-to-back mode (take readings as
  // fast as possible).  To use continuous timed mode
  // instead, provide a desired inter-measurement period in
  // ms (e.g. sensor.startContinuous(100)).
  sensor.startContinuous();
}

void loop()
{
  Serial.print(sensor.readRangeContinuousMillimeters());
  if (sensor.timeoutOccurred()) { Serial.print(" TIMEOUT"); }

  Serial.println();
}

/* This example shows how to use continuous mode to take

range measurements with the VL53L0X. It is based on

vl53l0x_ContinuousRanging_Example.c from the VL53L0X API.

The range readings are in units of mm. */

#include <Wire.h>

#include <VL53L0X.h>

VL53L0X sensor;

void setup()

{

Serial.begin(9600);

Wire.begin();

sensor.init();

sensor.setTimeout(500);

// Start continuous back-to-back mode (take readings as

// fast as possible). To use continuous timed mode

// instead, provide a desired inter-measurement period in

// ms (e.g. sensor.startContinuous(100)).

sensor.startContinuous();

}

void loop()

{

Serial.print(sensor.readRangeContinuousMillimeters());

if (sensor.timeoutOccurred()) { Serial.print(" TIMEOUT"); }

Serial.println();

}

Y el que sigue es un ejemplo con la biblioteca de Adafruit, con los comentarios traducidos. Siempre con la misma conexión del diagrama de arriba.

#include "Adafruit_VL53L0X.h"
 
Adafruit_VL53L0X lox = Adafruit_VL53L0X();
 
void setup() {
  Serial.begin(9600);
 
  // Iniciar sensor
  Serial.println("VL53L0X test");
  if (!lox.begin()) {
    Serial.println(F("Error al iniciar VL53L0X"));
    while(1);
  }
}
 
 
void loop() {
  VL53L0X_RangingMeasurementData_t measure;
    
  Serial.print("Leyendo sensor... ");
  lox.rangingTest(&measure, false); // si se pasa true como parametro, muestra por puerto serie datos de debug
 
  if (measure.RangeStatus != 4)
  {
    Serial.print("Distancia (mm): ");
   Serial.println(measure.RangeMilliMeter);
  } 
  else
  {
    Serial.println("  Fuera de rango ");
  }
    
  delay(100);
}

#include "Adafruit_VL53L0X.h"

Adafruit_VL53L0X lox = Adafruit_VL53L0X();

void setup() {

Serial.begin(9600);

// Iniciar sensor

Serial.println("VL53L0X test");

if (!lox.begin()) {

Serial.println(F("Error al iniciar VL53L0X"));

while(1);

}

void loop() {

VL53L0X_RangingMeasurementData_t measure;

Serial.print("Leyendo sensor... ");

lox.rangingTest(&measure, false); // si se pasa true como parametro, muestra por puerto serie datos de debug

if (measure.RangeStatus != 4)

{

Serial.print("Distancia (mm): ");

Serial.println(measure.RangeMilliMeter);

}

else

{

Serial.println(" Fuera de rango ");

}

delay(100);

}

En el programa que sigue, para reducir el ruido de la medición se muestra el promedio de varias medidas. Las líneas comentadas muestran los distintos modos de funcionamiento.

/* ################## Sensor VL53L0X #############################
* Filename: VL53L0X_Ej1.ino
* Descripción: Test Medidor Distancia Laser
* Autor: Jose Mª Morales
* Revisión: 12-04-2017
* Probado: ARDUINO UNO r3 - IDE 1.8.2 (Windows7)
* Web: www.playbyte.es/electronica/
* Licencia: Creative Commons Share-Alike 3.0
* http://creativecommons.org/licenses/by-sa/3.0/deed.es_ES
* ##############################################################
*/

#include <Wire.h>
#include <VL53L0X.h>
VL53L0X sensor;

int n_Samples = 5; // numero de muestras para promediar

//#define LONG_RANGE // Aumenta sensibilidad, +rango, -precision
//#define HIGH_SPEED // Mayor velocidad, menor precision
#define HIGH_ACCURACY // Alta precision, menor velocidad


void setup() {

 Serial.begin(9600);
 Wire.begin();

 sensor.init();
 sensor.setTimeout(500);

//###### Parametros Medida simple ##########
#if defined LONG_RANGE
// Limite de la tasa de retorno (por defecto 0.25 MCPS)
 sensor.setSignalRateLimit(0.1);
// Periodo de pulso laser (por defecto 14 y 10 PCLKs)
 sensor.setVcselPulsePeriod(VL53L0X::VcselPeriodPreRange, 18);
 sensor.setVcselPulsePeriod(VL53L0X::VcselPeriodFinalRange, 14);
#endif

#if defined HIGH_SPEED
// reduce tiempo estimado a 20 ms (por defecto 33 ms)
 sensor.setMeasurementTimingBudget(20000);
#elif defined HIGH_ACCURACY
// incrementa tiempo estimado a 200 ms
 sensor.setMeasurementTimingBudget(200000);
#endif
}


void loop() {

 float DISTANCIA = getDISTANCIA (n_Samples);
 
 if (sensor.timeoutOccurred()) {
 Serial.println(" TIME OUT");
 }else {
 if (DISTANCIA< 2) Serial.println("Fuera de Rango (d < 2 cm)");
 else if (DISTANCIA>220) Serial.println("Fuera de Rango (d > 2 m)");
 else { 
 Serial.print(DISTANCIA, 1); // distancia en cm y 1 decimal
 Serial.println(" cm"); 
 }
 }
 delay (300);
}


float getDISTANCIA(int n) { // hacemos "n" mediciones

 float SUMA_n = 0;
 for (int i = 0; i < n; i++) { 
 SUMA_n += sensor.readRangeSingleMillimeters();
 }
 return( SUMA_n /n /10); // Promedio en centimetros
}

/* ################## Sensor VL53L0X #############################

* Filename: VL53L0X_Ej1.ino

* Descripción: Test Medidor Distancia Laser

* Autor: Jose Mª Morales

* Revisión: 12-04-2017

* Probado: ARDUINO UNO r3 - IDE 1.8.2 (Windows7)

* Web: www.playbyte.es/electronica/

* Licencia: Creative Commons Share-Alike 3.0

* http://creativecommons.org/licenses/by-sa/3.0/deed.es_ES

* ##############################################################

#include <Wire.h>

#include <VL53L0X.h>

VL53L0X sensor;

int n_Samples = 5; // numero de muestras para promediar

//#define LONG_RANGE // Aumenta sensibilidad, +rango, -precision

//#define HIGH_SPEED // Mayor velocidad, menor precision

#define HIGH_ACCURACY // Alta precision, menor velocidad

void setup() {

Serial.begin(9600);

Wire.begin();

sensor.init();

sensor.setTimeout(500);

//###### Parametros Medida simple ##########

#if defined LONG_RANGE

// Limite de la tasa de retorno (por defecto 0.25 MCPS)

sensor.setSignalRateLimit(0.1);

// Periodo de pulso laser (por defecto 14 y 10 PCLKs)

sensor.setVcselPulsePeriod(VL53L0X::VcselPeriodPreRange, 18);

sensor.setVcselPulsePeriod(VL53L0X::VcselPeriodFinalRange, 14);

#endif

#if defined HIGH_SPEED

// reduce tiempo estimado a 20 ms (por defecto 33 ms)

sensor.setMeasurementTimingBudget(20000);

#elif defined HIGH_ACCURACY

// incrementa tiempo estimado a 200 ms

sensor.setMeasurementTimingBudget(200000);

#endif

}

void loop() {

float DISTANCIA = getDISTANCIA (n_Samples);

if (sensor.timeoutOccurred()) {

Serial.println(" TIME OUT");

}else {

if (DISTANCIA< 2) Serial.println("Fuera de Rango (d < 2 cm)");

else if (DISTANCIA>220) Serial.println("Fuera de Rango (d > 2 m)");

else {

Serial.print(DISTANCIA, 1); // distancia en cm y 1 decimal

Serial.println(" cm");

}

delay (300);

}

float getDISTANCIA(int n) { // hacemos "n" mediciones

float SUMA_n = 0;

for (int i = 0; i < n; i++) {

SUMA_n += sensor.readRangeSingleMillimeters();

}

return( SUMA_n /n /10); // Promedio en centimetros

}

Puente H: Placa controladora de motores L9110S

3 respuestas

La placa L9110S está diseñada para que los microcontroladores o circuitos lógicos puedan controlar con sencillez motores de corriente continua.

El circuito está diseñado en base al chip controlador L9110, fabricado en la clásica cápsula DIP8 o en un diseño SOP8 SMD y basado en transistores MOSFET.

La tensión de alimentación para los motores puede variar de 2,5 a 12 V.

Como se observa en el siguiente diagrama, el control con el cableado típico no requiere componentes adicionales.

Las entradas se pueden conectar directamente al microcontrolador. Si se conectan a un circuito que tiene salidas OC (Open Colector, o Colector Abierto) se requiere una resistencia pull-up conectada a la alimentación de 5V. Si bien en la hoja de datos del chip indica que el valor adecuado es ?1 k?, el módulo en sí incluye en su circuito resistores de 10 k? conectados al voltaje de alimentación de la lógica, o Vcc.

El circuito tiene dos entradas: una que puesta en ALTO hará que el motor avance, y una que puesta en ALTO hará que retroceda. Si se desea que el motor esté detenido, ambas entradas deben estar en el mismo valor: las dos en estado BAJO (LOW), o ambas en estado alto (HIGH). La placa tiene dos salidas, con bornera, que se conectan directamente al motor.

Las entradas que no se conectan a un circuito son tomadas como nivel BAJO (L, o Low) sin que ingrese ruido. Con un nivel ALTO (H, o HIGH), la corriente en esa entrada será de alrededor de 1 mA. El nivel de tensión para que el chip detecte la entrada en estado lógico BAJO o L es como máximo de 0,7 V.

Típicamente, para el nivel ALTO o H, la tensión en el pin de entrada debe ser de alrededor de la mitad del valor de alimentación o más (hasta, como máximo, el valor de la tensión de alimentación).

La corriente del motor se puede mantener constantemente desde 0,75 hasta 0,8 A (750 a 800 mA), y el circuito soporta picos de 1,5 a 2 A.

La hoja de datos ofrece una lista de los valores lógicos de las entradas y salidas.

Esta tabla se puede ampliar para situaciones no típicas. Si sólo hay una entrada en el nivel H y la otra está en nivel L, el motor gira. Pero si ambas entradas están en H, o ambas entradas están en L, las salidas están en un tercer estado, o “flotante” (ningún voltaje), y no ambas en 0 volt, o “L”, como se muestra en la tabla.

Las salidas están conectadas internamente a diodos que protegen al circuito de los pulsos de contracorriente.

El L9110 gestiona dinámicamente frecuencias de hasta 40 kHz, mientras que el tiempo de conmutación más breve para la regulación por ancho de pulso (PWM) es de alrededor de 15 uS.

Diagrama de conexiones

Diagrama eléctrico

Ejemplo práctico para controlar un robot

Ejemplo de programa para Arduino: prueba de movimientos

/*
 L9110 motor driver controlando 2 motores CC
 COPIAR Y PEGAR SOBRE EL SKETCH DE ARDUINO
*/

const int AIA = 6;  // (pwm) pin 6 conectado a pin A-IA 
const int AIB = 5;  // (pwm) pin 5 conectado a pin A-IB 
const int BIA = 10; // (pwm) pin 10 conectado a pin B-IA  
const int BIB = 9;  // (pwm) pin 9 conectado a pin B-IB 

byte velocidad = 160;  
// cambie este valor (100 a 255) para controlar 
// la velocidad de los motores 

void setup() {
  pinMode(AIA, OUTPUT); // fijar los pines como salidas
  pinMode(AIB, OUTPUT);
  pinMode(BIA, OUTPUT);
  pinMode(BIB, OUTPUT);
}

void loop() {
  izquierda();
  delay(2000);
  derecha();
  delay(2000);
  avanzar();
  delay(500);
  retroceder();
  delay(1000);
  avanzar();
  delay(500);
}

void avanzar()
{
  analogWrite(AIA, 0);
  analogWrite(AIB, velocidad);
  analogWrite(BIA, 0);
  analogWrite(BIB, velocidad);
}

void retroceder()
{
  analogWrite(AIA, velocidad);
  analogWrite(AIB, 0);
  analogWrite(BIA, velocidad);
  analogWrite(BIB, 0);
}

void izquierda()
{
  analogWrite(AIA, velocidad);
  analogWrite(AIB, 0);
  analogWrite(BIA, 0);
  analogWrite(BIB, velocidad);
}

void derecha()
{
  analogWrite(AIA, 0);
  analogWrite(AIB, velocidad);
  analogWrite(BIA, velocidad);
  analogWrite(BIB, 0);
}

L9110 motor driver controlando 2 motores CC

COPIAR Y PEGAR SOBRE EL SKETCH DE ARDUINO

const int AIA = 6; // (pwm) pin 6 conectado a pin A-IA

const int AIB = 5; // (pwm) pin 5 conectado a pin A-IB

const int BIA = 10; // (pwm) pin 10 conectado a pin B-IA

const int BIB = 9; // (pwm) pin 9 conectado a pin B-IB

byte velocidad = 160;

// cambie este valor (100 a 255) para controlar

// la velocidad de los motores

void setup() {

pinMode(AIA, OUTPUT); // fijar los pines como salidas

pinMode(AIB, OUTPUT);

pinMode(BIA, OUTPUT);

pinMode(BIB, OUTPUT);

}

void loop() {

izquierda();

delay(2000);

derecha();

delay(2000);

avanzar();

delay(500);

retroceder();

delay(1000);

avanzar();

delay(500);

}

void avanzar()

{

analogWrite(AIA, 0);

analogWrite(AIB, velocidad);

analogWrite(BIA, 0);

analogWrite(BIB, velocidad);

}

void retroceder()

{

analogWrite(AIA, velocidad);

analogWrite(AIB, 0);

analogWrite(BIA, velocidad);

analogWrite(BIB, 0);

}

void izquierda()

{

analogWrite(AIA, velocidad);

analogWrite(AIB, 0);

analogWrite(BIA, 0);

analogWrite(BIB, velocidad);

}

void derecha()

{

analogWrite(AIA, 0);

analogWrite(AIB, velocidad);

analogWrite(BIA, velocidad);

analogWrite(BIB, 0);

}

L9110S como amplificador de sonido para su robot

El control de un motor no es la única aplicación posible. El circuito también se puede utilizar como un sustituto de amplificador de potencia para una salida de audio digital de un microcontrolador.

En lugar de conmutar corriente a través del parlante como se realiza habitualmente, con un transistor, este circuito proporciona una doble amplitud de los impulsos de salida y, por lo tanto, aporta una potencia significativamente mayor.

Para una fuente de alimentación de 5 V es conveniente conectar un altavoz con una impedancia de 8 ? (o superior), mientras que con una entrada de 3 voltios puede utilizarse un altavoz adaptado a un voltaje menor. Para controlar el altavoz es necesario utilizar dos salidas en las que el nivel H alternará en cada media onda de la frecuencia del sonido.

En la siguiente figura hay una conexión que es normal con una salida, y funciona bien de 5 Hz a aproximadamente 30 kHz. Es importante mantener la condición de salida del microcontrolador en un nivel H cuando no se emite sonido, de lo contrario circulará corriente constante por el parlante.

Robots Didácticos

Robótica, Automatización, control industrial, microcontroladores, electrónica digital

Archivo de la categoría: Diseños

Ampliar la cantidad de entradas de Arduino

Arduino: ampliar cantidad de salidas digitales con 74HC595

Ingresar lectura de varios sensores a través de un único pin analógico

VL53L0X: Sensor de distancia que mide por la velocidad de la luz (Time-of-Fly)

Puente H: Placa controladora de motores L9110S