This note is to document how I finally managed to connect a HD44870 (JHD162A) based generic 16×2 LCD with my Raspberry Pi 3. I was at it for two days but the module just wouldn’t display any text, only the back light would stay lit but just won’t display any text.
Wiring
I followed [this] article which nicely explains the process. However, I had to make changes to the wiring and pin-outs (on the Rpi3 end) to make it work. I think the article author was using an older RPi with different GPIO pin-outs.
The following diagram made with the brilliant fritzing software shows the wiring I’ve setup for this task.
The code given by the author had to be modified to reflect my GPIO pin-outs. Specifically, I edited the following section and gave my own GPIO pins.
# Define GPIO to LCD mapping
LCD_RS = 21
LCD_E = 20
LCD_D4 = 16
LCD_D5 = 12
LCD_D6 = 7
LCD_D7 = 8Controlling the text contrast in software
Almost all the tutorials that I read mentioned the use of a 10K POT (potentiometer) to be used with the pin 3 of the LCD (which controls the contrast of the text).
Initially I skipped the instructions and just grounded (GND) the pin 3 (which means 0V to pin 3). This did not work. The screen would stay lit up bright blue (I have a blue/white 16×2 LCD) but would show no text on the display.
Since I could not find a potentiometer in my components drawer and salvaged defunct electronics dump, I started searching for other hacks to make this work without a POT.
I found that the data GPIO pins can also be made to send out upto 3.3Vs (eg GPIO 15 pin). This meant that I can take one of the data GPIO pins and simulate a variable voltage output. This function is called PWM (voltage can be varied between 0V to 3.3V on Rpi3). Which gave me an idea that I could experiment by outputting 0V to 3V to the contrast pin and see what works the best. I remember the manufacturer’s pdf mentioning a good value lies between 0.6V to 1.2V.
Sure enough it worked!
I connected the pin 3 of LCD to GPIO 15 of Rpi3 and ran some code in a new window as root to test this out. There was already another window running the python code to send some test texts to the LCD.
In the new window, I ran these commands one by one (>>> is the python prompt).
pi@raspberrypi:~/Downloads $ sudo python
Python 2.7.9 (default, Mar 8 2015, 00:52:26)
[GCC 4.9.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import RPi.GPIO as GPIO
>>> GPIO.setmode(GPIO.BCM)
>>> GPIO.setup(15,GPIO.OUT)
__main__:1: RuntimeWarning: This channel is already in use, continuing anyway. Use GPIO.setwarnings(False) to disable warnings.
>>> my_pwm=GPIO.PWM(15,100)
>>> my_pwm.start(10)After this I ran with some experimental values to see what works for my display
>>> my_pwm.start(5)
>>> my_pwm.start(20)
>>> my_pwm.start(18)
>>> my_pwm.start(15)
>>> my_pwm.start(12)
>>> my_pwm.start(11)
>>> my_pwm.start(13)
>>> my_pwm.start(14)
>>> my_pwm.start(21)
>>> my_pwm.start(30)
>>> my_pwm.start(33)
>>> my_pwm.start(80)
>>> my_pwm.start(60)
>>> my_pwm.start(50)
>>> my_pwm.start(40)
>>> my_pwm.start(45)
>>> my_pwm.start(55)
>>> my_pwm.start(50)
>>> my_pwm.start(48)
>>> my_pwm.start(15)
>>> my_pwm.start(10)I noticed the screen would flicker a lot with higher values when I was playing around with the start(nn) function. Later I discovered a ChangeDutyCycle(nn) function which solved that problem for me as well.
>>> my_pwm.ChangeDutyCycle(1)
>>> my_pwm.ChangeDutyCycle(10)
>>> my_pwm.ChangeDutyCycle(20)
>>> my_pwm.ChangeDutyCycle(30)
>>> my_pwm.ChangeDutyCycle(80)
>>> my_pwm.ChangeDutyCycle(60)
>>> my_pwm.ChangeDutyCycle(40)
>>> my_pwm.ChangeFrequency(1000)
>>> my_pwm.ChangeDutyCycle(80)
>>> my_pwm.ChangeDutyCycle(55)
>>> my_pwm.ChangeDutyCycle(45)
>>> my_pwm.ChangeDutyCycle(60)
>>> my_pwm.ChangeDutyCycle(10)
>>> my_pwm.ChangeDutyCycle(30)Now my display was running well with the added ability to software control the contrast!
To stop the PWN pin output, run
>>> my_pwm.stop()This article [link] is a good short read about the PWM trick which I followed to make my module work. Saved me a trip to the electronics shop to get new parts.
Next steps would be to integrate the PWM contrast code snippet with the primary program and also set up an init.d script to launch this at startup. I don’t know if it is possible, but if I could, I’d like the LCD to launch and display the OS menu during boot time (the BerryBoot menu) for OS selection.
Final code
#!/usr/bin/python
# The wiring for the LCD is as follows:
# 1 : GND
# 2 : 5V
# 3 : Contrast (0-5V)*
# 4 : RS (Register Select)
# 5 : R/W (Read Write) - GROUND THIS PIN
# 6 : Enable or Strobe
# 7 : Data Bit 0 - NOT USED
# 8 : Data Bit 1 - NOT USED
# 9 : Data Bit 2 - NOT USED
# 10: Data Bit 3 - NOT USED
# 11: Data Bit 4
# 12: Data Bit 5
# 13: Data Bit 6
# 14: Data Bit 7
# 15: LCD Backlight +5V**
# 16: LCD Backlight GND
#import
import RPi.GPIO as GPIO
import time
from time import sleep
from datetime import datetime
from time import strftime
# Define GPIO to LCD mapping
LCD_RS = 21
LCD_E = 20
LCD_D4 = 16
LCD_D5 = 12
LCD_D6 = 7
LCD_D7 = 8
LCD_VEE = 15 # Contrast
# Define some device constants
LCD_WIDTH = 16 # Maximum characters per line
LCD_CHR = True
LCD_CMD = False
LCD_LINE_1 = 0x80 # LCD RAM address for the 1st line
LCD_LINE_2 = 0xC0 # LCD RAM address for the 2nd line
# Timing constants
E_PULSE = 0.0005
E_DELAY = 0.0200
def main():
# Main program block
GPIO.setwarnings(True)
GPIO.setmode(GPIO.BCM) # Use BCM GPIO numbers
GPIO.setup(LCD_E, GPIO.OUT) # E
GPIO.setup(LCD_RS, GPIO.OUT) # RS
GPIO.setup(LCD_D4, GPIO.OUT) # DB4
GPIO.setup(LCD_D5, GPIO.OUT) # DB5
GPIO.setup(LCD_D6, GPIO.OUT) # DB6
GPIO.setup(LCD_D7, GPIO.OUT) # DB7
GPIO.setup(LCD_VEE, GPIO.OUT) # Contrast for LCD text
# Set PWM values for LCD contrast
my_pwm=GPIO.PWM(15,100)
my_pwm.start(10)
my_pwm.ChangeFrequency(1000)
my_pwm.ChangeDutyCycle(30)
# Initialise display
lcd_init()
while True:
# Send some test
lcd_string("Raspberry Pi",LCD_LINE_1)
lcd_string("...............",LCD_LINE_2)
time.sleep(3) # 3 second delay
# Send some text
lcd_string("Finally! LCD ",LCD_LINE_1)
lcd_string(" is working!",LCD_LINE_2)
time.sleep(3) # 3 second delay
# Send some text
lcd_string("~ DooM Pi ~",LCD_LINE_1)
lcd_string(" :-)",LCD_LINE_2)
time.sleep(3)
# Send some text
lcd_string("Time is:",LCD_LINE_1)
lcd_string(datetime.now().strftime('%b %d %H:%M:%S\n'),LCD_LINE_2)
time.sleep(20)
def lcd_init():
# Initialise display
lcd_byte(0x33,LCD_CMD) # 110011 Initialise
lcd_byte(0x32,LCD_CMD) # 110010 Initialise
lcd_byte(0x06,LCD_CMD) # 000110 Cursor move direction
lcd_byte(0x0C,LCD_CMD) # 001100 Display On,Cursor Off, Blink Off
lcd_byte(0x28,LCD_CMD) # 101000 Data length, number of lines, font size
lcd_byte(0x01,LCD_CMD) # 000001 Clear display
time.sleep(E_DELAY)
def lcd_byte(bits, mode):
# Send byte to data pins
# bits = data
# mode = True for character
# False for command
GPIO.output(LCD_RS, mode) # RS
# High bits
GPIO.output(LCD_D4, False)
GPIO.output(LCD_D5, False)
GPIO.output(LCD_D6, False)
GPIO.output(LCD_D7, False)
if bits&0x10==0x10:
GPIO.output(LCD_D4, True)
if bits&0x20==0x20:
GPIO.output(LCD_D5, True)
if bits&0x40==0x40:
GPIO.output(LCD_D6, True)
if bits&0x80==0x80:
GPIO.output(LCD_D7, True)
# Toggle 'Enable' pin
lcd_toggle_enable()
# Low bits
GPIO.output(LCD_D4, False)
GPIO.output(LCD_D5, False)
GPIO.output(LCD_D6, False)
GPIO.output(LCD_D7, False)
if bits&0x01==0x01:
GPIO.output(LCD_D4, True)
if bits&0x02==0x02:
GPIO.output(LCD_D5, True)
if bits&0x04==0x04:
GPIO.output(LCD_D6, True)
if bits&0x08==0x08:
GPIO.output(LCD_D7, True)
# Toggle 'Enable' pin
lcd_toggle_enable()
def lcd_toggle_enable():
# Toggle enable
time.sleep(E_DELAY)
GPIO.output(LCD_E, True)
time.sleep(E_PULSE)
GPIO.output(LCD_E, False)
time.sleep(E_DELAY)
def lcd_string(message,line):
# Send string to display
message = message.ljust(LCD_WIDTH," ")
lcd_byte(line, LCD_CMD)
for i in range(LCD_WIDTH):
lcd_byte(ord(message[i]),LCD_CHR)
if __name__ == '__main__':
try:
main()
except KeyboardInterrupt:
pass
finally:
lcd_byte(0x01, LCD_CMD)
lcd_string("Goodbye!",LCD_LINE_1)
my_pwm=GPIO.PWM(15,100)
my_pwm.stop()
GPIO.cleanup()