[PYTHON] Essayez de mettre des LED dans votre propre PC (légèrement)
Bonjour.
Récemment, je suis Yukari, qui est également un magasin de LED dans le domaine professionnel. Eh bien, selon la mode récente. Oiler a également voulu «faire briller le PC avec une LED». J'ai essayé de le faire.
résultat
Dans une telle situation!
Préparation
Ce n'est pas grave si vous collectez des matériaux qui remplissent les conditions suivantes et que vous le faites avec l'alchimie du pot.
――Un cas où vous pouvez mettre des LED à l'intérieur et vous pouvez voir les LED de l'extérieur.
- LED matricielle appropriée ――Peut-être qu'il s'étouffe, c'est donc un moyen de dissipation thermique approprié
Eh bien, je cherchais un boîtier avec une "façade en verre ou acrylique". J'ai fait un cas du H510i Elite de NZXT. Eh bien, j'ai également introduit un simple refroidissement par eau appelé "kraken M22" afin que la chaleur d'échappement du CPU puisse être évacuée.
Sélection de LED
Il existe plusieurs types de «LED matricielles couleur montées en surface HUB75» qui sont populaires de nos jours, selon la taille du bourgeon. Le nombre après le "P" dans le numéro de modèle correspond à la taille du bord. Le boîtier sélectionné cette fois semble pouvoir contenir deux éventails de 12 cm à 14 cm à l'avant. Sélectionnez une taille qui lui ressemble.
Par exemple, si c'est 32x64 de P5, la taille est "16cm x 32cm", ce qui est un peu grand. Eh bien, si vous tabulez la résolution et la taille typiques, cela ressemble à ceci.
| pas | Taille | Taille |
|---|---|---|
| P2 | 64x128 | 12.8cm x 25.6cm |
| P2.5 | 32x64 | 8.0cm x 16.0cm |
| P3 | 32x64 | 9.6cm x 19.2cm |
| P4 | 32x64 | 12.8cm x 25.6cm |
| P5 | 32x64 | 16.0cm x 32.0cm |
| P6.67 | 32x64 | 21.3cm x 42.6cm |
Eh bien, cette fois, j'ai décidé d'utiliser le top "P2 64x128". C'est peut-être plus amusant d'avoir une résolution. Si le côté court est de 64 points ou plus, il y a une forte possibilité que la ligne d'adresse «E» soit requise. Soyez prudent lors du choix du tableau, qui sera décrit plus tard.
Tarte à la râpe et préparation de l'interface
Eh bien, utilisez le Raspberry Pi pour le faire briller.
Cette fois, j'ai choisi "Raspberry Pi4 4 Go".
Le cas est approprié, mais comme GPIO est utilisé, le cas officiel est strict.
Vient ensuite la carte d'interface LED.
Cette fois, j'ai décidé d'utiliser l'ancienne planche Adafruit qu'il me restait.
Pourtant! , Les deux modifications suivantes sont nécessaires.
- Lecteur PWM matériel --Ajout de la ligne d'adresse "E"
Eh bien, en se référant à cette description, on a l'impression d'ajouter deux lignes et un motif coupé. Il existe deux modèles de ligne d'adresse E, alors vérifiez d'abord avec un testeur, etc., quel panneau vous utilisez. La ligne d'adresse E inutilisée tombe à GND.
- Les deux connexions sont donc NG.
https://github.com/hzeller/rpi-rgb-led-matrix
Le câblage est correctement fixé avec du polyimide.
Assemblée
Tout d'abord, la face avant ressemble à ceci.
Le dos est fixé au support pour le ventilateur de 12 cm avec des vis M3.
Cela ressemblera à ceci lorsque vous l'insérerez.
Cela seul est solitaire, alors j'ai également posé une LED sur le fond.
Ce mec est fixé avec des aimants et se monte aux quatre coins.
Cet aimant est vendu au magasin LED à côté de Sengoku Densho à Akihabara, Benribenri.
https://www.akiba-led.jp/product/1197
La LED connecte la LED inférieure à la tarte à la râpe, puis se connecte à la LED avant avec une chaîne. Ceci est purement une commodité de câblage.
L'alimentation est tirée du SATA.
Eh bien, c'est une promesse de longue date, mais l'alimentation des ordinateurs personnels est généralement «jaune: 12V», «rouge: 5V», «orange: 3,3V» et «noir: GND».
Avec RaspberryPi4 et LED, il semble utiliser 5A ou plus, mais ce sera bien car il s'agit d'une alimentation d'ordinateur personnel (appropriée).
L'interface entre Raspberry Pi et PC utilise LAN.
Le côté PC est USB LAN.
Pour l'USB, utilisez le connecteur de conversion pour le boîtier de l'en-tête de la carte mère.
La connexion autour du Raspberry Pi ressemble à ceci.
Après cela, poussez la tarte à la râpe dans l'espace derrière l'alimentation du H510i Elite, et c'est terminé.
Complétion intégrée
Eh bien, en d'autres termes, ce PC.
C'est un "PC à double configuration" qui vit dans deux environnements.
Eh bien de l'extérieur, cela ressemble à un PC normal.
Le dos est également un PC ordinaire.
Ce n'est pas au bâton avec le véritable mécanisme de contrôle NZXT "HUE2".
- Eh bien, j'ai supprimé tous les fans qui étaient depuis le début.
Tout en gardant les choses à ce point, ce n'est "aucune modification du cas".
Préparation côté PC
Côté PC, un logiciel de surveillance est nécessaire. Cette fois, j'ai utilisé "Open Hardware Monitor". Ce logiciel a une fonction de serveur Web, je peux donc appréhender la situation de l'extérieur. C'est une stratégie pour obtenir le JSON utilisé pour le rendu du côté Raspeye. https://forest.watch.impress.co.jp/docs/review/383668.html
Cependant, le logiciel ci-dessus ne prend pas en charge l'architecture récente. En fait, j'utilise "LibreHardwareMonitor" de Nora construit à partir de l'URL suivante. http://takkun87.blog40.fc2.com/blog-category-6.html
Si vous activez le serveur Web, définissez le F / W de manière appropriée et obtenez le JSON suivant de l'extérieur, cela réussit. http://[IPアドレス]:8085/data.json
Le contenu ressemble à ceci (extrait partiel):
data.json
{
"id": 0,
"Text": "Sensor",
"Min": "Min",
"Value": "Value",
"Max": "Max",
"ImageURL": "",
"Children": [
{
"id": 1,
"Text": "DESKTOP-HOGEHOGE",
"Min": "",
"Value": "",
"Max": "",
"ImageURL": "images_icon/computer.png ",
"Children": [
{
"id": 2,
"Text": "ASRock Z390 Phantom Gaming 6",
"Min": "",
"Value": "",
"Max": "",
"ImageURL": "images_icon/mainboard.png ",
"Children": [
{
"id": 3,
"Text": "Nuvoton NCT6791D",
"Min": "",
"Value": "",
"Max": "",
"ImageURL": "images_icon/chip.png ",
"Children": [
{
"id": 4,
"Text": "Voltages",
"Min": "",
"Value": "",
"Max": "",
"ImageURL": "images_icon/voltage.png ",
"Children": [
{
"id": 5,
"Text": "Vcore",
"Min": "1.392 V",
"Value": "1.392 V",
"Max": "1.408 V",
"SensorId": "/lpc/nct6791d/voltage/0",
"Type": "Voltage",
"ImageURL": "images/transparent.png ",
"Children": []
},
{
"id": 6,
"Text": "Voltage #2",
"Min": "1.680 V",
"Value": "1.688 V",
"Max": "1.688 V",
"SensorId": "/lpc/nct6791d/voltage/1",
"Type": "Voltage",
"ImageURL": "images/transparent.png ",
"Children": []
},
{
"id": 7,
"Text": "AVCC",
"Min": "3.488 V",
"Value": "3.488 V",
"Max": "3.488 V",
"SensorId": "/lpc/nct6791d/voltage/2",
"Type": "Voltage",
"ImageURL": "images/transparent.png ",
"Children": []
},
{
"id": 8,
"Text": "3VCC",
"Min": "3.488 V",
"Value": "3.488 V",
"Max": "3.488 V",
"SensorId": "/lpc/nct6791d/voltage/3",
"Type": "Voltage",
"ImageURL": "images/transparent.png ",
"Children": []
},
{
"id": 9,
"Text": "Voltage #5",
"Min": "1.016 V",
"Value": "1.032 V",
"Max": "1.032 V",
"SensorId": "/lpc/nct6791d/voltage/4",
"Type": "Voltage",
"ImageURL": "images/transparent.png ",
"Children": []
},
{
"id": 10,
"Text": "Voltage #6",
"Min": "1.088 V",
"Value": "1.088 V",
Ensuite, attribuez une adresse IP locale appropriée au LAN USB et au Raspeye de votre PC pour sécuriser la communication.
Préparation du côté de tarte aux râpes
Que faire est comme ça
--Ajout de bibliothèque pour panneau LED --Programme --Définition de RAMDISK et SYSTEMD
Pour la bibliothèque des panneaux LED, reportez-vous à l'URL ci-dessous. https://qiita.com/eucalyhome/items/e871e297bfd527ccaf2c
programme
J'ai essayé d'implémenter "l'affichage de l'état" et le "jeu de la vie (l'occupation change en fonction de la température)". Les LED sont enchaînées, donc les 128 premiers points sont pour les jeux de la vie, et les 128 derniers points sont pour l'affichage d'état vertical.
ledstat.py
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from PIL import Image, ImageDraw, ImageOps, ImageFont, ImageFilter, ImageChops, ImageColor
from rgbmatrix import RGBMatrix, RGBMatrixOptions
import time, re, copy, os, codecs, random, datetime, json
import numpy as np
from scipy import signal
class ledworker(object):
def ledinit(self):
self.options = RGBMatrixOptions()
self.options.hardware_mapping = "adafruit-hat-pwm"
self.options.led_rgb_sequence = "RGB"
self.options.rows = 64
self.options.chain_length = 8
self.options.parallel = 1
self.options.pwm_bits = 11
self.options.brightness = 50
self.options.pwm_lsb_nanoseconds = 130
self.options.gpio_slowdown = 1
self.options.panel_type = "FM6126A"
self.matrix = RGBMatrix(options = self.options)
def ledoutput(self,handle):
self.matrix.SetImage(handle)
def imagenew(self):
imagecolorspace = 'RGB'
imagecolorfill = (0, 0, 80)
imagesizex = 256
imagesizey = 64
image = Image.new(imagecolorspace, (imagesizex, imagesizey), imagecolorfill)
return (image)
class lifeworker(object):
def initstate(self, width, height, init_alive_prob=0.5):
N = width*height
v = np.array(np.random.rand(N) + init_alive_prob, dtype=int)
return v.reshape(height, width)
def addstate(self, F, width, height, init_alive_prob=0.5):
N = width*height
v = np.array(np.random.rand(N) + init_alive_prob, dtype=int).reshape(height, width)
v = F + v
return v
def countneighbor(self, F):
mask = np.ones((3, 3), dtype=int)
return signal.correlate2d(F, mask, mode="same", boundary="wrap")
def nextgeneration(self, F):
N = self.countneighbor(F)
G = (N == 3) + F * (N == 4)
return G
def toimage(self, F):
nparray = np.array(F, dtype=np.uint8)*255
image = Image.fromarray(np.uint8(nparray)).convert("1")
return image
class monitorworker(object):
def getdata(self):
datafile_hwdata = '/ramdisk/hwdata.json'
outdata = {}
outdata['cpuload'] = 0
outdata['cputemp'] = 0
outdata['gpuload'] = 0
outdata['gputemp'] = 0
outdata['cpuclock'] = 0
if not os.path.exists(datafile_hwdata):
return (outdata)
try:
with open(datafile_hwdata) as f:
hwdata = json.load(f)
except:
return (outdata)
for primarykey in hwdata['Children'][0]['Children']:
if 'cpu' in primarykey['ImageURL']:
for secondarykey in primarykey['Children']:
if 'Clocks' in secondarykey['Text']:
for thirdkey in secondarykey['Children']:
if 'CPU Core #1' in thirdkey['Text']:
outdata['cpuclock'] =re.sub("[^0-9\.]","",thirdkey['Value'])
if 'Load' in secondarykey['Text']:
for thirdkey in secondarykey['Children']:
if 'CPU Total' in thirdkey['Text']:
outdata['cpuload'] =re.sub("[^0-9\.]","",thirdkey['Value'])
if 'nvidia' in primarykey['ImageURL']:
for secondarykey in primarykey['Children']:
if 'Temperatures' in secondarykey['Text']:
outdata['gputemp'] = re.sub("[^0-9\.]","",secondarykey['Children'][0]['Value'])
if 'Load' in secondarykey['Text']:
outdata['gpuload'] = re.sub("[^0-9\.]","",secondarykey['Children'][0]['Value'])
if 'mainboard' in primarykey['ImageURL']:
for secondarykey in primarykey['Children'][0]['Children']:
if 'Temperatures' in secondarykey['Text']:
outdata['cputemp'] = re.sub("[^0-9\.]","",secondarykey['Children'][0]['Value'])
outdata['cpuload'] = "{0:5.1f}".format(float(outdata['cpuload']))
outdata['gpuload'] = "{0:5.1f}".format(float(outdata['gpuload']))
outdata['cpuclock'] = "{0:4d}".format(int(outdata['cpuclock']))
return (outdata)
def writetext(draw,hpos,message,color,font):
w, h = draw.textsize(str(message), font)
w = 48 - w
draw.text((w,hpos), str(message), color,font=font)
def main():
led = ledworker()
led.ledinit()
image = led.imagenew()
fontdata = "./GDhwGoJA-OTF112b2.otf"
life = lifeworker()
lifedatablue = life.initstate(128, 64, init_alive_prob=0.08)
lifedatagreen = life.initstate(128, 64, init_alive_prob=0.08)
monitor = monitorworker()
outdata = monitor.getdata()
imagebasel = Image.open('/data/ledstat/nzx_log_w.png').convert("RGB")
imagebasel = imagebasel.transpose(Image.ROTATE_180)
imagebaseh = copy.copy(imagebasel)
imagebaseh = imagebaseh.transpose(Image.ROTATE_90)
imageh = copy.copy(imagebasel)
image = Image.new('RGB', (256, 64), (0, 0, 0))
image.paste(imageh,(128, 0))
imagehtemp = copy.copy(imagebaseh)
draw = ImageDraw.Draw(imagehtemp)
font = ImageFont.truetype(fontdata, 16)
fontsmall = ImageFont.truetype(fontdata, 7)
addcount = 0
while True:
imageblue = life.toimage(lifedatablue)
imagegreen = life.toimage(lifedatagreen)
imagel = copy.copy(imagebasel)
imagel.paste(Image.new("RGB", imagel.size, (0,255,255)), mask=imageblue)
imagel.paste(Image.new("RGB", imagel.size, (0,0,255)), mask=imagegreen)
image.paste(imagel,(128, 0))
led.ledoutput(image)
lifedatablue = life.nextgeneration(lifedatablue)
lifedatagreen = life.nextgeneration(lifedatagreen)
time.sleep(0.05)
addcount = addcount + 1
if addcount > 20:
addcount = 0
outdatatemp = monitor.getdata()
if outdatatemp['cputemp'] != 0:
outdata = outdatatemp
blueseed = (float(outdata['cputemp'])-40) / 200
greenseed = (float(outdata['gputemp'])-40) / 200
if blueseed < 0:
blueseed = 0
if greenseed < 0:
greenseed = 0
lifedatablue = life.addstate(lifedatablue,128, 64, init_alive_prob=blueseed)
lifedatagreen = life.addstate(lifedatagreen,128, 64, init_alive_prob=greenseed)
lifedatablue = life.nextgeneration(lifedatablue)
lifedatagreen = life.nextgeneration(lifedatagreen)
imagehtemp.paste(imagebaseh,(0, 0))
draw.text((0,0), "CPU", (0, 255, 255),font=font)
writetext(draw,16,outdata['cpuload'],(255, 255, 255),font)
draw.text((48,24), "%", (0, 255, 255),font=fontsmall)
writetext(draw,32,outdata['cputemp'],(255, 255, 255),font)
draw.text((48,40), "'C", (0, 255, 255),font=fontsmall)
writetext(draw,48,outdata['cpuclock'],(255, 255, 255),font)
draw.text((48,56), "MHz", (0, 255, 255),font=fontsmall)
draw.text((0,74), "GPU", (0, 0, 255),font=font)
writetext(draw,90,outdata['gpuload'],(255, 255, 255),font)
draw.text((48,98), "%", (0, 0, 255),font=fontsmall)
writetext(draw,106,outdata['gputemp'],(255, 255, 255),font)
draw.text((48,116), "'C", (0, 0, 255),font=fontsmall)
imageh = copy.copy(imagehtemp)
imageh = imageh.transpose(Image.ROTATE_90)
image.paste(imageh,(0, 0))
if __name__ == '__main__':
main()
Pour la mise en œuvre du jeu de la vie, je me suis référé à l'URL suivante. https://qiita.com/sage-git/items/c6c175887faa4cf737fb
Les fichiers prérequis sont les suivants Logo d'arrière-plan 128x64: /data/ledstat/nzx_log_w.png État Data.json pour PC: /ramdisk/data.json Police: ./GDhwGoJA-OTF112b2.otf
La police est celle de l'autoroute, si vous le souhaitez. https://forest.watch.impress.co.jp/library/software/gdhighway/
Ensuite, un programme approprié pour obtenir JSON à partir du PC
getdata.py
import urllib.request
import json
import time
url = 'http://[ip address]:8085/data.json'
datafile = '/ramdisk/hwdata.json'
req = urllib.request.Request(url)
while True:
try:
with urllib.request.urlopen(req) as res:
body = json.load(res)
fw = open(datafile,'w')
json.dump(body,fw,indent=4)
fw.close()
except:
time.sleep(30)
time.sleep(2)
Cela fonctionne avec Python3 Note, enfin, sans scrupules.
La définition RAMDISK est simple. Tout d'abord, créez un répertoire 777 avec "/ ramdisk /" comme root. Ajoutez "tmpfs / ramdisk tmpfs defaults, size = 16m 0 0" à FSTAB. Juste "monter -a" ou redémarrer. Si vous df et avez "tmpfs 16384 84 16300 1% / ramdisk", c'est OK.
L'enregistrement sur systemd ressemble à ce qui suit.
/etc/system/getdata.service
[Unit]
Description=getdata
[Service]
ExecStart=/usr/bin/python3 /data/ledstat/getdata.py
Restart=always
Type=simple
User=pi
[Install]
WantedBy=multi-user.target
/etc/systemd/system/ledstat.service
[Unit]
Description=ledstat
[Service]
WorkingDirectory=/data/ledstat
ExecStart=/usr/bin/python /data/ledstat/ledstat.py
Restart=always
Type=simple
[Install]
WantedBy=multi-user.target
Ensuite, à partir de "systemctl daemon -reload"
systemctl start getdata
systemctl enable getdata
systemctl start ledstat
systemctl enable ledstat
Avec un sentiment. Si une erreur se produit, vérifiez l'état.
Contrôle de fonctionnement
Le panneau avant ressemble à ceci! ..
Le panneau inférieur ressemble à ceci si vous n'êtes pas occupé.
Quand je suis occupé et que la température monte, je suis confus.
C'est assez amusant w.
Essaye de le faire
Je veux dire. Je me demande si je pourrais faire quelque chose comme de l'huile.
Au fait, je ne vois pas d'autre ordinateur pendant que je joue à un jeu. Il est recouvert de panneaux LED, donc la température semble augmenter. En premier lieu, la LED génère de la chaleur.
Il n'y a rien de bon à penser sérieusement. C'est bien parce que c'est amusant! .. C'est beau! ..
Manzoku! ..
Recommended Posts