[PYTHON] Steuern Sie die Anzeige des RGB LED Matirix Lightning Bulletin Boards mit Raspberry Pi 3B + frei
Umgebung
Razpai 3B + (einschließlich SD-Karte) RGB-LED-Matrix (6 mm Abstand 32 x 32) 6 Blatt Anschluss für LED-Matrix MAXWELL Schaltnetzteil 3 Netzkabel für LED-Panel 6 IDC-Flachkabel 50 Sprungdrähte, männlich und weiblich, und 50 männlich und weiblich Brotbrett Mit Ausnahme der Raspeltorte habe ich sie im LED Picari-Gebäude in Akihabara gekauft. LED Pikarikan
Was Sie erreichen wollen
Ich möchte die Score-Anzeige der LED-Matrix mit Raspeye frei schalten. Wenn LEDmatrix mit Raspeye gehandhabt werden kann, kann von einem Smartphone über eine Internetverbindung gewechselt werden, daher sollte das Anwendungsspektrum breit sein!
Was ist LEDmatrix?
LED-Matrix ist eine Sammlung von LEDs (lacht wie es ist) Es ist dasselbe wie das elektrische Bulletin Board, das Sie häufig an Stationen sehen. Es gibt verschiedene Typen, aber im Grunde ist der Unterschied der Abstand (Abstand zwischen den LEDs), die Farbe, die ausgedrückt werden kann, und die Anzahl der angeordneten vertikalen und horizontalen LEDs. Dieses Mal habe ich 6 RGB (alle Farben können ausgedrückt werden) 32x32 LED-Matrix mit 6 mm Abstand verwendet.
Verdrahtung
Zunächst werden wir verdrahten. Stellen Sie sicher, dass Sie alles haben, was Sie brauchen.
Verkabelung um das Netzteil und zwischen LED-Matrix
Das Netzteil verwendet ein Schaltnetzteil. Der für jede Karte erforderliche Strom beträgt ca. 2A. Wenn Sie also mehrere Karten verwenden, kaufen Sie ein entsprechendes Netzteil. Ich habe diesmal 6 Blatt verwendet, also brauchte ich 12A oder mehr. Es ist in Ordnung, solange Sie GND nicht mit V㏄ verwechseln.
Befolgen Sie die Hinweise auf der hinteren Steckdose (siehe Abbildung unten). Verdrahten Sie die Matrizen nur horizontal mit einem Flachkabel.
Raspetorte und LED-Matrixverkabelung
Diese Verkabelung wurde gemäß der folgenden Site durchgeführt.
hzeller github
Um dies durch Zitieren dieser Site zu erklären, muss die Steckerseite mit jeder der 16 Stellen auf dem Foto unten verdrahtet werden.
Jedes Verbindungsziel ist eine handschriftliche Tabelle unten.
Die beiden Reihen in der Mitte zeigen auf Pin 40 der Raspeltorte. Jedes Verbindungsziel wird daneben geschrieben. In dieser Bibliothek kann LEDmatrix bis zu 3 Ebenen anzeigen. Die Verbindungsziele von der ersten bis zur dritten Zeile werden in der Reihenfolge von oben eingegeben. Verdrahten Sie die LED-Matrix am rechten Ende jeder Reihe mit der Raspeltorte, wie in der Abbildung unten gezeigt.
Es ist möglich, den Stecker wie bei einem Sprungdraht anzuschließen, wenn es sich um eine Stufe handelt. Wenn es sich jedoch um zwei oder mehr Stufen handelt, ist ein Steckbrett erforderlich. Wenn die Verkabelung unordentlich ist, sieht sie wie im Bild unten aus.
LED-Matrix gesteuert durch Raspeltorte
Ich habe die folgende Bibliothek benutzt. LEDmatrix Control Library
Installation
Installieren Sie die Bibliothek sofort von Github. Bitte wechseln Sie in das Verzeichnis der installierten Bibliothek und erstellen Sie.
git clone https://github.com/hzeller/rpi-rgb-led-matrix/
cd rpi-rgb-led-matrix
make -C examples-api-use
Führen Sie den folgenden Befehl aus, um Python zu aktivieren.
sudo apt-get update && sudo apt-get install python3-dev python3-pillow -y
cd rpi-rgb-led-matrix/python
make build-python PYTHON=$(which python3)
sudo make install-python PYTHON=$(which python3)
Führen Sie das Demo-Programm aus
Sie können das Demo-Programm ausführen, indem Sie in das Verzeichnis rpi-rgb-led-matrix wechseln. Mach Folgendes:
cd rpi-rgb-led-matrix
sudo examples-api-use/demo
Anschließend werden die folgenden Betriebsoptionen angezeigt: Befolgen Sie diese Optionen. Lassen Sie mich die wichtigen erklären. Geben Sie die LED-Matrixmatrix pro Blatt mit --led-Zeilen, --led-Spalten an. Wenn Sie mehrere Stufen verwenden, geben Sie --led-parallel für die Anzahl der Stufen und --led-chain für die Anzahl der horizontal verbundenen Stufen an. Die Helligkeit wird durch --led-Helligkeit und die Anzeigezeit durch -t angegeben.
Expected required option -D <demo>
usage: examples-api-use/demo <options> -D <demo-nr> [optional parameter]
Options:
-D <demo-nr> : Always needs to be set
-t <seconds> : Run for these number of seconds, then exit.
--led-gpio-mapping=<name> : Name of GPIO mapping used. Default "regular"
--led-rows=<rows> : Panel rows. Typically 8, 16, 32 or 64. (Default: 32).
--led-cols=<cols> : Panel columns. Typically 32 or 64. (Default: 32).
--led-chain=<chained> : Number of daisy-chained panels. (Default: 1).
--led-parallel=<parallel> : Parallel chains. range=1..3 (Default: 1).
--led-multiplexing=<0..9> : Mux type: 0=direct; 1=Stripe; 2=Checkered; 3=Spiral; 4=ZStripe; 5=ZnMirrorZStripe; 6=coreman; 7=Kaler2Scan; 8=ZStripeUneven; 9=P10-128x4-Z (Default: 0)
--led-pixel-mapper : Semicolon-separated list of pixel-mappers to arrange pixels.
Optional params after a colon e.g. "U-mapper;Rotate:90"
Available: "Rotate", "U-mapper". Default: ""
--led-pwm-bits=<1..11> : PWM bits (Default: 11).
--led-brightness=<percent>: Brightness in percent (Default: 100).
--led-scan-mode=<0..1> : 0 = progressive; 1 = interlaced (Default: 0).
--led-row-addr-type=<0..2>: 0 = default; 1 = AB-addressed panels; 2 = direct row select(Default: 0).
--led-show-refresh : Show refresh rate.
--led-inverse : Switch if your matrix has inverse colors on.
--led-rgb-sequence : Switch if your matrix has led colors swapped (Default: "RGB")
--led-pwm-lsb-nanoseconds : PWM Nanoseconds for LSB (Default: 130)
--led-pwm-dither-bits=<0..2> : Time dithering of lower bits (Default: 0)
--led-no-hardware-pulse : Don't use hardware pin-pulse generation.
--led-slowdown-gpio=<0..2>: Slowdown GPIO. Needed for faster Pis/slower panels (Default: 1).
--led-daemon : Make the process run in the background as daemon.
--led-no-drop-privs : Don't drop privileges from 'root' after initializing the hardware.
Demos, choosen with -D
0 - some rotating square
1 - forward scrolling an image (-m <scroll-ms>)
2 - backward scrolling an image (-m <scroll-ms>)
3 - test image: a square
4 - Pulsing color
5 - Grayscale Block
6 - Abelian sandpile model (-m <time-step-ms>)
7 - Conway's game of life (-m <time-step-ms>)
8 - Langton's ant (-m <time-step-ms>)
9 - Volume bars (-m <time-step-ms>)
10 - Evolution of color (-m <time-step-ms>)
11 - Brightness pulse generator
Example:
examples-api-use/demo -t 10 -D 1 runtext.ppm
Scrolls the runtext for 10 seconds
Um die Demo auszuführen, können Sie daher den folgenden Befehl eingeben (entsprechend Ihrer eigenen Nummer ändern). Standardmäßig tritt ein Fehler auf, wenn Sie ihn nicht mit sudo ausführen. Sie können die Demo auch ändern, indem Sie die Nummer nach dem letzten -D anpassen.
sudo examples-api-use/demo --led-no-hardware-pulse --led-rows=32 --led-cols=32 --led-chain=3 -t 10 --led-brightness=80 --led-parallel=2 -D 0
Japanische Textanzeige in Python
Diese Bibliothek enthält auch Beispielcode für Python, sodass wir das Programm neu erstellen, damit es japanischen Text anzeigen kann, indem wir darauf verweisen. Da es sich um eine Bibliothek für Ausländer handelt, gibt es ein Beispielprogramm zum Anzeigen von Text, das jedoch nur Alphabete anzeigen kann. Als Ergebnis verschiedener Suchanfragen habe ich eine Spezifikation erstellt, um japanischen Text in ein Bild umzuwandeln und anzuzeigen, und zwar unter Bezugnahme auf diesen Artikel. Jede japanische Schriftart ist in Ordnung, aber bitte laden Sie sie auf Razpai herunter. Die diesmal verwendete Schriftart wurde von [dieser Site] heruntergeladen (http://jikasei.me/font/kh-dotfont/).
text_image_ledmatrix.py
#!/usr/bin/env python
# -*- encoding:utf8 -*-
import time
import sys
import os
import numpy as np
from PIL import Image, ImageFont, ImageDraw
from rgbmatrix import RGBMatrix, RGBMatrixOptions
import subprocess, os, sys, re
def imaged_text(text, fontfile, fontsize, color, scale_bias=4):
font = ImageFont.truetype(fontfile, fontsize * scale_bias)
image = Image.new('RGBA', (1, 1))
draw = ImageDraw.Draw(image)
w,h = draw.textsize(text, font=font)
del draw
image = Image.new('RGBA', (w, h))
draw = ImageDraw.Draw(image)
draw.text((0, 0), text, font=font, fill=color)
del draw
return image.resize((w // scale_bias, h // scale_bias), Image.ANTIALIAS)
def draw_text_to(target, position, text, fontfile, fontsize, color):
image = imaged_text(text, fontfile, fontsize, color)
target.paste(image , position, image)
def select_color(threshold, color, destcolor = '#FFFFFF'):
mean = np.array(color).mean()
if mean > threshold:
#return (255, 255, 255)
return (int(destcolor[1:3],16),int(destcolor[3:5],16),int(destcolor[5:7],16))
else:
return (0, 0, 0)
#Binärisierung von Zeichenbildern
def to_bin(img, w, h, color = '#FFFFFF'):
#R für jeden Pixelwert,g,Finden Sie den Durchschnitt von b
means = np.array([[img.getpixel((x,y)) for x in range(w)] for y in range(h)]).mean(axis=2).reshape(w * h,)
#Machen Sie ein Histogramm
hist = np.array([np.sum(means == i) for i in range(256)])
max_v = 0
threshold = 0
#Berechnen Sie von 0 bis 255, um den geeigneten Schwellenwert zu finden
#Ein Pixelwert, der größer als der Schwellenwert ist, wird als Klasse 1 klassifiziert, und ein Pixelwert, der kleiner als der Schwellenwert ist, wird als Klasse 2 klassifiziert.
for th in range(256):
n1 = sum(hist[:th]) #Nummer der Klasse 1
m1 = np.dot(hist[:th], np.array(range(256))[:th]) #Durchschnitt der Werte der Klasse 1
n2 = sum(hist[th:]) #Nummer der Klasse 2
m2 = np.dot(hist[th:], np.array(range(256))[th:]) #Durchschnitt der Klasse 2-Werte
if n1 == 0 or n2 == 0:
v = 0
else:
#Finden Sie das Molekül der Dispersion zwischen den Klassen
v = n1 * n2 * (m1 / n1 - m2 / n2) ** 2
#Aktualisieren Sie den Schwellenwert, bei dem der Zähler der Streuung zwischen Klassen maximal ist
if max_v < v:
max_v = v
threshold = th
bin_img = Image.new('RGB', (w, h))
np.array([[bin_img.putpixel((x, y), select_color(threshold, img.getpixel((x,y)), color)) for x in range(w)] for y in range(h)])
return bin_img
#Verbinden Sie Bilder nebeneinander
def get_concat_h(im1, im2):
dst = Image.new('RGB', (im1.width + im2.width, im1.height))
dst.paste(im1, (0, 0))
dst.paste(im2, (im1.width, 0))
return dst
#Verbinden Sie Bilder vertikal
def get_concat_w(im1, im2):
dst = Image.new('RGB', (im1.width,im1.height + im2.height,))
dst.paste(im1, (0, 0))
dst.paste(im2, (0, im1.height))
return dst
def get_text(str, width, separator = u"", col = '#B5E61D'):
image = Image.new("RGB", (width, 16))
draw_text_to(image, (0, 0), separator + str, 'KH-Dot-Kodenmachou-16.ttf', 16, col)
bin = to_bin(image, image.width, image.height, col)
return bin
def get_large_text(str, width, separator = u"", col = '#B5E61D'):
image = Image.new("RGB", (width,64))
draw_text_to(image, (0, 16), separator + str, 'KH-Dot-Kodenmachou-16.ttf', 32, col)
bin = to_bin(image, image.width, image.height, col)
return bin
def add_text(tex):
filename='clear.txt'
with open(filename,'a') as file_object:
file_object.write(tex+'\n')
def clearmatrix():
f=open('clear.txt')
line=f.readline()
while line:
ans=line
line=f.readline()
f.close()
ans=ans.strip()
if ans=='clear':
return True
else:
return False
# Configuration for the matrix
options = RGBMatrixOptions()
options.rows = 32
options.chain_length = 3
options.parallel = 2
options.hardware_mapping = 'regular'
options.brightness = 40
options.pwm_lsb_nanoseconds = 100
matrix = RGBMatrix(options = options)
def textscroll(text):
add_text("on")
width=full_width_decision(text)+32*6
text1=" "
left=0
right=96
result = Image.new("RGB", (96, 32))
text=text1+text
text_im = get_large_text(text, width, u"", '#FF7F27')
while clearmatrix()==False:
result=text_im.crop((left,0,right,64))
left+=1
right=left+96
if left>=width:
left=0
matrix.SetImage(result)
time.sleep(0.005)#Durch Ändern dieses Werts wird die Bildlaufgeschwindigkeit geändert.
matrix.Clear()
add_text("off")
def ledprint(text):
add_text("on")
length=len(text)
row=int((length-1)/6)
text1=" "
text2=" "
text3=" "
text4=" "
if row==0:
text1=text
if row==1:
text1=text[0:6]
text2=text[6:]
if row==2:
text1=text[0:6]
text2=text[6:12]
text3=text[12:]
if row>=3:
text1=text[0:6]
text2=text[6:12]
text3=text[12:18]
text4=text[18:]
text1_im = Image.new("RGB", (96, 16))
text2_im = Image.new("RGB", (96, 16))
text3_im = Image.new("RGB", (96, 16))
text4_im = Image.new("RGB", (96, 16))
while clearmatrix()==False:
text1_im = get_text(text1, 96, u"", '#FF7F27')
text2_im = get_text(text2, 96, u"", '#FF7F27')
text3_im = get_text(text3, 96, u"", '#FF7F27')
text4_im = get_text(text4, 96, u"", '#FF7F27')
result = get_concat_w(text1_im,text2_im)
result = get_concat_w(result,text3_im)
result = get_concat_w(result,text4_im)
matrix.SetImage(result)
time.sleep(1)
matrix.Clear()
add_text("off")
if __name__ == '__main__':
ledprint(u"Es ist möglich, auf diese Weise anzuzeigen")
Sie können den Text jetzt mit den beiden unten definierten Funktionen anzeigen und scrollen. Bitte ändern Sie den Zahlenteil entsprechend der Größe Ihrer LED-Matrix. Wie ich diesmal in der zweiten Hälfte des Artikels erläutern werde, lese ich'clear.txt 'und entscheide, ob ich sie löschen möchte, da die Anzeige durch Lesen und Schreiben der Textdatei (Programmanfänger) umgeschaltet wird. ..
Worauf ich mich beziehen durfte
Bei der Steuerung der LED-Matrix mit Raspeye habe ich diesmal auf den folgenden Artikel verwiesen. Vielen Dank für den wunderbaren Artikel. https://qiita.com/sousan/items/19425d5eac43786003a7/ https://qiita.com/t_slash_k/items/35ccf49ce85e5cbd045b/ https://qiita.com/eucalyhome/items/e871e297bfd527ccaf2c/ https://www.buildinsider.net/small/raspisinage/01/ https://yomon.hatenablog.com/entry/2018/09/p3rgbdisplay/
abschließend
Jetzt ist es möglich, eine LED-Matrix vorzubereiten, zu verdrahten und japanischen Text anzuzeigen. Ab dem nächsten Mal werde ich versuchen, Raspeye und Slack zu verknüpfen, damit es einfacher zu handhaben ist.
Recommended Posts