raspbian lcd displays random characters in stock

Many of these LCD controllers differ slightly from the HD44780 controller in things like the initialization sequence, minimum delay between commands and maybe other ways I don"t know of.

try putting a 1n4148 diode between the 5V supply and the 5V of the LCD, so the LCD will get around 4.5V, that is enough for the LCD, and lowers its logical input levels enough so that it sees 3V3 logic highs as "1" reliably. The garbled letters, and blocks are due to the LCD sometimes seeing a "1" as a zero and that corrupts all communication between the PI and the LCD.

Its a well know problem when trying to drive an LCD with 3V3 levels, it actually needs minimally 3.5V when its powered with 5V (70 % of VCC = 0.7 x 5.0 = 3.5).

In the photos above the Pi is a Model B Rev 2 so should work fine with my tutorial. Random characters is usually a sign it has not been initialized correctly. Again this could be caused by intermittent connections.

I was having the same problem as the OP on my current build with an I2C back-packed LCD getting corrupted. I"d tried all kinds of things to fix the problems - changing the delays, trying different libraries, and pulling out hair with no joy in fixing it.

For anyone else with this problem, you may have what I have if you"re doing event-driven code e.g. from from a switch or rotary encoder. I was getting events triggered while the python code was trying to communicate with the LCD screen - which themselves tried to write to the LCD.

I also had the same problem with scrambled characters on my display. I found that there was a short between the data lines on the expander board where it is soldered to the display board. Once I cleaned up the messy solder, the display worked perfectly.

My code seems to work for outputting to the console, however when I try to output to the LCD, it gives some weird characters and stops. Not sure what to do as i"m not a python wiz (you"d think id be more like php, but nah lol).

When I start my code, it displays as expected the initial screen on the LCD (as defined in setup() function) and then the temperature. But suddenly the LCD displays random characters, see attached, and somehow never stop displaying random characters until i restart the board.

Previous examples connect the white LED backlight to power. The following example is specifically for those using an LCD with a RGB LED backlight. The only difference between the connection is the LED"s backlight on pins 15-18.

The Matrix Orbital Parallel display series offers a low cost display solution utilizing an industry standard communication interface for simple integration into a wide variety of new and existing applications.  The Light Emitting Diode backlight with configurable brightness and voltage controlled contrast allows the MOP Liquid Crystal Display line to offer a professional display solution with low power impact for any project.  The standard alphanumeric font set also allows up to eight custom characters to be saved in display Random Access Memory for a custom design touch.

CategorySub CategoryFile NameRevisionSizeDescriptionNotesFeaturesChange LogCategorySub CategoryFile NameRevisionSizeDescriptionNotesFeaturesChange LogMOP SeriesMOP Character LCD1.0278.43KiBAll of our Matrix Orbital Alphanumeric displays have HD44780U compatible drivers.

Connecting an LCD to your Raspberry Pi will spice up almost any project, but what if your pins are tied up with connections to other modules? No problem, just connect your LCD with I2C, it only uses two pins (well, four if you count the ground and power).

In this tutorial, I’ll show you everything you need to set up an LCD using I2C, but if you want to learn more about I2C and the details of how it works, check out our article Basics of the I2C Communication Protocol.

There are a couple ways to use I2C to connect an LCD to the Raspberry Pi. The simplest is to get an LCD with an I2C backpack. But the hardcore DIY way is to use a standard HD44780 LCD and connect it to the Pi via a chip called the PCF8574.

The PCF8574 converts the I2C signal sent from the Pi into a parallel signal that can be used by the LCD. Most I2C LCDs use the PCF8574 anyway. I’ll explain how to connect it both ways in a minute.

I’ll also show you how to program the LCD using Python, and provide examples for how to print and position the text, clear the screen, scroll text, print data from a sensor, print the date and time, and print the IP address of your Pi.

Connecting an LCD with an I2C backpack is pretty self-explanatory. Connect the SDA pin on the Pi to the SDA pin on the LCD, and the SCL pin on the Pi to the SCL pin on the LCD. The ground and Vcc pins will also need to be connected. Most LCDs can operate with 3.3V, but they’re meant to be run on 5V, so connect it to the 5V pin of the Pi if possible.

If you have an LCD without I2C and have a PCF8574 chip lying around, you can use it to connect your LCD with a little extra wiring. The PCF8574 is an 8 bit I/O expander which converts a parallel signal into I2C and vice-versa. The Raspberry Pi sends data to the PCF8574 via I2C. The PCF8574 then converts the I2C signal into a 4 bit parallel signal, which is relayed to the LCD.

Now we need to install a program called I2C-tools, which will tell us the I2C address of the LCD when it’s connected to the Pi. So at the command prompt, enter sudo apt-get install i2c-tools.

Now reboot the Pi and log in again. With your LCD connected, enter i2cdetect -y 1 at the command prompt. This will show you a table of addresses for each I2C device connected to your Pi:

We’ll be using Python to program the LCD, so if this is your first time writing/running a Python program, you may want to check out How to Write and Run a Python Program on the Raspberry Pi before proceeding.

The function mylcd.lcd_display_string() prints text to the screen and also lets you chose where to position it. The function is used as mylcd.lcd_display_string("TEXT TO PRINT", ROW, COLUMN). For example, the following code prints “Hello World!” to row 2, column 3:

On a 16×2 LCD, the rows are numbered 1 – 2, while the columns are numbered 0 – 15. So to print “Hello World!” at the first column of the top row, you would use mylcd.lcd_display_string("Hello World!", 1, 0).

You can create any pattern you want and print it to the display as a custom character. Each character is an array of 5 x 8 pixels. Up to 8 custom characters can be defined and stored in the LCD’s memory. This custom character generator will help you create the bit array needed to define the characters in the LCD memory.

By inserting the variable from your sensor into the mylcd.lcd_display_string() function (line 22 in the code above) you can print the sensor data just like any other text string.

These programs are just basic examples of ways you can control text on your LCD. Try changing things around and combining the code to get some interesting effects. For example, you can make some fun animations by scrolling with custom characters. Don’t have enough screen space to output all of your sensor data? Just print and clear each reading for a couple seconds in a loop.

You might find that your screen displays random text/characters/gibberish as per the image below, I didn"t find a software fix for this, because although I had the four data cables connected for 4 bit opperation, it was seemingly still trying to run in 8 bit mode, so my fix for this was to just connect the other 4 cables. I mean, it"s not like the Pi doesn"t have enough IO ports.

This LCD has been chosen specifically because it works well with the RasPiO®Duino. We’ve opened, tested and adjusted the contrast on every single one. We’ve also written someawesome “RasPi.TV-style” instructionsto guarantee you have a positive experience with your LCD.

There’s an open source library for driving this LCD from your RasPiO®Duino. I’ve written a demo-sketch to get you started. It operates the dual-sensor digital thermometer shown above, giving you the following output…

If the display is powered up without the RX line connected to anything, the display may fill with strange characters. This is because the display is receiving random noise on the disconnected line. If you connect the RX line to a true TX port, this will not happen.

If your LCD screen has entered an unknown state, or you are unable to communicate with it, it"s probably a good idea to try resetting everything back to default settings. The OpenLCD firmware has a built-in "emergency reset" feature. When the screen first boots up, the AVR on the back will watch its RX pin. If that pin is held LOW (aka tied to ground), for 2 seconds, then it will reset all settings to default. Most importantly, your baud rate will be set back to 9600. After the reset is complete, the screen will display the message "System Reset Power Cycle Me", and flicker the backlight on and off repeatedly until you cycle power.

Heads up! Remember, the name "SerLCD" will refer to the hardware throughout the tutorial. OpenLCD will refer to the firmware used on the SerLCD. The board definition (i.e. "SparkFun SerLCD") refers to the board type flashed on the ATmega328P.

To update the firmware on your LCD, you can use an FTDI Basic 3.3V - beefy model and the Arduino IDE software. The AVR on the back of your LCD actually has an Arduino-compatible bootloader. That said, it is slightly custom in that it was compiled for the 11.0592 crystal. This means you will need to install the SparkFun AVR Boards, and then select "Sparkfun SerLCD" as your board type.

Note: For advanced users, you can also flash the hex file by connecting an AVR programmer if you are still having issues uploading through the Arduino IDE. Just make sure to power the SerLCD if the AVR programmer does not provide power for your target and the logic levels are 3.3V.

Once connected, grab the *.hex file from the GitHub repo with the Arduino bootloader to re-flash the ATmega328P with AVR Studio or command line. Once the bootloader is re-installed, try following the directions below to install the latest firmware version on the SerLCD. At the time of writing this note, the *.hex file used firmware v1.2.

Once the board add-on and associated libraries are installed, click the UPLOAD button in the IDE (the right facing arrow) to get the latest code onto your LCD!

If you are using the serial enabled LCD with an Atmega32U4-based Arduino (like a Pro Micro, Arduino Leonardo, Arduino LilyPad USB, etc), you might need to add a small delay in the setup before you can get it working with the hardware UART (pins 0 and 1). Here"s an example:

Unfortunately, you are not able to use the serial enabled LCDs with an Arduino Due due the differences in how change interrupts are used for the ARM processor. The software serial library is not included in the Arduino Due"s tree:

These displays all plug directly into the pins of your Pico and are programmed in the same way but require slightly different driver code, supplied by Waveshare via their Wiki pages.

All these displays need some memory in the Pico, a "buffer", to hold the data to be displayed on the screen. As the number of pixels increases so does the size of this buffer requirement and the space available for code decreases. As the pixel size gets smaller the basic text gets progressively harder the read as it is so small.

For this tutorial we are going to use the 1.44” 128x128 display as it provides a good compromise between basic text size, number of pixels on the display for graphics, buffer size, input buttons and price. The code is easily converted to run on the other displays.

The first line initialises the display using the driver code at the start of the program. It calls the display device LCD, but we could call it something different – but using LCD makes typing code easier!

All of these Waveshare displays use 16-bit colour codes to mix colours by varying the brightness ratios of red, green and blue in each pixel. As human eyes are more sensitive to green light, an extra bit is given to the green component. This code is called RGB565 with 5 bits for red and blue and 6 bits for green.

At this point we ported the code to work on the other four displays and found that they use a slightly different system - the blue and red bits have been swapped over:

To make things easy we are providing minimum setup programs for each of the 5 boards. Each program includes the correct screen driver, sets up the buttons and joystick, if available, and includes the correct version of the colour(R, G ,B) function. It also displays a 3-line colour check at the start.

Each program contains the screen driver code, sets up the buttons/joystick and sets the width and height variables correctly, loads the essential libraries, defines the colour(R, G, B) and clear(c) procedures. It then displays some colour checking text.