Pantalla Gráfica LCD 128x64

http://www.arduinoecia.com.br/2013/09/display-grafico-lcd-128x64-st7920.
html
http://www.arduinoecia.com.br/2015/05/display-grafico-128x64-st7920-modo-8-bits-
paralelo.html
https://github.com/olikraus/u8glib/wiki/userreference#begin
pantalla grfica LCD 128x64 - ST7920

Las pantallas LCD , en mi opinin, son elementos esenciales para aquellos que trabajan con
Arduino. Son componentes relativamente baratos y proporcionar, dependiendo del uso, de una
manera ms eficiente que los datos del monitor en serie para detectar.
He utilizado las pantallas LCD en muchos artculos aqu en el Arduino and Co., est mostrando
indicadores de temperatura y humedad en un LCD de Nokia 5110 , o las distancias ledo por un
sensor de ultrasonido en un LCD de 16x2 .
Ahora tengo la oportunidad de mostrar otra pantalla grfica LCD , esto con una resolucin
de 128x64 , basado en el chip ST7920 , que adquiri el FILIPEFLOP .
Esta pantalla tiene luz de fondo azul y blanco de escribir, y con l (y la biblioteca de la derecha) se
puede efectos grficos muy interesantes, como la rotacin de pantalla, fuentes del texto del
cambio, la rotacin de texto y, por supuesto, dibujar. Publiqu un breve vdeo en YouTube que
muestra algunas de estas funciones:
La pantalla tiene 20 pines, numeradas de derecha a izquierda, como podemos ver en la imagen
siguiente. Se puede utilizar para comunicarse con el Arduino tanto forma de serie y paralelo. En
este artculo, cuando la frecuencia de actualizacin LCD no es un punto crtico, vamos a utilizar la
comunicacin serie, ocupando slo 4 puertos Arduino:
http://www.arduinoecia.com.br/2013/09/display-grafico-lcd-128x64-st7920.html
paralelo.html
Una informacin ms detallada sobre la asignacin de pines de la pantalla LCD se puede encontrar
en la hoja de datos del producto.
Actualizacin: Aqu 's cmo para encender la pantalla de forma paralela en el artculo grfico
pantalla LCD de 128x64 ST7920 modo de 8 bits .
Actualizado : montar un reloj analgico / digital con esta pantalla. Ver el poste reloj con pantalla
LCD de 128x64 y el mdulo RTC DS3231 .
El circuito utiliza un potencimetro (utilizado un 50K) para ajustar el contraste de la pantalla, y la

potencia se realiza por Arduino 5v. Para alimentar a la luz de fondo, he utilizado el 3.3V de
Arduino Uno R3 (pero de acuerdo a las especificaciones, tambin se puede conectar 5v):
paralelo.html
La biblioteca que usamos es la U8Glib , una biblioteca muy completa (y compleja, a veces), con
muchos ejemplos de uso. Recomiendo una visita a la u8glib pgina (en Ingls), donde encontrar
instrucciones sobre el funcionamiento de la biblioteca e informacin detallada acerca tambin el
uso de cada comando. Vale la pena explorar.
paralelo.html
El programa siguiente se basa en el ejemplo "GraphicsTest" , que viene con la biblioteca. De
acuerdo a las instrucciones del desarrollador, ahorr el encabezamiento con la informacin de
derechos de autor:
/*
GraphicsTest.pde
2 >>> Before compiling: Please remove comment from the constructor of
3 the
4 >>> connected graphics display (see below).
5
6 Universal 8bit Graphics Library, http://code.google.com/p/u8glib/
7
8 Copyright (c) 2012, olikraus@gmail.com
9 All rights reserved.
10
11 Redistribution and use in source and binary forms, with or without
12 modification, are permitted provided that the following conditions
13 are met:
14
15 * Redistributions of source code must retain the above copyright
16 notice,
17 this list of conditions and the following disclaimer.
18
19 * Redistributions in binary form must reproduce the above copyright
20 notice, this list of conditions and the following disclaimer in
21 the
22 documentation and/or other materials provided with the
23 distribution.
24
25 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
26 CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
27 INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
28 MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
29 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
30 CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
31 SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
32 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
33 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
34 CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
35 STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
36 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
37 ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
38 */
39
40 #include "U8glib.h"
41 // A linha abaixo define as ligacoes e deve ser
42 // ajustada conforme o display utilizado.
43 U8GLIB_ST7920_128X64_1X u8g(6, 5, 4 ,7); //Enable, RW, RS, RESET
44 int display = 1;
paralelo.html
45
46 void u8g_prepare()
47 {
48 u8g.setFont(u8g_font_6x10);
49 u8g.setFontRefHeightExtendedText();
50 u8g.setDefaultForegroundColor();
51 u8g.setFontPosTop();
52 }
53
54 void u8g_Tela1() //Tela 1 - Arduino e Cia - Retangulos
55 {
56 u8g.setFont(u8g_font_unifont);
57 u8g.drawStr( 11, 35, "Arduino e Cia");
59 u8g.drawFrame(0,0,128,64);
60 u8g.drawFrame(2,2,124,60);
61 }
62
63 void u8g_Tela2() //Tela 2 - Moldura e relgio
64 {
65 u8g.drawRFrame(0,0,128,64,3);
66 u8g.drawStr( 3, 10, "Hor.: 13:00");
67 u8g.drawStr( 3, 25, "Temp: 27");
68 char s[2] = " ";
69 s[0] = 176;
70 u8g.drawStr(51, 25, s);
71 u8g.drawStr( 3, 40, "Umid: 25%");
72 u8g.drawCircle(95,32,28);
73 u8g.drawCircle(95,32,29);
74 u8g.drawLine(95, 9, 95, 4);
75 u8g.drawLine(123, 32, 118, 32);
76 u8g.drawLine(95, 55, 95, 60);
77 u8g.drawLine(67, 32, 72, 32);
78 u8g.drawLine(95, 32, 95, 12);
79 u8g.drawLine(95, 32, 100.8, 21.87 );
80 u8g.setFont(u8g_font_04b_03);
81 u8g.drawStr(89,43, "Tag");
82 u8g.drawStr(85,50, "Heuer");
83 }
84
85 void u8g_Tela3() //Tela 3 - Caracteres Ascii - Pag. 1
86 {
87 char s[2] = " ";
88 u8g.drawStr( 0, 0, "ASCII page 1");
89 for(int y = 0; y < 6; y++ )
90 {
91 for(int x = 0; x < 16; x++ )
92 {
93 s[0] = y*16 + x + 32;
94 u8g.drawStr(x*7, y*10+10, s);
paralelo.html
95 }
96 }
97 }
98
99 void u8g_Tela4() //Tela 3 - Caracteres Ascii - Pag. 2
100 {
101 char s[2] = " ";
102 uint8_t x, y;
103 u8g.drawStr( 0, 0, "ASCII page 2");
104 for( y = 0; y < 6; y++ )
105 {
106 for( x = 0; x < 16; x++ )
107 {
108 s[0] = y*16 + x + 160;
109 u8g.drawStr(x*7, y*10+10, s);
110 }
111 }
112 }
113
114 void u8g_Tela5() //Tela 5 - Arduino e Cia - Retangulo preenchido
115 {
116 u8g.setFont(u8g_font_unifont);
117 u8g.drawBox(0,0,128,64);
118 u8g.drawBox(2,2,124,60);
119 u8g.setColorIndex(0);
122 u8g.drawFrame(2,2,124,60);
123 }
124
125 void u8g_Tela6() //Tela 6 - Arduino e Cia em 0, 90 e 270 graus
126 {
127 u8g.setFont(u8g_font_helvB08);
128 u8g.drawStr(50,31, " Arduino");
129 u8g.drawStr90(50,31, " e");
130 u8g.drawStr270(50,31, " Cia");
131 }
132
133 void u8g_Tela7() //Tela 7 - Fontes diferentes
134 {
135 u8g.setFont(u8g_font_robot_de_niro);
136 u8g.drawStr(5,13, "Arduino e Cia !");
137 u8g.setFont(u8g_font_helvB08);
139 u8g.drawBox(5,31, 118,11);
141 u8g.setFont(u8g_font_8x13);
144 u8g.setFont(u8g_font_ncenB10);
paralelo.html
146 }
147
148 void draw() //Rotina Desenho
149 {
150 u8g_prepare();
151 switch(display) //Carrega a tela correspondente
152 {
153 case 1:
154 u8g_Tela1();
155 break;
156 case 2:
157 u8g_Tela2();
158 break;
159 case 3:
160 u8g_Tela3();
161 break;
162 case 4:
163 u8g_Tela4();
164 break;
165 case 5:
166 u8g_Tela5();
167 break;
168 case 6:
169 u8g_Tela6();
170 break;
171 case 7:
172 u8g_Tela7();
173 break;
174 }
175 }
176
177 void setup()
178 {
179 // flip screen, if required
180 //u8g.setRot180();
181
182 // assign default color value
183 if ( u8g.getMode() == U8G_MODE_R3G3B2 )
184 u8g.setColorIndex(255); // white
185 else if ( u8g.getMode() == U8G_MODE_GRAY2BIT )
186 u8g.setColorIndex(1); // max intensity
187 else if ( u8g.getMode() == U8G_MODE_BW )
188 u8g.setColorIndex(1); // pixel on
189
190 //u8g.setContrast(0x30);
191 }
192
193 void loop()
194 {
paralelo.html
195 // picture loop
196 for (display =1; display < 8; display++) //Carrega as telas de 1 a
197 7
198 {
199 u8g.firstPage();
200 do
201 {
202 draw();
203 }
while( u8g.nextPage() );
delay(3000); //Pausa de 3 segundos e reinicia o processo
}
}
/////////////////////////////////////////////////////////////////////////////////
/ *
GraphicsTest.pde
>>> Antes de compilar: Por favor quite comentario desde el constructor de
la
>>> pantalla grfica conectada (vase ms adelante).
8bit universal Graphics Library, http://code.google.com/p/u8glib/
Copyright (C) 2012, olikraus@gmail.com Todos los derechos reservados.
La redistribucin y uso en formas fuente y binario, con o sin
modificaciones, estn permitidos siempre Que Las siguientes condiciones
se cumplen: * Las redistribuciones del cdigo fuente deben conservar el
aviso de copyright anterior, esta lista de condiciones y la renuncia de
responsabilidad siguiente. * Las redistribuciones en formato binario
deben reproducir el copyright anterior notificacin, esta lista de
condiciones y la renuncia de responsabilidad Siguiendo la documentacin
y / u otros materiales proporcionados con la distribucin. ESTE
SOFTWARE SE PROPORCIONA LOS PROPIETARIOS DEL COPYRIGHT Y
COLABORADORES "TAL CUAL" SIN GARANTA EXPRESA O IMPLCITAS,
INCLUYENDO, PERO NO LIMITADO A, LAS GARANTAS DE COMERCIALIZACIN Y
APTITUD PARA UN FIN DETERMINADO DENEGARLOS. EN NINGN CASO EL
TITULAR DE DERECHOS DE AUTOR O SUS COLABORADORES responsables de
daos directos, incidentales, indirectos , o daos especiales,
EJEMPLARES DERIVADOS (INCLUYENDO, PERO NO LIMITADO A, LA ADQUISICIN
DE BIENES O SERVICIOS; PRDIDA DE USO, DE DATOS O BENEFICIOS; O
INTERRUPCIN DE NEGOCIO), ORIGEN Y DE CUALQUIER TEORA DE
RESPONSABILIDAD, YA SEA EN CONTRATO, RESPONSABILIDAD OBJETIVA O
AGRAVIO (INCLUYENDO NEGLIGENCIA), DERIVADO EN CUALQUIER FORMA DEL
USO DE ESTE SOFTWARE, INCLUSO SI SE ADVIERTE DE LA POSIBILIDAD DE
TAL DAO. * /
paralelo.html
# include "U8glib.h"
// La siguiente lnea define la llamada y debe ser
// establece como la pantalla utilizada.
U8GLIB_ST7920_128X64_1X u8g ( 6 , 5 , 4 , 7 ); // Habilitar, RW, RS,
REINICIAR
int pantalla = 1 ;
void u8g_prepare ()
{
u8g.setFont (u8g_font_6x10);
u8g.setFontRefHeightExtendedText ();
u8g.setDefaultForegroundColor ();
u8g.setFontPosTop ();
}
void u8g_Tela1 () // Pantalla 1 - Arduino y Co - rectngulos

{
u8g.setFont (u8g_font_unifont);
u8g.drawStr ( 11 , 35 , "Arduino y Co" );
u8g.drawFrame ( 0 , 0 , 128 , 64 );
u8g.drawFrame ( 2 , 2 , 124 , 60 );
}
void u8g_Tela2 () // Pantalla 2 - Estructura y Reloj

{
paralelo.html
u8g.drawRFrame ( 0 , 0 , 128 , 64 , 3 );
u8g.drawStr ( 3 , 10 , "Hor: 13:00." );
u8g.drawStr ( 3 , 25 , "Temp: 27" );
Char s [ 2 ] = "" ;
s [ 0 ] = 176 ;
u8g.drawStr ( 51 , 25 , s);
u8g.drawStr ( 3 , 40 , "Umid 25%" );
u8g.drawCircle ( 95 , 32 , 28 );
u8g.drawCircle ( 95 , 32 , 29 );
u8g.drawLine ( 95 , 9 , 95 , 4 );
u8g.drawLine ( 123 , 32 , 118 , 32 );
u8g.drawLine ( 95 , 55 , 95 , 60 );
u8g.drawLine ( 67 , 32 , 72 , 32 );
u8g.drawLine ( 95 , 32 , 95 , 12 );
u8g.drawLine ( 95 , 32 , 100.8 , 21.87 );
u8g.setFont (u8g_font_04b_03);
u8g.drawStr ( 89 , 43 , "etiqueta" );
u8g.drawStr ( 85 , 50 , "Heuer" );
}
void u8g_Tela3 () // Pantalla 3 - caracteres ASCII - Pag. 1

{
Char s [ 2 ] = "" ;
u8g.drawStr ( 0 , 0 , "ASCII pgina 1" );
para ( int y = 0 ; y < 6 ; y ++)
{
para ( int x = 0 ; x < 16 ; x ++)
{
s [ 0 ] = Y * 16 + x + 32 ;
u8g.drawStr (x * 7 , * y 10 + 10 , s);
}
}
}
void u8g_Tela4 () // Pantalla 3 - caracteres ASCII - Pag. 2

{
Char s [ 2 ] = "" ;
uint8_t x, y;
u8g.drawStr ( 0 , 0 , "ASCII pgina 2" );
para (y = 0 ; y < 6 ; y ++)
{
para (x = 0 ; x < 16 ; x ++)
{
s [ 0 ] = Y * 16 + x + 160 ;
u8g.drawStr (x * 7 , * y 10 + 10 , s);
}
}
}
void u8g_Tela5 () // Pantalla 5 - Arduino y Co - rectngulo relleno

paralelo.html
{
u8g.setFont (u8g_font_unifont);
u8g.drawBox ( 0 , 0 , 128 , 64 );
u8g.drawBox ( 2 , 2 , 124 , 60 );
u8g.setColorIndex ( 0 );
u8g.drawFrame ( 2 , 2 , 124 , 60 );
}
void u8g_Tela6 () // Pantalla 6 - Arduino y compaa a los 0, 90 y 270

grados
{
u8g.setFont (u8g_font_helvB08);
u8g.drawStr ( 50 , 31 , "Arduino" );
u8g.drawStr90 ( 50 , 31 , "y" );
u8g.drawStr270 ( 50 , 31 , "CIA" );
}
void u8g_Tela7 () // Pantalla 7 - Diferentes tipos de letra

{
u8g.setFont (u8g_font_robot_de_niro);
u8g.drawStr ( 5 , 13 , "Arduino y Co." );
u8g.setFont (u8g_font_helvB08);
u8g.drawBox ( 5 , 31 , 118 , 11 );
u8g.setFont (u8g_font_8x13);
u8g.setFont (u8g_font_ncenB10);
}
void draw () // Diseo de rutina

{
u8g_prepare ();
Interruptor (pantalla) // Cargar la pantalla correspondiente
{
caso 1 :
u8g_Tela1 ();
romper ;
caso 2 :
u8g_Tela2 ();
romper ;
caso 3 :
u8g_Tela3 ();
romper ;
caso 4 :
u8g_Tela4 ();
paralelo.html
romper ;
Caso 5 :
u8g_Tela5 ();
romper ;
Caso 6 :
u8g_Tela6 ();
romper ;
Caso 7 :
u8g_Tela7 ();
romper ;
}
}
void setup ()
{
Voltear la pantalla //, si es necesario
//u8g.setRot180 ();
// Asignar valor de color por defecto

si (u8g.getMode () == U8G_MODE_R3G3B2)
u8g.setColorIndex ( 255 ); // Blanco
dems si (u8g.getMode () == U8G_MODE_GRAY2BIT)
u8g.setColorIndex ( 1 ); // Intensidad mxima
otro si (u8g.getMode () == U8G_MODE_BW)
u8g.setColorIndex ( 1 ); // Pxel en la
//u8g.setContrast(0x30);
}
void loop ()
{
// Bucle de imagen
es (display = 1 ; display < 8 ; pantalla ++) // pantallas de carga 1-7
{
u8g.firstPage ();
de
{
draw ();
}
mientras que (u8g.nextPage ());
retardo ( 3000 ); // 3 segundos de pausa y reiniciar el proceso de
}
}
////////////////////////////////////////////////////////////////////////////////
paralelo.html
Pantalla LCD Grfica 12864 con ST7920

Hay muchas y muy diversas pantallas que podemos hacer funcionar directamente con Arduino. En
sta entrada vamos a presentar esta singular pantalla LCD grfica de 128 x 64 pixeles con el
controlador ST7920, ya que hemos visto por Internet cantidad de gente que no es capaz de
conectarla correctamente ni hacerla funcionar por la falta de documentacin en el significado de
sus pines.
Introduccin
Como ya hemos adelantado, estamos ante un LCD grfico, retroiluminado, con contraste
variable, con 128 pixeles de largo y 64 pixeles de ancho. Las pantallas quedan muy elegantes en
la mayora de proyectos realizados con Arduino, ya sea para mostrar informacin, para ayudar al
usuario con la navegacin por la aplicacin o con la configuracin, etc.
Encapsulado
La unidad que presentamos en ste post es un mdulo etiquetado como HJ12864ZW, con un LCD
grfico 12864 controlada por un integrado ST7920.
LCD
grfico 12864 con ST7920
paralelo.html
Datos del mdulo

Sus principales caractersticas son:
Dimensiones: 93.0 x 70.0 x 13.5 mm.
rea visual: 72.0 x 40.0 mm.
Tamao del pxel: 0.48 x 0.48 mm.
Tensin de funcionamiento: 3.3v / 5.0v.
Tensin del funcionamiento del controlador del LCD: 3.0v 5.0v.
Temperatura de funcionamiento: -20C 70C.
Conexin
El mdulo que os presentamos tiene una variedad de pines que nos puede parecer demasiado
numerosa. Veamos el significado de cada uno:
Esquema de pines
Pin Significado Descripcin
VSS/GND Ground
VDD/VCC Vin
Voltaje del driver

V0 Ajusta el contraste del LCD (<=7.0v).
del LCD
Tiene distintos propsitos si est trabajando en modo serie o

RS Register Select
paralelo.
En modo paralelo indica el tipo de operacin (lectura/escritura). En

R/W Read / Write Line
modo serie se utiliza como entrada de datos.
paralelo.html
Read / Write En modo paralelo es la seal de comienzo de actividad (lectura de
E
Enable datos/seleccin de operacin). En modo serie es la seal de reloj.
Data Bus 0 Data

DB0-DB3 Bits menos significativos en modo paralelo 8 bits.
Bus 3
Data Bus 4 Data Bits ms significativos en modo paralelo 8 bits. Bus de datos en
DB4-DB7
Bus 7 modo paralelo 4 bits.
Serial / Parallel
PSB Selecciona el modo de funcionamiento (Serie / Paralelo).
control port
NC Not Connected
RST Reset
Salida del
Vout doblador de
voltaje
BLA BackLight (+) Terminal positivo de la retroiluminacin (3.3v 5.0v).
BLK BackLight (-) Terminal negativo de la retroiluminacin.
Dependiendo del mdulo, tendris o no un tornillo por la parte de atrs, el cual nos sirve
para variar el contraste de la pantalla. En caso de no disponer de ste tornillo (en realidad es
un potencimetro), podemos conectar un potencimetro en el pin V0 y tensin positiva (+) para
variarlo manualmente.
Del mismo modo, podemos variar la retroiluminacin del LCD colocando otro potencimetro para
variar la tensin en el pin BLA.
Un ejemplo de esquema de conexiones para utilizarlo con la librera que os recomendamos ms
abajo sera el siguiente:
paralelo.html
Pin LCD Pin Arduino Comentarios
VSS/GND Ground
VDD/VCC 5v
Si tenemos variador de contraste en el reverso del LCD no hace falta

V0 Al aire o a 5v
conectarlo.
RS Pin X digital Tiene distintos propsitos si est trabajando en modo serie o paralelo.
Pin Y digital o Si no vamos a programar ningn caracter del LCD conectamos GND, en
R/W
GND caso contrario a un pin digital.
En modo paralelo es la seal de comienzo de actividad (lectura de

E Pin Z digital
datos/seleccin de operacin). En modo serie es la seal de reloj.
Pines A D
DB0-DB3
digitales
Pines E H
DB4-DB7
digitales
PSB 5v Seleccionando as el modo paralelo.
NC Al aire
RST Al aire
Vout Al aire
BLA 5v
paralelo.html
BLK Ground
Librera
Hay varias libreras circulando por la red, pero sin duda, la ms completa, con ms actualizaciones
y mejor documentada es la librera u8glib. No slo nos va a servir para este mdulo, sino que es
vlida para un montn de pantallas. Podis encontrar un montn de documentacin en su pgina
oficial de Google Code u8glib.
Biblioteca grfica LCD

La biblioteca GLCD por Michael Margolis permite 128x64 pantallas
grficas a utilizar. Dibujo con diferentes fuentes, mapas de bits, lneas,
crculos y los pxeles individuales son compatibles.
Descargar : ks0108.zip (versin 2, con parches Teensy)
Esta copia incluye la asignacin de patillas por defecto para la placa

Teensy.
paralelo.html
Requisitos de hardware
Se requiere un 128x64 LCD grfica basada en el chip controlador
KS0108. El 128x64 LCD vendidos por PJRC es totalmente compatible.
Teensy ++ 2.0 con 128x64 LCD de ejecutar el programa de

(ms fotos de abajo)
ejemplo
Teensy de LCD conexiones se documentan a continuacin .
ejemplo de programa
Este programa de ejemplo viene con la biblioteca. Puede abrirlo desde
el Archivo -> Ejemplos -> KS0108 -> GLCDexample men; Ms
informacin se puede encontrar en la pgina oficial de GLCD web .
//////////////////////////////////////////////////////////////////
paralelo.html
Example Program
This example program comes with the library. You can open it from
the File -> Examples -> ks0108 -> GLCDexample menu; More
information can be found on the official GLCD web page.
/*
* GLCDexample
*
* Basic test code for the Arduino KS0108 GLCD library.
* This code exercises a range of graphic functions supported
* by the library and is an example of its use.
* It also gives an indication of performance, showing the
* number of frames drawn per second.
*/
#include <ks0108.h>
#include "Arial14.h" // proportional font
#include "SystemFont5x7.h" // system font
#include "ArduinoIcon.h" // bitmap
unsigned long startMillis;

unsigned int loops = 0;
unsigned int iter = 0;
void setup(){
delay(500); // allow time for LCD to reset
GLCD.Init(NON_INVERTED); // initialise the library, non inverted
writes pixels onto a clear screen
GLCD.ClearScreen();
GLCD.DrawBitmap(ArduinoIcon, 32,0, BLACK); //draw the bitmap at the
given x,y position
GLCD.SelectFont(System5x7); // switch to fixed width system font
countdown(5);
GLCD.ClearScreen();
introScreen(); // show some intro stuff
GLCD.ClearScreen();
}
void introScreen(){
GLCD.SelectFont(Arial_14); // you can also make your own fonts, see
playground for details
GLCD.GotoXY(20, 2);
GLCD.Puts("GLCD version ");
GLCD.PrintNumber(GLCD_VERSION);
GLCD.DrawRoundRect(16,0,99,18, 5, BLACK); // rounded rectangle around
text area
GLCD.SelectFont(System5x7); // switch to fixed width system font
showCharacters();
countdown(5);
}
paralelo.html
void showCharacters(){
byte line = 3; // start on the fourth line
for(byte c = 32; c <=127; c++){
if( (c-32) % 20 == 0)
GLCD.CursorTo(1,line++); // CursorTo is used for fixed width
system font
GLCD.PutChar(c);
}
}
void drawSpinner(byte pos, byte x, byte y) {

// this draws an object that appears to spin
switch(pos % 8) {
case 0 : GLCD.DrawLine( x, y-8, x, y+8, BLACK); break;
case 1 : GLCD.DrawLine( x+3, y-7, x-3, y+7, BLACK); break;
case 4 : GLCD.DrawLine( x+8, y, x-8, y, BLACK); break;
case 5 : GLCD.DrawLine( x+7, y+3, x-7, y-3, BLACK); break;
}
}
void countdown(int count){

while(count--){ // do countdown
GLCD.CursorTo(0,1); // first column, second row (offset is from 0)
GLCD.PutChar(count + '0');
delay(1000);
}
}
void loop(){ // run over and over again

iter = 0;
startMillis = millis();
while( millis() - startMillis < 1000){ // loop for one second
GLCD.DrawRect(0, 0, 64, 61, BLACK); // rectangle in left side of
screen
GLCD.DrawRoundRect(68, 0, 58, 61, 5, BLACK); // rounded rectangle
around text area
for(int i=0; i < 62; i += 4)
GLCD.DrawLine(1,1,63,i, BLACK); // draw lines from upper left down
right side of rectangle
GLCD.DrawCircle(32,31,30,BLACK); // draw circle centered in the
left side of screen
GLCD.FillRect(92,40,16,16, WHITE); // clear previous spinner position
drawSpinner(loops++,100,48); // draw new spinner position
//GLCD.FillRect(24,txtLINE3,14,14, WHITE); // clear text area that
will be drawn below
GLCD.CursorTo(5,5); // locate curser for printing text
GLCD.PrintNumber(++iter); // print current iteration at the
current cursor position
}
// display number of iterations in one second
paralelo.html
GLCD.ClearScreen(); // clear the screen
GLCD.CursorTo(14,2); // positon cursor
GLCD.Puts("FPS= "); // print a text string
GLCD.PrintNumber(iter); // print a number
}
////////////////////////////////////////////////////////////////
Biblioteca grfica LCD

La biblioteca GLCD por Michael Margolis permite 128x64 pantallas
grficas a utilizar. Dibujo con diferentes fuentes, mapas de bits, lneas,
crculos y los pxeles individuales son compatibles.
Descargar : ks0108.zip (versin 2, con parches Teensy)
Esta copia incluye la asignacin de patillas por defecto para la placa

Teensy.
Requisitos de hardware
Se requiere un 128x64 LCD grfica basada en el chip controlador
KS0108. El 128x64 LCD vendidos por PJRC es totalmente compatible.
paralelo.html
Teensy ++ 2.0 con 128x64 LCD de ejecutar el programa de

(ms fotos de abajo)
ejemplo
Teensy de LCD conexiones se documentan a continuacin .
ejemplo de programa
Este programa de ejemplo viene con la biblioteca. Puede abrirlo desde
el Archivo -> Ejemplos -> KS0108 -> GLCDexample men; Ms
informacin se puede encontrar en la pgina oficial de GLCD web .
/ *
* GLCDexample
*
* cdigo de prueba bsica para la biblioteca Arduino GLCD KS0108.
* Este cdigo ejerce una serie de funciones grficas apoyado
* por la biblioteca y es un ejemplo de su uso.
* Tambin da una indicacin del rendimiento, que muestra el
nmero * de cuadros dibujados.
* /
# include <ks0108.h>
# include "Arial14.h" // proporcional fuente
# include "SystemFont5x7.h" // fuente del sistema
# include "ArduinoIcon.h" // mapa de bits
sin firmar largos startMillis;

unsigned int bucles = 0;
paralelo.html
unsigned int = 0; iter
void setup () {
retardo (500); // Dar tiempo a la LCD para restablecer
GLCD . Init ( NON_INVERTED ); // Inicializar la biblioteca, no
invertida escribe pxeles en una pantalla clara
GLCD . ClearScreen ();
GLCD .DrawBitmap (ArduinoIcon, 32,0, NEGRO ); // dibujar el mapa de
bits en el dado x, y posicin
GLCD . Selectfont (System5x7); // Cambia a fuente de sistema de ancho
fijo
cuenta atrs (5);
introScreen (); // Mostrar un poco de materia de
introduccin
}
anular introScreen () {
GLCD . Selectfont (Arial_14); // Tambin puede hacer sus propias
fuentes, parque infantil para ver detalles
GLCD . Gotoxy (20, 2);
GLCD . Puts ( "versin GLCD" );
GLCD . PrintNumber (GLCD_VERSION);
GLCD . DrawRoundRect (16,0,99,18, 5, NEGRO ); // Redondeado rectngulo
alrededor de rea de texto
GLCD . Selectfont (System5x7); // Cambia a fuente de sistema de ancho
fijo
muestra caracteres();
cuenta atrs (5);
}
void showCharacters () {
byte de la lnea = 3; // Inicia en la cuarta lnea
de ( byte c = 32; c <= 127; c ++) {
si ((c-32) 20% == 0)
GLCD . CursorTo (1, lnea ++); // CursorTo se utiliza para la
anchura fija de fuente del sistema
GLCD . Putchar (c);
}
}
void drawSpinner ( byte de la posicin, el byte x, bytes y) {

// esto dibuja un objeto que parece girar
el interruptor (pos% 8) {
caso 0: GLCD . DrawLine (x, y-8, x, y + 8, NEGRO ); descanso;
caso 1: GLCD . DrawLine (x + 3, Ao-7, x-3, y + 7, NEGRO ); descanso;
caso 2: GLCD . DrawLine (x + 6, Ao-6, x-6, y + 6, NEGRO ); descanso;
caso 3: GLCD . DrawLine (x + 7, Y-3, x-7, y + 3, NEGRO ); descanso;
caso 4: GLCD . DrawLine (x + 8, y, x-8, y, NEGRO ); descanso;
caso 5: GLCD . DrawLine (x + 7, y + 3, x-7, Y-3, NEGRO ); descanso;
caso 6: GLCD . DrawLine (x + 6, y + 6, x-6, Ao-6, NEGRO ); descanso;
caso 7: GLCD . DrawLine (x + 3, y + 7, x-3, Ao-7, NEGRO ); descanso;
}
}
paralelo.html
void cuenta atrs ( int count) {

tiempo (cuenta -) { // hacer la cuenta atrs
GLCD . CursorTo (0,1); // Primera columna, segunda fila (offset es
de 0)
GLCD . PutChar (count + '0' );
retardo (1000);
}
}
void loop () { // ejecutar una y otra vez

iter = 0;
startMillis = millis ();
mientras que ( Millis () - startMillis <1.000) { // bucle durante un
segundo
GLCD . DrawRect (0, 0, 64, 61, NEGRO ); // Rectngulo en el lado
izquierdo de la pantalla
GLCD . DrawRoundRect (68, 0, 58, 61, 5, NEGRO ); // Rectngulo
redondeado alrededor de la zona de texto
para ( int i = 0; i <62; i + = 4)
GLCD . DrawLine (1,1,63, i, NEGRO ); // Dibujar lneas desde el
lado derecho hacia abajo a la izquierda superior del rectngulo
GLCD . DrawCircle (32,31,30, NEGRO ); // Dibujar crculo centrado
en el lado izquierdo de la pantalla
GLCD . FillRect (92,40,16,16, BLANCO ); // Clara spinner anterior
posicin
drawSpinner (bucles ++, 100,48); // Llamar la nueva posicin
spinner
//GLCD.FillRect(24,txtLINE3,14,14, BLANCO); // rea de texto claro
que se extrae a continuacin
GLCD . CursorTo (5,5); // Localizar cursor para
imprimir texto
GLCD . PrintNumber (++ ITER); // Imprimir iteracin actual en
la posicin actual del cursor
}
// Nmero de iteraciones pantalla en un segundo
GLCD . ClearScreen (); // Borrar la pantalla
GLCD . CursorTo (14,2); // Cursor positon
GLCD . Puts ( "FPS =" ); // Imprimir una cadena de texto
GLCD . PrintNumber (ITER); // Imprimir un nmero
}
paralelo.html
Conexin de la pantalla LCD para Teensy

o Teensy ++
Conexiones estndar para Teensy ++ 1.0 o 2.0:
paralelo.html
Conexiones estndar para Teensy 2.0:
paralelo.html
conexiones alternativas para Teensy 2.0: (debe modificar el cdigo para
habilitar esta conexin)
La pantalla requiere un potencimetro de ajuste de contraste. Un valor de

5 o 10 km funciona bien. El terminal central debe conectarse con el
"ajuste de contraste" pin (Vo). Los dos terminales secundarios deben
conectarse a la patilla "Contraste de energa" (Vee) y tierra. No importa
qu lados del potencimetro se conecta a estas 2 seales, como la
conexin inversa simplemente hacer el giro a la derecha ajustar en la
direccin opuesta.
El pin de reset se debe conectar a +5 voltios. No es necesario para

conducir la baja pin de reset antes de usar la pantalla LCD.
Alternativamente, el pin de reset se puede conectar a cualquier pin no

utilizado del Teensy, si quieres una conexin de hardware que restablece
la pantalla LCD a su estado predeterminado. Antes de inicializar la
pantalla LCD, la produccin mnima para restablecer la pantalla LCD y
alta para que pueda funcionar. Por ejemplo:
void setup () {
pinMode (3, SALIDA );
digitalWrite (3, LOW ); // Restablecer la LCD
paralelo.html
de retardo (10);
digitalWrite (3, ALTA ); // Permitir que se ejecute
GLCD . Init ( NON_INVERTED );
}
Ms fotos
Teensy 2.0 con 128x64 LCD de ejecutar el programa de ejemplo
Ha navegado por nuestra web hasta aqu: HuborArduino Programacin Curso de

programacin de Arduino utilizando Proteus Leccin 23: Control de un display LCD
grfico
Leccin 23: Control de un display LCD

grfico
Publicado: 08 Septiembre 2014 | Escrito por F.J.Alexandre | | Visto: 12735
[Proteus versin 8.2]

En la leccin 16 estudiamos la forma de utilizar un display LCD de texto en
nuestros proyectos ARDUINO. En aquella ocasin ya definimos un display LCD
(siglas del ingls liquid crystal display) o pantalla de cristal lquido, como una
pantalla delgada y plana formada por un nmero de pxeles, en color o
paralelo.html
monocromos, colocados delante de una fuente de luz o reflectora. Su principal
ventaja es que utiliza cantidades muy pequeas de energa elctrica.
Tambin vimos que existen pantallas muy variadas en el mercado. Las hay de
colores diferentes (monocromo verde, monocromo mbar o color). Unas tienen
capacidad para mostrar slo caracteres de texto y otras admiten grficos. La
leccin 16 se dedic a la familia de pantallas que slo eran capaces de mostrar
caracteres de texto. En esta ocasin queremos introducirnos en el uso de las que
tienen capacidades grficas.
Antes de empezar con la leccin hay que hacer dos salvedades importantes. En
primer lugar, hay que saber que existen muchos tipos diferentes de pantallas
grficas y que su gobierno puede diferir mucho de unas a otras. Cuando vayamos
a elegir la pantalla para nuestro proyecto hay que tener en cuenta dos cuestiones:
la pantalla propiamente dicha (su tamao, color o monocromo, resolucin, etc) y el
chip con la que se controla. Hay diferentes tipos de controlador y su programacin
es diferente. Nosotros vamos a ver en esta leccin el control de una pantalla
monocromo de 128 x 64 pixels y basada en el controlador SAMSUNG KS0108.
paralelo.html
En segundo lugar, es importante tener en cuenta una cosa. La programacin de

una pantalla grfica es considerablemente ms compleja que el de una pantalla de
texto. En esta leccin vamos a explicar los conceptos ms bsicos y realizaremos
sencillos dibujos de lneas, polgonos y caracteres. Llegar a realizar una pantalla
grfica completa y profesional puede ser una tarea bastante laboriosa y que nos
lleve mucho tiempo.
Para controlar nuestra pantalla grfica vamos a utilizar una librera para ARDUINO
disponible en la pgina oficial en el siguiente enlace: KS0108 Graphics LCD library.
Como ya hemos visto en anteriores lecciones cuando utilizamos libreras de
terceros tenemos que colocarla en el directorio 'libraries' de la carpeta donde
hayamos instalado nuestro entorno de desarrollo ARDUINO. En esta ocasin, la
librera se crear en la carpeta llamada KS0108.
paralelo.html
Para simular nuestra pantalla grfica, Proteus nos facilita varios modelos.
Nosotros vamos a utilizar el llamado LGM12641BS1R. En la siguiente pantalla se
muestra su representacin grfica y la forma en que lo tenemos que conectar a
nuestro equipo ARDUINO.
paralelo.html
Es importante tener en cuenta que hemos puesto la seal de reset (RST)
conectada directamente al potencial de +5V. De esta manera la pantalla est
encendida en todo momento. El resto de los pines se han conectado a los pines
de nuestro ARDUINO segn las especificaciones de la librera que estamos
utilizando. El esquema elctrico completo es el siguiente:
paralelo.html
paralelo.html
Veamos ahora el software. Vamos a empezar con un programa muy sencillo para
poder ir introducindonos poco a poco en el control de una pantalla grfica.
Siguiendo con la costrumbre que vamos adquiriendo en lecciones anteriores
partimos de un armazn bsico que nos sirve de estructura para todos los
programas.
paralelo.html
paralelo.html
Como vamos a utilizar la librera HUBOR que ya vimos en la leccin 22 y que

podemos descargar desde nuestra web, hemos includo en la lnea 14 un enlace a
dicha librera. En la lnea 15 llamamos a la librera ks0108 que es la encargada de
controlar la pantalla grfica basada en el controlador SAMSUNG.En la lnea 16
incluimos en nuestro cdigo el fichero "SystemFont5x7.h" que contiene la
definicin de una familia de caracteres de 5x7 pixels. Esta fichero viene includo en
la librera ks0108 y por eso hemos optado por l.
En la funcin setup() hemos escrito tres sentencias de programa. En la lnea 31
inicializamos la pantalla con la funcin GLCD.Init() de la librera ks0108. Esta
funcin slo recibe un parmetro que puede tomar dos valores (NON_INVERTED
y INVERTED) segn deseemos que la pantalla tenga fondo claro y dibujemos en
negro o tenga fondo oscuro y dibujemos en blando.
En la lnea 32 seleccionamos la familia de caracteres que vamos a utilizar para
escribr textos en nuestra pantalla.Como se puede observar, pasamos como
parmetro precisamente la familia de caracteres que se define en el fichero
"SystemFont5x7.h".
Por ltimo, en la lnea 33 utilizamos el primer comando para dibujar en nuestra
pantalla grfica. En este caso la funcin GLCD.DrawRect() que se encarga de
dibujar un recuadro. Los parmetros que recibe esta funcin son cinco:
coordenadas x e y del origen del recuadro, coordenadas x e y del fin del recuadro
y color.
Compilemos y ejecutemos nuestro programa. El resultado en pantalla, aunque no
es muy espectacular, si es muy satisfactorio para el tiempo empleado en escribir el
cdigo.
paralelo.html
Veamos ahora un segundo ejemplo. Con este cdigo vamos a ver un ejemplo de
utilizacin de la mayora de las funciones que nos facilita la librera ks0108 para
dibujar en nuestra pantalla grfica. El cdigo completo es el siguiente:
paralelo.html
paralelo.html
paralelo.html
La lgica de funcionamiento es como sigue.

Hasta la lnea 25 se encuentran las sentencias necesarias para llamar a las
libreras utilizadas y definir las constantes y variables que vamos a utilizar a lo
largo del programa.
En las lneas 26 a 38 se encuentra la funcin setup() para inicializar el equipo. En
ella se realiza las llamadas necesarias para inicializar la pantalla y poner a cero las
variables auxiliares.
paralelo.html
A partir de la lnea 40 se encuentra la funcin loop() que, como siempre, contiene
las sentencias que se ejecutan de forma cclica. Hemos divido esta funcin en
cuatro secciones (siguiendo el esquema que ya hemos establecido como estndar
en nuestras lecciones).
En el primer bloque leemos las entradas (en este caso no hay nada que leer).
En el segundo bloque, escribimos la lgica de control. En nuestro caso es muy
sencilla. Con la ayuda de las funciones temporales iniTmp() y chkTmp() de la
librera HUBOR, ejecutamos cada segundo unas sentencias que sirven para
incrementar el contador y poner a uno el disparador que utilizaremos para saber
cuando tenemos que escribir en nuestra pantalla.
En el tercer bloque que utilizamos para escribir las salidas tampoco hay nada,
porque en este proyecto no utilizamos salidas a parte de las utilizadas para contral
la pantalla grfica.
En el cuarto bloque que utilizamos para controlar perifricos, se encuentran las
lneas que ms nos importan en esta leccin y que se encargan de escribir en la
pantalla. Para facilitar la visualizacin y comprensin de lo que escribimos en la
pantalla hemos hecho lo siguiente. Cada vez que el disparador vale 1, realizamos
una escritura en la pantalla y lo volvemos a poner a cero (lnea 66). A continuacin
borramos la pantalla (lnea 67).
En las lneas 68 a 115 utilizamos la estructura de control SWITCH-CASE. Como
es la primera vez que la utilizamos en este curso, vamos a empezar por explicar
cmo funciona. La sentencia SWITCH es una estructura de control de bifurcacin
mltiple estndar en el lenguaje de programacin C. En un bloque SWITCH-
CASE, el controlador comprueba el valor de una variable (en nuestro caso
Contador1) de forma sucesiva frente a una lista de valores (cada una de las
sentencias CASE). Cuando encuentra una coincidencia, se ejecuta el bloque de
sentencias asociados con el CASE hasta que encuentra un BREAK. Si no se
encuntra ninguna coincidencia se ejecuta el bloque DEFAULT.
Una vez que ya sabemos como funciona un bloque SWITCH-CASE vayamos
ahora a ver cmo controlamos nuestra pantalla en cada incremento de nuestro
contador. Cuando el contador vale 1 se ejecuta la funcin GCLD,DrawBitmap() de
la librera KS0108. Esta funcin se encarga de dibujar en nuestra pantalla una
imagen en formato de mapa de bits. En nuestro caso, la informacin de esta
imagen se encuentra almacenada en el fichero ArduinoIcon.h que se suministra
con la librera y que incluimos en la lnea 16 de nuestro cdigo.
El resultado que se visualiza en nuestra pantalla es:

paralelo.html
Cuando el contador vale 2 se ejecuta un bucle repetitivo con ayuda de la

estructura de control FOR. En cada iteracin del bucle ejecutamos una funcin
GLCD.DrawCircle que se encarga de dibujar un crculo en la pantalla. Los
parmetros que le tenemos que pasar a esta funcin son las coordenadas x e y
del centro, el radio del cculo y el color con el que vamos a dibujarlo. En nuestro
caso, dibujamos una serie de cculos concentrcos con centro en el punto 64,32 y
de radios comprendidos entre 5 y 20 en saltos de 5 en 5.
El resultado ser:
paralelo.html
Cuando el contador vale 3 ejecutamos la funcin GLCD.DrawLine() que se
encarga de dibujar una lnea recta. Los parmetros que debemos pasar a esta
funcin son las coordenadas x e y del origen de la lnea, las coordenadas x e y del
fin de la lnea y el color.
En la pantalla se visualiza:
Cuando el contador vale 4 ejecutamos la funcin GLCD.DrawVertLine() que se

encarga de dibujar una lnea recta vertical. Los parmetros que debemos pasar a
esta funcin son las coordenadas x e y del origen de la lnea, la longitud de la
misma y el color. En este caso volvermos a utilizar un bucle FOR para dibujar una
serie de lneas desde la coordenada x = 20 hasta la coordenada x=100 en saltos
de 5 en 5.
paralelo.html
Cuando el contador vale 5 ejecutamos la funcin GLCD.DrawHoriLine() que se

encarga de dibujar una lnea recta horizontal. Los parmetros que debemos pasar
a esta funcin son las coordenadas x e y del origen de la lnea, la longitud de la
misma y el color.
Cuando el contador vale 6 ejecutamos la funcin GLCD.DrawRect() que se

encarga de dibujar un rectngulo. Los parmetros que debemos pasar a esta
funcin son las coordenadas x e y del origen del recuadro, las coordenadas x e y
del final y el color.
paralelo.html
Cuando el contador vale 7 ejecutamos la funcin GLCD.DrawRoundRect() que se

encarga de dibujar un rectngulo de esquinas redondeadas. Los parmetros que
debemos pasar a esta funcin son las coordenadas x e y del origen del rectngulo,
las coordenadas x e y del final, el radio con el que se redondear las esquinas y el
color.
Cuando el contador vale 8 ejecutamos la funcin GLCD.FillRect() que se encarga

de dibujar un rectngulo con relleno. Los parmetros que debemos pasar a esta
funcin son las coordenadas x e y del origen del rectngulo, las coordenadas x e y
del final y el color.
paralelo.html
Cuando el contador vale 10 ejecutamos la funcin GLCD.DrawLine() que ya vimos

con anterioridad y que se encarga de dibujar una lnea recta. Con ayuda de un
bucle FOR somos capaces de dibujar una serie de lneas con origen en un punto
comn (0,0) y con final en un punto de coordenada x constante (127) y
coordenada y variable desde 0 a 65 en intervalos de 2 pixel de separacin.
paralelo.html
Cuando el contador vale ms de 9 no existe ninguna clasula CASE que se

cumpla, as que se ejecutar el bloque DEFAULT. En este bloque se utilizan
varias funciones. La funcin GLCD.CursorTo() se encarga de situar el cursor en
las coordenadas x e y correspondientes. La funcin GLCD.Puts() escribe una
cadena de texto en el lugar donde se encuentre el cursor en este momento. La
funcin GLCD.PrintNumber() escribe un nmero en la pantalla. Tambin nos
ayudamos de la funcin estndar de C strcpy() para escribir en la variable
'Cadena' el valor de una constante de texto.
En la pantalla se visualiza en cada nuevo incremento del contador, un mensaje

con el valor del contador.
paralelo.html
Y con esto, terminamos nuestra leccin de hoy. Ya hemos aprendido a utilizar un

display grfico. Todava exigir por parte del lector una buena dosis de trabajo
para mostrar resultados satisfactorios en sus proyectos. Pero las bases estn
slidamente fundamentadas.
El cdigo completo de la leccin se puede descargar desde este enlace: Cdigo
leccin 23.
Ha navegado por nuestra web hasta aqu: HuborArduino Programacin Curso de

programacin de Arduino utilizando Proteus Leccin 22: Creacin de libreras
Leccin 22: Creacin de libreras

Publicado: 26 Agosto 2014 | Escrito por F.J.Alexandre | | Visto: 7569
[Proteus versin 8.2]

En varias de las lecciones de este curso hemos utilizado una serie de funciones
auxiliares que nos facilitaron la utilizacin de temporizadores, bsculas set-reset,
control de un motor, etc. Aunque estas funciones que hemos utilizado
repetidamente, por ejemplo las funciones iniTemp() y chkTemp(), siempre
contienen el mismo cdigo, nos hemos visto obligados a escribirlas una y otra vez
en cada nuevo programa que construamos.
Por supuesto, que podemos utilizar las facilidades que nos brindan los
procesadores de textos actuales para copiar y pegar el cdigo de unos proyectos
paralelo.html
a otros. Pero, tendramos que acordarnos en qu proyecto las usamos para ir a su
cdigo y realizar el proceso de copia. Y, a medida que va pasando el tiempo, esta
tarea puede terminar siendo una labor de bsqueda pesada y difcil.
En general, todos los programadores acaban utilizando una serie de funciones de
forma bastante repetitiva en todos sus proyectos. Por eso surge el concepto de
librera (en algunos pases tambin se le conoce con el nombre de biblioteca). Una
librera es un fichero (o una serie de ellos) que contiene una serie de funciones
que pueden ser enlazadas y utilizadas por nuestro proyecto.
Nuestro entorno de desarrollo ya viene con una gran cantidad de libreras
disponibles para utilizar en nuestros proyectos. Algunas ya las hemos ido
utilizando a lo largo de este curso. Sin embargo en esta leccin queremos dar un
paso ms all que la mera utilizacin de libreras de terceras personas. Nuestro
objetivo es aprender a construir nuestra propia librera con una serie de funciones
bsicas y a utilizarlas en uno de nuestros proyectos. Por supuesto que cada
usuario podr incluir ms funciones o eliminar aquellas que l no considere tiles
para adaptar la librera a sus necesidades particulares.
En primer lugar, tenemos que tener en cuenta una cosa importante para facilitar la
utilizacin de nuestras libreras en nuevos proyectos. El lugar donde coloquemos
nuestra librera nos facilitar su uso desde nuestro entorno de desarrollo. En
concreto, el sistema de desarrollo de ARDUINO busca, por defecto, todas las
libreras que se encuentran en el directorio 'libraries' de la carpeta donde
tengamos instalado el entorno ARDUINO. En nuestro caso (windows 7 64bits) la
carpeta se encuentra en la siguiente ruta:
Y contiene las siguientes libreras:

paralelo.html
Como es lgico, en cada ordenador encontraremos una lista diferente segn el

nmero de libreras de terceros que hayamos instalado.
Nosotros, vamos a crear una librera llamada Hubor. Si el usuario quiere cambiar
el nombre de su librera por uno que se adece ms a sus gustos, slo tiene que
seguir todos los pasos de esta leccin cambiando 'Hubor' por el nombre elegido en
todos ellos. Lo importante es que mantengamos la coherencia a lo largo de todo el
proceso para que su utilizacin sea intuitiva y sencilla.
paralelo.html
La primera tarea consiste en crear un directorio de nombre 'Hubor' en la
mencionada carpeta de libreras. Dentro de esta carpeta que acabamos de crear
tenemos que escribir dos ficheros de texto. Uno de ellos lo llamaremos 'Hubor.cpp'
y el otro 'Hubor.h'. Por ahora estn vacos, pero ms tarde iremos aadiendo los
cdigos necesarios. El primero contendr el cdigo en lenguaje 'c' de nuestras
funciones. El segundo es un fichero de cabecera con informacin para el
compilador (normalmente, una declaracin directa de clases, subrutinas, variables,
u otros identificadores) para el uso de la librera.
El cdigo completo del archivo Hubor.cpp se puede descargar desde este
enlace: Fichero Hubor.cpp. Este fichero contiene el cdigo de las siguientes
funciones: iniTemp(), chkTemp(), flancoSub(), flancoBaj(), bascula_r(),
bascula_s(), pulso(), pulso_mem(), parpadeo(), retraso() y ctrlMotor(). En el
cdigo, delante de cada funcin, figura una pequea explicacin del
funcionamiento de cada una de ellas y de la forma de utilizarla dentro de nuestro
cdigo. A efectos de esta leccin, vamos a concentrarnos en el comienzo del
archivo con el cdigo de las dos primeras funciones, de sobra conocidas para
quien siga este curso puesto que las hemos utilizado en varias lecciones. El resto
de las funciones siguen un procedimiento de construccin similar.
paralelo.html
paralelo.html
Es importante observar que nuestro fichero, despus de los comentarios con la
informacin de la librera, contiene dos sentencias #include. Cuando utilizamos
una sentencia include, le estamos indicando al compilador que incluya en ese
punto el archivo correspondiente y lo compile con el resto de los ficheros fuente
que forman nuestro programa. Puesto que slo le indicamos el nombre del
archivo, el compilador entiende que lo tiene que buscar en el mismo directorio
donde se encuentra el archivo que lo est llamando (en nuestro caso la carpeta
Hubor que acabamos de crear y que es dnde est situado el archivo Hubor.ccp)
o en alguno de los directorios definidos por el compilador como lugares de
bsqueda por defecto.
Por lo tanto, con estas dos sentencias #include estamos diciendo al compilador
que incluya en este punto los ficheros 'Hubor.h' y 'Arduino.h'. el primero es el
fichero de cabecera que acabamos de crear para nuestra librera y el segundo
contiene una serie de definiciones utilizadas de forma estndar por el entorno de
programacin ARDUINO. En realidad, estas definiciones incluidas en el fichero
'Arduino.h' las hemos estado utilizando en todos nuestros proyectos hasta ahora.
Cuando creamos un programa en ARDUINO, el compilador enlaza a este fichero
por defecto de forma automtica para nosotros. Pero cuando construmos una
librera no lo hace y, por ese motivo, se lo tenemos que indicar expresamente.
El resto del fichero es el cdigo de todas las funciones, tal y como lo hubiermos
utilizado en cualquiera de nuestros proyectos.
A continuacin vamos a escribir el cdigo del fichero de cabecera 'Hubor.h'. Lo
podemos descargar desde el siguiente enlace: Fichero Hubor.h. Como ya dijimos
antes, contiene las definiciones para ayudar al compilador a utilizar la librera.
paralelo.html
En la lnea 15 utilizamos una sentencia #include como la que acabamos de ver en

el fichero Hubor.cpp para incluir el fichero con las definiciones estndar utilizadas
por el entorno ARDUINO.
En las lneas 17 a 19 definimos los operadores lgicos para su utilizacin en
nuestro cdigo.
En la linea 21 declaramos la estructura MotorDatosControl que ya vimos en
la Leccin 19 y que se utiliza en la funcin ctrlMotor() para intercambiar datos.
paralelo.html
Y, por ltimo, de las lneas 35 a la 45 se incluyen los prototipos de todas las
funciones includas en la librera. Un prototipo es una declaracin de una funcin
que se lleva a cabo con dos propsitos principales: evitar conversiones errneas
de valores (al definir el tipo de dato que utilizamos para cada parmetro pasado a
la funcin y el tipo de dato que devuelve la propia funcin) y evitar errores en el
nmero de argumentos pasados a la funcin.
Y ya tenemos todo listo para utilizar nuestra librera 'Hubor.h' en cualquier nuevo
proyecto. Vamos a crear el siguiente montaje:
paralelo.html
paralelo.html
Donde utilizaremos nuestro Arduino con cuatro entradas (tres pulsadores y un
interruptor) y siete salidas para gobernar otros tantos leds.
El cdigo de nuestro programa ser el siguiente:
paralelo.html
Observe que la manera de poder utilizar todas las funciones almacenadas en

nuestra librera no puede ser ms sencilla. Slo con utilizar en la lnea 10 la
sentencia #include correspondiente ya las tenemos todas disponibles.
El resto de cdigo ya no tiene que tener secretos a esta altura del curso. Primero
definimos las variables de trabajo que vamos a utilizar. Luego la configuracion de
los piines que vamos a usar como entradas y salidas en la funcin setup(). Por
ltimo el cdigo de trabajo que se repetir de forma cclica en la funcin loop().
En la primera parte leemos los valores de las entradas. En la segunda, utilizamos
las diferentes funciones de la librera. En la tercera, escribimos las salidas. Y en la
cuarta y ltima parte, usamos las funciones de tiempo chkTemp() e iniTemp() para
enviar informacin cada segundo al exterior. Como en este caso no utilizamos las
comunicaciones, hemos utilizado este espacio para cambiar de valor una variable
paralelo.html
llamada flag1 que utilizamos para encender y apagar cada segundo el led includo
en la placa base de ARDUINO y conectado al pin IO13.
Si ejecutamos nuestro proyecto podemos ver como funciona cada una de las
funciones de la librera. En este punto hay que hacer una salvedad importante.
Para que Proteus vuelva a leer todas las libreras disponibles en el directorio
'libreries' de la carpeta 'Arduino' en lugar de compilar nuestro proyecto como
siempre con la opcin 'construir proyecto', necesitaremos utilizar la opcin
'reconstruir el proyecto'. Una vez hecho esto la primera vez, ya podemos utilizar la
opcin 'construir proyecto' como siempre.
Veamos con detalle el uso de las funciones:

paralelo.html
flancoSub() detecta el flanco de subida al pulsar el botn arranque1. Ese pulso de

subida lo utilizamos para alimentar el set de la funcin bascula_r() y por lo tanto se
activa la salida1. Cuando actuemos sobre el interruptor parada1 que utilizamos
para alimentar el reset de la funcin bascula_r se desactiva la salida1.
flancoBaj() detecta el flanco de bajada al pulsar el botn arranque2. Ese pulso al
cesar la seal lo utilizamos para alimentar el set de la funcin bascula_s() y por lo
tanto se activa la salida2. Cuando actuemos sobre el interruptor parada1 que
utilizamos para alimentar el reset de la funcin bascula_s se desactiva la salidas.
La diferencia entre bascula_r() y bascula_s() es la dominancia del set o el reset en
caso de que ambas seales lleguen al mismo tiempo. Podemos comprobar su
funcionamiento diferente ejercitando con este ejemplo.
pulso() genera un pulso de duracin igual a 5000mseg cuando se recibe la seal
del pulsador arranque2 y lo muestra en la salida3.
pulso_mem() genera un pulso de duracin igual a 5000mseg cuando se recibe la
seal del pulsador arranque2 y lo muestra en la salida4.
La diferencia entre pulso() y pulso_mem() es que la primera interrumpe la salida si
cesa la seal de entrada mientras que la segunda memoriza la orden de entrada y
la sigue generando despus de cesar el disparador. Para interrumpir el pulso
antes de alcanzar el tiempo podemos utilizar el parmetro reset de la funcin (en
este caso parada1).
parpadeo() genera una intermitencia sobre la salida5 mientras est activa la
entrada arranque3.
Por ltimo, retraso() activa la salida6 1500mseg despus de que se produzca la
entrada3. Si la entrada cesa antes de que pasen los 1500mseg no se llegar a
generar la salida6.
Por supuesto, que el lector ya est en condiciones de construir la librera con las
funciones que l desee. Adems podr ir incorporando con el tiempo nuevas
funciones acumulando trabajo para el futuro.
Esperamos que esta leccion haya resultado interesante y que la utilizacin de
libreras sea una prctica habitual en los prximos proyectos.
paralelo.html
-- Tutorial de Arduino desde 0 -- Tutorial 20;

Grabar en la memoria interna (EEPROM) de
nuestro Arduino + cdigo puerta de acceso
En esta entrada, aprenderemos a guardar datos permanentes dentro de nuestro Arduino. Nos puede ser til si queremos
que permanezcan aunque se vaya la luz de ste.
Segn la pgina oficial de Arduino, Arduino Uno tiene una memoria EEPROM interna de 1KB
y ArduinoMega2560, una memoria de 4KB.
Yo he usado un Arduino Mega2560, aunque se podra usar un Arduino Uno aprovechando los pines analgicos.
Usaremos la librera EEPROM ( en todas las IDE de Arduino que he usado, vena incluida , no s si hay alguna IDE que
venga sin ella, en la IDE que yo uso, la 1.5.6-r2, viene incluida ).
Esta librera tiene dos funciones, read() y write(). Son muy fciles de usar as que se aprenden rpidamente.
EEPROM.read( posicin memoria);
EEPROM.write( posicin memoria , dato a escribir );
He creado a modo de ejemplo, un sistema para caja fuerte ( o una puerta con control de acceso) donde se pide un
password y se almacena en la EEPROM ( tambin se almacenan el nmero de intentos errneos). De esta forma, si se va
paralelo.html
la luz, ni el password ni el nmero de intentos fallidos, no se perdern nunca.
Un posible problema que podra haber, es que usamos anteriormente la memoria eeprom de nuestro Arduino y no quedase
limpia, por eso la limpiaremos con el siguiente cdigo:
?
1 #include <EEPROM.h>
3 void setup()
4 {
5 EEPROM.write(0, 0); // contador de intentos
EEPROM.write(1, 0); // 0 = primera vez que se introduce password. Si hay otro nu

6
dejaremos escribirlo de nuevo
7 // de la posicin 2 a la 5 la usaremos para guardar nuestros
8 }
10 void loop()
11 {
}
12
Descarga cdigo
Una vez limpia la memoria, cargaremos el nuevo cdigo de la puerta de acceso. Pero antes, explicar un poco qu lleva:
Sensor para detectar el estado de la puerta, cuando est cerrada, est a 1 . Pin 5.
Interruptor para cambiar el password, activo = 1. Pin 6.
Led color verde que representa el pistn de apertura. Pin 7.
Display 16x2. Pines: 8-13;
Teclado Matricial. Pines: 14-21.
Y aqu el cdigo para la puerta de acceso, cre una librera ( para ahorrar un poco de lineas de cdigo y as introducirnos
un poco en la programacin orientada a objetos). Bsicamente est todo implementado en dicha librera ( incluida ms
abajo )
?
paralelo.html
//GeekChickens
1
//http://geekchickens.blogspot.com.es/
2
3
#include <cajaFuerte.h>
4
#include <EEPROM.h>
5
#include <Keypad.h>
6
#include <LiquidCrystal.h>
7
8 // posicin 0 memoria -> contador de intentos
9 // posicin 1 memoria -> estar a 0 si es la primera vez que se introduce el passwor
10 // posicin 2 a la 5 -> password
11 cajaFuerte miCaja;
12
int sensorPuerta = 5;
13
int interruptorCambioPassword = 6;
14
int led_verde = 7;
15
int i = 0;
16
char passwordEntrado[4];
17
int tiempoEspera = 7; // en segundos!
18 int tiempoParaAbrir = 10; // el tiempo que dejamos de margen para que abran la puer
cerramos. Est en segundos!
19
20
void setup()
21
{
22
pinMode(led_verde,OUTPUT);
23
pinMode(sensorPuerta,INPUT);
24
pinMode(interruptorCambioPassword, INPUT);
paralelo.html
25 passwordPrimeraVez(); // la primera vez que se enciende Arduino y no tiene passwor
26 }
27
void loop()
28
{
29
mensajePassword();
30
31
if( EEPROM.read(0) <3 ) // si el contador de intentos est entre el 0 y el 2 q
32 probando.
33 {
i = leerTecla(passwordEntrado,i);
34
35
if(i == 4) // password lleno, son 4 dgitos
36
{
37
delay(800);
38
39
if( miCaja.comprobarPassword( passwordEntrado ) == 1) // Si el password fu
40
{
41 passwordCorrecto(led_verde, sensorPuerta, interruptorCambioPassword ,
42 i = 0;
43
44 }else
45 {
46 passwordIncorrecto(led_verde);
i = 0;
47
}
48
paralelo.html
49 limpiarLCD(i);
50 }
}
51
52
else // si el contador de intentos est lleno
53
{
54
demasiadosIntentos( tiempoEspera );
55
}
56
}
57
58
59
60
61
Descarga el cdigo con su librera aqu.
Recordad, tenis que guardar la librera en: carpeta de vuestro Arduino / libraries
El procedimiento es sencillo: Primero cargamos el sketch para limpiar nuestra memoria EEPROM y despus el sketch de
control de acceso. Entonces nos pedir que introduzcamos un password.
Una vez introducido dicho password, lo almacenar en la memoria EEPROM y ya no se borrar aunque apaguemos o
reiniciemos nuestro Arduino ( a menos que limpiemos la memoria EEPROM con el sketch mencionado anteriormente)
Vdeo del funcionamiento

paralelo.html
paralelo.html
USANDO EL MPU6050
Primeras pruebas con GY-201
Home Usando El MPU6050
OBJETIVOS
o Presentar los conceptos bsicos de los sistemas de medida inercial o IMUs.

o Plantear las nociones bsicas de sistemas de referencia.
o Acelermetros y girscopos.
o El MPU6050, Medida inercial de 6 grados de libertad.
MATERIAL REQUERIDO.
Arduino UNO o equivalente
Un mdulo MPU6050
paralelo.html
USANDO EL MPU6050
En la sesin anterior dimos un repasito a cuatro ideas claves de las que era preciso
asegranos que las tenamos claras, y as poder empezar a hablar directamente
de acelermetros y girscopos, y una vez sentadas las bases ya podemos empezar con la
parte divertida.
Es importante que entendis que los IMUs son unas piezas de hardware bastante
sofisticadas y que el MPU650 que vamos a utilizar es un chip de 6 dof o grados de libertad
porque incluye un acelermetro de 3 ejes y un girscopo de 3 ejes.
Aunque lo que miden lo sensores internos son aceleraciones lineales y angulares el

procesador interno del IMU es capaz de realizar clculos sobre la marcha para darnos
informaciones ms tiles como los ngulos de inclinacin con respecto a los 3 ejes principales.
Por eso todos los tutoriales que veis por ah os dirn que conseguir los datos en bruto
del MPU650 es la parte fcil, procesarlos y reaccionar es otra historia que se puede complicar
un poco ms.
Pero como siempre se dice un viaje de 1000 km empieza con un sencillo paso, as que vamos
a darlo. Empecemos viendo cmo se conecta a nuestro Arduino.
Para estas sesin vamos a utilizar una Breakout board bastante tpica llamada GY-201, que
incluye un MPU650 y un regulador de tensin, con lo que podemos alimentar a tanto 3.3V
como a 5V
ESQUEMA DE CONEXIN
EL MPU650 viene con interface I2C por lo que la conexin es trivial y podis hacerla poco ms
o menos as:
paralelo.html
Basta con conectar los pines de alimentacin y montar los pines necesarios para el control del
bus I2C. Cuando el IMU dispone de alguna medida se lo informa a nuestro Arduino mediante
una interrupcin y por eso conectamos el pin INT a nuestra primera interrupcin en el pin 2.
Si vas a usar un Arduino Mega la conexin es ligeramente diferente como se muestra aqu:
Poco ms porque la conexin es muy sencilla y basta con hacer la conexin del bus I2C.
Pasemos ahora a la parte del software.
paralelo.html
EL PROGRAMA DE CONTROL
Vamos a montar las libreras correspondientes y a probar con uno de los programas de
ejemplo que tanto las conexiones como el MPU650 estn en condiciones operativas.
El seor Jeff Rowberg ha puesto a nuestra disposicin una bonita librera que podemos
descargar desde aqu: MPU6050 y tambin vamos a necesitar una librera modifica de I2C
que se lleve bien con el IMU llamada I2Cdev.
Parece que el I2C del chip es un tanto peculiar a juzgar por lo que dicen por Internet la pgina
oficial de Arduino y algunos doctos comentaristas, y con aspectos delicados si necesitis
colocar ms elementos I2C al Bus.
Vamos a empezar cargando el ejemplo MPU6050_RAW:
\\Archivo\Ejemplos\MPU6050\Examples\ MPU6050_RAW
Y a continuacin asegurndonos de que la consola serie est a 38400 baudios, porque

los IMUs son muy charlatanes y mejor que nos aseguremos de que recibimos a suficiente
velocidad porque de lo contrario la informacin se amontonar en nuestra puerta.
paralelo.html
Este programa es de lo ms sencillo, y lo que hace es leer e imprimir los valores en bruto que
los acelermetros y girscopos le envan a tu Duino, es decir sin procesar en absoluto, algo
que sirve de muy poco, pero es un programa que si vais saltando las partes de egipcio antiguo
que contiene, encontrareis bastante comprensible, en lneas generales.
Si todo est bien, deberais ver una pantalla parecida a esta:
No te preocupes demasiado de estos valores, porque son las medidas reales que producen
los acelermetros y los girscopos, pero as no valen de mucho. El objetivo es asegurarnos
de que tu MPU6050 se comunica bien con tu Arduino.
De todos modos fjate en que hay 6 valores. Los tres primeros corresponden a
los acelermetros y los tres ltimos a los girscopos.(De ah el a/g: al principio de la lnea)
Si vas girando el IMU en direcciones perpendiculares vers con rapidez cual es cada uno de
los ejes, porque aunque el chip este en movimiento inercial (O sea en reposo o movimiento
lineal uniforme, Te suena del cole?) aun detectar la aceleracin de la gravedad, claramente
en una de las direcciones.
paralelo.html
Nosotros estamos tan acostumbrados a la gravedad que ni la notamos a no ser que nos
dejemos los morros contra el suelo de un tropezn, pero el MP6050 es un sensor y mide de
continuo su efecto, que es una aceleracin y mira qu casualidad, es justo lo que mide un
acelermetro).
Vale, todo muy bonito. Pero Cmo mido los ngulos respecto a la horizontal? Que es lo
que os interesa para aseguraros de que no nos estrellamos contra el pavimento.
Y de nuevo, por una de esas increbles casualidades de la vida, el segundo ejemplo trata de
eso
MIDIENDO NGULOS DE INCLINACIN
Vamos a cargar el segundo ejemplo que viene de demo con el MPU6050 que se llama DMP6:
\\Archivo\Ejemplos\MPU6050\Examples\ MPU6050_DMP6
Pero el autor quera comprobar que estabais despiertos y ha puesto el programa a 115200
baudios, a diferencia del ejemplo anterior, as que empezar cambiando la velocidad de la
consola Arduino en consonancia:
Si ahora volcis el programa a vuestro Arduino, os aparecer un mensaje con este:

paralelo.html
Donde como veis os pide que le enviis cualquier pulsacin ms intro para empezar el
programa.
Dadle cualquier cosa, y enseguida veris que empiezan a aparecer valores en la pantalla,
pero esperad un poco porque necesita como 10 segundos para que los valores se estabilicen
y tengan sentido:
El texto que aparece al principio de cada lnea ypr corresponde a las iniciales en ingles de
los tres ngulos de referencia Yaw, Pitch y Roll, que si recordis los presentamos con esta
imagen:
paralelo.html
Y los valores que van cambiando son poco ms o menos el valor instantneo de cada uno de
esos ngulos. Para tratar de dar un poco de sentido a es interminable flujo de valores tenemos
que hablar de la gravedad, (De la de Newton, no del estado de nuestras finanzas) y si alguno
pensabais que se puede manejar y programar un IMU sin hablar de fsica ms vale que os
vayis a la biblioteca a por un libro de poesa.
Recordad que lo que mide un acelermetro es una aceleracin en tres ejes y resulta que
nuestro acelermetro siempre est sometido al menos a una aceleracin presente por
doquier que llamamos gravedad y nuestro MPU6050 la detecta y mide permanentemente.
Lo cual es una gran ventaja porque como adems sabe que su valor en reposo es de 9,8
m/seg2 (Disfrutad que yo s que esto os encanta) en cuanto sus lecturas se estabilizan, l
sabe localizar el eje vertical porque es el que la gravedad le indica y por tanto ya tiene una
primera referencia del plano horizontal (El plano horizontal es perpendicular a la gravedad,
naturalmente)
Si el IMU dispone adems de un magnetmetro de 3 ejes, ya est en condiciones de apuntar

al Norte adems y puede fijar con precisin el segundo eje, y el tercero cae por su propio
peso, pero no es el caso del MPU6050 que estamos usando. .
Ahora aplica la famosa regla de los tres dedos que tanto disfrutamos en las entretenidas
clases de electromagnetismo entre otras:
Con el pulgar apuntado en la direccin de la gravedad o z, y poniendo los dedos ndice y

anular poco ms o menos a 90 entre s y con el eje z, nuestro sensor es capaz de utilizar
unas referencias primarias en tres ejes.
Por eso veris que si habis hecho como yo, y habis colocado vuestro sensor inercial poco
ms o menos horizontal, los ngulos de Pitch y Roll tendern rpidamente a cero como
corresponde a un IMU bien educado.
En cambio, el Angulo que a m me sale de 54 y a vosotros puede saliros cualquier cosa

Mide la desviacin con respecto a qu?
Pues no lo tengo muy claro. Supongo que es una referencia que el elige a huevo, o como se
dice ms elegantemente, es una referencia arbitraria. El IMU cuenta con una serie de
paralelo.html
mecanismos para elegir una referencia arbitraria en el arranque y despus podemos corregir
esas orientaciones, pero de momento no vale la pena complicarnos ms la vida.
En mi caso he montado el MPU6050 en una protoboard para poder mover con claridad el
sensor y por eso si ahora vais girando con cuidado la protoboard (O la plataforma de base)
veris como los ngulos van reflejando la desviacin respecto de la horizontal y con valores
que pueden ser tanto positivos como negativos.
COMENTARIOS FINALES
Bueno esto no ha pretendido ms que ser una introduccin al tema de acelermetros y

girscopos y tendremos tiempo para ir hablando ms sobre el asunto en futuras sesiones,
pero por ahora nos conviene comentar que los IMUs tienen sus historias.
En primer lugar no son demasiado estables y sus medidas bailan bastante por lo que ser
preciso filtrar los errores.
Adems son muy sensibles (Una mala combinacin) por lo que la medida que te dan, baila
mucho con cualquier golpecito o vibracin que detecten. Haz la prueba moviendo un poco la
plataforma y en seguida veras el baile de las cifras.
No se puede despreciar tampoco las interferencias, que como sabis afectan a todos los
aparatos electrnicos y los IMUs no son la excepcin.
Y por ltimo sufren tambin de un problema que se llama deriva (Shift en ingls) y que se
produce porque el procesador interno del IMU calcula las orientaciones, o si prefieres, los ejes
de referencia por clculo de aceleraciones, que por mucha precisin que se intente al final
tendrn pequeos errores que se irn acumulando.
Este error acumulado puede hacernos perder el norte (Literalmente) y acabar recogiendo
cachitos del asfalto para ver que podemos salvar del desastre.
Todo tiene solucin, pero supone clculos y procesamiento abundante, adems de nociones
de fsica, geometra y otras disciplinas que, aunque no os lo creis, no todos disfrutan.
Por ultimo si vais a montar algn robot volador de un cierto valor, no os interesa perder la
posibilidad de que vuestro chip incluya un magnetmetro de 3 ejes ms para localizar
direcciones absolutas de referencia y si el chisme va a volar, un sensor de presin baromtrica
no vendra mal tampoco para calcular la altitud.
Ya habis adivinado que hay cantidad de sensores de este estilo en el mercado y

simplemente os comentar que existe algn Breakout Board por ah 10 dof o grados de
libertad, como el GY-88 MPU-6050 HMC5883L 10 dof, que incluyen:
Un acelermetro de 3 ejes
Un Girscopo de tres ejes
Un magnetmetro de 3 ejes
paralelo.html
Un sensor baromtrico. .
Son algo ms caros que este MPU6050 con el que llevo aburrindoos ya buen rato, pero os
compensar la diferencia de precio.
RESUMEN DE LA SESIN
o Hicimos un primer acercamiento a los IMUs.

o Presentamos la forma de conectarlos a nuestros Arduinos.
o Presentamos un par de ejemplos de cmo leer valores en bruto y como medir ngulos sin
entrar en detalles.
o Presentamos el MPU650

Pantalla Gráfica LCD 128x64

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Pantalla Gráfica LCD 128x64

Uploaded by

Copyright:

Available Formats

http://www.arduinoecia.com.br/2013/09/display-grafico-lcd-128x64-st7920.

pantalla grfica LCD 128x64 - ST7920

El circuito utiliza un potencimetro (utilizado un 50K) para ajustar el contraste de la pantalla, y la

void u8g_Tela1 () // Pantalla 1 - Arduino y Co - rectngulos

void u8g_Tela2 () // Pantalla 2 - Estructura y Reloj

void u8g_Tela3 () // Pantalla 3 - caracteres ASCII - Pag. 1

void u8g_Tela4 () // Pantalla 3 - caracteres ASCII - Pag. 2

void u8g_Tela5 () // Pantalla 5 - Arduino y Co - rectngulo relleno

void u8g_Tela6 () // Pantalla 6 - Arduino y compaa a los 0, 90 y 270

void u8g_Tela7 () // Pantalla 7 - Diferentes tipos de letra

void draw () // Diseo de rutina

// Asignar valor de color por defecto

Pantalla LCD Grfica 12864 con ST7920

Datos del mdulo

rea visual: 72.0 x 40.0 mm.

Tamao del pxel: 0.48 x 0.48 mm.

Tensin de funcionamiento: 3.3v / 5.0v.

Tensin del funcionamiento del controlador del LCD: 3.0v 5.0v.

Temperatura de funcionamiento: -20C 70C.

Pin Significado Descripcin

Voltaje del driver

Tiene distintos propsitos si est trabajando en modo serie o

En modo paralelo indica el tipo de operacin (lectura/escritura). En

Data Bus 0 Data

BLA BackLight (+) Terminal positivo de la retroiluminacin (3.3v 5.0v).

BLK BackLight (-) Terminal negativo de la retroiluminacin.

Si tenemos variador de contraste en el reverso del LCD no hace falta

En modo paralelo es la seal de comienzo de actividad (lectura de

PSB 5v Seleccionando as el modo paralelo.

Biblioteca grfica LCD

Descargar : ks0108.zip (versin 2, con parches Teensy)

Esta copia incluye la asignacin de patillas por defecto para la placa

Teensy ++ 2.0 con 128x64 LCD de ejecutar el programa de

Teensy de LCD conexiones se documentan a continuacin .

unsigned long startMillis;

void drawSpinner(byte pos, byte x, byte y) {

void countdown(int count){

void loop(){ // run over and over again

Biblioteca grfica LCD

Descargar : ks0108.zip (versin 2, con parches Teensy)

Esta copia incluye la asignacin de patillas por defecto para la placa

Teensy ++ 2.0 con 128x64 LCD de ejecutar el programa de

Teensy de LCD conexiones se documentan a continuacin .

sin firmar largos startMillis;

void drawSpinner ( byte de la posicin, el byte x, bytes y) {

void cuenta atrs ( int count) {

void loop () { // ejecutar una y otra vez

Conexin de la pantalla LCD para Teensy

La pantalla requiere un potencimetro de ajuste de contraste. Un valor de

El pin de reset se debe conectar a +5 voltios. No es necesario para

Alternativamente, el pin de reset se puede conectar a cualquier pin no

Teensy 2.0 con 128x64 LCD de ejecutar el programa de ejemplo

Ha navegado por nuestra web hasta aqu: HuborArduino Programacin Curso de

Leccin 23: Control de un display LCD

[Proteus versin 8.2]

En segundo lugar, es importante tener en cuenta una cosa. La programacin de

Como vamos a utilizar la librera HUBOR que ya vimos en la leccin 22 y que

La lgica de funcionamiento es como sigue.

El resultado que se visualiza en nuestra pantalla es:

Cuando el contador vale 2 se ejecuta un bucle repetitivo con ayuda de la

Cuando el contador vale 4 ejecutamos la funcin GLCD.DrawVertLine() que se

Cuando el contador vale 5 ejecutamos la funcin GLCD.DrawHoriLine() que se

Cuando el contador vale 6 ejecutamos la funcin GLCD.DrawRect() que se

Cuando el contador vale 7 ejecutamos la funcin GLCD.DrawRoundRect() que se