5. The LCD160CR skin¶
This tutorial shows how to get started using the LCD160CR skin.
For detailed documentation of the driver for the display see the
5.1. Plugging in the display¶
The display can be plugged directly into a pyboard (all pyboard versions are supported). You plug the display onto the top of the pyboard either in the X or Y positions. The display should cover half of the pyboard. See the picture above for how to achieve this; the left half of the picture shows the X position, and the right half shows the Y position.
5.2. Getting the driver¶
You can control the display directly using a power/enable pin and an I2C
bus, but it is much more convenient to use the driver provided by the
lcd160cr module. This driver is included in recent version of the
pyboard firmware (see here). You
can also find the driver in the GitHub repository
here, and to use this version you will need to copy the file to your
board, into a directory that is searched by import (usually the lib/
Once you have the driver installed you need to import it to use it:
5.3. Testing the display¶
There is a test program which you can use to test the features of the display, and which also serves as a basis to start creating your own code that uses the LCD. This test program is available on GitHub here. Copy it to the board over USB mass storage, or by using MicroPython remote control: mpremote.
To run the test from the MicroPython prompt do:
>>> import lcd160cr_test
It will then print some brief instructions. You will need to know which position your display is connected to (X or Y) and then you can run (assuming you have the display on position X):
5.4. Drawing some graphics¶
You must first create an LCD160CR object which will control the display. Do this using:
>>> import lcd160cr >>> lcd = lcd160cr.LCD160CR('X')
This assumes your display is connected in the X position. If it’s in the Y
position then use
lcd = lcd160cr.LCD160CR('Y') instead.
To erase the screen and draw a line, try:
>>> lcd.set_pen(lcd.rgb(255, 0, 0), lcd.rgb(64, 64, 128)) >>> lcd.erase() >>> lcd.line(10, 10, 50, 80)
The next example draws random rectangles on the screen. You can copy-and-paste it into the MicroPython prompt by first pressing “Ctrl-E” at the prompt, then “Ctrl-D” once you have pasted the text.
from random import randint for i in range(1000): fg = lcd.rgb(randint(128, 255), randint(128, 255), randint(128, 255)) bg = lcd.rgb(randint(0, 128), randint(0, 128), randint(0, 128)) lcd.set_pen(fg, bg) lcd.rect(randint(0, lcd.w), randint(0, lcd.h), randint(10, 40), randint(10, 40))
5.5. Using the touch sensor¶
The display includes a resistive touch sensor that can report the position (in pixels) of a single force-based touch on the screen. To see if there is a touch on the screen use:
This will return either
True. Run the above command while touching
the screen to see the result.
To get the location of the touch you can use the method:
This will return a 3-tuple, with the first entry being 0 or 1 depending on whether there is currently anything touching the screen (1 if there is), and the second and third entries in the tuple being the x and y coordinates of the current (or most recent) touch.
5.6. Directing the MicroPython output to the display¶
The display supports input from a UART and implements basic VT100 commands, which means it can be used as a simple, general purpose terminal. Let’s set up the pyboard to redirect its output to the display.
First you need to create a UART object:
>>> import pyb >>> uart = pyb.UART('XA', 115200)
This assumes your display is connected to position X. If it’s on position Y then
uart = pyb.UART('YA', 115200) instead.
Now, connect the REPL output to this UART:
From now on anything you type at the MicroPython prompt, and any output you receive, will appear on the display.
No set-up commands are required for this mode to work and you can use the display
to monitor the output of any UART, not just from the pyboard. All that is needed
is for the display to have power, ground and the power/enable pin driven high.
Then any characters on the display’s UART input will be printed to the screen.
You can adjust the UART baudrate from the default of 115200 using the