Latest revision as of 19:00, 20 June 2016

Also see the original project, which was using an Arduino to control this LCD display: Arduino/LCD Display

Overview

See Arduino LCD Display#Overview for an overview of how the LCD display works. It works by communicating with the microcontroller using I2C pins, which provide a way for integrated circuits to communicate with each other.

Adafruit provides an entire package for interfacing with character LCD displays [1]. Unfortunately, however, these are for LCDs that do not have an integrated circuit onboard, and so have a much greater number of pins. This is an excellent illustration of why we would want to install an integrated circuit to control the LCD, rather than controlling the LCD directly.

Without the IC onboard the LCD, we might need to connect up to 16 pins:

But with the Pi, we have only the two power pins (which can/should be connected to something other than the Pi) and the SDA/SCL pins.

The Code

This section covers the software needed to drive the LCD display via the GPIO pins on the Raspberry Pi.

Preparing the Pi

Pinout

See [2] for Raspberry Pi pinout diagram.

To run a simple hello world with the Sainsmart LCD hooked up to the Pi, it is necessary to send IC2 signals out over pins 3 and 5, SDA/SCL.

Basic Connection to Pi

Make sure you can log in to the Pi. This consists of the following steps:

Mount the SD card and edit cmdline.txt, hard-code an IP address in cmdline.txt
Unmount the SD card and insert it back into the Pi and power it up
Give the Pi a minute to finish booting up, then connect it using an Ethernet cable to your desktop/computer
Remotely log in to the Pi via SSH

Enable SPI

In order to use the GPIO, you need the GPIO library installed above (which provides bindings between Python and the Raspberry Pi kernel, which contains code to control the pins on-board the Pi).

However, in order to use I2C, which is the protocol used to communicate from one integrated circuit to another, you need to enable SPI on the Raspberry Pi.

This page [3] states that SPI is not enabled by default on Raspbian. However, I had Kali for ARM installed, and SPI was enabled by default. If you run the lsmod command, you can check whether the SPI kernel module is enabled. (This stuff is mostly over my head anyway, but you don't have to understand all the details of what's going on to make it work...)

$  lsmod
Module                  Size  Used by
cfg80211              498967  0
rfkill                 22468  1 cfg80211
snd_soc_wm8804          8209  0
snd_soc_pcm512x_i2c     2562  0
regmap_spi              2307  1 snd_soc_wm8804
snd_soc_tas5713         5858  0
snd_soc_pcm512x        16523  1 snd_soc_pcm512x_i2c
regmap_i2c              3338  3 snd_soc_wm8804,snd_soc_pcm512x_i2c,snd_soc_tas5713
snd_soc_bcm2708_i2s     7595  0
regmap_mmio             3548  1 snd_soc_bcm2708_i2s
snd_soc_core          167442  4 snd_soc_pcm512x,snd_soc_wm8804,snd_soc_tas5713,snd_soc_bcm2708_i2s
snd_compress            8840  1 snd_soc_core
snd_pcm_dmaengine       5770  1 snd_soc_core
snd_pcm                92149  4 snd_soc_pcm512x,snd_soc_wm8804,snd_soc_core,snd_pcm_dmaengine
snd_timer              23475  1 snd_pcm
spi_bcm2708             6006  0
i2c_bcm2708             6244  0
snd                    67406  4 snd_soc_core,snd_timer,snd_pcm,snd_compress
fuse                   92370  1
ipv6                  353829  0

The line we're looking for here relates to SPI:

spi_bcm2708             6006  0

This means we have the SPI kernel module enabled. In case you don't have it enabled, you can find instructions here [4]. Basically, enable the kernel module using modprobe:

$ sudo modprobe spi_bcm2708
$ sudo chown `id -u`.`id -g` /dev/spidev0.*

SMBus

Let's introduce yet another acronym-infused techno-jargony term: SMBus.

To communicate over the I2C ports, you can use the I2C standard protocol, but you can also use SMBus, which is a subset of the I2C protocol. SMBus is common in devices, I suppose, so you want to use it when you can - that way, it'll work if I2C is used, and it'll work if SMBus is used.

Before we can use this code, we need to address the fact that the Pi uses 3.3 V logic, but the LCD display uses 5.5 V logic. So we need a logic converter, 3.3V to 5V. Apparently, this is necessary. But it actually works without it. Not sure why.

Aptitude

Install some smbus tools and I2C tools using aptitude:

sudo apt-get install python-smbus i2c-tools

these came from here: http://hardware-libre.fr/2014/03/en-raspberry-pi-using-a-4x20-characters-display/

The Circuit

This is straightforward. There are four wires:

RED - 5 V port of Raspberry Pi
GND - ground of Raspberry Pi
SDA - connects the SDA port on the LCD display to the SDA port of the Raspberry Pi GPIO pins
SCL - connects the SCL port on the LCD display to the SCL port of the Raspberry Pi GPIO pins

There should be an additional circuit between the 3.3 V Pi and the 5 V LCD, but (apparently) it is not necessary. I hope it is not necessary.

The Result

Flags

@@ Line 1: / Line 1: @@
-Also see [[Arduino LCD Display]], which was the original.
+Also see the original project, which was using an Arduino to control this LCD display: [[Arduino/LCD Display]]
+[[Image:LCD16pins_3.jpg|400px]]
 =Overview=
@@ Line 5: / Line 7: @@
 See [[Arduino LCD Display#Overview]] for an overview of how the LCD display works. It works by communicating with the microcontroller using I2C pins, which provide a way for integrated circuits to communicate with each other.
-=The Code=
-This section covers the software needed to drive the LCD display via the GPIO pins on the Raspberry Pi.
 Adafruit provides an entire package for interfacing with character LCD displays [https://github.com/adafruit/Adafruit_Python_CharLCD]. Unfortunately, however, these are for LCDs that do not have an integrated circuit onboard, and so have a much greater number of pins. This is an excellent illustration of why we would want to install an integrated circuit to control the LCD, rather than controlling the LCD directly.
@@ Line 20: / Line 19: @@
 [[Image:LCD16pins_3.jpg|400px]]
+=The Code=
+This section covers the software needed to drive the LCD display via the GPIO pins on the Raspberry Pi.
 ==Preparing the Pi==
+===Pinout===
+See [https://howto8165.files.wordpress.com/2014/08/rpi-pinout.png] for Raspberry Pi pinout diagram.
+To run a simple hello world with the Sainsmart LCD hooked up to the Pi, it is necessary to send IC2 signals out over pins 3 and 5, SDA/SCL.
 ===Basic Connection to Pi===
@@ Line 30: / Line 39: @@
 * Give the Pi a minute to finish booting up, then connect it using an Ethernet cable to your desktop/computer
 * Remotely log in to the Pi via SSH
-===Installing Pi GPIO Library===
-Adafruit code for controlling LCDs from the Raspberry Pi: https://github.com/adafruit/Adafruit_Python_CharLCD
-Make sure the RPi-GPIO package is installed:
-Download the package on your laptop and copy it over to the Pi:
-<pre>
-[laptop] $ wget https://pypi.python.org/packages/source/R/RPi.GPIO/RPi.GPIO-0.5.11.tar.gz
-[laptop] $ scp RPi.*.tar.gz root@169.254.113.200:~/.
-</pre>
-Then you install it manually on the Pi:
-<pre>
-[pi] $ cd ~
-[pi] $ tar xzf RPi*.tar.gz
-[pi] $ cd RPi*
-[pi] $ sudo python setup.py install
-</pre>
-This has other prerequisites, all available from Adafruit on GitHub (need to add links):
-<pre>
-Adafruit_Python_PureIO
-Adafruit_Python_GPIO
-py-spidev
-</pre>
-These will need to be installed in a similar way (downloading on an internet-connected computer, and copied over to the py so you can run <code>python setup.py install</code>). Alternatively, you can hook up the Pi to an internet-connected router, which makes it easier to both remotely connect to it and to be able to use tools like pip and apt-get.
 ===Enable SPI===
@@ Line 108: / Line 85: @@
 $ sudo chown `id -u`.`id -g` /dev/spidev0.*
 </pre>
-==Hello World==
-See [https://howto8165.files.wordpress.com/2014/08/rpi-pinout.png] for Raspberry Pi pinout diagram.
-To run a simple hello world with the Sainsmart LCD hooked up to the Pi, it is necessary to send IC2 signals out over pins 3 and 5, SDA/SCL.
-http://hardware-libre.fr/2014/03/en-raspberry-pi-using-a-4x20-characters-display/
 ===SMBus===
@@ Line 124: / Line 92: @@
 To communicate over the I2C ports, you can use the I2C standard protocol, but you can also use SMBus, which is a subset of the I2C protocol. SMBus is common in devices, I suppose, so you want to use it when you can - that way, it'll work if I2C is used, and it'll work if SMBus is used.
-Unfortunately, however, before we can use this code, we need to address the fact that the Pi uses 3.3 V logic, but the LCD display uses 5.5 V logic. So we need a logic converter, 3.3V to 5V.
+Before we can use this code, we need to address the fact that the Pi uses 3.3 V logic, but the LCD display uses 5.5 V logic. So we need a logic converter, 3.3V to 5V. Apparently, this is necessary. But it actually works without it. Not sure why.
-===If only we had aptitude===
+===Aptitude===
+Install some smbus tools and I2C tools using aptitude:
 <pre>
-sudo apt-get install python-smbus i2c-tools. Enter "sudo reboot" to restart the pi and now the I2C pins will be available to use.
+sudo apt-get install python-smbus i2c-tools
 </pre>
-===Other Code===
+these came from here: http://hardware-libre.fr/2014/03/en-raspberry-pi-using-a-4x20-characters-display/
-This advertises itself as a drop-in for smbus: https://github.com/adafruit/Adafruit_Python_PureIO
 =The Circuit=
@@ Line 145: / Line 113: @@
 * SCL - connects the SCL port on the LCD display to the SCL port of the Raspberry Pi GPIO pins
-There is some yadda yadda about 3.3 V vs 5 V. Hope that it doesn't matter!
+There should be an additional circuit between the 3.3 V Pi and the 5 V LCD, but (apparently) it is not necessary. I hope it is not necessary.
+==The Result==
+[[Image:Pi_LCD_1.jpg|500px]]
-===The Result===
+[[Image:Pi_LCD_2.jpg|500px]]
 =Flags=
 {{PiFlag}}

RaspberryPi/LCD Display: Difference between revisions

From charlesreid1