___________
1.- I2C

- Esta es la mejor forma de conexión, se observa el módulo I2C marrón acoplado a la pantalla en su parte posterior.

- Es la forma que utilizaremos.

- Además es conveniente que tenga las direcciones A0, A1 y A2 como he marcado en el dibujo, para más adelante poder estudiar más a fondo el bus I2C.

- Tiene un potenciómetro para ajustar el brillo de pantalla.

- Atención, cuidado con la dirección, en la mayoría de los tutoriales encontrarás que la dirección por defecto es 0x27, pero en algunos modelos no tienen esa dirección, tienen la 0x3F.

#include <Wire.h>

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

  // Leonardo: wait for serial port to connect
  while (!Serial)
    {
    }

  Serial.println ();
  Serial.println ("I2C scanner. Scanning ...");
  byte count = 0;
 
  Wire.begin();
  for (byte i = 1; i < 120; i++)
  {
    Wire.beginTransmission (i);
    if (Wire.endTransmission () == 0)
      {
      Serial.print ("Found address: ");
      Serial.print (i, DEC);
      Serial.print (" (0x");
      Serial.print (i, HEX);
      Serial.println (")");
      count++;
      delay (1);  // maybe unneeded?
      } // end of good response
  } // end of for loop
  Serial.println ("Done.");
  Serial.print ("Found ");
  Serial.print (count, DEC);
  Serial.println (" device(s).");
}  // end of setup

void loop() {}

#include <Wire.h>  
#include <LiquidCrystal_I2C.h>

// LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);

void setup() 
{
  Serial.begin(9600); 
  lcd.begin(16,2);   // 2 filas y 16 columnas

// Parpaea tres veces
  for(int i = 0; i< 3; i++)
  {
    lcd.backlight();
    delay(250);
    lcd.noBacklight();
    delay(250);
  }
  lcd.backlight(); 


  lcd.setCursor(0,0); 
  lcd.print(" Hola a todos.");
  delay(1000);
  lcd.setCursor(0,1);
  lcd.print("  KIO4.COM");
  delay(8000);  

  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print("Escribe en el");
  lcd.setCursor(0,1);
  lcd.print("Serial Monitor");  


}

void loop() 
{
  {
    // Si hay caracteres disponibles...
    if (Serial.available()) {
      delay(100);
      lcd.clear();
      while (Serial.available() > 0) {
        lcd.write(Serial.read());
    }
   }
  }

}

#include <Wire.h>  
#include <LiquidCrystal_I2C.h>

// LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);

void setup() 
{
Serial.begin(9600); 
lcd.begin(16,2); // 2 filas y 16 columnas
}

void loop() 
{
for(int i = 0; i< 16; i++)
{
lcd.setCursor(i,0); 
lcd.print("Hola a todos.");
delay(500);
lcd.clear();
} 
}

#include <Wire.h>  
#include <LiquidCrystal_I2C.h>

// LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);

void setup() 
{
Serial.begin(9600); 
lcd.begin(16,2); // 2 filas y 16 columnas
lcd.setCursor(0,0); 
lcd.print("Hola a todos");
lcd.setCursor(2,1); 
lcd.print("KIO4.COM");
}


void loop() {
// scroll 13 positions (string length) to the left 
// to move it offscreen left:
for (int positionCounter = 0; positionCounter < 13; positionCounter++) {
// scroll one position left:
lcd.scrollDisplayLeft(); 
// wait a bit:
delay(150);
}

// scroll 29 positions (string length + display length) to the right
// to move it offscreen right:
for (int positionCounter = 0; positionCounter < 29; positionCounter++) {
// scroll one position right:
lcd.scrollDisplayRight(); 
// wait a bit:
delay(150);
}

// scroll 16 positions (display length + string length) to the left
// to move it back to center:
for (int positionCounter = 0; positionCounter < 16; positionCounter++) {
// scroll one position left:
lcd.scrollDisplayLeft(); 
// wait a bit:
delay(150);
}

// delay at the end of the full loop:
delay(1000);

}

#include <Wire.h>  
#include <LiquidCrystal_I2C.h>

// LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
void setup() {
// set up the LCD's number of columns and rows: 
lcd.begin(16,2);
}

void loop() {
// set the cursor to (0,0):
lcd.setCursor(0, 0);
// print from 0 to 9:
for (int thisChar = 0; thisChar < 10; thisChar++) {
lcd.print(thisChar);
delay(500);
}

// set the cursor to (16,1):
lcd.setCursor(16,1);
// set the display to automatically scroll:
lcd.autoscroll();
// print from 0 to 9:
for (int thisChar = 0; thisChar < 10; thisChar++) {
lcd.print(thisChar);
delay(500);
}
// turn off automatic scrolling
lcd.noAutoscroll();

// clear screen for the next loop:
lcd.clear();
}

// http://forum.arduino.cc/index.php?topic=263627.0
// Adaptado por Juan Antonio Villalpando.
// KIO4.COM
#include <Wire.h>  
#include <LiquidCrystal_I2C.h>
#define N_CHARS  ((sizeof(MessageOut)/sizeof(MessageOut[0]))-1)
#define N_CHARS2  ((sizeof(MessageOut2)/sizeof(MessageOut2[0]))-1)
// LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);

char MessageOut[21];
char MessageOut2[35];

int index = 19, index2 = 0;
unsigned long oldTime = 0, oldTime2 = 0;

void setup()
{
lcd.clear();
lcd.begin(16,2); // 2 filas y 16 columnas
}

void loop() 
{
setHeadingRight("Hola amigos.", 0, 1000); // message, row, duration
setHeadingLeft("Bienvenidos a la web de KIO4.COM ", 1, 500);
}

void setHeadingRight(char * msg, byte row, unsigned long duration) 
{
strncpy(MessageOut, msg, sizeof(MessageOut));
if(millis() - oldTime > duration) // Duración.
{
oldTime = millis(); // update oldTime with the current time
if(index >= 0) // make sure the index does not go under 0
{ 
index--; // decrecment index by 1
for (int i = 0; i < N_CHARS; i++) // this part here displays the message on the display
{
lcd.setCursor(i,row); // set the column to show the element in the array
if(index == N_CHARS) index = 0; // set index back to 0 if the index has reached the arrays max size.

if(MessageOut[index++] != NULL) // if the element @ index is anything but NULL, show it.
lcd.print(MessageOut[index-1]);
else 
lcd.print(' '); // if the element @ index is NULL, display a space. 
}
}
else index = 19; // if index is less than 0, then set it back to 19
}
}

void setHeadingLeft(char * msg, byte row, unsigned long duration2) 
{
strncpy(MessageOut2, msg, sizeof(MessageOut2));
if(millis() - oldTime2 > duration2)
{
oldTime2 = millis();
if(index2 < 34) // check to see if index2 is under the array max size
{
index2++; // increment index
for (int i = 0; i < N_CHARS2; i++) // same as above
{
lcd.setCursor(i,row);
if(index2 == N_CHARS2) index2 = 0;

if(MessageOut2[index2++] != NULL)
lcd.print(MessageOut2[index2-1]);
else 
lcd.print(' '); 
}
}
else index2 = 0; // otherwise set it back to 0
}
}

// Juan Antonio Villalpando
// kio4.com

#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); 
int entrada = A2; // Centro del potenciómetro a ANALOG IN A2
int x;
 
void setup()
{
  lcd.begin(16,2);
  lcd.home ();
  lcd.print("  KIO4.COM  ");
  delay(1500);
}
 
void loop()
{
  int valor = analogRead(entrada);
  x = map(valor, 0, 1023,0,100);
  lcd.setCursor(0, 1);
  lcd.print("V= "); lcd.print(valor); lcd.print("   X= ");lcd.print(x);
  lcd.print("                  ");
  delay (200);
}

Atención, muchas LCD tienen estas direcciones (la de defecto 0x27), pero otras no. Instala el programa que verás más abajo para ver la dirección de tu pantalla.

______________________________

Para que el Arduino distinga a cada una de las tres pantallas, cada una debe tener una dirección distinta.

Aquí vemos el módulo de control I2C:

Según cortocircuitemos la pareja de conexión de cada A, así se le asignará una dirección.

La dirección por defecto es la 0x27 corresponde a la configuración de la foto.

0x27

Las direcciones se configuran
mediante uniones en: A0, A1 y A2

Hay fabricantes que utilizan para el módulo I2C el chip PCF8574, este viene con la dirección base: 0x20, por lo cual cuando no tiene ningún puente tendrá la dirección 0x27

Las direcciones se configuran mediante uniones en: A0, A1 y A2

Otros fabricantes utilizan para el módulo I2C el chip PCF8574A, este viene con la dirección base: 0x38, por lo cual cuando no tiene ningún puente tendrá la dirección 0x3F

#include <Wire.h> 
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd1(0x3F,16,2); // Dirección de una pantalla
LiquidCrystal_I2C lcd2(0x3E,16,2); // Dirección de otra pantalla
LiquidCrystal_I2C lcd3(0x3D,16,2); // Dirección de otra pantalla

void setup()
{
lcd1.init();
lcd2.init();
lcd3.init();


lcd1.backlight();
lcd1.print("Pantalla 1");


lcd2.backlight();
lcd2.print("Pantalla 2");

lcd3.backlight();
lcd3.print("Pantalla 3");

}

void loop()
{
}

// https://www.hackster.io/pravynandas/lcd-1602-scroll-text-line-1-static-line-2-scrolling-a25546
#include <Wire.h>                 
#include <LiquidCrystal_I2C.h>    
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
// LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);


char * messagePadded = "                Twinkle Twinkle Little star how I wonder what you are, up above the world so high, like a diamond in the sky.                ";

void setup()
{
  lcd.begin (16, 2);
  lcd.setCursor(3, 0);
  lcd.print("Sing Along");
}

void loop()
{
  for (int letter = 0; letter <= strlen(messagePadded) - 16; letter++) //From 0 to upto n-16 characters supply to below function
  {
    showLetters(0, letter);
  }
}

void showLetters(int printStart, int startLetter)
{
  lcd.setCursor(printStart, 1);
  for (int letter = startLetter; letter <= startLetter + 15; letter++) // Print only 16 chars in Line #2 starting 'startLetter'
  {
    lcd.print(messagePadded[letter]);
  }
  lcd.print(" ");
  delay(250);
}

// https://arduino.stackexchange.com/questions/3959/scroll-string-only-on-second-line-using-2x16-lcd
#include <Wire.h>                 
#include <LiquidCrystal_I2C.h>    
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
// LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);

String line1;
String line2;

int stringStart, stringStop = 0;
int scrollCursor = screenWidth;

String CompleteString;
String stringArray[] = {"s=Plane", "i=Car", "h=Boat", "u=Rocket", "d=Jet",  "p=Submarine", "l=Truck", "b=Bicycle", "m=Skate", "enter=Train"};

String string1 = "String";
int countMovement=0;
int arraylimit = 9;

void setup() {
   lcd.begin(16,2);// Columnas y filas de LCD    
   Serial.begin(9600);
}

void loop(){
   char ser = Serial.read();

   if ( ser == 'c' ) {  
     CompleteString="";

     for (int i = 0 ; i <= arraylimit; i++) {
        CompleteString += stringArray[i] + " "; // Convert String Array To Single String
     }

     roop(string1,CompleteString);
  }

}

void roop(String line1, String line2) {

  countMovement = 0;
  stringStart = 0;
  stringStop = 0;
  scrollCursor = screenWidth;

  while ((countMovement) < (line2.length() + screenWidth )) {

     lcd.clear();
     lcd.setCursor(scrollCursor, 1);
     lcd.print(line2.substring(stringStart,stringStop));
     lcd.setCursor(4, 0); // 1 = word eat array of words very cool
     lcd.print(line1);
     delay(300);

     if(stringStart == 0 && scrollCursor > 0){
        // Serial.println(scrollCursor);     
        scrollCursor--;
        stringStop++;
     } else if (stringStart == stringStop){
        stringStart = stringStop = 0;
        scrollCursor = screenWidth;
     } else if (stringStop == line1.length() && scrollCursor == 0) {
        stringStart++;
     } else {
       stringStart++;
       stringStop++;
     }

     countMovement++;
  }

  lcd.setCursor(4, 0);
  lcd.print(line1);
}		
			 

// https://www.instructables.com/id/Scroll-a-Single-LCD-Line-In-How-to/
#include <Wire.h>                 
#include <LiquidCrystal_I2C.h>    
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
// LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
int i = 0;
int j = 0;
int k = 0;
int delayTime2 = 350; // Delay between shifts

void scrollInFromRight (int line, char str1[]) {
// Written by R. Jordan Kreindler June 2016

i = strlen(str1);
for (j = 16; j >= 0; j--) {
    lcd.setCursor(0, line);
      for (k = 0; k <= 15; k++) {
      lcd.print(" "); // Clear line
      }
    
    lcd.setCursor(j, line);
    lcd.print(str1);
    delay(delayTime2);
   }
}



void scrollInFromLeft (int line, char str1[]) {
// Written by R. Jordan Kreindler June 2016

i = 40 - strlen(str1);
line = line - 1;
for (j = i; j <= i + 16; j++) {
for (k = 0; k <= 15; k++) {
lcd.print(" "); // Clear line
}

lcd.setCursor(j, line);
lcd.print(str1);
delay(delayTime2);
}
}



void setup() {
Serial.begin(9600);
Serial.println("Starting test ...");
lcd.begin(16, 2);
lcd.clear();
lcd.print("Test Only");
}

void loop() {
lcd.clear();
scrollInFromRight(0, "Line1 From Right");
scrollInFromRight(1, "Line2 From Right");
lcd.clear();
scrollInFromLeft(0, "Line1 From Left.");
scrollInFromLeft(1, "Line2 From Left.");
lcd.clear();
scrollInFromRight(0, "Line1 From Right");
scrollInFromLeft(1, "Line2 From Left.");
lcd.clear();
}

// https://awsh.org/2017/08/09/scrolling-one-line-on-a-16x2-lcd/
#include <Wire.h>                 
#include <LiquidCrystal_I2C.h>    
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
// LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);


char line2[17] = "                 "; // initialize line2 (16 characters plus 1 null terminator)
 
void setup() {
   lcd.begin(16, 2); //initialize lcd
}
 
void loop(){
     char str[] = "This is a scrolling string."; // string to scroll
     for (int i = 0 ; i <= sizeof(str); i++) { // loop through the string
        update_lcd_buffer(str[i]); // update lcd with each character 
        delay(500);
     }
}
 
void update_lcd_buffer(char c) {
  char *buffer = &line2[1]; // create pointer to the second character of line2
  strncpy(line2, buffer, 16); // set line2 = the second character of line2 to the end 
  line2[15] = c; // append our new char to end of line2
  lcd.clear(); // clear the screen
  lcd.setCursor(0, 0); // set cursor to beginning of first line
  lcd.print("Static string.");  // print the static string on the first line
  lcd.setCursor(0, 1); // set cursor to beginning of second line
  lcd.print(line2); // print line2
}