Guide: Brug en OLED-skærm til din Raspberry Pi

Af Torben Okholm, Alt om Data

Denne artikel er oprindeligt bragt på Alt om Data. Computerworld overtog i november 2022 Alt om Data. Du kan læse mere om overtagelsen her.

OLED-skærmen bliver forbundet til Raspberry Pis GPIO ved hjælp af et I2C-interface. Det er et specielt interface, der kun kræver fire pins på denne Pi for at kunne sende data. Når du skal tilslutte din Pi, bør du holde dig til diagrammet herunder [Billede A].

Når den fysiske forbindelse er foretaget, skal vi aktivere I2C på din Pi – det foregår i værktøjet Raspberry Pi Configuration. Vi vil også installere to Python-biblioteker til dette projekt, og derfor skal du i en terminal skrive den følgende kommando: $ sudo pip3 install Adafruit-SSD1306 netifaces . Det første bibliotek er til vores OLED-skærm, mens det andet gør det muligt for vores kode at arbejde med netværksinterfaces.

Billede A

1 Koden skal skrives

Når vi skal skrive koden, bruger vi Thonny, der er standard-editoren til Python på den nyeste Raspbian. Du kan bruge enhver editor, men husk at gemme koden som “live-data.py” – og gem ofte. Vi begynder koden med en linje, der angiver, hvor vores Python 3-interpreter befinder sig. Vores projekt skal være en baggrunds-app i systemet, og dette får den til at køre.
#! /usr/bin/env python3

> Nu importerer vi tre biblioteker for at føje funktioner til vores kode. Det første gør det muligt for os at bruge OLED-skærmen med Python. Det andet bruger vi til at få adgang til systeminformation i Python. Det tredje giver adgang til netværksinterface-information. Bemærk, at vi importerer netifaces, men for nemheds skyld kan du henvise til det som “ni”. import Adafruit_SSD1306 import psutil import netifaces as ni

>> Tre yderligere importer, der alle er fra Python Imaging Library (PIL), skal håndtere tegning på skærmen. From PIL import Image, ImageDraw, ImageFont

>> For at kunne bruge OLED-skærmen [Billede B] skal vi fortælle Python, hvor den er, og hvilken størrelse den har. I den forbindelse opretter vi et objekt ved navn disp , og der bruger vi Adafruit-biblioteket – specifikt funktionen 128_64 . Bemærk, at skærmen ikke har en reset-pin ( rst ), og derfor sætter vi den til None . Så begynder vi på forbindelsen til skærmen.
disp = Adafruit_SSD1306.SSD1306_128_64(rst=None)
disp.begin()

Billede B

>> Når vi skal konfigurere skærmen, har vi brug for at kende bredden og højden; det klarer funktionen heldigvis for os. Disse tal bliver gemt til variabler, og dernæst bliver skærmen sat til 1-bit-farve (sort-hvid).
width = disp.width
height = disp.height
image = Image.new(‘1’, (width, height))

>> Mens vi forbereder skærmen på output, opretter vi et objekt, som vi kan tegne til.
draw = ImageDraw.Draw(image)

> Nu indstiller vi skærmens begrænsninger. Variablen padding sætter os i stand til at blive inden for skærmen; vi sætter toppen, så den svarer til vores padding, og bunden af skærmen som højden minus vores padding. Vi opretter også en variabel, x , til at holde styr på, hvor teksten fremkommer på den vandrette akse.
padding = -2
top = padding
bottom = height-padding
x = 0

2 Datadetaljer

Nu skal vi samle data til vores skærm. De første indsamlede data er cpu’ens temperatur, og derfor åbner vi en fil i skrivebeskyttet tilstand. Denne fil lagrer data fra cpu-temperatur-sensoren, og dem gemmer vi til en variabel ved navn f .
f = open(“/sys/class/thermal/thermal_zone0/temp”, “r”)
t = f.readline()
>> Eftersom disse data bliver gemt som en streng, skal vi, hvis vi ønsker at lave beregninger med den, konvertere den til en float. Den gemte værdi er alt for stor, og derfor dividerer vi den med 1000 og afrunder tallet til én decimal, og så har vi den korrekte temperatur.
t = float(t)
t = round(t/1000,1)

>> Når vi ønsker at kende procentværdien for cpu-brug, opretter vi en variabel ved navn cpu og gemmer outputtet fra funktionen psutil.cpu_percent() i den. Vi runder tallet ned uden decimaler, så det bliver nemmere at huske.
cpu = psutil.cpu_percent(interval=1)
cpu = round(cpu)

>> Når vi vil kende ram-forbruget, bruger vi igen psutil , i dette tilfælde den virtuelle ram-funktion. Den leverer en liste over data, og fra denne liste skal vi bruge den sekundære værdi, som er tilgængelig hukommelse. For at finde den sekundære værdi bruger vi [1] , fordi en liste begynder med 0. Så regner vi lidt på værdien i hukommelse, som står for bytes. Vi er nødt til at konvertere den til megabytes, og derfor dividerer vi værdien med 1024 – to gange.
memory = psutil.virtual_memory()
memory = memory[1]
memory = round(memory / 1024 / 1024)

3 Adresser og advarsler

Den sidste stump data er den interne ip-adresse på Ethernet-porten. Derfor opretter vi en variabel med navnet ip og gemmer de data, vi har opnået fra netifaces-funktionen ifaddresses i den. Det kræver interfacenavnet som argument, og i de returnerede data skal vi gå ind i en række af indlejrede lister: først ved position 2, derefter ind i den liste, position 0. Dernæst bruger vi nøglen addr til at hente de data, der er gemt i en mappe.
ip = ni.ifaddresses(‘eth0’)[2][0][‘addr’]

> Det næste skridt består i at tilføje en advarsel til vores cpu. Hvis temperaturen ( t ) er over 50 grader, bliver teksten på skærmen ændret. Ellers får vi NOMINAL .
if t > 50:
ALERT = “CPU TEMP ALERT”
else:
ALERT = “NOMINAL”

4 Tekst på skærmen

Nu begynder vi at skrive tekst til skærmen. De første to linjer skriver cpu-temperatur og brug. Den første linje er vores cpu-temperatur, og du kan se, at vi begynder med at skrive øverst til venstre ( x ) to pixel fra toppen af skærmen (toppen er -2). Vi skriver en tekststreng og konverterer den til en streng t . Så bruger vi standardskrifttypen og sætter farven til 255 (hvid). Den anden linje er den samme, men vi rykker otte pixel ned.
draw.text((x, top), “CPU Temp is “+str(t)+”C”, font=ImageFont
load_default(), fill=255)
draw.text((x, top+8), “CPU usage is “+str(cpu)+”%”,
font=ImageFont.load_default(), fill=255)

>> De næste tre linjer er vores Advarselsstatus, tilgængelig ram og ip-adresse.
draw.text((x, top+16), ALERT, font=ImageFont.load_default(),
fill=255)
draw.text((x, top+25), str(memory)+”MB Free”, font=ImageFont.
load_default(), fill=255)
draw.text((x, top+33), “eth0:”+ip,
font=ImageFont.load_default(),
fill=255)

>> De allersidste to linjer af denne kode opdaterer skærmbilledet og viser de levende data.
disp.image(image)
disp.display()

>> Gem koden, og klik “Run”. Nu vågner din OLED-skærm til live og viser de seneste data for din maskine. I boksen nedenfor kan du se, hvordan du får denne kode kørt under boot. Hvis du får brug for at ændre I2C-adressen på din skærm, ændrer du forbindelsen til 0x78 og opretter en ny til 0x7A [Billede C].

Billede C