arduino tft lcd animation price
Normally the TFT chip select line for a single display is defined within a user_setup file of the TFT_eSPI library, however when using the library with two displays the chip selects must be controlled by the sketch, thus you must NOT define the TFT_CS pin in the TFT_eSPI library setup files. Instead, the chip selects (CS) must be defined in the "config.h" tab of the Animated_Eyes_2 sketch.
The TFT_eSPI library uses "user_setup" files to define all the parameters for the display, processor and interfaces, for the Animated_Eyes_2 sketch the "Setup47_ST7735.h" file was used with the wiring as shown above.
The displays used for testing were 128x128 ST7735 displays, the TFT_eSPI library setup file may need to be changed as these displays come in many configuration variants.
The uLCD-144G2 display module is compact and cost effective and features a 1.44” LCD TFT screen, which is the smallest LCD TFT module available from 4D Systems. Driven by the GOLDELOX processor, the uLCD-144G2 is the perfect compact display solution for any application requiring a small embedded screen.
The module is an elegant combination of a 1.44” TFT LCD screen, along with a modest but comprehensive collection of I/O Features. These include a micro-SD card connector, two general purpose input/output pins (GPIO"s) with Dallas 1-Wire Support, Analog Input and sound generation capability, along with serial communications.
This display module serves as a perfect solution to be deployed at the forefront of any product design, requiring a brilliance of colour, animation or images on any application. This GOLDELOX driven Intelligent Display Module is a perfect example of where art meets technology.
I picked up the following Adafruit TFT LCD:This lovely little display breakout is the best way to add a small, colorful, and bright display to any project. Since the display uses 4-wire SPI to communicate and has its own ...
I"ve played with the example code to do some line drawings, as well as to pull a bitmap from an attached SD card. I also figured out how to do some basic animation with the following pseudocode:
Question #2 has to do with bitmap animation. I figured out how to pull a similar 30x30 image, and I can move it around the screen, similar to the line drawing animation. However, redrawing the animation currently involves accessing the SD card at every movement, which seems slow and incorrect. I think the correct way to do it would be to pull the bitmap into an object of some kind, but I don"t know how to do this.
I was wondering if it is possible to have a screen (either LCD, or OLED ...) that can display a video loaded from my computer to an included storage device (like SD card). Maybe it is possible to use a screen that doesn"t have an included storage device but couple it with an external one ?
The thing is that I would like to be able to have a short video playing continuously on the screen (just like the animated pictures in Harry Potter for example) without having thee Arduino device + screen connected to my computer.
The idea would be to upload the video to the SD card once and for all and then be able to walk around with the screen playing the video in a loop (I assume it would be possible to power the Arduino device with batteries).
Also, in the very best case, would it even be possible to have screens that could work in this way without using any Arduino device ? That would be more convenient to store in a frame for example.
Only US$14.99, buy best 3.5 inch tft color display screen module 320 x 480 support uno mega2560 geekcreit for arduino - products that work with official arduino boards sale online store at wholesale price.
In this guide we’re going to show you how you can use the 1.8 TFT display with the Arduino. You’ll learn how to wire the display, write text, draw shapes and display images on the screen.
The 1.8 TFT is a colorful display with 128 x 160 color pixels. The display can load images from an SD card – it has an SD card slot at the back. The following figure shows the screen front and back view.
This module uses SPI communication – see the wiring below . To control the display we’ll use the TFT library, which is already included with Arduino IDE 1.0.5 and later.
The TFT display communicates with the Arduino via SPI communication, so you need to include the SPI library on your code. We also use the TFT library to write and draw on the display.
The 1.8 TFT display can load images from the SD card. To read from the SD card you use the SD library, already included in the Arduino IDE software. Follow the next steps to display an image on the display:
In this guide we’ve shown you how to use the 1.8 TFT display with the Arduino: display text, draw shapes and display images. You can easily add a nice visual interface to your projects using this display.
are very popular low costDisplay ShieldsforArduino.has had support for them for quite a while, but I never had chance to write a Tutorial on how to use them. Recently however few people asked questions about using displays with, so I decided to make a tutorial.
In this Tutorial, I will show you how easy it is, to connect the Shield toArduino, and program it withto animate a Bitmap to move around on the Display.
TheVisuino:https://www.visuino.comalso needs to be installed.StartVisuinoas shown in thefirst pictureClick on the "Arrow Down" button of the Arduino component to open the Drop Down Menu (Picture 1)From the Menu select "Add Shields..." (Picture 1)In the "Shields" dialog expand the "Displays" category, and select the "TFT Color Touch Screen Display ILI9341 Shield", then click on the "+" button to add it (Picture 2)
Next we need to add Graphics elements to render text and bitmap. First we will add graphics element to draw the shadow of the text:In the Object Inspector, click on the "..." button next to the value of the "Elements" property of the "TFT Display" Element (Picture 1)In the Elements editor select “”, and then click on the "+" button (Picture 2) to add one (Picture 3)In the Object Inspector set the value of the "Color" property of the "Draw Text1" element to "aclSilver" (Picture 3)In the Object Inspector set the value of the "Size" property of the "Draw Text1" element to "4" (Picture 4). This makes the text biggerIn the Object Inspector set the value of the "Text" property of the "Draw Text1" element to "Visuino" (Picture 5)In the Object Inspector set the value of the "X" property of the "Draw Text1" element to "43" (Picture 6)In the Object Inspector set the value of the "Y" property of the "Draw Text1" element to "278" (Picture 6)
Next we will add graphics element to draw the bitmap:In the Elements editor select “Draw Bitmap”, and then click on the "" button (Picture 1) to add one (Picture 2)In the Object Inspector, click on the "..." button next to the value of the "Bitmap" property of the "Draw Bitmap1" Element (Picture 2) to open the "Bitmap Editor" (Picture 3)In the "Bitmap Editor" click on the "Load..." button (Picture 3) to open the File Open Dialog (Picture 4)In the File Open Dialog, select the bitmap to draw, and click on the "Open" button (Picture 4). If the file is too big it may not be able to fit in the Arduino memory. If you get out of memory error during the compilation, you may need to select a smaller bitmapIn the "Bitmap Editor" click on the "OK." button (Picture 5) to close the dialog
In the Object Inspector, set the value of the "Amplitude" property of theSineIntegerGenerator2component to "120" (Picture 1)In the Object Inspector, set the value of the "Offset" property of theSineIntegerGenerator2component to "120" (Picture 2)In the Object Inspector, set the value of the "Frequency" property of theSineIntegerGenerator2component to "0.03" (Picture 3)Connect the "Out" output pin of theSineIntegerGenerator1component to the "X" input pin of the "Shields.TFT Sisplay.Elements.Draw Bitmap1" element of theArduinocomponent (Picture 4)Connect the "Out" output pin of theSineIntegerGenerator2component to the "Y" input pin of the "Shields.TFT Display.Elements.Draw Bitmap1" element of theArduinocomponent (Picture 5)
To render the bitmap every time the X and Y position are updated we need to send a clock signal to the "Draw Bitmap1" element. To send the command after the positions have been changed, we need a way to synchronize the events. For this we will use Repeat component to constantly generate events, and Clock Multi Source to generate 2 events in sequence. The first event will clock the sine generators to update the X and Y positions, and the second will clock the "Draw Bitmap1" :Type "repeat" in the Filter box of the Component Toolbox, then select the "Repeat" component (Picture 1), and drop it in the design area (Picture 2)Type "multi" in the Filter box of the Component Toolbox, then select the "Clock Multi Source" component (Picture 2), and drop it in the design area (Picture 3)Connect the "Out" output pin of theRepeat1component to the "In" input pin of theClockMultiSource1component (Picture 3)Connect the "Pin[ 0 ]" output pin of the "Out" pins of theClockMultiSource1component to the "In" input pin of theSineIntegerGenerator1component (Picture 4)Connect the "Pin[ 0 ]" output pin of the "Out" pins of theClockMultiSource2component to the "In" input pin of theSineIntegerGenerator1component (Picture 5)Connect the "Pin[ 1 ]" output pin of the "Clock" input pin of the "Shields.TFT Display.Elements.Draw Bitmap1" element of theArduinocomponent (Picture 6)
InVisuino, PressF9or click on the button shown onPicture 1to generate the Arduino code, and open the Arduino IDEIn theArduino IDE, click on theUploadbutton, to compile and upload the code (Picture 2)
In this tutorial, I will show you how easy it is to connect the shield to the Arduino and program it using visualino to make the bitmap move on the display.
As shown in picturesTo to start programming the Arduino, insert the TFT shield into the top of the Arduino Uno, you need to install the Arduino IDE from here: Make sure to install 1. 6.
Spice up your Arduino project with a beautiful large touchscreen display shield with built in microSD card connection. This TFT display is big (5" diagonal) bright (18 white-LED backlight) and colorful 800x480 pixels with individual pixel control. As a bonus, this display has a capacitive touch panel attached on screen by default.
The shield is fully assembled, tested and ready to go. No wiring, no soldering! Simply plug it in and load up our library - you"ll have it running in under 10 minutes! Works best with any classic Arduino Mega2560.
Of course, we wouldn"t just leave you with a datasheet and a "good luck!" - we"ve written a full open source graphics library at the bottom of this page that can draw pixels, lines, rectangles, circles and text. We also have a touch screen library that detects x,y and z (pressure) and example code to demonstrate all of it. The code is written for Arduino but can be easily ported to your favorite microcontroller!
If you"ve had a lot of Arduino DUEs go through your hands (or if you are just unlucky), chances are you’ve come across at least one that does not start-up properly.The symptom is simple: you power up the Arduino but it doesn’t appear to “boot”. Your code simply doesn"t start running.You might have noticed that resetting the board (by pressing the reset button) causes the board to start-up normally.The fix is simple,here is the solution.
Arduino Uno: Bitmap Animation on ILI9341 TFT Touchscreen Display Shield With Visuino: ILI9341 based TFT Touchscreen Display Shields are very popular low cost Display Shields for...
The Beginner’s Guide to Display Text, Image & Animation on OLED Display by Arduino: In this article, we’ll talk about OLED displays story and their differences, how to run them ...
Displaying a custom image or graphic on a LCD display is a very useful task as displays are now a premium way of providing feedback to users on any project. With this functionality, we can build projects that display our own logo, or display images that help users better understand a particular task the project is performing, providing an all-round improved User Experience (UX) for your Arduino or ESP8266 based project. Today’s tutorial will focus on how you can display graphics on most Arduino compatible displays.
The procedure described in this tutorial works with all color displays supported by Adafruit’s GFX library and also works for displays supported by the TFTLCD library from Adafruit with little modification. Some of the displays on which this procedure works include:
While these are the displays we have, and on which this tutorial was tested, we are confident it will work perfectly fine with most of the other Arduino compatible displays.
For each of the displays mentioned above, we have covered in past how to program and connect them to Arduino. You should check those tutorials, as they will give you the necessary background knowledge on how each of these displays works.
For this tutorial, we will use the 2.8″ ILI9325 TFT Display which offers a resolution of 320 x 340 pixels and we will display a bitmap image of a car.
To demonstrate how things work, we will use the 2.8″ TFT Display. The 2.8″ TFT display comes as a shield which plugs directly into the Arduino UNO as shown in the image below.
Not all Arduino displays are available as shields, so when working with any of them, connect the display as you would when displaying text (we recommend following the detailed tutorial for the display type you use of the above list). This means no special connection is required to display graphics.
Before an image is displayed on any of the Arduino screens, it needs to be converted to a C compatible hex file and that can only happen when the image is in bitmap form. Thus, our first task is to create a bitmap version of the graphics to be displayed or convert the existing image to a bitmap file. There are several tools that can be used for creation/conversion of bitmap images including, Corel Draw and Paint.net, but for this tutorial, we will use the Paint.net.
Your graphics could also include some text. Just ensure the background is black and the fill color is white if you plan to change the color within your Arduino code.
Image2Code is an easy-to-use, small Java utility to convert images into a byte array that can be used as a bitmap on displays that are compatible with the Adafruit-GFX or Adafruit TFTLCD (with little modification) library.
Paste the bit array in the graphics.c file and save. Since we have two graphics (the car and the text), You can paste their data array in the same file. check the graphics.c file attached to the zip file, under the download section to understand how to do this. Don’t forget to declare the data type as “const unsigned char“, add PROGEM in front of it and include the avr/pgmspace.h header file as shown in the image below. This instructs the code to store the graphics data in the program memory of the Arduino.
With this done, we are now ready to write the code. Do note that this procedure is the same for all kind of displays and all kind of graphics. Convert the graphics to a bitmap file and use the Img2code utility to convert it into a hex file which can then be used in your Arduino code.
To reduce the amount of code, and stress involved in displaying the graphics, we will use two wonderful libraries; The GFX library and the TFTLCD library from Adafruit.
The Adafruit libraries do not support all of the displays but there are several modifications of the libraries on the internet for more displays. If you are unable to find a modified version of the library suitable for your the display, all you need do is copy the code of the drawBitmap() function from the GFX library and paste it in the Arduino sketch for your project such that it becomes a user-defined function.
The first two are thex and y coordinates of a point on the screen where we want the image to be displayed. The next argument is the array in which the bitmap is loaded in our code, in this case, it will be the name of the car and the text array located in the graphics.c file. The next two arguments are the width and height of the bitmap in pixels, in other words, the resolution of the image. The last argument is the color of the bitmap, we can use any color we like. The bitmap data must be located in program memory since Arduino has a limited amount of RAM memory available.
As usual, we start writing the sketch by including the libraries required. For this procedure, we will use the TFTLCD library alone, since we are assuming you are using a display that is not supported by the GFX library.
Next, we specify the name of the graphics to be displayed; car and title. At this stage, you should have added the bit array for these two bitmaps in the graphics.c file and the file should be placed in the same folder as the Arduino sketch.
The last section of the code is the drawBitmap function itself, as earlier mentioned, to use the drawbitmap() function with the Adafruit TFTLCD library, we need to copy the function’s code and paste into the Arduino sketch.
Plug in your screen as shown above. If you are using any other display, connect it as shown in the corresponding linked tutorial. With the schematics in place, connect the Arduino board to your PC and upload the code. Don’t forget the graphics file needs to be in the same folder as the Arduino sketch.
That’s it for this tutorial guys. The procedure is the same for all kinds of Arduino compatible displays. If you get stuck while trying to replicate this using any other display, feel free to reach out to me via the comment sections below.
An LCD display (Liquid Crystal Display) is a flat panel display that uses the light modulating properties of liquid crystals. Since liquid crystals do not emit light, this type of display needs a backlight, or external light to produce an image. That’s why the power consumption of these displays is relatively high for battery powered Arduino projects.
On the other hand, the price of the LCDs is very low. The Nokia 5110, the 1.8″ Color TFT display and the 3.5″ Color TFT display, are all displays that use the LCD technology.
An OLED display is a screen that uses organic light emitting diodes. It requires no backlight, so the power consumption of these display is low and depends on how many pixels are lit. Also, since the screen does not need a backlight, it can display deep black color. Another advantage of this kind of display is that they are usually thinner and lighter the LCD displays. In low light, OLED displays can achieve better contrast in comparison to LCDs.
On the other hand, OLED displays are more expensive than LCD displays. Because of this, the available OLED displays for Arduino are tiny in size, and until recently they were only monochrome. A few months ago a small Color OLED appeared at a relatively low cost.
E-Paper of Electronic paper are displays that unlike traditional LCD or OLED displays does not emit light but reflect light. It is like the ink on the paper. This characteristic makes e-paper displays very comfortable to read, and they have an excellent readability under direct sunlight. Another great thing about e-paper displays is that they can hold static text and image for months without electricity! Yes, that’s correct, the display can show text and image even if it is off! That makes e-paper displays ideal for low powered projects!
Unfortunately there some disadvantages as well. The price of e-paper display is still very high. For example, this 4.3″ E-Paper display for Arduino costs over $60. Another significant disadvantage is that e-paper displays take a lot of time to update, as much as 2-3 seconds. So, they are only helpful for static text and images and not animations.
The Nokia 5110 is a basic graphic LCD screen which was originally intended for as a cell phone screen. It uses the PCD8544 controller which is a low power CMOS LCD controller/driver. Because of this, this display has an impressive power consumption. It uses only 0.4mA when it is on, but the backlight is disabled. It uses less than 0.06mA when in sleep mode! That’s one of the reasons that make this display my favorite. The PCD8544 interfaces to microcontrollers through a serial bus interface. That makes the display very easy to use with Arduino.
This impressive library is developed by Henning Karlsen who has put an enormous amount of effort to help the Arduino community move forward with his libraries. I have prepared a detailed tutorial on how to use the Nokia 5110 LCD display with Arduino. You watch it in this video:
Furthermore, it is also straightforward to use with Arduino since there is a library for it. It is the Adafruit SSD1331 library, and you find it here.
First of all the ST7735 Color TFT display is a very inexpensive display. It costs around $5, and it has a great library support. I have used it many of my projects, and I think it is great!
Furthermore, the display offers a resolution of 160×128 pixels, and it can display 65.000 colors. It uses the SPI interface to communicate with the Arduino boards. In addition to that, it works well with all the available Arduino boards, like the Arduino Uno, the Arduino Mega, and the Arduino Due. It also works fine with ESP8266 based boards, like the Wemos D1 and the Wemos D1 mini board.
In conclusion, this is one of the best Arduino displays if you need color and low cost. I have prepared a detailed tutorial about the 1.8″ ST7735 Color TFT display, you can watch it here:
This is another very nice display to use with Arduino. It is an OLED display and that means that it has a low power consumption. The power consumption of this display is around 10-20 mA and it depends on how many pixels are lit.
In addition to that, the display uses the I2C interface, so the connection with Arduino is incredibly easy. You only need to connect two wires except for Vcc and GND. If you are new to Arduino and you want an inexpensive and easy to use display to use with your project, start with display. It is the easiest way to add a display to your Arduino project.
This 3.5″ Color TFT display is the biggest display that you can use in your project if you are using an Arduino Uno or a Mega. Unfortunately, it does not support the fast Arduino Due, nor the Wemos D1 ESP8266 board.
Also, the display comes as a shield. So, you only have to connect the display with your Arduino board, and you are ready to use it. Of course, you need to install the appropriate driver for the display. Luckily I have a link to this driver here. Search for the download file, and you will find the library for the display in that .zip file.
Adding a display to your Arduino can serve many purposes. Since a common use for microcontrollers is reading data from sensors, a display allows you to see this data in real-time without needing to use the serial monitor within the Arduino IDE. It also allows you to give your projects a personal touch with text, images, or even interactivity through a touch screen.
Transparent Organic Light Emitting Diode (TOLED) is a type of LED that, as you can guess, has a transparent screen. It builds on the now common OLED screens found in smartphones and TVs, but with a transparent display, offers up some new possibilities for Arduino screens.
The liquid crystal display (LCD) is the most common display to find in DIY projects and home appliances alike. This is no surprise as they are simple to operate, low-powered, and incredibly cheap.
This type of display can vary in design. Some are larger, with more character spaces and rows; some come with a backlight. Most attach directly to the board through 8 or 12 connections to the Arduino pins, making them incompatible with boards with fewer pins available. In this instance, buy a screen with an I2C adapter, allowing control using only four pins.
The screens are capable of a large variety of preset characters which cover most use cases in a variety of languages. You can control your LCD using the Liquid Crystal Library provided by Arduino. The display() and noDisplay() methods write to the LCD, as shown in the official tutorial on the Arduino website.
These simple boards are made up of 7 LEDs (8 if you include the dot), and work much like normal LEDs with a common Anode or Cathode connection. This allows them to take one connection to V+ (or GND for common cathode) and be controlled from the pins of your Arduino. By combining these pins in code, you can create numbers and several letters, along with more abstract designs—anything you can dream up using the segments available!
These tiny LCD screens are monochrome and have a screen size of 84 x 48 pixels, but don"t let that fool you. Coming in at around $2 on AliExpress, these displays are incredibly cheap and usually come with a backlight as standard.
Depending on which library you use, the screen can display multiple lines of text in various fonts. It"s also capable of displaying images, and there is free software designed to help get your creations on screen. While the refresh rate is too slow for detailed animations, these screens are hardy enough to be included in long-term, always-on projects.
They connect to your Arduino using I2C, meaning that alongside the V+ and GND pins, only two further pins are required to communicate with the screen. With various sizes and full color options available, these displays are incredibly versatile.
Thin-film-transistor liquid-crystal displays (TFT LCDs) are in many ways another step up in quality when it comes to options for adding a screen to your Arduino. Available with or without touchscreen functionality, they also add the ability to load bitmap files from an on-board microSD card slot.
Arduino have an official guide for setting up their non-touchscreen TFT LCD screen. For a video tutorial teaching you the basics of setting up the touchscreen version, YouTuber educ8s.tv has you covered:
This article has covered most options available for Arduino displays, though there are definitely more weird and wonderful ways to add feedback to your DIY devices.
Now that you have an idea of what is out there, why not incorporate a screen into your DIY smart home setup? If retro gaming is more your thing, why not create some retro games on Arduino?
– Arduino is an open-source platform used for building electronics projects. Arduino consists of both a physical programmable microcontroller and a piece of software, or IDE (Integrated Development Environment) that runs on your computer, used to write and upload computer code to the physical board.
– The Arduino platform unlike most previous programmable circuit boards, the Arduino does not need a separate programmer to load new code onto the board — you can simply use a USB cable. Additionally, the Arduino IDE uses a simplified version of C++, making it easier to learn to program.
– The open sources and extensible language: Arduino IDE is based on open source tool. The programming language used can be extended through the C++ library.
– The open source and expandable hardware: Arduino is based on Atmel’s ATMEGA 8-bit microcontrollers and its SAM3X8E and SAMD21 32-bit microcontrollers. Development boards and modules are planned to be released under the premise of following the “Creative Commons License Agreement”, so experienced circuit designers can make their own modules and carry out corresponding expansions and improvements. Even users who are relatively inexperienced can make a trial version of the basic Uno development board, which is easy to understand the principle of its operation and save costs.
– The Arduino hardware and software were designed for artists, designers, hobbyists, hackers, newbies, and anyone interested in creating interactive objects or environments. Arduino can interact with buttons, LEDs, motors, speakers, GPS units, cameras, the internet, and even your smart-phone or your TV.
Arduino Leonardo: Arduino’s first development board to use one microcontroller with built-in USB. It is cheaper and simpler. The code libraries allow the board to emulate a computer keyboard, mouse, and more.
LCD means liquid crystal display. Basically, any displays can be used with Arduino, including alphanumeric character LCD display, monochrome graphic LCD display, color TFT LCD display, IPS LCD display. It can also be used for non LCD displays like: PMOLED display, AMOLED display, E-ink (E-paper) displays. Orient Display developed easy interface (SPI, I2C) displays which can be easily used with Arduino.
LCD displays were first used for watches and calculators. Now, LCD display technology dominants the display world, it can be found in wearables, smart homes, mobile phones, TVs, laptops, monitors, kiosks, aircraft cockpit, digital cameras, lab instrument, power grid etc.
LCD itself can emit light itself. It has to utilize outside light sources. LCD display module normally includes LCD glass (or LCD panel), LCD driving circuitry ( can be COG, COB or TAB) and a backlight.
A LCD display 16*2 is actually a basic and simple to use LCD module. It includes LCD glass, COB (Chip on PCB Board) LCD control board, backlight, zebra to connect LCD glass and control board and a bezel to hold everything together. 16×2 LCD display can display 16 characters per line and there are two lines. Each character has 5×7 dot matrix pixels and the cursor underneath. All 16×2 LCD display originally used standard Hitachi HD44780 driver. Of course the legendary HD44780 controller had EOL long time ago. All the 16×2 LCD displays use HD44780 compatible LCD controllers. Some of them are drop replacement, some of them need to modify the initialization code a little.
A 16×2 LCD has two registers like data register and command register. The RS (register select) is mainly used to change from one register to another. When the register set is ‘0’, then it is known as command register. Similarly, when the register set is ‘1’, then it is known as data register.
Data Register: The main function of the data register is to store the information which is to be exhibited on the LCD screen. Here, the ASCII value of the character is the information which is to be exhibited on the screen of LCD. Whenever we send the information to LCD, it transmits to the data register, and then the process will be starting there. When register set =1, then the data register will be selected.
All of the code below uses the LiquidCrystal library that comes pre-installed with the Arduino IDE. A library is a set of functions that can be easily added to a program in an abbreviated format. In order to use a library, it needs be included in the program. Line 1 in the code below does this with the command #include
Now we’re ready to get into the programming! I’ll go over more interesting things you can do in a moment, but for now let’s just run a simple test program. This program will print “hello, world!” to the screen. Enter this code into the Arduino IDE and upload it to the board:
The LiquidCrystal() function sets the pins the Arduino uses to connect to the LCD. You can use any of the Arduino’s digital pins to control the LCD. Just put the Arduino pin numbers inside the parentheses in this order:
This function sets the dimensions of the LCD. It needs to be placed before any other LiquidCrystal function in the void setup() section of the program. The number of rows and number of columns are specified as lcd.begin(columns, rows). For a 16×2 LCD, you would use lcd.begin(16, 2), and for a 20×4 LCD you would use lcd.begin(20, 4).
This function clears any text or data already displayed on the LCD. If you use lcd.clear() with lcd.print() and the delay() function in the void loop() section, you can make a simple blinking text program.
Similar, but more useful than lcd.home() is lcd.setCursor(). This function places the cursor (and any printed text) at any position on the screen. It can be used in the void setup() or void loop() section of your program.
The cursor position is defined with lcd.setCursor(column, row). The column and row coordinates start from zero (0-15 and 0-1 respectively). For example, using lcd.setCursor(2, 1) in the void setup() section of the “hello, world!” program above prints “hello, world!” to the lower line and shifts it to the right two spaces:
This function creates a block style cursor that blinks on and off at approximately 500 milliseconds per cycle. Use it in the void loop() section. The function lcd.noBlink() disables the blinking block cursor.
This function turns on any text or cursors that have been printed to the LCD screen. The function lcd.noDisplay() turns off any text or cursors printed to the LCD, without clearing it from the LCD’s memory.
This function takes anything printed to the LCD and moves it to the left. It should be used in the void loop() section with a delay command following it. The function will move the text 40 spaces to the left before it loops back to the first character. This code moves the “hello, world!” text to the left, at a rate of one second per character.
lcd.noAutoscroll() turns the lcd.autoscroll() function off. Use this function before or after lcd.autoscroll() in the void loop() section to create sequences of scrolling text or animations.
This function sets the direction that text is printed to the screen. The default mode is from left to right using the command lcd.leftToRight(), but you may find some cases where it’s useful to output text in the reverse direction.
This command allows you to create your own custom characters. Each character of a 16×2 LCD has a 5 pixel width and an 8 pixel height. Up to 8 different custom characters can be defined in a single program. To design your own characters, you’ll need to make a binary matrix of your custom character from an LCD character generator or map it yourself. This code creates a degree symbol (°).
The detailed LCD tutorial can be found in the article. ARDUINO LCD SET UP AND PROGRAMMING GUIDE or to check https://github.com/arduino-libraries/LiquidCrystal
This is a derivative of the Adafruit graphics libraries. I have copied the original README files below. To achieve the requisite performance optimizations, this library is no longer compatible with multiple LCD displays. This project is intended only for use of the 9341 TFT LCD display with the Arduino Uno.
Load sketches in Examples folder onto Arduino UNO (Leonardo support is limited and buggy). It may work on other AtMega based Arduinos, but this has not been tested.
The 9351 displays operate in 16-bit color, so the low/high bytes of each color are sent separately. This means that we need to constantly switch the Arduino pin states from the high and low byte of the color data when filling part of the screen. This is expensive.
The Uno9341TFT library optimizes this by detecting when the high and low byte of the color are the same. It configures the output lines to this byte, and then strobes the data clock twice for each pixel to send. The optimized flood routine also unrolls the loop for testing how many pixels to send.
The Uno9341TFT library also assumes a 320x240 pixel display in portrait mode. So, it assumes that only a single byte is needed to specify the x location. This means that the drawing commands won"t work correctly in landscape mode. It is easy to transpose x and y coordinates in user code, so this is no limitation.
The Arduino doesn"t have enough memory (or speed) to support double-buffering. To avoid flickering when rendering 2D or 3D animations, it is useful to draw the next frame before erasing the pixels from the previous frame.
We implement flat shading by checking the per-triangle face normals, and using 16-color maps color_maps.h that can be written quickly to the display. The Arduino is too slow for Phong shading, but Gouraud shading is possible.
Ms.Josey 
Ms.Josey