Raspberry Pi PICO LCD (not I2C)

Introduction: Raspberry Pi PICO LCD (not I2C)

About: I love making things. I have for as long as I can remember liked to make stuff. Now days I have two kids (Thomas and Emma) and most of the things I do are safe for them! I love electronics and Microchips, I ha…

If you have purchased the book (Get started with MicroPython on Raspberry Pi Pico) you will note that there really isn't much information on driving LCD's In fact the book only focuses on the sparkfun I2C LCD. So in this instructable I would like to look at connecting and driving a standard LCD using the Pico.

Supplies

Raspberry Pi Pico running MicroPython.

Standard LCD for example 20 * 4 or 16 * 2

Wire to connect up.

proto board

Step 1: Binary, Ones and Zero's.

There are only 10 types of people in the world – those who understand binary, and those who don’t.

So lets look at the LCD. Most simple LCD's are driven by a Hitachi HD44780 LCD controller and have the following connections.

  1. Ground
  2. VCC +3.3 to +5V (typical)
  3. Contrast adjustment (VO) This is an analogue input.
  4. Register Select (RS). RS=0: Command, RS=1: Data
  5. Read/Write (R/W). R/W=0: Write, R/W=1: Read, Not used connected to ground.
  6. Clock (Enable). Falling edge triggered
  7. Bit 0 (Not used in 4-bit operation)
  8. Bit 1 (Not used in 4-bit operation)
  9. Bit 2 (Not used in 4-bit operation)
  10. Bit 3 (Not used in 4-bit operation)
  11. Bit 4
  12. Bit 5
  13. Bit 6
  14. Bit 7
  15. Backlight Anode (+) (If applicable)
  16. Backlight Cathode (-) (If applicable)

So that might look like a lot of connections but you only ned 4 data bits and the E and RS pins. Not forgetting power.

Step 2: Lets Start on an Arduino.

So this might seem like a strange step but the Arduino IDE so so simple to use and the libraries make programming a cinch.

#include <Time.h>
#include 

const int rs = 3, en = 2, d4 = 4, d5 = 5, d6 = 6, d7 = 7;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);

void setup()
{
  lcd.begin(20, 4);
  lcd.print("Hello");
}

void loop() {
}

However the library in this case doesn't help me understand what is happening in the background, so I decided to write my own program. (once I had proved the LCD worked) The wiki page was really useful for this bit. It explains that the LCD needs to be initialised as it could be in one of three states on start up and at this point its worth saying that the Register Select (RS) is the pin which is used to tell the LCD whether the data is a command or character.

So to start with you need to clear the RS pin (set to zero) Then you turn on/off the 4 data lines to the required code then you clock the data in using the Enable Pin. The data you need to send is as follows.

  • 0b0011 (D7-D4) Function Set with 8 bit interface.
  • 0b0011 (D7-D4) Function Set with 8 bit interface.
  • 0b0011 (D7-D4) Function Set with 8 bit interface.
  • 0b0010 (D7-D4) Function Set with 4 bit interface.

Once you have sent those 4 commands you can then send 8 bit binary numbers which need to be sent in two 4 bits nibbles. Certain delays should be maintained as per the wiki page but that's not to hard to achieve. I wrote a function to pulse the Enable pin and a function to send 4 bits to the LCD and then another to send 8 bits to the LCD (in two nibbles)

#include <Time.h>

const int e = 2, rs = 3, d4 = 4, d5 = 5, d6 = 6, d7 = 7;
int BinNum;

void setup()
{
  pinMode(e, OUTPUT);
  pinMode(rs, OUTPUT);
  pinMode(d4, OUTPUT);
  pinMode(d5, OUTPUT);
  pinMode(d6, OUTPUT);
  pinMode(d7, OUTPUT);
  setUpLCD();
  digitalWrite(rs, HIGH);
  delay(5);
  send2LCD8(0b01001000);//H
  send2LCD8(0b01100101);//e
  send2LCD8(0b01101100);//l
  send2LCD8(0b01101100);//l
  send2LCD8(0b01101111);//o
}

void loop(){
}

void setUpLCD()
{
  digitalWrite(rs, LOW);
  delay(5);
  send2LCD4(0b0011);//send 8bit operation command
  send2LCD4(0b0011);//send 8bit operation command
  send2LCD4(0b0011);//send 8bit operation command
  send2LCD4(0b0010);//send 4bit operation command
  send2LCD8(0b00101000);//Functin set, 8 bit
  send2LCD8(0b00001100);//Display ON, Cursor OFF, Cursor NOT Blinking
  send2LCD8(0b00000110);//Entry mode, incremental,
  send2LCD8(0b00000001);//clear screen
}
void pulseE()
{
  digitalWrite(e, HIGH);
  delay(2);
  digitalWrite(e, LOW);
  delay(5);
}
void send2LCD8(int BinNum)
{
  digitalWrite(d4, (BinNum & 0b00010000) >> 4);
  digitalWrite(d5, (BinNum & 0b00100000) >> 5);
  digitalWrite(d6, (BinNum & 0b01000000) >> 6);
  digitalWrite(d7, (BinNum & 0b10000000) >> 7);
  pulseE();
  digitalWrite(d4, (BinNum & 0b00000001) >> 0);
  digitalWrite(d5, (BinNum & 0b00000010) >> 1);
  digitalWrite(d6, (BinNum & 0b00000100) >> 2);
  digitalWrite(d7, (BinNum & 0b00001000) >> 3);
  pulseE();
}
void send2LCD4(int BinNum)
{
  digitalWrite(d4, (BinNum & 0b00000001) >> 0);
  digitalWrite(d5, (BinNum & 0b00000010) >> 1);
  digitalWrite(d6, (BinNum & 0b00000100) >> 2);
  digitalWrite(d7, (BinNum & 0b00001000) >> 3);
  pulseE(); 
}

Step 3: Arduino Program With All the Bits!

So before I moved onto the Pico I added a few more bits to the Arduino program. If you look at the Wiki page you will see there are quite a few commands, so I added a few more functions to test them. These included clearing the screen, returning home, and moving the cursor left or right. And lastly I made a function with allowed you to define a line and position you wanted the text to start on.

void whichLinePos(int number, int pos)
{
  int b = 0;
  if (number == 1){
    b = 0;
  }
  if (number == 2){
    b = 40;
  }
  if (number == 3){
    b = 20;
  }
  if (number == 4){
    b = 60;
  }
  returnHome();
  for (int x = 0; x < b+(pos-1); x++)
  {
    moveCursorR();
  }
}

void returnHome()
{
  digitalWrite(rs, LOW);
  delay(5);
  send2LCD8(0b00000010);
  digitalWrite(rs, HIGH);
  delay(5);
}
void clearScreen()
{
  digitalWrite(rs, LOW);
  delay(5);
  send2LCD8(0b00000001);
  digitalWrite(rs, HIGH);
  delay(5);
}
void cursorOff()
{
  digitalWrite(rs, LOW);
  delay(5);
  send2LCD8(0b00001100);
  digitalWrite(rs, HIGH);
  delay(5);
}
void moveCursorR()
{
  digitalWrite(rs, LOW);
  delay(5);
  send2LCD8(0b00010100);
  digitalWrite(rs, HIGH);
  delay(5);
}
void moveCursorL()
{
  digitalWrite(rs, LOW);
  delay(5);
  send2LCD8(0b00010000);
  digitalWrite(rs, HIGH);
  delay(5);
}

Step 4: MicroPython on the Pico

So now I had a good understanding of the commands for the LCD it was time to translate the program over to MicroPython. Luckily there are lots of similarities so it wasn't that hard to do and very quickly I had written the whole program. BUT did it work? Initially nothing happened and I thought this was due to the 3.3 Voltage logic levels coming from the Pico, so I quickly added logic level converters on all the pins, the LCD had to be powered by 5 Volts. However this didn't work and the LCD still did nothing.

After a quick coffee I had a look at the code again and realised I had made an error! when I send the binary number to the send2LCD4 function it uses an "&" to isolate the required bit then file rotates the required bit to place it at the LSB then it sets the required pin either high or low depending on the value. I had used the word "and" (is statement one and statements two correct) and not the "&" (bitwise and). Anyway once corrected the LCD jumped into life!

I then wondered if I needed the logic level converters? so I removed them and gave it another go and yes the LCD still works on 3.3V logic levels. (the LCD still needed 5Volts power)

Anyway the below program is the simple Hello World! LCD program.

import machine
import utime

rs = machine.Pin(0,machine.Pin.OUT)
e = machine.Pin(1,machine.Pin.OUT)
d4 = machine.Pin(2,machine.Pin.OUT)
d5 = machine.Pin(3,machine.Pin.OUT)
d6 = machine.Pin(4,machine.Pin.OUT)
d7 = machine.Pin(5,machine.Pin.OUT)

def pulseE():
    e.value(1)
    utime.sleep_us(40)
    e.value(0)
    utime.sleep_us(40)
def send2LCD4(BinNum):
    d4.value((BinNum & 0b00000001) >>0)
    d5.value((BinNum & 0b00000010) >>1)
    d6.value((BinNum & 0b00000100) >>2)
    d7.value((BinNum & 0b00001000) >>3)
    pulseE()
def send2LCD8(BinNum):
    d4.value((BinNum & 0b00010000) >>4)
    d5.value((BinNum & 0b00100000) >>5)
    d6.value((BinNum & 0b01000000) >>6)
    d7.value((BinNum & 0b10000000) >>7)
    pulseE()
    d4.value((BinNum & 0b00000001) >>0)
    d5.value((BinNum & 0b00000010) >>1)
    d6.value((BinNum & 0b00000100) >>2)
    d7.value((BinNum & 0b00001000) >>3)
    pulseE()
def setUpLCD():
    rs.value(0)
    send2LCD4(0b0011)#8 bit
    send2LCD4(0b0011)#8 bit
    send2LCD4(0b0011)#8 bit
    send2LCD4(0b0010)#4 bit
    send2LCD8(0b00101000)#4 bit,2 lines?,5*8 bots
    send2LCD8(0b00001100)#lcd on, blink off, cursor off.
    send2LCD8(0b00000110)#increment cursor, no display shift
    send2LCD8(0b00000001)#clear screen
    utime.sleep_ms(2)#clear screen needs a long delay

setUpLCD()
rs.value(1)
for x in 'Hello World!':
    send2LCD8(ord(x))

Step 5: Full Program With Functions

The full program is below and gives a good indication what is possible. However you do need to be careful and some command will effect other options. For example

Display on/off control also has the configuration for cursor on/off, and blink of cursor position character.

I have slowed the display down so you can see the text writing to the screen.

  1. Cursor of blink off, text writing left to right (normal).
  2. Cursor of blink off, text writing right to left (backwards).
  3. Mistake corrected with cursor and blink on.
  4. Cursor of blink off, text writing left to right (normal).
  5. Cursor of blink off, text writing left to right (normal).
  6. Screen text moves one character right.
  7. Screen text moves one character left.
  8. Screen blanks.
  9. Screen returns.
  10. Clear screen and start again.
import machine
import utime

rs = machine.Pin(0,machine.Pin.OUT)
e = machine.Pin(1,machine.Pin.OUT)
d4 = machine.Pin(2,machine.Pin.OUT)
d5 = machine.Pin(3,machine.Pin.OUT)
d6 = machine.Pin(4,machine.Pin.OUT)
d7 = machine.Pin(5,machine.Pin.OUT)

def pulseE():
    e.value(1)
    delayShort()
    e.value(0)
    delayShort()
    
def delayShort():
    utime.sleep_us(40)
    
def delay():
    utime.sleep_ms(2)
    
def delayBig():
    utime.sleep(0.3)

def send2LCD4(BinNum):
    d4.value((BinNum & 0b00000001) >>0)
    d5.value((BinNum & 0b00000010) >>1)
    d6.value((BinNum & 0b00000100) >>2)
    d7.value((BinNum & 0b00001000) >>3)
    pulseE()

def send2LCD8(BinNum):
    d4.value((BinNum & 0b00010000) >>4)
    d5.value((BinNum & 0b00100000) >>5)
    d6.value((BinNum & 0b01000000) >>6)
    d7.value((BinNum & 0b10000000) >>7)
    pulseE()
    d4.value((BinNum & 0b00000001) >>0)
    d5.value((BinNum & 0b00000010) >>1)
    d6.value((BinNum & 0b00000100) >>2)
    d7.value((BinNum & 0b00001000) >>3)
    pulseE()
    
def whichLinePos(line, pos):
    b = 0
    if (line == 1):
        b = 0
    if (line == 2):
        b = 40
    if (line == 3):
        b = 20
    if (line == 4):
        b = 60
    cursorHome()
    for x in range(0,b+pos):
        moveCursorR()

def clearDisplay():#blanks the LCD, needs a long delay.
    rs.value(0)
    send2LCD8(0b00000001)
    rs.value(1)
    delay()        
def cursorHome():#returns the cursor to home, needs a long delay.
    rs.value(0)
    send2LCD8(0b00000010)
    rs.value(1)
    delay()
def cursorMoveForward():
    rs.value(0)
    send2LCD8(0b00000110)
    rs.value(1)
def cursorMoveBack():
    rs.value(0)
    send2LCD8(0b00000100)
    rs.value(1)
def moveCursorR():#write text from left to right
    rs.value(0)
    send2LCD8(0b00010100)
    rs.value(1)
def moveCursorL():#write text from right to left (backwards)
    rs.value(0)
    send2LCD8(0b00010000)
    rs.value(1)
def cursorOff():
    rs.value(0)
    send2LCD8(0b00001100)
    rs.value(1)
def cursorOn():
    rs.value(0)
    send2LCD8(0b00001110)
    rs.value(1)
def blinkOn():
    rs.value(0)
    send2LCD8(0b00001111)
    rs.value(1)
def blinkOff():
    rs.value(0)
    send2LCD8(0b00001100)
    rs.value(1)
def displayShiftR():#move all caractors one space right
    rs.value(0)
    send2LCD8(0b00011100)
    rs.value(1)
def displayShiftL():#move all caractors one space left
    rs.value(0)
    send2LCD8(0b00011000)
    rs.value(1)
def displayOff():
    rs.value(0)
    send2LCD8(0b00001000)
    rs.value(1)
def displayOn():
    rs.value(0)
    send2LCD8(0b00001100)
    rs.value(1)
    
def setUpLCD():
    rs.value(0)
    send2LCD4(0b0011)
    send2LCD4(0b0011)
    send2LCD4(0b0011)
    send2LCD4(0b0010)
    send2LCD8(0b00101000)
    send2LCD8(0b00001100)
    send2LCD8(0b00000110)
    send2LCD8(0b00000001)
    rs.value(1)

setUpLCD()
while True:
    whichLinePos(1,3)
    for x in 'Instructables':
        send2LCD8(ord(x))
        delayBig()
    whichLinePos(2,18)
    moveCursorL()
    cursorMoveBack()
    for x in 'a no LCD a gnisU':
        send2LCD8(ord(x))
        delayBig()
    whichLinePos(3,1)
    moveCursorR()
    cursorMoveForward()
    whichLinePos(2,9)
    cursorOn()
    blinkOn()
    for x in ' LCD':
        send2LCD8(ord(x))
        delayBig()
        delayBig()
    blinkOff()
    
    whichLinePos(3,1)
    for x in 'Raspberry Pi PICO!':
        send2LCD8(ord(x))
        delayBig()
    whichLinePos(4,5)
    for x in '(NOT I2C!)':
        send2LCD8(ord(x))
    utime.sleep(2)
    displayShiftR()
    utime.sleep(2)
    displayShiftL()
    utime.sleep(2)
    displayOff()
    utime.sleep(2)
    displayOn()
    utime.sleep(2)
    clearDisplay()

Microcontroller Contest

Participated in the
Microcontroller Contest

3 People Made This Project!

Recommendations

  • Woodworking Contest

    Woodworking Contest
  • Stick It Challenge

    Stick It Challenge
  • Electronics Contest

    Electronics Contest

7 Comments

0
snizbatch
snizbatch

1 year ago

Thank you mr_fid! This was exactly what I was looking for to experiment with my new PICO. I took the liberty of making a LCD class and adding a scrolling text function. I'll post it below:
-Jim
from machine import Pin
from time import sleep
import utime

# LCD Code
class LCD:
"""
https://www.instructables.com/Raspberry-Pi-PICO-L...

RPI PICO LCD Pins on most Hitachi HD44780 controlled LCDs
GND 1 - VSS Ground
VBUS 2 - VDD / VCC +3.3 to +5V (typical)
- 3 - VO - Contrast adjust - Use 10K Pot OR 2K ohm resistor to GND
GP0 4 - RS - Register Select. RS=0: Command, RS=1: Data
GND 5 - Read/Write (R/W). R/W=0: Write, R/W=1: Read, Not used connected to ground.
GP1 6 - Clock (Enable). Falling edge triggered
- 7 - Bit 0 (Not used in 4-bit operation)
- 8 - Bit 1 (Not used in 4-bit operation)
- 9 - Bit 2 (Not used in 4-bit operation)
- 10 - Bit 3 (Not used in 4-bit operation)
GP2 11 - Bit 4
GP3 12 - Bit 5
GP4 13 - Bit 6
GP5 14 - Bit 7
VBUS 15 - A Backlight Anode (+) (If applicable)
GND 16 - K Backlight Cathode (-) (If applicable)
"""


def __init__(self):
self.rs = Pin(0,Pin.OUT)
self.e = Pin(1,Pin.OUT)
self.d4 = Pin(2,Pin.OUT)
self.d5 = Pin(3,Pin.OUT)
self.d6 = Pin(4,Pin.OUT)
self.d7 = Pin(5,Pin.OUT)




def scrollText(self, text, line=1, breakChars=" | ", displayWidth=16):
xindex = 0
st = text + breakChars + text + breakChars
scrollSlice = text
while True:
if len(text) > displayWidth:
scrollSlice = st[xindex:displayWidth+xindex]
xindex += 1
if xindex > len(st) - displayWidth:
xindex = 0
self.whichLinePos(line, 0)
self.prt(scrollSlice)

yield None

def prt(self, text):
for x in text:
self.send2LCD8(ord(x))




def delayShort(self):
utime.sleep_us(40)

def delay(self):
utime.sleep_ms(2)

def delayBig(self):
utime.sleep(0.3)

def pulseE(self):
self.e.value(1)
self.delayShort()
self.e.value(0)
self.delayShort()

def send2LCD4(self, BinNum):
self.d4.value((BinNum & 0b00000001) >>0)
self.d5.value((BinNum & 0b00000010) >>1)
self.d6.value((BinNum & 0b00000100) >>2)
self.d7.value((BinNum & 0b00001000) >>3)
self.pulseE()

def send2LCD8(self, BinNum):
self.d4.value((BinNum & 0b00010000) >>4)
self.d5.value((BinNum & 0b00100000) >>5)
self.d6.value((BinNum & 0b01000000) >>6)
self.d7.value((BinNum & 0b10000000) >>7)
self.pulseE()
self.d4.value((BinNum & 0b00000001) >>0)
self.d5.value((BinNum & 0b00000010) >>1)
self.d6.value((BinNum & 0b00000100) >>2)
self.d7.value((BinNum & 0b00001000) >>3)
self.pulseE()




def whichLinePos(self, line, pos):
b = 0
if (line == 1):
b = 0
if (line == 2):
b = 40
if (line == 3):
b = 20
if (line == 4):
b = 60
self.cursorHome()
for x in range(0,b+pos):
self.moveCursorR()




def clearDisplay(self):#blanks the LCD, needs a long delay.
self.rs.value(0)
self.send2LCD8(0b00000001)
self.rs.value(1)
self.delay()
def cursorHome(self):#returns the cursor to home, needs a long delay.
self.rs.value(0)
self.send2LCD8(0b00000010)
self.rs.value(1)
self.delay()
def cursorMoveForward(self):
self.rs.value(0)
self.send2LCD8(0b00000110)
self.rs.value(1)
def cursorMoveBack(self):
self.rs.value(0)
self.send2LCD8(0b00000100)
self.rs.value(1)
def moveCursorR(self):#write text from left to right
self.rs.value(0)
self.send2LCD8(0b00010100)
self.rs.value(1)
def moveCursorL(self):#write text from right to left (backwards)
self.rs.value(0)
self.send2LCD8(0b00010000)
self.rs.value(1)
def cursorOff(self):
self.rs.value(0)
self.send2LCD8(0b00001100)
self.rs.value(1)
def cursorOn(self):
self.rs.value(0)
self.send2LCD8(0b00001110)
self.rs.value(1)
def blinkOn(self):
self.rs.value(0)
self.send2LCD8(0b00001111)
self.rs.value(1)
def blinkOff(self):
self.rs.value(0)
self.send2LCD8(0b00001100)
self.rs.value(1)
def displayShiftR(self):#move all caractors one space right
self.rs.value(0)
self.send2LCD8(0b00011100)
self.rs.value(1)
def displayShiftL(self):#move all caractors one space left
self.rs.value(0)
self.send2LCD8(0b00011000)
self.rs.value(1)
def displayOff(self):
self.rs.value(0)
self.send2LCD8(0b00001000)
self.rs.value(1)
def displayOn(self):
self.rs.value(0)
self.send2LCD8(0b00001100)
self.rs.value(1)

def setUpLCD(self):
self.rs.value(0)
self.send2LCD4(0b0011)
self.send2LCD4(0b0011)
self.send2LCD4(0b0011)
self.send2LCD4(0b0010)
self.send2LCD8(0b00101000)
self.send2LCD8(0b00001100)
self.send2LCD8(0b00000110)
self.send2LCD8(0b00000001)
self.rs.value(1)




if __name__ == "__main__":




l = LCD()
l.setUpLCD()
l.clearDisplay()


line1 = l.scrollText("Hello There", line=1, breakChars="", displayWidth=16)
line2 = l.scrollText("Do you like my scrolling sign?", line=2, breakChars=" | ", displayWidth=16)


while True:
sleep(0.2)
next(line1)
next(line2)


# This code never actually gets here but to clean up the 2 generators
# Call the following lines:
line1.close()
line2.close()








0
mr_fid
mr_fid

Reply 1 year ago

That's brilliant. my level of programming is very basic, i am very glad you have tidied up the code.

0
xSSPx
xSSPx

1 year ago

Thanks a bunch !! Was able to run a 16x2 and a 8x2 LCD with this. Saved me a lot of time. Very clean and precise code super easy to understand.

0
mr_fid
mr_fid

Reply 1 year ago

Thanks for your kind comments. Glad it worked for you.

0
mr_fid
mr_fid

Reply 1 year ago

OK, so i had a look at your data sheet and it is compatible. One thing i didn't go into on my instructable is that the RW line has to be pulled up, i have done this by adding a link on the lcd from VSS to RW. And you will need a variable resistor for the contrast. Did you have those? let me know and i will give a 16 * 2 a go to make sure it works for me

0
edwred
edwred

1 year ago

first view and comment