Themabewertung:
  • 1 Bewertung(en) - 5 im Durchschnitt
  • 1
  • 2
  • 3
  • 4
  • 5
Meine Versuche mit Raspberry Pi zum Internetradio
#1
Hallo Radiofreunde!

Im Forum wurde schon einiges zum Internetradio geschrieben.
Vorreiter waren "Vagabund", "Bernhard45" und "Saarfranzose" schon ab 2014, insbesondere auf Basis des Mikrorechners Raspberry Pi (im Folgenden nur mit RPi bezeichnet).
Von "Vagabund":
https://radio-bastler.de/forum/showthrea...=Raspberry
Von "Bernhard45" und "saarfranzose":
https://radio-bastler.de/forum/showthread.php?tid=11484
bis
https://radio-bastler.de/forum/showthrea...484&page=9

Mein Eindruck ist, dass man als Quereinsteiger das von den "Spezialisten" Vorgestellte nur schwer nachvollziehen kann.
Ich möchte hier Wege mit kleinen Schritten aufzeigen, auch wenn das für einige wenige schon "Schnee von Gestern" ist.

Mein Interessengebiet war bisher die Sammlung und Reparatur von Koffer-Radios der 50er und 60er Jahre. Das Internetradio-Gebiet war mir zu "modern".
Da ich jetzt nicht mehr zeitlich eingeschränkt bin, möchte ich es doch einmal mit dieser neuen Technik versuchen.

Der RPi ist eine programmierbare "Allzweckwaffe" als PC, Mediacenter, Steuerungen von externer Technik sowie durch seine einfache Handhabung zu Lehrzwecken.
Er kam als "Pi Zero" ab 2012 auf den Markt und hat sich seitdem in seinen Funktionen, Interface und Betriebssystem weiter entwickelt.
Siehe dazu:
https://de.wikipedia.org/wiki/Raspberry_Pi
Die gegenwärtig letzte Ausführung ist der "RPi 4B". Für meine Versuche habe ich den Vorgänger "RPi 3B+" ausgewählt.
Er ist zwar nicht preiswerter als die modernste Ausführung, ist aber etwas stromsparender und hat alles was man für ein Internetradio und sonstige Versuche benötigt.

Im Elektronik-Kompendium ist das RPi-Thema gut dargestellt
http://www.elektronik-kompendium.de/site.../index.htm
Die Kommandos des RPi sind kurz zusammengestellt zu finden unter:
https://www.cenz.at/various/raspberry_pi...efehle.pdf

Ich habe mir 6 Projektstufen vorgestellt:
1. Den RPi mit peripheren Geräten Tastatur (USB), Maus (USB), Monitor (Ferseher HDMI), Soundverstärker (3,5 mm Klinkenstecker) und WLAN zum Laufen zu bringen
2. Integration eines speziellen RPi-Displays (Touchscreen)
3. Installation spezieller Medienmanagement-Software, Zusammenstellung Internetradio
4. Das Internetradio im Gehäuse
5. Verbindung des RPi mit einem PC über Ethernet oder WLAN zur Fernsteuerung (Remote Desktop) um die Peripherie zu ersetzen.
6. Einige Steuerungen programmieren

Der RPi 3B+ wird bei researchgate.net gut dargestellt:
   
Bild1-01 Aufbau Raspberry Pi 3B+
Rund um die Rechner-IC ist das Interface angeordnet.

1. Für den Einstieg habe ich mir den Kit bestellt:
Raspberry Pi 3 B+ schon mit einem einfachen Gehäuse.


Angeschlossen ergibt sich:  
   
   
Bild1-02, Bild1-03 Versuchsaufbau
Funkmaus, rot (Anschluss links unten), Tastatur (Anschluss links oben), Soundverstärker (Anschluss oben links), Fernseher, HDMI (Anschluss oben Mitte) und die 5 V/2,5 A Betriebspannung (Anschluss rechts oben).

Auf der 16 GB-SDHD-Karte ist das Beginner-Betriebssystem NOOBS installiert.
Nach Zuschalten der Betriebsspannung (Netzstecker) und Boot des Rechners zeigt sich auf dem Fernsehbildschirm ein einfaches Auswahl-Menü.

Jetzt kann auch der Rechner mit dem WLAN verbunden werden; es wird der Zugangskode verlangt.
Das Auswahl-Menü erweitert sich durch mögliche Betriebssysteme.
   
Bild Bild1-04 NOOBS-Menü nach WLAN-Verbindung

Nach Auswahl des Rasbian Full und Start wird das NOOBS mit dem Rasbuin auf der SD überschrieben.

Hat man keine SDHC-Karte mit NOOBS oder es gibt Probleme kann man das Rasbian am PC auf eine SD-Karte bringen und diese in den RPi stecken.
Das Rasbian kann man bei raspberrypi als Zip herunterladen:
https://www.raspberrypi.org/downloads/raspberry-pi-os/
speziell das Paket: Raspberry Pi OS (32-bit) with desktop and recommended software.

Nach Entfaltung (Zip-Funktion bei Windows 10 inklusiv) anschließend mit dem Programm Win32-Disk-Imager:
https://www.chip.de/downloads/  

Das booten dauert ca. 30 s. Es wird dabei ein neues Password (Standard: Raspberry), Zeitzone mit Sprache und der Zugangskode für WLAN mit abgefragt.
WLAN kann man auch noch nachträglich verbinden.

Das war die Installation.   
   
Bild1-05 Startbildschirm
Die Button des PullDown-Menü von links nach rechts: Grundfunktionen, Internet, Datei-Manager, Terminal zur Kommandoeingabe
   
Bild1-06 Die Programmierebene Thonny Python IDE
   
Bild1-07 Der Datei-Manager
   
Bild1-08 Das geöffnete-Terminal-Fenster

Das Hintergrundbild kann man ändern mit Rechtsklick darauf und Auswahl von Desktop-Einstellungen.
Die Hintergrundbilder befinden sich im Verzeichnis usr/share/rpd-wallpaper.
Es können auch neue hinzugefügt werden.

------------------------------------------------------------------------------
2.Integration eines RPi-Touchscreen-Displays
 
Als 5-Zoll-Display habe ich gekauft:
https://www.reichelt.de/raspberry-pi-shi...tlink&&r=1

Es ist der Typ 5inch HDMI LCD V2 800x480 Pixel XPT2046 Touch Controller für RPi.
Das Display soll auch für den RPi 3B+ sein!.

Bevor ich das Display erprobte, habe ich mich schon mit dem Gehäuse beschäftigt (4. Projekt, folgt).
Damit alles seinen Halt hat, habe ich im Bodenteil des Gehäuses die Befestigungen für RPi und Display angebracht.
   
Bild2-01 Einbau im Gehäuseboden
Links liegend Display (Rückseite)
   
Bild2-02 Display auf RPi gesteckt
Das Display steckt direkt auf den ersten 26 GRIPO-Pins und wird über einen HDMI-Doppelstecker mit dem RPi verbunden.
Damit werden 26 Pins des I/O-Ports schon für die Touch-Funktion belegt!

Vor dem Start des Betriebssystems sind einige Einstellungen vorzunehmen:
Ausführlich sind die Einstellungen im Video zu sehen unter (in chinesisch mit englischen Untertiteln):
https://www.waveshare.com/wiki/5inch_HDMI_LCD#Image
und in beschrieben:
https://www.waveshare.com/w/upload/4/4a/...ual_EN.pdf

Am PC ist im Hauptverzeichnis der SDHC-Karte die Datei config.txt mit dem Texteditor zu öffnen und am Ende einzufügen und danach zu speichern:
>>>>>>>>>>>>>>>>>
max_usb_current=1
hdmi_group=2
hdmi_mode=87
hdmi_cvt 800 480 60 6 0 0 0
hdmi_drive=1
<<<<<<<<<<<<<<<<<

Damit bewirkt man die Umleitung der Ausgabe vom Monitor auf das Display; kann auch wieder durch Auskommentieren mit dem Zeichen # rückgängig machen.
 
Es ist die SDHC in den RPi zu stecken, am Display die Hintergrundbeleuchtung Ein schalten und den RPi über die Stromversorgung hochzufahren.
Es wird noch die Lokalisation (Sprache) und ein neues Password verlangt. Kann später auch vor den Schnittstellen-Einstellungen erledigt werde.
Man kann auch noch entscheiden, ob das Betriebssystem aktualisiert werden soll (erfolgt intern mittels update und upgrade).
   
Bild2-03 RPi gestartet

Jetzt gehe ich in die Einstellungen/Raspberry-Pi-Konfiguration/Schnittstellungen des PullDown-Menüs.
An Aktivierungen nehme ich vor:
- für spätere Fernsteuerungen: SSH und VNC
(- SPI für die Touch-Funktion des Displays)

Mit der noch angeschlossenen Tastatur und Maus kann auf der sehr kleinen Bildschirmfläche gearbeitet werde; noch ohne Touchpad.
Ich empfehle, dass schon mit der weiter hinten beschriebenen Fernsteuerung des RPi durch den PC mittels VNC gearbeitet wird (siehe 5. Projekt).

Jetzt sind die Treiber für das Touchpad zu laden.
Es ist im RPi-Menü rechts oben das Terminal zu öffnen und die Linux-Kommandos einzeln einzugeben.
Am PC kann dabei die Window-Kopie-Funktion genutzt werden; am Terminal einfügen über die rechte Maustaste:
>>>>>>>>>>>>>>>>>
git clone https://github.com/waveshare/LCD-show.git
cd LCD-show/
./LCD5-show
<<<<<<<<<<<<<<<<<

Danach startet der RPi neu.

Die Ausrichtung des Bildschirmes kann gesetzt werden mit (0 Grad Drehung):
>>>>>>>>>>>>>>>>>
cd LCD-show/
sudo ./LCD5-show 0
<<<<<<<<<<<<<<<<<

Danach startet der RPi neu.

Installation Kalibrator Tool:
>>>>>>>>>>>>>>>>>
cp LCD-show/xinput-calibrator_0.7.5-1_armhf.deb ~/
sudo dpkg -i -B xinput-calibrator_0.7.5-1_armhf.deb
<<<<<<<<<<<<<<<<<

Installation des Xservice:
>>>>>>>>>>>>>>>>>
sudo apt-get install xserver-xorg-input-evdev
sudo cp -rf /usr/share/X11/xorg.conf.d/10-evdev.conf /usr/share/X11/xorg.conf.d/45-evdev.conf
sudo reboot
<<<<<<<<<<<<<<<<<

Danach startet der RPi neu.

Start Kalibrator und Finish:
>>>>>>>>>>>>>>>>>
DISPLAY=:0.0 xinput_calibrator
<<<<<<<<<<<<<<<<<

Jetzt ist auf dem Display ein Rechteck abzustecken.
Bei mir erfolgte es noch mit der Maus und nicht mit der Touch-Funktion!!

Speichen der Calibration in File:
>>>>>>>>>>>>>>>>>
sudo mkdir /etc/X11/xorg.conf.d
sudo nano /etc/X11/xorg.conf.d/99-calibration.conf
<<<<<<<<<<<<<<<<<

Es öffnet sich die leere Datei; es ist komplett einzufügen:
>>>>>>>>>>>>>>>>>
Section "InputClass"
    Identifier "Calibration"
    MatchProduct "ADS7846 Touchscreen"
    Option "Calibration" "208 3905 288 3910"
    Option "SwapAxesw" "0"
EndSection
<<<<<<<<<<<<<<<<<

Ich habe den mittleren Text mit 4 Leerzeichen eingeschoben.
Diesen Text mit Funktion am unteren Fensterrand bzw. mit Tastenkombination Str + o in Datei 99-calibration.conf speichern.
Wieder in das Terminalfenster mit Str + x

Mit
>>>>>>>>>>>>>>>>>
sudo reboot
<<<<<<<<<<<<<<<<<
ist ein Neustart durchzuführen.

Während des Neustartes wurde bei mir ein langes Listing (Protokoll?) durchgeschoben!
Die Touch-Funktion ist immer noch nicht wirksam!!!.

Beim Herunterfahren wird auch wieder ein Listing angezeigt.
Nach einer Aktivierung des Startbildschirmes in Einstellungen/Raspberry-Pi-Konfiguration
läuft kein Listing mehr.

Auf der oben genannten LCD-Anweisung:
https://www.waveshare.com/wiki/5inch_HDMI_LCD#Image
wird auch am Ende die Einrichtung einer virtuellen Tastatur beschrieben.

Es gibt noch eine 2. Möglichkeit für die Installation der Treiber:
Man kann auch ein Betriebssystem laden, was schon alle Treiber für das Touch Diaplay beinhaltet:
https://drive.google.com/file/d/1cyLR1lP...eFFjU/view
Es ist mit 7z verpackt; bei Bedarf muss dieses Programm noch installiert werden.
Auch diese Möglichkeit führte bei mir noch nicht zu einer funktionierenden Touch-Funktion!!

Dieses Betriebssystem ladet nicht nur die Display-Treiber, sondern auch viele zusätzliche Programme.
   
   
   
   
Bild2-10, Bild2-11, Bild2-12, Bild2-13 Zusätzliche Programme

Das verwendete Display kam schon 2015 auf den Markt und war ursprünglich auch für den Pi 3 vorgesehen.
Der Pi 3B+ kam erst später und hatte u.a. einen höheren CPU-Takt!
Könnte das ein Problem sein?

Auch vorerst ohne Touch-Funktion, nur mit kleiner Funkmaus, kann das Projekt weiter verfolgt werden.

Fortsetzung folgt!
Zitieren
#2
Danke, Georg,
bisher alles sehr übersichtlich erklärt. ich lese spannend weiter. Thumbs_up
Gruß!
Ivan
Zitieren
#3
Hallo Radiofreunde!
Fortsetzung der Internetradio-Projekte

3. Installation spezieller Medienmanagement-Software
Noch ohne die Touch-Funktion habe ich das Projekt Internetradio weiter verfolgt.
Mit der Funkmaus anstelle der Touch-Funktion kann man bis auf weiteres auch gut arbeiten.

Mein Projekt setzt auf die Anleitung:
https://www.reichelt.de/magazin/how-to/k...rnetradio/

.png   Bild3-01.png (Größe: 8,4 KB / Downloads: 458)
Bild3-01 Das Projekt KODI

Es wird mit dem Programmpaket KODI gearbeitet, eine kostenlose Media-Center-Software, auch für den Raspberry Pi.
KODI wird im RPi-Terminalfenster installiert mit:
>>>>>>>>>>>>>>>>>
sudo apt-get install kodi
sudo reboot
<<<<<<<<<<<<<<<<<
Anschließend erfolgt in der RPi-Ebene nur noch eine Skalierung der KODI-Fenster
über die Datei .kodi/userdata/advancedsettings.xml

Nach Neustart des RPi ist KODI verfügbar.

Da die Installationen und Einstellungen von KODI nicht über die Fernwartung, z.B. VNC (Fernwartung siehe weiter hinten) vorgenommen werden können
habe ich die RPi-Grundkonfiguration, d.h. mit Tastatur, Maus und HDMI-Monitor gewählt.
   
Bild3-11 RPi mit Grundkonfiguration
Dazu muss die Umleitung des Bildes vom Display zum Monitor erfolgen und danach wieder rückgängig gemacht werden:
Am PC ist im Hauptverzeichnis der SDHC-Karte die Datei config.txt mit dem Texteditor zu öffnen und am Ende stehenden Kommandos mit dem Vorzeichen # zu versehen und danach zu speichern:
>>>>>>>>>>>>>>>>>
# max_usb_current=1
# hdmi_group=2
# hdmi_mode=87
# hdmi_cvt 800 480 60 6 0 0 0
# hdmi_drive=1
<<<<<<<<<<<<<<<<<
Bei Verwendung des Displays ist dies wieder rückgängig zu machen.

Die Radiosender-Sammlungen werden als AddOn angeboten.
   
   
   
   
Bild3-02, Bild3-03, Bild3-04,Bild3-05 Programmpakete

Ich habe mich (wie in der Anleitung) für das AddOn Radio.de entschieden. Es beinhaltet 30.000 internationale Radio-Sender, die in Verzeichnissen abgelegt sind, z.B. "Sender in ihrer Nähe" usw.
   
Bild3-06 Das AddOn radio.de

Es gibt auch die Funktion "Sender-Suche" mittels Virtueller Tastatur und mittels rechter Maus-Taste die Abspeicherung des ausgewählten Senders in das Verzeichnis "Meine Sender".
Es können auch Sender nach vorherrschender Musikrichtung, wie Classic, Country ausgewählt werden.
   
Bild3-07 Sender in Thüringen am Monitor
   
Bild3-08 Sender in Thüringen später auf dem Display
   
Bild3-09 Mein Lieblingssender mdr Thüringen Erfurt am Monitor
   
Bild3-10 Mein Lieblingssender mdr Thüringen Erfurt später auf dem Display
Am unteren Bildrand Mitte kann man die Sender in der Senderliste, z.B. "Meine Sender" weiter und zurück wählen.
Darüber wird der Sendername und bei Musik der Song-Name angezeigt.

Es ist auch möglich einen ausgewählten Sender beim Aufruf des KODI direkt zu Starten oder sogar beim Start des RPi.

KODI ermöglicht u.a. auch das Abspielen von Videos oder Musiktitel.

-------------------------------------------------------------------------------
4. Konstruktiver Aufbau des Internetradios

Das Gehäuse eines kleinen Internet-Radios sollte sich von den der herkömmlichen Koffer-Radios unterscheiden.
Da sich die Bedienelemente, insbesondere der Bildschirm auf der Frontseite befindet
und sich dieser wegen des Lichteinfalls und guten Lesbarkeit ist dieser vorteilhaft leicht schräg anzuordnen.
Mir fielen gleich die ersten Tischrechner ein. Die Tastatur ist leicht geneigt und das Zahlen-Display etwas stärker.
In meinem Antik-Reserven war auch ein Olympia CD 402 bzw. auch von 1977. Im Internet werden solche Antik-Geräte noch für ca. 50 EUR verkauft.
   
Bild4-01 Tischrechner Olympia CD 402

Ich will nur das formschöne Gehäuse benutzen.
Im Inneren soll es einen Raspberry Pi 3 B+ für Versuche zur Steuerungen externer Geräte
bzw. in Verbindung mit dem 5" Touchscreen ein Internet-Radio beherbergen.

Die Audio-Ausgabe realisiere ich mit einem System, was für die analoge Verstärkung des Tonsignales und Ausgabe auf 2 Kleinlautsprechern des Tonsignales eines PC's entwickelt wurde.
Das elektrische System wurde entkernt und ohne Netzteil in das Internet-Radio-Gehäuse installiert.
Der Soundverstärker wird mit 5 V aus dem Netzteil des RPI gespeist. Er zieht weniger als 20 mA. Es kann also nicht kritisch werden bezüglich des Gesamtstromverbrauch.
Für den eingesetzten RPi und Display wird ein Strom von bis 2.5 A angegeben.

Für den portablen Betrieb gibt es Möglichkeiten:
Mit 6x NiMH AA Akkus erhält man 7,2 V mit ca. 2,5 Ah. Um die erforderlichen 5 V zu erreichen kann man einen Linearspannungsregler 7805 einsetzen. Wir haben aber eine Verlustleistung von ca. 3 W, was für ca. 1 Stunde Laufleistung nicht vertretbar wäre.
Auf dem Markt angebotene Power-Banks mit über 10.000 mAh gibt es schon für unter 20 EUR.
Powerbanks mit nur um 2.000 mAh habe ich ausprobiert; schon beim Hochfahren des RPi zeigt er Spannungsprobleme an.
Ich habe also vorerst nur den Netzbetrieb realisiert.
   
Bild4-02 Innenaufbau des Radios
- Oben links der Lautsprecher
- Oben rechts mittig der Audio-Verstärker
- Mitte links der RPi
   
Bild4-03 Innenaufbau mit Display
- Unten links das Display auf den RPi gesteckt
   
   
   
   
Bild4-04, Bild4-05, Bild4-06, Bild4-07 Ansichten von Außen
Der Lautstärkeregler des Audio-Verstärkers befindet sich an der rechten Seitenwand; der Ein/Aus Schalter oben rechts.

Fortsetzung folgt!
Zitieren
#4
Hallo Georg,

gefällt mir sehr, ein altes Tischrechnergehäuse zu verwenden.

Wer keines hat, findet da was passendes bei Bahar Enclosure z.B. bei der BDC-Serie

https://bahar-enclosure.com/products/des...dc-series/

Es gibt eine deutsche Niederlassung und die Gehäuse werden über Amazon u.a. sehr preiswert angeboten.

Gruß

(Reflex-)Kalle
Zitieren
#5
Hallo Radiofreunde!
Fortsetzung der Internetradio-Projekte

5. Zum besserem Service in der Entwicklungsphase versuche ich den RPi direkt mit einen PC (Laptop) über Ethernet-Netzwerkkabel bzw. WLAN zu verbinden und fernzusteuern.

Durch die geringe Größe des 5-Zoll-Display und dem noch kleinerem Terminal-Fenster für Lunix-Kommandos gibt es Probleme beim Installieren von Anwendungen und Einstellungen.
Auch der Wegfall von Tastatur und Maus am RPi ist das Ziel.

Möglichkeit 1:
Eine praktikable Möglichkeit für den Zugriff vom PC auf den RPi besteht über RDP (Remote Desktop Protocol).

Am RPi ist dafür an einem Terminal-Fenster einzugeben:
>>>>>>>>>>>>>>>>>
sudo apt-get update
sudo apt-get install xrdp
<<<<<<<<<<<<<<<<<

Damit wird der xRDP-Service installiert und wird nach einem Boot wirksam.
Jetzt muss noch die IP-Adresse des RPi erkundet werden:
>>>>>>>>>>>>>>>>>
ifconfig
<<<<<<<<<<<<<<<<<

Wenn der RPi mit dem WLAN verbunden ist, so ist die IP-Adresse unter wlan0 inet addr xxx.xxx.x.xx zu finden.

Die Realisierung eines Remotezugriffes (Remote Desktop) am PC unter Windows 10 ist nur bei der Windows-Version 10 Pro und nicht im vorinstallierten Home möglich.

Möglichkeit 2:
Eine Alternative ist z.B. das Programm TeamViewer, was für den privaten Gebrauch kostenlos ist.

Beim Hersteller gibt es Hinweise und Downloads bezüglich RPi allgemein ---> Voraussetzungen ---> Installation:
https://www.teamviewer.com/de/loesungen/...pberry-pi/
   
Bild5-01 Start TeamView am PC
Es wird hier schon die TeamView-ID des PC angezeigt, was aber nicht die offizielle des Gerätes ist. Die TeamView-ID des RPi ist in diesem Zustand noch nicht eingetragen.

Möglichkeit 3:
Eine nicht grafische Oberfläche von der PC-Tastatur zum Terminal des RPi kann über PuTTY/SSH hergestellt werden.
Damit können umfangreiche Steuersequenzen oder Programmier-Zeilen auch über die Window-Funktion Kopieren (Markieren, Str + c) und Einfügen (rechte Maus-Taste) übertragen werden.

Am RPi ist über das Einstellungs-Menü, Schnittstelle SSH zu aktivieren und den RPi neu zu starten.

Am PC ist PuTTY zu installieren, download über:
https://www.chiark.greenend.org.uk/~sgta...atest.html
gleich mit dem ersten Link:  putty-0.74-installer.msi

Die Bedienung des PuTTY auch für RPi-Zwecke ist gut beschrieben in:
https://bits-meet-bytes.de/kleine-putty-...insteiger/
und
https://bits-meet-bytes.de/einsteigertip...anfaenger/

.jpg   Bild5-02.jpg (Größe: 78,59 KB / Downloads: 374)
Bild5-02 Start Fernwartung mittels PuTTY

Möglichkeit 4:
Fernwartung des RPi mittels VNC (grafische Oberfläche)
Die Installation des VNC-Zugriffes ist hier beschrieben:
https://www.tutonaut.de/anleitung-raspbe...rnsteuern/

Zuerst ist der REALVNC-Server am RPi über Einstellungen/Schnittstellen zu aktivieren.

Danach ist der VNC-Client (Viewer!) für Windows 10 am PC herunter zu laden bei:
https://www.computerbild.de/download/VNC...09724.html

Beim Start des VNC-Dienstes am PC ist die ID des RPi einzugeben.

.jpg   Bild5-03.jpg (Größe: 46 KB / Downloads: 374)
Bild5-03 Start Fernwartung mittels VNC-Dienst

Am PC erscheint ein Bild mit der Oberfläche des RPi, aber nur mit der Auflösung des dort installierten Displays.
Für umfangreiche Arbeiten mit dieser Methode kann auch die Auflösung pernament höher eingestellt werden.
   
Bild5-04 Abbildung der RPi-Oberfläche auf dem PC-Bildschirm mit deren Tastatur- und Maus-Funktion

Unterprozesse am RPi, z.B. Arbeiten mit KODI können nicht dargestellt werden.

----------------------------------------------------------------------------------------------
6. Einige Steuerungen Programmieren

GPIO ist die Abkürzung für General Purpose Input Output. Man bezeichnet damit programmierbare Ein- und Ausgänge für allgemeine Zwecke. Die GPIOs werden als Pin in Form einer Stiftleiste herausgeführt und dienen als Schnittstelle zu anderen Systemen, um diese über den Raspberry Pi zu steuern.
Dabei kann der Raspberry Pi bei entsprechender Programmierung digitale Signale von außen annehmen (Input) oder Signale nach außen abgeben (Output).
https://www.elektronik-kompendium.de/sit...002191.htm

Viele der GPIOs erfüllen je nach Einstellung und Programmierung verschiedene Funktionen. Neben den typischen GPIO-Ein- oder Ausgängen finden sich aber auch Pins mit der Doppelfunktion für I2C, SPI und eine serielle Schnittstelle.
Alle GRIPO-Pins vertragen nur maximal 3,3V.
Es sind bestimmt schon viele Raspberry Pis gestorben, weil GPIO-Pins nicht korrekt verschaltet wurden. Ein einzelner GPIO-Pin liefert höchstens 16 mA. Alle GPIO-Pins zusammen höchstens 50 mA.
Geht man beim Modell B+ von 40 GPIO-Pins aus, von denen aber nur 26 Stück als Ein- oder Ausgänge beschaltet werden können, dann liegt der Strom, den man aus einem GPIO-Pin ziehen darf, wenn man alle gleichzeitig als Ausgang nutzt, bei unter 2 mA.
Da man nicht alle Pins gleichzeitig als Ausgang nutzen wird, sollte die Stromentnahme pro Pin nicht höher als 3 bis 5 mA liegen.
Vor Anschluss eines Boards an den RPi sollte die Schaltung elektrisch geprüft sein.
Alle Pins, welche „GPIO“ im Namen haben, können programmiert werden. Darüber hinaus gibt es noch „Ground“ (=Masseanschluss) und die Spannungspins (3.3V und 5V).
Einigen "GPIO" können durch Laden von Programm-Modulen speziellen Funktionen zugeordnet werden.

.jpg   Bild6-01.jpg (Größe: 83,89 KB / Downloads: 374)
Bild6-01 PIO-Belegung

Diese "GPIO" können im Programm nach Vereinbarung mit ihren Namen oder Pin-Nr. angesprochen werden.

Zuerst möchte ich ein einfaches Beispiel aufbauen.
Zu empfehlen ist dafür der Lehrgangabschnitt:
https://tutorials-raspberrypi.de/ampelsc...io-teil-1/
aus der Serie:
https://tutorials-raspberrypi.de/raspber...tarte-ich/

Die bei https://tutorials-raspberrypi.de gezeigten Bilder stellen nicht die reale Schaltung dar, sondern sind nur mit dem Programm "frizing" gezeichnet und können schon einige Fehler enthalten!

Ich beginne mit 2x LED, die von je 2 Transistoren gesteuert werden. Ein Python-Programm soll diese zum Blinken bringen, derart, dass 1 LED 10x blinkt und dann das andere.
   
Bild6-02 Schaltbild Experiment 1

Es wird ein Experimentier-Board und Leitungen (Buchse/Stecker) benötigt (Reichelt).
   
Bild6-03 Aufbau Experiment 1

Das Board ist so aufgebaut, dass alle am oberen und unteren Rand befindlichen waagerechten Steckbuchsenfelder horizontal verbunden sind. Sie eignen sich gut für die Versorgungsspannungen, z.B. ganz unten GND, darüber +3,3V.
Die Steckbuchsenfelder im mittleren Bereich sind je 5 Stück senkrecht verbunden.

Das Skript wird z.B. bei dem RPi 3B+ mit dem Programm Tonny-Python (Python 3) erstellt, was oben im PullDown-Menü zu finden ist.
Die Grundregeln für das Programmieren mit Python sind zu finden (mit Fortsetzungen):
https://tutorials-raspberrypi.de/program...nfuehrung/
oder hier:
https://www.codeflow.site/de/article/python-thonny

Zuerst wird aus dem Dateimanager mit der rechten Maustaste über dem leeren rechten Bereich eine neue Datei mit z.B. den Namen prog1.py erstellt.
Im Python Fenster wird diese noch leere Datei geöffnet.
Mit den #-Zeichen beginnt immer ein Kommentar
>>>>>>>>>>>>>>>>>
#Bibliotheken einbinden
#GPIO
import RPi.GPIO as GPIO
#Zeit-Funktion
import time

#GPIO Modus (Anschlussdefinition Pin von BOARD oder von GPIO(BCM))
GPIO.setmode(GPIO.BOARD)
 
#BOARD-Pins festlegen RPI-Ausgang fuer 1.LED
GPIO.setup(24, GPIO.OUT)
#BOARD-Pins festlegen RPI-Ausgang fuer 1.LED
GPIO.setup(24, GPIO.OUT)

#unendliche Schleife
while True:
    #Schleife fur 1.LED
    #10x Blinken
    zahl = 0
    for zahl in range(10):
        #Pin 24 HIGH Pegel
        GPIO.output(24, True)       
        #eine halbe Sekunde warten
        time.sleep(0.5)
        #Pin 24 LOW Pegel
        GPIO.output(24, False)
        #eine halbe Sekunde warten
        time.sleep(0.5)
    #Schleife fur 2.LED
    #10x Blinken
    zahl = 0
    for zahl in range(10):  
        #Pin 26 HIGH Pegel
        GPIO.output(26, True)
        #eine halbe Sekunde warten
        time.sleep(0.5)
        #Pin 26 LOW Pegel
        GPIO.output(26, False)
        #eine halbe Sekunde warten
        time.sleep(0.5)
<<<<<<<<<<<<<<<<<
#Abbruch mit Taste STRG + C

Beim Erstellen des Skripts ist zu beachten, dass ein Tabulator = 4 Leerzeichen entspricht.
Eine Anweisung gilt immer für folgende gleich weit eingerückte Anweisungen.

Gestartet wird das Programm im Python-Editor oder im Terminal-Fenster mit:
>>>>>>>>>>>>>>>>>
sudo  python prog1.py
<<<<<<<<<<<<<<<<<
   
Bild6-04 Ansteuerung Experiment 1

Fortsetzung folgt!
Zitieren
#6
Hallo Radiofreunde!
Fortsetzung der Internetradio-Projekte, Steuerungen programmieren

Für ein etwas komplizierteres Steuerungs-Experiment habe ich mir ein Display mit je 20 Zeichen in 4 Zeilen auf Basis des Controllers HD44780 gekauft.
Diese Displays haben normal 16 Pins. Verwendet man zur Ansteuerung einen I2C-Konverter, so hat dieser nur noch 4 Anschlüsse für den RPi; es können so viele GPIO-Ports für andere Zwecke genutzt werden.
Mein Display hat schon den I2C-Konverter auf der Display-Rückseite montiert.

Hier ist die prinzipielle Anwendung gut beschrieben:
http://www.netzmafia.de/skripten/hardwar...index.html

Der I2C-Bus stellt eine Schnittstelle des Raspberry Pi dar.
I2C steht für Inter-Integrated Circuit und verwendet nur
zwei Drähte (neben der Spannungsversorgung). Die benötigten Anschlüsse am Raspberry Pi sind der Pin 3 SDA und
der Pin 5 SCL.

Der I2C-Bus verwendet in der Regel Open-Collector-Eingänge. Das bedeutet, dass
die entsprechenden I2C-Bausteine keinen eigenen Spannungspegel an ihren I2C-Pins
führen. Die SDA- und SCL-Pins des Raspberry Pi werden durch interne Pullup-
Widerstände auf ein 3,3-V-Level gezogen. Die Busteilnehmer schalten bei der
Kommunikation diesen Pegel lediglich gegen Masse.

Wenn man die Möglichkeit hat, den I2C-Baustein mit +3,3V zu versorgen, sollte man diese Nutzen.
Dies minimiert das Risiko, den Raspberry Pi zu beschädigen.

Eine gute Anweisung gibt es hier:
https://tutorials-raspberrypi.de/hd44780...ansteuern/

Gleichwertig sind die Anweisungen des Herstellers JOY-It:
https://www.reichelt.de/entwicklerboards...dr::242692
Speziell unter Datenblätter: Anleitung LCD20x4_ANL.pdf

Anschlüsse:
Raspberry Pi PIN        I2C LCD PIN
-----------------------------------
PIN 3 (BCM 2/ DA)           SDA
PIN 4 (5v Power)            VCC
PIN 5 (BCM 3/SCL)           SCL
PIN 6 (Ground)              GND

Unter Einstellungen/Raspberry-Pi-Konfiguration/Schnittstellen ist jetzt auch I2C zu aktivieren.

Installation der Bibliotheken GRIPO und Python am Terminal:
>>>>>>>>>>>>>>>>>
sudo apt-get install python-pip python-dev build-essential
sudo pip install RPi.GPIO
sudo apt-get install python-imaging
<<<<<<<<<<<<<<<<<

Installation der I2C-Tools:
>>>>>>>>>>>>>>>>>
sudo apt-get install python-smbus i2c-tools
<<<<<<<<<<<<<<<<<

Jetzt Freischaltung von I2C.
Bei älteren RPi bzw. Rasbian erfolgt dies über:
>>>>>>>>>>>>>>>>>
sudo raspi-config
<<<<<<<<<<<<<<<<<

und Auswahl der "Advanced Options", danach der Punkt I2C.
Bei meiner neueren Version von RPi bzw. Rasbian erfolgt dies in 2 Schritten:
- Am RPi ist über das Einstellungs-Menü (PullDown-Menü Einstellungen/Raspberry-Pi-Einstellungen/Schnittstellen) I2C zu aktivieren.
- Öffnen der Datei config.txt auf der Rasbian-SD-Karte am Computer (notwendige Rechte vorhanden) und
  Einfügen (evtl. # Zeichen am Zeilenbeginn entfernen), anschließend speichern und zurück in den RPi:
>>>>>>>>>>>>>>>>>
  dtparam=i2c1=on
  dtparam=i2c_arm=on
<<<<<<<<<<<<<<<<<

Anschließend müssen noch Einträge zur Modul-Datei hinzugefügt werden.Öffnen Sie dazu die Modul-Datei
>>>>>>>>>>>>>>>>>
sudo nano /etc/modules
<<<<<<<<<<<<<<<<<

Fügen Sie ans Ende dieser Datei folgende Zeilen und speichern der Datei.
>>>>>>>>>>>>>>>>>
i2c-bcm2708
i2c-dev
<<<<<<<<<<<<<<<<<

Neustart:
>>>>>>>>>>>>>>>>>
sudo reboot
<<<<<<<<<<<<<<<<<
 
Um eine Möglichst einfache Anwendung zu ermöglichen, wird im Folgenden auf einen Code von Tutorials-Raspberrypi zurückgegriffen
>>>>>>>>>>>>>>>>>
mkdir I2C-LCD && cd I2C-LCD
wget http://tutorials-raspberrypi.de/wp-conte...80_i2c.zip
unzip hd44780_i2c.zip
<<<<<<<<<<<<<<<<<

Als nächstes muss das Display, insofern es bereits angeschlossen wurde, angesprochen werden
>>>>>>>>>>>>>>>>>
sudo i2cdetect -y 1
<<<<<<<<<<<<<<<<<

Ausgabe im Terminal-Fenster:
     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
00:          -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- 27 -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --

Falls du hier eine andere Zahl als 27 angezeigt bekommst, musst du dann nach dem unzip xxx in der lcddriver.py Datei ändern (ADDRESS = 0x27):
>>>>>>>>>>>>>>>>>
sudo nano lcddriver.py
<<<<<<<<<<<<<<<<<

Die auszuführende Datei kann erzeugt werden im Dateimanager im Verzeichnis /I2C-LCD mit der rechten Maustaste über den leeren rechten Bereich eine neue Datei mit z.B. den Namen prog2.py erstellen.
Im Python Fenster wird diese noch leere Datei geöffnet.

Wenn im Terminal die auszuführende Datei erstellt werden soll:
>>>>>>>>>>>>>>>>>
sudo nano prog2.py
<<<<<<<<<<<<<<<<<

Anzeigeprogramm prog2.py der 4 Zeilen:
>>>>>>>>>>>>>>>>>
import lcddriver
import time

lcd = lcddriver.lcd()
lcd.lcd_clear()
#Laufende Wiederholung der Schleife
while True:
    zahl = 0
    #Schleife 10x
    for zahl in range(10):
        #Ausgabe in jeder Zeile
        lcd.lcd_display_string("Wir testen          ", 1)
        lcd.lcd_display_string("das 20x4-Display", 2)
        lcd.lcd_display_string("am I2C-Bus", 3)
        lcd.lcd_display_string("des Raspberry Pi 3B+", 4)
        time.sleep(2)
        #Löschen jeder Zeile
        lcd.lcd_display_string("                    ", 1)
        lcd.lcd_display_string("                    ", 2)
        lcd.lcd_display_string("                    ", 3)
        lcd.lcd_display_string("                    ", 4)
        time.sleep(2)
<<<<<<<<<<<<<<<<<
#Abbruch mit Taste STRG + C

Gespeichert wird als prog2.py im Verzeichnis /I2C-LCD

Start aus Python-Editor oder aus dem Terminal-Fenster mit:
>>>>>>>>>>>>>>>>>
sudo python prog2.py
<<<<<<<<<<<<<<<<<
   
Bild6-05 Ansteuerung Experiment 2

Falls nichts angezeigt werden sollte könnte die Helligkeit des Displays zu gering sein. Am Display bzw. Konverter ist dafür ein Einstellregler.
Ursache für die verminderte Helligkeit könnte die herabgesetzte Betriebsspannung von 5V auf 3,3V sein.
-----------------------------------------------

Wir erweitern das Projektes durch eine laufende Schrift.

Aktuelles Programm prog3_1 für Ausgabe nur in erster Zeile des Displays im Python-Editor geschrieben:
>>>>>>>>>>>>>>>>>
import lcddriver
import time

lcd = lcddriver.lcd()
lcd.lcd_clear()
text = "Es lebe der 1.Mai, der Kampftag der Arbeiter aller Laender!"

#Laufende Wiederholung der Schleife
while True:
    #Beginn mit -1
    n = 0-1
    #Schleife 60x
    for zahl in range(0,60):
        #Verschiebung des Textanfangs
        n = n +1
        m = n + 19

        #es wird der anzuzeigende Text-String für eine Zeile entnommen
        text[n:m]

        #Anzeige des Textes
        lcd.lcd_display_string(text[n:m], 1)

        #warten 0.4 sec
        time.sleep(0.4)

        #Löschen aller Zeilen des Displays
        lcd.lcd_clear()
<<<<<<<<<<<<<<<<<
#Abbruch mit Taste STRG + C
   
Bild6-06 Python-Programm für Experiment 3-1
   
Bild6-07 Beginn 1. Zeile
   
Bild6-08 Text 1 Zeichen nach links gerückt

Nächstes Programm prog3_2 für Ausgabe über 4 Zeilen:
>>>>>>>>>>>>>>>>>
import lcddriver
import time

lcd = lcddriver.lcd()
lcd.lcd_clear()
text = "Es lebe der 1.Mai, der Kampftag der Arbeiter aller Laender!"

while True:
    n = 0-1
    for zahl in range(0,60):
        n = n +1
        m = n + 19
        text[n:m]
        #Anzeige des Textes in der 1. Zeile
        lcd.lcd_display_string(text[n:m], 1)
        #in den Zeilen 2-4 wird der Folge-Text-String angezeigt
        lcd.lcd_display_string(text[n+19:m+19], 2)
        lcd.lcd_display_string(text[n+38:m+38], 3)
        lcd.lcd_display_string(text[n+57:m+57], 4)
        #warten 0,1 sec
        time.sleep(0.1)
<<<<<<<<<<<<<<<<<
#Abbruch mit Taste STRG + C


Probiert es doch auch einmal aus!
Gruß Georg
Zitieren
#7
Hallo Radiofreunde!

Im vorn vorgestellten Internetradio-Projekt gab es ja noch das Problem, dass die Touch-Funktion für das Display nicht installiert werden konnte.
Als meine Versuche, auch mit anderen Treibern, keinen Erfolg brachten, habe ich "tief in die Taschen gegriffen" und mir ein fast baugleiches
Display der gleichen Firma WaveShare 5inch HDMI LCD 800x480 (B) geleistet.
   
Bild 7-1 vorher 5inch-HDMI-LCD-V2

   
Bild 7-2 jetzt  5inch-HDMI-LCD-(B)
Gekauft bei
https://www.amazon.de/dp/B071Y3NWCK/ref=...UTF8&psc=1
Es ist ein chinesischer Händler mit Lager in der Nähe(?); die Ware war in 2 Tagen eingetroffen.

Die Installationsanweisung ist hier:
https://www.waveshare.com/wiki/5inch_HDMI_LCD_(B)

Die Touch-Funktion wird nicht mehr über GPIO gesteuert, sondern über einen zusätzlichen USB-Anschluss.
Dies verringert das Problem der Treiber-Installation.
Das Display ist nur noch zu kalibrieren.
Ein weiterer Vorteil ist, dass alle GPIO-Kontakte für Steuerungen noch frei verfügbar sind.
Nachteilig ist die separate Verkabelung der HDMI- und USB-Anschlüsse.

Installation des Xservice, wie oben:
>>>>>>>>>>>>>>>>>
sudo apt-get install xserver-xorg-input-evdev
sudo cp -rf /usr/share/X11/xorg.conf.d/10-evdev.conf /usr/share/X11/xorg.conf.d/45-evdev.conf
sudo reboot
<<<<<<<<<<<<<<<<<

Danach startet der RPi neu.

Installation des xinput-Kalibrators:
>>>>>>>>>>>>>>>>>
sudo apt-get install -y xinput-calibrator
<<<<<<<<<<<<<<<<<

Start Kalibrator über das Pull-Down-Menü unter Einstellungen/Touchscreen-Kalibrieren  
oder über das Terminal mit:
>>>>>>>>>>>>>>>>>
sudo DISPLAY=:0.0 xinput_calibrator
<<<<<<<<<<<<<<<<<

Jetzt ist auf dem Display ein Rechteck auf den roten Kreuzen abzustecken.
Nach Ablauf der verfügbaren Zeit werden die ermittelten Positionen
korrekter Weise in der unten angegebenen Form ausgegeben. Dies wird jetzt gespeichert.
Öffnen der config-Datei mit:
>>>>>>>>>>>>>>>>>
sudo nano /usr/share/X11/xorg.conf.d/40-libinput.conf
<<<<<<<<<<<<<<<<<

In die geöffnete Datei ist am Ende der zuvor ausgegebene Text einzufügen.
>>>>>>>>>>>>>>>>>
Section "InputClass"
    Identifier "Calibration"
    MatchProduct "WaveShare WS170120"
    Option "Calibration" "229 3884 368 3974"  
    Option "SwapAxesw" "0"
EndSection
<<<<<<<<<<<<<<<<<

Mit
>>>>>>>>>>>>>>>>>
sudo reboot
<<<<<<<<<<<<<<<<<
ist ein Neustart durchzuführen.

Die Touch-Funktion ist verfügbar!
Die Kalibrierung sollte noch optimiert werden.
   
Bild7-03 Installation des neuen Displays

-----------------------------
Unter KODI ist zwar auch die Touch-Funktion verfügbar,
sie muss aber noch kalibriert werden mit dem Kommando:
>>>>>>>>>>>>>>>>>
nano .kodi/userdata/advancedsettings.xml
<<<<<<<<<<<<<<<<<
Es wird eine leere Datei geöffnet.
In diese werden vorerst Erfahrungswerte eingefügt und gespeichert:
>>>>>>>>>>>>>>>>>
<advancedsettings>
<touchscreen>
<x_offset> -42 </x_offset>
<y_offset> -36.16 </y_offset>
<x_stretch_factor> 0.21639 </x_stretch_factor>
<y_stretch_factor> 0.1325 </y_stretch_factor>
<touch_mouse>0</touch_mouse>
<touch_confines>8</touch_confines>
</touchscreen>
</advancedsettings>
<<<<<<<<<<<<<<<<<

Nach Neustart von KODI erfasst die Touch-Funktion bei mir nicht die obere Zeile in der Display-Ansicht.

In:
https://forum.kodi.tv/showthread.php?tid...pid2721769
ist folgende Berechnung angeführt:
Wenn Ihr Bildschirm kalibriert ist, können Sie die Faktoren für Kodi berechnen,
indem Sie die Min- und Max-Werte für jede Achse aus der Datei 40-libinput.conf verwenden, z. B.:
xmin = 229, xmax = 3884, ymin = 368, ymax = 3974

Berechnung:
Es ist die Auflösung des Displays : W = 800, H = 480

Bei mir sind xmin = 229, xmax = 3884, ymin = 368, ymax = 3974

Berechnungsformel:
x_stretch_factor = W / (xmax-xmin)
x_offset = xmin * xstretch
y_stretch_factor = H / (ymax-ymin)
y_offset = ymin * ystretch

Mein Ergebnis: x_stretch_factor> 0.2188
               x_offset> 50.10
               y_stretch_factor> 0.1341
               y_offset> 49.3

Diese Werte werden in die oben erstellten Datei advancedsettings.xml eingetragen.

----------------------------------------------
Neues Projekt für die Anzeige des Datums und der Zeit

Es soll das 20x4 Display zur Anzeige von Datum und Zeit mit in das Radio-Gehäuse eingebaut werden.
   
Bild7-04 Installation des 20x4-Displays
Es musste auch der Lautsprecher etwas nach rechts verschoben werden.
 
Das Anzeigeprogramm für das 20x4-Display zeitanzeige.py enthält jetzt:
>>>>>>>>>>>>>>>>>
#!/usr/bin/python
#ist auszufuehrender Interpreter
import lcddriver
import time
import locale

lcd = lcddriver.lcd()
lcd.lcd_clear()

#Wochentag-Name in Deutsch ausgeben
locale.setlocale(locale.LC_ALL, 'de_DE.utf8')

#Laufende Wiederholung der Schleife
while True:
    heute_tag = time.strftime('  %a %d. %b %Y', time.localtime())
    lcd.lcd_display_string(heute_tag, 3)
   
   #Alle Sekunde blinken lassen, eine Minute lang
    zahl = 0
    for zahl in range(60):
        heute_zeit = time.strftime('    %H : %M Uhr ', time.localtime())
        lcd.lcd_display_string(heute_zeit, 4)
        time.sleep(1)

lcd.lcd_clear()

#Ende der Ausführung bei Abbruch mit Taste STRG + C
<<<<<<<<<<<<<<<<<
Die Ausgabe erfolgt auf der 3. und 4. Zeile.

Gespeichert wird die Datei im Verzeichnis /I2C-LCD.

Zum Evtl. Löschen dieser Zeitanzeige wird das Programm zeitanzeige_out.py ( nur mit dem lcd.lcd_clear() Befehl) erstellt.

Starten des Programmes beim Start des Betriebssystems
Öffnen der Datei rs_local
>>>>>>>>>>>>>>>>>>>>>>
sudo nano /etc/rc.local
<<<<<<<<<<<<<<<<<<<<<<
Einfügen vor dem Ende (exit 0!) davor Ausführungsrechte setzen und speichern:
>>>>>>>>>>>>>>>>>>>>>>
sudo chmod +X /home/pi/I2C-LCD/zeitanzeige.py
/usr/bin/python /home/pi/I2C-LCD/zeitanzeige.py &
<<<<<<<<<<<<<<<<<<<<<<
Das letzte Zeichen "&" verhindert ein Abbruch bei Fehler im Programm, d.h. Programmausführung im Hintergrund
   
Bild7-05 Die Touch-Funktion ist vorhanden
   
Bild7-06 Das Internetradio in Funktion
   
Bild7-07 Jetzt auch mit aktuellem Datum und Zeit

Gruß Georg
Zitieren
#8
Hallo Radiofreunde!

Im vorn vorgestellten Internetradio-Projekt wurde das Internetradio durch die Anzeige von Datum und Uhrzeit auf einem LCD-Display erweitert.
Dies war möglich, da aufgrund des eingesetzten Displays WaveShare 5inch HDMI LCD 800x480 (B) die GPIO-Anschlüsse noch für zusätzliche Funktionen verfügbar waren.

Eine andere Möglichkeit zur Verwendung von GPIO und LCD-Display ist die Anzeige
von Tag, Zeit, Temperatur, Druck und Luftfeuchtigkeit im Raum, wobei die Uhrzeit in der unteren LCD-Zeile im Sekunden-Rhythmus blinkt
und in der oberen LCD-Zeile im Minuten-Rhythmus der Tag, Temperatur, Luftdruck und Feuchtigkeit angezeigt wird.

Die Arbeitsschritte für Tag und Zeit wiederhole ich hier noch einmal, damit alles als Einheit nachvollzogen werden kann.
Für die Erfassung von Temperatur, Druck und Luftfeuchte im Raum wird der Sensor BME280 eingesetzt (ca. 5 EUR im Fachhandel).

--------------------
1. I2C-Bus einrichten
--------------------
Der I2C-Bus stellt eine Schnittstelle des Raspberry Pi dar.
I2C steht für Inter-Integrated Circuit und verwendet nur
zwei Drähte (neben der Spannungsversorgung). Die benötigten Anschlüsse am Raspberry Pi sind der Pin 3 SDA und
der Pin 5 SCL.

Der I2C-Bus verwendet in der Regel Open-Collector-Eingänge. Das bedeutet, dass
die entsprechenden I2C-Bausteine keinen eigenen Spannungspegel an ihren I2C-Pins
führen. Die SDA- und SCL-Pins des Raspberry Pi werden durch interne Pullup-
Widerstände auf ein 3,3-V-Level gezogen. Die Busteilnehmer schalten bei der
Kommunikation diesen Pegel lediglich gegen Masse.

Wenn man die Möglichkeit hat, den I2C-Baustein mit +3,3V zu versorgen, sollte man diese Nutzen.
Dies minimiert das Risiko, den Raspberry Pi zu beschädigen.

Eine gute Anweisung gibt es hier:
https://tutorials-raspberrypi.de/hd44780...ansteuern/

Gleichwertig sind die Anweisungen des Herstellers JOY-It:
https://www.reichelt.de/entwicklerboards...dr::242692
Speziell unter Datenblätter: Anleitung LCD20x4_ANL.pdf

Anschlüsse LCD20x4 :
Raspberry Pi PIN        I2C LCD PIN
-----------------------------------
PIN 3 (BCM 2/ DA)           SDA
PIN 4 (5v Power)            VCC
PIN 5 (BCM 3/SCL)           SCL
PIN 6 (Ground)              GND

Unter Einstellungen/Raspberry-Pi-Konfiguration/Schnittstellen ist jetzt auch I2C zu aktivieren.

Installation der Bibliotheken GRIPO und Python am Terminal:
>>>>>>>>>>>>>>>>>
sudo apt-get install python-pip python-dev build-essential
sudo pip install RPi.GPIO
sudo apt-get install python-imaging
<<<<<<<<<<<<<<<<<

Installation der I2C-Tools:
>>>>>>>>>>>>>>>>>
sudo apt-get install python-smbus i2c-tools
<<<<<<<<<<<<<<<<<

Jetzt Freischaltung von I2C.
Bei älteren RPi bzw. Rasbian erfolgt dies über:
>>>>>>>>>>>>>>>>>
sudo raspi-config
<<<<<<<<<<<<<<<<<

und Auswahl der "Advanced Options", danach der Punkt I2C.
Bei meiner neueren Version von RPi bzw. Rasbian erfolgt dies in 2 Schritten:
- Am RPi ist über das Einstellungs-Menü (PullDown-Menü Einstellungen/Raspberry-Pi-Einstellungen/Schnittstellen) I2C zu aktivieren.
- Öffnen der Datei config.txt auf der Rasbian-SD-Karte am Computer (notwendige Rechte vorhanden) und
  Einfügen (evtl. # Zeichen am Zeilenbeginn entfernen), anschließend speichern und zurück in den RPi:
>>>>>>>>>>>>>>>>>
dtparam=i2c1=on
dtparam=i2c_arm=on
<<<<<<<<<<<<<<<<<

Anschließend müssen noch Einträge zur Modul-Datei hinzugefügt werden.Öffnen Sie dazu die Modul-Datei
>>>>>>>>>>>>>>>>>
sudo nano /etc/modules
<<<<<<<<<<<<<<<<<

Fügen Sie ans Ende dieser Datei folgende Zeilen und speichern der Datei.
>>>>>>>>>>>>>>>>>
i2c-bcm2708
i2c-dev
<<<<<<<<<<<<<<<<<

Neustart:
>>>>>>>>>>>>>>>>>
sudo reboot
<<<<<<<<<<<<<<<<<

-------------------------
2. 20x4 Display einrichten
-------------------------
Im Folgenden wird auf einen Code von Tutorials-Raspberrypi zurückgegriffen.
>>>>>>>>>>>>>>>>>
mkdir I2C-LCD && cd I2C-LCD
wget http://tutorials-raspberrypi.de/wp-conte...80_i2c.zip
unzip hd44780_i2c.zip
<<<<<<<<<<<<<<<<<

Als nächstes muss das Display, insofern es bereits angeschlossen wurde, angesprochen werden
>>>>>>>>>>>>>>>>>
sudo i2cdetect -y 1
<<<<<<<<<<<<<<<<<

Ausgabe im Terminal-Fenster:
     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
00:          -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- 27 -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --

Es sollte die Zahl 27 angezeigt werden.

-------------------------------------
3. Tag und Zeit anzeigen mit Autostart
-------------------------------------
Die auszuführende Datei kann im Verzeichnis /I2C-LCD generiert werden,
z.B. mit der rechten Maustaste über den leeren rechten Bereich die neue Datei zeitanzeige.py.

Wenn im Terminal die auszuführende Datei erstellt werden soll:
>>>>>>>>>>>>>>>>>
sudo nano zeitanzeige.py
<<<<<<<<<<<<<<<<<

Ansonsten im Python öffnen als zeitanzeige.py und den folgenden Code einfügen:
>>>>>>>>>>>>>>>>>
#!/usr/bin/python
#ist auszufuehrender Interpreter
import lcddriver
import time
import locale

#zustaendiges Geraet am I2C-Bus
DEVICE = 0x27

lcd = lcddriver.lcd()
lcd.lcd_clear()

#Wochentag-Name in Deutsch ausgeben
locale.setlocale(locale.LC_ALL, 'de_DE.utf8')

#Laufende Wiederholung der Schleife
while True:
    heute_tag = time.strftime('  %a %d. %b %Y', time.localtime())
    lcd.lcd_display_string(heute_tag, 2)
   
   #Alle Sekunde blinken lassen, eine Minute lang
    zahl = 0
    for zahl in range(60):
        heute_zeit = time.strftime('    %H : %M Uhr ', time.localtime())
        lcd.lcd_display_string(heute_zeit, 3)
        time.sleep(1)

lcd.lcd_clear()

#Ende der Ausführung bei Abbruch mit Taste STRG + C
<<<<<<<<<<<<<<<<<

Start des Programmes aus Python-Editor oder aus dem Terminal-Fenster mit:
>>>>>>>>>>>>>>>>>
sudo python zeitanzeige.py
<<<<<<<<<<<<<<<<<

Falls nichts angezeigt werden sollte könnte die Helligkeit des Displays zu gering sein. Am Display bzw. Konverter ist dafür ein Einstellregler.
Ursache für die verminderte Helligkeit könnte die herabgesetzte Betriebsspannung von 5V auf 3,3V sein.

Starten des Programmes beim Start des Betriebssystems
Öffnen der Datei rs_local
>>>>>>>>>>>>>>>>>>>>>>
sudo nano /etc/rc.local
<<<<<<<<<<<<<<<<<<<<<<
Einfügen vor dem Ende (exit 0!) davor Ausführungsrechte setzen und speichern:
>>>>>>>>>>>>>>>>>>>>>>
sudo chmod +X /home/pi/I2C-LCD/zeitanzeige.py
/usr/bin/python /home/pi/I2C-LCD/zeitanzeige.py &
<<<<<<<<<<<<<<<<<<<<<<
Das letzte Zeichen "&" verhindert ein Abbruch bei Fehler im Programm, d.h. Programmausführung im Hintergrund

----------------------------------------------------------
4. BME280(Temperatur, Druck, Luftfeuchte)-Sensor einrichten
----------------------------------------------------------
Anschluss BME280 an den RPi.
Anschlüsse:
Raspberry Pi PIN        I2C LCD PIN
-----------------------------------
PIN 3 (BCM 2/ DA)           SDA
PIN 2 (3,3V Power)          VIN
PIN 5 (BCM 3/SCL)           SCL
PIN 6 (Ground)              GND

   
Bild8-01 Montage des Sensors
Der Sensor "blickt" durch ein Loch in der Seitenwand. Damit kann die Beeinflussung durch innere Technik minimiert werde.

Als nächstes muss die Verbindung getestet werden:
>>>>>>>>>>>>>>>>>
sudo i2cdetect -y 1
<<<<<<<<<<<<<<<<<

Ausgabe im Terminal-Fenster:
     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
00:          -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- 27 -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- 76 --

Die Adresse des BME280 ist 74

Das Datenblatt ist zu finden in:
https://cdn.shopify.com/s/files/1/1509/1...6957190172

Der eigentliche Sensor ist von Bosch und sehr komplex zu programmieren.
Die Anschlussplatine mit dem Interface ist hier von Adafruit.

Ein nahezu fertiges Python-Programm ist von Matt Hawkins und hier herunter zuladen:
https://bitbucket.org/MattHawkinsUK/rpis.../bme280.py

Wir wollen das Programm in das für I2C schon kreierte Verzeichnis copieren:
>>>>>>>>>>>>>>>>>>>
cd I2C-LCD
wget https://bitbucket.org/MattHawkinsUK/rpis.../bme280.py
<<<<<<<<<<<<<<<<<<<
In der Datei bme280.py sind im Programmteil Main, print-Anweisungen die Funktionsklammern hinzuzufügen.

Es kann auch schon einmal gestartet werden mit Ausgabe der Ergebnisse im Terminal.
>>>>>>>>>>>>>>>>>
sudo python bme280.py  
<<<<<<<<<<<<<<<<<
Ergebnis:
chipID      : 96
version     : 0
Temperature : 22,18 C
Pressure    : 982.901 hPa
Humidity    : 45.55 %

Inhalt des Programmes bme280.py:
Das Skript enthält einige beängstigend aussehende Mathematik-Abschnitte, gemäß Datenblatt.

- importiert einige Bibliotheken
- definiert einige Funktionen
- function main verwendet die Funktion readBME280ID, um die ID des Geräts abzurufen
  Die Funktion main ruft dann readBME280All auf
    + Legt das Oversampling (Überlastung) und den Modus fest
    + liest Kalibrierungsdaten von dem Gerät, das im Werk voreingestellt war
    + liest die Rohdaten zu Temperatur, Druck und Luftfeuchtigkeit
        * Verfeinert die Daten mithilfe der Mathematik aus dem Datenblatt
        * gibt die Werte an main() zurück

-----------------------------------
5. Rahmenprogramm für Gesamtanzeige
-----------------------------------
Code:
Im Verzeichnis /home/pi/I2C-LCD/ sind die folgenden Dateien anzulegen:

- lcd_anzeige.py (ein Python-Programm für die Anzeige):
>>>>>>>>>>>>>>>>>
#!/usr/bin/python
#ist auszufuehrender Interpreter

import bme280
import lcddriver
import time
import locale
import sys

global lcd_on
lcd_on = 1

#(chip_id, chip_version) = bme280.readBME280ID()
#print "Chip ID :", chip_id
#print "Version :", chip_version

lcd = lcddriver.lcd()
lcd.lcd_clear()

#Wochentag-Name in Deutsch ausgeben
locale.setlocale(locale.LC_ALL, 'de_DE.utf8')

#Laufende Wiederholung der Schleife
while True:
   #Modus-Datei auslesen
   datei = open('/home/pi/I2C-LCD/anzeige_modus.txt','r')
   lcd_on = datei.read()
   #Kontrollausgabe
   print("Modus",lcd_on)
   datei.close()

   if lcd_on == "0":
       lcd.lcd_clear()
       break

   #Beginn mit zahl=0
   for zahl in range(4):

       #Lesen BME280
       temperature,pressure,humidity = bme280.readBME280All()
       print ("Temperature : ", temperature, "C")
       print ("Pressure : ", pressure, "hPa")
       print ("Humidity : ", humidity, "%")
       tem = str(temperature)
       dru = str(pressure)
       feu = str(humidity)

       #Display 20x4 an I2C-Bus
       DEVICE = 0x27
       #LesenTag
       heute_tag = time.strftime('  %a %d. %b %Y', time.localtime())
       #Lesen Zeit
       heute_zeit = time.strftime('    %H : %M Uhr ', time.localtime())

       if zahl == 0:
           if lcd_on == "0":
               lcd.lcd_clear()
               break

           #Kontrollausgabe
           print (zahl," ", lcd_on)
           #Anzeige TagTag
           lcd.lcd_display_string(heute_tag, 3)

       if zahl == 1:
           if lcd_on == "0":
               lcd.lcd_clear()
               break
           
           #Kontrollausgabe                        
           print (zahl," ", lcd_on)
           lcd.lcd_display_string("   Temp = "+tem[0:4]+" C    ", 3)          

       if zahl == 2:
           if lcd_on == "0":
               lcd.lcd_clear()
               break
                                                           
           #Kontrollausgabe
           print (zahl," ", lcd_on)
           lcd.lcd_display_string(" Druck = "+dru[0:5]+" hPa", 3)          

       if zahl == 3:
           if lcd_on == "0":
               lcd.lcd_clear()
               break
           
           #Kontrollausgabe
           print (zahl," ", lcd_on)
           lcd.lcd_display_string("  Feucht = "+feu[0:4]+" %    ", 3)          

       #Alle Sekunde blinken lassen, 4 x 15 sec lang
       #Beginn mit wert=0
       for wert in range(15):
           #Kontrollausgabe
           print (zahl," ", lcd_on)                                                
           #Anzeige Zeit
           lcd.lcd_display_string(heute_zeit, 4)
           time.sleep(1)
           lcd.lcd_display_string("                    ", 4)    

           #Modus-Datei auslesen
           datei = open('/home/pi/I2C-LCD/anzeige_modus.txt','r')
           lcd_on = datei.read()
           #Kontrollausgabe
           print("Modus",lcd_on)
           datei.close()

           if lcd_on == "0":
               lcd.lcd_clear()
               break

#Datei speichern mit Überschreiben:
datei = open('/home/pi/I2C-LCD/anzeige_modus.txt','w')
datei.write("1")
datei.close()

#lcd.lcd_clear()
#sys.exit(0)
<<<<<<<<<<<<<<<<<

Weitere Dateien
- lcd_off_datei.py (ein Python-Programm für die Beendigung der Schleife):
>>>>>>>>>>>>>>>>>>>
#lcd_anzeige stoppen
import lcddriver
lcd = lcddriver.lcd()

lcd_on = "0"
#Datei speichern mit Überschreiben:
datei = open('/home/pi/I2C-LCD/anzeige_modus.txt','w')
datei.write("0")
datei.close()
#Kontrollausgabe
print("Out-Modus",lcd_on)
<<<<<<<<<<<<<<<<<<<<

- anzeige_modus.txt (die Übergabe-Datei des Modus):
>>>>>>>>>>>>>>>>>>
0 bzw. 1
<<<<<<<<<<<<<<<<<<

Im Verzeichnis /home/pi/Desktop/ die Aufruf-Funktionen
- LCD-Anzeige (für den Aufruf des Anzeige-Programmes):
>>>>>>>>>>>>>>>>>>
[Desktop Entry]
Name=LCD_Anzeige
Comment=Start der LCD-Anzeige
Icon=/home/pi/Documents/screen_akt.png
Exec=sudo python3 /home/pi/I2C-LCD/lcd_anzeige.py
Type=Application
Encoding=UTF-8
Terminal=false
Categories=None;
<<<<<<<<<<<<<<<<<<

- LCD_Aus (für die Beendigung des Anzeige-Programmes):
>>>>>>>>>>>>>>>>>>
[Desktop Entry]
Name=LCD_Anzeige_Aus
Comment=Stopp der LCD-Anzeige
Icon=/home/pi/Documents/screen_off.png
Exec=python3 /home/pi/I2C-LCD/lcd_off_datei.py
Type=Application
Encoding=UTF-8
Terminal=false
Categories=None;
Name[de_DE]=LCD_Anzeige_Aus
<<<<<<<<<<<<<<<<<<<<<<

Bild8-02 Die neue Innenansicht

Im Verzeichnis /home/pi/Documents/ sind dafür die Icons auf der Desktop-Oberfläche
- screen_akt.png für den Aufruf
- screen_off.png für die Beendigung
Kostenlose Icon's für das Raspberry-Format 64x64 als *.png findet man im Internet



   
Bild8-02 Die neue Innenansicht


.png   Bild8-03.png (Größe: 269,82 KB / Downloads: 218)
Bild8-03 Icons für den Start der neuen Programme

Wurde das Anzeige-Programm mit dem Beendigungs-Programm abgebrochen,
ist beim erneuten Start des Anzeige-Programmes dieser Start 2x notwendig,
damit die Variable in der Datei anzeige_modus.txt neu auf 1 gesetzt wird.
   
Bild8-04 Anzeige Datum und Zeit
   
Bild8-05 Anzeige Temperatur
   
Bild8-06 Anzeige Luftdruck
   
Bild8-07 Anzeige Luftfeuchtigkeit

Wenn es stört, dass nach Aufruf eines Icons für eine Anweisung auf dem Display
die Frage kommt ob man die zugrundeliegende Anweisung ausführen möchte
oder die Datei öffnen, kann dies im Dateimanager/Einstellungen verhindert werden.

Ein weiteres Projekt wäre, neben dem Internetradio eine Wetterstation mit Vorhersage zu installieren.
Dafür sind 2 Möglichkeiten praktikabel.

Fortsetzung folgt!

Gruß Georg
Zitieren
#9
Wie bei Jupp: klasse Arbeit und edles Aussehen!
Herzliche Grüße

Pitter
Zitieren
#10
Hallo Radiofreunde!

Auch dies kann  noch ein Internetradio:
Die Anzeige nicht nur des Raumklimas, sondern des aktuellen Wetters vor der Haustür
evtl. mit Vorhersage für die nächsten Tage, wäre eine gute Sache.
Die Daten dafür sind nur über Portale des Internets zu erhalten.

Die besten Konditionen für den kostenlosen privaten Gebrauch bietet OpenWeatherMap,
gut beurteilt bei Wikipedia:
https://de.wikipedia.org/wiki/OpenWeatherMap

   
Bild9-01 Wettervorhersage unter Windows/FireFox

Für die Nutzung von OpenWeatherMap muss ein API-Key generiert werden,
dies erfordert bei der Firma auch einen Account:
https://openweathermap.org/
Zu dem Login-Fenster kommt man rechts oben auf "sign in".

Der generierte API-Key ist 32-stellig aus Kleinbuchstaben und Zahlen.

Mit dem Gratis-Abonnement können Informationen zum aktuellen Wetter oder einer Vorhersage für 5 Tage im 3 h Intervall abgerufen werden.

Jetzt können im Test schon einmal Daten im Format JSON aufgerufen werden:
http://api.openweathermap.org/data/2.5/w...API-Key&gt;

Ausgegeben wird untereinander die Liste der Daten.

Einige Einstellungen:
Ausgabemode: &mode=JSON oder XML
Anfrage: weather? (Wetter) oder forecast? (Vorhersage alle 3 Std)
         onecall? (Vorhersage 8 Tage) mit &exclude=hourly
                   (nur mit Ortsdaten in Längen- und Breiten-Graden,
                         aus den weather?-Daten für Weimar erhält man lat=50.98&lon=11.32)
Zeitstempel: &cnt=<Zahl> (je 3 Std Abstand)
Ausgabesprache deutsch: &lang=de

   
Bild9-02 Wetterdaten im Format ISON
Dargestellt sind nur die Daten für den 1.Tag (daily: 0) + ersten Daten des 2.Tages (daily: 1)

Zum Programm:
Code:
Prüfung im Terminalfenster, ob request installiert ist:
>>>>>>>>>>>>>>>>>>>>>
sudo pip install requests
<<<<<<<<<<<<<<<<<<<<<

Python Programm outdoor_vor_dat.py zum Auslesen der Wetterdaten für 8 Tage
und Anzeige auf dem LCD-Display:
>>>>>>>>>>>>>>>>>>>>>
#!/usr/bin/python
#python ist auszufuehrender Interpreter
#coding=utf8

#für LCD-Anzeige
import lcddriver
import time
import locale
import sys

#für Wetterdaten
import json
import requests
import time
import datetime
from datetime import datetime as dt

#Variable für Aktivierung der lcd-anzeige
global lcd_on
lcd_on = 1

#Display 20x4 an I2C-Bus
DEVICE = 0x27

lcd = lcddriver.lcd()
lcd.lcd_clear()

#Modus-Datei auslesen
datei = open('/home/pi/I2C-LCD/anzeige_modus.txt','r')
lcd_on = datei.read()
#Kontrollausgabe
print("Modus",lcd_on)
datei.close()

#Wochentag-Name in Deutsch ausgeben
locale.setlocale(locale.LC_ALL, 'de_DE.utf8')

#Daten der Vorhersage auslesen
url = "http://api.openweathermap.org/data/2.5/onecall?lat=50.98&lon=11.32&exclude=hourly&units=metric&mode=JSON&appid=255a77bfba9e45b64f4f45e4b97484ee"
#ohne Landessprache deutsch, siehe unten

r = requests.get(url);
wetter_vor = r.json()

#Funktion Wind-Himmelsrichtung ausgeben anstelle der Grad-Zahl
def position(windricht):
   himmelsricht = "Windrichtung: keine"
   x=0
   for x in range(8):
       if windricht > 337:
           himmelsricht = "  Windrichtung: N"
           break
       if windricht > 292:
           himmelsricht = "  Windrichtung: NW"
           break
       if windricht > 247:
           himmelsricht = "  Windrichtung: W"
           break
       if windricht > 202:
           himmelsricht = "  Windrichtung: SW"
           break
       if windricht > 157:
           himmelsricht = "  Windrichtung: S"
           break
       if windricht > 112:
           himmelsricht = "  Windrichtung: SO"
           break
       if windricht > 67:
           himmelsricht= "  Windrichtung: O"
           break
       if windricht > 22:
           himmelsricht = "  Windrichtung: NO"
           break
       if windricht > 0:
           himmelsricht = "  Windrichtung: N"
           break
   return himmelsricht

#Funktion verbale Wetterlage in deutsch übersetzen
#(die erwartete Landessprache "deutsch" ist unvollständig)
def lageanzei(lageanzeige):
   lagean = lageanzeige
   y=0
   for y in range(10):
       if lageanzeige == "rain":
           lagean = "  Regen        "
           break
       if lageanzeige == "rain and snow":
           lagean = "  Regen mit Schnee  "
           break
       if lageanzeige == "light rain":
           lagean = "  Leichter Regen    "
           break
       if lageanzeige == "clouds":
           lagean = "  bedeckt      "
           break
       if lageanzeige == "overcast clouds":
           lagean = "  leicht bedeckt   "
           break
       if lageanzeige == "broken clouds":
           lagean = " aufgelockert wolkig    "
           break
       if lageanzeige == "few clouds":
           lagean = "  wenig Wolken    "
           break
       if lageanzeige == "scattered clouds":
           lagean = "  vereinzelt Wolken  "
           break
       if lageanzeige == "clear sky":
           lagean = "  klarer Himmel   "
           break
       if lageanzeige == "light snow":
           lagean = "  leicht Schnee    "
           break
       if lageanzeige == "snow":
           lagean = "  Schnee       "
           break

   return lagean

#Anzahl der Vorschau-Tage = heute + 8
#Beginn mit zahl=0
zahl=0
for zahl in range(8):

   #Modus-Datei auslesen
   datei = open('/home/pi/I2C-LCD/anzeige_modus.txt','r')
   lcd_on = datei.read()
   #Kontrollausgabe
   print("Modus",lcd_on)
   datei.close()
   if lcd_on == "0":
       lcd.lcd_clear()
       break

   #Variablen für einen Tag belegen
   if zahl == 0:
       #Heutiger Tag
       #tag = time.strftime('  %a %d. %b %Y', time.localtime())
       tag = dt.fromtimestamp(wetter_vor['current']['dt']).strftime('  %a %d.%m.%Y')
       taganzeige = tag
       #Kontrollanzeige
       print(taganzeige)

       # Alle weiteren Werte auslesen
       tempanzeige = "  Temp: {} C".format(wetter_vor['current']['temp'])
       druckanzeige = "  Druck: {} hPa".format(wetter_vor['current']['pressure'])
       feuchtanzeige ="  Feuchte: {} %".format(wetter_vor['current']['humidity'])
       windgeschwanzeige = "  Wind: {} m/s".format(wetter_vor['current']['wind_speed'])
       windrichtanzeige = "Wind von: {} grd".format(wetter_vor['current']['wind_deg'])
       windricht = int("{}".format(wetter_vor['current']['wind_deg']))

       #Rückgabewert der Funktion aufrufen
       himmelsrichtanzeige = position(windricht)

       lageanzeige = "{}".format(wetter_vor['current']['weather'][0]['description'])
       #Rückgabewert der Funktion aufrufen
       lageanzeige = lageanzei(lageanzeige)
#Kontrollausgabe
       print(tempanzeige)
       print(druckanzeige)
       print(feuchtanzeige)
       print(windgeschwanzeige)
       print(himmelsrichtanzeige)
       print(lageanzeige)

   if zahl == 1:
       #morgen
       tag = dt.fromtimestamp(wetter_vor['daily'][1]['dt']).strftime('  %a %d.%m.%Y')
       taganzeige = tag
       print(taganzeige)

       tempanzeige = " Temp: {}".format(wetter_vor['daily'][1]['temp']['min']) +"/"+ "{} C".format(wetter_vor['daily'][1]['temp']['max'])
       druckanzeige = "  Druck: {} hPa".format(wetter_vor['daily'][1]['pressure'])
       feuchtanzeige = "  Feuchte: {} %".format(wetter_vor['daily'][1]['humidity'])
       windgeschwanzeige = "  Wind: {} m/s".format(wetter_vor['daily'][1]['wind_speed'])
       windrichtanzeige = "Wind von: {} grd".format(wetter_vor['daily'][1]['wind_deg'])
       windricht = int("{}".format(wetter_vor['daily'][1]['wind_deg']))
       print(windricht)

       #Rückgabewert der Funktion aufrufen
       himmelsrichtanzeige = position(windricht)
       
       lageanzeige = "{}".format(wetter_vor['daily'][1]['weather'][0]['description'])
       lageanzeige = lageanzei(lageanzeige)
       print(tempanzeige)
       print(druckanzeige)
       print(feuchtanzeige)
       print(windgeschwanzeige)
       print(himmelsrichtanzeige)
       print(lageanzeige)

   if zahl == 2:
       #übermorgen
       tag = dt.fromtimestamp(wetter_vor['daily'][2]['dt']).strftime('  %a %d.%m.%Y')
       taganzeige = tag
       #print(taganzeige)
       #Funktion zum Wandeln des Wochentag-Namens in Deutsch
       #dat = taganzeige[3:14]
       #woch = taganzeige[0:3]
       #taganzeige = wochentag(woch) + dat
       print(taganzeige)

       tempanzeige = " Temp: {}".format(wetter_vor['daily'][2]['temp']['min']) +"/"+ "{} C".format(wetter_vor['daily'][2]['temp']['max'])
       druckanzeige = "  Druck: {} hPa".format(wetter_vor['daily'][2]['pressure'])
       feuchtanzeige = "  Feuchte: {} %".format(wetter_vor['daily'][2]['humidity'])
       windgeschwanzeige = "  Wind: {} m/s".format(wetter_vor['daily'][1]['wind_speed'])
       windrichtanzeige = "Wind von: {} grd".format(wetter_vor['daily'][2]['wind_deg'])
       windricht = int("{}".format(wetter_vor['daily'][2]['wind_deg']))
       print(windricht)

       #Rückgabewert der Funktion aufrufen
       himmelsrichtanzeige = position(windricht)

       lageanzeige = "{}".format(wetter_vor['daily'][2]['weather'][0]['description'])
       lageanzeige = lageanzei(lageanzeige)
       print(tempanzeige)
       print(druckanzeige)
       print(feuchtanzeige)
       print(windgeschwanzeige)
       print(himmelsrichtanzeige)
       print(lageanzeige)

   if zahl == 3:
       #Tag 4
       tag = dt.fromtimestamp(wetter_vor['daily'][3]['dt']).strftime('  %a %d.%m.%Y')
       taganzeige = tag
       #print(taganzeige)

       #Funktion zum Wandeln des Wochentag-Namens in Deutsch
       #dat = taganzeige[3:14]
       #woch = taganzeige[0:3]
       #taganzeige = wochentag(woch) + dat
       print(taganzeige)

       tempanzeige = " Temp: {}".format(wetter_vor['daily'][3]['temp']['min']) +"/"+ "{} C".format(wetter_vor['daily'][3]['temp']['max'])
       druckanzeige = "  Druck: {} hPa".format(wetter_vor['daily'][3]['pressure'])
       feuchtanzeige = "  Feuchte: {} %".format(wetter_vor['daily'][3]['humidity'])
       windgeschwanzeige = "  Wind: {} m/s".format(wetter_vor['daily'][3]['wind_speed'])
       windrichtanzeige = "Wind von: {} grd".format(wetter_vor['daily'][3]['wind_deg'])
       windricht = int("{}".format(wetter_vor['daily'][3]['wind_deg']))
       print(windricht)

       #Rückgabewert der Funktion aufrufen
       himmelsrichtanzeige = position(windricht)

       lageanzeige = "{}".format(wetter_vor['daily'][3 ]['weather'][0]['description'])
       lageanzeige = lageanzei(lageanzeige)
       print(tempanzeige)
       print(druckanzeige)
       print(feuchtanzeige)
       print(windgeschwanzeige)
       print(himmelsrichtanzeige)
       print(lageanzeige)

   if zahl == 4:
       #Tag 5
       tag = dt.fromtimestamp(wetter_vor['daily'][4]['dt']).strftime('  %a %d.%m.%Y')
       taganzeige = tag
       #print(taganzeige)
       #Funktion zum Wandeln des Wochentag-Namens in Deutsch
       #dat = taganzeige[3:14]
       #woch = taganzeige[0:3]
       #taganzeige = wochentag(woch) + dat
       print(taganzeige)

       tempanzeige = " Temp: {}".format(wetter_vor['daily'][4]['temp']['min']) +"/"+ "{} C".format(wetter_vor['daily'][1]['temp']['max'])
       druckanzeige = "  Druck: {} hPa".format(wetter_vor['daily'][4]['pressure'])
       feuchtanzeige = "  Feuchte: {} %".format(wetter_vor['daily'][4]['humidity'])
       windgeschwanzeige = "  Wind: {} m/s".format(wetter_vor['daily'][4]['wind_speed'])
       windrichtanzeige = "Wind von: {} grd".format(wetter_vor['daily'][4]['wind_deg'])
       windricht = int("{}".format(wetter_vor['daily'][4]['wind_deg']))
       print(windricht)

       #Rückgabewert der Funktion aufrufen
       himmelsrichtanzeige = position(windricht)
       
       lageanzeige = "{}".format(wetter_vor['daily'][4]['weather'][0]['description'])
       lageanzeige = lageanzei(lageanzeige)
       print(tempanzeige)
       print(druckanzeige)
       print(feuchtanzeige)
       print(windgeschwanzeige)
       print(himmelsrichtanzeige)
       print(lageanzeige)

   if zahl == 5:
       #Tag 6
       tag = dt.fromtimestamp(wetter_vor['daily'][5]['dt']).strftime('  %a %d.%m.%Y')
       taganzeige = tag
       #print(taganzeige)
       #Funktion zum Wandeln des Wochentag-Namens in Deutsch
       #dat = taganzeige[3:14]
       #woch = taganzeige[0:3]
       #taganzeige = wochentag(woch) + dat
       print(taganzeige)

       tempanzeige = " Temp: {}".format(wetter_vor['daily'][5]['temp']['min']) +"/"+ "{} C".format(wetter_vor['daily'][1]['temp']['max'])
       druckanzeige = "  Druck: {} hPa".format(wetter_vor['daily'][5]['pressure'])
       feuchtanzeige = "  Feuchte: {} %".format(wetter_vor['daily'][5]['humidity'])
       windgeschwanzeige = "  Wind: {} m/s".format(wetter_vor['daily'][5]['wind_speed'])
       windrichtanzeige = "Wind von: {} grd".format(wetter_vor['daily'][5]['wind_deg'])
       windricht = int("{}".format(wetter_vor['daily'][5]['wind_deg']))
       print(windricht)

       #Rückgabewert der Funktion aufrufen
       himmelsrichtanzeige = position(windricht)
       
       lageanzeige = "{}".format(wetter_vor['daily'][5]['weather'][0]['description'])
       lageanzeige = lageanzei(lageanzeige)
       print(tempanzeige)
       print(druckanzeige)
       print(feuchtanzeige)
       print(windgeschwanzeige)
       print(himmelsrichtanzeige)
       print(lageanzeige)

   if zahl == 6:
       #Tag 7
       tag = dt.fromtimestamp(wetter_vor['daily'][6]['dt']).strftime('  %a %d.%m.%Y')
       taganzeige = tag
       #print(taganzeige)
       #Funktion zum Wandeln des Wochentag-Namens in Deutsch
       #dat = taganzeige[3:14]
       #woch = taganzeige[0:3]
       #taganzeige = wochentag(woch) + dat
       print(taganzeige)

       tempanzeige = " Temp: {}".format(wetter_vor['daily'][6]['temp']['min']) +"/"+ "{} C".format(wetter_vor['daily'][1]['temp']['max'])
       druckanzeige = "  Druck: {} hPa".format(wetter_vor['daily'][6]['pressure'])
       feuchtanzeige = "  Feuchte: {} %".format(wetter_vor['daily'][6]['humidity'])
       windgeschwanzeige = "  Wind: {} m/s".format(wetter_vor['daily'][6]['wind_speed'])
       windrichtanzeige = "Wind von: {} grd".format(wetter_vor['daily'][6]['wind_deg'])
       windricht = int("{}".format(wetter_vor['daily'][6]['wind_deg']))
       print(windricht)

       #Rückgabewert der Funktion aufrufen
       himmelsrichtanzeige = position(windricht)
       
       lageanzeige = "{}".format(wetter_vor['daily'][6]['weather'][0]['description'])
       lageanzeige = lageanzei(lageanzeige)
       print(tempanzeige)
       print(druckanzeige)
       print(feuchtanzeige)
       print(windgeschwanzeige)
       print(himmelsrichtanzeige)
       print(lageanzeige)

   if zahl == 7:
       #Tag 8
       tag = dt.fromtimestamp(wetter_vor['daily'][7]['dt']).strftime('  %a %d.%m.%Y')
       taganzeige = tag
       print(taganzeige)

       tempanzeige = " Temp: {}".format(wetter_vor['daily'][7]['temp']['min']) +"/"+ "{} C".format(wetter_vor['daily'][1]['temp']['max'])
       druckanzeige = "  Druck: {} hPa".format(wetter_vor['daily'][7]['pressure'])
       feuchtanzeige = "  Feuchte: {} %".format(wetter_vor['daily'][7]['humidity'])
       windgeschwanzeige = "  Wind: {} m/s".format(wetter_vor['daily'][7]['wind_speed'])
       windrichtanzeige = "Wind von: {} grd".format(wetter_vor['daily'][7]['wind_deg'])
       windricht = int("{}".format(wetter_vor['daily'][7]['wind_deg']))
       print(windricht)

       #Rückgabewert der Funktion aufrufen
       himmelsrichtanzeige = position(windricht)
       
       lageanzeige = "{}".format(wetter_vor['daily'][7]['weather'][0]['description'])
       lageanzeige = lageanzei(lageanzeige)
       print(tempanzeige)
       print(druckanzeige)
       print(feuchtanzeige)
       print(windgeschwanzeige)
       print(himmelsrichtanzeige)
       print(lageanzeige)


   #Anzeige Tag auf Display
   lcd.lcd_display_string("                    ", 3)
   lcd.lcd_display_string(taganzeige, 3)

   #7 x Wetter-Parameter ausgeben
   wetter = 0
   for wetter in range(6):

       #Modus-Datei auslesen
       datei = open('/home/pi/I2C-LCD/anzeige_modus.txt','r')
       lcd_on = datei.read()
       #Kontrollausgabe
       print("Modus",lcd_on)
       datei.close()
       if lcd_on == "0":
           lcd.lcd_clear()
           break
       #Wetter-Daten LCD-Ausgabe
       if wetter == 0:
           lcd.lcd_display_string("                    ", 4)
           lcd.lcd_display_string(tempanzeige, 4)
       if wetter == 1:
           lcd.lcd_display_string("                    ", 4)
           lcd.lcd_display_string(druckanzeige, 4)
       if wetter == 2:
           lcd.lcd_display_string("                    ", 4)
           lcd.lcd_display_string(feuchtanzeige, 4)
       if wetter == 3:
           lcd.lcd_display_string("                    ", 4)
           lcd.lcd_display_string(windgeschwanzeige, 4)
       if wetter == 4:
           lcd.lcd_display_string("                    ", 4)
           lcd.lcd_display_string(himmelsrichtanzeige, 4)
       if wetter == 5:
           lcd.lcd_display_string("                    ", 4)
           lcd.lcd_display_string(lageanzeige, 4)

       time.sleep(3)

#Umwandlung des UNIX-Zeitstempels
#print(datetime.datetime.fromtimestamp(1606399317).strftime('%Y-%m-%d %H:%M:%S'))

#Datei speichern mit Überschreiben:
datei = open('/home/pi/I2C-LCD/anzeige_modus.txt','w')
datei.write("1")
datei.close()

lcd.lcd_clear()
#sys.exit(0)
<<<<<<<<<<<<<<<<<<<<<<<<<<


.png   Bild9-03.png (Größe: 486,77 KB / Downloads: 156)
Bild9-03 Mit dem rechten Icon kann das neue Programme gestartet werden

   
   
Bild9-04 Bild9-05 Eine Auswahl der angezeigten Wetterdaten der Vorhersage

Das Programm läuft z.Z. nur einmal durch für die Vorhersage aller 8 Tage.
Möchte man diesen Prozess zwischendurch stoppen, kann man dies auch mit dem Programm LCD_AUS von der Desktop-Oberfläche.

--------------------------------------------
Hier noch 2 kleine Anregungen:

1. Virtuelle Tastatur einrichten
Nummer eins ist das matchbox Keyboard.
Dieses Keyboard lässt sich frei konfigurieren und ist somit in allen möglichen Sprachen verfügbar.
Je nach Nutzung kann man bestimmte Tasten entfernen –
man könnte zum Beispiel nur ein Nummernfeld mit einer Entertaste konfigurieren.

Installiert wird diese Bildschirm-Tastatur wie folgt:
>>>>>>>>>>>>>>>>>>>
sudo apt-get update
sudo apt-get install matchbox-keyboard
<<<<<<<<<<<<<<<<<<<

Das Keyboard findet man nach der Installation bereit im Startmenü unter Zubehör (Accessories).
Standardmäßig wird das englischsprachige Tastaturlayout installiert.

Wer den Aufruf der Tastatur gern in der Panel-Zeile des Pull-Down-Menüs haben möchte
kann dies einrichten nach der Anleitung in:
https://github.com/Elecrow-RD/Elecrow-LC...t-Keyboard

-----------------------------------
2. Bei Touchscreen Maus-Rechtsklick aktivieren
Falls ihr ohne Maus mit Touch arbeitet und die „Rechte Maustaste“ via Touchscreen benötigt
könnt diese durch folgendes aktivieren:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
sudo nano /etc/X11/xorg.conf
<<<<<<<<<<<<<<<<<<<<<<<<<<<<

Fügt folgenden Text in die Datei ein:
>>>>>>>>>>>>>>>>>>>>>>>>>>>
Section "InputClass"
   Identifier "calibration"
   Driver "evdev"
   MatchProduct "FT5406 memory based driver"

   Option "EmulateThirdButton" "1"
   Option "EmulateThirdButtonTimeout" "750"
   Option "EmulateThirdButtonMoveThreshold" "30"
EndSection
<<<<<<<<<<<<<<<<<<<<<<<<<<<<

Speichert mit STRG-o, Enter , STR-x
Nach einem Reboot könnt ihr durch längeres „Drücken“
auf den Touchscreen die Rechte Maustaste aktivieren.

Dann folgt noch die Wetterstation unter KODI!

Gruß Georg
Zitieren
#11
Hallo Radiofreunde!

Unter KODI kann auch eine Wetterstation installiert werden.

In meinem vorangegangenen Beitrag wurde unter KODI schon das Addon "Radio" installiert.
KODI bietet auch ein Wetter-Addon an.
Nach der Installation des Wetter-Addon sollte aber die Radio-Funktion im Hintergrund weiter verfügbar sein.

Für die Installationsarbeiten wird, wie auch schon vorn aufgezeigt, das Bild des Display zum HDMI-Monitor bzw. Fernseher mit HDMI-Eingang umgeleitet.
Damit haben wir für die Einstellungen eine gute Arbeitsfläche. Eine Tastatur braucht nicht angeschlossen werden, da KODI eine virtuelle Tastatur beinhaltet.

Am PC ist im Hauptverzeichnis der SDHC-Karte die Datei config.txt mit dem Texteditor zu öffnen und am Ende stehenden Kommandos mit dem Vorzeichen # zu versehen und danach zu speichern:
>>>>>>>>>>>>>>>>>
# max_usb_current=1
# hdmi_group=2
# hdmi_mode=87
# hdmi_cvt 800 480 60 6 0 0 0
# hdmi_drive=1
<<<<<<<<<<<<<<<<<
Bei Verwendung des Displays ist dies wieder rückgängig zu machen.

   
Bild9-01 Kodi in der bisherigen Einstellung nach dem Start mit Heimatsender
   
Bild9-02 Vollbild
   
Bild9-03 Start der Funktion Wetter im Haupt-Menü
Es werden noch keine aktuellen Werte angezeigt.

   
Bild9-04 Einstellungen
Es werden die Dienste/Wetter/mehr gewählt
   
Bild9-05 Auswahl der Wetter-Dienste
Es wird "OpenWeatherMap Extended" empfohlen
Der Dienst wird installiert.
Unter Einstellungen muss der API-Key eingegeben werden, danach der Standort
   
Bild9-06 Dienste/Wetter/Einstellungen
   
Bild9-07 Erste Anzeige der aktuellen Wetterdaten
Eine Vorhersage ist mit diesen Einstellungen noch nicht möglich.

Jetzt gehen wir zu : Einstellungen/Benutzeroberfläche/Skins/Skins/mehr
   
   
Bild9-08, Bild9-09
Wir wählen "Confluence", Es wird installiert... und beibehalten.
Jetzt haben wir auch das Erscheinungsbild von unserem Radio verändert!
   
Bild8-10 Confluence Look & Feel
Skins-konfigurieren/Hauptfenster
Es ist die "Auswahl Wetterinformationen anzeigen" einzustellen

Wenn wir jetzt in das Hauptfenster gehen haben wir ein neues Bild.
   
Bild9-12 Neues Hauptfenster
Es wird sogar links oben das aktuelle Wetter in Kurzform angezeigt und rechts oben die Zeit mit Datum

Bei Auswahl Wetter kommt noch ein Hinweis auf ein linkes seitliches Ausklapp-Menü
   
Bild9-14 Hinweis auf das Klapp-Menü

Jetzt fehlt uns noch die Vorhersage im rechten Fenster-Teil, aber im Ausklapp-Menü kann man die Vorhersage-Konfiguration einstellen
Wir wählen die Stündliche Vorhersage (alle 3 Stunden über 3-Vorhersagetage )
   
Bild9-15 Wetteranzeige mit Vorhersage

Mit dem "Haus" am rechten, unteren Bildrand kommt man wieder in das Hauptfenster

Beim Neustart von KODI stellt sich jetzt das Bild so dar:
   
Bild9-16 Radio nach KODI Start

Als Vollbild haben wir jetzt.
   
Bild9-17 Vollbild des empfangenen Senders
Mit dem gefüllten Quadrat in der Sendersteuerung kommt man in das vorherige Fenster, aber ohne Radio.
Zur Hauptseite kommt man mit dem Haus rechts,unten.

Von der Wettervorhersage zum Radio gelangt man in folgenden Schritten:
Im Hauptmenü wählt man das Addon Musik/Musik-Addon.
Es erscheint links oben das Addon Radio.
   
Bild9-18 Das Addon Radio
Nach Doppelklick kommt man auf die allgemeine Senderliste
   
Bild9-19 Allgemeine Senderliste
Es wird "Meine Sender" gewählt, die schon einmal zusammengestellt wurde.
   
Bild9-20 Liste Meine Sender

Wenn der Wunschsender ausgewählt wurde, kann dieser mittels linken Ausklapp-Menü im Vollbild dargestellt werden.

Probiert es doch einmal...

Ich wünsche Euch schöne Weihnachtstage und bleibt gesund!

Gruß Georg
Zitieren


Möglicherweise verwandte Themen...
Thema Verfasser Antworten Ansichten Letzter Beitrag
  Ein minimales Internetradio für alte und neue (Android) Smartphones Bernhard45 15 3.487 24.05.2021, 19:58
Letzter Beitrag: reinersbg
  Ein minimales Internetradio für alte und neue Raspberrys Bernhard45 182 51.540 10.04.2021, 16:23
Letzter Beitrag: Bernhard45
  Adafruit Raspberry Pi Video Looper saarfranzose 10 1.127 08.03.2021, 15:27
Letzter Beitrag: pintel
  JupI - Internetradio navi 8 1.624 26.07.2020, 21:49
Letzter Beitrag: navi
  Philips N2212M Umbau zum Internetradio saarfranzose 0 1.239 21.05.2020, 00:43
Letzter Beitrag: saarfranzose

Gehe zu: