Teensy_4.1_ILI9341.md

ILI9341_T4

LCD

#define PIN_SCK     13      // mandatory
#define PIN_MISO    12      // mandatory (if the display has no MISO line, set this to 255 but then VSync will be disabled)
#define PIN_MOSI    11      // mandatory
#define PIN_DC      9      // mandatory, can be any pin but using pin 10 (or 36 or 37 on T4.1) provides greater performance

#define PIN_CS      10       // optional (but recommended), can be any pin.  
#define PIN_RESET   6       // optional (but recommended), can be any pin. 

Touch

// XPT2046 TOUSCHSCREEN CONNECTED ON THE SAME SPI PORT AS ILI9341:
// 
// -> connect T_DIN to the same Teensy pin as PIN_MOSI
// -> connect T_DO to the same Teensy pin as PIN_MISO
// 
#define PIN_TOUCH_CS  4     // mandatory for this example, can be any pin
#define PIN_TOUCH_IRQ 3     // (optional) can be any digital pin with interrupt capabilities

Micropython SPI example

i.MXRT SPI Bus:

SPI bus

"""ILI9341 demo (bouncing boxes)."""
from machine import Pin, SPI, SoftSPI
from random import random, seed
from ili9341 import Display, color565
from utime import sleep_us, ticks_cpu, ticks_us, ticks_diff


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))
        # TeensyHardware SPI
        # https://docs.micropython.org/en/latest/mimxrt/quickref.html#hardware-spi-bus
        # spi = SPI(0, 10000000)
        # TeensySoftware SPI
        spi = SoftSPI(baudrate=40000000, polarity=1, phase=0, sck=Pin(13), mosi=Pin(11), miso=Pin(12))
        # https://docs.micropython.org/en/latest/mimxrt/quickref.html#software-spi-bus
        display = Display(spi, dc=Pin(9), cs=Pin(10), rst=Pin(6))
        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()

Simple ILI9341 shader test

mySetup.py

from ili9341 import Display
from machine import Pin, SPI,SoftSPI

TFT_CLK_PIN = const(13)
TFT_MOSI_PIN = const(11)
TFT_MISO_PIN = const(12)

TFT_CS_PIN = const(10)
TFT_RST_PIN = const(6)
TFT_DC_PIN = const(9)

def createMyDisplay():
    #sw
    #tftSpi = SoftSPI(baudrate=40000000, polarity=1, phase=0,sck=Pin(TFT_CLK_PIN), mosi=Pin(TFT_MOSI_PIN), miso=Pin(TFT_MISO_PIN))
    # hw
    tftSpi = SPI(0, 40 * 1000000)
    display = Display(spi = tftSpi,
                      dc=Pin(TFT_DC_PIN), cs=Pin(TFT_CS_PIN), rst=Pin(TFT_RST_PIN))
    return display
       

main.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 math
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()

class Vector2:
    """A two-dimensional vector with Cartesian coordinates."""

    def __init__(self, x, y):
        self.x, self.y = x, y

    def __str__(self):
        """Human-readable string representation of the vector."""
        return '{:g}i + {:g}j'.format(self.x, self.y)

    def __repr__(self):
        """Unambiguous string representation of the vector."""
        return repr((self.x, self.y))

    def dot(self, other):
        """The scalar (dot) product of self and other. Both must be vectors."""

        if not isinstance(other, Vector2D):
            raise TypeError('Can only take dot product of two Vector2D objects')
        return self.x * other.x + self.y * other.y
    # Alias the __matmul__ method to dot so we can use a @ b as well as a.dot(b).
    __matmul__ = dot

    def __sub__(self, other):
        """Vector subtraction."""
        return Vector2(self.x - other.x, self.y - other.y)

    def __add__(self, other):
        """Vector addition."""
        return Vector2(self.x + other.x, self.y + other.y)

    def __mul__(self, scalar):
        """Multiplication of a vector by a scalar."""

        if isinstance(scalar, int) or isinstance(scalar, float):
            return Vector2(self.x*scalar, self.y*scalar)
        raise NotImplementedError('Can only multiply Vector2D by a scalar')

    def __rmul__(self, scalar):
        """Reflected multiplication so vector * scalar also works."""
        return self.__mul__(scalar)

    def __neg__(self):
        """Negation of the vector (invert through origin.)"""
        return Vector2(-self.x, -self.y)

    def __truediv__(self, scalar):
        """True division of the vector by a scalar."""
        return Vector2(self.x / scalar, self.y / scalar)

    def __mod__(self, scalar):
        """One way to implement modulus operation: for each component."""
        return Vector2(self.x % scalar, self.y % scalar)

    def __abs__(self):
        """Absolute value (magnitude) of the vector."""
        return math.sqrt(self.x**2 + self.y**2)

    def distance_to(self, other):
        """The distance between vectors self and other."""
        return abs(self - other)

    def to_polar(self):
        """Return the vector's components in polar coordinates."""
        return self.__abs__(), math.atan2(self.y, self.x)
    
downScale = 0.125*1
oW = 240;
oH = 320;
cX = 0;



while True:
    cX = cX + 0.05;
    for x in range(int(oW*downScale)):
        for y in range(int(oH*downScale)):
            uv=Vector2(x,1.-y)
            speed = .1;
            scale = 0.01*int(1/downScale);
            p = Vector2(x*scale,y*scale)
                    
            for i in range(1,2):
                p.x+=0.3/i*math.sin(i*3.*p.y ) + cX;
                p.y+=0.3/i*math.cos(i*3.*p.x);
            r=math.cos(p.x+p.y+1.)*.5+.5;
            g=math.sin(p.x+p.y+1.)*.5+.5;
            b=(math.sin(p.x+p.y)+math.cos(p.x+p.y))*.3+.5;
                    
            c = ili9341.color565(int(r*255),int(g*255),int(255 - b*255))
            display.fill_rectangle(x*int(1/downScale), y*int(1/downScale),int(1/downScale),int(1/downScale), c)

print("- bye -")