En este tutorial veremos como se configura el display 16×2 sus conexiones y programación usando el adaptador de la interfaz I2C para usar menos pines en el Arduino, en nuestro caso vamos a usar un Arduino Mega pero pueden usar un UNO tambien. La explicación del procedimiento lo haremos mediante la realización de un juego que usa un botón para capturar fugitivos .

La pantalla LCD de 16×2 basada en el controlador HD44780 de Hitachi es un periférico muy común, que se utiliza ampliamente en proyectos con arduino y microcontroladores en general, sin embargo, es bien sabido por todo aquel maker que ha incluido una en sus proyectos, que este tipo de pantalla requiere muchos pines del microcontrolador para ser controlada, debido principalmente a que utiliza un bus paralelo para comunicarse. Afortunadamente existe una solución muy fácil y económica para este problema: un adaptador basado en el PCF8574 que permite conectar la pantalla al arduino usando solamente dos lineas digitales a través del bus I2C. Dichos pines, pueden además ser compartidos por otros periféricos como el RTC o memorias EEPROM. En este artículo te explicamos como utilizar una pantalla LCD 16×2 por I2C con Arduino de manera que puedas aprovechar mejor tus pines de I/O.

La dirección I2C por defecto del módulo puede ser 0x3F o en otros casos 0x27. Es muy importante identificar correctamente la dirección I2C de nuestro modulo, pues de otra forma nuestro programa no funcionará correctamente. Para identificar la dirección especifica de nuestro módulo podemos utilizar un pequeño sketch de prueba llamado:

I2C Scanner

/ --------------------------------------
// i2c_scanner
//
// Version 1
//    This program (or code that looks like it)
//    can be found in many places.
//    For example on the Arduino.cc forum.
//    The original author is not know.
// Version 2, Juni 2012, Using Arduino 1.0.1
//     Adapted to be as simple as possible by Arduino.cc user Krodal
// Version 3, Feb 26  2013
//    V3 by louarnold
// Version 4, March 3, 2013, Using Arduino 1.0.3
//    by Arduino.cc user Krodal.
//    Changes by louarnold removed.
//    Scanning addresses changed from 0...127 to 1...119,
//    according to the i2c scanner by Nick Gammon
//    https://www.gammon.com.au/forum/?id=10896
// Version 5, March 28, 2013
//    As version 4, but address scans now to 127.
//    A sensor seems to use address 120.
// Version 6, November 27, 2015.
//    Added waiting for the Leonardo serial communication.
//
//
// This sketch tests the standard 7-bit addresses
// Devices with higher bit address might not be seen properly.
//
 
#include <Wire.h>
 
 
void setup()
{
  Wire.begin();
 
  Serial.begin(9600);
  while (!Serial);             // Leonardo: wait for serial monitor
  Serial.println("\nI2C Scanner");
}
 
 
void loop()
{
  byte error, address;
  int nDevices;
 
  Serial.println("Scanning...");
 
  nDevices = 0;
  for(address = 1; address < 127; address++ )
  {
    // The i2c_scanner uses the return value of
    // the Write.endTransmisstion to see if
    // a device did acknowledge to the address.
    Wire.beginTransmission(address);
    error = Wire.endTransmission();
 
    if (error == 0)
    {
      Serial.print("I2C device found at address 0x");
      if (address<16)
        Serial.print("0");
      Serial.print(address,HEX);
      Serial.println("  !");
 
      nDevices++;
    }
    else if (error==4)
    {
      Serial.print("Unknown error at address 0x");
      if (address<16)
        Serial.print("0");
      Serial.println(address,HEX);
    }    
  }
  if (nDevices == 0)
    Serial.println("No I2C devices found\n");
  else
    Serial.println("done\n");
 
  delay(5000);           // wait 5 seconds for next scan
}

el cual nos permite identificar la dirección I2C del dispositivo conectado al Arduino.

Este sketck es solo necesario correr si no muestra el display 16×2 los mensajes que envia el sketck principal del juego.

Como se aprecia el adaptador para LCD 16×2 por I2C con Arduino nos permite ahorrar bastante tiempo en las conexiones, pues ya incluye el potenciómetro para regular el contraste de la pantalla. También incluye todo lo necesario para el funcionamiento del backlight (retro-iluminación), pudiendo incluso controlar esta función a través de software. Si no queremos soldar el adaptador a la pantalla, podemos utilizar un protoboard para realizar la conexión entre ambas piezas

Elementos Requeridos

1- Arduino Mega o UNO

1- Display 16×2 con adaptador I2C

1- Protoboard

4- Cables Jumpers Macho- Hembra

4- Cables Jumpers Macho- Macho

1- Botón Pulsador Tact Switch 6X6X7mm

1- Resistencia de 10K

Conexiones del Adaptador Interfaz I2C al Arduino

Librería para LCD 16×2 por I2C con Arduino

Para usar el LCD 16×2 por I2C con Arduino es necesario también agregar una librería a nuestro IDE, de forma que este sepa como comunicarse con el  chip PCF8574.

Puedes descargar la librería desde la página oficial en Bitbucket. A continuación dejamos el enlace para bajarlo.

• Descarga desde página oficial (repositorio bitbucket)

La librería LiquidCrystal_I2C dispone de  los siguientes métodos .

• LiquidCrystal_I2C() – Constructor de la clase, configura el hardware.
• init() – Prepara el LCD para su uso.
• clear() – Borra todos los caracteres de la pantalla LCD.
• setCursor(col, row) – Permite mover el cursor a la posición indicada en sus parámetros.
• print() – Imprime una variable o literal en la pantalla
• scrollDisplayLeft() y scrollDisplayRight() – Recorre el contenido de la pantalla a la izquierda o a la derecha
• backlight() y noBacklight() – Métodos para encender / apagar la iluminación de fondo
• createChar(num, data) –  Crear un carácter definido por el usuario en la memoria del controlador de pantalla

Recomendamos revisar el siguiente enlace para conocer todos los métodos de los que dispone la librería oficial LiquidCrystal:

• Documentación de la clase LiquidCrystal (librería oficial para LCD incluida con Arduino)

Codigo del Juego “Captura el Fugitivo”

Una vez instaladas las librerías en el IDE de Arduino, copiamos el siguiente Código.

#include <Wire.h> 
#include <LiquidCrystal_I2C.h> 
 
LiquidCrystal_I2C lcd(0x27,2,1,0,4,5,6,7,3, POSITIVE);  
  

byte letra1[8] = { B01110, B01110, B01110, B00100, B11111, B00100, B01010, B01010 }; 
byte letra2[8] = { B01110, B01110, B01110, B10101, B01110, B00100, B01010, B10001 }; 

byte letra3[8] = { B00100, B00100, B00100, B00100, B00100, B11111, B01110, B00100 };

byte letra0[8] = { B00000, B00000, B00000, B00000, B00000, B00000, B00000, B00000 };
byte letra4[8] = { B01110, B01110, B01110, B11111, B10101, B01110, B01010, B11011 };

int x=0;
int y=1;
int retardo=200;
int presos=0;
int libres=8;
int fallas=0;
int puntaje=0;

void setup() {
  lcd.begin(16, 2);               // Configura el LCD con 16 columnas y 2 filas
  lcd.createChar(1, letra1);      // asigna los nuevos caracteres por numeros
  lcd.createChar(2, letra2);
  lcd.createChar(3, letra3);
  lcd.createChar(0, letra0);
  lcd.createChar(4, letra4);
} 

void loop() {
 
  lcd.setCursor(0, 0);   // Posicion del letrero en 0,0
  lcd.print(presos); 
  lcd.setCursor(2, 0);   // Posicion del letrero en 2,0
  lcd.print("F"); 
  lcd.setCursor(3, 0);   // Posicion del letrero en 3,0
  lcd.print(fallas); 
  lcd.setCursor(0, 1);   // Posicion del letrero en 0,1
  lcd.print(libres); 

  lcd.setCursor(x,y);  // imagen fugitivo 1
  lcd.write(byte(1)); 
  delay(retardo);

  lcd.setCursor(x,y);  // imagen fugitivo 2
  lcd.write(byte(2));
  delay(retardo);

  lcd.clear();        // borrar Pantalla

  lcd.setCursor(14,0); // Flecha en posicion 
  lcd.write(byte(3));
  
  lcd.setCursor(5, 0);   
  lcd.print("Capturalo"); 
  
  if (analogRead(A5)<= 10) {  // Si es oprimido el interruptor A5
    lcd.setCursor(14,0);      
    lcd.write(byte(0));
    lcd.setCursor(14,1);     
    lcd.write(byte(3));
   
    if (x == 14) {           
       lcd.setCursor(5, 0);
       lcd.print("Bien   ."); 
       lcd.setCursor(x,y);    
       lcd.write(byte(4));
       presos++;   
       libres--;  
    }
    else{                        // Cuando no es capturado
       lcd.setCursor(0, 0);
       lcd.print("Fallaste JAJAJA"); 
       lcd.setCursor(x,y);       +
       lcd.write(byte(2));
       fallas++;
    }
  delay(3000);                     
  }
 
  x=x+1;                         // avanza el corredor
  
  if (x>=16) {
     x=0;                       
  }  
 
  retardo = random(1,150);       // Escoge un retardo aleatorio

 if (fallas == 4) {                 
       lcd.clear();                
       lcd.setCursor(0, 0);
       lcd.print("NO PUDISTE JAJA"); 
       puntaje=presos+presos;
       lcd.setCursor(3, 1);
       lcd.print("Puntaje:"); 
       lcd.setCursor(12, 1);
       lcd.print(puntaje); 
       delay (7000);
       presos=0;
       libres=7;
       fallas=0;
       lcd.clear();        
    }
 if (libres == 0) {             // Si coincide en la posicion 14 y es capturado
       lcd.clear();             // borrar Pantalla
       lcd.setCursor(3, 0);
       if (fallas == 0) {              // Si no hubo fallas
         lcd.print("EXCELENTE!!!!"); 
       }
       else{
         lcd.print("PODES MEJORAR");    // si termino pero con alguna falla
       }
       
       puntaje=presos+presos;
       lcd.setCursor(3, 1);
       lcd.print("Puntaje:"); 
       lcd.setCursor(12, 1);
       lcd.print(puntaje);              
       delay (7000);
       presos=0;
       libres=7;
       fallas=0;
       lcd.clear();       
    }   
   
}

Esta bien comentado pero si quieren ver explicación paso a paso de las conexiones y  del código ver el siguiente video.

Saludos GokuGamer2.0

105

• arduino | programación

Publicación by GokuGamer2.0 is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 Internacional