| 用户中心 | 我的订单
购物车(0)

树莓派 斑梨电子

树莓派1.14寸 1.3寸显示屏使用教程

Mini Pi TFT的1.3英寸和1.14英寸版本都具有相同的2x12连接器和引脚排列。


Mini Pi TFT连接到Pi 2x 20集管接口上的“顶部”2x12集管。它使用以下引脚:

  • 5.0V - 连接到显示器背光
  • 3.3V - 连接到显示电源和STEMMA QT / Qwiic连接器
  • GND - 万物之地
  • SDA & SCL - I2C数据。不被按钮或显示器使用
  • GPIO22 - 用于打开和关闭背光。如果你永远不想关掉背光，剪下底部的小跳线，释放GPIO22
  • GPIO23 & GPIO24 - 连接到两个前按钮。这些引脚的10K上拉电压为3.3V，因此当按下按钮时，这些引脚上的电压会很低
  • SCK, MOSI, CE0 & GPIO25 - 这些是显示控制引脚。请注意，即使是SPI引脚，MISO也没有连接，因为您无法从显示器上读取。

未使用:GPIO4、GPIO17、GPIO18、GPIO27 如果您使用的是240x135 1.14英寸(小矩形)Mini Pi TFT，如果您使用堆叠头，您可以将其他硬件连接到这些引脚上的Pi-它将通过Mini PiTFT上的2x12连接器。这在1.3英寸上是行不通的，因为孔不会穿过印刷电路板



1.14寸/1.3寸显示屏内核模块安装：

240x135Mini Pi TFT太小了，这不是小TFT默认支持的分辨率。这项技术将更新你的内核到最新的，如果你升级你的树莓派来代替内核，你需要重新运行指令！如果您从Pi Zero / Pi 2 / Pi 3 / Pi 4更改，您还需要重新运行，因为这些都使用不同的内核类型。

有两种方法可以使用240x135显示屏。

要意识到你一次只能选择做一种方式。如果你选择难的方式，它会安装内核驱动程序，这将阻止你以简单的方式做这件事。

简单的方法是使用“pure Python 3”和Pillow库从Python内部绘制到显示器。这对于显示你自己设计的文本、统计数据、图像等非常有用。如果您想这样做，请跳过此页面，转到Python安装/使用页面 困难的方法是安装一个内核模块来增加对薄膜晶体管显示器的支持，这将使控制台出现在显示器上。这很聪明，因为你可以让任何程序打印文本或绘制到帧缓冲区(或者说，用pygame)，Linux会为你显示它。如果您不需要控制台或直接帧缓冲区访问，请考虑使用“pure Python”技术，因为它不那么微妙。

您不会得到图形用户界面/LXDE显示，这只是为了文本控制台的使用。显示器对LXDE来说太小了


准备树莓派！

在你开始之前，让你的树莓派完全更新和升级是一个好主意。我们假设你烧了一张SD卡，可以登录到控制台安装东西。

运行

 Download: file
Copied!
  1. sudo apt update -y
  2. sudo apt-get update -y
  3. sudo apt-get upgrade -y

完全更新和升级你的树莓派!

在此之后，完成运行 sudo关闭-现在 安全关闭树莓派。拔下电源并连接mini Pi TFT。注意插脚插入到第一个2x12插头中！圆角和安装孔应对齐。


给Pi加电并重新登录。Pi TFT应该点亮，但屏幕上什么也没有。

在终端运行以下内容

 Download: file
Copy Code
  1. cd ~
  2. sudo pip3 install --upgrade adafruit-python-shell click==7.0
  3. sudo apt-get install -y git
  4. git clone https://github.com/adafruit/Raspberry-Pi-Installer-Scripts.git
  5. cd Raspberry-Pi-Installer-Scripts
  6. sudo python3 adafruit-pitft.py --display=st7789_240x135 --rotation=90 --install-type=console


当你被要求重启时，重启！


就这样！现在，您将拥有一个带有控制台显示的mini Pi TFT


如果你曾经得到这样的显示，这意味着你的内核改变了——要么是因为升级/更新，要么是因为你换了树莓派板。解决方法就是简单的重新运行上面的脚本！





Python 安装程序

从240x135迷你pift到320x480，您可以在任何pift上使用这种技术。它没有内核模块支持版本快，但是不管什么内核/操作系统/版本/等等，它都可以工作，所以困难要小得多

连接

使用Python和 Adafruit CircuitPython RGB Display 模块很容易使用显示中断。该模块允许您轻松编写Python代码来控制显示。

由于Pi TFT是预先组装好的，您只需将其放在GPIO引脚上。

因为有几十台你可以使用的电脑/主板，我们将展示树莓派的布线。对于其他平台，请访问Linux上的电路Python指南，了解您的平台是否受支持。

将如下所示的显示器连接到您的树莓派上。

请注意，这不是一个内核驱动程序，让你的控制台出现在薄膜晶体管。但是，当你不能安装一个fbtft驱动程序，想纯粹从‘用户Python’代码使用tft的时候，这个就方便了！

您只能将此技术用于支持硬件SPI的Linux/计算机设备，并且并非所有单板计算机都有SPI设备，因此在继续之前请进行检查
对于1.14 :


对于1.3：

设置

您需要安装Adapour _ Blinka库，该库提供Python中的电路Python支持。这可能还需要在您的平台上启用SPI，并验证您正在运行Python 3。由于每个平台都有一点不同，并且Linux经常变化，请访问Linux上的电路Python指南，准备好您的计算机！

如果您已经安装了内核模块，您将需要在继续之前通过编辑/boot/config.txt文件来删除它。

RGB显示库的Python安装

完成后，从命令行运行以下命令:

  • sudo pip3 install adafruit-circuitpython-rgb-display
  • sudo pip3 install --upgrade --force-reinstall spidev

如果您的默认Python是版本3，您可能需要运行“pip”。请确保您没有试图在Python 2.x上使用电路Python，它不受支持！ 如果它抱怨没有安装pip3，那么首先运行以下命令来安装它:

  • sudo apt-get install python3-pip

DejaVu TTF字体

树莓派通常带有已经安装的DejaVu字体，但如果没有，您可以运行以下命令来安装它:

  • sudo apt-get install ttf-dejavu

Pillow Library

我们还需要PIL，Python图像库，允许图形和使用自定义字体的文本。PIL依赖于几个系统库，因此通过包管理器安装是引入所有内容的最简单方法:

  • sudo apt-get install python3-pil

NumPy Library

最近对RGB_Display库的改进利用了NumPy来提高速度。这可以通过以下命令安装:

  • sudo apt-get install python3-numpy

就是这样。你应该准备好出发了。

快速启动按钮测试 

该按钮测试演示将进行测试，以确保一切设置正确。继续，将文件保存到您主目录中的树莓Pi中，格式为rgb_display_minipitfttest.py.

 Download: Project Zip or rgb_display_minipitfttest.py |  View on Github
Copy Code
  1. import digitalio
  2. import board
  3.  
  4. from adafruit_rgb_display.rgb import color565
  5. import adafruit_rgb_display.st7789 as st7789
  6.  
  7. # Configuration for CS and DC pins for Raspberry Pi
  8. cs_pin = digitalio.DigitalInOut(board.CE0)
  9. dc_pin = digitalio.DigitalInOut(board.D25)
  10. reset_pin = None
  11. BAUDRATE = 64000000  # The pi can be very fast!
  12. # Create the ST7789 display:
  13. display = st7789.ST7789(
  14.     board.SPI(),
  15.     cs=cs_pin,
  16.     dc=dc_pin,
  17.     rst=reset_pin,
  18.     baudrate=BAUDRATE,
  19.     width=135,
  20.     height=240,
  21.     x_offset=53,
  22.     y_offset=40,
  23. )
  24.  
  25. backlight = digitalio.DigitalInOut(board.D22)
  26. backlight.switch_to_output()
  27. backlight.value = True
  28. buttonA = digitalio.DigitalInOut(board.D23)
  29. buttonB = digitalio.DigitalInOut(board.D24)
  30. buttonA.switch_to_input()
  31. buttonB.switch_to_input()
  32.  
  33. # Main loop:
  34. while True:
  35.     if buttonA.value and buttonB.value:
  36.         backlight.value = False  # turn off backlight
  37.     else:
  38.         backlight.value = True  # turn on backlight
  39.     if buttonB.value and not buttonA.value:  # just button A pressed
  40.         display.fill(color565(255, 0, 0))  # red
  41.     if buttonA.value and not buttonB.value:  # just button B pressed
  42.         display.fill(color565(0, 0, 255))  # blue
  43.     if not buttonA.value and not buttonB.value:  # none pressed
  44.         display.fill(color565(0, 255, 0))  # green

继续使用以下命令运行它:

sudo python3 rgb_display_minipitfttest.py

一旦它运行，按下按钮。顶部的按钮应该使显示屏亮起红色，底部的蓝色，同时按下这两个按钮应该使其变为绿色。

Python统计示例
如果您之前已经安装了pitft easy安装程序的内核驱动程序，那么为了运行这个示例，您需要首先删除它

我们还可以显示一些关于您的Pi的统计数据，如IP地址、资源使用情况，甚至CPU温度。首先将下面的代码保存在你的树莓皮的主目录中。

 Download: Project Zip or rgb_display_minipitftstats.py |  View on Github
Copy Code
  1. # -*- coding: utf-8 -*-
  2.  
  3. import time
  4. import subprocess
  5. import digitalio
  6. import board
  7. from PIL import Image, ImageDraw, ImageFont
  8. import adafruit_rgb_display.st7789 as st7789
  9.  
  10.  
  11. # Configuration for CS and DC pins (these are FeatherWing defaults on M0/M4):
  12. cs_pin = digitalio.DigitalInOut(board.CE0)
  13. dc_pin = digitalio.DigitalInOut(board.D25)
  14. reset_pin = None
  15.  
  16. # Config for display baudrate (default max is 24mhz):
  17. BAUDRATE = 64000000
  18.  
  19. # Setup SPI bus using hardware SPI:
  20. spi = board.SPI()
  21.  
  22. # Create the ST7789 display:
  23. disp = st7789.ST7789(
  24.     spi,
  25.     cs=cs_pin,
  26.     dc=dc_pin,
  27.     rst=reset_pin,
  28.     baudrate=BAUDRATE,
  29.     width=135,
  30.     height=240,
  31.     x_offset=53,
  32.     y_offset=40,
  33. )
  34.  
  35. # Create blank image for drawing.
  36. # Make sure to create image with mode 'RGB' for full color.
  37. height = disp.width  # we swap height/width to rotate it to landscape!
  38. width = disp.height
  39. image = Image.new("RGB", (width, height))
  40. rotation = 90
  41.  
  42. # Get drawing object to draw on image.
  43. draw = ImageDraw.Draw(image)
  44.  
  45. # Draw a black filled box to clear the image.
  46. draw.rectangle((0, 0, width, height), outline=0, fill=(0, 0, 0))
  47. disp.image(image, rotation)
  48. # Draw some shapes.
  49. # First define some constants to allow easy resizing of shapes.
  50. padding = -2
  51. top = padding
  52. bottom = height - padding
  53. # Move left to right keeping track of the current x position for drawing shapes.
  54. x = 0
  55.  
  56.  
  57. # Alternatively load a TTF font.  Make sure the .ttf font file is in the
  58. # same directory as the python script!
  59. # Some other nice fonts to try: http://www.dafont.com/bitmap.php
  60. font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", 24)
  61.  
  62. # Turn on the backlight
  63. backlight = digitalio.DigitalInOut(board.D22)
  64. backlight.switch_to_output()
  65. backlight.value = True
  66.  
  67. while True:
  68.     # Draw a black filled box to clear the image.
  69.     draw.rectangle((0, 0, width, height), outline=0, fill=0)
  70.  
  71.     # Shell scripts for system monitoring from here:
  72.     # https://unix.stackexchange.com/questions/119126/command-to-display-memory-usage-disk-usage-and-cpu-load
  73.     cmd = "hostname -I | cut -d' ' -f1"
  74.     IP = "IP: " + subprocess.check_output(cmd, shell=True).decode("utf-8")
  75.     cmd = "top -bn1 | grep load | awk '{printf \"CPU Load: %.2f\", $(NF-2)}'"
  76.     CPU = subprocess.check_output(cmd, shell=True).decode("utf-8")
  77.     cmd = "free -m | awk 'NR==2{printf \"Mem: %s/%s MB  %.2f%%\", $3,$2,$3*100/$2 }'"
  78.     MemUsage = subprocess.check_output(cmd, shell=True).decode("utf-8")
  79.     cmd = 'df -h | awk \'$NF=="/"{printf "Disk: %d/%d GB  %s", $3,$2,$5}\''
  80.     Disk = subprocess.check_output(cmd, shell=True).decode("utf-8")
  81.     cmd = "cat /sys/class/thermal/thermal_zone0/temp |  awk '{printf \"CPU Temp: %.1f C\", $(NF-0) / 1000}'"  # pylint: disable=line-too-long
  82.     Temp = subprocess.check_output(cmd, shell=True).decode("utf-8")
  83.  
  84.     # Write four lines of text.
  85.     y = top
  86.     draw.text((x, y), IP, font=font, fill="#FFFFFF")
  87.     y += font.getsize(IP)[1]
  88.     draw.text((x, y), CPU, font=font, fill="#FFFF00")
  89.     y += font.getsize(CPU)[1]
  90.     draw.text((x, y), MemUsage, font=font, fill="#00FF00")
  91.     y += font.getsize(MemUsage)[1]
  92.     draw.text((x, y), Disk, font=font, fill="#0000FF")
  93.     y += font.getsize(Disk)[1]
  94.     draw.text((x, y), Temp, font=font, fill="#FF00FF")
  95.  
  96.     # Display image.
  97.     disp.image(image, rotation)
  98.     time.sleep(0.1)

通过键入以下内容继续运行脚本:

python3 stats.py

它应该显示一些系统信息。



1.3英寸显示屏的改进

为了让stats.py示例在1.3英寸薄膜晶体管显示器上正确显示，您需要根据显示器的不同几何形状进行一些更改。您需要调整的参数是高度、x_offset、y_offset和旋转。

  • height = 240
  • x_offset = 0
  • y_offset = 80
  • rotation = 180

替换它们最简单的方法可能是复制下面的代码块，并在上面的代码中替换它。

 Download: file
Copy Code
  1. # Create the ST7789 display:
  2. disp = st7789.ST7789(
  3.     spi,
  4.     cs=cs_pin,
  5.     dc=dc_pin,
  6.     rst=reset_pin,
  7.     baudrate=BAUDRATE,
  8.     width=240,
  9.     height=240,
  10.     x_offset=0,
  11.     y_offset=80,
  12. )
  13.  
  14. # Create blank image for drawing.
  15. # Make sure to create image with mode 'RGB' for full color.
  16. height = disp.width  # we swap height/width to rotate it to landscape!
  17. width = disp.height
  18. image = Image.new("RGB", (width, height))
  19. rotation = 180

启动时运行统计

你可以很容易地做到这一点，所以这个方便的程序运行，每次你启动你的树莓派。 最快/最简单的方法是放入/etc/rc.local 运行sudo nano /etc/rc.local并添加行

sudo python3 /home/pi/stats.py &

就在0号出口前 然后保存并退出。重启以验证屏幕在启动时出现！


要了解更多高级用法，请查看我们的linux系统服务指南

启动时统计故障排除

为了在树莓派上正常安装Blinka，我们让您安装没有sudo关键字的东西，这将在本地安装库。但是，要让脚本在启动时运行，您需要在更大的系统范围内提供库。您可以通过运行以下命令来测试这一点，并查看统计数据是否出现:

sudo python3 /home/pi/stats.py

如果您有任何错误，大多数都可以通过运行以下命令来修复:

sudo pip3 install --upgrade adafruit-blinka adafruit-circuitpython-rgb-display spidev

一旦你能让它启动，继续按下控制+C并重新启动系统。现在应该上来了。

有时Pi启动太快，所以您可能还需要在/etc/rc.local.中添加的命令之前添加 sleep 10

Python 用法

如果您之前已经安装了带有PiTFT简易安装程序的内核驱动程序，您将需要首先删除它才能运行此示例。
现在您已经设置好了一切，我们将查看三个不同的示例。首先，我们将看一下自动缩放和裁剪图像，然后将其居中显示。

打开背光

在一些显示器上，背光由单独的引脚控制，例如带操纵杆的1.3英寸薄膜晶体管阀盖。在这种显示器上，运行下面的代码可能会导致显示器保持黑色。要打开背光，您需要添加一小段代码。如果您的背光引脚编号不同，请务必在代码中进行更改:

 Download: file
Copy Code
  1. # Turn on the Backlight
  2. backlight = DigitalInOut(board.D26)
  3. backlight.switch_to_output()
  4. backlight.value = True

显示图像

下面是这个例子的完整代码。我们将一节一节地讲解，以帮助您更好地理解正在发生的事情。先来下载一张Blinka的图片。该图像有足够的边框，可以根据不同的显示大小和比例调整大小和裁剪，以保持良好的外观。



请确保将其保存为blinka.jpg，并将其放在与脚本相同的文件夹中。下面是我们将要加载到树莓派上的代码。我们将讨论有趣的部分。

 Download: Project Zip or rgb_display_pillow_image.py |  View on Github
Copy Code
  1. """
  2. Be sure to check the learn guides for more usage information.
  3.  
  4. This example is for use on (Linux) computers that are using CPython with
  5. Adafruit Blinka to support CircuitPython libraries. CircuitPython does
  6. not support PIL/pillow (python imaging library)!
  7.  
  8. Author(s): Melissa LeBlanc-Williams for Adafruit Industries
  9. """
  10.  
  11. import digitalio
  12. import board
  13. from PIL import Image, ImageDraw
  14. import adafruit_rgb_display.ili9341 as ili9341
  15. import adafruit_rgb_display.st7789 as st7789  # pylint: disable=unused-import
  16. import adafruit_rgb_display.hx8357 as hx8357  # pylint: disable=unused-import
  17. import adafruit_rgb_display.st7735 as st7735  # pylint: disable=unused-import
  18. import adafruit_rgb_display.ssd1351 as ssd1351  # pylint: disable=unused-import
  19. import adafruit_rgb_display.ssd1331 as ssd1331  # pylint: disable=unused-import
  20.  
  21. # Configuration for CS and DC pins (these are PiTFT defaults):
  22. cs_pin = digitalio.DigitalInOut(board.CE0)
  23. dc_pin = digitalio.DigitalInOut(board.D25)
  24. reset_pin = digitalio.DigitalInOut(board.D24)
  25.  
  26. # Config for display baudrate (default max is 24mhz):
  27. BAUDRATE = 24000000
  28.  
  29. # Setup SPI bus using hardware SPI:
  30. spi = board.SPI()
  31.  
  32. # pylint: disable=line-too-long
  33. # Create the display:
  34. # disp = st7789.ST7789(spi, rotation=90,                            # 2.0" ST7789
  35. # disp = st7789.ST7789(spi, height=240, y_offset=80, rotation=180,  # 1.3", 1.54" ST7789
  36. # disp = st7789.ST7789(spi, rotation=90, width=135, height=240, x_offset=53, y_offset=40, # 1.14" ST7789
  37. # disp = hx8357.HX8357(spi, rotation=180,                           # 3.5" HX8357
  38. # disp = st7735.ST7735R(spi, rotation=90,                           # 1.8" ST7735R
  39. # disp = st7735.ST7735R(spi, rotation=270, height=128, x_offset=2, y_offset=3,   # 1.44" ST7735R
  40. # disp = st7735.ST7735R(spi, rotation=90, bgr=True,                 # 0.96" MiniTFT ST7735R
  41. # disp = ssd1351.SSD1351(spi, rotation=180,                         # 1.5" SSD1351
  42. # disp = ssd1351.SSD1351(spi, height=96, y_offset=32, rotation=180, # 1.27" SSD1351
  43. # disp = ssd1331.SSD1331(spi, rotation=180,                         # 0.96" SSD1331
  44. disp = ili9341.ILI9341(
  45.     spi,
  46.     rotation=90,  # 2.2", 2.4", 2.8", 3.2" ILI9341
  47.     cs=cs_pin,
  48.     dc=dc_pin,
  49.     rst=reset_pin,
  50.     baudrate=BAUDRATE,
  51. )
  52. # pylint: enable=line-too-long
  53.  
  54. # Create blank image for drawing.
  55. # Make sure to create image with mode 'RGB' for full color.
  56. if disp.rotation % 180 == 90:
  57.     height = disp.width  # we swap height/width to rotate it to landscape!
  58.     width = disp.height
  59. else:
  60.     width = disp.width  # we swap height/width to rotate it to landscape!
  61.     height = disp.height
  62. image = Image.new("RGB", (width, height))
  63.  
  64. # Get drawing object to draw on image.
  65. draw = ImageDraw.Draw(image)
  66.  
  67. # Draw a black filled box to clear the image.
  68. draw.rectangle((0, 0, width, height), outline=0, fill=(0, 0, 0))
  69. disp.image(image)
  70.  
  71. image = Image.open("blinka.jpg")
  72.  
  73. # Scale the image to the smaller screen dimension
  74. image_ratio = image.width / image.height
  75. screen_ratio = width / height
  76. if screen_ratio < image_ratio:
  77.     scaled_width = image.width * height // image.height
  78.     scaled_height = height
  79. else:
  80.     scaled_width = width
  81.     scaled_height = image.height * width // image.width
  82. image = image.resize((scaled_width, scaled_height), Image.BICUBIC)
  83.  
  84. # Crop and center the image
  85. x = scaled_width // 2 - width // 2
  86. y = scaled_height // 2 - height // 2
  87. image = image.crop((x, y, x + width, y + height))
  88.  
  89. # Display image.
  90. disp.image(image)

所以我们从我们通常的进口产品开始，包括几个Pillow模块和显示驱动程序。然后在这里定义几个引脚。我们选择这些的原因是，如果您选择这样做，它们允许您将相同的代码用于PiTFT

 Download: file
Copy Code
  1. import digitalio
  2. import board
  3. from PIL import Image, ImageDraw
  4. import adafruit_rgb_display.ili9341 as ili9341
  5. import adafruit_rgb_display.st7789 as st7789
  6. import adafruit_rgb_display.hx8357 as hx8357
  7. import adafruit_rgb_display.st7735 as st7735
  8. import adafruit_rgb_display.ssd1351 as ssd1351
  9. import adafruit_rgb_display.ssd1331 as ssd1331
  10.  
  11. # Configuration for CS and DC pins
  12. cs_pin = digitalio.DigitalInOut(board.CE0)
  13. dc_pin = digitalio.DigitalInOut(board.D25)
  14. reset_pin = digitalio.DigitalInOut(board.D24)

接下来，我们将设置默认的24 MHz波特率，以便它可以在各种显示器上工作。唯一的例外是SSD1351驱动程序，它会自动将其限制在16兆赫，即使你通过24兆赫。我们将设置SPI总线，然后初始化显示器。

我们想让这些例子在尽可能多的显示器上工作，只需要很少的改动。默认情况下，选择ILI9341显示。对于其他显示器，请继续注释以下列内容开头的行:

disp = ili9341.ILI9341(spi,

并取消适合您的显示的行的注释。显示器具有旋转属性，因此可以只在一个位置进行设置。

 Download: file
Copy Code
  1. # Config for display baudrate (default max is 24mhz):
  2. BAUDRATE = 24000000
  3.  
  4. # Setup SPI bus using hardware SPI:
  5. spi = board.SPI()
  6.  
  7. #disp = st7789.ST7789(spi, rotation=90,                            # 2.0" ST7789
  8. #disp = st7789.ST7789(spi, height=240, y_offset=80, rotation=180,  # 1.3", 1.54" ST7789
  9. #disp = st7789.ST7789(spi, rotation=90, width=135, height=240, x_offset=53, y_offset=40, # 1.14" ST7789
  10. #disp = hx8357.HX8357(spi, rotation=180,                           # 3.5" HX8357
  11. #disp = st7735.ST7735R(spi, rotation=90,                           # 1.8" ST7735R
  12. #disp = st7735.ST7735R(spi, rotation=270, height=128, x_offset=2, y_offset=3,   # 1.44" ST7735R
  13. #disp = st7735.ST7735R(spi, rotation=90, bgr=True,                 # 0.96" MiniTFT ST7735R
  14. #disp = ssd1351.SSD1351(spi, rotation=180,                         # 1.5" SSD1351
  15. #disp = ssd1351.SSD1351(spi, height=96, y_offset=32, rotation=180, # 1.27" SSD1351
  16. #disp = ssd1331.SSD1331(spi, rotation=180,                         # 0.96" SSD1331
  17. disp = ili9341.ILI9341(spi, rotation=90,                           # 2.2", 2.4", 2.8", 3.2" ILI9341
  18.                        cs=cs_pin, dc=dc_pin, rst=reset_pin, baudrate=BAUDRATE)

接下来，我们读取显示器的当前旋转设置，如果是90度或270度，我们需要交换宽度和高度进行计算，否则我们只需获取宽度和高度。我们将用我们的尺寸创建一个图像，并使用它来创建一个绘图对象。绘图对象将拥有我们所有的绘图功能。

 Download: file
Copy Code
  1. # Create blank image for drawing.
  2. # Make sure to create image with mode 'RGB' for full color.
  3. if disp.rotation % 180 == 90:
  4.     height = disp.width   # we swap height/width to rotate it to landscape!
  5.     width = disp.height
  6. else:
  7.     width = disp.width   # we swap height/width to rotate it to landscape!
  8.     height = disp.height
  9. image = Image.new('RGB', (width, height))
  10.  
  11. # Get drawing object to draw on image.
  12. draw = ImageDraw.Draw(image)

接下来，我们通过画一个黑色矩形来清除屏幕上的任何东西。这并不是绝对必要的，因为它将被图像覆盖，但它在某种程度上设置了舞台。

 Download: file
Copy Code
  1. # Draw a black filled box to clear the image.
  2. draw.rectangle((0, 0, width, height), outline=0, fill=(0, 0, 0))
  3. disp.image(image)

接下来我们打开Blinka图像，我们将它命名为blinka.jpg，假设它位于您运行脚本的同一个目录中。如果与您的配置不匹配，请随意更改。

 Download: file
Copy Code
  1. image = Image.open("blinka.jpg")

这就是它开始变得有趣的地方。我们希望缩放图像，使其与显示器的宽度或高度相匹配，具体取决于哪个更小，以便在裁剪图像时可以剪掉一些图像。所以我们从计算显示器和图像的宽高比开始。如果高度更接近尺寸，我们希望图像高度与显示器高度匹配，并让它比显示器宽一点。否则，我们想反其道而行之。 一旦我们想出如何缩放它，我们传递新的维度，并使用Bicubic缩放方法，我们重新分配新缩放的图像回image。Pillow有相当多不同的方法可供选择，但Bicubic做得很好，而且相当快。

 Download: file
Copy Code
  1. # Scale the image to the smaller screen dimension
  2. image_ratio = image.width / image.height
  3. screen_ratio = width / height
  4. if screen_ratio < image_ratio:
  5.     scaled_width = image.width * height // image.height
  6.     scaled_height = height
  7. else:
  8.     scaled_width = width
  9.     scaled_height = image.height * width // image.width
  10. image = image.resize((scaled_width, scaled_height), Image.BICUBIC)

接下来，我们想弄清楚图像的x和y起始点，我们想从这两个点开始裁剪图像，使其最终居中。我们通过使用标准的居中功能来做到这一点，这基本上是要求显示器中心和图像中心的差异。就像缩放一样，我们用新裁剪的图像替换图像变量。

 Download: file
Copy Code
  1. # Crop and center the image
  2. x = scaled_width // 2 - width // 2
  3. y = scaled_height // 2 - height // 2
  4. image = image.crop((x, y, x + width, y + height))

最后，我们把我们的图像显示出来。此时，图像应该在显示器上具有完全相同的尺寸，并完全填满它。

 Download: file
Copy Code
  1. disp.image(image)



绘制形状和文本

在下一个例子中，我们将看一下绘制形状和文本。这与displayio示例非常相似，但它使用了Pillow。这是代码。

 Download: Project Zip or rgb_display_pillow_demo.py |  View on Github
Copy Code
  1. """
  2. This demo will draw a few rectangles onto the screen along with some text
  3. on top of that.
  4.  
  5. This example is for use on (Linux) computers that are using CPython with
  6. Adafruit Blinka to support CircuitPython libraries. CircuitPython does
  7. not support PIL/pillow (python imaging library)!
  8.  
  9. Author(s): Melissa LeBlanc-Williams for Adafruit Industries
  10. """
  11.  
  12. import digitalio
  13. import board
  14. from PIL import Image, ImageDraw, ImageFont
  15. import adafruit_rgb_display.ili9341 as ili9341
  16. import adafruit_rgb_display.st7789 as st7789  # pylint: disable=unused-import
  17. import adafruit_rgb_display.hx8357 as hx8357  # pylint: disable=unused-import
  18. import adafruit_rgb_display.st7735 as st7735  # pylint: disable=unused-import
  19. import adafruit_rgb_display.ssd1351 as ssd1351  # pylint: disable=unused-import
  20. import adafruit_rgb_display.ssd1331 as ssd1331  # pylint: disable=unused-import
  21.  
  22. # First define some constants to allow easy resizing of shapes.
  23. BORDER = 20
  24. FONTSIZE = 24
  25.  
  26. # Configuration for CS and DC pins (these are PiTFT defaults):
  27. cs_pin = digitalio.DigitalInOut(board.CE0)
  28. dc_pin = digitalio.DigitalInOut(board.D25)
  29. reset_pin = digitalio.DigitalInOut(board.D24)
  30.  
  31. # Config for display baudrate (default max is 24mhz):
  32. BAUDRATE = 24000000
  33.  
  34. # Setup SPI bus using hardware SPI:
  35. spi = board.SPI()
  36.  
  37. # pylint: disable=line-too-long
  38. # Create the display:
  39. # disp = st7789.ST7789(spi, rotation=90,                            # 2.0" ST7789
  40. # disp = st7789.ST7789(spi, height=240, y_offset=80, rotation=180,  # 1.3", 1.54" ST7789
  41. # disp = st7789.ST7789(spi, rotation=90, width=135, height=240, x_offset=53, y_offset=40, # 1.14" ST7789
  42. # disp = hx8357.HX8357(spi, rotation=180,                           # 3.5" HX8357
  43. # disp = st7735.ST7735R(spi, rotation=90,                           # 1.8" ST7735R
  44. # disp = st7735.ST7735R(spi, rotation=270, height=128, x_offset=2, y_offset=3,   # 1.44" ST7735R
  45. # disp = st7735.ST7735R(spi, rotation=90, bgr=True,                 # 0.96" MiniTFT ST7735R
  46. # disp = ssd1351.SSD1351(spi, rotation=180,                         # 1.5" SSD1351
  47. # disp = ssd1351.SSD1351(spi, height=96, y_offset=32, rotation=180, # 1.27" SSD1351
  48. # disp = ssd1331.SSD1331(spi, rotation=180,                         # 0.96" SSD1331
  49. disp = ili9341.ILI9341(
  50.     spi,
  51.     rotation=90,  # 2.2", 2.4", 2.8", 3.2" ILI9341
  52.     cs=cs_pin,
  53.     dc=dc_pin,
  54.     rst=reset_pin,
  55.     baudrate=BAUDRATE,
  56. )
  57. # pylint: enable=line-too-long
  58.  
  59. # Create blank image for drawing.
  60. # Make sure to create image with mode 'RGB' for full color.
  61. if disp.rotation % 180 == 90:
  62.     height = disp.width  # we swap height/width to rotate it to landscape!
  63.     width = disp.height
  64. else:
  65.     width = disp.width  # we swap height/width to rotate it to landscape!
  66.     height = disp.height
  67.  
  68. image = Image.new("RGB", (width, height))
  69.  
  70. # Get drawing object to draw on image.
  71. draw = ImageDraw.Draw(image)
  72.  
  73. # Draw a green filled box as the background
  74. draw.rectangle((0, 0, width, height), fill=(0, 255, 0))
  75. disp.image(image)
  76.  
  77. # Draw a smaller inner purple rectangle
  78. draw.rectangle(
  79.     (BORDER, BORDER, width - BORDER - 1, height - BORDER - 1), fill=(170, 0, 136)
  80. )
  81.  
  82. # Load a TTF Font
  83. font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", FONTSIZE)
  84.  
  85. # Draw Some Text
  86. text = "Hello World!"
  87. (font_width, font_height) = font.getsize(text)
  88. draw.text(
  89.     (width // 2 - font_width // 2, height // 2 - font_height // 2),
  90.     text,
  91.     font=font,
  92.     fill=(255, 255, 0),
  93. )
  94.  
  95. # Display image.
  96. disp.image(image)

就像上一个例子一样，我们将进行导入，但这次我们包括了图像字体枕头模块，因为我们这次将绘制一些文本。

 Download: file
Copy Code
  1. import digitalio
  2. import board
  3. from PIL import Image, ImageDraw, ImageFont
  4. import adafruit_rgb_display.ili9341 as ili9341

接下来，我们将定义一些参数，我们可以为各种显示进行调整。BORDER将是显示器边缘和内部紫色矩形之间绿色边框的像素大小。字体大小将是字体的大小，以磅为单位，以便我们可以轻松地为不同的显示进行调整。

 Download: file
Copy Code
  1. BORDER = 20
  2. FONTSIZE = 24

接下来，就像前面的例子一样，我们将设置显示，设置旋转，并创建一个绘图对象。如果您使用的显示器与ILI9341不同，请按照前面的示例调整您的初始化器。之后，我们将用占据整个屏幕的绿色矩形来设置背景。为了得到绿色，我们传入一个元组，元组中有红色、绿色和蓝色的颜色值，顺序可以是 0 到 255之间的任何整数。

 Download: file
Copy Code
  1. draw.rectangle((0, 0, width, height), fill=(0, 255, 0))
  2. disp.image(image)

接下来我们将画一个内部的紫色矩形。这与displayio quickstart中的示例颜色值相同，只是十六进制值已转换为十进制值。我们使用BORDER参数来计算我们想要绘制矩形的大小和位置。

 Download: file
Copy Code
  1. draw.rectangle((BORDER, BORDER, width - BORDER - 1, height - BORDER - 1),
  2.                fill=(170, 0, 136))

接下来我们将加载一个TTF字体。DejaVuSans.ttf字体应该预加载到您的Pi代码中的位置。我们还利用了前面讨论过的font size参数。

 Download: file
Copy Code
  1. # Load a TTF Font
  2. font = ImageFont.truetype('/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf', FONTSIZE)

现在我们将文本Hello World绘制到显示屏的中心。您可能会认识到居中计算与我们在前面的示例中用于居中裁剪图像的计算是相同的。在这个例子中，我们使用字体对象的 getsize() 函数获得字体大小值

 Download: file
Copy Code
  1. # Draw Some Text
  2. text = "Hello World!"
  3. (font_width, font_height) = font.getsize(text)
  4. draw.text((width//2 - font_width//2, height//2 - font_height//2),
  5.           text, font=font, fill=(255, 255, 0))

最后，就像以前一样，我们显示图像。

 Download: file
Copy Code
  1. disp.image(image)



显示系统信息

在最后这个例子中，我们将看一下获取系统信息并显示它。这对系统监控非常方便。以下是该示例的代码:

 Download: Project Zip or rgb_display_pillow_stats.py |  View on Github
Copy Code
  1. """
  2. This will show some Linux Statistics on the attached display. Be sure to adjust
  3. to the display you have connected. Be sure to check the learn guides for more
  4. usage information.
  5.  
  6. This example is for use on (Linux) computers that are using CPython with
  7. Adafruit Blinka to support CircuitPython libraries. CircuitPython does
  8. not support PIL/pillow (python imaging library)!
  9. """
  10.  
  11. import time
  12. import subprocess
  13. import digitalio
  14. import board
  15. from PIL import Image, ImageDraw, ImageFont
  16. import adafruit_rgb_display.ili9341 as ili9341
  17. import adafruit_rgb_display.st7789 as st7789  # pylint: disable=unused-import
  18. import adafruit_rgb_display.hx8357 as hx8357  # pylint: disable=unused-import
  19. import adafruit_rgb_display.st7735 as st7735  # pylint: disable=unused-import
  20. import adafruit_rgb_display.ssd1351 as ssd1351  # pylint: disable=unused-import
  21. import adafruit_rgb_display.ssd1331 as ssd1331  # pylint: disable=unused-import
  22.  
  23. # Configuration for CS and DC pins (these are PiTFT defaults):
  24. cs_pin = digitalio.DigitalInOut(board.CE0)
  25. dc_pin = digitalio.DigitalInOut(board.D25)
  26. reset_pin = digitalio.DigitalInOut(board.D24)
  27.  
  28. # Config for display baudrate (default max is 24mhz):
  29. BAUDRATE = 24000000
  30.  
  31. # Setup SPI bus using hardware SPI:
  32. spi = board.SPI()
  33.  
  34. # pylint: disable=line-too-long
  35. # Create the display:
  36. # disp = st7789.ST7789(spi, rotation=90,                            # 2.0" ST7789
  37. # disp = st7789.ST7789(spi, height=240, y_offset=80, rotation=180,  # 1.3", 1.54" ST7789
  38. # disp = st7789.ST7789(spi, rotation=90, width=135, height=240, x_offset=53, y_offset=40, # 1.14" ST7789
  39. # disp = hx8357.HX8357(spi, rotation=180,                           # 3.5" HX8357
  40. # disp = st7735.ST7735R(spi, rotation=90,                           # 1.8" ST7735R
  41. # disp = st7735.ST7735R(spi, rotation=270, height=128, x_offset=2, y_offset=3,   # 1.44" ST7735R
  42. # disp = st7735.ST7735R(spi, rotation=90, bgr=True,                 # 0.96" MiniTFT ST7735R
  43. # disp = ssd1351.SSD1351(spi, rotation=180,                         # 1.5" SSD1351
  44. # disp = ssd1351.SSD1351(spi, height=96, y_offset=32, rotation=180, # 1.27" SSD1351
  45. # disp = ssd1331.SSD1331(spi, rotation=180,                         # 0.96" SSD1331
  46. disp = ili9341.ILI9341(
  47.     spi,
  48.     rotation=90,  # 2.2", 2.4", 2.8", 3.2" ILI9341
  49.     cs=cs_pin,
  50.     dc=dc_pin,
  51.     rst=reset_pin,
  52.     baudrate=BAUDRATE,
  53. )
  54. # pylint: enable=line-too-long
  55.  
  56. # Create blank image for drawing.
  57. # Make sure to create image with mode 'RGB' for full color.
  58. if disp.rotation % 180 == 90:
  59.     height = disp.width  # we swap height/width to rotate it to landscape!
  60.     width = disp.height
  61. else:
  62.     width = disp.width  # we swap height/width to rotate it to landscape!
  63.     height = disp.height
  64.  
  65. image = Image.new("RGB", (width, height))
  66.  
  67. # Get drawing object to draw on image.
  68. draw = ImageDraw.Draw(image)
  69.  
  70. # Draw a black filled box to clear the image.
  71. draw.rectangle((0, 0, width, height), outline=0, fill=(0, 0, 0))
  72. disp.image(image)
  73.  
  74. # First define some constants to allow easy positioning of text.
  75. padding = -2
  76. x = 0
  77.  
  78. # Load a TTF font.  Make sure the .ttf font file is in the
  79. # same directory as the python script!
  80. # Some other nice fonts to try: http://www.dafont.com/bitmap.php
  81. font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", 24)
  82.  
  83. while True:
  84.     # Draw a black filled box to clear the image.
  85.     draw.rectangle((0, 0, width, height), outline=0, fill=0)
  86.  
  87.     # Shell scripts for system monitoring from here:
  88.     # https://unix.stackexchange.com/questions/119126/command-to-display-memory-usage-disk-usage-and-cpu-load
  89.     cmd = "hostname -I | cut -d' ' -f1"
  90.     IP = "IP: " + subprocess.check_output(cmd, shell=True).decode("utf-8")
  91.     cmd = "top -bn1 | grep load | awk '{printf \"CPU Load: %.2f\", $(NF-2)}'"
  92.     CPU = subprocess.check_output(cmd, shell=True).decode("utf-8")
  93.     cmd = "free -m | awk 'NR==2{printf \"Mem: %s/%s MB  %.2f%%\", $3,$2,$3*100/$2 }'"
  94.     MemUsage = subprocess.check_output(cmd, shell=True).decode("utf-8")
  95.     cmd = 'df -h | awk \'$NF=="/"{printf "Disk: %d/%d GB  %s", $3,$2,$5}\''
  96.     Disk = subprocess.check_output(cmd, shell=True).decode("utf-8")
  97.     cmd = "cat /sys/class/thermal/thermal_zone0/temp |  awk '{printf \"CPU Temp: %.1f C\", $(NF-0) / 1000}'"  # pylint: disable=line-too-long
  98.     Temp = subprocess.check_output(cmd, shell=True).decode("utf-8")
  99.  
  100.     # Write four lines of text.
  101.     y = padding
  102.     draw.text((x, y), IP, font=font, fill="#FFFFFF")
  103.     y += font.getsize(IP)[1]
  104.     draw.text((x, y), CPU, font=font, fill="#FFFF00")
  105.     y += font.getsize(CPU)[1]
  106.     draw.text((x, y), MemUsage, font=font, fill="#00FF00")
  107.     y += font.getsize(MemUsage)[1]
  108.     draw.text((x, y), Disk, font=font, fill="#0000FF")
  109.     y += font.getsize(Disk)[1]
  110.     draw.text((x, y), Temp, font=font, fill="#FF00FF")
  111.  
  112.     # Display image.
  113.     disp.image(image)
  114.     time.sleep(0.1)

就像上一个例子一样，我们将从导入我们导入的所有内容开始，但是我们将再添加两个导入。第一个是时间，这样我们可以增加一个小的延迟，另一个是子过程，这样我们就可以收集一些系统信息。

 Download: file
Copy Code
  1. import time
  2. import subprocess
  3. import digitalio
  4. import board
  5. from PIL import Image, ImageDraw, ImageFont
  6. import adafruit_rgb_display.ili9341 as ili9341

接下来，就像前两个例子一样，我们将设置显示，设置旋转，并创建一个绘图对象。如果您使用的显示器与ILI9341不同，请按照前面的示例调整您的初始化器。 就像第一个例子一样，我们要画一个黑色的矩形来填满屏幕。之后，我们将设置几个常量来帮助定位文本。第一个是填充，这将是最上面文本的Y位置，另一个是X，这是X位置，代表文本的左侧。

 Download: file
Copy Code
  1. # First define some constants to allow easy positioning of text.
  2. padding = -2
  3. x = 0

接下来，我们像第二个例子一样加载一个字体。

 Download: file
Copy Code
  1. font = ImageFont.truetype('/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf', 24)

 现在我们进入主循环，通过使用while True:，它将循环直到在键盘上按下Control+C。这里的第一项，我们清空了屏幕，但是请注意，我们没有像以前那样给它一个元组，我们只需传递0，它就会变成黑色。

 Download: file
Copy Code
  1. draw.rectangle((0, 0, width, height), outline=0, fill=0)

接下来，我们使用子过程函数运行一些脚本，这些函数被操作系统调用以获取信息。每个命令中的都通过awk传递，以便更好地格式化显示。通过让操作系统来完成这项工作，我们不必这样做。这些小脚本来自 https://unix.stackexchange.com/questions/119126/command-to-display-memory-usage-disk-usage-and-cpu-load

 Download: file
Copy Code
  1. cmd = "hostname -I | cut -d\' \' -f1"
  2. IP = "IP: "+subprocess.check_output(cmd, shell=True).decode("utf-8")
  3. cmd = "top -bn1 | grep load | awk '{printf \"CPU Load: %.2f\", $(NF-2)}'"
  4. CPU = subprocess.check_output(cmd, shell=True).decode("utf-8")
  5. cmd = "free -m | awk 'NR==2{printf \"Mem: %s/%s MB  %.2f%%\", $3,$2,$3*100/$2 }'"
  6. MemUsage = subprocess.check_output(cmd, shell=True).decode("utf-8")
  7. cmd = "df -h | awk '$NF==\"/\"{printf \"Disk: %d/%d GB  %s\", $3,$2,$5}'"
  8. Disk = subprocess.check_output(cmd, shell=True).decode("utf-8")
  9. cmd = "cat /sys/class/thermal/thermal_zone0/temp |  awk \'{printf \"CPU Temp: %.1f C\", $(NF-0) / 1000}\'" # pylint: disable=line-too-long
  10. Temp = subprocess.check_output(cmd, shell=True).decode("utf-8")

现在我们为用户显示信息。这里我们使用另一种方式来传递颜色信息。我们可以使用磅符号将它作为一个颜色字符串传递，就像我们在HTML中所做的那样。对于每一行，我们使用getsize()获取该行的高度，并将指针向下移动那么多。

 Download: file
Copy Code
  1. y = padding
  2. draw.text((x, y), IP, font=font, fill="#FFFFFF")
  3. y += font.getsize(IP)[1]
  4. draw.text((x, y), CPU, font=font, fill="#FFFF00")
  5. y += font.getsize(CPU)[1]
  6. draw.text((x, y), MemUsage, font=font, fill="#00FF00")
  7. y += font.getsize(MemUsage)[1]
  8. draw.text((x, y), Disk, font=font, fill="#0000FF")
  9. y += font.getsize(Disk)[1]
  10. draw.text((x, y), Temp, font=font, fill="#FF00FF")

最后，我们使用disp.image()将所有信息写入显示器。既然是循环，我们就告诉Python睡眠0.1秒，这样CPU永远不会太忙。

 Download: file
Copy Code
  1. disp.image(image)
  2. time.sleep(.1)


下载
文件：

图解


1.3英寸微型薄膜晶体管的原理图和工厂图


价格：
¥60
型号：
RPI-1.14inch-LCD
制造商：
斑梨电子
SKU：
0105220

树莓派1.14寸LCD IPS高清显示屏Mini Pi TFT 240x135

TAG： 工业级隔离型转换器 STM32 1.5寸LCD 树莓派RP2040 树莓派 5.79寸电子墨水屏模块黑白ePaper适用于Arduino树莓派STM32 Jetson Milk-V Duo SG2002 ESP32-S3网口 树莓派PICO W ESP-32-PICO 树莓派5 PCIE M.2 NVME SSD固态硬盘Pi5 2280-2242-2230 X1001 树莓派5 MIPI转接线 RS485转以太网 Raspberry Pi 5 树莓派5透明亚克力外壳 树莓派DSI 4.3寸LCD 外壳 MIPI 电容触摸显示屏 800x480 树莓派2.8寸LCD DSI显示屏MIPI触摸屏480×640 Luckfox Pico RJ45 树莓派RP2040 树莓派5外壳 树莓派5 PCIE M.2 NVME双SSD固态硬盘HAT(B)2280-2242-2230 PI5
©Copyright 2015 Berlinger Haus | All Rights Reserved,XML,HTML
地址：广东省 深圳市 龙岗区 南湾街道 康桥路丹竹头恩来工业城4栋4层401
电话：13246739196 (投诉建议专线,下单/售后请查看网页“联系我们”)
邮箱：manager@spotpear.cn (投诉邮箱)
斑梨电子,深圳市斑梨电子有限公司,spotpear ,树莓派4b,树莓派DSI,树莓派显示屏,树莓派摄像头,树莓派CM4,树莓派pico, Jetson Nano BBC micro:bit Arduino