Themabewertung:
  • 0 Bewertung(en) - 0 im Durchschnitt
  • 1
  • 2
  • 3
  • 4
  • 5
Ein SSD1306-OLED am Pimoroni Internetradio
#1
Ich habe ja schon einige Anfragen dazu bekommen, wie man am kleinen Internetradio aus dem Bausatz ein Display betreibt.
Im Prinzip kommt ein Pi ja ganz ohne Ein-/Ausgabe-Geräte aus – je nachdem, was man damit macht. Manchmal ist es aber schon recht praktisch, sich ein paar Informationen auf einem Display ausgeben lassen. In diesem Beitrag wollen wir ein kleines 0,96'' OLED-Display mit 128x64 Pixeln über die I2C-Schnittstelle ansteuern.

Von Haus aus ist die I2C-Schnittstelle am Raspberry Pi deaktiviert. Um diese nun einzuschalten verbinden wir uns per SSH und starten die Konfigurationsoberfläche vom Raspberry Pi:

Code:
$ sudo raspi-config

Dort gehen wir zum Punkt 5 (Interfacing Options) -> P5 (I2C) -> ENTER und bestätigen die Abfrage, ob wir I2C aktivieren wollen, mit <Ja>. Anschließend verlassen wir raspi-config.

Jetzt installieren wir noch ein paar Pakete, die wir für unser Script brauchen:

Code:
$ sudo apt-get install python-smbus i2c-tools git python-pil

Nun das OLED-Display anschließen.
Mit ein paar Steckbrücken verbinden wir den Pi Zero mit dem OLED-Display. Es gibt SSD1603-OLEDs die können mit 5V und/oder nur mit 3.3V betrieben werden. Die I2C Pins SDA und SCL auf dem Pi Zero sind aber 3.3V (!) Pins. Achtet also darauf. Betreibt Ihr das Display durchweg mit 3.3V ist in der Regel kein Pegelwandler erforderlich.
Nach dem Anschließen kann man das Display schon mal testen, indem man mit einem kleinen Kommandozeilentool die I2C-Adresse des Displays ermittelt.

Da I2C ein Bus-System für mehrere Teilnehmer ist, haben alle Teilnehmer auch eine Busadresse. Bei diesen kleinen OLEDs hat sich so etwas wie ein Standard durchgesetzt. Bei fast allen lautet die Adresse 0x3C. Das lässt sich einfach überprüfen, indem wir folgenden Befehl absetzen:

Code:
$ i2cdetect -y 1

Als Ausgabe erhalten wir dann so eine Tabelle, der wir als Adresse des (momentan) einzigen Busteilnehmers 3c entnehmen können:

pi@raspberrypi:~ $ i2cdetect -y 1
    0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
00:          -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- 3c -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --

Nun der Python-Code (auf dem Radio läuft ja sowieso vieles in Python, also nutzen wir die Sprache einfach weiter, C wie bei den Arduinos geht natürlich auch).
Für die Ansteuerung des Displays machen wir uns eine kleine fertige Python-Bibliothek auf Github zu Nutze. Die klonen wir und haben damit alles, was wir benötigen:

Code:
$ git clone https://github.com/BLavery/lib_oled96

Wir wechseln in das Verzeichnis lib_oled96 und legen uns dort eine neue Script-Datei an:

Code:
$ cd lib_oled96
$ touch display.py
$ chmod 755 display.py

Anschließend öffnen wir die soeben erstellte Datei in einem beliebigen Editor und fangen mit der Programmierung an, ich benutze hier den Editor nano:

Code:
$ nano display.py

Die Adresse 0x3c ist in der von uns verwendeten Python-Bibliothek schon vorausgewählt, sodass wir der Adresse keine weitere Beachtung schenken müssen.

Code:
#!/usr/bin/env python
# coding=utf-8

# Bibliotheken importieren
from lib_oled96 import ssd1306
from smbus import SMBus

# Display einrichten
i2cbus = SMBus(1)            # 0 = Raspberry Pi 1, 1 = Raspberry Pi > 1
oled = ssd1306(i2cbus)

# Ein paar Abkürzungen, um den Code zu entschlacken
draw = oled.canvas

# Display zum Start löschen
oled.cls()
oled.display()

# Hallo Welt
draw.text((20, 16), "Hallo", fill=1)
draw.text((60, 40), "Welt!", fill=1)

# Ausgaben auf Display schreiben
oled.display()

Der Klassiker in der Programmierung schreibt einfach ein paar Worte aufs Display. Die Zeilen 1-10 im Script liefern dabei die Grundfunktionalitäten und Zeile 13 dient lediglich dazu, den Code etwas zu verschlanken. Interessant wird es ab Zeile 16, denn hier beginnt die echte Ausgabe aufs Display. Der hier verwendete Befehl oled.cls() löscht den kompletten Inhalt und oled.display() schreibt die bisherigen Ausgaben auf das OLED-Display.

ACHTUNG: Alle Display-Manipulationen werden solange gesammelt, bis sie mit dem Befehl oled.display() auf dem Display ausgeführt werden.

Auf den Zeilen 20 und 21 wird dann die eigentliche Textausgabe erzeugt. Die Syntax lautet draw.text((<x>, <y>), <Inhalt>, [<Schriftart>], [<Formatierung>]). Die Angaben <x>, <y> stehen hier für die Koordinaten auf dem Display, bezogen auf die obere linke Ecke. Das Wort „Hallo“ wird also 20 Pixel nach rechts und 16 Pixel nach unten verschoben. Das Wort „Welt“ dann demzufolge um 60 Pixel nach rechts und 40 Pixel nach unten. Zeile 24 erzeugt wieder die Anzeige auf dem Display.

Den Code kopieren wir einfach in den Editor, speichern und schließen diesen (Strg+X) und führen das Script aus:

Code:
$ ./display.py

Schriften formatieren:

Code:
#!/usr/bin/env python
# coding=utf-8

# Bibliotheken importieren
from lib_oled96 import ssd1306
from smbus import SMBus
from PIL import ImageFont

# Display einrichten
i2cbus = SMBus(1)            # 0 = Raspberry Pi 1, 1 = Raspberry Pi > 1
oled = ssd1306(i2cbus)

# Ein paar Abkürzungen, um den Code zu entschlacken
draw = oled.canvas

# Schriftarten festlegen
FreeSans12 = ImageFont.truetype('FreeSans.ttf', 12)
FreeSans20 = ImageFont.truetype('FreeSans.ttf', 20)

# Display zum Start löschen
oled.cls()
oled.display()

# Hallo Welt
draw.text((20, 16), "Hallo", font=FreeSans12, fill=1)
draw.text((60, 40), "Welt!", font=FreeSans20, fill=1)

# Ausgaben auf Display schreiben
oled.display()

Wir gehen einen Schritt weiter und formatieren die ausgegebene Schrift. Dazu erweitern wir unser Script um Elemente der Bibliothek PIL (Zeile 7), legen die Schriftarten fest (Zeilen 17 und 18) und wenden sie als Formatierung auf den Text an (Zeilen 25 und 26).

Das Ergebnis sieht dann so aus:
   

An den entsprechenden Stellen könnte dann der aktuelle Sendername und das gespielte Lied/Programm stehen. Wie man an diese Daten von vlc kommt, habe ich ja im Nachbarthread geschrieben, Otto hatte dazu sogar ein einfaches Script gezeigt.

Mit weiteren Grafikprimitiven ist dann sogar das Zeichnen von Figuren möglich.

Linien: draw.line((x1, y1, x2, y2), fill=1)
Rechteck (nur Rahmen): draw.rectangle((x1, y1, x2, y2), outline=1, fill=0)
Rechteck (ausgefüllt): draw.rectangle((x1, y1, x2, y2), outline=1, fill=1)
Ellipse: draw.ellipse((x1, y1, x2, y2), outline=1, fill=0)
Polygon: draw.polygon([(x1, y1), (x2, y2), (x3, y3)], outline=1, fill=0)
Die Eckpunkte werden als Array angegeben. (x1, y1) erste Ecke, (x2, y2) zweite Ecke, (x3, y3) dritte Ecke, …
Bogen: draw.arc((x1, y1, x2, y2), α1, α2, fill=1)
α1, α2 stehen für den Startwinkel und den Endwinkel, gerechnet im Uhrzeigersinn, begonnen bei 3:00 Uhr. Der Platzbedarf eines Bogens ist der selbe, wie der einer Ellipse, jedoch wird nur der angegebene Winkel gezeichnet.
Übrigens: mit oled.height und oled.width kann man über die gesamte Bildschirmbreite zeichnen, die Variablen enthalten Angaben zur Höhe und Breite des OLEDs.

Viel Spaß am weiteren Ausbau des Pimoroni-Bausatzes!
Bei Fragen zum Umbau oder zur Modernisierung von Röhrenradios mittels SDR,DAB+,Internetradio,Firmwareentwicklung oder einfach nur Kontakt- bitte Email unter: mbernhard1945(at)gmail(dot)com

mein PGP-Key unter: https://pgp.mit.edu  Keyword: mbernhard1945
Zitieren
#2
Hallo!

Ich habe den Displaycode von oben mal abgeändert. Mit meinem Programm zur Abfrage des Sendernamens und des aktuellen Liedes hat man damit eine schöne selbstaktualisierende Anzeige für das Radio.

Hier der Displaycode.


Code:
#!/usr/bin/env python
# coding=utf-8

# Bibliotheken importieren
from lib_oled96 import ssd1306
from smbus import SMBus
from PIL import ImageFont
import time
import subprocess

# Display einrichten
i2cbus = SMBus(1)            # 0 = Raspberry Pi 1, 1 = Raspberry Pi > 1
oled = ssd1306(i2cbus)

# Ein paar Abk  rzungen, um den Code zu entschlacken
draw = oled.canvas

# Schriftarten festlegen
FreeSans12 = ImageFont.truetype('FreeSans.ttf', 12)
FreeSans14 = ImageFont.truetype('FreeSans.ttf', 14)
FreeSans20 = ImageFont.truetype('FreeSans.ttf', 20)

# Display zum Start l  schen
oled.cls()
oled.display()

title = ""
now = ""

while True:
       old_title = title
       old_now = now

       time.sleep(1)
       title = subprocess.check_output(["./vlc_status.py","title"])
       now = subprocess.check_output(["./vlc_status.py","now"])

       if title != old_title or now != old_now :
               oled.cls()
               draw.text((5,10), title[:16] , font=FreeSans14, fill=1)
               if len(now) < 21:
                       draw.text((5,30), now , font=FreeSans12, fill=1)
               else:
                       draw.text((5,30), now[:21], font=FreeSans12, fill=1)
                       draw.text((5,45), now[21:], font=FreeSans12, fill=1)

       oled.display()
Und so sieht die selbstaktualisierende Anzeige aus.


.jpg   3.jpg (Größe: 32,49 KB / Downloads: 173)
.jpg   2.jpg (Größe: 41,48 KB / Downloads: 173)
.jpg   1.jpg (Größe: 47,11 KB / Downloads: 173)

Beide Programme sind unten als zip-Datei angefügt.

.zip   Display.zip (Größe: 1,82 KB / Downloads: 6)
Zitieren
#3
Hallo Otto, das sind doch schon mal vorzeigbare Resultate. Man könnte deinen "Parser" eventuell direkt in oled.py importieren, dann würde etwas Overhead von subprocess wegfallen weil man direkt auf die Methoden zugreifen kann. Ich habe einen ähnlichen Daemonen geschrieben der die Anzeige ebenso zyklisch aktualisiert, allerdings gehe ich über XML-DOM bei der Auswertung des Requests an cvlc. Mit der sekündlichen Abfrage brauchst Du auch die Programmumschaltung nicht abfangen, das bekommt das Display so mit. Sehr schön gelöst das das Display nur dann aktualisiert wird, wenn sich die Informationsfelder ändern. Dadurch verhinderst Du unnötigen Verkehr auf dem I2C-Bus und ein flackern des Displays. Ich sehe schon ich habe bei Dir den richtigen Nerv getroffen, mach weiter so.
Bei Fragen zum Umbau oder zur Modernisierung von Röhrenradios mittels SDR,DAB+,Internetradio,Firmwareentwicklung oder einfach nur Kontakt- bitte Email unter: mbernhard1945(at)gmail(dot)com

mein PGP-Key unter: https://pgp.mit.edu  Keyword: mbernhard1945
Zitieren
#4
Hallo,
auch ich habe ein kleines Python Script für die Ansteuerung eines I2C OLED
Displays geschrieben.

Im Radiomodus werden Details zum jewels laufenden Stream angezeigt.

.jpg   Radio.jpg (Größe: 85,04 KB / Downloads: 119)

Wenn es keine Stream Daten anzuzeigen gibt (VLC-Player pausiert oder gestoppt),
zeigt das Display Datum und Uhrzeit.

.jpg   VLC_paused.jpg (Größe: 73,16 KB / Downloads: 119)

Alternativ zu beiden Anzeigen, lassen sich per Knopfdruck auch WLAN Parameter
angezeigen.

.jpg   WIFI.jpg (Größe: 78,19 KB / Downloads: 119)

Für die Uschaltung verwende ich den "phatbeat.BTN_ONOFF". Die eigentlich darauf
konfigurierte Shutdown Funktion habe ich auf langen Tastendruck umkonfiguriert.

Über Kommentare, oder Hinweise was ich vielleicht noch optimieren sollte, würde
ich mich freuen.

Gruß aus Kiel
Holger

Hier der Code:
Code:
import time
import subprocess
import urllib2
import base64
import xml.etree.ElementTree as et
import Adafruit_GPIO.SPI as SPI
import Adafruit_SSD1306
from PIL import Image
from PIL import ImageDraw
from PIL import ImageFont
import signal
import phatbeat

# Raspberry Pi pin configuration:
RST = None     # on the PiOLED this pin isnt used

# 128x32 display with hardware I2C:
# disp = Adafruit_SSD1306.SSD1306_128_32(rst=RST)
# 128x64 display with hardware I2C:
disp = Adafruit_SSD1306.SSD1306_128_64(rst=RST)

# Initialize library.
disp.begin()

# Clear display.
disp.clear()
disp.display()

# Create blank image for drawing.
# Make sure to create image with mode '1' for 1-bit color.
width = disp.width
height = disp.height
image = Image.new('1', (width, height))

# Get drawing object to draw on image.
draw = ImageDraw.Draw(image)
# Draw a black filled box to clear the image.
draw.rectangle((0,0,width,height), outline=0, fill=0)

# First define some constants to allow easy resizing of shapes.
padding = -2
top = padding
bottom = height-padding

# Move left to right keeping track of the current x position for drawing shapes.
x = 0

ShowNetParas =0

# Load font.
# font = ImageFont.truetype("/home/pi/Adafruit_Python_SSD1306/examples/Perfect DOS VGA 437.ttf", 15)

# Give vlcd some time to comming up
time.sleep(5)

while True:
   # Switch display mode
   @phatbeat.on(phatbeat.BTN_ONOFF)
   def onoff(pin):
       global ShowNetParas
       if (ShowNetParas):
           ShowNetParas =0
       else:
           ShowNetParas =1

   # Get status.xml from vlc webserver
   username = ""
   password = "raspberry"
   request = urllib2.Request("http://127.0.0.1:8080/requests/status.xml")
   base64string = base64.encodestring('%s:%s' % (username, password)).replace('\n', '')
   request.add_header("Authorization", "Basic %s" % base64string)
   response = urllib2.urlopen(request)
   xml = response.read()
   response.close()
   
   # Draw a black filled box to clear the image.
   draw.rectangle((0,0,width,height), outline=0, fill=0)

   # Extract infos from xml file
   tree =et.fromstring(xml)
   State ="stopped"
   State =tree.find('state').text

   lst =tree.findall('information/category/info')
   Title =" "
   Genre =" "
   Now_playing =" "
   Genre =" "
   Bitrate =" "
   SampleRate =" "
   Channels =" "
   for item in lst:
       if (item.get("name")) =="title":
           Title =((item.text)[0:12])
       elif (item.get("name")) =="now_playing":
   if (item.text):
            Now_playing =((item.text)[0:16])
    # Now_playing =Now_playing.replace('&amp;', '')
       elif (item.get("name")) =="genre":
           Genre =item.text
       elif (item.get("name")) =="Bitrate":
           Bitrate =item.text
       elif (item.get("name")) =="Sample rate":
           SampleRate =item.text
       elif (item.get("name")) =="Channels":
           Channels =item.text

   # Get SSID
   cmd ="iwconfig wlan0|grep ESSID:"
   ssid =subprocess.check_output(cmd, shell =True)
   ssid = ssid[(ssid.find("ESSID:") +7):-4]

   # Get WIFI quality
   cmd ="iwconfig wlan0|grep Link"
   lq_signal =subprocess.check_output(cmd, shell =True)
   linkquality =lq_signal[(lq_signal.find("Quality") +8):(lq_signal.find("Signal") -2)]
   signal =lq_signal[(lq_signal.find("level") +6): -2]
   signal = signal.replace(" ", "")
 
   # Get WIFI bitrate
   cmd ="iwconfig wlan0|grep Rate"
   bitrate =subprocess.check_output(cmd, shell =True)
   bitrate =bitrate[19:(bitrate.find("Tx-Power") -2)]
   bitrate = bitrate.replace(" ", "")

   # Get IP adress
   cmd ="ifconfig wlan0|grep netmask"
   ip =subprocess.check_output(cmd, shell =True)
   ip =ip[13:(ip.find("netmask") -2)]

   # Write to display
   if (ShowNetParas):
       font = ImageFont.truetype("/home/pi/Adafruit_Python_SSD1306/examples/Perfect DOS VGA 437.ttf", 20)
       draw.text((25, top),  ssid,  font=font, fill=255)
       font = ImageFont.truetype("/home/pi/Adafruit_Python_SSD1306/examples/Perfect DOS VGA 437.ttf", 15)
       draw.text((x, top+18),    "IP:"+ip,  font=font, fill=255)
       draw.text((x, top+32),    "Bitrate:"+bitrate,  font=font, fill=255)
       draw.text((x, top+46),    " Q:" +linkquality +" " +signal,  font=font, fill=255)
   elif State == "playing":
       # Write text.
       font = ImageFont.truetype("/home/pi/Adafruit_Python_SSD1306/examples/Perfect DOS VGA 437.ttf", 20)
       draw.text((x, top),   Title,  font=font, fill=255)
       font = ImageFont.truetype("/home/pi/Adafruit_Python_SSD1306/examples/Perfect DOS VGA 437.ttf", 15)
       draw.text((x, top+18),    Now_playing,  font=font, fill=255)
       draw.text((x, top+32),    Genre,  font=font, fill=255)
       draw.text((75, top+32),    Channels,  font=font, fill=255)
       draw.text((x, top+46),    Bitrate.replace(" ", "") +" @" +SampleRate.replace(" ", ""),  font=font, fill=255)
   else:
font = ImageFont.truetype("/home/pi/Adafruit_Python_SSD1306/examples/Perfect DOS VGA 437.ttf", 15)
       draw.text((22, top+18),    time.strftime("%d.%m.%Y", time.localtime()),  font=font, fill=255)
       font = ImageFont.truetype("/home/pi/Adafruit_Python_SSD1306/examples/Perfect DOS VGA 437.ttf",30)
       draw.text((20, top+35),     time.strftime("%H:%M", time.localtime()),  font=font, fill=255)
       font = ImageFont.truetype("/home/pi/Adafruit_Python_SSD1306/examples/Perfect DOS VGA 437.ttf", 15)
       draw.text((20, top),    "VLC " +State,  font=font, fill=255)

   disp.image(image)
   disp.display()
   time.sleep(.5)

Gruß aus Kiel
Holger
Zitieren
#5
Hallo Holger, hallo Otto.

Ich würde die Aufgaben (Tastenabfrage, Displayansteuerung, usw.) nicht alle in ein Thread packen, sondern auf mehrere verteilen, so wie es Pimoroni angefangen hat.
Der Displaythread kümmert sich nur um die Darstellung, ein Thread holt sich nur die Infos von VLC und informiert den Displaythread per Message Queue falls Veränderungen aufgetreten sind, ein Thread kümmert sich nur um die Benutzerschnittstelle (Tasten, Drehregler) und informiert VLC das Änderungen eingetreten sind. Alle anderen Threads werden dann automatisch per Message Queue syncronisiert. Das macht die ganze Sache performanter und leichter zu warten/zu erweitern.

Holger das sieht gut aus auf dem Display, die eigentlich vielen statischen Sachen, nimm Sie raus aus der While-Schleife, die müssen doch nicht bei jeden Durchlauf erneut ausgeführt werden und einen haufen Funktionsaufrufe auslösen. Ich wette der Interpreter optimiert das nicht weg und irgendwann kommen andere Sachen und Erweiterungen die die CPU vielleicht dringend brauchen (DAB+, UKW, KW - SDR generell halt). RAM haben wir ja genug.
Bei Fragen zum Umbau oder zur Modernisierung von Röhrenradios mittels SDR,DAB+,Internetradio,Firmwareentwicklung oder einfach nur Kontakt- bitte Email unter: mbernhard1945(at)gmail(dot)com

mein PGP-Key unter: https://pgp.mit.edu  Keyword: mbernhard1945
Zitieren
#6
Hallo Bernhard,
danke für die Tip's.

Ich habe die Display Ausgabe in einen separaten Thread gepackt und die
while Schleife ein bisschen aufgeräumt.
Ein neues Feature gibt es auch, die bisher auf die Displaybreite verkürzte
Anzeige des aktell laufenden Titels scrollt jetzt in kompletter Länge durch.

Gruß aus Kiel
Holger

Hier der neue Code
Code:
###########################################################
# Display contol for Pimoroni Pirate Radio
# by Holger Krebs
#
# Display: OLED SSD1306
# File: disply.contol.py
# Daze: 13.10.2018
# Version: 2.1
#
###########################################################

import time
import subprocess
import urllib2
import base64
import xml.etree.ElementTree as et
import Adafruit_GPIO.SPI as SPI
import Adafruit_SSD1306
from PIL import Image
from PIL import ImageDraw
from PIL import ImageFont
import signal
import phatbeat
import thread

global State
global Title
global Now_playing
global Genre
global Channels
global Bitrate
global SampleRate
global ShowNetParas
global ssid
global ip
global wifi_linkquality
global wifi_signal
global wifi_bitrate

State =" "
Title =" "
Now_playing =" "
Genre =" "
Channels =" "
Bitrate =" "
SampleRate =" "
ShowNetParas =0
wifi_linkquality =" "
wifi_signal =" "
wifi_bitrate =" "

# Raspberry Pi pin configuration:
RST = None     # on the PiOLED this pin isnt used

# 128x32 display with hardware I2C:
# disp = Adafruit_SSD1306.SSD1306_128_32(rst=RST)
# 128x64 display with hardware I2C:
disp = Adafruit_SSD1306.SSD1306_128_64(rst=RST)

# Initialize library.
disp.begin()

# Clear display.
disp.clear()
disp.display()

# Create blank image for drawing.
# Make sure to create image with mode '1' for 1-bit color.
width = disp.width
height = disp.height
image = Image.new('1', (width, height))

# Get drawing object to draw on image.
draw = ImageDraw.Draw(image)
# Draw a black filled box to clear the image.
draw.rectangle((0,0,width,height), outline=0, fill=0)

# First define some constants to allow easy resizing of shapes.
padding = -2
top = padding
bottom = height-padding

# Move left to right keeping track of the current x position for drawing shapes.
x = 0

# Set fonts
font_DOS_VGA_15 =ImageFont.truetype("/home/pi/Adafruit_Python_SSD1306/fonts/Perfect DOS VGA 437.ttf", 15)
font_DOS_VGA_20 =ImageFont.truetype("/home/pi/Adafruit_Python_SSD1306/fonts/Perfect DOS VGA 437.ttf", 20)
font_DOS_VGA_30 =ImageFont.truetype("/home/pi/Adafruit_Python_SSD1306/fonts/Perfect DOS VGA 437.ttf", 30)

# Give vlcd some time to comming up
time.sleep(5)

# Display control thread
def display_control():
   i =0
   while True:
       # Draw a black filled box to clear the image.
       draw.rectangle((0,0,width,height), outline=0, fill=0)

       if (ShowNetParas):
           draw.text((25, top),  ssid,  font=font_DOS_VGA_20, fill=255)
           draw.text((x, top+18),    "IP:"+ip,  font=font_DOS_VGA_15, fill=255)
           draw.text((x, top+32),    "Bitrate:"+wifi_bitrate,  font=font_DOS_VGA_15, fill=255)
           draw.text((x, top+46),    " Q:" +wifi_linkquality +" " +wifi_signal,  font=font_DOS_VGA_15, fill=255)
       elif State == "playing":
           draw.text((x, top),   Title,  font=font_DOS_VGA_20, fill=255)
           draw.text((x, top+32),    Genre,  font=font_DOS_VGA_15, fill=255)
           draw.text((75, top+32),    Channels,  font=font_DOS_VGA_15, fill=255)
           draw.text((x, top+46),    Bitrate.replace(" ", "") +" @" +SampleRate.replace(" ", ""),  font=font_DOS_VGA_15, fill=255)  
           if (i >len(Now_playing) |(len(Now_playing) <16)):
               i =0
           draw.text((x, top+18),    Now_playing[i:i+16],  font=font_DOS_VGA_15, fill=255)  
           i =i +1
       else:
       draw.text((22, top+18),    time.strftime("%d.%m.%Y", time.localtime()),  font=font_DOS_VGA_15, fill=255)
           draw.text((20, top+35),     time.strftime("%H:%M", time.localtime()),  font=font_DOS_VGA_30, fill=255)
           draw.text((20, top),    "VLC " +State,  font=font_DOS_VGA_15, fill=255)

       time.sleep(.5)
       disp.image(image)
       disp.display()

# Start display tread
thread.start_new_thread(display_control,())

# Get SSID
cmd ="iwconfig wlan0|grep ESSID:"
ssid =subprocess.check_output(cmd, shell =True)
ssid = ssid[(ssid.find("ESSID:") +7):-4]

# Get IP adress
cmd ="ifconfig wlan0|grep netmask"
ip =subprocess.check_output(cmd, shell =True)
ip =ip[13:(ip.find("netmask") -2)]

while True:
    # Switch display mode    
    @phatbeat.on(phatbeat.BTN_ONOFF)
    def onoff(pin):
        global ShowNetParas
        if (ShowNetParas):
            ShowNetParas =0
        else:
            ShowNetParas =1

    # Get status.xml from vlc webserver
    username = ""
    password = "raspberry"
    request = urllib2.Request("http://127.0.0.1:8080/requests/status.xml")
    base64string = base64.encodestring('%s:%s' % (username, password)).replace('\n', '')
    request.add_header("Authorization", "Basic %s" % base64string)
    response = urllib2.urlopen(request)
    xml = response.read()
    response.close()
  
    # Extract infos from xml file
    tree =et.fromstring(xml)
    State ="stopped"
    State =tree.find('state').text

    lst =tree.findall('information/category/info')
    
    for item in lst:
        if (item.get("name")) =="title":
            Title =((item.text)[0:12])
        elif (item.get("name")) =="now_playing":
        if (item.text):
        Now_playing =item.text
            else:
            Now_playing ="                "
        elif (item.get("name")) =="genre":
            Genre =item.text
        elif (item.get("name")) =="Bitrate":
            Bitrate =item.text
        elif (item.get("name")) =="Sample rate":
            SampleRate =item.text
        elif (item.get("name")) =="Channels":
            Channels =item.text

    if (ShowNetParas):
        # Get WIFI quality
        cmd ="iwconfig wlan0|grep Link"
        lq_signal =subprocess.check_output(cmd, shell =True)
        wifi_linkquality =lq_signal[(lq_signal.find("Quality") +8):(lq_signal.find("Signal") -2)]
        wifi_signal =lq_signal[(lq_signal.find("level") +6): -2]
        wifi_signal = wifi_signal.replace(" ", "")
  
        # Get WIFI bitrate
        cmd ="iwconfig wlan0|grep Rate"
        wifi_bitrate =subprocess.check_output(cmd, shell =True)
        wifi_bitrate =wifi_bitrate[19:(wifi_bitrate.find("Tx-Power") -2)]
        wifi_bitrate =wifi_bitrate.replace(" ", "")

    time.sleep(1)
Zitieren


Möglicherweise verwandte Themen...
Thema Verfasser Antworten Ansichten Letzter Beitrag
  Mein Internetradio rotbarth 38 672 Vor 2 Stunden
Letzter Beitrag: OttoBerger
  PIMORONI-Internetradio auf Raspberry Model A/B Bernhard45 20 473 21.10.2018, 21:45
Letzter Beitrag: saarfranzose
  Ein Internetradio Bausatz von PIMORONI Bernhard45 158 3.510 21.10.2018, 18:12
Letzter Beitrag: saarfranzose
  Statische IP-Adresse für Pimoroni Web-Radio HolgerK 2 108 13.10.2018, 13:10
Letzter Beitrag: Bernhard45
  Roary Pimoroni Internet Radio saarfranzose 3 194 23.09.2018, 21:52
Letzter Beitrag: saarfranzose

Gehe zu: