How can I use a LCD display with a I2C adapter?

Question

I'd like to try to communicate to a 16x2 LCD display, however whole docs I found assume I should connect the whole pin-out however I got some kind of I2C adapter from mjkdz.com which makes a 4 pin interface:

enter image description here

Then I wonder:

• How should I connect and use my display to my Raspbery I2C pins?
• What libraries should I use for either C or Python?
• How should I get rid of the LCD writing back and so sending 5 V risk?

• goldilocks: I think you may need a level shifter?
• Danilo Bargen: I wrote a Python LCD library for the Raspberry Pi: github.com/dbrgn/RPLCD There's an I2C branch that I was working on: github.com/dbrgn/RPLCD/tree/i2c It's not finished yet, but maybe I'll find the time to do so soon. Contributions always welcome.
• diegoaguilar: Could you write any introductor steps in a answer?

Answer 1

You do not need level converter as long you will not mix 5V and 3.3V I2C devices. Raspberry is tough enough to handle 5V I2C devices without a problem. So you are safe here.

Use links from previous reply to enable I2C support and connect LCD with a converter.

You can tak a look at this:

https://github.com/DzikuVx/WinguWeatherRaspberryPi

File lcd.py uses very similar LCD with I2C to display some text.

Have fun

Answer 2

Here are the basics of getting i2c working under linux and python:

http://www.instructables.com/id/Raspberry-Pi-I2C-Python/

As far as your module, here is a post I saw about the i2c address:

http://forum.arduino.cc/index.php?topic=142255.0

Finally I think you can get away without a levelshifter, but it's not guaranteed to work. To prevent the i2c slave (at 5v) from writing back, never send a "read" command over i2c. only send a "write" command. The read/write command is usually controlled by most significant bit (first bit) of the i2c address. I can't find the datasheet for your lcd converter. But it would be very helpful if you could find and post it.

If you need a levelshifter, here is one: http://letsmakerobots.com/blog/unixguru/running-both-5v-and-33v-devices-i2c

Answer 3

you can use this library ,very easily

for write data in lcd ex. clear display write charecter ...

from time import sleep 
import i2c_lib

select LCD I2C address :

# LCD Address
ADDRESS = 0x3F
#ADDRESS = 0x27

I2C bus (1,2)

BUS =1

commands register address :

LCD_CLEARDISPLAY = 0x01
LCD_RETURNHOME = 0x02
LCD_ENTRYMODESET = 0x04
LCD_DISPLAYCONTROL = 0x08
LCD_CURSORSHIFT = 0x10
LCD_FUNCTIONSET = 0x20
LCD_SETCGRAMADDR = 0x40
LCD_SETDDRAMADDR = 0x80

flags for display entry mode

LCD_ENTRYRIGHT = 0x00
LCD_ENTRYLEFT = 0x02
LCD_ENTRYSHIFTINCREMENT = 0x01
LCD_ENTRYSHIFTDECREMENT = 0x00

flags for display on/off control

LCD_DISPLAYON = 0x04
LCD_DISPLAYOFF = 0x00
LCD_CURSORON = 0x02
LCD_CURSOROFF = 0x00
LCD_BLINKON = 0x01
LCD_BLINKOFF = 0x00

flags for display/cursor shift

LCD_DISPLAYMOVE = 0x08
LCD_CURSORMOVE = 0x00
LCD_MOVERIGHT = 0x04
LCD_MOVELEFT = 0x00

flags for function set

LCD_8BITMODE = 0x10
LCD_4BITMODE = 0x00
LCD_2LINE = 0x08
LCD_1LINE = 0x00
LCD_5x10DOTS = 0x04
LCD_58DOTS = 0x00

flags for backlight control

LCD_BACKLIGHT = 0x08
LCD_NOBACKLIGHT = 0x00
En = 0b00000100 # Enable bit
Rw = 0b00000010 # Read/Write bit
Rs = 0b00000001 # Register select bit

Class to control the 16x2 I2C LCD display from sainsmart from the Raspberry Pi

class lcd: 

Setup the display, turn on backlight and text display + ...?

 def __init__(self):
 self.device = i2c_lib.i2c_device(ADDRESS, BUS)
 self.write(0x03)
 self.write(0x03)
 self.write(0x03)
 self.write(0x02)
 self.write(LCD_FUNCTIONSET | LCD_2LINE | LCD_5x8DOTS | LCD_4BITMODE)
 self.write(LCD_DISPLAYCONTROL | LCD_DISPLAYON)
 # self.write(LCD_CLEARDISPLAY)
 self.write(LCD_ENTRYMODESET | LCD_ENTRYLEFT)
 sleep(0.2)

clocks EN to latch command

 def strobe(self, data):
 self.device.write_cmd(data | En | LCD_BACKLIGHT)
 sleep(0.0005)
 self.device.write_cmd(((data & ~En) | LCD_BACKLIGHT))
 sleep(0.001)
 def write_four_bits(self, data):
 self.device.write_cmd(data | LCD_BACKLIGHT)
 self.strobe(data)

write a command to lcd

 def write(self, cmd, mode=0):
 self.write_four_bits(mode | (cmd & 0xF0))
 self.write_four_bits(mode | ((cmd << 4) & 0xF0))
 def display_string(self, string, line):
 if line == 1:
 self.write(0x80)
 if line == 2:
 self.write(0xC0)
 if line == 3:
 self.write(0x94)
 if line == 4:
 self.write(0xD4)
 for char in string:
 self.write(ord(char), Rs)

clear lcd and set to home

 def clear(self):
 self.write(LCD_CLEARDISPLAY)
 self.write(LCD_RETURNHOME)

turn off backlight, anything that calls write turns it on again

 def backlight_off(self):
 self.device.write_cmd(LCD_NOBACKLIGHT)

turn off the text display

 def display_off(self):
 self.write(LCD_DISPLAYCONTROL | LCD_DISPLAYOFF)

turn on the text display

 def display_on(self):
 self.write(LCD_DISPLAYCONTROL | LCD_DISPLAYON)

example :

from lcd import lcd
mylcd = lcd
mylcd.clear()
lcd_str = 'hello world'

write in line 1

 mylcd.display_string(lcd_str,1)