The display used in this exercise is a 2.4-inch 65K color using ili9341 driver with touch, 2.4inch_SPI_Module_ILI9341_SKU:MSP2402. I have other exercises using jeffmer/micropython-ili9341 library. This exercise using another lib rdagger/micropython-ili9341.
rdagger/micropython-ili9341 is a MicroPython ILI9341 Display and XPT2046 Touch Screen Drivers.
Connection:
Library:
Visit rdagger/micropython-ili9341, copy ili9341.py, xglcd_font.py and fonts/Unispace12x24.c to
your Raspberry Pi Pico device.
Exercise code:
To make it easy to update the lib's examples, I define the hardware connection
in separated code, mySetup.py. Save it to Raspberry Pi Pico device.
from ili9341 import Display
from machine import Pin, SPI
TFT_CLK_PIN = const(6)
TFT_MOSI_PIN = const(7)
TFT_MISO_PIN = const(4)
TFT_CS_PIN = const(13)
TFT_RST_PIN = const(14)
TFT_DC_PIN = const(15)
def createMyDisplay():
#spi = SPI(0, baudrate=40000000, sck=Pin(TFT_CLK_PIN), mosi=Pin(TFT_MOSI_PIN))
spiTFT = SPI(0, baudrate=51200000,
sck=Pin(TFT_CLK_PIN), mosi=Pin(TFT_MOSI_PIN))
display = Display(spiTFT,
dc=Pin(TFT_DC_PIN), cs=Pin(TFT_CS_PIN), rst=Pin(TFT_RST_PIN))
return display
My exercise code, mPico_ili9341_test.py.
"""
Raspperry Pi Pico exercise display on ili9341 SPI Display
using rdagger/micropython-ili9341,
MicroPython ILI9341 Display and XPT2046 Touch Screen Drivers
https://github.com/rdagger/micropython-ili9341
"""
from machine import Pin, SPI
from sys import implementation
from os import uname
import utime
import ili9341
from xglcd_font import XglcdFont
import mySetup
print(implementation.name)
print(uname()[3])
print(uname()[4])
print(SPI(0))
print(SPI(1))
display = mySetup.createMyDisplay()
print('Loading fonts...')
print('Loading unispace')
unispace = XglcdFont('fonts/Unispace12x24.c', 12, 24)
display.draw_text(0, 0, ili9341.__name__, unispace,
ili9341.color565(255, 128, 0))
display.draw_text(0, 25, ili9341.implementation.name, unispace,
ili9341.color565(0, 0, 200))
display.draw_text(0, 50, str(ili9341.implementation.version), unispace,
ili9341.color565(0, 0, 200))
display.draw_text(0, 100, "https://github.com/", unispace,
ili9341.color565(200, 200, 200))
display.draw_text(0, 125, "rdagger/micropython-ili9341", unispace,
ili9341.color565(200, 200, 200))
display.draw_text(0, 175, "ABCDEFGHIJKLMNOPQRS", unispace,
ili9341.color565(200, 200, 200))
display.draw_text(0, 200, "TUVWXYZ", unispace,
ili9341.color565(200, 200, 200))
display.draw_text(0, 225, "abcdefghijklmnopqrs", unispace,
ili9341.color565(200, 200, 200))
display.draw_text(0, 250, "tuvwxyz", unispace,
ili9341.color565(200, 200, 200))
display.draw_text(0, 275, "01234567890", unispace,
ili9341.color565(200, 200, 200))
display.draw_text(0, 300, "~!@#$%^&*()_+`-={}[]", unispace,
ili9341.color565(200, 200, 200))
display.draw_text(0, 325, "\|;:'<>,.?/", unispace,
ili9341.color565(200, 200, 200))
for i in range(320):
display.scroll(i)
utime.sleep(0.02)
for i in range(320, 0, -1):
display.scroll(i)
utime.sleep(0.02)
utime.sleep(0.5)
# Display inversion on
display.write_cmd(display.INVON)
utime.sleep(2)
# Display inversion off
display.write_cmd(display.INVOFF)
while True:
pass
print("- bye -")
I also modify some of the examples in the library.
"""ILI9341 demo (bouncing boxes)."""
from machine import Pin, SPI
from random import random, seed
from ili9341 import Display, color565
from utime import sleep_us, ticks_cpu, ticks_us, ticks_diff
import mySetup
class Box(object):
"""Bouncing box."""
def __init__(self, screen_width, screen_height, size, display, color):
"""Initialize box.
Args:
screen_width (int): Width of screen.
screen_height (int): Width of height.
size (int): Square side length.
display (ILI9341): display object.
color (int): RGB565 color value.
"""
self.size = size
self.w = screen_width
self.h = screen_height
self.display = display
self.color = color
# Generate non-zero random speeds between -5.0 and 5.0
seed(ticks_cpu())
r = random() * 10.0
self.x_speed = 5.0 - r if r < 5.0 else r - 10.0
r = random() * 10.0
self.y_speed = 5.0 - r if r < 5.0 else r - 10.0
self.x = self.w / 2.0
self.y = self.h / 2.0
self.prev_x = self.x
self.prev_y = self.y
def update_pos(self):
"""Update box position and speed."""
x = self.x
y = self.y
size = self.size
w = self.w
h = self.h
x_speed = abs(self.x_speed)
y_speed = abs(self.y_speed)
self.prev_x = x
self.prev_y = y
if x + size >= w - x_speed:
self.x_speed = -x_speed
elif x - size <= x_speed + 1:
self.x_speed = x_speed
if y + size >= h - y_speed:
self.y_speed = -y_speed
elif y - size <= y_speed + 1:
self.y_speed = y_speed
self.x = x + self.x_speed
self.y = y + self.y_speed
def draw(self):
"""Draw box."""
x = int(self.x)
y = int(self.y)
size = self.size
prev_x = int(self.prev_x)
prev_y = int(self.prev_y)
self.display.fill_hrect(prev_x - size,
prev_y - size,
size, size, 0)
self.display.fill_hrect(x - size,
y - size,
size, size, self.color)
def test():
"""Bouncing box."""
try:
# Baud rate of 40000000 seems about the max
#spi = SPI(1, baudrate=40000000, sck=Pin(14), mosi=Pin(13))
#display = Display(spi, dc=Pin(4), cs=Pin(16), rst=Pin(17))
display = mySetup.createMyDisplay()
display.clear()
colors = [color565(255, 0, 0),
color565(0, 255, 0),
color565(0, 0, 255),
color565(255, 255, 0),
color565(0, 255, 255),
color565(255, 0, 255)]
sizes = [12, 11, 10, 9, 8, 7]
boxes = [Box(239, 319, sizes[i], display,
colors[i]) for i in range(6)]
while True:
timer = ticks_us()
for b in boxes:
b.update_pos()
b.draw()
# Attempt to set framerate to 30 FPS
timer_dif = 33333 - ticks_diff(ticks_us(), timer)
if timer_dif > 0:
sleep_us(timer_dif)
except KeyboardInterrupt:
display.cleanup()
test()
demo_colored_squares_.py
"""ILI9341 demo (colored squares)."""
from time import sleep
from ili9341 import Display
from machine import Pin, SPI
from sys import modules
import mySetup
RED = const(0XF800) # (255, 0, 0)
GREEN = const(0X07E0) # (0, 255, 0)
BLUE = const(0X001F) # (0, 0, 255)
YELLOW = const(0XFFE0) # (255, 255, 0)
FUCHSIA = const(0XF81F) # (255, 0, 255)
AQUA = const(0X07FF) # (0, 255, 255)
MAROON = const(0X8000) # (128, 0, 0)
DARKGREEN = const(0X0400) # (0, 128, 0)
NAVY = const(0X0010) # (0, 0, 128)
TEAL = const(0X0410) # (0, 128, 128)
PURPLE = const(0X8010) # (128, 0, 128)
OLIVE = const(0X8400) # (128, 128, 0)
ORANGE = const(0XFC00) # (255, 128, 0)
DEEP_PINK = const(0XF810) # (255, 0, 128)
CHARTREUSE = const(0X87E0) # (128, 255, 0)
SPRING_GREEN = const(0X07F0) # (0, 255, 128)
INDIGO = const(0X801F) # (128, 0, 255)
DODGER_BLUE = const(0X041F) # (0, 128, 255)
CYAN = const(0X87FF) # (128, 255, 255)
PINK = const(0XFC1F) # (255, 128, 255)
LIGHT_YELLOW = const(0XFFF0) # (255, 255, 128)
LIGHT_CORAL = const(0XFC10) # (255, 128, 128)
LIGHT_GREEN = const(0X87F0) # (128, 255, 128)
LIGHT_SLATE_BLUE = const(0X841F) # (128, 128, 255)
WHITE = const(0XFFF) # (255, 255, 255)
colors = [RED,
GREEN,
BLUE,
YELLOW,
FUCHSIA,
AQUA,
MAROON,
DARKGREEN,
NAVY,
TEAL,
PURPLE,
OLIVE,
ORANGE,
DEEP_PINK,
CHARTREUSE,
SPRING_GREEN,
INDIGO,
DODGER_BLUE,
CYAN,
PINK,
LIGHT_YELLOW,
LIGHT_CORAL,
LIGHT_GREEN,
LIGHT_SLATE_BLUE,
WHITE ]
def test():
"""Test code."""
"""
# Baud rate of 40000000 seems about the max
spi = SPI(0, baudrate=40000000, sck=Pin(TFT_CLK_PIN), mosi=Pin(TFT_MOSI_PIN))
display = Display(spi, dc=Pin(TFT_DC_PIN), cs=Pin(TFT_CS_PIN), rst=Pin(TFT_RST_PIN))
"""
display = mySetup.createMyDisplay()
"""
# Build color list from all upper case constants (lazy approach)
colors = [getattr(modules[__name__], name) for name in dir(
modules[__name__]) if name.isupper() and name is not 'SPI']
"""
colors.sort()
c = 0
for x in range(0, 240, 48):
for y in range(0, 320, 64):
display.fill_rectangle(x, y, 47, 63, colors[c])
c += 1
sleep(9)
display.cleanup()
test()
demo_color_palette_.py
"""ILI9341 demo (color palette)."""
from time import sleep
from ili9341 import Display, color565
from machine import Pin, SPI
import mySetup
def hsv_to_rgb(h, s, v):
"""
Convert HSV to RGB (based on colorsys.py).
Args:
h (float): Hue 0 to 1.
s (float): Saturation 0 to 1.
v (float): Value 0 to 1 (Brightness).
"""
if s == 0.0:
return v, v, v
i = int(h * 6.0)
f = (h * 6.0) - i
p = v * (1.0 - s)
q = v * (1.0 - s * f)
t = v * (1.0 - s * (1.0 - f))
i = i % 6
v = int(v * 255)
t = int(t * 255)
p = int(p * 255)
q = int(q * 255)
if i == 0:
return v, t, p
if i == 1:
return q, v, p
if i == 2:
return p, v, t
if i == 3:
return p, q, v
if i == 4:
return t, p, v
if i == 5:
return v, p, q
def test():
"""Test code."""
# Baud rate of 40000000 seems about the max
#spi = SPI(1, baudrate=40000000, sck=Pin(14), mosi=Pin(13))
#display = Display(spi, dc=Pin(4), cs=Pin(16), rst=Pin(17))
display = mySetup.createMyDisplay()
c = 0
for x in range(0, 240, 20):
for y in range(0, 320, 20):
color = color565(*hsv_to_rgb(c / 192, 1, 1))
display.fill_circle(x + 9, y + 9, 9, color)
c += 1
sleep(9)
display.cleanup()
test()
demo_color_wheel_.py
"""ILI9341 demo (color wheel)."""
from time import sleep
from ili9341 import Display, color565
from machine import Pin, SPI
from math import cos, pi, sin
import mySetup
HALF_WIDTH = const(120)
HALF_HEIGHT = const(160)
CENTER_X = const(119)
CENTER_Y = const(159)
ANGLE_STEP_SIZE = 0.05 # Decrease step size for higher resolution
PI2 = pi * 2
def hsv_to_rgb(h, s, v):
"""
Convert HSV to RGB (based on colorsys.py).
Args:
h (float): Hue 0 to 1.
s (float): Saturation 0 to 1.
v (float): Value 0 to 1 (Brightness).
"""
if s == 0.0:
return v, v, v
i = int(h * 6.0)
f = (h * 6.0) - i
p = v * (1.0 - s)
q = v * (1.0 - s * f)
t = v * (1.0 - s * (1.0 - f))
i = i % 6
v = int(v * 255)
t = int(t * 255)
p = int(p * 255)
q = int(q * 255)
if i == 0:
return v, t, p
if i == 1:
return q, v, p
if i == 2:
return p, v, t
if i == 3:
return p, q, v
if i == 4:
return t, p, v
if i == 5:
return v, p, q
def test():
"""Test code."""
# Baud rate of 40000000 seems about the max
#spi = SPI(1, baudrate=40000000, sck=Pin(14), mosi=Pin(13))
#display = Display(spi, dc=Pin(4), cs=Pin(16), rst=Pin(17))
display = mySetup.createMyDisplay()
x, y = 0, 0
angle = 0.0
# Loop all angles from 0 to 2 * PI radians
while angle < PI2:
# Calculate x, y from a vector with known length and angle
x = int(CENTER_X * sin(angle) + HALF_WIDTH)
y = int(CENTER_Y * cos(angle) + HALF_HEIGHT)
color = color565(*hsv_to_rgb(angle / PI2, 1, 1))
display.draw_line(x, y, CENTER_X, CENTER_Y, color)
angle += ANGLE_STEP_SIZE
sleep(5)
for r in range(CENTER_X, 0, -1):
color = color565(*hsv_to_rgb(r / HALF_WIDTH, 1, 1))
display.fill_circle(CENTER_X, CENTER_Y, r, color)
sleep(9)
display.cleanup()
test()
demo_shapes_.py
"""ILI9341 demo (shapes)."""
from time import sleep
from ili9341 import Display, color565
from machine import Pin, SPI
import mySetup
def test():
"""Test code."""
# Baud rate of 40000000 seems about the max
#spi = SPI(1, baudrate=40000000, sck=Pin(14), mosi=Pin(13))
#display = Display(spi, dc=Pin(4), cs=Pin(16), rst=Pin(17))
display = mySetup.createMyDisplay()
display.clear(color565(64, 0, 255))
sleep(1)
display.clear()
display.draw_hline(10, 319, 229, color565(255, 0, 255))
sleep(1)
display.draw_vline(10, 0, 319, color565(0, 255, 255))
sleep(1)
display.fill_hrect(23, 50, 30, 75, color565(255, 255, 255))
sleep(1)
display.draw_hline(0, 0, 222, color565(255, 0, 0))
sleep(1)
display.draw_line(127, 0, 64, 127, color565(255, 255, 0))
sleep(2)
display.clear()
coords = [[0, 63], [78, 80], [122, 92], [50, 50], [78, 15], [0, 63]]
display.draw_lines(coords, color565(0, 255, 255))
sleep(1)
display.clear()
display.fill_polygon(7, 120, 120, 100, color565(0, 255, 0))
sleep(1)
display.fill_rectangle(0, 0, 15, 227, color565(255, 0, 0))
sleep(1)
display.clear()
display.fill_rectangle(0, 0, 163, 163, color565(128, 128, 255))
sleep(1)
display.draw_rectangle(0, 64, 163, 163, color565(255, 0, 255))
sleep(1)
display.fill_rectangle(64, 0, 163, 163, color565(128, 0, 255))
sleep(1)
display.draw_polygon(3, 120, 286, 30, color565(0, 64, 255), rotate=15)
sleep(3)
display.clear()
display.fill_circle(132, 132, 70, color565(0, 255, 0))
sleep(1)
display.draw_circle(132, 96, 70, color565(0, 0, 255))
sleep(1)
display.fill_ellipse(96, 96, 30, 16, color565(255, 0, 0))
sleep(1)
display.draw_ellipse(96, 256, 16, 30, color565(255, 255, 0))
sleep(5)
display.cleanup()
test()
Detect Touch:
To detect touch, visit
rdagger/micropython-ili9341, download xpt2046.py to Raspberry Pi Pico.
Save mySetupX.py to Raspberry Pi Pico, with setup for xpd2046. Connect extra
pins accordingly.
from ili9341 import Display
from machine import Pin, SPI
from xpt2046 import Touch
TFT_CLK_PIN = const(6)
TFT_MOSI_PIN = const(7)
TFT_MISO_PIN = const(4)
TFT_CS_PIN = const(13)
TFT_RST_PIN = const(14)
TFT_DC_PIN = const(15)
XPT_CLK_PIN = const(10)
XPT_MOSI_PIN = const(11)
XPT_MISO_PIN = const(8)
XPT_CS_PIN = const(12)
XPT_INT = const(0)
def createMyDisplay():
spiTFT = SPI(0, baudrate=40000000, sck=Pin(TFT_CLK_PIN), mosi=Pin(TFT_MOSI_PIN))
display = Display(spiTFT,
dc=Pin(TFT_DC_PIN), cs=Pin(TFT_CS_PIN), rst=Pin(TFT_RST_PIN))
return display
def createXPT(touch_handler):
spiXPT = SPI(1, baudrate=1000000,
sck=Pin(XPT_CLK_PIN), mosi=Pin(XPT_MOSI_PIN), miso=Pin(XPT_MISO_PIN))
xpt = Touch(spiXPT, cs=Pin(XPT_CS_PIN), int_pin=Pin(XPT_INT),
int_handler=touch_handler)
return xpt
Run xpt_cal_.py, touch the corners to found the min/max of x/y. The detected
min/max of x/y will be shown on screen. (Please check the
video, y_max=2047 may be mis-detected, but very close. It apear before
touched.)
from machine import Pin, SPI
from sys import implementation
from os import uname
import ili9341
from xglcd_font import XglcdFont
import mySetupX
print(implementation.name)
print(uname()[3])
print(uname()[4])
print(SPI(0))
print(SPI(1))
minX = maxX = minY = maxY = 500
def xpt_touch(x, y):
global xptTouch
global minX, maxX, minY, maxY
touchXY = xptTouch.get_touch()
rawX = xptTouch.send_command(xptTouch.GET_X)
rawY = xptTouch.send_command(xptTouch.GET_Y)
if rawX != 0:
if rawX > maxX:
maxX = rawX
elif rawX < minX:
minX = rawX
if rawY != 0:
if rawY > maxY:
maxY = rawY
elif rawY < minY:
minY = rawY
display.fill_circle(x, y, 2, ili9341.color565(0, 255, 0))
print(str(x) + ":" + str(y) + " / " + str(rawX) + ":" + str(rawY))
if touchXY != None:
touchX = touchXY[0]
touchY = touchXY[1]
display.fill_circle(touchX, touchY, 2, ili9341.color565(255, 0, 0))
print(str(touchX) + ":" + str(touchY))
xReading = "X: " + str(minX) + " - " + str(maxX) + " "
yReading = "Y: " + str(minY) + " - " + str(maxY) + " "
display.draw_text(0, 100, xReading, unispace,
ili9341.color565(255, 128, 0))
display.draw_text(0, 125, yReading, unispace,
ili9341.color565(255, 128, 0))
display = mySetupX.createMyDisplay()
xptTouch = mySetupX.createXPT(xpt_touch)
print('Loading fonts...')
print('Loading unispace')
unispace = XglcdFont('fonts/Unispace12x24.c', 12, 24)
display.draw_text(0, 0, ili9341.__name__, unispace,
ili9341.color565(255, 128, 0))
display.draw_text(0, 25, ili9341.implementation.name, unispace,
ili9341.color565(0, 0, 200))
display.draw_text(0, 50, str(ili9341.implementation.version), unispace,
ili9341.color565(0, 0, 200))
while True:
pass
print("- bye -")
Update x_min, x_max, y_min and y_max in mySetupX.py accordingly.
xpt = Touch(spiXPT, cs=Pin(XPT_CS_PIN), int_pin=Pin(XPT_INT),
int_handler=touch_handler,
x_min=64, x_max=1847, y_min=148, y_max=2047)
Run my exercise code, xpt_moveII_2.4.py.
from machine import Pin, SPI, Timer
from sys import implementation
from os import uname
import ili9341
from xglcd_font import XglcdFont
import mySetupX
print(implementation.name)
print(uname()[3])
print(uname()[4])
print(SPI(0))
print(SPI(1))
led = Pin(25, Pin.OUT)
#=== variable share btween ISR and main loop ===
x_passedTo_ISR = 0
y_passwsTo_ISR = 0
EVT_NO = const(0)
EVT_PenDown = const(1)
EVT_PenUp = const(2)
event = EVT_NO
TimerReached = False
#===============================================
def xpt_touch(x, y):
global event, x_passedTo_ISR, y_passedTo_ISR
event = EVT_PenDown
x_passedTo_ISR = x
y_passedTo_ISR = y
display = mySetupX.createMyDisplay()
xptTouch = mySetupX.createXPT(xpt_touch)
print('Loading fonts...')
print('Loading unispace')
unispace = XglcdFont('fonts/Unispace12x24.c', 12, 24)
display.clear()
display.draw_text(0, 0, ili9341.__name__, unispace,
ili9341.color565(255, 128, 0))
display.draw_text(0, 25, ili9341.implementation.name, unispace,
ili9341.color565(0, 0, 200))
display.draw_text(0, 50, str(ili9341.implementation.version), unispace,
ili9341.color565(0, 0, 200))
tim = Timer()
def TimerTick(timer):
global TimerReached
TimerReached = True
tim.init(freq=50, mode=Timer.PERIODIC, callback=TimerTick)
touching = False
lastX = lastY = 0
while True:
curEvent = event
event = EVT_NO
if curEvent!= EVT_NO:
if curEvent == EVT_PenDown:
print("Pen Down")
touching = True
lastX = x_passedTo_ISR
lastY = y_passedTo_ISR
touchXY = xptTouch.get_touch()
rawX = xptTouch.send_command(xptTouch.GET_X)
rawY = xptTouch.send_command(xptTouch.GET_Y)
display.clear()
display.fill_circle(x_passedTo_ISR, y_passedTo_ISR,
8, ili9341.color565(0, 255, 0))
print(str(x_passedTo_ISR) + ":" + str(y_passedTo_ISR) +
" / " + str(rawX) + ":" + str(rawY))
if touchXY != None:
touchX = touchXY[0]
touchY = touchXY[1]
display.fill_circle(touchX, touchY, 5, ili9341.color565(255, 0, 0))
print(str(touchX) + ":" + str(touchY))
elif curEvent == EVT_PenUp:
print("Pen Up")
pass
else:
print("unknown event!!!")
if TimerReached:
TimerReached = False
if touching:
led.toggle()
buff = xptTouch.raw_touch()
if buff is not None:
x, y = xptTouch.normalize(*buff)
lastX = x
lastY = y
display.fill_circle(x, y, 1, ili9341.color565(255, 255, 255))
print("... " + str(x) + " : " + str(y))
else:
event = EVT_PenUp
touching = False
led.off()
display.fill_circle(lastX, lastY, 5, ili9341.color565(0, 0, 255))
print("- bye -")
Tested on my another unit of 2.8 inch version, 2.8" TFT SPI 240*320.
X-position is in reverse order, so edit for 2.8 inch version.
from machine import Pin, SPI, Timer
from sys import implementation
from os import uname
import ili9341
from xglcd_font import XglcdFont
import mySetupX
print(implementation.name)
print(uname()[3])
print(uname()[4])
print(SPI(0))
print(SPI(1))
led = Pin(25, Pin.OUT)
#=== variable share btween ISR and main loop ===
x_passedTo_ISR = 0
y_passwsTo_ISR = 0
EVT_NO = const(0)
EVT_PenDown = const(1)
EVT_PenUp = const(2)
event = EVT_NO
TimerReached = False
#===============================================
def xpt_touch(x, y):
global event, x_passedTo_ISR, y_passedTo_ISR
event = EVT_PenDown
x_passedTo_ISR = x
y_passedTo_ISR = y
display = mySetupX.createMyDisplay()
xptTouch = mySetupX.createXPT(xpt_touch)
print('Loading fonts...')
print('Loading unispace')
unispace = XglcdFont('fonts/Unispace12x24.c', 12, 24)
display.clear()
display.draw_text(0, 0, ili9341.__name__, unispace,
ili9341.color565(255, 128, 0))
display.draw_text(0, 25, ili9341.implementation.name, unispace,
ili9341.color565(0, 0, 200))
display.draw_text(0, 50, str(ili9341.implementation.version), unispace,
ili9341.color565(0, 0, 200))
tim = Timer()
def TimerTick(timer):
global TimerReached
TimerReached = True
tim.init(freq=50, mode=Timer.PERIODIC, callback=TimerTick)
touching = False
lastX = lastY = 0
while True:
curEvent = event
event = EVT_NO
if curEvent!= EVT_NO:
if curEvent == EVT_PenDown:
print("Pen Down")
touching = True
lastX = x_passedTo_ISR
lastY = y_passedTo_ISR
touchXY = xptTouch.get_touch()
rawX = xptTouch.send_command(xptTouch.GET_X)
rawY = xptTouch.send_command(xptTouch.GET_Y)
display.clear()
display.fill_circle(240-x_passedTo_ISR, y_passedTo_ISR,
8, ili9341.color565(0, 255, 0))
print(str(x_passedTo_ISR) + ":" + str(y_passedTo_ISR) +
" / " + str(rawX) + ":" + str(rawY))
if touchXY != None:
touchX = touchXY[0]
touchY = touchXY[1]
display.fill_circle(240-touchX, touchY, 5, ili9341.color565(255, 0, 0))
print(str(touchX) + ":" + str(touchY))
elif curEvent == EVT_PenUp:
print("Pen Up")
pass
else:
print("unknown event!!!")
if TimerReached:
TimerReached = False
if touching:
led.toggle()
buff = xptTouch.raw_touch()
if buff is not None:
x, y = xptTouch.normalize(*buff)
lastX = x
lastY = y
display.fill_circle(240-x, y, 1, ili9341.color565(255, 255, 255))
print("... " + str(x) + " : " + str(y))
else:
event = EVT_PenUp
touching = False
led.off()
display.fill_circle(240-lastX, lastY, 5, ili9341.color565(0, 0, 255))
print("- bye -")
Related:
~ CircuitPython version: Raspberry Pi Pico/CircuitPython + ILI9341 SPI Display with Touch
No comments:
Post a Comment