LCD 2x16 I2C in Python

mswiniuch

I need your help.
I'd like to display some text on text LCD 2x16 connected by I2C to GPIO. I don't know how to start with it - I'm not programist. Can you give me simple example code please?
Based on https://github.com/duxingkei33/orangepi_PC_gpio_pyH3 I can use buttons but I have no idea how to get LCD working.

nopnop2002

I ported python code of this page to OrangePi-PC.

http://www.raspberrypi-spy.co.uk/2012/07/16x2-lcd-module-control-using-python/

1. #!/usr/bin/python
   
2. #--------------------------------------
   
3. #    ___  ___  _ ____
   
4. #   / _ \/ _ \(_) __/__  __ __
   
5. #  / , _/ ___/ /\ \/ _ \/ // /
   
6. # /_/|_/_/  /_/___/ .__/\_, /
   
7. #                /_/   /___/
   
8. #
   
9. #  lcd_16x2.py
   
10. #  16x2 LCD Test Script
    
11. #
    
12. # Author : Matt Hawkins
    
13. # Date   : 06/04/2015
    
14. #
    
15. # http://www.raspberrypi-spy.co.uk/
    
16. #
    
17. #--------------------------------------
    
18. 
    
19. # The wiring for the LCD is as follows:
    
20. # 1 : GND
    
21. # 2 : 5V
    
22. # 3 : Contrast (0-5V)*
    
23. # 4 : RS (Register Select)
    
24. # 5 : R/W (Read Write)       - GROUND THIS PIN
    
25. # 6 : Enable or Strobe
    
26. # 7 : Data Bit 0             - NOT USED
    
27. # 8 : Data Bit 1             - NOT USED
    
28. # 9 : Data Bit 2             - NOT USED
    
29. # 10: Data Bit 3             - NOT USED
    
30. # 11: Data Bit 4
    
31. # 12: Data Bit 5
    
32. # 13: Data Bit 6
    
33. # 14: Data Bit 7
    
34. # 15: LCD Backlight +5V**
    
35. # 16: LCD Backlight GND
    
36. 
    
37. #import
    
38. #import RPi.gpio.as GPIO
    
39. from pyA20.gpio import gpio
    
40. from pyA20.gpio import port
    
41. import time
    
42. 
    
43. # Define gpio.to LCD mapping
    
44. # for RaspberryPi
    
45. #LCD_RS = 7
    
46. #LCD_E  = 8
    
47. #LCD_D4 = 25
    
48. #LCD_D5 = 24
    
49. #LCD_D6 = 23
    
50. #LCD_D7 = 18
    
51. # for OrangePi
    
52. LCD_RS = port.PA21
    
53. LCD_E  = port.PC3
    
54. LCD_D4 = port.PA2
    
55. LCD_D5 = port.PC7
    
56. LCD_D6 = port.PC4
    
57. LCD_D7 = port.PD14
    
58. 
    
59. # Define some device constants
    
60. LCD_WIDTH = 16    # Maximum characters per line
    
61. LCD_CHR = True
    
62. LCD_CMD = False
    
63. 
    
64. LCD_LINE_1 = 0x80 # LCD RAM address for the 1st line
    
65. LCD_LINE_2 = 0xC0 # LCD RAM address for the 2nd line
    
66. 
    
67. # Timing constants
    
68. E_PULSE = 0.0005
    
69. E_DELAY = 0.0005
    
70. 
    
71. def main():
    
72.   # Main program block
    
73. #  gpio.setwarnings(False)
    
74.   gpio.init()                      # Use BCM gpio.numbers
    
75.   gpio.setcfg(LCD_E, gpio.OUTPUT)  # E
    
76.   gpio.setcfg(LCD_RS, gpio.OUTPUT) # RS
    
77.   gpio.setcfg(LCD_D4, gpio.OUTPUT) # DB4
    
78.   gpio.setcfg(LCD_D5, gpio.OUTPUT) # DB5
    
79.   gpio.setcfg(LCD_D6, gpio.OUTPUT) # DB6
    
80.   gpio.setcfg(LCD_D7, gpio.OUTPUT) # DB7
    
81. 
    
82.   # Initialise display
    
83.   lcd_init()
    
84. 
    
85.   while True:
    
86. 
    
87.     # Send some test
    
88.     lcd_string("Rasbperry Pi",LCD_LINE_1)
    
89.     lcd_string("16x2 LCD Test",LCD_LINE_2)
    
90. 
    
91.     time.sleep(3) # 3 second delay
    
92. 
    
93.     # Send some text
    
94.     lcd_string("1234567890123456",LCD_LINE_1)
    
95.     lcd_string("abcdefghijklmnop",LCD_LINE_2)
    
96. 
    
97.     time.sleep(3) # 3 second delay
    
98. 
    
99.     # Send some text
    
100.     lcd_string("RaspberryPi-spy",LCD_LINE_1)
     
101.     lcd_string(".co.uk",LCD_LINE_2)
     
102. 
     
103.     time.sleep(3)
     
104. 
     
105.     # Send some text
     
106.     lcd_string("Follow me on",LCD_LINE_1)
     
107.     lcd_string("Twitter @RPiSpy",LCD_LINE_2)
     
108. 
     
109.     time.sleep(3)
     
110. 
     
111. def lcd_init():
     
112.   # Initialise display
     
113.   lcd_byte(0x33,LCD_CMD) # 110011 Initialise
     
114.   lcd_byte(0x32,LCD_CMD) # 110010 Initialise
     
115.   lcd_byte(0x06,LCD_CMD) # 000110 Cursor move direction
     
116.   lcd_byte(0x0C,LCD_CMD) # 001100 Display On,Cursor Off, Blink Off
     
117.   lcd_byte(0x28,LCD_CMD) # 101000 Data length, number of lines, font size
     
118.   lcd_byte(0x01,LCD_CMD) # 000001 Clear display
     
119.   time.sleep(E_DELAY)
     
120. 
     
121. def lcd_byte(bits, mode):
     
122.   # Send byte to data pins
     
123.   # bits = data
     
124.   # mode = True  for character
     
125.   #        False for command
     
126. 
     
127.   gpio.output(LCD_RS, mode) # RS
     
128. 
     
129.   # High bits
     
130.   gpio.output(LCD_D4, False)
     
131.   gpio.output(LCD_D5, False)
     
132.   gpio.output(LCD_D6, False)
     
133.   gpio.output(LCD_D7, False)
     
134.   if bits&0x10==0x10:
     
135.     gpio.output(LCD_D4, True)
     
136.   if bits&0x20==0x20:
     
137.     gpio.output(LCD_D5, True)
     
138.   if bits&0x40==0x40:
     
139.     gpio.output(LCD_D6, True)
     
140.   if bits&0x80==0x80:
     
141.     gpio.output(LCD_D7, True)
     
142. 
     
143.   # Toggle 'Enable' pin
     
144.   lcd_toggle_enable()
     
145. 
     
146.   # Low bits
     
147.   gpio.output(LCD_D4, False)
     
148.   gpio.output(LCD_D5, False)
     
149.   gpio.output(LCD_D6, False)
     
150.   gpio.output(LCD_D7, False)
     
151.   if bits&0x01==0x01:
     
152.     gpio.output(LCD_D4, True)
     
153.   if bits&0x02==0x02:
     
154.     gpio.output(LCD_D5, True)
     
155.   if bits&0x04==0x04:
     
156.     gpio.output(LCD_D6, True)
     
157.   if bits&0x08==0x08:
     
158.     gpio.output(LCD_D7, True)
     
159. 
     
160.   # Toggle 'Enable' pin
     
161.   lcd_toggle_enable()
     
162. 
     
163. def lcd_toggle_enable():
     
164.   # Toggle enable
     
165.   time.sleep(E_DELAY)
     
166.   gpio.output(LCD_E, True)
     
167.   time.sleep(E_PULSE)
     
168.   gpio.output(LCD_E, False)
     
169.   time.sleep(E_DELAY)
     
170. 
     
171. def lcd_string(message,line):
     
172.   # Send string to display
     
173. 
     
174.   message = message.ljust(LCD_WIDTH," ")
     
175. 
     
176.   lcd_byte(line, LCD_CMD)
     
177. 
     
178.   for i in range(LCD_WIDTH):
     
179.     lcd_byte(ord(message[i]),LCD_CHR)
     
180. 
     
181. if __name__ == '__main__':
     
182. 
     
183.   try:
     
184.     main()
     
185.   except KeyboardInterrupt:
     
186.     pass
     
187.   finally:
     
188.     lcd_byte(0x01, LCD_CMD)
     
189.     lcd_string("Goodbye!",LCD_LINE_1)
     
190. #    gpio.cleanup()

Copy code

It work fine.

mswiniuch

Can you show how to connect on schematic? Or write port.xxx->pin number. I can't understand PCx, PDx. But maybe you can port other code for I2C - it should be easier.
Very simple code in C is here: http://www.itcooky.com/?p=4023

nopnop2002

mswiniuch replied at 2016-3-26 15:48
Can you show how to connect on schematic? Or write port.xxx->pin number. I can't understand PCx, PDx ...

The connection of a wire is same as this.

http://www.raspberrypi-spy.co.uk/2012/07/16x2-lcd-module-control-using-python/

Please refer to this about the name of the pin.

http://linux-sunxi.org/Xunlong_Orange_Pi_2

mswiniuch

Thank you nopnop2002 - it works
Belllow some code from me. This is verry simle internet radio control - mpd+mpc
I'm planing to do some menu sterred by three buttons to control not only radio but system.
I'm not programist and don't know pytton verry much so this code isn't so clear ;)

1. #!/usr/bin/env python
   
2. 
   
3. import os
   
4. import sys
   
5. import subprocess
   
6. import time
   
7. 
   
8. from time import sleep
   
9. from subprocess import *
   
10. from pyA20.gpio import gpio
    
11. from pyA20.gpio import connector
    
12. from pyA20.gpio import port
    
13. 
    
14. if not os.getegid() == 0:
    
15.   sys.exit('Script must be run as root')
    
16. 
    
17. button_pause = connector.gpio1p36  #PIN 36
    
18. button_prev  = connector.gpio1p38  #PIN 38
    
19. button_next  = connector.gpio1p40  #PIN 40
    
20. 
    
21. # Define GPIO to LCD mapping
    
22. LCD_RS = port.PA21 #PIN 26
    
23. LCD_E  = port.PC3  #PIN 24
    
24. LCD_D4 = port.PA2  #PIN 22
    
25. LCD_D5 = port.PC7  #PIN 18
    
26. LCD_D6 = port.PC4  #PIN 16
    
27. LCD_D7 = port.PD14 #PIN 12
    
28. 
    
29. # Define some device constants
    
30. LCD_WIDTH = 16    # Maximum characters per line
    
31. LCD_CHR = True
    
32. LCD_CMD = False
    
33. 
    
34. LCD_LINE_1 = 0x80 # LCD RAM address for the 1st line
    
35. LCD_LINE_2 = 0xC0 # LCD RAM address for the 2nd line
    
36. 
    
37. # Timing constants
    
38. E_PULSE = 0.0005
    
39. E_DELAY = 0.0005
    
40. 
    
41. #Init gpio module
    
42. gpio.init()
    
43. 
    
44. gpio.setcfg(LCD_E,  gpio.OUTPUT) # E
    
45. gpio.setcfg(LCD_RS, gpio.OUTPUT) # RS
    
46. gpio.setcfg(LCD_D4, gpio.OUTPUT) # DB4
    
47. gpio.setcfg(LCD_D5, gpio.OUTPUT) # DB5
    
48. gpio.setcfg(LCD_D6, gpio.OUTPUT) # DB6
    
49. gpio.setcfg(LCD_D7, gpio.OUTPUT) # DB7
    
50. 
    
51. #Set buttons
    
52. gpio.setcfg(button_pause, gpio.INPUT)
    
53. gpio.setcfg(button_prev,  gpio.INPUT)
    
54. gpio.setcfg(button_next,  gpio.INPUT)
    
55. 
    
56. #Enable pullup resistor
    
57. gpio.pullup(button_pause, gpio.PULLUP)
    
58. gpio.pullup(button_prev,  gpio.PULLUP)
    
59. gpio.pullup(button_next,  gpio.PULLUP)
    
60. 
    
61. 
    
62. def main():
    
63. 
    
64.   reset_pressed = 1
    
65.   prev_pressed = 1
    
66.   next_pressed = 1
    
67. 
    
68.   # Initialise display
    
69.   lcd_init()
    
70. 
    
71.   lcd_string("[  INTERNET    ]",LCD_LINE_1)
    
72.   lcd_string("[       RADIO  ]",LCD_LINE_2)
    
73. 
    
74.   while True:
    
75.     value_out = 0
    
76.     pause_pressed = gpio.input(button_pause)
    
77.     prev_pressed = gpio.input(button_prev)
    
78.     next_pressed = gpio.input(button_next)
    
79. 
    
80.     if (pause_pressed == 0):
    
81.       value_out = 1
    
82.       lcd_string("[ PRESSED      ]",LCD_LINE_1)
    
83.       lcd_string("[        PAUSE ]",LCD_LINE_2)
    
84.       run_cmd("mpc pause")
    
85. 
    
86.     if (prev_pressed == 0):
    
87.       value_out = 1
    
88.       lcd_string("[ PRESSED      ]",LCD_LINE_1)
    
89.       lcd_string("[      PREVIOUS]",LCD_LINE_2)
    
90.       run_cmd("mpc prev")
    
91. 
    
92.     if (next_pressed == 0):
    
93.       value_out = 1
    
94.       lcd_string("[ PRESSED      ]",LCD_LINE_1)
    
95.       lcd_string("[          NEXT]",LCD_LINE_2)
    
96.       run_cmd("mpc next")
    
97. 
    
98.     sleep(0.1)
    
99. 
    
100. 
     
101. def run_cmd(cmd):  
     
102.   p = Popen(cmd, shell=True, stdout=PIPE, stderr=STDOUT)  
     
103.   output = p.communicate()[0]  
     
104.   return output  
     
105. 
     
106. def lcd_init():
     
107.   # Initialise display
     
108.   lcd_byte(0x33,LCD_CMD) # 110011 Initialise
     
109.   lcd_byte(0x32,LCD_CMD) # 110010 Initialise
     
110.   lcd_byte(0x06,LCD_CMD) # 000110 Cursor move direction
     
111.   lcd_byte(0x0C,LCD_CMD) # 001100 Display On,Cursor Off, Blink Off
     
112.   lcd_byte(0x28,LCD_CMD) # 101000 Data length, number of lines, font size
     
113.   lcd_byte(0x01,LCD_CMD) # 000001 Clear display
     
114.   time.sleep(E_DELAY)
     
115. 
     
116. def lcd_byte(bits, mode):
     
117.   # Send byte to data pins
     
118.   # bits = data
     
119.   # mode = True  for character
     
120.   #        False for command
     
121. 
     
122.   gpio.output(LCD_RS, mode)
     
123. 
     
124.   # High bits
     
125.   gpio.output(LCD_D4, False)
     
126.   gpio.output(LCD_D5, False)
     
127.   gpio.output(LCD_D6, False)
     
128.   gpio.output(LCD_D7, False)
     
129.   if bits&0x10==0x10:
     
130.     gpio.output(LCD_D4, True)
     
131.   if bits&0x20==0x20:
     
132.     gpio.output(LCD_D5, True)
     
133.   if bits&0x40==0x40:
     
134.     gpio.output(LCD_D6, True)
     
135.   if bits&0x80==0x80:
     
136.     gpio.output(LCD_D7, True)
     
137. 
     
138.   # Toggle 'Enable' pin
     
139.   lcd_toggle_enable()
     
140. 
     
141.   # Low bits
     
142.   gpio.output(LCD_D4, False)
     
143.   gpio.output(LCD_D5, False)
     
144.   gpio.output(LCD_D6, False)
     
145.   gpio.output(LCD_D7, False)
     
146.   if bits&0x01==0x01:
     
147.     gpio.output(LCD_D4, True)
     
148.   if bits&0x02==0x02:
     
149.     gpio.output(LCD_D5, True)
     
150.   if bits&0x04==0x04:
     
151.     gpio.output(LCD_D6, True)
     
152.   if bits&0x08==0x08:
     
153.     gpio.output(LCD_D7, True)
     
154. 
     
155.   # Toggle 'Enable' pin
     
156.   lcd_toggle_enable()
     
157. 
     
158. def lcd_toggle_enable():
     
159.   # Toggle enable
     
160.   time.sleep(E_DELAY)
     
161.   gpio.output(LCD_E, True)
     
162.   time.sleep(E_PULSE)
     
163.   gpio.output(LCD_E, False)
     
164.   time.sleep(E_DELAY)
     
165. 
     
166. def lcd_string(message,line):
     
167.   # Send string to display
     
168.   message = message.ljust(LCD_WIDTH," ")
     
169.   lcd_byte(line, LCD_CMD)
     
170.   for i in range(LCD_WIDTH):
     
171.     lcd_byte(ord(message[i]),LCD_CHR)
     
172. 
     
173. 
     
174. if __name__ == '__main__':
     
175. 
     
176.   try:
     
177.     main()
     
178.   except KeyboardInterrupt:
     
179.     pass
     
180.   finally:
     
181.     lcd_byte(0x01, LCD_CMD)
     
182.     lcd_string("    Goodbye!    ",LCD_LINE_1)
     
183.     gpio.cleanup()

Copy code

Ehsanahmadi

nopnop2002Published in 2016-3-27 06:03
Edited by nopnop2002 at 2016-3-28 23:01

Thankyou nanopop2022,

It works well.