nokia 5110 lcd screen factory

The Nokia 5110 LCD is very popular among the Arduino tinkerers. These modules are used on wide variety of applications that require some sort of interface or display data to the user.

Nokia 5110 LCD Module can be powered by 3.3V to 5V. But it is recommended to use with 3.3V. It consumes very low power as less than 3mA when no backlight is used.

All necessary functions for the display are provided in a single chip, including on-chip generation of LCD supply and bias voltages, resulting in a minimum of external components and low power consumption.

I had a project that needed some live data display, and looking for the cheapest low-power solution for our loggers lead me to the Nokia 5110 LCD. Once you get the backlight current under control, you can power the entire display from a digital pin, and if you use shiftout for soft SPI you can then get rid of the Reset and CS control lines. This brings the display down to any four wires you can spare on your build (incl. the power pin) and a ground line. This is much more manageable than what you see with the standard hookup guides if your mc is I/O limited like our pro-mini based loggers:

This LCD (I have the old-old kind) is absolutely my favorite. Yes, it has a board-to-glass connector that ranges from bad to abysmal, but it offers such a simple interface and so many pixels for so little money (obviously less if you buy only the panel.) Here are some clever things I"ve discovered:

Will fully operate on as little as 2.0V. That"s power (Vdd) and i/o. It can be driven at 2MHz at these speeds; in fact, the LCD will work at even lower voltages but the contrast fades quickly and your microcontroller will likely approach its lower voltage limit too.

The LCD will work with the chip-select pin (SCE) tied to ground. This means that if it"s the only device on the SPI bus, don"t bother framing the i/o with a chip-select pin. If the bus is shared, frame the entire transaction, not every individual byte you send to the LCD. Interestingly, the display also seems to work fine with a floating Vdd pin - it must draw sufficient power just from i/o via clamping diodes; not surprising when you consider how low-power it is.

The Vout pin: Looks like you don"t have to worry about it on this product, but the bare LCD will generate positive 6-9V on that pin. This wasn"t totally clear to me from reading the datasheet.

(5) If you are using a PIC to run ths thing, and using the PIC"s USART or EUSART in a synchronous mode, be sure to note that the LCD controller expects the MSBit of each byte to be transmitted first on the serial line. The PIC 18F EUSART transmits the LSBit first. For now, I have lots of extra code space, so I"ve wasted a 256-byte section on a lookup table that reverses the bits in a byte. This way, I just write my initialization code normally, and I have a TransmitCommandByte() function that looks up every byte it sends so I don"t have to think about that.

Thank you! I"m not quite sure I do want an LCD yet, to be honest, I"m just considering the different options available. I"ll check out the Sharp component, thanks!

Advice for others: It took me quite a while to get this working on an ARM Cortex. Since there is no way to read from the LCD, it is very hard to know if SPI is working without doing everything perfectly. SO:

The problem I had was solid black display screen. No matter the combination of bias and contrast values that I set. The unit wasn"t totally defective, because under a strong lamp light you could see the display trying to show the letters and pictures that are in the tutorial for Arduino that I got from SFE.

If the LCD module is soldered to another board and the two top screws installed and tightened carefully to pull the bow out of the module it seems to prevent (or solve) the problem.

I"m using voltage dividers to supply 3V in the inputs of the LCD, because of the Arduino works in 5V. LCD Vcc and LED are powered from the 3.3V output of the Arduino. The LCD only displayed something when I used: R1=470K,R2=820K. I have tried several values to obtain 3V, but the LCD showed nothing. I don"t understand that.

I"m interfacing this LCD with ATMEGA 32. Its been more than a week that I"ve been trying to get it right. All I get is the LED dimming effect. Here is my initialization code..CE=1;

I have a similar board made by mib-instruments and bought from ebay years ago. It has been my standard spi test tool because it"s so easy to work with. http://www.ebay.com/itm/Nokia-5110-LCD-84x84-dot-martix-backlight-PCB-RED-/320684678723 (specs http://i1119.photobucket.com/albums/k636/mib_instruments/diy/LCDC2A0SPEC.jpg)

I almost have it working satisfactorily but I find that the bottom 1/5th of the screen does not function correctly. Sometimes it has some random blocks that are black, most of the time it is blank. I am not sure what would cause this. Is it safe to assume it is a defect on this module?

These LCD"s need cleaning. I have an average failure rate of about 15-20% on delivery. The most common problem is that the contrast is too high, and there"s constant flickering / changing of contrast compared to the other 80% of them.

The solution is fairly simple, unclip the LCD from it"s board and clean the pads on the PCB with 99% IPA. Then remove the lcd back plate and contact bar. Sometimes the contact bar is stuck fairly well to the glass, peel off carefully. Clean the contacts on the LCD glass with IPA, if any residue from the contacts is left on, rub it off carefully with IPA / tissue.

I love this little display! I wanted to be able to create images for it but nothing I saw did exactly what I wanted. So I wrote a processing sketch that creates 84x48 squares on the screen and allows you to click to turn them on or off. Also has buttons to invert, move up/down/left/right, and flip horizontally/vertically. Then, it saves the hex data to a text file to copy to your code. You can also load an image (any size, any colors) and it will scale it, convert to b/w, then put it in the rest of the program so that you can alter the pixels or move it. It isn"t perfect for every occasion but I"ve found it useful and I hope others might too. It is heavily commented so it should be easy to figure things out and change them if you want something different. http://thewanderingengineer.com/2014/07/12/nokia-5110-screen-photo-to-bitmap-converter/

Never mind, I had no problem running it at 5V directly from the Arduino with the contrast value bumped up to 45 or above. With 10K ohm resistors on the control lines as shown in the sample hookup, I get a blank screen. Also removing the backslash from the sample code got garbage characters, so I left it in.

Anyone taken these things apart yet? You know the flexible rectangular blocky thing that connects the contact pad on the board to the LCD itself? What are these called?

Got mine running last night and found two problems with the code, one of which was the backslash a couple of others have already noted. Second was that the LCDCharacter() writes two blank vertical lines, one before the character and a second after, when only one is needed. Without the extra blank you get at least one additional character on each line. I"ll probably also move the ASCII font table to PROGMEM space to save on RAM and then start to work on some big digits for a clock.

I"m using this LCD for a large Arduino UNO project, but I"m running out of SRAM memory space. I was wondering if I used PROGMEM on the LCD ASCII array if that would help. If so, does anyone know what the right code for this would be? After looking through a lot of PROGMEM examples, I"m not advance enough to really grasp everything that"s going on. Any help you can give would be a great help. Thanks in advance!

I used one of these LCDs with an Arduino to display GPS information. I wrote a few functions that can display large numbers (28 px high) if anyone is interested, this lets me display speed, heading etc. A writeup of my project is here: http://mechinations.wordpress.com/2014/04/07/gps-sailing/

These are great displays. I ran into a problem using them with the nRF24L01+ radio transciever, which requires the use of the SPI bus. If one attaches both the radio and the display MOSI and SCK pins to pins 13 and 11 as instructed in the hookup guide, the SPI traffic of the other device (in this case the nRF24L01+ radio) will prevent the display from functioning. The easy solution is to move the Nokia 5110 MOSI and SCK pins to any other digital pin. This should be made clear in the hookup guide, where it says there is no choice but to use the hardware SPI pins for the display. I found out that is not true at all. I hope his helps others with the same problem. Despite the occasional bad display these carry much more information that the comparably prices 16 x 2 LCD and use fewer pins too boot. What a deal!

I was able to get this work only after using 5v, and lowering the contrast by int from 55 to 45 to remove the "black box" flickering behind the screen drawings. When I power with 3.3v, nothing - just the LED and dimming etc of the screen. I"d love to use 3.3v (and it seems based on responses here) that it should run only on 3.3v. Any ideas anyone?

This is a great display for the money, certainly the best bang for the buck of you can live with B&W and lower res graphics. I have a lcd driver for Arduino I will post on http://www.marchdvd.com/5110 so take a look there it draws text aligned on pixels boundaries of 8 and draws lines and has invert video options.

I just started messing around with this LCD using a STM32F103 microcontroller running at 72MHz... it works great. The only problem I had, and I suspect others might have if they are using fast processors, is that you have to deliberately introduce the setup and hold time delays on the DC pin... if you don"t you will get spurious pixels written to the display. I used a delay of 10uS, although the spec says 100nS is fine.

I been trying to display 8-10 images as an animation. The individual images all work, but when I trey more than 8 images, nothing happens on the screen, and above 2 images, I get errors in the drawing of the images. Is there some kind of buffer or violent reset I can do so that the data doesnt get jumbled up?

I just spent the last couple hours struggling with this LCD because of something very stupid of me. I was using an atmega328p in AVR-GCC and using hardware SPI. Thinking i didn"t need MISO I hooked it to DC. The LCD worked absolutely fine until I tried to set the x and y position in the ram. It started acting weird every time I tried it. Finally I put dc to another pin and BAM NO PROBLEMS. Looking back I feel pretty stupid but hopefully this post will save someone else the same mistake. Other than that great LCD for my projects

The Energia folks have an example program for this LCD and the TI Launchpad written using their Arduino style tooling. I"ve updated their example and added the ability to report back the temperature over a UART. It is a very simple hardware setup since both systems are 3.3v. http://joe.blog.freemansoft.com/2012/08/digital-thermometer-with-ti-lanchpad.html

I did find another example (did"t save it and can"t find it again) that worked with the Adafruit libraries as it was supplied (including graphics), but trying to change it in any way beyond changing the text of the "Hello World !" string (which actually shoed on screen as "Hffmmp Wpsme !", so obviously a coding problem there!!!) just locked everythig up.

I tried using the "LCDAssistant" package to create a logo from a graphic that I resized to a b&w jpg of 84x48 but every byte generated was 0x00 so that was not right. I tried fiddling with the settings (flying blind) but still got nowhere - does anybody know the settings for LCDAssistant and this display and has used it successfully?

One of the things that I test regularly is a commercial item that features a 16x4 (HD44780) display. Currently I have a 20x4 on a flying lead that I plug in to determine if a display failure is down the lcd display or the main board.

Is there any way to get the 5110 Graphic Display to work with signals that were feeding to an HD44780? - if I could build that in then I would have a complete multi-testing set up in one box.

I am using arduino example and while i am getting proper images and text i also get some odd horizontal flickering. It looks like several horizantal lines across the screen on the background with image/text on foreground. I tried switching to only use digital pins on my arduino leonardo but i still see this behaviour. Any ideas?

Make sure your power is regulated correctly, and that all of your soldering points and connections are good. It may simply be a bad screen. If you still run into problems, shoot us an email at techsupport@sparkfun.com

Is there mechanical documentation for this (location of mounting holes, location of screen relative to board, etc)? Yes, I can measure it but I"m lazy...

Might I suggest you (SFE) source some of the Electronic Assembly"s LCD Dog-S series. I think they would be a step up from these at a reduced price. I don"t think that they website is up to date, but their part number is LED39x41-GR.

I made a little font generator for the Nokia 5110 in the processing programming language (processing.org). It allows you to convert any font and any character that you can display on the screen into a list of hex codes that can be directly used in an embedded system (I"m using msp430). Just type a character and the corresponding hex codes will be in your clipboard and you can copy them into your program. It starts with an example with the chinese character for 5. It should work on any system that can run processing (e.g. mac osx).

I finally got around to running this LCD on my 3310 PCB. It is working fine with one minor problem. The SF 3310 display hides to first line of bytes for some reason and I had to offset everything to compensate. The 5110 doesn"t do this as behaves as expected. I haven"t heard anyone else report this so maybe my initialization code is different.

Using a 3V source, my LCD often worked OK using bias 0x14 like the other examples, but sometimes it would appear gray and faded. The fading would lessen if I touched the panel lightly with my hand for a few seconds, then let go, so maybe it"s a temperature-dependent thing?

Ack! After two days of working nicely with 0x15 bias, I reset the board today, and the LCD appeared way over-dark. I changed the bias back to 0x14 and it looks perfect. What the heck?! I think there must be some temperature-sensing or temperature-dependence going on, so the same init values may produce good-looking results one day but not the next.

If you are having problems with the black pixels in images/warping PCB, use original Nokia 5110, I happened to have one at home and it works as it should, no bad connections degrading image quality.

Does anyone know whether this can be stripped of its backing so it can be used in transmission? I would love to use this as a modulator for a laser beam. Or if someone knows a similarly cheap transmission LCD that would be fine too.

Stuck. Blank LCD. Added 0x20, changed Vop to 0xB3. Guessing connections may be the issue? 3.3v for LED and VCC. GND to GND. Remainder connected to Arduino via voltage dividers. What am I doing wrong?

This is a great little lcd. When I first wired it up, the backlight was shorted (accidentally) against my 5v rail, so i got some magic smoke, and burnt to LEDs but it re-soldered the offending joints and it works very well now. Something to note: the refresh and write times are much, much slower if you use 5 volt logic. I stuck in a logic level converter and it ran at least 5x faster.

You can also use FastLCD to convert your bitmaps - google it. It outputs BASIC code, but you just search and replace &h to 0x and you"re grand. It has the added advantage of being an editor for touching up output.

I found that same 0xB3 value works just right for the two units I have. I wonder if some of the difficulties people have getting them going is from using "E0" or "BF" or some of the other values I"ve seen posted. When I first powered mine up, I got NOTHING on the screen, and I would have thought it was dead, or assumed mine had "bad connections", if I hadn"t known to play with that Vop value...

I recently obtained a virtually identical LCD from a Nokia 5160, and although its backlight LEDs are green, not white and conversely use different voltages, I had success hooking up the LEDs" Vcc pin to a PWM capable pin on the microcontroller, allowing me to control backlight intensity (I didn"t need a current limiting resistor for this either, but adding one will help reduce current drain on the controller).

Seems like the PCD8544 library does it"s own SPI bit managing and it really doesn"t like me using the SD library (also talks SPI) at the same time. I"ve made sure I"ve got all the SPI pins matching for both libraries (MISO, MOSI, Clock are the same and each device has it"s own Select), but it looks like the SD.begin() call just breaks the SPI bus for the 5110 and it becomes non-responsive. The LCD works just fine if I don"t initialize the SD library and the SD card works fine if I do initialize the SD card.

I"m pretty sure I tracked down the problem- the PCD8544 library uses software SPI while the SD library uses hardware SPI and I"m pretty sure the Arduino can"t do both over the same SPI clock/miso/mosi pins. Anyone know if this LCD will work with hardware SPI?

I"ve had issues with the LCD not showing anything intermittently. You got to make sure that all the connections are secure, and for the reset pulse, be sure to have a delay that"s 30-50 milliseconds long.

As much as I love SFE products and will continue to order from them, this is one product I would not recommend. The connection between the LCD unit itself and the carrier board is via those rubber polymer connectors. All the planets must line up properly for them to work. In this case, the carrier board was warped preventing the connection from working. You will find other such remarks in the comments area.

I have mine working now! The secret was oz-solutions"s linked-to observation about the second code example which does more initialisation. I suspect that the default contrast etc makes the screen blank.

Don"t do this. Each divider will be burning 20x the entire amount of current that the display needs to function, and the whole assembly will waste 100x the LCD"s needed power and many, many times more than even the atmega needs to run at full speed. This will kill battery life.

I got this little screen for my Netduino but it just won"t work! I"ve tried everything, and even worked on it with someone who had the same screen but it won"t work. We got it all right, but it just won"t work. If anyone here gets it to work with the netduino please let me know.

Hi, I just bought this wonderful LCD but I"m having huge huge problems connecting it..could anyone please point me in the right direction? Since there are pins that aren"t metioned in the code, for example the 6 - DNK(MOSI)...

Does anyone know the diode rating and package size, also does anyone know where to get the rubber ferroius connector behind the LCD mine is defective. Has anyone come into issues with the breadboard the LCD is connected to, a few aren"t working for me.

Yes, we have noticed that the PCB was bowing and as a result the LCD now only works when we press down on the metal strip at the top. I hope that only a small number of these LCDs have this problem. We"re expecting a shipment to arrive today, I will be running more tests.

Edit: After leaving glue to dry overnight, LCD simply does not turn on anymore. All the connections are good, but absolutely nothing shows on the LCD now at all. Only the LEDs come on.

Did you get either of the LCDs to display anything, at any time? Is it possible that the connections were OK, but you were not initializing or driving them correctly? Or did they start to work at one point, and then fail at some later point?

When I originally tried to get mine working, I was seeing NOTHING on the display. Then I had to get my initialization sequence correct, and adjusted my Vop value (ultimately using a byte of 0xB3) before the screen would display anything visible at all.

Note that the backlight LED"s are soldered onto the breakout board, and have nothing to do with the circuitry of the controller and LCD. So just because the backlights are shining doesn"t tell you anything about the operability of the LCD itself.

It depends on the code that you are using to control the LCD. If you are using the Arduino example above, the pins are defined in the beginning of the code.

FWIW I have connected this LCD with a 5V power supply to a 5V Arduino board with no level conversion and it worked. Presumably this may reduce the lifetime of the LCD.

I am attempting to use this with a Duemilanove (ATmega328). Up til now, I have been powering it with the 3.3V line, including the LED. The datasheet for the LDC claims: "VDDmax = 5 V if LCD supply voltage is internally generated (voltage generator enabled)." The logic levels should be kept from 2.7V to 3.3V. Since the Duemilanove uses 5V logic levels, I am using a simple voltage divider on the communication line with no issues.

The maximum logic value of 3.3 volts made me cautious of driving the LCDs at the native 5 volts of my Teensy AVR. That said, running purely off 5 volts seems to do no harm to the LCD.

For those interested, I have taken a few measurements of the current draw of the LED backlight of my LCD. As I said earlier, powering the LED with 5V external has caused permanent damage to one, perhaps two of the four LEDs. So, use the following graph at your own risk.

Is there any more documentation available for the additions to the LCD? For example, the datasheet has no information (that I could find, at least) on the LED. Everything seems fine on 3.3V, but what is the current limit on the LED? (note: if it wasn"t for work, I would just mess around with it myself.)

If you want to wire up several up these to a single microcontroller, you might take advantage of my freshly GPL"d C++ driver library for PCD8544 devices. It"s templated, so you can avoid duplicating code all over the place. Here"s a picture of two PCD8544 screens running off of an ATmega328. (The screens are operating independently, even though they happen to be showing the same logo graphic in that picture.)

Here is a PicBasic Pro example for the 3310, which should be compatible with the 5110. http://www.picbasic.co.uk/forum/content.php?r=174-Using-Nokia-3310-LCD

Fantastic! It appears from your example link that this uses the same controller as the Nokia 3310 that I"ve already used in past projects. The only thing that made it so cumbersome was trying to connect to its fine pitch press on type connector. This gives me a great low cost display option that is easy to connect to.

If anyone doesn"t have experience with this LCD, take a peak at the Arduino example link above to see just how easy it is to use. If you use plain C on your AVRs, I have sample code on http://tinkerish.com.

Floppy Emu uses an 84×48 graphical LCD display. It’s just a low-resolution 1-bit display, but it’s fast and easy to use, and has a nice built-in backlight. The display is actually a clone of the old Nokia 5110 phone display, and it’s made by semi-mysterious third-party factories in Shenzhen. It can be purchased in bulk for about $2.50 apiece.

The big problem with these Nokia 5110 displays is that their reliability stinks. The actual LCD module (the glass and metal bit) is clipped onto a supporting PCB with some passive electronics, and it’s only a pressure-fit holding the two together. If it’s not clipped in just right, the display will exhibit contrast problems, or glitchy behavior, or just won’t work at all. Gently pushing on the LCD frame sometimes changes the pressure-fit enough to make these problems appear and disappear. Adjusting and tightening the LCD clips, as described in the Floppy Emu manual, is the only thing I’ve found that helps.

The electronics assembler that builds Floppy Emus must go through every LCD to check for problems. They usually end up discarding about 10% of all the LCDs, because they don’t work no matter how the clips are adjusted. Once the boards are finished, I do a second check of each LCD immediately before it’s shipped to the customer. This often requires more fiddling with the clips, or manual contrast adjustments, and a further 5% of LCDs are discarded. It’s very time-consuming, but despite all this effort, some troublesome LCDs still reach customers who must then make further adjustments.

In the most recent batch of LCDs, the pressure-fit contact design changed slightly, and it now appears to be even more troublesome than before. At the same time, the LCD bezel was unexpectedly enlarged by 2mm, forcing me to redesign the Floppy Emu acrylic case to match. This is a risk of buying generic parts from eBay and Alibaba, with no manufacturer to stand behind them or datasheet to document them.

It would be very nice to replace the 5110 displays with something similar but more stable. A replacement would need to handle about 84 x 48 1-bit pixels (equivalent to 21 x 6 text characters), with a diagonal size about 1.5 inches, and ideally use an SPI interface. Unfortunately, I’ve found nothing that even comes close. The alternatives are either much too large/small, lack graphical capabilities, are too slow, or are much too expensive.

Character and numeric displays aren’t appropriate, since they can’t do graphics or six rows of text. So looking at Digikey’s Display Modules – LCD, OLED, Graphic category, and sorting by unit price quantity 100 purchasing, and including only those results that have at least a few hundred units in stock, I found these:

128×128 RGB LCD, 1.44 inch diagonal, $4.23 – This could almost work, except I believe it’s a 24-bit color display, so the microcontroller would need to move 24x as much data to draw on it. And because it’s a much higher resolution, the amount of data to moved must be still higher to maintain the same font sizes as the old display. And it’s a slow I2C interface, instead of fast SPI. And there’s no datasheet.

128×64 OLED, 0.96 inch diagonal, $2.91 – This could sort of work, and I have one of these modules already. But it’s tiny, smaller than a postage stamp, which isn’t really suitable. It’s also I2C which means the interface is comparatively slow. Coming from a random non-branded eBay seller, it’s also not clear it would be any more reliable than the LCD display I have now.

128×128 RGB LCD, 1.44 inch diagonal, $3.04 – This is basically the same as the $4.23 module from DigiKey. Although this one says it has an SPI interface. Maybe this is the best option from a list of not-so-great alternatives.

Other for the Nokia 5 display LCD options are easy to find and replace. Find all the nokia 5 LCD options in bulk, and lcd options are easy to find and replace. Nokia 5 lcdds in bulk, are a great option for those looking for a more affordable option.

When looking for a Nokia 511 lcd, there are a variety of options available. Alibaba.com ’ s suppliers provide you with a variety of LCD options, including the Nokia 511 lcd, Nokia 511 Lcd, and Nokia 511 lcd are available in a variety of colors, styles, and sizes. One of the best Nokia 511 lcd is available in black, white, and light colors. Nokia 511 lcd is available in black, white, and light colors. Nokia 511 lcd, Nokia 511 LCD, and Nokia 5 11 displaycd are a of the options available. Including black Nokia 511 lcd, Nokia 511 LCD, and Nokia 5 11 displaycd are available with a variety of options.

The Nokia 5110 is a basic graphic LCD screen for lots of applications. It was originally intended for as a cell phone screen. This one is mounted on an easy to solder PCB.

It uses the PCD8544 controller, which is the same used in the Nokia 3310 LCD. The PCD8544 is a low power CMOS LCD controller/driver, designed to drive a graphic display of 48 rows and 84 columns. All necessary functions for the display are provided in a single chip, including on-chip generation of LCD supply and bias voltages, resulting in a minimum of external components and low power consumption. The PCD8544 interfaces to microcontrollers through a serial bus interface.

All categories360 mount3D Printed Parts3D Printer partsAC-DC Boards & AdaptorsAC/DC converterAcceleration & Rotation sensorAdapterAlphanumeric LCDAmplifier moduleAntennaArduino & AVRArduino & Interfacing CableAudio adapterAudio ConnectorsAudio ModulesBasic Robot PartsBatteryBattery ChargerBattery HolderBergstripBiometric & Touch SensorBJTBLDC MotorBluetooth ModulesBluetooth remote shutterBMSBNC connectorBO MotorBox ConnectorBoxes & EnclosuresBreadboardBridge RectifierBuck-Boost ConvertersBuzzer and SpeakersCableCable Clampscamera holderCard ReaderCellCeramic CapacitorChrome castCOB LEDCommunication ModulesconnectorConsumablesController boardcontroller moduleControllers ICConverter ICCooling BlockCooling FanCounter ICCrimping ToolsDC Gear MotorDC MotorDiacDigital Logic ICsDiodeDIP SwitchDot MatrixDrill ChuckDrone PartsEEPROM ICElectrolytic CapacitorEncoder & Decoder ICsEnd TerminalsESP BoardsExtension AdapterfilamentFilm Capacitorfinger printFlat CablesForce & Pressure SensorsfuseFuse & Fuse HoldersGeneral TransistorsGlue Gun and SticksGPS ModulesGraphics LCDGSM & GPRS ModulesHatchnHack KitsHatchnHack ProductsHDMI PortHDMI switchHDTV to VGA AdapterHeadphone jack adapterHealth SensorsHeat ShrinkHeat SinkHeat Sink CompoundHi-Link ConvertersHookup WiresICIC Base & Zif SocketsIGBT MOSFETIntegrated Circuits & ChipsIoT GatewaysJST FemaleJST MaleJST SM PairJumper WiresKoptan TapeLaser DiodeLCR meterLEDLED driverLED DriversLED IndicatorLED PCBLED StripsLight, Sound Sensor & Vibration SensorLimit SwitchMagnetic SensorsMeanwell SMPSMeasuring InstrumentsMicro - HDMI Type-D ConnectorMicro SwitchMicrophoneMiscellaneous Development BoardMiscellaneous ModuleMobile mountModuleMolex ConnectorMonopodMornsun power SupplyMOSFETMOSFET/DIODEMotorMotor AccessoriesMotor DriverMotor Driver ICMulti Strand WiresMultiturn PotentiometerNeodymium MagnetsNuts & BoltsOperational amplifierOperational AmplifiersOptocoupler ICOptocouplersOrange PiOscillatorsOTGOther Soldering ToolsOther ToolsPH SensorPot PotentiometerPotentiometerPotentiometer KnobsPower & Interface ConnectorsPower & Interfacing CablePower & Interfacing CablesPower AdapterPower Bank ModulePower JackPower mosfetPower supplyPower transistorPower TransistorsPreset PotentiometerProgrammersPumps & ValvesPush ButtonsPVC Heat ShrinkPVC TerminalsPWM ICsRaspberry Pi & AccessoriesRectifierReed SwitchRegulatorRelayRelay ModulesRelaysRelimate FemaleRelimate MaleremoteRemotesResistance Based Light SensorResistance Based SensorResistance Based Temperature SensorResistorResistor NetworkRework stationRF ModuleRocker SwitchRotary SwitchRTC & ADC ModulesScrewdriverSD card adapterSensorServo MotorSeven Segment DisplaySlide & Toggle SwitchSMD Capacitors 0603SMD Capacitors 0805SMD Capacitors 1206SMD General DiodesSMD LEDSMD Resistor 0402SMD Resistor 0603SMD Resistor 0805SMD Resistor 1206SMD Schottky DiodesSMD Zener DiodesSmooth RodsSMPSSocketSolar PanelsSolder PasteSoldering Iron & AccessoriesSpacers & StandoffStepper MotorStereo AdapterSwitchSynchronous MotorTantalum CapacitorTapesTemp, Humidity & Gas SensorTerminal BlockThermal SwitchThrough Hole General DiodesThrough Hole InductorThrough Hole LEDThrough Hole Resistor 1/2WThrough Hole Resistor 1/4WThrough Hole Resistor 1/8WThrough Hole Resistor 10WThrough Hole Resistor 1WThrough Hole Resistor 2WThrough Hole Resistor 5WThrough Hole Schottky DiodesThyristorTimer ICsTouch ICTouch SwitchTransformersTransistorTriacsTrimpot PotentiometerTweezersUltrafast diodeUltrasonic & ProximityUltrasonic & Proximity SensorUSB lightUSB ModuleVaristorVibrator MotorVoltage & Current SensorVoltage regulatorVoltage RegulatorsVoltage_Sensor_Measuring_InstrumentsWater Sensorwifi moduleWire Cutter & StrippersX Y PlottersZener DiodeZero Board & Copper CladsZip Ties

The main code of the project is very simple. We need to include the Nokia 5110 library. Next we declare some variables. We initialize the display and we print the ui icon once. Then we read the analog value from the sensor second. All the magic happens in the loop function:

In the loop function we first clear the display and we print the UI icon. We then read the sensor value. After this, we covert the analog value we read in percentage value, and this value we convert it into a String variable in order to display it on the screen. This procedure is repeated every second.

This is a monochrome LCD module comprised of 84x48 pixels that can be used to display rich graphics and text content. Though it"s an industrial module, this LCD display is extremely easy to use. This module is a revision that accepts 3-5v input. So no extra level shifter is needed. To have full control, you just need 5 pins. and as a classic display module among open source communities.

It uses the PCD8544 controller, which is the same used in the Nokia 3310 LCD. The PCD8544 is a low power CMOS LCD controller/driver, designed to drive a graphic display of 48 rows and 84 columns. All necessary functions for the display are provided in a single chip, including on-chip generation of LCD supply and bias voltages, resulting in a minimum of external components and low power consumption. The PCD8544 interfaces to microcontrollers through a serial bus interface.

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.

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.

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.

D/C (Data/Command) is used by the library to separate the commands (such as setting the cursor to a specific location, clearing the screen, etc.) from the data.

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 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.

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.

Before printing the message, we must first set the cursor position by calling the setCursor(X,Y) function. Pixels on the screen are referenced by their horizontal (X) and vertical (Y) coordinates. The origin (0,0) is located in the upper left corner, with positive X increasing to the right and positive Y increasing downward.

To print the message on the screen, we can use the print(" ") or println(" ") functions, similar to how we print data on the serial monitor. Keep in mind that println() will move the cursor to the next line.

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.

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.

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.

The drawRect() function can be used to draw a rectangle on the screen. This function accepts five parameters: X and Y coordinates, width, height, and color. This function actually draws a hollow rectangle with a 1 pixel border. The fillRect() function can be used to draw a filled rectangle.

The drawRoundRect() function can be used to draw a round rectangle on the screen. This function accepts the same parameters as drawRect(), with the exception of one additional parameter – the radius of corner rounding. This function actually draws a hollow round rectangle with a 1 pixel border. The fillRoundRect() function can be used to draw a filled round rectangle.

The drawCircle() function can be used to draw a circle on the screen. This function accepts four parameters: the X coordinate of the center, the Y coordinate of the center, the radius, and the color. This function draws a hollow circle with a 1 pixel border. The fillCircle() function can be used to draw a filled circle.

The drawTriangle() function can be used to draw a triangle on the screen. This function accepts seven parameters: three X and Y coordinates (x0, y0, x1, y1, x2 & y2) of triangle vertices, and a color. (X0, y0) is the top vertex, (x1, y1) is the left vertex, and (x2, y2) is the right vertex.

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).

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.

In this user guide, we will learn to interface Nokia 5110 Graphic LCD Display with ESP32 using Arduino IDE. We will discuss how to display simple texts, rotate texts, draw numbers and shapes on Nokia 5110 LCD display. Additionally, we will also display a monochrome bitmap image on the screen.

Nokia 5510 LCD display is a graphics screen LCD display and has been used for a lot of applications. Initially, it was designed only for iconic Nokia 5510 cell phone screen but now we can easily use it for different purposes such as for displaying alphanumeric characters, draw lines, shapes, and even for displaying bitmap images because of its 84X48 monochrome pixels that mean 84 columns and 48 rows. All necessary functions of this display are packed in a single small chip which is operated at very low voltages. It is very cost effective, more precise, more reliable and easy to use than LCD display.

The pin configuration of the LCD is almost SPI but in one-way only. The LCD only uses a one-way communication to operate because it doesn’t have to send any data to the microcontroller. However, it has two modes of data and command modes for operating properly.

Pin2:Chip Enable (CE)The enable pin in SPI helps to select the device in case of multiple devices. Here it will active the LCD with the LOW input signal.

Sixth pin is the VCC pin, which is voltage supplying pin and is used for turning the LCD display ON or OFF. This LCD display requires 2.7V-3.3V DC voltage to power it up.

As we have seen above, the Nokia 5510 LCD display has 8 terminals which we will connect with the ESP32 board. As the OLED display requires an operating voltage in the range of 2.7-3.3V hence the VCC terminal of the LCD display will in common with the 3.3V pin of the ESP32 board. Likewise, both the devices will have their grounds in common. The SPI communication helps to communicate with LCD, which is common in every microcontroller. Thus, we will use the SPI interface of ESP32. We can either use VSPI or HSPI pins. We are using the VSPI pins in this case. Below you can view the VSPI pins in the ESP32 module. We will be using the MOSI, CLK and the CS pins from this interface. For RST and DC, you can use any appropriate ESP32 pin.

To use the Nokia 5510 display in our project, we have to install the Adafruit Nokia 5510 library and the Adafruit GFX library in Arduino IDE. Follow the steps below to successfully install them.

Now we will proceed further and learn how to display simple text on the Nokia 5510 LCD display. We will be using the Adafruit Nokia 5510 library to access useful functions to show you how to display texts easily on the LCD.

Firstly, we will include all the following libraries which are required for this project. SPI.h will allow us to communicate through the SPI protocol. Whereas the other libraries are the ones which we previously installed and are required for the proper functionality of the Nokia 5510 LCD display.

Next, we will initialize the display by creating an object of Adafruit_PCD8544 and specifying the ESP32 GPIO pins which we have connected to the Nokia 5510’s CLK, DIN, DC and RST pins respectively. In total it takes in 5 parameters. In our case, the CLK is connected with GPIO18, the DIN is connected with GPIO23, the DC is connected with GPIO4, the CE is connected with GPIO15 and the RST is connected with GPIO2. Carefully, specify the parameters.

Inside the setup() function, we will open a serial connection at a baud rate of 115200. Moreover, we will also initialize the LCD display by using display.begin().

Next, we will use setContrast() method on the Adafruit object. This will be used to set the contrast of the display for a better view of the text on the screen. It takes in values between 0-100 but values from 50-60 give a good result. You can change the values and see what suits you better. We have set it to 50.

In this part, we will show you how to display the different texts. Inside the void setup() function, after setting the serial baud rate and clearing the buffer we will include the code to display the simple text then invert its background colour, numbers, ASCII symbol and text rotation. Each illustration will display on the LCD screen for 10 seconds and then the next one follows. The rotating text will continue in an infinite loop after all previous illustrations have been shown.

After displaying the simple text ‘Welcome!’ on the LCD screen as we did in the previous sketch, we will invert its background colour. This is achieved by using the setTextColor() function on the Adafruit_PCD8544 object that is ‘display.’ This function takes in two parameters. The first parameter is the font colour and the second parameter is the background colour. We have set the font colour as WHITE and the background colour as BLACK. This is opposite to what we had before. Additionally, we will call the display() function on the display object so that the inversion displays on the LCD.

Next, we will change the font size. First we will change the text colour back to Black. Next by using setTextSize() function and pass the font size as a parameter inside it. In our case it is 2 that relatively increases the font size as compared to 1. Remember this function takes in positive values where 1 is the smallest size. The text is scaled by 5:7 where font size 2 means 10×14 pixels enhancement. Additionally, we will call the display() function on the display object so that the font size displays on the LCD.

Now, we will show you how to display numbers on the LCD screen. Just set your text size and cursor position. Then by using the println() function pass the numbers that you want to display on the screen. In our case we are displaying ‘12345’. Additionally, we will call the display() function on the display object so that the numbers display on the LCD.

Now we will show the base for a number on our LCD display. We will convert a hexadecimal number to decimal format and display it on the LCD. The number is 255 in decimal and 0xFF in hexadecimal. The print() will take in two parameters to achieve this. The first is the number and the second is the base format (HEX/DEC) in our case. Additionally, we will call the display() function on the display object so that the numbers display on the LCD.

Now let us learn how to display an ASCII symbol. First set up the font size and the cursor position. We have set the font size to 2 and the cursor at (10,10). This will give us a good view of the symbol. Now by using the write() function on the Adafruit_PCD8544 object that is ‘display’ we will pass a number inside it. This will send the binary data and display it on the screen by converting it to ASCII text. We are passing 14 inside it which denotes the ASCII symbol for musical note. Additionally, we will call the display() function on the display object so that the symbol displays on the LCD.

Lastly, we will rotate the ‘Welcome!’ text in all directions on the LCD screen. This will be achieved by using the setRotation() function that takes in values from 0-3 where 0 denotes rotation of 0 degrees, 1 denotes rotation of 90 degrees, 2 denotes rotation of 180 degrees and 3 denotes a rotation of 270 degrees. We initially defined an integer variable named ‘rotation’ and set it equal to 1. Inside the infinite loop() we will rotate the text 90 degrees as the rotate variable increments after each rotation. There is a delay of 1 second between each rotation.

Once the code is uploaded to ESP32, you will be able to view all the above mentioned illustrations on the LCD display after a gap of 10 seconds. Watch the video below to have a look.

Now let us move ahead and learn how to display different shapes on the Nokia 5110 LCD display. By the end of this section you will be able to display the following shapes on your LCD screen:

In this part, we will show you how to display the different simple shapes. Inside the void setup() function, after setting the serial baud rate and clearing the buffer we will include the code to display the shapes. Each illustration will display on the LCD screen for 5 seconds and then the next one will follow.

First, we will display a series of different rectangles on the LCD screen that include an unfilled and a filled rectangle. First, we will display an unfilled rectangle. This is achieved by using the drawRect() function on the Adafruit_PCD8544 object that is ‘display.’ This function takes in five parameters. The first two parameters are the starting (x1, y1) coordinates that indicate the top left corner of the rectangle. The next two parameters are the width and height of the rectangle. Lastly the fifth parameter is the colour of the rectangle. We have passed (20,20) as the starting coordinates and 50 as the width and 20 as the height of the rectangle. It will be black in colour. Additionally, we will call the display() function on the display object so that the rectangle displays on the screen.

Additionally, we will also display a rounded rectangle. This is achieved by using the drawRoundRect() function. This function takes in six parameters. The first two parameters are the starting (x1, y1) coordinates that indicate the top left corner of the rectangle. The next two parameters are the width and height of the rectangle. The fifth parameter is the radius of the corner. We have passed (20,20) as the starting coordinates and 50 as the width and 20 as the height of the rectangle. For the radius of the corners we have set it to 10. The rectangle will be black in colour. Additionally, we will call the display() function on the display object so that the rounded rectangle displays on the LCD.

Now, we will display a circle. This is achieved by using the drawCircle() function. This function takes in four parameters. The first two parameters are the (x, y) coordinates that indicate the center of the circle. The next parameter is the radius of the circle. The last parameter is the color of the circle. We have passed (40,20) as the center coordinates of the circle and the radius as 20. The circle will be black in color. Additionally, we will call the display() function on the display object so that the circle displays on the LCD.

To display a triangle we will use the drawTriangle() function. This function takes in seven parameters. The first two parameters are the (x1, y1) coordinates of the first corner of the triangle. The next two parameters are the (x2, y2) coordinates of the second corner of the triangle. Likewise the fifth and sixth parameters are the (x3, y3) coordinates of the third corner of the triangle. The last parameter is the colour of the triangle. We have passed (40,20) as the first corner, (20, 30) as the second corner and (50, 30) as the third corner of the triangle. The triangle will be black in colour. Additionally, we will call the display() function on the display object so that the triangle displays on the LCD screen.

Now let us look at something more interesting to display on our graphic LCD screen. We can display 84×48 (pixels) monochrome bitmap images on our screen very easily by following a couple of steps. We will just need a 84×48 .bmp image and the image array that we will obtain through an image to array converter. The rest of the steps we have already seen in the examples above.

Now move ahead to the image settings. Set the canvas size to 84×48 and change the brightness according to your needs. You can view in the preview section how the bitmap image looks like. This is how it will get displayed on the LCD screen. Thus, set the brightness appropriately.

When you are satisfied with your preview then go to output and click ‘Generate code.’ Now we will obtain the array. Copy that array and save it. We will use it while programming our ESP32 board with the Nokia 5110 LCD display.

After including the necessary libraries and defining the Nokia LCD display we will define the image array which we got from the image2cpp application as follows. Define it as ‘static const uint8_t NAME_OF_.bmp_FILE[1024].’

Inside the setup() function, we will initialize the LCD display by using display.begin(). We will also set the background contrast according to our needs. Next, we will use clearDisplay() to clear the buffer before displaying the bitmap image on the screen.

Through drawBitmap() function, we will display the bitmap image on the LCD display. This takes in six parameters. The first two parameters are the (x, y) starting coordinates. The third parameter is the name of the image array that is ‘bitmap_image’ in our case. The next two parameters are the image width and height in pixels that we are specifying as 84 and 48 respectively so that the image fills the Nokia LCD display. Lastly, the sixth parameter is the colour. Additionally, we will call the display() function on the display object so that the image displays on the screen.

In conclusion, we comprehensively looked at the Nokia 5110 LCD display and set it up with the ESP32 board using Arduino IDE. We have learned its introduction, pinout, connection with the development board and some Arduino sketches to get started with the LCD display. The program sketches included displaying simple texts, numbers, ASCII symbols, changing font size, rotating texts, and displaying simple shapes. Additionally, we were also able to display monochrome bitmap images on the LCD screen by following a series of steps.