ARDUINO GENUINO
I'm soo excited working with the ultimate cool hardware ARDUINO GENUINO!!!
C:\Users\admin\Desktop\arduino\2018-07-29 12_33_48-Elegoo Super Starter Kit para UNO V1.0 2017.7.10.pdf (PROTEGIDO) - Adobe Acrobat.png
/*
Blink
Turns an LED on for one second, then off for one second, repeatedly.
Most Arduinos have an on-board LED you can control. On the UNO, MEGA and ZERO
it is attached to digital pin 13, on MKR1000 on pin 6. LED_BUILTIN is set to
the correct LED pin independent of which board is used.
If you want to know what pin the on-board LED is connected to on your Arduino
model, check the Technical Specs of your board at:
https://www.arduino.cc/en/Main/Products
modified 8 May 2014
by Scott Fitzgerald
modified 2 Sep 2016
by Arturo Guadalupi
modified 8 Sep 2016
by Colby Newman
This example code is in the public domain.
Un poco de historia:
What is Arduino?
Arduino is an open-source electronics platform based on easy-to-use hardware and software. Arduino boards are able to read inputs - light on a sensor, a finger on a button, or a Twitter message - and turn it into an output - activating a motor, turning on an LED, publishing something online. You can tell your board what to do by sending a set of instructions to the microcontroller on the board. To do so you use the Arduino programming language (based on Wiring), and the Arduino Software (IDE), based on Processing.
Over the years Arduino has been the brain of thousands of projects, from everyday objects to complex scientific instruments. A worldwide community of makers - students, hobbyists, artists, programmers, and professionals - has gathered around this open-source platform, their contributions have added up to an incredible amount of accessible knowledge that can be of great help to novices and experts alike.
Arduino was born at the Ivrea Interaction Design Institute as an easy tool for fast prototyping, aimed at students without a background in electronics and programming. As soon as it reached a wider community, the Arduino board started changing to adapt to new needs and challenges, differentiating its offer from simple 8-bit boards to products for IoT applications, wearable, 3D printing, and embedded environments. All Arduino boards are completely open-source, empowering users to build them independently and eventually adapt them to their particular needs. The software, too, is open-source, and it is growing through the contributions of users worldwide.
Historial[editar]
De forma estricta, el proyecto «Arduino» se inició en el año 2005 como un proyecto enfocado a estudiantes en el Instituto IVREA (IDII), en Ivrea (Italia).2 En aquellos años, los estudiantes usaban el microcontrolador BASIC Stamp, cuyo costo era de $100USD, un costo considerablemente alto para un estudiante promedio. Antes del año 2005, específicamente durante el año 2003, Hernando Barragán había creado la plataforma de desarrollo Wiring como resultado de su proyecto de tesis en la maestría en el IDII, bajo la supervisión de Massimo Banzi y Casey Reas, quienes eran conocidos por haber trabajado en el lenguaje Processing y daban clases en el IDII2. El objetivo del proyecto era crear herramientas simples y de bajo costo para la creación de proyectos digitales por parte de personas sin altos conocimientos técnicos o sin un perfil de ingeniería. El proyecto Wiring era una placa de desarrollo de hardware la cual consistía de una placa de circuito impreso (PCB) con un microcontrolador ATmega168, un Ambiente de Desarrollo Integrado (IDE) basado en funciones de procesamiento y una biblioteca de funciones para programar fácilmente el microcontrolador.6 Regresando al año 2005, Massimo Banzi junto con David Mellis, quien era otro estudiante del IDII, y David Cuartielles, agregaron soporte a Wiring para el microcontrolador ATmega8 el cual era más económico al de un principio (Atmega168). Pero en lugar de continuar el desarrollo en Wiring, se separaron del proyecto y lo renombraron Arduino.6
El nombre Arduino viene de un un bar en Ivrea, Italia; en donde algunos de los fundadores del proyecto Arduino solían reunirse. El bar tiene el nombre de " Bar di Re Arduino", y fue nombrado en honor a Arduino de Ivrea, quien fue el margrave de la Marcha de Ivrea y Rey de Italia desde el año 1002 hasta el año 1014.4
El equipo inicial de Arduino estaba conformado por Massimo Banzi, David Cuartielles, Tom Igoe, Gianluca Martino y David Mellis. Hernando Barragán no fue invitado a participar.6
Posteriormente el proyecto Wiring siguió adelante, placas menos densas y menos costosas se distribuyeron con la comunidad de código abierto.7
Adafruit Industries, un proveedor de componentes electrónicos y fabricante de placas de circuito empreso, entre ellas placas Arduino, ubicado en la ciudad de Nueva York, estimó a mediados del año 2011 que más de 300,000 placas Arduino oficiales habían sido producidos comercialmente.8 En el año 2013, estimó que 700,000 placas Arduino oficiales se encontraban en manos de usuarios.9
En octubre del año 2016, Federico Musto (actualmente ex CEO de Arduino), adquirió el 50% de la compañía luego de haber adquirido las acciones de uno de los miembros fundadores del equipo. En abril del año 2017, la revista Wired informó que Musto había "fabricado su propio expediente académico", habiéndolo publicado en el sitio web de Arduino, cuenta personal de LinkedIn, e incluso en documentos comerciales oficiales italianos. Musto afirmaba tener un PhD en ciencias de la computación por el Instituto Tecnológico de Massachusetts (MIT), y un MBA de la Universidad de Nueva York. La revista Wired reportó que ninguna de las universidades que él afirmaba haber cursado tenía registro alguno de la asistencia de Musto. Musto más tarde afirmó, en una entrevista a Wired, que realmente nunca había obtenido los grados académicos.10
En el año 2017, Massimo Banzi anunció la creación de la «Fundación Arduino», declarando que sería «un nuevo comienzo para Arduino». Dicha fundación según palabras del mismo Banzi «permitirá defender los valores fundamentales de la Comunidad Arduino dentro del ecosistema de código abierto y hacer que nuestro compromiso ( haciendo referencia a la empresa Arduini) con el código abierto sea más sólido que nunca».11 Sin embargo ha existido cierta incertidumbre del desarrollo actual de dicha iniciativa.12
La controversia en torno a Federico Musto continuó en julio del año 2017, según los informes, por haber retirado licencias de código abierto, esquemas y códigos del sitio web de Arduino, lo que provocó escrutinio y protesta por parte de la comunidad de maker.13
En octubre del año 2017, Arduino anunció su asociación con la multinacional ARM Holdings (ARM). El anuncio decía, en parte, que "ARM reconoce la independencia como un valor central de Arduino... sin ningún acuerdo de uso exclusivo con la arquitectura ARM". Arduino tiene la intención de seguir trabajando con todos los proveedores y arquitecturas de tecnología.14
Para la producción en serie de la primera versión se tomó en cuenta que el coste no fuera mayor de 30 euros, que fuera ensamblado en una placa de color azul, debía ser Plug and Play y que trabajara con todas las plataformas informáticas tales como MacOSX, Windows y GNU/Linux. Las primeras 300 unidades se las dieron a los alumnos del Instituto IVREA, con el fin de que las probaran y empezaran a diseñar sus primeros prototipos.[cita requerida]
Disputa por la marca Arduino[editar]
A principios de 2008, los cinco cofundadores del proyecto Arduino crearon la empresa Arduino LLC, cuyo propósito era englobar las marcas comerciales asociadas a las placas Arduino15. La fabricación y venta de las placas Arduino debía ser hecha por compañías externas, y Arduino LLC obtendría un royalty(comisión), de ellos. Los estatutos bajo los cuales se creó Arduino LLC especificaban que cada uno de los cinco fundadores originales transferirían la propiedad de la marca Arduino a la empresa recién formada (Arduino LLC).[cita requerida]
A finales de 2008, la empresa de Gianluca Martino (Smart Projects), registró la marca Arduino en Italia y mantuvo esto en secreto de los otros co-fundadores durante un periodo aproximado de dos años. Esto fue revelado cuando la compañía Arduino LLC intentó registrar la marca en otras partes del mundo (originalmente ellos se habían registrado solo en EE. UU.), y descubriendo que esta ya estaba registrada en Italia. Las negociaciones con Gianluca y su firma para poner la marca bajo control de la compañía Arduino LLC fallaron. En el año 2014, Smart Projects comenzó a negarse a pagar regalías. Luego nombraron a un nuevo CEO, Federico Musto, que renombró a la empresa Arduino SRL y creó el sitio web arduino.org, copiando los gráficos y el diseño del arduino.cc original. Esto resultó una fractura en el equipo de desarrollo de Arduino.161718
En enero de 2015, Arduino LLC entabló una demanda contra Arduino SRL.19
En mayo de 2015, Arduino LLC creó la marca mundial Genuino, utilizada como marca fuera de los Estados Unidos. 20
En julio de 2017, la nueva compañía BCMI LABS LLC fundada por Massimo Banzi, David Cuartielles, David Mellis y Tom Igoe, adquirió Arduino AG y todas las marcas registradas de Arduino. Fabio Violante se convirtió en el nuevo CEO que reemplazaría a Federico Musto, quien ya no trabajaría para Arduino AG. 21
Durante la "World Maker Faire" en Nueva York del 1 de octubre de 2016, el cofundador y CEO de Arduino LLC (Massimo Banzi) y el CEO de Arduino SRL (Federico Musto), anunciaron la fusión de ambas compañías. 22
Hardware[editar]
Arduino es hardware libre. Los diseños de referencia de hardware se distribuyen bajo licencia Creative Commons Attribution Share-Alike 2.5 y están disponibles en el sitio web de Arduino. Los esquemáticos y archivos de montaje de componentes (PCBs) para algunas versiones de placas también están disponibles.
Aunque los diseños de hardware y software están disponibles bajo licencias de copyleft, los desarrolladores han solicitado que el nombre Arduino sea exclusivo del producto oficial y no se use para trabajos derivados sin antes solicitar permiso. El documento de política oficial sobre el uso del nombre Arduino enfatiza que el proyecto está abierto a incorporar el trabajo de otros en el producto oficial. Varios productos compatibles con Arduino lanzados comercialmente han evitado incluir el nombre del proyecto Arduino en sus dispositivos al emplear nombres que terminan en «-duino».
La mayoría de las placas Arduino constan de un microcontrolador AVR Atmel-8 bits (ATmega8, [25] ATmega168, ATmega328, ATmega1280, ATmega2560), cada microncontrolador consta de diversas cantidades de memoria flash, pines y funciones. Las placas utilizan pines/cabezales hembra de una o dos hileras que facilitan las conexiones e incorporación en otros circuitos.
Las placas Arduino pueden conectarse con módulos adicionales denominados shields (escudos, por su traducción al español), dichos shields aumentan las características técnicas de la placa Arduino en uso, debido a que posen circuitos específicos que añaden una o más funcionalidades extras a la placa Arduino nativa en la cual se utilice, también se les conoce como placas de expansión. La mayoría de estos shields se conectan a través de un bus serie I²C, aunque existen también aquellas que emplean conexión mediante el bus UART (Universal Asynchronous Receiver-Transmitter, por su traducción al español Transmisor-Receptor Asíncrono Universal), así como con el bus SPI (Serial Peripheral Interface, por su traducción al español Interfaz Periférica Serial).
La mayoría de las placas incluyen un regulador lineal de 5 V y un oscilador de cristal de 16 MHz, o un resonador de cerámica según sea el caso. Algunos diseños, como el LilyPad, funcionan a 8 MHz y prescinden del regulador de voltaje a bordo debido a restricciones de factor/tamaño de forma específicas.
Los modelos de Arduino se categorizan en placas de desarrollo, placas de expansión (shields), kits, accesorios e impresoras 3D.
- Placas: Arduino Galileo,23 Arduino Uno, Arduino Leonardo, Arduino Due, Arduino Yún, Arduino Tre (En Desarrollo), Arduino Zero, Arduino Micro, Arduino Esplora, Arduino Mega ADK, Arduino Ethernet, Arduino Mega 2560, Arduino Robot, Arduino Mini, Arduino Nano, LilyPad Arduino Simple, LilyPad Arduino SimpleSnap, LilyPad Arduino, LilyPad Arduino USB, Arduino Pro Mini, Arduino Fio, Arduino Pro, Arduino MKR1000/Genuino MKR1000, Arduino MICRO/Genuino MICRO, Arduino 101/Genuino 101, Arduino Gemma.
- Placas de expansión (shields): Arduino GSM Shield, Arduino Ethernet Shield, Arduino WiFi Shield, Arduino Wireless SD Shield, Arduino USB Host Shield, Arduino Motor Shield, Arduino Wireless Proto Shield, Arduino Proto Shield.
- Kits: The Arduino Starter Kit, Arduino Materia 101.
- Accesorios: Pantalla LCD TFT, Adaptador USB/Serie y MiniUSB/Serie, Arduino ISP.
- Impresoras 3d: Arduino Materia 101.
Equipo de desarrollo[editar]
El núcleo del equipo de desarrollo de Arduino está formado por Massimo Banzi, David Cuartielles, Tom Igoe, Gianluca Martino, David Mellis y Nicholas Zambetti.
Aplicaciones[editar]
La plataforma Arduino ha sido usada como base en diversas aplicaciones electrónicas:
- Xoscillo: Osciloscopio de código abierto24
- Equipo científico para investigaciones25
- Arduinome: Un dispositivo controlador MIDI26
- OBDuino: un económetro que usa una interfaz de diagnóstico a bordo que se halla en los automóviles modernos
- SCA-ino: Sistema de cómputo automotriz capaz de monitorear sensores como el TPS, el MAP y el 02S y controlar actuadores automotrices como la bobina de ignición, la válvula IAC y aceleradores electrónicos
- Humane Reader: dispositivo electrónico de bajo coste con salida de señal de TV que puede manejar una biblioteca de 5000 títulos en una tarjeta microSD27
- The Humane PC: equipo que usa un módulo Arduino para emular un computador personal, con un monitor de televisión y un teclado para computadora28
- Ardupilot: software y hardware de aeronaves no tripuladas
- ArduinoPhone: un teléfono móvil construido sobre un módulo Arduino2930
- Máquinas de control numérico por computadora (CNC)
- Open Theremín Uno: Versión digital de hardware libre del instrumento Theremín
- Impresoras 3D
- Ambilight, sistema de retroiluminación led imitando el sistema de los televisores Philips [cita requerida]
Otras interfaces de programación[editar]
Es posible comunicar una aplicación que corra sobre Arduino con otros dispositivos que corran otros lenguajes de programación y aplicaciones populares,31 debido a que Arduino usa la transmisión serial de datos, la cual es soportada por la mayoría de los lenguajes que se mencionan a continuación. Y para los que no soportan el formato serie de forma nativa, es posible utilizar software intermediario que traduzca los mensajes enviados por ambas partes para permitir una comunicación fluida. Algunos ejemplos de lenguajes son:
- 3DVIA Virtools: aplicaciones interactivas y de tiempo real.
- Adobe Director
- BlitzMax (con acceso restringido).
- C
- C++ (mediante libSerial o en Windows).
- C#
- Cocoa/Objective-C (para Mac OS X).
- Flash (mediante ActionScript).
- Gambas
- Isadora (Interactividad audiovisual en tiempo real).
- Instant Reality (X3D).
- Java
- Liberlab (software de medición y experimentación).
- LabView
- Mathematica
- Matlab
- MaxMSP: Entorno gráfico de programación para aplicaciones musicales, de audio y multimedia.
- Minibloq: Entorno gráfico de programación, corre también en las computadoras OLPC.
- Perl
- Php
- Physical Etoys: Entorno gráfico de programación usado para proyectos de robótica educativa.
- Processing
- Pure Data
- Piton
- Ruby
- Scratch for Arduino (S4A): Entorno gráfico de programación, modificación del entorno para niños Scratch, del MIT.
- Squeak: Implementación libre de Smalltalk.
- SuperCollider: Síntesis de audio en tiempo real.
- VBScript
- Visual Basic .NET
- VVVV: Síntesis de vídeo en tiempo real.
*++++++++++++++
*/
// the setup function runs once when you press reset or power the board
void setup() {
// initialize digital pin LED_BUILTIN as an output.
pinMode(LED_BUILTIN, OUTPUT);
}
// the loop function runs over and over again forever
void loop() {
digitalWrite(LED_BUILTIN, HIGH); // turn the LED on (HIGH is the voltage level)
delay(1000); // wait for a second
digitalWrite(LED_BUILTIN, LOW); // turn the LED off by making the voltage LOW
delay(1000); // wait for a second
}
****************
Subrutine for the LCD screen
//www.elegoo.com
//2016.12.9
/*
LiquidCrystal Library - Hello World
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 prints "Hello World!" to the LCD
and shows the time.
The circuit:
* LCD RS pin to digital pin 7
* LCD Enable pin to digital pin 8
* LCD D4 pin to digital pin 9
* LCD D5 pin to digital pin 10
* LCD D6 pin to digital pin 11
* LCD D7 pin to digital pin 12
* LCD R/W pin to ground
* LCD VSS pin to ground
* LCD VCC pin to 5V
* 10K resistor:
* ends to +5V and ground
* wiper to LCD VO pin (pin 3)
Library originally added 18 Apr 2008
by David A. Mellis
library modified 5 Jul 2009
by Limor Fried (http://www.ladyada.net)
example added 9 Jul 2009
by Tom Igoe
modified 22 Nov 2010
by Tom Igoe
This example code is in the public domain.
http://www.arduino.cc/en/Tutorial/LiquidCrystal
*/
// include the library code:
#include "LiquidCrystal.h"
// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(7, 8, 9, 10, 11, 12);
void setup() {
// set up the LCD's number of columns and rows:
lcd.begin(16, 2);
// Print a message to the LCD.
lcd.print("Roberto Perez eres un chingon!!");
}
void loop() {
// set the cursor to column 0, line 1
// (note: line 1 is the second row, since counting begins with 0):
lcd.setCursor(0, 1);
// print the number of seconds since reset:
lcd.print(millis() / 1000);
}
***********************
#include "LiquidCrystal.h"
#include <stdio.h>
#include <string.h>
#include <inttypes.h>
#include "Arduino.h"
// When the display powers up, it is configured as follows:
//
// 1. Display clear
// 2. Function set:
// DL = 1; 8-bit interface data
// N = 0; 1-line display
// F = 0; 5x8 dot character font
// 3. Display on/off control:
// D = 0; Display off
// C = 0; Cursor off
// B = 0; Blinking off
// 4. Entry mode set:
// I/D = 1; Increment by 1
// S = 0; No shift
//
// Note, however, that resetting the Arduino doesn't reset the LCD, so we
// can't assume that its in that state when a sketch starts (and the
// LiquidCrystal constructor is called).
LiquidCrystal::LiquidCrystal(uint8_t rs, uint8_t rw, uint8_t enable,
uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3,
uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7)
{
init(0, rs, rw, enable, d0, d1, d2, d3, d4, d5, d6, d7);
}
LiquidCrystal::LiquidCrystal(uint8_t rs, uint8_t enable,
uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3,
uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7)
{
init(0, rs, 255, enable, d0, d1, d2, d3, d4, d5, d6, d7);
}
LiquidCrystal::LiquidCrystal(uint8_t rs, uint8_t rw, uint8_t enable,
uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3)
{
init(1, rs, rw, enable, d0, d1, d2, d3, 0, 0, 0, 0);
}
LiquidCrystal::LiquidCrystal(uint8_t rs, uint8_t enable,
uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3)
{
init(1, rs, 255, enable, d0, d1, d2, d3, 0, 0, 0, 0);
}
void LiquidCrystal::init(uint8_t fourbitmode, uint8_t rs, uint8_t rw, uint8_t enable,
uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3,
uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7)
{
_rs_pin = rs;
_rw_pin = rw;
_enable_pin = enable;
_data_pins[0] = d0;
_data_pins[1] = d1;
_data_pins[2] = d2;
_data_pins[3] = d3;
_data_pins[4] = d4;
_data_pins[5] = d5;
_data_pins[6] = d6;
_data_pins[7] = d7;
if (fourbitmode)
_displayfunction = LCD_4BITMODE | LCD_1LINE | LCD_5x8DOTS;
else
_displayfunction = LCD_8BITMODE | LCD_1LINE | LCD_5x8DOTS;
begin(16, 1);
}
void LiquidCrystal::begin(uint8_t cols, uint8_t lines, uint8_t dotsize) {
if (lines > 1) {
_displayfunction |= LCD_2LINE;
}
_numlines = lines;
setRowOffsets(0x00, 0x40, 0x00 + cols, 0x40 + cols);
// for some 1 line displays you can select a 10 pixel high font
if ((dotsize != LCD_5x8DOTS) && (lines == 1)) {
_displayfunction |= LCD_5x10DOTS;
}
pinMode(_rs_pin, OUTPUT);
// we can save 1 pin by not using RW. Indicate by passing 255 instead of pin#
if (_rw_pin != 255) {
pinMode(_rw_pin, OUTPUT);
}
pinMode(_enable_pin, OUTPUT);
// Do these once, instead of every time a character is drawn for speed reasons.
for (int i=0; i<((_displayfunction & LCD_8BITMODE) ? 8 : 4); ++i)
{
pinMode(_data_pins[i], OUTPUT);
}
// SEE PAGE 45/46 FOR INITIALIZATION SPECIFICATION!
// according to datasheet, we need at least 40ms after power rises above 2.7V
// before sending commands. Arduino can turn on way before 4.5V so we'll wait 50
delayMicroseconds(50000);
// Now we pull both RS and R/W low to begin commands
digitalWrite(_rs_pin, LOW);
digitalWrite(_enable_pin, LOW);
if (_rw_pin != 255) {
digitalWrite(_rw_pin, LOW);
}
//put the LCD into 4 bit or 8 bit mode
if (! (_displayfunction & LCD_8BITMODE)) {
// this is according to the hitachi HD44780 datasheet
// figure 24, pg 46
// we start in 8bit mode, try to set 4 bit mode
write4bits(0x03);
delayMicroseconds(4500); // wait min 4.1ms
// second try
write4bits(0x03);
delayMicroseconds(4500); // wait min 4.1ms
// third go!
write4bits(0x03);
delayMicroseconds(150);
// finally, set to 4-bit interface
write4bits(0x02);
} else {
// this is according to the hitachi HD44780 datasheet
// page 45 figure 23
// Send function set command sequence
command(LCD_FUNCTIONSET | _displayfunction);
delayMicroseconds(4500); // wait more than 4.1ms
// second try
command(LCD_FUNCTIONSET | _displayfunction);
delayMicroseconds(150);
// third go
command(LCD_FUNCTIONSET | _displayfunction);
}
// finally, set # lines, font size, etc.
command(LCD_FUNCTIONSET | _displayfunction);
// turn the display on with no cursor or blinking default
_displaycontrol = LCD_DISPLAYON | LCD_CURSOROFF | LCD_BLINKOFF;
display();
// clear it off
clear();
// Initialize to default text direction (for romance languages)
_displaymode = LCD_ENTRYLEFT | LCD_ENTRYSHIFTDECREMENT;
// set the entry mode
command(LCD_ENTRYMODESET | _displaymode);
}
void LiquidCrystal::setRowOffsets(int row0, int row1, int row2, int row3)
{
_row_offsets[0] = row0;
_row_offsets[1] = row1;
_row_offsets[2] = row2;
_row_offsets[3] = row3;
}
/********** high level commands, for the user! */
void LiquidCrystal::clear()
{
command(LCD_CLEARDISPLAY); // clear display, set cursor position to zero
delayMicroseconds(2000); // this command takes a long time!
}
void LiquidCrystal::home()
{
command(LCD_RETURNHOME); // set cursor position to zero
delayMicroseconds(2000); // this command takes a long time!
}
void LiquidCrystal::setCursor(uint8_t col, uint8_t row)
{
const size_t max_lines = sizeof(_row_offsets) / sizeof(*_row_offsets);
if ( row >= max_lines ) {
row = max_lines - 1; // we count rows starting w/0
}
if ( row >= _numlines ) {
row = _numlines - 1; // we count rows starting w/0
}
command(LCD_SETDDRAMADDR | (col + _row_offsets[row]));
}
// Turn the display on/off (quickly)
void LiquidCrystal::noDisplay() {
_displaycontrol &= ~LCD_DISPLAYON;
command(LCD_DISPLAYCONTROL | _displaycontrol);
}
void LiquidCrystal::display() {
_displaycontrol |= LCD_DISPLAYON;
command(LCD_DISPLAYCONTROL | _displaycontrol);
}
// Turns the underline cursor on/off
void LiquidCrystal::noCursor() {
_displaycontrol &= ~LCD_CURSORON;
command(LCD_DISPLAYCONTROL | _displaycontrol);
}
void LiquidCrystal::cursor() {
_displaycontrol |= LCD_CURSORON;
command(LCD_DISPLAYCONTROL | _displaycontrol);
}
// Turn on and off the blinking cursor
void LiquidCrystal::noBlink() {
_displaycontrol &= ~LCD_BLINKON;
command(LCD_DISPLAYCONTROL | _displaycontrol);
}
void LiquidCrystal::blink() {
_displaycontrol |= LCD_BLINKON;
command(LCD_DISPLAYCONTROL | _displaycontrol);
}
// These commands scroll the display without changing the RAM
void LiquidCrystal::scrollDisplayLeft(void) {
command(LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVELEFT);
}
void LiquidCrystal::scrollDisplayRight(void) {
command(LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVERIGHT);
}
// This is for text that flows Left to Right
void LiquidCrystal::leftToRight(void) {
_displaymode |= LCD_ENTRYLEFT;
command(LCD_ENTRYMODESET | _displaymode);
}
// This is for text that flows Right to Left
void LiquidCrystal::rightToLeft(void) {
_displaymode &= ~LCD_ENTRYLEFT;
command(LCD_ENTRYMODESET | _displaymode);
}
// This will 'right justify' text from the cursor
void LiquidCrystal::autoscroll(void) {
_displaymode |= LCD_ENTRYSHIFTINCREMENT;
command(LCD_ENTRYMODESET | _displaymode);
}
// This will 'left justify' text from the cursor
void LiquidCrystal::noAutoscroll(void) {
_displaymode &= ~LCD_ENTRYSHIFTINCREMENT;
command(LCD_ENTRYMODESET | _displaymode);
}
// Allows us to fill the first 8 CGRAM locations
// with custom characters
void LiquidCrystal::createChar(uint8_t location, uint8_t charmap[]) {
location &= 0x7; // we only have 8 locations 0-7
command(LCD_SETCGRAMADDR | (location << 3));
for (int i=0; i<8; i++) {
write(charmap[i]);
}
}
/*********** mid level commands, for sending data/cmds */
inline void LiquidCrystal::command(uint8_t value) {
send(value, LOW);
}
inline size_t LiquidCrystal::write(uint8_t value) {
send(value, HIGH);
return 1; // assume sucess
}
/************ low level data pushing commands **********/
// write either command or data, with automatic 4/8-bit selection
void LiquidCrystal::send(uint8_t value, uint8_t mode) {
digitalWrite(_rs_pin, mode);
// if there is a RW pin indicated, set it low to Write
if (_rw_pin != 255) {
digitalWrite(_rw_pin, LOW);
}
if (_displayfunction & LCD_8BITMODE) {
write8bits(value);
} else {
write4bits(value>>4);
write4bits(value);
}
}
void LiquidCrystal::pulseEnable(void) {
digitalWrite(_enable_pin, LOW);
delayMicroseconds(1);
digitalWrite(_enable_pin, HIGH);
delayMicroseconds(1); // enable pulse must be >450ns
digitalWrite(_enable_pin, LOW);
delayMicroseconds(100); // commands need > 37us to settle
}
void LiquidCrystal::write4bits(uint8_t value) {
for (int i = 0; i < 4; i++) {
digitalWrite(_data_pins[i], (value >> i) & 0x01);
}
pulseEnable();
}
void LiquidCrystal::write8bits(uint8_t value) {
for (int i = 0; i < 8; i++) {
digitalWrite(_data_pins[i], (value >> i) & 0x01);
}
pulseEnable();
}
*******************************
#ifndef LiquidCrystal_h
#define LiquidCrystal_h
#include <inttypes.h>
#include "Print.h"
// commands
#define LCD_CLEARDISPLAY 0x01
#define LCD_RETURNHOME 0x02
#define LCD_ENTRYMODESET 0x04
#define LCD_DISPLAYCONTROL 0x08
#define LCD_CURSORSHIFT 0x10
#define LCD_FUNCTIONSET 0x20
#define LCD_SETCGRAMADDR 0x40
#define LCD_SETDDRAMADDR 0x80
// flags for display entry mode
#define LCD_ENTRYRIGHT 0x00
#define LCD_ENTRYLEFT 0x02
#define LCD_ENTRYSHIFTINCREMENT 0x01
#define LCD_ENTRYSHIFTDECREMENT 0x00
// flags for display on/off control
#define LCD_DISPLAYON 0x04
#define LCD_DISPLAYOFF 0x00
#define LCD_CURSORON 0x02
#define LCD_CURSOROFF 0x00
#define LCD_BLINKON 0x01
#define LCD_BLINKOFF 0x00
// flags for display/cursor shift
#define LCD_DISPLAYMOVE 0x08
#define LCD_CURSORMOVE 0x00
#define LCD_MOVERIGHT 0x04
#define LCD_MOVELEFT 0x00
// flags for function set
#define LCD_8BITMODE 0x10
#define LCD_4BITMODE 0x00
#define LCD_2LINE 0x08
#define LCD_1LINE 0x00
#define LCD_5x10DOTS 0x04
#define LCD_5x8DOTS 0x00
class LiquidCrystal : public Print {
public:
LiquidCrystal(uint8_t rs, uint8_t enable,
uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3,
uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7);
LiquidCrystal(uint8_t rs, uint8_t rw, uint8_t enable,
uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3,
uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7);
LiquidCrystal(uint8_t rs, uint8_t rw, uint8_t enable,
uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3);
LiquidCrystal(uint8_t rs, uint8_t enable,
uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3);
void init(uint8_t fourbitmode, uint8_t rs, uint8_t rw, uint8_t enable,
uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3,
uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7);
void begin(uint8_t cols, uint8_t rows, uint8_t charsize = LCD_5x8DOTS);
void clear();
void home();
void noDisplay();
void display();
void noBlink();
void blink();
void noCursor();
void cursor();
void scrollDisplayLeft();
void scrollDisplayRight();
void leftToRight();
void rightToLeft();
void autoscroll();
void noAutoscroll();
void setRowOffsets(int row1, int row2, int row3, int row4);
void createChar(uint8_t, uint8_t[]);
void setCursor(uint8_t, uint8_t);
virtual size_t write(uint8_t);
void command(uint8_t);
using Print::write;
private:
void send(uint8_t, uint8_t);
void write4bits(uint8_t);
void write8bits(uint8_t);
void pulseEnable();
uint8_t _rs_pin; // LOW: command. HIGH: character.
uint8_t _rw_pin; // LOW: write to LCD. HIGH: read from LCD.
uint8_t _enable_pin; // activated by a HIGH pulse.
uint8_t _data_pins[8];
uint8_t _displayfunction;
uint8_t _displaycontrol;
uint8_t _displaymode;
uint8_t _initialized;
uint8_t _numlines;
uint8_t _row_offsets[4];
};
#endif
