## LCDs

- [Autoscroll](#autoscroll)
- [Caracter Personalizado](#caracter-personalizado)
- [Contador loops](#contador-loops)
- [i2c](#i2c)
  - [I2C Scan](#i2c-scan)
  - [I2C 20x4](#i2c-20x4)
- [Metodo de 8 bits](#metodo-8-bits)
- [Texto en Movimiento](#texto-en-movimiento)

----

### Autoscroll
***LiquidCrystal Library***

Demonstrates the use a **16x2 LCD display**. The LiquidCrystal  
library works with all LCD displays that are compatible with the  
Hitachi HD44780 driver. There are many of them out there, and you  
can usually tell them by the 16-pin interface.  

This sketch demonstrates the use of the autoscroll() and  
noAutoscroll() functions to make new text scroll or not.  

#### Circuito
| LCD | Arduino |
|-|-|
|`RS`|`12`|
|`LCD Enable`|`11`|
|`D4`|`9`|
|`D5`|`8`|
|`D6`|`7`|
|`D7`|`6`|
|`R/W`| `ground`|

**10K resistor**:
 * ends to `+5V` and `ground`
 * wiper to `LCD VO` pin (pin `3`)

This [example](http://arduino.cc/en/Tutorial/LiquidCrystalAutoscroll) code is in the public domain. 

```c
// include the library code:
#include <LiquidCrystal.h>

// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(12, 11, 9, 8, 7, 6);

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);
    for (int thisChar = 'a'; thisChar < 'q'; thisChar++) {
        lcd.print((char)thisChar);
        delay(100);
    }
    lcd.setCursor(16, 1);
    lcd.autoscroll();
    for (int thisChar1 = 0; thisChar1 < 13; thisChar1++) {
        lcd.print(thisChar1);
        delay(100);
    }
    delay(1000);
    lcd.noAutoscroll();
    lcd.clear();
}
```
[autoscroll.ino](./autoscroll/autoscroll.ino)

----

## Caracter Personalizado
***LiquidCrystal Library - Custom Characters***

#### Circuito
| LCD | Arduino |
|-|-|
|`RS`|`12`|
|`LCD Enable`|`11`|
|`D4`|`5`|
|`D5`|`4`|
|`D6`|`3`|
|`D7`|`2`|
|`R/W`| `ground`|


**10K resistor poterntiometer** on `A0`  
- ends to `+5V` and `ground`
- wiper to `LCD VO` pin (pin `3`)
    
```c
#include <LiquidCrystal.h>

// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(12, 11, 9, 8, 7, 6);

// make some custom characters:
byte heart[8] = { 0b00000, 0b01010, 0b11111, 0b11111,
                  0b11111, 0b01110, 0b00100, 0b00000};

byte smiley[8] = { 0b00000, 0b00000, 0b01010, 0b00000,
                   0b00000, 0b10001, 0b01110, 0b00000};

byte frownie[8] = { 0b00000, 0b00000, 0b01010, 0b00000,
                    0b00000, 0b00000, 0b01110, 0b10001};

byte armsDown[8] = { 0b00100, 0b01010, 0b00100, 0b00100,
                     0b01110, 0b10101, 0b00100, 0b01010};

byte armsUp[8] = { 0b00100, 0b01010, 0b00100, 0b10101,
                   0b01110, 0b00100, 0b00100, 0b01010};

void setup() {
    // initialize LCD and set up the number of columns and rows: 
    lcd.begin(16, 2);
    // create a new characters
    lcd.createChar(0, heart);
    lcd.createChar(1, smiley);
    lcd.createChar(2, frownie);
    lcd.createChar(3, armsDown);
    lcd.createChar(4, armsUp);
    lcd.setCursor(0, 0);
    // Print a message to the lcd.
    lcd.print("I "); 
    // when calling lcd.write() '0' must be cast as a byte
    lcd.write(byte(0)); 
    lcd.print(" Arduino! ");
    lcd.write((byte) 1);
}

void loop() {
    // read the potentiometer on A0:
    int sensorReading = analogRead(A0);
    // map the result to 200 - 1000:
    int delayTime = map(sensorReading, 0, 1023, 200, 1000);
    // set the cursor to the bottom row, 5th position:
    lcd.setCursor(4, 1);
    // draw the little man, arms down:
    lcd.write(3);
    delay(delayTime);
    lcd.setCursor(4, 1);
    // draw him arms up:
    lcd.write(4);
    delay(delayTime);
}
```

[caracter_personalizado.ino](./caracter_personalizado/caracter_personalizado.ino)

----

## Contador Loops

#### Circuito
| LCD | Arduino |
|-|-|
|`RS`|`12`|
|`LCD Enable`|`11`|
|`D4`|`9`|
|`D5`|`8`|
|`D6`|`7`|
|`D7`|`6`|
|`R/W`| `ground`|

**10K resistor**:
 * ends to `+5V` and `ground`
 * wiper to `LCD VO` pin (pin `3`)

```c
#include <LiquidCrystal.h>

// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(12, 11, 9, 8, 7, 6);
int var;
int var2;
int var3;
int contl;

void setup() {
    // set up the LCD's number of columns and rows:
    lcd.begin(16, 2);
    var = 0;
    var2 = 0;
    var3 = 0;
    contl = 0;
}

void loop() {
    lcd.setCursor(0, 0);
    lcd.print("Contador x10: "+ (String)var);
    lcd.setCursor(0, 1);
    var2 += 1;
    var3 += 1;
    lcd.print("====  "+(String)var2+"  ====");
    if (var3 == 10) {
        var3 = 0;
        var += 1;
        lcd.setCursor(0, 0);
        lcd.print("Contador x10: "+ (String)var);
    }
    delay(100);
    if (var > 99) {
        contl += 1;
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("Se han contado :");
        lcd.setCursor(0, 1);
        lcd.print("*  "+(String)contl+"000 loops  *");
        delay(5000);
        lcd.clear();
        var = 0;
        var2 = 0;
        if (contl == 10) {
            lcd.clear();
            lcd.setCursor(0, 0);
            lcd.print("...ya van 10000 ");
            lcd.setCursor(0, 1);
            lcd.print("fue suficiente!!");
            delay(6000);
            lcd.clear();
            setup();
        }
    }
}
```
[contador_loops.ino](./contador_loops/contador_loops.ino)

----

## I2C

### I2C Scanner

> This sketch tests the standard 7-bit addresses  
> Devices with higher bit address might not be seen properly.

```c
#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
}
```
[i2c_scanner.ino](./i2c/i2c_scan/i2c_scan.ino)

----

### I2C 20x4

Conexión chip I2C y Arduino
|I2C|Arduino|
|-|-|
|`VCC`|`+5V`|
|`GND`|`GND`| 
|`SDA`|`A4 `|
|`SCL`|`A5 `|

```c
#include <LiquidCrystal_I2C.h>

// Set the LCD I2C address [0x27 o 0x3F]
// Pins chip I2C a LCD(addr,en,rw,rs,d4,d5,d6,d7,BackLight, BLstatus) 
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);

void setup() {
    //pinMode(BACKLIGHT_PIN, OUTPUT );
    lcd.begin(20,4);               // initialize the lcd 
    //digitalWrite(BACKLIGHT_PIN, HIGH );
}

void loop() {
    lcd.clear();
    lcd.home();//
    lcd.print("Sainsmart docs????");  
    delay(1000);
    lcd.setCursor(0, 1);// go to the next line
    lcd.print("just Googleit");
    delay(1000);
    lcd.setCursor(0, 2);// next line
    lcd.print("    funciona !!!!");
    delay(500);
    lcd.setCursor(0, 3);
    lcd.print("        XD!      ");
    delay(1000);
    lcd.clear();
}
```

[i2c_20x4.ino](./i2c/i2c_20x4/i2c_20x4.ino)

----

### Metodo 8 bits

```c
int DI = 12;
int RW = 11;
int DB[] = {3, 4, 5, 6, 7, 8, 9, 10};// use array to select pin for bus
int Enable = 2;

void LcdCommandWrite(int value) {
    int i = 0;
    // assign value for bus
    for (i=DB[0]; i <= DI; i++) {
        // for 1602 LCD, it uses D7-D0( not D0-D7) for signal identification;
        // here, it’s used for signal inversion. 
        digitalWrite(i,value & 01);
        value >>= 1;
    }
    digitalWrite(Enable,LOW);
    delayMicroseconds(1);
    digitalWrite(Enable,HIGH);
    delayMicroseconds(1);  // wait for 1ms
    digitalWrite(Enable,LOW);
    delayMicroseconds(1);  // wait for 1ms
}

void LcdDataWrite(int value) {
    // initialize all pins
    int i = 0;
    digitalWrite(DI, HIGH);
    digitalWrite(RW, LOW);
    for (i=DB[0]; i <= DB[7]; i++) {
        digitalWrite(i,value & 01);
        value >>= 1;
    }
    digitalWrite(Enable,LOW);
    delayMicroseconds(1);
    digitalWrite(Enable,HIGH);
    delayMicroseconds(1);
    digitalWrite(Enable,LOW);
    delayMicroseconds(1);  // wait for 1ms
}

void setup (void) {
    int i = 0;
    for (i=Enable; i <= DI; i++) {
        pinMode(i,OUTPUT);
    }
    delay(100);
    // initialize LCD after a brief pause for LCD control
    LcdCommandWrite(0x38);  // select as 8-bit interface, 2-line display, 5x7 character size 
    delay(64);                      
    LcdCommandWrite(0x38);  // select as 8-bit interface, 2-line display, 5x7 character size 
    delay(50);                      
    LcdCommandWrite(0x38);  // select as 8-bit interface, 2-line display, 5x7 character size             
    delay(20);                      
    LcdCommandWrite(0x06);  // set input mode
                            // auto-increment, no display of shifting
    delay(20);                      
    LcdCommandWrite(0x0E);  // display setup
                            // turn on the monitor, cursor on, no flickering
    delay(20);                      
    LcdCommandWrite(0x01);  // clear the scree, cursor position returns to 0
    delay(100);                      
    LcdCommandWrite(0x80);  //  display setup
                            //  turn on the monitor, cursor on, no flickering
    delay(20);                      
}

void loop (void) {
    LcdCommandWrite(0x01);  // clear the scree, cursor position returns to 0  
    delay(10); 
    LcdCommandWrite(0x80+3); 
    delay(10);                     
    // write in welcome message 
    LcdDataWrite('F');
    delay(50);
    LcdDataWrite('u');
    delay(50);
    LcdDataWrite('z');
    delay(50);
    LcdDataWrite('a');
    delay(50);
    LcdDataWrite('n');
    delay(50);
    LcdDataWrite(' ');
    delay(50);
    LcdDataWrite('T');
    delay(50);
    LcdDataWrite('o');
    delay(50);
    LcdDataWrite('k');
    delay(50);
    LcdDataWrite('o');
    delay(50);
    LcdCommandWrite(0xc0+0);  // set cursor position at second line, second position
    delay(10); 
    LcdDataWrite('*');
    LcdDataWrite('*');delay(70);
    LcdDataWrite('A');delay(90);
    LcdDataWrite('R');delay(110);
    LcdDataWrite('D');delay(130);
    LcdDataWrite('U');delay(150);
    LcdDataWrite('I');delay(170);
    LcdDataWrite('N');delay(200);
    LcdDataWrite('O');delay(170);
    LcdDataWrite('-');delay(150);
    LcdDataWrite('L');delay(130);
    LcdDataWrite('E');delay(110);
    LcdDataWrite('A');delay(90);
    LcdDataWrite('R');delay(70);
    LcdDataWrite('N');delay(70);
    LcdDataWrite('*');
    LcdDataWrite('*');
    delay(3000);
    LcdCommandWrite(0x01);  // clear the screen, cursor returns to 0  
    delay(10);
    LcdDataWrite('A');
    LcdDataWrite('p');
    LcdDataWrite('r');
    LcdDataWrite('e');
    LcdDataWrite('n');
    LcdDataWrite('d');
    LcdDataWrite('e');
    LcdDataWrite(' ');
    LcdDataWrite(' ');
    LcdDataWrite('c');
    LcdDataWrite('r');
    LcdDataWrite('e');
    LcdDataWrite('a');
    LcdDataWrite(' ');
    LcdDataWrite(' ');
    LcdCommandWrite(0xc0);
    delay(2000);
    // set mode as new characters replay old ones,
    // where there is no new ones remain the same
    LcdCommandWrite(0xc02); 
    delay(10);
    // set cursor position at first line, sixth position
    LcdCommandWrite(0xc80+6);
    delay(10);  
    LcdDataWrite('o');
    LcdDataWrite('p');
    LcdDataWrite('e');
    LcdDataWrite('n');
    LcdDataWrite(' ');
    LcdDataWrite('s');
    delay(3000);
}
```
[metodo_8bits.ino](./metodo_8bits/metodo_8bits.ino)

----

### Texto en movimiento

***LiquidCrystal Library - display() and noDisplay()***

#### Circuito
| LCD | Arduino |
|-|-|
|`RS`|`12`|
|`LCD Enable`|`11`|
|`D4`|`9`|
|`D5`|`8`|
|`D6`|`7`|
|`D7`|`6`|
|`R/W`| `ground`|

**10K resistor**:
 * ends to `+5V` and `ground`
 * wiper to `LCD VO` pin (pin `3`)

> This sketch  uses the **display()** and **noDisplay()** functions 
> to turn **on** and **off** the display.

```c
#include <LiquidCrystal.h>

// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(12, 11, 9, 8, 7, 6);
byte fil;
byte col;
byte cont;

void setup() {
    lcd.begin(16, 2);
    fil = 0;
    col = 0;
    cont = 0;
}

void loop() {
    for (int i=0; i<8; i++) {
        lcd.clear();
        lcd.setCursor(col++ , fil);
        lcd.print("FuzanToko");
        lcd.noDisplay();
        delay(100);
        lcd.display();
        delay(300);
    }
    fil += 1;
    col = 7;
    for (int j=0; j<8; j++) {
        lcd.clear();
        lcd.setCursor(col-- , fil);
        lcd.print("FuzanToko");
        lcd.noDisplay();
        delay(100);
        lcd.display();
        delay(300);
    }
    setup();
}
```

[texto_en_movimiento](./texto_en_movimiento/texto_en_movimiento.ino)