arduino connect lcd display price

Before you learn how to connect your display to Arduino, it’s worth to think about what exact task it’s going to perform, to choose the right type and model of display. Commonly used with Arduino are 2×16 alphanumeric LCD displays (capable of displaying 2 lines of 16 characters each) with green or blue backlight.

In the offer of electronics shops you will often find e-paper displays as well – their main advantage over other screens is much lower energy consumption (due to the type of technology) and a unique image that looks literally as if the content was written on paper. The biggest disadvantage of this solution is of course the relatively high price per unit.

Shops often also offer larger versions of LCD displays, 8-segment displays, touch screens and many other solutions. The choice should be made based on the needs – for example, if the project is commercial and the device will be used in sunlight, and low price is not a priority – no backlighting will be an advantage and an e-paper display will work well for this. In a project where the device will only need to display a single number – an 8-segment display will work well. Nevertheless, the most popular choice remains the 2×16 LCD, which works well for most projects and is particularly popular with electronics beginners and students.

Due to its high popularity and usefulness, below we will describe how to connect a 2×16 LCD display. This type of equipment is usually sold as a display on a laminated PCB – some products have the I2C converter soldered in, but some models do not have it. In this case such a converter must also be prepared to realise the project. To complete the whole task it will be practical to use a contact board, thanks to which you will be able to reuse each of the used elements many times – also in other projects. Prepare also a set of connection wires (with male and female plugs on their ends) and

The first step is to solder a female goldpin to GPIO pins on Arduino board. Thanks to this, you will be able to connect any device in any configuration and use for example dedicated frontends (e.g. with male goldpins soldered on). If the I2C converter does not have male leads, a goldpin strip should be soldered there as well. Both components should be connected by correct positioning on the contact board. Converter should have 4 pins on output – it will be power supply (VCC), ground (GND) and SDA and SCL.

Before connecting the power supply make sure exactly what voltage your display requires – it will be 3.3 V or 5 V. Based on this information, connect the VCC pin from your converter to the corresponding voltage on your Arduino board. Of course, you can power the display with an external power supply, but this will only make sense if you connect more components to the board. The GND pin should be connected to the GND pin on the Arduino, and the SDA and SCL pins to the analog inputs on the board.

After connecting the power supply to the board, the display should work. However, it’s worth to remember, that in order to display anything, you have to program any content first. For example your name or a sequence of numbers. If the image is not clearly visible, there is a brightness or contrast control on each display. If a potentiometer is not built in, it is certainly possible to take the appropriate pin out on a contact board, where you can connect the appropriate resistor (or potentiometer) yourself and make the image readable.

Oczywiście sposobów podłączania wyświetlacza jest bardzo wiele – te różnią się między sobą przede wszystkim w zależności od wyświetlaczy, ale także w zależności od przyzwyczajeń elektronika oraz od zadania jakie wyświetlacz ma spełniać. Nawet wśród najprostszych wyświetlaczy LCD 2×16 różnice między modelami mogą być stosunkowo duże, dlategoza każdym razem zapoznajmy się z dokumentacją techniczną, nawet jeszcze przed jego kupnem, aby uniknąć niemiłego zaskoczenia, kiedy staniemy przed problemem z podłączeniem lub przedwczesną diagnozą o uszkodzeniu sprzętu.

In this Arduino touch screen tutorial we will learn how to use TFT LCD Touch Screen with Arduino. You can watch the following video or read the written tutorial below.

As an example I am using a 3.2” TFT Touch Screen in a combination with a TFT LCD Arduino Mega Shield. We need a shield because the TFT Touch screen works at 3.3V and the Arduino Mega outputs are 5 V. For the first example I have the HC-SR04 ultrasonic sensor, then for the second example an RGB LED with three resistors and a push button for the game example. Also I had to make a custom made pin header like this, by soldering pin headers and bend on of them so I could insert them in between the Arduino Board and the TFT Shield.

Next we need to define the fonts that are coming with the libraries and also define some variables needed for the program. In the setup section we need to initiate the screen and the touch, define the pin modes for the connected sensor, the led and the button, and initially call the drawHomeSreen() custom function, which will draw the home screen of the program.

So now I will explain how we can make the home screen of the program. With the setBackColor() function we need to set the background color of the text, black one in our case. Then we need to set the color to white, set the big font and using the print() function, we will print the string “Arduino TFT Tutorial” at the center of the screen and 10 pixels  down the Y – Axis of the screen. Next we will set the color to red and draw the red line below the text. After that we need to set the color back to white, and print the two other strings, “by HowToMechatronics.com” using the small font and “Select Example” using the big font.

In order the code to work and compile you will have to include an addition “.c” file in the same directory with the Arduino sketch. This file is for the third game example and it’s a bitmap of the bird. For more details how this part of the code work  you can check my particular tutorial. Here you can download that 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.

Take for example this brilliant project that makes use of TOLED displays. By stacking 10 transparent OLED screens in parallel, creator Sean Hodgins has converted a handful of 2D screens into a solid-state volumetric display. This kind of display creates an image that has 3-dimensional depth, taking us one step closer to the neon, holographic screens we imagine in the future.

Crystalfontz has a tiny monochrome (light blue) 1.51" TOLED that has 128x56 pixels. As the technology is more recent than the following displays in this list, the cost is higher too. One of these screens can be purchased for around $26, but for certain applications, it might just be worth it.

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.

Available for only a few dollars (or as little as a couple of dollars on AliExpress with included I2C adapter), these simple displays can be used to give real-time feedback to any project.

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.

Are you looking for something simple to display numbers and a few basic characters? Maybe you are looking for something with that old-school arcade feel? A seven-segment display might suit your needs.

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!

Next on our list is the 5110 display, also affectionately known as the Nokia display due to its wide use in the beloved and nigh indestructible Nokia 3310.

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.

For a step up in resolution and functionality, an OLED display might be what you are looking for. At first glance, these screens look similar to the 5110 screens, but they are a significant upgrade. The standard 0.96" screens are 128 x 64 monochrome, and come with a backlight as standard.

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.

For a project to get you started with OLED displays, our Electronic D20 build will teach you everything you need to know -- and you"ll end up with the ultimate geeky digital dice for your gaming sessions!

These displays can be used in the same way as the others we have mentioned so far, but their refresh rate allows for much more ambitious projects. The basic monochrome screen is available on Amazon.

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:

With the touchscreen editions of these screens costing less than $10 on AliExpress, these displays are another great choice for when you need a nice-looking display for your project.

Looking for something a little different? An E-paper (or E-ink depending on who you ask) display might be right for you. These screens differ from the others giving a much more natural reading experience, it is no surprise that this technology is the cornerstone of almost every e-reader available.

The reason these displays look so good is down to the way they function. Each "pixel" contains charged particles between two electrodes. By switching the charge of each electrode, you can influence the negatively charged black particles to swap places with the positively charged white particles.

This is what gives e-paper such a natural feel. As a bonus, once the ink is moved to its location, it uses no power to keep it there. This makes these displays naturally low-power to operate.

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.

Pin4 (RS pin or Register Select/Control Pin): This pin toggles among command or data register, used to connect a microcontroller unit pin and obtains either 0 or 1(0 = data mode, and 1 = command mode).

Pin5 (Read/Write/Control Pin): This pin toggles the display among the read or writes operation, and it is connected to a microcontroller unit pin to get either 0 or 1 (0 = Write Operation, and 1 = Read Operation).

Pin 6 (Enable pin/Control Pin): This pin should be held high to execute Read/Write process, and it is connected to the microcontroller unit & constantly held high.

Pins 7-14 (Data Pins): These pins are used to send data to the display. These pins are connected in two-wire modes like 4-bit mode and 8-bit mode. In 4-wire mode, only four pins are connected to the microcontroller unit like 0 to 3, whereas in 8-wire mode, 8-pins are connected to microcontroller unit like 0 to 7.

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.

Command Register: The main function of the command register is to store the instructions of command which are given to the display. So that predefined tasks can be performed such as clearing the display, initializing, set the cursor place, and display control. Here commands processing can occur within the 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 . When you include a library in a program, all of the code in the library gets uploaded to the Arduino along with the code for your program.

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:

There are 19 different functions in the LiquidCrystal library available for us to use. These functions do things like change the position of the text, move text across the screen, or make the display turn on or off. What follows is a short description of each function, and how to use it in a program.

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

Today, among the various projects with Arduino used in the market, those that involve integration with LCD displays for the display of information stand out.

In this case, the I2C module needs to be connected to the display to have all its communication reduced to four wires: two for power and two for signal.

In order not to make a mistake in the numbering of the pinout, it is important to carefully observe the characteristics of each pin and their locations on the Arduino.

Meanwhile, pin 5 (R/W), connected to GND, demonstrates the read and write signal of the display, and pin 6 (E) serves to enable or disable the signal.

In addition, pins 15 (LED+) and 16 (LED-) will be responsible for supplying power to the LEDs at the bottom of the display. It is possible to connect pin 15 using:Using 2 resistors of 220 ohms in parallel;

With the proper connections, it"s time to program the Arduino by connecting it to the computer and opening the official Arduino IDE in its updated version.

Furthermore, despite being highly efficient, LCD technology is not new to the market, which lowers its cost in relation to other displays with similar benefits.

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.

In which “Hello, World!” is the text you want to display and the (x, y) coordinate is the location where you want to start display text on the screen.

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:

Note: some people find issues with this display when trying to read from the SD card. We don’t know why that happens. In fact, we tested a couple of times and it worked well, and then, when we were about to record to show you the final result, the display didn’t recognized the SD card anymore – we’re not sure if it’s a problem with the SD card holder that doesn’t establish a proper connection with the SD card. However, we are sure these instructions work, because we’ve tested them.

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.

In this Instructables lesson, displaying texts and featuring them on a 16 by 2 LCD using Arduino is demonstrated. Let"s get started and I hope you enjoy!

Arduino is a device that is widely used by students for various robotics projects and sensors to detect heart-rate, temperature, air pressure ... Arduino is an open-source hardware and software company, project and user community that designs and manufactures single-board micro controllers and micro controller kits for building digital devices and interactive objects that can sense and control both physically and digitally. Basically Arduino is capable to store codes inserted from Arduino IDE using C and C++ coding languages from a computer to manipulate the functions that are assigned for the device to do. LCD (Liquid Crystal Display) screen is an electronic display module and find a wide range of applications. A 16x2 LCD display is very basic module and is very commonly used in various devices and circuits. A 16x2 LCD means it can display 16 characters per line and there are 2 such lines. The LCD has 16 pins. Starting from left to right, the first pin is GND (ground). The second pin is the VCC (5 volts) pin which is connected to the Arduino board. The third pin is the Vo (display contrast) pin which can be connected to a potentiometer to adjust the display contrast. Fourth pin is the RS (register select) pin used for selecting the commands/data sent to the LCD using methods defined in the Arduino Liquid Crystal packages. Fifth one is the R/W (read/write) pin which selects the mode whether we read or write on the LCD. Sixth pin is the E (enable) pin which enables writings to the registers. The next 8 pins are data pins D0 to D7 that registers are written in using binary numbers according to the ASCII Table. The fifteenth pin is the A (anode) , and the last one is K (cathode).

The IDE Now that we have a little undrestanding of what Arduino and the LCD are, let"s jump ahead into the Arduino IDE and install that on our computer. Arduino IDE can be downloaded from Or from the windows store on windows 8. The IDE is the place where coding takes place. Here, the codes are written in C and C++. After compiling the code and troubleshooting the mistakes, the complied code is sent to the Arduino Board using the USB 2 cable. After installing the IDE we implement the Liquid Crystal package as shown below. Liquid Crystal Package implementation... Installing LiquidCrystal package opens our access to use the methods and implementations defined in the specific package regarding to the LCD on our IDE to be compiled and stored into the Arduino board. After package installation, the setup and loop are written in the IDE. Follow the above and copy the parameters to make a connection between the board and the LCD.

Compiling and Storing the Code into the Arduino For the last step, connect the Arduino to the computer using a USB-2 cable. compile the code and select the Arduino UNO on the IDE and store the code into the Arduino by clicking on the horizontal arrow on the top left corner of the IDE.

The note "Arduino" should be appearing on your LCD. Congratulations !!! You have made your first text on the LCD... Now if you want to go the extra mile, www.arduino.cc has all the methods and explanations that can be used to use on your text for further design and change, move, personalize your own text. Above are some of the example codes found in the website. Try them yourself.

Think back to the pre-iPhone era, when the only time you touched your phone’s tiny black-and-white LCD screen was to wipe it clean. Back then, Nokia’s 3310 and 5110 cell phones used these tiny LCDs.

As technology progressed, these displays found a new place in the world of DIY. They quickly gained popularity among hobbyists due to their small size (about 1.5″), low cost, ease of use, low power consumption, and ability to display text as well as bitmaps.

The PCD8544 controller’s on-chip LCD supply and bias voltage generation reduces power consumption, making it suitable for power-sensitive applications. The LCD normally consumes only 6 to 7 mA.

According to the datasheet, this chip operates in the 2.7 to 3.3 V range and has 3V communication levels. Therefore, in order to interface it with a 5V logic microcontroller such as Arduino, some sort of logic level shifting is required.

The backlight is made up of four LEDs spaced around the display’s edges. To change the LCD’s backlight, remove the LCD from the board by pushing the metal clips on the back side. You’ll notice four LEDs soldered around the display’s edges. Simply replace the LEDs with the desired color LEDs.

The PCD8544 LCD driver includes 504 bytes of Graphic Display Data RAM (GDDRAM) that stores the bit pattern to be displayed on the screen. This memory area is divided into 6 banks (from 0 to 5). Each bank has 84 columns/segments (from 0 to 83). And each column can store 8 bits of data (from 0 to 7). That certainly proves that we have:

RST pin is used to reset the display. It is an active low pin, which means that by pulling it low, the display can be reset. By connecting this pin to the Arduino’s reset, the screen will be automatically reset.

BL (Backlight) pin controls the backlight of the display. By connecting this pin to any PWM-capable Arduino pin or by using a potentiometer, the brightness can be controlled.

Connections are straightforward. The serial clock(CLK), serial data(DIN), data/command(DC), chip enable(CE) and reset(RST) pins are connected from pin 7 to pin 3 on the Arduino.

Finally, the backlight(BL) pin is connected to 3.3V through a 330Ω current limiting resistor. If you want to control the brightness, add a potentiometer or connect this pin to any PWM-capable Arduino pin.

The PCD8544 LCD controller has flexible but complex drivers. To use the PCD8544 controller, extensive knowledge of memory addressing is required. Fortunately, the Adafruit PCD8544 Nokia 5110 LCD library was written to hide the complexities of the PCD8544 controller, allowing us to control the display with simple commands.

Filter your search by typing ‘nokia‘. There should be a few entries. Look for Adafruit PCD8544 Nokia 5110 LCD library. Click on that entry, and then choose Install.

This library is a hardware-specific library that handles lower-level functions. To display graphics primitives such as points, lines, circles, and rectangles, it must be paired with the Adafruit GFX Library. Install this library as well.

This sketch will provide you with a thorough understanding of how to operate the Nokia 5110 LCD display and can serve as the foundation for more practical experiments and projects. Try out the sketch, and then we’ll go over it in detail.

The next step is to create an object of Adafruit_PCD8544.h. The Adafruit_PCD8544 constructor accepts five Arduino pin numbers, which are connected to the display’s CLK, DIN, D/C, CE, and RST pins. There is also a rotatetext variable defined, the significance of which will become clear in a moment.

In the setup function, we initialize the LCD object using the begin() function. We also set the contrast of the display using the setContrast(value) function, where value can range from 0 to 100. However, a value of 50-60 produces excellent results.

To display text on the screen, we must first set the font size. This can be accomplished by calling setTextSize() and passing a non-negative number (starting from 1) as a parameter.

The final step is to use the display() command to instruct the library to bulk transfer the screen buffer to the PCD8544 controller’s internal memory and display the contents on the LCD.

To display inverted text, we use the setTextColor(FontColor, BackgroundColor) function. If you’ve been paying attention, you’ll notice that we previously passed only one parameter to this function, but now we’re passing two. This is possible due to function overloading.

The print() or println() functions can be used to display numbers on the LCD. Because an overloaded implementation of these functions accepts 32-bit unsigned int values, you can only display numbers ranging from 0 to 4,294,967,295.

The print() and println() functions send data to the display as human-readable ASCII text, whereas the write() function sends binary data to the display. This function can thus be used to display ASCII symbols. For example, sending 3 displays a heart symbol.

You can rotate the contents of the display by using the setRotation() function. It allows you to view your display in either portrait or landscape mode.

This function takes only one parameter, which corresponds to four cardinal rotations. This can be any non-negative integer beginning with 0. When you increase the value, the display’s contents rotate 90 degrees anticlockwise. For example:0 – Maintains the screen’s standard landscape orientation.

Our last example shows how to draw bitmap images on the Nokia 5110 LCD display. This comes in handy when displaying things like logos, sprites, infographics, or icons.

The drawBitmap() function is used to display a bitmap image on the LCD. This function accepts six parameters: the top left corner X coordinate, the top left corner Y coordinate, the monochrome bitmap byte array, the bitmap width in pixels, the bitmap height in pixels, and color.

But, before we can use the drawBitmap() function, we need an image to draw. Remember that the display’s screen resolution is 84×48 pixels, so images larger than that will not display properly. To get a properly sized image, open your favorite drawing program, such as Inkscape, Photoshop, or MS Paint, and set the canvas size to 84×48 pixels.

Once you have a bitmap, you must convert it into an array that the PCD8544 controller can understand. This can be accomplished in two ways: with image2cpp (online) or with LCD Assistant (offline).

The dimensions of your image will be displayed in the Canvas size option under Image Settings. If your image is larger than 84×48, change it to 84×48 by selecting the appropriate scaling option. You can see the result in the Preview section.

When you are satisfied with the results, you can proceed to generate the data array. Simply select Arduino Code as the code output format and press the Generate code button.

For your information, there is a setting called “Draw Mode”. It actually generates images based on the scanning pattern of the display. If your image appears distorted on your screen, try changing the mode.

There’s also a Windows application called LCD assistant that can turn your bitmap image into a data array. It is not as powerful as image2cpp, but it is still widely used by hobbyists.

For your information, there is a setting called Byte Orientation. It actually generates images based on the scanning pattern of the display. If your image appears distorted on your screen, try changing the mode.