0% found this document useful (0 votes)
33 views34 pages

6 Using Displays

This document provides instructions for connecting and using a text LCD display with Arduino. It explains that most common text LCD displays are compatible with the Hitachi HD44780 controller chip. It provides details on connecting the power, data, and control pins between the LCD and Arduino. The connections are shown in a figure and table. Instructions are given for using the LiquidCrystal library to interface with the LCD and display text. Taking care with the wiring is emphasized to avoid damaging the LCD.

Uploaded by

Adrian Jidveian
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
33 views34 pages

6 Using Displays

This document provides instructions for connecting and using a text LCD display with Arduino. It explains that most common text LCD displays are compatible with the Hitachi HD44780 controller chip. It provides details on connecting the power, data, and control pins between the LCD and Arduino. The connections are shown in a figure and table. Instructions are given for using the LiquidCrystal library to interface with the LCD and display text. Taking care with the wiring is emphasized to avoid damaging the LCD.

Uploaded by

Adrian Jidveian
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 34

CHAPTER 11

Using Displays

11.0 Introduction
/LTXLGFU\VWDOGLVSOD\V /&'V RIIHUDFRQYHQLHQWDQGLQH[SHQVLYHZD\WRSURYLGHDXVHU
LQWHUIDFHIRUDSURMHFW7KLVFKDSWHUH[SODLQVKRZWRFRQQHFWDQGXVHFRPPRQWH[WDQG
JUDSKLFDO/&'SDQHOVZLWK$UGXLQR%\IDUWKHPRVWSRSXODU/&'LVWKHWH[WSDQHO
EDVHGRQWKH+LWDFKL+'FKLS7KLVGLVSOD\VWZRRUIRXUOLQHVRIWH[WZLWKRU
FKDUDFWHUVSHUOLQH DQGFKDUDFWHUYHUVLRQVDUHDYDLODEOHEXWXVXDOO\DWPXFK
KLJKHUSULFHV $OLEUDU\IRUGULYLQJWH[W/&'GLVSOD\VLVSURYLGHGZLWK$UGXLQRDQG
\RX FDQ SULQW WH[W RQ \RXU /&' DV HDVLO\ DV RQ WKH 6HULDO 0RQLWRU VHH &KDSWHU 
EHFDXVH/&'DQGVHULDOVKDUHWKHVDPHXQGHUO\LQJprintIXQFWLRQV
/&'VFDQGRPRUHWKDQGLVSOD\VLPSOHWH[WZRUGVFDQEHVFUROOHGRUKLJKOLJKWHGDQG
\RXFDQGLVSOD\DVHOHFWLRQRIVSHFLDOV\PEROVDQGQRQ(QJOLVKFKDUDFWHUV
<RXFDQFUHDWH\RXURZQV\PEROVDQGEORFNJUDSKLFVZLWKDWH[W/&'EXWLI\RXZDQW
ILQHJUDSKLFDOGHWDLO\RXQHHGDJUDSKLFDOGLVSOD\*UDSKLFDO/&' */&' GLVSOD\V
DUHDYDLODEOHDWDVPDOOSULFHSUHPLXPRYHUWH[WGLVSOD\VDQGPDQ\SRSXODU*/&'
SDQHOVFDQGLVSOD\XSWRHLJKWOLQHVRIWH[WFKDUDFWHUVLQDGGLWLRQWRJUDSKLFV
/&'GLVSOD\VKDYHPRUHZLUHVFRQQHFWLQJWR$UGXLQRWKDQPRVWRWKHUUHFLSHVLQWKLV
ERRN,QFRUUHFWFRQQHFWLRQVDUHWKHPDMRUFDXVHRISUREOHPVZLWK/&'VVRWDNH\RXU
WLPHZLULQJWKLQJVXSDQGWULSOHFKHFNWKDWWKLQJVDUHFRQQHFWHGFRUUHFWO\$QLQH[
SHQVLYHPXOWLPHWHUFDSDEOHRIPHDVXULQJYROWDJHDQGUHVLVWDQFHLVDELJKHOSIRUYHUL
I\LQJWKDW\RXUZLULQJLVFRUUHFW,WFDQVDYH\RXDORWRIKHDGVFUDWFKLQJLIQRWKLQJLV
EHLQJGLVSOD\HG<RXGRQWQHHGDQ\WKLQJIDQF\DVHYHQWKHFKHDSHVWPXOWLPHWHUZLOO
KHOS\RXYHULI\WKDWWKHFRUUHFWSLQVDUHFRQQHFWHGDQGWKDWWKHYROWDJHVDUHFRUUHFW
<RXFDQHYHQILQGDYLGHRWXWRULDODQG3')H[SODLQLQJKRZWRXVHDPXOWLPHWHUDWKWWS
EORJPDNH]LQHFRPDUFKLYHPXOWLPHWHUBWXWRULDOBPDNHBKWPO
)RUSURMHFWVWKDWUHTXLUHDELJJHUGLVSOD\WKDQDYDLODEOHLQLQH[SHQVLYH/&'SDQHOV
5HFLSHVKRZVKRZ\RXFDQXVHDWHOHYLVLRQDVDQRXWSXWGHYLFHIRU$UGXLQR

333
11.1 Connecting and Using a Text LCD Display
Problem
<RXKDYHDWH[W/&'EDVHGRQWKHLQGXVWU\VWDQGDUG+'RUDFRPSDWLEOHFRQ
WUROOHUFKLSDQG\RXZDQWWRGLVSOD\WH[WDQGQXPHULFYDOXHV

Solution
7KH$UGXLQRVRIWZDUHLQFOXGHVWKH/LTXLG&U\VWDOOLEUDU\IRUGULYLQJ/&'GLVSOD\VEDVHG
RQWKH+'FKLS

0RVWWH[W/&'VVXSSOLHGIRUXVHZLWK$UGXLQRZLOOEHFRPSDWLEOHZLWK
WKH+LWDFKL+'FRQWUROOHU,I\RXDUHQRWVXUHDERXW\RXUFRQ
WUROOHUFKHFNWKHGDWDVKHHWWRVHHLILWLVDRUFRPSDWLEOH

7RJHWWKHGLVSOD\ZRUNLQJ\RXQHHGWRZLUHWKHSRZHUGDWDDQGFRQWUROSLQV&RQQHFW
WKHGDWDDQGVWDWXVOLQHVWRGLJLWDORXWSXWSLQVDQGZLUHXSDFRQWUDVWSRWHQWLRPHWHU
DQGFRQQHFWWKHSRZHUOLQHV,I\RXUGLVSOD\KDVDEDFNOLJKWWKLVQHHGVFRQQHFWLQJ
XVXDOO\WKURXJKDUHVLVWRU
)LJXUHVKRZVWKHPRVWFRPPRQ/&'FRQQHFWLRQV,WVLPSRUWDQWWRFKHFNWKH
GDWD VKHHW IRU \RXU /&' WR YHULI\ WKH SLQ FRQQHFWLRQV 7DEOH  VKRZV WKH PRVW
FRPPRQSLQFRQQHFWLRQVEXWLI\RXU/&'XVHVGLIIHUHQWSLQVPDNHVXUHLWLVFRPSDW
LEOHZLWKWKH+LWDFKL+'WKLVUHFLSHZLOORQO\ZRUNRQ/&'GLVSOD\VWKDWDUH
FRPSDWLEOH ZLWK WKDW FKLS 7KH /&' ZLOO KDYH  SLQV RU  SLQV LI WKHUH LV QR
EDFNOLJKW PDNHVXUH\RXLGHQWLI\SLQRQ\RXUSDQHOLWPD\EHLQDGLIIHUHQWSRVLWLRQ
WKDQVKRZQLQWKHILJXUH

<RXPD\ZRQGHUZK\/&'SLQVWKURXJKDUHQRWFRQQHFWHG7KH
/&'GLVSOD\FDQEHFRQQHFWHGXVLQJHLWKHUIRXUSLQVRUHLJKWSLQVIRU
GDWDWUDQVIHU7KLVUHFLSHXVHVWKHIRXUSLQPRGHEHFDXVHWKLVIUHHVXS
WKHRWKHUIRXU$UGXLQRSLQVIRURWKHUXVHV7KHUHLVDWKHRUHWLFDOSHU
IRUPDQFHLPSURYHPHQWXVLQJHLJKWSLQVEXWLWVLQVLJQLILFDQWDQGQRW
ZRUWKWKHORVVRIIRXU$UGXLQRSLQV

334 | Chapter 11: Using Displays


)LJXUH&RQQHFWLRQVIRUDWH[W/&'
7DEOH/&'SLQFRQQHFWLRQV
LCD pin Function Arduino pin
1 Gnd or 0V or Vss Gnd
2 +5V or Vdd 5V
3 Vo or contrast
4 RS 12
5 R/W
6 E 11
7 D0
8 D1
9 D2
10 D3
11 D4 5
12 D5 4
13 D6 3
14 D7 2
15 A or analog
16 K or cathode

11.1 Connecting and Using a Text LCD Display | 335


<RXZLOOQHHGWRFRQQHFWD.SRWHQWLRPHWHUWRSURYLGHWKHFRQWUDVWYROWDJHWR/&'
SLQ:LWKRXWWKHFRUUHFWYROWDJHRQWKLVSLQ\RXPD\QRWVHHDQ\WKLQJGLVSOD\HG,Q
)LJXUHRQHVLGHRIWKHSRWFRQQHFWVWR*QG JURXQG WKHRWKHUVLGHFRQQHFWVWR
$UGXLQR9DQGWKHFHQWHURIWKHSRWJRHVWR/&'SLQ7KH/&'LVSRZHUHGE\
FRQQHFWLQJ*QGDQG9IURP$UGXLQRWR/&'SLQVDQG
0DQ\/&'SDQHOVKDYHDQLQWHUQDOODPSFDOOHGDEDFNOLJKWWRLOOXPLQDWHWKHGLVSOD\
<RXUGDWDVKHHWVKRXOGLQGLFDWHZKHWKHUWKHUHLVDEDFNOLJKWDQGLILWUHTXLUHVDQH[WHUQDO
UHVLVWRUPDQ\GRQHHGWKLVWRSUHYHQWEXUQLQJRXWWKHEDFNOLJKW/('DVVHPEO\ LI\RX
DUHQRWVXUH\RXFDQEHVDIHE\XVLQJDRKPUHVLVWRU 7KHEDFNOLJKWLVSRODUL]HG
VRPDNHVXUHSLQLVFRQQHFWHGWR9DQGSLQWR*QG 7KHUHVLVWRULVVKRZQ
FRQQHFWHGEHWZHHQSLQDQG*QGEXWLWFDQDOVREHFRQQHFWHGEHWZHHQSLQDQG
9
'RXEOHFKHFNWKHZLULQJEHIRUH\RXDSSO\SRZHUDV\RXFDQGDPDJHWKH/&'LI\RX
FRQQHFW WKH SRZHU SLQV LQFRUUHFWO\ 7R UXQ WKH +HOOR:RUOG VNHWFK SURYLGHG ZLWK
$UGXLQR FOLFN WKH ,'( )LOHV PHQX LWHP DQG QDYLJDWH WR ([DP
SOHV /LEUDU\ /LTXLG&U\VWDO +HOOR:RUOG
7KHIROORZLQJFRGHLVPRGLILHGVOLJKWO\WRSULQWQXPEHUVLQDGGLWLRQWRKHOORZRUOG
&KDQJHnumRowsDQGnumColsWRPDWFKWKHURZVDQGFROXPQVLQ\RXU/&'
/*
LiquidCrystal Library - Hello World

Demonstrates the use of a 16 2 LCD display.


http://www.arduino.cc/en/Tutorial/LiquidCrystal
*/

#include <LiquidCrystal.h> // include the library code

//constants for the number of rows and columns in the LCD


const int numRows = 2;
const int numCols = 16;

// initialize the library with the numbers of the interface pins


LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup()
{
lcd.begin(numCols, numRows);
lcd.print("hello, world!"); // Print a message to the LCD.
}

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:

336 | Chapter 11: Using Displays


lcd.print(millis()/1000);
}

5XQWKHVNHWFK\RXVKRXOGVHHKHOORZRUOGGLVSOD\HGRQWKHILUVWOLQHRI\RXU/&'
7KHVHFRQGOLQHZLOOGLVSOD\DQXPEHUWKDWLQFUHDVHVE\RQHHYHU\VHFRQG

Discussion
,I\RXGRQWVHHDQ\WH[WDQG\RXKDYHGRXEOHFKHFNHGWKDWDOOZLUHVDUHFRQQHFWHG
FRUUHFWO\\RXPD\QHHGWRDGMXVWWKHFRQWUDVWSRW:LWKWKHSRWVKDIWURWDWHGWRRQH
VLGH XVXDOO\WKHVLGHFRQQHFWHGWR*QG \RXZLOOKDYHPD[LPXPFRQWUDVWDQGVKRXOG
VHHEORFNVDSSHDULQDOOWKHFKDUDFWHUSRVLWLRQV:LWKWKHSRWURWDWHGWRWKHRWKHUH[
WUHPH\RXSUREDEO\ZRQWVHHDQ\WKLQJDWDOO7KHFRUUHFWVHWWLQJZLOOGHSHQGRQPDQ\
IDFWRUVLQFOXGLQJYLHZLQJDQJOHDQGWHPSHUDWXUHWXUQWKHSRWXQWLO\RXJHWWKHEHVW
ORRNLQJGLVSOD\
,I\RXFDQWVHHEORFNVRISL[HOVDSSHDUDWDQ\VHWWLQJRIWKHSRWFKHFNWKDWWKH/&'LV
EHLQJGULYHQRQWKHFRUUHFWSLQV
2QFH\RXFDQVHHWH[WRQWKHVFUHHQXVLQJWKH/&'LQDVNHWFKLVHDV\<RXXVHVLPLODU
SULQW FRPPDQGV WR WKRVH IRU VHULDO SULQWLQJ FRYHUHG LQ &KDSWHU  7KH QH[W UHFLSH
UHYLHZVWKHSULQWFRPPDQGVDQGH[SODLQVKRZWRFRQWUROWH[WSRVLWLRQ

See Also
/LTXLG&U\VWDOUHIHUHQFHKWWSDUGXLQRFFHQ5HIHUHQFH/LTXLG&U\VWDO3ULQW
6HH&KDSWHUIRUGHWDLOVRQprintFRPPDQGV
7KHGDWDVKHHWIRUWKH+LWDFKL+'/&'FRQWUROOHULVWKHGHILQLWLYHUHIHUHQFHIRU
GHWDLOHGORZOHYHOIXQFWLRQDOLW\7KH$UGXLQROLEUDU\LQVXODWHV\RXIURPPRVWRIWKH
FRPSOH[LW\EXWLI\RXZDQWWRUHDGDERXWWKHUDZFDSDELOLWLHVRIWKHFKLS\RXFDQ
GRZQORDG WKH GDWD VKHHW IURP KWWSZZZVSDUNIXQFRPGDWDVKHHWV/&'+'
SGI
7KH/&'SDJHLQWKH$UGXLQR3OD\JURXQGFRQWDLQVVRIWZDUHDQGKDUGZDUHWLSVDQG
OLQNVKWWSZZZDUGXLQRFFSOD\JURXQG&RGH/&'

11.2 Formatting Text


Problem
<RXZDQWWRFRQWUROWKHSRVLWLRQRIWH[WGLVSOD\HGRQWKH/&'VFUHHQIRUH[DPSOHWR
GLVSOD\YDOXHVLQVSHFLILFSRVLWLRQV

11.2 Formatting Text | 337


Solution
7KLVVNHWFKGLVSOD\VDFRXQWGRZQIURPWR,WWKHQGLVSOD\VDVHTXHQFHRIGLJLWVLQ
WKUHHFROXPQVRIIRXUFKDUDFWHUV&KDQJHnumRowsDQGnumColsWRPDWFKWKHURZVDQG
FROXPQVLQ\RXU/&'
/*
LiquidCrystal Library - FormatText
*/

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

//constants for the number of rows and columns in the LCD


const int numRows = 2;
const int numCols = 16;
Download from Wow! eBook <www.wowebook.com>

int count;

// initialize the library with the numbers of the interface pins


LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup()
{
lcd.begin(numCols, numRows);
lcd.print("Starting in "); // this string is 12 characters long
for(int i=9; i > 0; i--) // count down from 9
{
// the top line is row 0
lcd.setCursor(12,0); // move the cursor to the end of the string
printed above
lcd.print(i);
delay(1000);
}
}

void loop()
{
int columnWidth = 4; //spacing for the columns
int displayColumns = 3; //how many columns of numbers

lcd.clear();
for( int col=0; col < displayColumns; col++)
{
lcd.setCursor(col * columnWidth, 0);
count = count+ 1;
lcd.print(count);
}
delay(1000);
}

338 | Chapter 11: Using Displays


Discussion
7KHlcd.printIXQFWLRQVDUHVLPLODUWRSerial.print,QDGGLWLRQWKH/&'OLEUDU\KDV
FRPPDQGVWKDWFRQWUROWKHFXUVRUORFDWLRQ WKHURZDQGFROXPQZKHUHWH[WZLOOEH
SULQWHG 
7KHlcd.printVWDWHPHQWGLVSOD\VHDFKQHZFKDUDFWHUDIWHUWKHSUHYLRXVRQH7H[WSULQ
WHGEH\RQGWKHHQGRIDOLQHPD\QRWEHGLVSOD\HGRUPD\EHGLVSOD\HGRQDQRWKHUOLQH
7KH lcd.setCursor()FRPPDQGHQDEOHV\RXWRVSHFLI\ZKHUHWKHQH[W lcd.printZLOO
VWDUW<RXVSHFLI\WKHFROXPQDQGURZSRVLWLRQ WKHWRSOHIWFRUQHULV 2QFHWKH
FXUVRULVSRVLWLRQHGWKHQH[Wlcd.printZLOOVWDUWIURPWKDWSRLQWDQGLWZLOORYHUZULWH
H[LVWLQJWH[W7KHVNHWFKLQWKLVUHFLSHV6ROXWLRQXVHVWKLVWRSULQWQXPEHUVLQIL[HG
ORFDWLRQV
)RUH[DPSOHLQsetup
lcd.setCursor(12,0); // move the cursor to the 13th position
lcd.print(i);

lcd.setCursor(12,0) HQVXUHV WKDW HDFK QXPEHU LV SULQWHG LQ WKH VDPH SRVLWLRQ WKH
WKLUWHHQWKFROXPQILUVWURZSURGXFLQJWKHGLJLWVKRZQDWDIL[HGSRVLWLRQUDWKHUWKDQ
HDFKQXPEHUEHLQJGLVSOD\HGDIWHUWKHSUHYLRXVQXPEHU

5RZV DQG FROXPQV VWDUW IURP ]HUR VR setCursor(4,0) ZRXOG VHW WKH
FXUVRUWRWKHILIWKFROXPQRQWKHILUVWURZ7KLVLVEHFDXVHWKHUHDUHILYH
FKDUDFWHUVORFDWHGLQSRVLWLRQVWKURXJK,IWKDWLVQRWFOHDULWPD\
KHOS\RXLI\RXFRXQWWKLVRXWRQ\RXUILQJHUVVWDUWLQJIURP]HUR

7KH IROORZLQJ OLQHV XVH setCursor WR VSDFH RXW WKH VWDUW RI HDFK FROXPQ WR SURYLGH
columnwidthVSDFHVIURPWKHVWDUWRIWKHSUHYLRXVFROXPQ
lcd.setCursor(col * columnWidth, 0);
count = count+ 1;
lcd.print(count);
lcd.clear();

lcd.clearFOHDUVWKHVFUHHQDQGPRYHVWKHFXUVRUEDFNWRWKHWRSOHIWFRUQHU
+HUH LV D YDULDWLRQ RQ loop WKDW GLVSOD\V QXPEHUV XVLQJ DOO WKH URZV RI \RXU /&'
5HSODFH\RXU loopFRGHZLWKWKHIROORZLQJ PDNHVXUH\RXVHWnumRowsDQG numColsDW
WKHWRSRIWKHVNHWFKWRPDWFKWKHURZVDQGFROXPQVLQ\RXU/&' 
void loop()
{
int columnWidth = 4;
int displayColumns = 3;

lcd.clear();
for(int row=0; row < numRows; row++)
{
for( int col=0; col < displayColumns; col++)

11.2 Formatting Text | 339


{
lcd.setCursor(col * columnWidth, row);
count = count+ 1;
lcd.print(count);
}
}
delay(1000);
}

7KH ILUVW for ORRS VWHSV WKURXJK WKH DYDLODEOH URZV DQG WKH VHFRQG for ORRS VWHSV
WKURXJKWKHFROXPQV
7R DGMXVW KRZ PDQ\ QXPEHUV DUH GLVSOD\HG LQ D URZ WR ILW WKH /&' FDOFXODWH WKH
displayColumnsYDOXHUDWKHUWKDQVHWWLQJLW&KDQJH
int displayColumns = 3;

WR
int displayColumns = numCols / columnWidth;

See Also
7KH/LTXLG&U\VWDOOLEUDU\WXWRULDOKWWSDUGXLQRFFHQ5HIHUHQFH/LTXLG&U\VWDO"IURP
7XWRULDO/&'/LEUDU\

11.3 Turning the Cursor and Display On or Off


Problem
<RXZDQWWREOLQNWKHFXUVRUDQGWXUQWKHGLVSOD\RQRURII<RXPD\DOVRZDQWWRGUDZ
DWWHQWLRQWRDVSHFLILFDUHDRIWKHGLVSOD\

Solution
7KLVVNHWFKVKRZVKRZ\RXFDQFDXVHWKHFXUVRU DIODVKLQJEORFNDWWKHSRVLWLRQZKHUH
WKHQH[WFKDUDFWHUZLOOEHGLVSOD\HG WREOLQN,WDOVRLOOXVWUDWHVKRZWRWXUQWKHGLVSOD\
RQDQGRIIIRUH[DPSOHWRGUDZDWWHQWLRQE\EOLQNLQJWKHHQWLUHGLVSOD\
/*
blink
*/

// include the library code:


#include <LiquidCrystal.h>

// initialize the library with the numbers of the interface pins


LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup()
{
// set up the LCD's number of columns and rows and:
lcd.begin(16, 2);

340 | Chapter 11: Using Displays


// Print a message to the LCD.
lcd.print("hello, world!");
}

void loop()
{
lcd.setCursor(0, 1);

lcd.print("cursor blink");
lcd.blink();
delay(2000);

lcd.noBlink();
lcd.print(" noBlink");
delay(2000);

lcd.clear();

lcd.print("Display off ...");


delay(1000);
lcd.noDisplay();
delay(2000);

lcd.display(); // turn the display back on

lcd.setCursor(0, 0);
lcd.print(" display flash !");
displayBlink(2, 250); // blink twice
displayBlink(2, 500); // and again for twice as long

lcd.clear();
}

void displayBlink(int blinks, int duration)


{
while(blinks--)
{
lcd.noDisplay();
delay(duration);
lcd.display();
delay(duration);
}
}

Discussion
7KHVNHWFKFDOOVblinkDQGnoBlinkIXQFWLRQVWRWRJJOHFXUVRUEOLQNLQJRQDQGRII
7KHFRGHWREOLQNWKHHQWLUHGLVSOD\LVLQDIXQFWLRQQDPHG displayBlinkWKDWPDNHV
WKHGLVSOD\IODVKDVSHFLILHGQXPEHURIWLPHV7KHIXQFWLRQXVHV lcd.display()DQG
lcd.noDisplay()WRWXUQWKHGLVSOD\WH[WRQDQGRII ZLWKRXWFOHDULQJLWIURPWKHVFUHHQV
LQWHUQDOPHPRU\ 

11.3 Turning the Cursor and Display On or Off | 341


11.4 Scrolling Text
Problem
<RXZDQWWRVFUROOWH[WIRUH[DPSOHWRFUHDWHDPDUTXHHWKDWGLVSOD\VPRUHFKDUDFWHUV
WKDQFDQILWRQRQHOLQHRIWKH/&'GLVSOD\

Solution
7KLVVNHWFKGHPRQVWUDWHVERWKlcd.ScrollDisplayLeftDQGlcd.ScrollDisplayRight
,WVFUROOVDOLQHRIWH[WWRWKHOHIWZKHQWLOWHGDQGWRWKHULJKWZKHQQRWWLOWHG&RQQHFW
RQHVLGHRIDWLOWVHQVRUWRSLQDQGWKHRWKHUSLQWR*QG VHH5HFLSHLI\RXDUHQRW
IDPLOLDUZLWKWLOWVHQVRUV 
/*
Scroll
* this sketch scrolls text left when tilted
* text scrolls right when not tilted.
*/

#include <LiquidCrystal.h>

// initialize the library with the numbers of the interface pins


LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
const int numRows = 2;
const int numCols = 16;

const int tiltPin = 7; // pin connected to tilt sensor

const char textString[] = "tilt to scroll";


const int textLen = sizeof(textString) -1; // the number of characters
boolean isTilted = false;

void setup()
{
// set up the LCD's number of columns and rows:
lcd.begin(numCols, numRows);
digitalWrite(tiltPin, HIGH); // turn on pull-ups for the tilt sensor
lcd.print(textString);
}

void loop()
{
if(digitalRead(tiltPin) == LOW && isTilted == false )
{
// here if tilted left so scroll text left
isTilted = true;
for (int position = 0; position < textLen; position++)
{
lcd.scrollDisplayLeft();
delay(150);
}

342 | Chapter 11: Using Displays


}
if(digitalRead(tiltPin) == HIGH && isTilted == true )
{
// here if previously tilted but now flat, so scroll text right
isTilted = false;
for (int position = 0; position < textLen; position++)
{
lcd.scrollDisplayRight();
delay(150);
}
}
}

Discussion
7KHILUVWKDOIRIWKH loopFRGHKDQGOHVWKHFKDQJHIURPQRWWLOWHGWRWLOWHG7KHFRGH
FKHFNVWRVHHLIWKHWLOWVZLWFKLVFORVHG LOW RURSHQ HIGH ,ILWVLOWDQGWKHFXUUHQW
VWDWH VWRUHGLQWKHisTiltedYDULDEOH LVQRWWLOWHGWKHWH[WLVVFUROOHGOHIW7KHGHOD\LQ
WKHforORRSFRQWUROVWKHVSHHGRIWKHVFUROODGMXVWWKHGHOD\LIWKHWH[WPRYHVWRRIDVW
RUWRRVORZ
7KHVHFRQGKDOIRIWKHFRGHXVHVVLPLODUORJLFWRKDQGOHWKHFKDQJHIURPWLOWHGWRQRW
WLOWHG
$VFUROOLQJFDSDELOLW\LVSDUWLFXODUO\XVHIXOZKHQ\RXQHHGWRGLVSOD\PRUHWH[WWKDQ
FDQILWRQDQ/&'OLQH
7KLVVNHWFKKDVDmarqueeIXQFWLRQWKDWZLOOVFUROOWH[WXSWRFKDUDFWHUVLQOHQJWK
/*
Marquee
* this sketch scrolls a long line of text
*/

#include <LiquidCrystal.h>

// initialize the library with the numbers of the interface pins


LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
const int numRows = 2;
const int numCols = 16;

void setup()
{
// set up the LCD's number of columns and rows:
lcd.begin(numCols, numRows);
}

void loop()
{
marquee("A message too long to fit !");
delay(1000);
lcd.clear();
}

11.4 Scrolling Text | 343


// this function uses scrolling to display a message up to 32 bytes long
void marquee( char *text)
{
int length = strlen(text); // the number of characters in the text
if(length < numCols)
lcd.print(text);
else
{
int pos;
for( pos = 0; pos < numCols; pos++)
lcd.print(text[pos]);
delay(1000); // allow time to read the first line before scrolling
while(pos < length)
{
lcd.scrollDisplayLeft();
lcd.print(text[pos]);
pos = pos + 1;
delay(300);
}
}
}

7KHVNHWFKXVHVWKHlcd.scrollDisplayLeftIXQFWLRQWRVFUROOWKHGLVSOD\ZKHQWKHWH[W
LVORQJHUWKDQWKHZLGWKRIWKHVFUHHQ
7KH/&'FKLSKDVLQWHUQDOPHPRU\WKDWVWRUHVWKHWH[W7KLVPHPRU\LVOLPLWHG 
E\WHVRQPRVWIRXUOLQHGLVSOD\V ,I\RXWU\WRXVHORQJHUPHVVDJHVWKH\PD\VWDUWWR
ZUDSRYHUWKHPVHOYHV,I\RXZDQWWRVFUROOORQJHUPHVVDJHV HJDWZHHW RUFRQWURO
VFUROOLQJPRUHSUHFLVHO\\RXQHHGDGLIIHUHQWWHFKQLTXH7KHIROORZLQJIXQFWLRQVWRUHV
WKHWH[WLQ5$0RQ$UGXLQRDQGVHQGVVHFWLRQVWRWKHVFUHHQWRFUHDWHWKHVFUROOLQJ
HIIHFW7KHVHPHVVDJHVFDQEHDQ\OHQJWKWKDWFDQILWLQWR$UGXLQRPHPRU\
// this version of marquee uses manual scrolling for very long messages
void marquee( char *text)
{
int length = strlen(text); // the number of characters in the text
if(length < numCols)
lcd.print(text);
else
{
int pos;
for( pos = 0; pos < numCols; pos++)
lcd.print(text[pos]);
delay(1000); // allow time to read the first line before scrolling
while(pos <= length - numCols)
{
lcd.setCursor(0,0);
for( int i=0; i < numCols; i++)
lcd.print(text[pos+i]);
delay(300);
pos = pos + 1;
}

344 | Chapter 11: Using Displays


}
}

11.5 Displaying Special Symbols


Problem
<RXZDQWWRGLVSOD\VSHFLDOV\PEROV GHJUHHV  SL RUDQ\RWKHUV\PEROVWRUHG
LQWKH/&'FKDUDFWHUPHPRU\

Solution
,GHQWLI\WKHFKDUDFWHUFRGH\RXZDQWWRGLVSOD\E\ORFDWLQJWKHV\PEROLQWKHFKDUDFWHU
SDWWHUQ WDEOH LQ WKH /&' GDWD VKHHW 7KLV VNHWFK SULQWV VRPH FRPPRQ V\PEROV LQ
setup,WWKHQVKRZVDOOGLVSOD\DEOHV\PEROVLQloop
/*
LiquidCrystal Library - Special Chars
*/

#include <LiquidCrystal.h>

//set constants for number of rows and columns to match your LCD
const int numRows = 2;
const int numCols = 16;

// defines for some useful symbols


const byte degreeSymbol = B11011111;
const byte piSymbol = B11110111;
const byte centsSymbol = B11101100;
const byte sqrtSymbol = B11101000;
const byte omegaSymbol = B11110100; // the symbol used for ohms

byte charCode = 32; // the first printable ascii character


int col;
int row;

// initialize the library with the numbers of the interface pins


LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup()
{
lcd.begin(numRows, numCols);

showSymbol(degreeSymbol, "degrees");
showSymbol (piSymbol, "pi");
showSymbol(centsSymbol, "cents");
showSymbol(sqrtSymbol, "sqrt");
showSymbol(omegaSymbol, "ohms");
lcd.clear();

11.5 Displaying Special Symbols | 345


void loop()
{
lcd.print(charCode);
calculatePosition();
if(charCode == 255)
{
// finished all characters so wait another few seconds and start over
delay(2000);
lcd.clear();
row = col = 0;
charCode = 32;
}
charCode = charCode + 1;
}

void calculatePosition()
{
col = col + 1;
if( col == numCols)
{
col = 0;
row = row + 1;
if( row == numRows)
{
row = 0;
delay(2000); // pause
lcd.clear();
}
lcd.setCursor(col, row);
}
}

// function to display a symbol and its description


void showSymbol( byte symbol, char * description)
{
lcd.clear();
lcd.print(symbol);
lcd.print(' '); // add a space before the description
lcd.print(description);
delay(3000);
}

Discussion
$WDEOHVKRZLQJWKHDYDLODEOHFKDUDFWHUSDWWHUQVLVLQWKHGDWDVKHHWIRUWKH/&'FRQ
WUROOHUFKLS \RXFDQILQGLWRQSDJHRIWKHGDWDVKHHWDWKWWSZZZVSDUNIXQFRP
GDWDVKHHWV/&'+'SGI 
7RXVHWKHWDEOHORFDWHWKHV\PERO\RXZDQWWRGLVSOD\7KHFRGHIRUWKDWFKDUDFWHULV
GHWHUPLQHGE\FRPELQLQJWKHELQDU\YDOXHVIRUWKHFROXPQDQGURZIRUWKHGHVLUHG
V\PERO VHH)LJXUH 

346 | Chapter 11: Using Displays


)LJXUH8VLQJGDWDVKHHWWRGHULYHFKDUDFWHUFRGHV
)RUH[DPSOHWKHGHJUHHV\PEROLVWKHWKLUGIURPODVWHQWU\DWWKHERWWRPURZRIWKH
WDEOHVKRZQLQ)LJXUH,WVFROXPQLQGLFDWHVWKHXSSHUIRXUELWVDUHDQGLWV
URZLQGLFDWHVWKHORZHUIRXUELWVDUH&RPELQLQJWKHVHJLYHVWKHFRGHIRUWKLV
V\PERO % <RX FDQ XVH WKLV ELQDU\ YDOXH RU FRQYHUW WKLV WR LWV KH[ YDOXH
[') RUGHFLPDOYDOXH  1RWHWKDW)LJXUHVKRZVRQO\RIWKHDFWXDO
URZVLQWKHGDWDVKHHW
7KH/&'VFUHHQFDQDOVRVKRZDQ\RIWKHGLVSOD\DEOH$6&,,FKDUDFWHUVE\XVLQJWKH
$6&,,YDOXHLQlcd.print
7KHVNHWFKXVHVDIXQFWLRQQDPHGshowSymbolWRSULQWWKHV\PERODQGLWVGHVFULSWLRQ
void showSymbol( byte symbol, char * description)

6HH5HFLSHLI\RXQHHGDUHIUHVKHURQXVLQJFKDUDFWHUVWULQJVDQGSDVVLQJWKHPWR
IXQFWLRQV

See Also
'DWD VKHHW IRU +LWDFKL +' GLVSOD\ KWWSZZZVSDUNIXQFRPGDWDVKHHWV/&'
+'SGI

11.6 Creating Custom Characters


Problem
<RXZDQWWRGHILQHDQGGLVSOD\FKDUDFWHUVRUV\PEROV JO\SKV WKDW\RXKDYHFUHDWHG
7KHV\PEROV\RXZDQWDUHQRWSUHGHILQHGLQWKH/&'FKDUDFWHUPHPRU\

11.6 Creating Custom Characters | 347


Solution
8SORDGLQJWKHIROORZLQJFRGHZLOOFUHDWHDQDQLPDWLRQRIDIDFHVZLWFKLQJEHWZHHQ
VPLOLQJDQGIURZQLQJ
/*
custom_char sketch
creates an animated face using custom characters
*/

#include <LiquidCrystal.h>
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

byte happy[8] =
{
B00000,
B10001,
B00000,
B00000,
B10001,
B01110,
B00000,
B00000
};

byte saddy[8] =
{
B00000,
B10001,
B00000,
B00000,
B01110,
B10001,
B00000,
B00000
};

void setup() {
lcd.createChar(0, happy);
lcd.createChar(1, saddy);
lcd.begin(16, 2);

void loop() {
for (int i=0; i<2; i++)
{
lcd.setCursor(0,0);
lcd.write(i);
delay(500);
}
}

348 | Chapter 11: Using Displays


Discussion
7KH/LTXLG&U\VWDOOLEUDU\HQDEOHV\RXWRFUHDWHXSWRHLJKWFXVWRPFKDUDFWHUVZKLFK
FDQEHSULQWHGDVFKDUDFWHUFRGHVWKURXJK(DFKFKDUDFWHURQWKHVFUHHQLVGUDZQ
RQDJULGRISL[HOV7RGHILQHDFKDUDFWHU\RXQHHGWRFUHDWHDQDUUD\RIHLJKW
E\WHV(DFKE\WHGHILQHVRQHRIWKHURZVLQWKHFKDUDFWHU:KHQZULWWHQDVDELQDU\
QXPEHUWKHLQGLFDWHVDSL[HOLVRQLVRII DQ\YDOXHVDIWHUWKHILIWKELWDUHLJQRUHG 
7KHVNHWFKH[DPSOHFUHDWHVWZRFKDUDFWHUVQDPHGhappyDQGsaddy VHH)LJXUH 

)LJXUH'HILQLQJFXVWRPFKDUDFWHUV

7KHIROORZLQJOLQHLQsetupFUHDWHVWKHFKDUDFWHUXVLQJGDWDGHILQHGLQWKHhappyDUUD\
WKDWLVDVVLJQHGWRFKDUDFWHU
lcd.createChar(0, happy);

7RSULQWWKHFXVWRPFKDUDFWHUWRWKHVFUHHQ\RXZRXOGXVHWKLVOLQH
lcd.write(0);

1RWH WKH GLIIHUHQFH EHWZHHQ ZULWLQJ D FKDUDFWHU ZLWK RU ZLWKRXW DQ


DSRVWURSKH7KHIROORZLQJZLOOSULQWD]HURQRWWKHKDSS\V\PERO
lcd.write('0'); // this prints a zero

&RGH LQ WKH for ORRS VZLWFKHV EHWZHHQ FKDUDFWHU  DQG FKDUDFWHU  WR SURGXFH DQ
DQLPDWLRQ

11.7 Displaying Symbols Larger Than a Single Character


Problem
<RXZDQWWRFRPELQHWZRRUPRUHFXVWRPFKDUDFWHUVWRSULQWV\PEROVODUJHUWKDQD
VLQJOHFKDUDFWHUIRUH[DPSOHGRXEOHKHLJKWQXPEHUVRQWKHVFUHHQ

11.7 Displaying Symbols Larger Than a Single Character | 349


Solution
7KHIROORZLQJVNHWFKZULWHVGRXEOHKHLJKWQXPEHUVXVLQJFXVWRPFKDUDFWHUV
/*
* customChars
*
* This sketch displays double-height digits
* the bigDigit arrays were inspired by Arduino forum member dcb
*/

#include <LiquidCrystal.h>

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

byte glyphs[5][8] = {
{ B11111,B11111,B00000,B00000,B00000,B00000,B00000,B00000 } ,
{ B00000,B00000,B00000,B00000,B00000,B00000,B11111,B11111 } ,
{ B11111,B11111,B00000,B00000,B00000,B00000,B11111,B11111 } ,
{ B11111,B11111,B11111,B11111,B11111,B11111,B11111,B11111 } ,
{ B00000,B00000,B00000,B00000,B00000,B01110,B01110,B01110 } };

const int digitWidth = 3; // the width in characters of a big digit (excludes


space between characters)
//arrays to index into custom characters that will comprise the big numbers
// digits 0 - 4 0 1 2 3 4
const char bigDigitsTop[10][digitWidth]={ 3,0,3, 0,3,32, 2,2,3, 0,2,3, 3,1,3,
// digits 5-9 5 6 7 8 9
3,2,2, 3,2,2, 0,0,3, 3,2,3, 3,2,3};

const char bigDigitsBot[10][ digitWidth]={ 3,1,3, 1,3,1, 3,1,1, 1,1,3, 32,32,3,


1,1,3, 3,1,3, 32,32,3, 3,1,3, 1,1,3};

char buffer[12]; // used to convert a number into a string

void setup ()
{
lcd.begin(20,4);
// create the custom glyphs
for(int i=0; i < 5; i++)
lcd.createChar(i, glyphs[i]); // create the 5 custom glyphs

// show a countdown timer


for(int digit = 9; digit >= 0; digit--)
{
showDigit(digit, 2); // show the digit
delay(1000);
}
lcd.clear();
}

350 | Chapter 11: Using Displays


void loop ()
{
// now show the number of seconds since the sketch started
int number = millis() / 1000;
showNumber( number, 0);
delay(1000);
}

void showDigit(int digit, int position)


{
lcd.setCursor(position * (digitWidth + 1), 0);
for(int i=0; i < digitWidth; i++)
lcd.print(bigDigitsTop[digit][i]);
lcd.setCursor(position * (digitWidth + 1), 1);
for(int i=0; i < digitWidth; i++)
lcd.print(bigDigitsBot[digit][i]);
}

void showNumber(int value, int position)


{
int index; // index to the digit being printed, 0 is the leftmost digit

itoa(value, buffer, 10); // see Recipe 2.8 for more on using itoa
// dislay each digit in sequence
for(index = 0; index < 10; index++) // display up to ten digits
{
char c = buffer[index];
if( c == 0) // check for null (not the same as '0')
return; // the end of string character is a null, see Chapter 2
c = c - 48; // convert ascii value to a numeric value (see Recipe 2.9)
showDigit(c, position + index);
}
}

Discussion
7KH/&'GLVSOD\KDVIL[HGVL]HFKDUDFWHUVEXW\RXFDQFUHDWHODUJHUV\PEROVE\FRP
ELQLQJFKDUDFWHUV7KLVUHFLSHFUHDWHVILYHFXVWRPFKDUDFWHUVXVLQJWKHWHFKQLTXHGH
VFULEHGLQ5HFLSH7KHVHV\PEROV VHH)LJXUH FDQEHFRPELQHGWRFUHDWH
GRXEOHVL]HGGLJLWV VHH)LJXUH 7KHVNHWFKGLVSOD\VDFRXQWGRZQIURPWRRQ
WKH/&'XVLQJWKHELJGLJLWV,WWKHQGLVSOD\VWKHQXPEHURIVHFRQGVVLQFHWKHVNHWFK
VWDUWHG
7KH glyphsDUUD\GHILQHVSL[HOVIRUWKHILYHFXVWRPFKDUDFWHUV7KHDUUD\KDVWZRGL
PHQVLRQVJLYHQLQWKHVTXDUHEUDFNHWV
byte glyphs[5][8] = {

[5]LVWKHQXPEHURIJO\SKVDQG[8]LVWKHQXPEHURIURZVLQHDFKJO\SK(DFKHOHPHQW
FRQWDLQVVDQGVWRLQGLFDWHZKHWKHUDSL[HOLVRQRURIILQWKDWURZ,I\RXFRPSDUH

11.7 Displaying Symbols Larger Than a Single Character | 351


)LJXUH&XVWRPFKDUDFWHUVXVHGWRIRUPELJGLJLWV

)LJXUH7HQELJGLJLWVFRPSRVHGRIFXVWRPJO\SKV
WKHYDOXHVLQglyph[0] WKHILUVWJO\SK ZLWK)LJXUH\RXFDQVHHWKDWWKHVFRUUH
VSRQGWRGDUNSL[HOV
{ B11111,B11111,B00000,B00000,B00000,B00000,B00000,B00000 } ,

(DFKELJQXPEHULVEXLOWIURPVL[RIWKHVHJO\SKVWKUHHIRUPLQJWKHXSSHUKDOIRIWKH
ELJGLJLWDQGWKUHHIRUPLQJWKHORZHUKDOI bigDigitsTopDQG bigDigitsBotDUHDUUD\V
GHILQLQJZKLFKFXVWRPJO\SKLVXVHGIRUWKHWRSDQGERWWRPURZVRQWKH/&'VFUHHQ

See Also
6HH&KDSWHUIRULQIRUPDWLRQRQVHJPHQW/('GLVSOD\VLI\RXQHHGUHDOO\ELJQX
PHUDOV1RWHWKDWVHJPHQWGLVSOD\VFDQJLYH\RXGLJLWVL]HVIURPRQHKDOILQFKWRWZR
LQFKHVRUPRUH7KH\FDQXVHPXFKPRUHSRZHUWKDQ/&'GLVSOD\VDQGGRQWSUHVHQW
OHWWHUVDQGV\PEROVYHU\ZHOOEXWWKH\DUHDJRRGFKRLFHLI\RXQHHGVRPHWKLQJELJ

11.8 Displaying Pixels Smaller Than a Single Character


Problem
<RXZDQWWRGLVSOD\LQIRUPDWLRQZLWKILQHUUHVROXWLRQWKDQDQLQGLYLGXDOFKDUDFWHUIRU
H[DPSOHWRGLVSOD\DEDUFKDUW

352 | Chapter 11: Using Displays


Solution
5HFLSHGHVFULEHVKRZWREXLOGELJV\PEROVFRPSRVHGRIPRUHWKDQRQHFKDUDFWHU
7KLVUHFLSHXVHVFXVWRPFKDUDFWHUVWRGRWKHRSSRVLWHLWFUHDWHVHLJKWVPDOOV\PEROV
HDFKDVLQJOHSL[HOKLJKHUWKDQWKHSUHYLRXVRQH VHH)LJXUH 

)LJXUH(LJKWFXVWRPFKDUDFWHUVXVHGWRIRUPYHUWLFDOEDUV

7KHVHV\PEROVDUHXVHGWRGUDZEDUFKDUWVDVVKRZQLQWKHVNHWFKWKDWIROORZV
/*
* customCharPixels
*/

#include <LiquidCrystal.h>

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

//set constants for number of rows and columns to match your LCD
const int numRows = 2;
const int numCols = 16;

// array of bits defining pixels for 8 custom characters


// ones and zeros indicate if a pixel is on or off

byte glyphs[8][8] = {
{B00000,B00000,B00000,B00000,B00000,B00000,B00000,B11111}, // 0
{B00000,B00000,B00000,B00000,B00000,B00000,B11111,B11111}, // 1
{B00000,B00000,B00000,B00000,B00000,B11111,B11111,B11111}, // 2
{B00000,B00000,B00000,B00000,B11111,B11111,B11111,B11111}, // 3
{B00000,B00000,B00000,B11111,B11111,B11111,B11111,B11111}, // 4
{B00000,B00000,B11111,B11111,B11111,B11111,B11111,B11111}, // 5
{B00000,B11111,B11111,B11111,B11111,B11111,B11111,B11111}, // 6
{B11111,B11111,B11111,B11111,B11111,B11111,B11111,B11111}}; // 7

void setup ()
{
lcd.begin(numCols, numRows);
for(int i=0; i < 8; i++)
lcd.createChar(i, glyphs[i]); // create the custom glyphs
lcd.clear();
}

11.8 Displaying Pixels Smaller Than a Single Character | 353


void loop ()
{
for( byte i=0; i < 8; i++)
lcd.print(i); // show all eight single height bars
delay(2000);
lcd.clear();
}

Discussion
7KHVNHWFKFUHDWHVHLJKWFKDUDFWHUVHDFKDVLQJOHSL[HOKLJKHUWKDQWKHSUHYLRXVRQH
VHH)LJXUH7KHVHDUHGLVSOD\HGLQVHTXHQFHRQWKHWRSURZRIWKH/&'7KHVH
EDUFKDUWFKDUDFWHUVFDQEHXVHGWRGLVSOD\YDOXHVLQ\RXUVNHWFKWKDWFDQEHPDSSHG
WRDUDQJHIURPWR)RUH[DPSOHWKHIROORZLQJZLOOGLVSOD\DYDOXHUHDGIURPDQDORJ
LQSXW
int value = analogRead(0);
byte glyph = map(value, 0, 1023,0,8);// returns a proportional value
from 0 through 7
lcd.print(glyph);

<RXFDQVWDFNWKHEDUVIRUJUHDWHUUHVROXWLRQ7KHdoubleHeightBarsIXQFWLRQVKRZQLQ
WKHIROORZLQJFRGHGLVSOD\VDYDOXHIURPWRZLWKDUHVROXWLRQRISL[HOVXVLQJ
WZROLQHVRIWKHGLVSOD\
void doubleHeightBars(int value, int column)
{
char upperGlyph;
char lowerGlyph;

if(value < 8)
{
upperGlyph = ' '; // no pixels lit
lowerGlyph = value;
}
else
{
upperGlyph = value - 8;
lowerGlyph = 7; // all pixels lit
}

lcd.setCursor(column, 0); // do the upper half


lcd.print(upperGlyph);
lcd.setCursor(column, 1); // now to the lower half
lcd.print(lowerGlyph);
}

7KHdoubleHeightBarsIXQFWLRQFDQEHXVHGDVIROORZVWRGLVSOD\WKHYDOXHRIDQDQDORJ
LQSXW
for( int i=0; i < 16; i++)
{

354 | Chapter 11: Using Displays


int value = analogRead(0);
value = map(value, 0, 1023,0,16);
doubleHeightBars(value, i); // show a value from 0 to 15
delay(1000); // one second interval between readings
}

,I\RXZDQWKRUL]RQWDOEDUV\RXFDQGHILQHILYHFKDUDFWHUVHDFKDVLQJOHSL[HOZLGHU
WKDQWKHSUHYLRXVRQHDQGXVHVLPLODUORJLFWRWKHYHUWLFDOEDUVWRFDOFXODWHWKHFKDUDFWHU
WRVKRZ
$PRUHFRPSOH[H[DPSOHRIWKLVWHFKQLTXHFDQEHIRXQGLQDVNHWFKLPSOHPHQWLQJWKH
ZHOONQRZQFRPSXWHUVLPXODWLRQNQRZQDV-RKQ&RQZD\V*DPHRI/LIH7KHVNHWFK
FDQEHGRZQORDGHGIURPWKLVERRNVZHEVLWH

11.9 Connecting and Using a Graphical LCD Display


Problem
<RXZDQWWRGLVSOD\JUDSKLFVDQGWH[WRQDQ/&'WKDWXVHVWKH.6RUFRPSDWLEOH
/&'GULYHUFKLS

Solution
7KLV6ROXWLRQXVHVWKH$UGXLQR*/&'OLEUDU\WRFRQWUROWKHGLVSOD\<RXFDQGRZQORDG
LWIURPKWWSZZZDUGXLQRFFSOD\JURXQG&RGH*/&'NV VHH&KDSWHULI\RX
QHHGKHOSLQVWDOOLQJOLEUDULHV 

7KHUHDUHPDQ\GLIIHUHQWW\SHVRI*/&'FRQWUROOHUVVRFKHFNWKDW\RXUV
LVD.6RUFRPSDWLEOH

7KHSLQFRQQHFWLRQVIRU*/&'GLVSOD\VDUHQRWVWDQGDUGL]HGDQGLWLVLPSRUWDQWWR
FKHFNWKHGDWDVKHHWIRU\RXUSDQHOWRFRQILUPKRZLWVKRXOGEHZLUHG,QFRUUHFWFRQ
QHFWLRQVRIWKHVLJQDOOLQHVDUHWKHPRVWFRPPRQFDXVHRISUREOHPVDQGSDUWLFXODUFDUH
VKRXOGEHWDNHQZLWKWKHSRZHUOHDGVDVZLULQJWKHVHLQFRUUHFWO\FDQGHVWUR\DSDQHO
0RVW*/&'SDQHOVUHTXLUHDQH[WHUQDOYDULDEOHUHVLVWRUWRVHWWKH/&'ZRUNLQJYROWDJH
FRQWUDVW DQGPD\UHTXLUHDIL[HGUHVLVWRUWROLPLWWKHFXUUHQWLQWKHEDFNOLJKW7KH
GDWDVKHHWIRU\RXUSDQHOVKRXOGSURYLGHVSHFLILFLQIRUPDWLRQRQWKHZLULQJDQGFKRLFH
RIFRPSRQHQWVIRUWKLV

11.9 Connecting and Using a Graphical LCD Display | 355


7DEOHLQGLFDWHVWKHGHIDXOWFRQQHFWLRQVIURPD.6SDQHOWRDQ$UGXLQR RU
0HJD <RXZLOOQHHGWRFKHFNWKHGRFXPHQWDWLRQIRU\RXUSDUWLFXODUSDQHOWRILQG
ZKHUH HDFK IXQFWLRQ LV FRQQHFWHG RQ \RXU GLVSOD\ 7KH WDEOH VKRZV WKH WKUHH PRVW
FRPPRQSDQHOOD\RXWVWKHILUVWODEHOHG3DQHO$LQWKHWDEOHLVWKHRQHLOOXVWUDWHG
LQ)LJXUH7KHGRFXPHQWDWLRQZLWKWKH*/&'OLEUDU\GRZQORDGLQFOXGHVFRORU
ZLULQJGLDJUDPVIRUWKHPRUHFRPPRQGLVSOD\V
7DEOH'HIDXOWFRQQHFWLRQVIURPD.6SDQHOWRDQ$UGXLQRRU0HJD
Arduino pins Mega pins GLCD function Panel A Panel B Panel C Comments
5V 5V +5 volts 1 2 13
Gnd Gnd Gnd 2 1 14
N/A N/A Contrast in 3 3 12 Wiper of contrast pot
8 22 D0 4 7 1
9 23 D1 5 8 2
10 24 D2 6 9 3
11 25 D3 7 10 4
4 26 D4 8 11 5
5 27 D5 9 12 6
6 28 D6 10 13 7
7 29 D7 11 14 8
14 (analog 0) 33 CSEL1 12 15 15 Chip 1 select
15 (analog 1) 34 CSEL2 13 16 16 Chip 2 select
Reset Reset 14 17 18 Connect to reset
16 (analog 2) 35 R_W 15 5 10 Read/write
17 (analog 3) 36 D_I 16 4 11 Data/instruction (RS)
18 (analog 4) 37 EN 17 6 9 Enable
N/A N/A Contrast out 18 18 17 10K or 20K preset
N/A N/A Backlight +5 19 19 19 See data sheet
Gnd Gnd Backlight Gnd 20 20 20 See data sheet

7KHQXPEHUVXQGHUWKH$UGXLQRDQG0HJDFROXPQVDUHWKH$UGXLQR RU0HJD SLQV


XVHGLQWKHFRQILJXUDWLRQILOHSURYLGHGLQWKHOLEUDU\,WLVSRVVLEOHWRXVHRWKHUSLQVLI
WKHVH SLQV FRQIOLFW ZLWK VRPHWKLQJ HOVH \RX ZDQW WR FRQQHFW ,I \RX GR FKDQJH WKH
FRQQHFWLRQV\RXZLOODOVRQHHGWRFKDQJHWKHSLQDVVLJQPHQWVLQWKHFRQILJXUDWLRQILOH
DQGVKRXOGVWXG\WKHOLEUDU\GRFXPHQWDWLRQWROHDUQKRZWRHGLWWKHFRQILJXUDWLRQILOH

356 | Chapter 11: Using Displays


Download from Wow! eBook <www.wowebook.com>

)LJXUH*/&'ZLULQJIRUW\SH$SDQHOVFKHFN\RXUGDWDVKHHWIRUSLQRXW

:LULQJWKHSDQHOXVLQJWKHGHIDXOWFRQILJXUDWLRQDQGUXQQLQJWKHVNHWFK
LQWKLVUHFLSHHQDEOHV\RXWRWHVWWKDWHYHU\WKLQJLVZRUNLQJEHIRUH\RX
PRGLI\WKHFRQILJXUDWLRQ$FRQILJXUDWLRQWKDWGRHVQRWPDWFKWKHZLU
LQJLVWKHPRVWFRPPRQVRXUFHRISUREOHPVVRWHVWLQJZLWKPLQLPDO
FKDQJHVPDNHVLWPRUHOLNHO\WKDWWKLQJVZLOOZRUNWKHILUVWWLPH

7KHIROORZLQJVNHWFKSULQWVVRPHWH[WDQGWKHQGUDZVVRPHJUDSKLFDOREMHFWV
/*
glcd
*/

#include <glcd.h>

#include "fonts/allFonts.h" // this makes all the distributed fonts


available to your sketch

int count = 0;

void setup()
{
GLCD.Init(NON_INVERTED); // initialize the library
GLCD.ClearScreen();
GLCD.SelectFont(System5x7); // select fixed width system font
GLCD.print("hello world"); // print a message
delay(3000);
}

11.9 Connecting and Using a Graphical LCD Display | 357


void loop()
{

GLCD.ClearScreen();
GLCD.DrawRect(0, 0, 64, 61, BLACK); // rectangle in left side of screen
// rounded rectangle around text area
GLCD.DrawRoundRect(68, 0, 58, 61, 5, BLACK);
for(int i=0; i < 62; i += 4)
{
// draw lines from upper left down right side of rectangle
GLCD.DrawLine(1,1,63,i, BLACK);
}
GLCD.DrawCircle(32,31,30,BLACK); // circle centered on left side of screen
GLCD.FillRect(92,40,16,16, WHITE); // clear previous spinner position
GLCD.CursorTo(5,5); // locate cursor for printing text
GLCD.PrintNumber(count); // print a number at current cursor position
count = count + 1;
delay(1000);
}

Discussion
7KHOLEUDU\SURYLGHVDZLGHUDQJHRIEDVLFKLJKOHYHOJUDSKLFDOGUDZLQJIXQFWLRQVVRPH
RIZKLFKDUHGHPRQVWUDWHGLQWKLVVNHWFK$OOWKHIXQFWLRQVDUHGHVFULEHGLQWKHGRFX
PHQWDWLRQSURYLGHGZLWKWKHOLEUDU\
*UDSKLFDQGWH[WVFUHHQFRRUGLQDWHVVWDUWDWLQWKHWRSOHIWKDQGFRUQHU0RVWSRS
XODU*/&'SDQHOVDUHSL[HOVDQGWKHOLEUDU\XVHVWKLVUHVROXWLRQE\GHIDXOW
,I\RXUVFUHHQLVDGLIIHUHQWUHVROXWLRQ\RXZLOOQHHGWRHGLWWKHFRQILJXUDWLRQILOHLQWKH
OLEUDU\WRPDWFK\RXUSDQHO XSWRSL[HOSDQHOVDUHFXUUHQWO\VXSSRUWHG 
*/&'HQDEOHVSULQWLQJWH[WWRWKHVFUHHQXVLQJVWDWHPHQWVVLPLODUWR$UGXLQRSULQW
FRPPDQGVXVHGIRUSULQWLQJWRWKHVHULDOSRUW,QDGGLWLRQ\RXFDQVSHFLI\WKHW\SHDQG
VL]HRIIRQW<RXFDQDOVRVSHFLI\DQDUHDRIWKHVFUHHQWKDWFDQEHXVHGDVDWH[WZLQGRZ
7KLVHQDEOHV\RXWRGHILQHDQDUHDRQWKHVFUHHQDQGWKHQVHQGWH[WWRWKDWDUHDSUR
YLGLQJ\RXZLWKDYLUWXDOWHUPLQDOWKDWZLOOFRQWDLQDQGVFUROOWH[WZLWKLQWKHERXQGV
\RXGHILQH)RULQVWDQFHWKHIROORZLQJFRGHFUHDWHVDQDUHDSL[HOVVTXDUHLQWKH
FHQWHURIWKHVFUHHQ
gText myTextArea = gText(GLCD.CenterX-16, GLCD.CenterY -16, GLCD.CenterX +16,
GLCD.CenterY+16);

<RXFDQVHOHFWDIRQWDQGSULQWWRWKHWH[WDUHDXVLQJFRGHVXFKDVWKHIROORZLQJ
myTextArea.SelectFont(System5x7); // select the system font for the text area
name textTop
myTextArea.println("Go"); // print a line of text to the text area.

7KHH[DPSOHVNHWFKVXSSOLHGZLWKWKHOLEUDU\GRZQORDGKDVDGHPRWKDWVKRZVKRZ
PXOWLSOHWH[WDUHDVFDQEHXVHGDORQJZLWKJUDSKLFDOGUDZLQJV

358 | Chapter 11: Using Displays


7KHVHJUDSKLFDOGLVSOD\VKDYHPDQ\PRUHFRQQHFWLRQVWKDQWKHWH[W/&'GLVSOD\VDQG
FDUHVKRXOGEHWDNHQWRHQVXUHWKDW\RXUSDQHOLVFRQQHFWHGFRUUHFWO\
,IWKHUHDUHQRSL[HOVYLVLEOHRQWKHGLVSOD\RUWKHSL[HOVDUHJDUEOHGGRWKHIROORZLQJ
&KHFN9DQG*QGFRQQHFWLRQVEHWZHHQ$UGXLQRDQGWKH*/&'SDQHO
&KHFNWKDWDOOGDWDDQGFRPPDQGSLQVDUHZLUHGDFFRUGLQJWRWKHGDWDVKHHWDQG
PDWFKWKHFRQILJXUDWLRQVHWWLQJV7KLVLVWKHPRVWFRPPRQFXUHIRUWKLVSUREOHP
&KHFNWKHGDWDVKHHWIRU\RXUSDQHOWRYHULI\WKDWDSSURSULDWHWLPLQJYDOXHVDUHVHW
LQWKHFRQILJXUDWLRQILOH
&KHFNWKHFRQWUDVWYROWDJH W\SLFDOO\EHWZHHQDQGYROWV RQWKHFRQWUDVWLQ
SLQRIWKH/&'SDQHO:KLOHWKHVNHWFKLVRSHUDWLQJWU\JUDGXDOO\DGMXVWLQJWKH
SRWWKURXJKLWVUDQJH6RPHGLVSOD\VDUHYHU\VHQVLWLYHWRWKLVVHWWLQJ
&KHFNWKDWWKHVNHWFKKDVFRPSLOHGFRUUHFWO\DQGKDVGRZQORDGHGWR$UGXLQR
5XQ WKH */&'GLDJV WHVW VNHWFK 7KH WHVW VNHWFK LV DYDLODEOH IURP WKH PHQX
([DPSOHV */&' */&'GLDJV
,IWKHOHIWDQGULJKWVLGHVRIWKHLPDJHDUHUHYHUVHGVZDSWKH&6(/DQG&6(/ZLUHV
\RXFDQDOVRVZDSSLQDVVLJQPHQWVLQWKHFRQILJXUDWLRQILOH 

11.10 Creating Bitmaps for Use with a Graphical Display


Problem
<RXZDQWWRFUHDWHDQGXVH\RXURZQJUDSKLFDOLPDJHV ELWPDSV ZLWKWKH*/&'GLV
SOD\GLVFXVVHGLQ5HFLSH<RXZDQWWKHIRQWGHILQLWLRQDQGWH[WVWRUHGLQSURJUDP
PHPRU\WRPLQLPL]H5$0XVDJH

Solution
<RXFDQXVHELWPDSVGLVWULEXWHGZLWKWKHOLEUDU\RUFUHDWH\RXURZQ%LWPDSVDUHGH
ILQHG LQ KHDGHU ILOHV ZLWK DQ H[WHQVLRQ RI K IRU H[DPSOH DQ $UGXLQR LFRQ LPDJH
QDPHG$UGXLQL,FRQKLVVWRUHGLQWKHELWPDSIROGHURIWKH*/&'OLEUDU\GLUHFWRU\7KLV
IROGHU DOVR FRQWDLQV D ILOH QDPHG DOO%LWPDSVK WKDW KDV GHWDLOV RI DOO WKH GLVWULEXWHG
ELWPDSVVR\RXFDQLQFOXGHWKLVWRPDNHDOOWKHVXSSOLHG RUQHZO\FUHDWHG ELWPDSV
DYDLODEOH
#include "bitmaps/allBitmaps.h" // this line includes all distributed bitmaps

1RWHWKDWLQFOXGLQJDOOWKHELWPDSVZLOOQRWFRQVXPHDQ\PHPRU\LIWKH\DUHQRWH[
SOLFLWO\UHIHUHQFHGLQ\RXUVNHWFKZLWKWKHDrawBitmapIXQFWLRQ
7RHQDEOH\RXWRDGG\RXURZQELWPDSVWKH*/&'OLEUDU\LQFOXGHVDXWLOLW\FDOOHG
JOFG0DNH%LWPDSZKLFKFRQYHUWVDJLIMSJEPSWJDRUSQJILOHWRDKHDGHUILOHWKDW
FDQEHXVHGE\WKH*/&'OLEUDU\7KHILOHJOFG0DNH%LWPDSSGHLVD3URFHVVLQJVNHWFK
WKDWFDQEHUXQXVLQJWKH3URFHVVLQJHQYLURQPHQW7KHVNHWFKLVORFDWHGLQWKHELWPDSV

11.10 Creating Bitmaps for Use with a Graphical Display | 359


XWLOVJOFG0DNH%LWPDSGLUHFWRU\)RUPRUHLQIRUPDWLRQRQ3URFHVVLQJVHHKWWSSURFHVV
LQJRUJ
7KHUHLVDOVRDMDYD -DYD UXQWLPHILOH JOFG0DNH%LWPDSMDU DQGDMDYD -DYD VRXUFH
JOFG0DNH%LWPDSMDYD LQWKHELWPDSVXWLOV-DYDGLUHFWRU\
5XQWKHXWLOLW\E\ORDGLQJWKHVNHWFKLQWR3URFHVVLQJ RUFOLFNRQWKHMDUILOH DQGGUDJ
DQGGURSWKHLPDJHILOHWREHFRQYHUWHGLQWRWKHZLQGRZ7KHXWLOLW\ZLOOFUHDWHDKHDGHU
ILOHZLWKWKHVDPHQDPHDVWKHLPDJHILOHGURSSHGLQWRWKHZLQGRZ7KHILOHLVVDYHGLQ
WKHELWPDSVGLUHFWRU\DQGDQHQWU\LVDXWRPDWLFDOO\DGGHGWRWKHDOO%LW0DSVKILOHVR
WKDWWKHQHZLPDJHFDQEHXVHGLQ\RXUVNHWFK
7R GHPRQVWUDWH WKLV UHQDPH DQ LPDJH RQ \RXU FRPSXWHU DV PHMSJ 7KHQ UXQ
JOFG0DNH%LWPDSDQGGURSWKHLPDJHLQWRWKHZLQGRZWKDWDSSHDUV
&RPSLOHDQGXSORDGWKHIROORZLQJVNHWFKWRVKRZWKHVXSSOLHG$UGXLQRLFRQIROORZHG
E\WKHLPDJH\RXFUHDWHG
/*
* GLCDImage
* Display an image defined in me.h
*/

#include <glcd.h>

#include "bitmaps/allBitmaps.h" // all images in the bitmap folder

void setup()
{
GLCD.Init(); // initialize the library
GLCD.ClearScreen();
GLCD.DrawBitmap(ArduinoIcon, 0,0); //draw the supplied bitmap
delay(5000);
GLCD.ClearScreen();
GLCD.DrawBitmap(me, 0,0); //draw your bitmap
}

void loop()
{

7KHIROORZLQJOLQHGUDZVWKHLPDJHGHILQHGLQWKHILOH$UGXLQR,FRQKWKDWLVVXSSOLHG
ZLWKWKHOLEUDU\
GLCD.DrawBitmap(ArduinoIcon, 0,0); //draw the supplied bitmap

$IWHUDGHOD\WKHIROORZLQJOLQHGUDZVWKHLPDJH\RXFUHDWHGWKDWLVVWRUHGLQWKHILOH
PHK
GLCD.DrawBitmap(me, 0,0);

360 | Chapter 11: Using Displays


See Also
6HHWKHGRFXPHQWDWLRQVXSSOLHGZLWKWKHOLEUDU\IRUPRUHRQFUHDWLQJDQGXVLQJJUDSK
LFDOLPDJHV
7KHGRFXPHQWDWLRQDOVRGHVFULEHVKRZ\RXFDQFUHDWH\RXURZQIRQWV

11.11 Displaying Text on a TV


Problem
<RXZDQWWRGLVSOD\WH[WRQDWHOHYLVLRQRUPRQLWRUZLWKDYLGHRLQSXW

Solution
7KLVUHFLSHXVHVDVKLHOGFDOOHG7HOO\0DWHWRSULQWWH[WRUEORFNJUDSKLFVWRDWHOHYLVLRQ
7KHVKLHOGSOXJVLQWR$UGXLQRDQGKDVDQRXWSXWMDFNWKDWFRQQHFWVWRWKHYLGHRLQSXW
RIDWHOHYLVLRQ
7KHVNHWFKSULQWVDOOWKHFKDUDFWHUVWKH7HOO\0DWHFDQGLVSOD\RQD79VFUHHQ
/*
TellyMate
Simple demo for TellMmate Shield
*/

const byte ESC = 0x1B; // ASCII escape character used in TellyMate commands

void setup()
{
Serial.begin(57600); //57k6 baud is default TellyMate speed
clear(); // clear the screen
Serial.print(" TellyMate Character Set"); // write some text
delay(2000);
}

void loop()
{

byte charCode = 32; // characters 0 through 31 are control codes


for(int row=0; row < 7; row++) // show 7 rows
{
setCursor(2, row + 8); // center the display
for(int col= 0; col < 32; col++) // 32 characters per row
{
Serial.print(charCode);
charCode = charCode + 1;
delay(20);
}
}
delay(5000);
clear();

11.11 Displaying Text on a TV | 361


}

// TellyMate helper functions

void clear( ) // clear the screen


{ // <ESC>E
Serial.print(ESC);
Serial.print('E');
}

void setCursor( int col, int row) // set the cursor


{ // <ESC>Yrc
Serial.print(ESC);
Serial.print('Y' ) ;
Serial.print((unsigned char)(32 + row)) ;
Serial.print((unsigned char)(32 + col)) ;
}

Discussion
$UGXLQRFRQWUROVWKH7HOO\0DWHGLVSOD\E\VHQGLQJFRPPDQGVWRWKHVHULDOSRUW

7HOO\0DWHFRPPXQLFDWHVZLWKWKH$UGXLQRWKURXJKWKHVHULDOSRUWVR
\RXPD\QHHGWRXQSOXJWKHVKLHOGWRXSORDGVNHWFKHV

)LJXUHVKRZVWKHFKDUDFWHUVWKDWFDQEHGLVSOD\HG<RXFDQILQGDWDEOHRIYDOXHV
IRUHDFKFKDUDFWHUDWKWWSHQZLNLSHGLDRUJZLNL&RGHBSDJHB

)LJXUH7HOO\0DWHFKDUDFWHUVHW FRGHSDJH

&KDUDFWHUVWKURXJKDUHLQWHUSUHWHGDVVFUHHQFRQWUROFRPPDQGV
VRRQO\FKDUDFWHUVWRFDQEHGLVSOD\HG

362 | Chapter 11: Using Displays


7KHVNHWFKXVHVQRQSULQWDEOHFRGHVFDOOHGHVFDSHFRGHVWRGLIIHUHQWLDWHSULQWDEOHFKDU
DFWHUVIURPFRPPDQGVWRFRQWUROWKHVFUHHQ&RQWUROFRGHVFRQVLVWRIWKH(6& VKRUW
IRUHVFDSH FKDUDFWHU KH[YDOXH[E IROORZHGE\RQHRUPRUHFKDUDFWHUVLQGLFDWLQJ
WKHQDWXUHRIWKHFRQWUROIXQFWLRQ'HWDLOVRIDOOWKHFRQWUROFRGHVDUHFRYHUHGLQWKH
7HOO\0DWHGRFXPHQWDWLRQ
7KHVNHWFKKDVDQXPEHURIKHOSHUIXQFWLRQVWKDWVHQGWKHDSSURSULDWHVHTXHQFHRI
FKDUDFWHUVWRDFKLHYHWKHGHVLUHGUHVXOWVHQDEOLQJ\RXWRFRQFHQWUDWHRQWKHKLJKHUOHYHO
DFWLYLW\RIWKHVNHWFKZKDW\RXZDQWLWWRGRUDWKHUWKDQWKHGHWDLOVRIKRZLWZLOO
GRLW
7KH VFUHHQ ZLOO VKRZ D IODVKLQJ FXUVRU \RX FDQ WXUQ WKLV RII XVLQJ D FRQWURO FRGH
$GGLQJWKHcursorHideIXQFWLRQZLOOWXUQRIIWKHFXUVRUZKHQWKHIXQFWLRQLVFDOOHG
void cursorHide()
{ // <ESC>f
Serial.print(ESC) ; // the escape character
Serial.print('f' ) ; // ... followed by the letter f will turn off the cursor.
}

7RDGGDER[DURXQGWKHHGJHRIWKHVFUHHQDGGWKHdrawBoxDQGshowXYIXQFWLRQVDW
WKHERWWRPRIWKHSUHYLRXVVNHWFK7RJHWWKHVNHWFKWRXVHWKHPDGGWKLVOLQHMXVW
LQVLGHWKHRSHQLQJEUDFNHWRIWKHORRS
drawBox(1,0, 38, 24); // the screen is 38 characters wide and 25 high

7KH drawBoxIXQFWLRQSULQWVFKDUDFWHUVIRUWKHIRXUFRUQHUVDQGWKHWRSERWWRPDQG
VLGHHGJHVXVLQJWKHOLQHGUDZLQJFKDUDFWHUFRGHV
// characters that form the box outline
// see http://en.wikipedia.org/wiki/Code_page_437
const byte boxUL = 201;
const byte boxUR = 187;
const byte boxLL = 200;
const byte boxLR = 188;
const byte HLINE = 205; // horizontal line
const byte VLINE = 186; // vertical line

void drawBox( int startRow, int startCol, int width, int height)
{
//draw top line
showXY(boxUL, startCol,startRow); // the upper-left corner
for(int col = startCol + 1; col < startCol + width-1; col++)
Serial.print(HLINE); // the line characters
Serial.print(boxUR); // upper-right character

// draw left and right edges


for(int row = startRow + 1; row < startRow + height -1; row++)
{
showXY(VLINE, startCol,row); // left edge
showXY(VLINE, startCol + width-1,row); // right edge
}

11.11 Displaying Text on a TV | 363


// draw bottom line
showXY(boxLL, 0, startRow+height-1); // the lower-left corner character
for(int col = startCol + 1; col < startCol + width-1; col++)
Serial.print(HLINE);
Serial.print(boxLR);

$FRQYHQLHQFHIXQFWLRQXVHGE\drawBoxQDPHGshowXYFRPELQHVFXUVRUSRVLWLRQLQJ
DQGSULQWLQJ
void showXY( char ch, int x, int y){
// display the given character at the screen x and y location
setCursor(x,y);
Serial.print(ch);
}

+HUHLVDQDGGLWLRQDOVNHWFKWKDWXVHVWKHFXUVRUFRQWUROFRPPDQGVWRDQLPDWHDEDOO
ERXQFLQJDURXQGWKHVFUHHQ
/*
TellyBounce
*/

// define the edges of the screen:


const int HEIGHT = 25; // the number of text rows
const int WIDTH = 38; // the number of characters in a row
const int LEFT = 0; // useful constants derived from the above
const int RIGHT = WIDTH -1;
const int TOP = 0;
const int BOTTOM = HEIGHT-1;

const byte BALL = 'o'; // character code for ball


const byte ESC = 0x1B; // ASCII escape character used in TellyMate commands

int ballX = WIDTH/2; // X position of the ball


int ballY = HEIGHT/2; // Y position of the ball
int ballDirectionY = 1; // X direction of the ball
int ballDirectionX = 1; // Y direction of the ball

// this delay moves ball across the 38-character screen in just under 4 seconds
long interval = 100;

void setup()
{
Serial.begin(57600); // 57k6 baud is default TellyMate speed
clear(); // clear the screen
cursorHide(); // turn cursor off
}

void loop()
{
moveBall();
delay(interval);
}

364 | Chapter 11: Using Displays


void moveBall() {
// if the ball goes off the top or bottom, reverse its Y direction
if (ballY == BOTTOM || ballY == TOP)
ballDirectionY = -ballDirectionY;

// if the ball goes off the left or right, reverse its X direction
if ((ballX == LEFT) || (ballX == RIGHT))
ballDirectionX = -ballDirectionX;

// clear the ball's previous position


showXY(' ', ballX, ballY);

// increment the ball's position in both directions


ballX = ballX + ballDirectionX;
ballY = ballY + ballDirectionY;

// show the new position


showXY(BALL, ballX, ballY);
Download from Wow! eBook <www.wowebook.com>

// TellyMate helper functions

void clear( ) // clear the screen


{ // <ESC>E
Serial.print(ESC);
Serial.print('E');
}

void setCursor( int col, int row) // set the cursor


{ // <ESC>Yrc
Serial.print(ESC);
Serial.print('Y' ) ;
Serial.print((unsigned char)(32 + row)) ;
Serial.print((unsigned char)(32 + col)) ;
}

void cursorShow( )
{ // <ESC>e
Serial.print(ESC) ;
Serial.print('e') ;
}

void cursorHide()
{ // <ESC>f
Serial.print(ESC) ;
Serial.print('f' ) ;
}

void showXY( char ch, int x, int y){


// display the given character at the screen x and y location
setCursor(x,y);
Serial.print(ch);
}

11.11 Displaying Text on a TV | 365


See Also
'HWDLOHGLQIRUPDWLRQRQWKH7HOO\0DWHVKLHOGLVDYDLODEOHDWKWWSZZZEDWVRFNVFRXN
SURGXFWV6KLHOGVLQGH[B6KLHOGVKWP
0XFKPRUHLQIRUPDWLRQRQFRGHSDJHLQFOXGLQJDWDEOHRIFKDUDFWHUVLVDYDLODEOH
DWKWWSHQZLNLSHGLDRUJZLNL&RGHBSDJHB

366 | Chapter 11: Using Displays

You might also like