Control LED - Arduino & Raspberry Pi Projekte, How To's und Ideen...

LED Strip Animationen und Effekte mit Python programmieren

Die rpi_ws281xx library ist auf dem Pi erfolgreich installiert und das Testprogramm läuft. Nein???
Kein Problem! Lese dir meinen letzten Beitrag: Adressierung von LED Strips mit dem Raspberry Pi  durch und installier die library.

Und es funktioniert?
Perfekt, in dem Post möchte ich dir coole Animationen zeigen, die du damit programmieren kannst.
Die Codes kannst du aus den Code Containern kopieren oder du lädst dir das fertige Programm aus dem Anhang herunter!


Vielleicht kannst du die Effekte noch verschönern? Die Programme habe ich in Anlehung an das GitHub Repository rpi_ws281xx_library und aus den Arduino Codebeispielen von der Seite Tweaking4All erstellt.  cheeky

 

 

import time, math
from rpi_ws281x import PixelStrip, Color
import argparse

# LED strip configuration:
LED_COUNT = 70       # Number of LED pixels.
LED_PIN = 13          # GPIO pin connected to the pixels (18 uses PWM!).
# LED_PIN = 10        # GPIO pin connected to the pixels (10 uses SPI /dev/spidev0.0).
LED_FREQ_HZ = 800000  # LED signal frequency in hertz (usually 800khz)
LED_DMA = 10          # DMA channel to use for generating signal (try 10)
LED_BRIGHTNESS = 255  # Set to 0 for darkest and 255 for brightest
LED_INVERT = False    # True to invert the signal (when using NPN transistor level shift)
LED_CHANNEL = 1       # set to '1' for GPIOs 13, 19, 41, 45 or 53

 

RPI_ws281x library mit Paramter initialisieren

Als erstes legen wir die Parameter der library fest und importieren die nötigen librarys.

 

Main Routine

 

if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument('-c', '--clear', action='store_true', help='clear the display on exit')
    args = parser.parse_args()
    strip = PixelStrip(LED_COUNT, LED_PIN, LED_FREQ_HZ, LED_DMA, LED_INVERT, LED_BRIGHTNESS, LED_CHANNEL)
    strip.begin()

    print('Press Ctrl-C to quit.')
    if not args.clear:
        print('Use "-c" argument to clear LEDs on exit')
    try:
        while True:
            #Entkommentieren um Programm auszuwählen
            #colorWipe(strip, color)
            #theaterChase(strip)
            theaterChaseRainbow(strip)
            #pulsing_light(strip)
            #snow_sparkle(strip)
            #strobe(strip)
            #bouncing_balls()
    except KeyboardInterrupt:
        if args.clear:
            colorWipe(strip, Color(0, 0, 0), 10)

 

Erklärung: Die Effekte werden in der while Schleife abgespielt. Wird dem Programm das Argument "-c" übergeben, wird bei einem Keyboard Interrupt mit STRG+ C alle LEDs ausgeschalten.

 

1. LED Strip Animation "color_wipe"

"Die Animation "color_wipe" wischt die Farben rot, grün und blau über den LED Streifen. Zum Testen ob alles funktioniert."

 

def colorWipe(strip, color, wait_ms=50):
    """Wipe color across display a pixel at a time."""
    for i in range(strip.numPixels()):
        strip.setPixelColor(i, color)  #Funktion rpi_ws281x.color wandelt DEC in BIN  um
        strip.show()
        time.sleep(wait_ms / 1000.0)

 

Erklärung:
Über die Main Routine wird die Funktion "color_wipe" aufgerufen. Als Funktionsargument wird der Wert Color(r,g,b) übergeben. Durch den import der Datei ws281xx findet man zu der Funktion color den Code. Dort werden die RGB Werte in binäre Werte umgewandelt.
Der Befehl strip.setPixelColor(i, color) benötigt binäre Werte!
 

2. LED Strip Animation "theaterChase"

"In der Animation "theaterChase" wird vorest jede dritte Pixel mit einer definierten Farbe gesetzt(LED=ON). Im Verlauf wird die Pixelnummeriung chronologisch um 1 erhöht. Der Effekt baut Spannung auf."

 

def theaterChase(strip, color, wait_ms=50, iterations=10):
    """Movie theater light style chaser animation."""
    for j in range(iterations):
        for q in range(3):
            for i in range(0, strip.numPixels(), 3):
                strip.setPixelColor(i + q, color)
            strip.show()
            time.sleep(wait_ms / 1000.0)
            for i in range(0, strip.numPixels(), 3):
                strip.setPixelColor(i + q, 0)

 

 

Erklärung:
Der Wert "iterations=10" gibt der Funktion die Anzahl der Wiederholungen, die die Anzahl der Iterationen der for loop bestimmen. In der zweiten for loop wird die Pixelnummerierung jeweils um 1 erhöht. In der dritten for loop werden die LEDs nach dem 3er Intervall System auf die ganze Länge des LED Strips erweitert. In der vierten for loop, die in der dritten eingebettet ist, werden die gesetzten LEDs wieder ausgeschalten.

 

3. LED Strip Animation "theaterChaseRainbow"

"Bei der Animation "theaterChaseRainbow" wird jedes dritte Pixel auf einen Wert im Farbspektrum(Regenbogen) gesetzt. Dadurch entsteht ein farbenprächtiges Spektakel."

 

def theaterChaseRainbow(strip, wait_ms=50):
    """Rainbow movie theater light style chaser animation."""
    for j in range(256):
        for q in range(3):
            for i in range(0, strip.numPixels(), 3):
                strip.setPixelColor(i + q, wheel((i + j) % 255))
            strip.show()
            time.sleep(wait_ms / 1000.0)
            for i in range(0, strip.numPixels(), 3):
                strip.setPixelColor(i + q, 0)

 

Erklärung:
Der Wert für j gibt die Position im Farbrad(Funktion wheel) an. .
Funktion wheel:
♦Zwischen 0-85 wird Rot auf 255 erhöht und Grün sinkt auf 0. Blau bleibt unverändert.
♦Zwischen 85-170 sinkt Rot auf 0 und erhöht und blau steight auf 255. Grün bleibt unverändert.
♦Zwischen 170-255 steigt Grün auf 255 und blau sinkt auf 0. Rot bleibt unverändert.

Sobald die Iteration über das Farbrad den Wert 255 erreicht hat ist der Farbfade vorbei und die Animation zu Ende. Die zweite for loop setzt wie bei dem Programm theaterChase schaltet jeweils eine LED weiter. Die dritte erweitert dieses Muster auf die ganze LED Strip.

 

4. LED Strip Animation "rainbow"

"Das Programm erstellt das Farbspektrum im Abstand zwischen zwei vollen Farben.Ein Rgenbogen ohne Regen. Sowas gibts nur auf LED Strips"

 

 

def rainbow(strip, wait_ms=20, iterations=1):
    """Draw rainbow that fades across all pixels at once."""
    for j in range(256 * iterations):
        for i in range(strip.numPixels()):
            strip.setPixelColor(i, wheel((i + j) & 255))
        strip.show()
        time.sleep(wait_ms / 1000.0)

 

Erklärung:

Der Regenbogen wird über das Farbrad (Funktion wheel erzeugt). Da der Regenbogen jedoch 10 mal angezeigt werden soll würden die Werte wheel(i+j) den Wert 255 überschreiten. Aus diesem Grund wird der Wert 255 mit einem logisch & verglichen. Dieser Vergleich setzt die binären Ziffern nur bei Übereinstimmung auf 1. Die Folge davon ist, das die Zahl 256 eine binäre 00000000  darstellt. So wiederholt sich das Farbrad wieder von vorne.

5. LED Strip Animation "pulsing_light"

"Wie der Name sagt, pulsieren die LEDs auf dem Streifen. Pulsieren deshalb, da die Helligkeitswerte in jedem Pixel nach dem System einer Sinusfunktion sich verändern. Erstaunlich was?"

 

 

 

def pulsing_light(strip, wait_ms=50, iterations=10):
    """Helle LIchteffekte in Kette"""
    position = 0
    for i in range(strip.numPixels() * 2):
        position = position+1
        for j in range(strip.numPixels()):
            strip.setPixelColor(j,Color(round(((math.sin(j+position) * 127 + 128)/255)*255),round(((math.sin(j+position) * 127 + 128) /255)*100), round(((math.sin(j+position) * 127 + 128) /255)*100)))
        strip.show()
        time.sleep(wait_ms/1000.0)

 

 

Erklärung:
Die Farbwerte werden in der Sinus-Funktion generiert. Funktion: math.sin(j+position) * 127 + 128/255) *255
Der Wert der Sinuskurve liegt zwischen 0 und 1. Umso länger die LED Kette, desto höher wird der Wert   (j+position) in deKlammer.
Gefolgt von der Sinusfunktion werden die Werte mit *127+128/255 multipliziert und addiert und zusätzlich durch 255 geteilt. Dese Zahlen verschieben einmal die Sinus-Funktion um +128 Punkte auf der y-Achse und stellen den Sinuswert in Korellation mit dem RGB Wert. (sprich: Welche Werteveränderung der Sinusfunktion , ändern den RGB Wert um 1 Punkt. Durch die Muliplikation von 255 wird der maximale RGB Wert (i.d.Fall 255)
(sprich: Der Hochpunkt der Sinusfunktion hat den RGB Wert 255)

 

6. LED Strip Animation "strobe"

"Schnelle helle Blitze wie aus einem Stroboskop. Das flasht richtig!"

 

 

def strobe(strip, wait_ms=400, strobe_count=7, pulse_count=12):
    from random import randrange
    """LED als springender Ball"""
    for strobe in range(strobe_count):    
        for pulse in range(pulse_count):
            for i in range(strip.numPixels()):
                strip.setPixelColorRGB(i, 255,255,255)
            strip.show()
            time.sleep(randrange(0,45,1)/1000.0)
            for i in range(strip.numPixels()):
                strip.setPixelColorRGB(i, 0,0,0)
            strip.show()
        time.sleep(wait_ms/1000.0)

 

 

Erklärung:
In strobe_count wird die Häufigkeit der Blitze eingestellt. Die Variable pulse_count stellt die Wiederholung der Blitze ein. Die Zeit zwischen den Pulsen ist eine Zufallszahl zwischen 0 und 45 ms time.sleep(randrange(0,45,1). 

 

7. LED Strip Animation "snow_sparkle"

"Aufleuchtender Schneesplitter auch mit Sonnenbrille sehbar. Ja der ist hell!"

 

 

def snow_sparkle(strip,sparkle_delay=20):
    from random import randint
    pixel= randint(0,strip.numPixels())
    speed_delay=randint(100,1000)
    for i in range(strip.numPixels()):
        strip.setPixelColor(i, Color(0x10,0x10,0x10))
    strip.show()
    time.sleep(speed_delay/1000.0)
    strip.setPixelColorRGB(pixel, 255,255,255)
    strip.show()
    time.sleep(sparkle_delay/1000.0)

 

Erklärung:
Eine Zufallspixel, sowie eine Zufallszeit zwischen 100ms und 1 s  werden "ausgewürfelt". Die Ganze LED Strip leuchten leicht weiss mit den Werten(0x10,0x10,0x10) in RGB(16,16,16). Der Zufallspixel leuchtet in der Zufallszeit kurz auf und verschwindet wieder.

8. LED Strip Animation "bouncing_balls"

"Schleudernde LED Pixel nach physikalischen Gesetzen. Wie im Film!"

 

 

def bouncing_balls(strip,ball_count=4, wait_ms=200):

    start_time = time.time()
    ClockTimeSinceLastBounce = [0 for i in range(ball_count)]
    StartHeight=1

    for i in range(ball_count):
        ClockTimeSinceLastBounce[i] = time.time()
    
    Height = [0 for i in range(ball_count)]
    Position = [0 for i in range(ball_count)]
    ImpactVelocity = [0 for i in range(ball_count)]
    ImpactVelocityStart= math.sqrt(-2 * -9.81 * 1)
    Dampening = [0 for i in range(ball_count)]
    TimeSinceLastBounce = [0 for i in range(ball_count)]

    for i in range(0,ball_count,1):
        last_ClockTimeSinceLastBounce = ClockTimeSinceLastBounce[i]
        ClockTimeSinceLastBounce[i] = time.time() - last_ClockTimeSinceLastBounce

        Height[i] = StartHeight
        Position[i] = 0
        ImpactVelocity[i] = math.sqrt(-2 * -9.81 * 1)
        TimeSinceLastBounce[i] = 0
        Dampening[i] = 0.90 - (float(i)/(ball_count**2))

    while True:
        for i in range(ball_count):
            TimeSinceLastBounce[i] = time.time() - ClockTimeSinceLastBounce[i]
            Height[i] = 0.5 * (-9.81) * (TimeSinceLastBounce[i]**2) + ImpactVelocity[i] * TimeSinceLastBounce[i]
            if (Height[i] < 0):
                Height[i] = 0
                ImpactVelocity[i] = Dampening[i] * ImpactVelocity[i]
                ClockTimeSinceLastBounce[i] = time.time()
                if (ImpactVelocity[i] < 0.01):
                    ImpactVelocity[i] = ImpactVelocityStart
                                  
            Position[i] = round(Height[i] * (strip.numPixels()-1)/StartHeight)   #Hier wird die relative Höhe auf die absolute Höhe mit der LED Anzahl umgewandelt.
        for i in range(ball_count):
            strip.setPixelColorRGB(Position[i], 0, 0,255)    
        strip.show()
        for i in range(strip.numPixels()):
            strip.setPixelColorRGB(i, 0,0,0)
            
def snow_sparkle(strip,sparkle_delay=20):
    from random import randint
    pixel= randint(0,strip.numPixels())
    speed_delay=randint(100,1000)
    for i in range(strip.numPixels()):
        strip.setPixelColor(i, Color(0x10,0x10,0x10))
    strip.show()
    time.sleep(speed_delay/1000.0)
    strip.setPixelColorRGB(pixel, 255,255,255)
    strip.show()
    time.sleep(sparkle_delay/1000.0)

 

 

Erklärung:
Es werden Listen erstellt, in denen die Werte(Height, ClockTimeSinceLastBounce, Position...) gespeichert sind. In der Endlosschleife werden die Pixel anhand den Werten die zu setzenden Pixel gerechnet...
 

 

 

Adressierung von LED Strips mit dem Raspberry Pi Zero

Es gibt verschiedene Möglichkeiten um LED Strips anzusteuern. Die einfachste Methode sind handelsübliche LED Controller zu erwerben. Wer jedoch technikbegeistert ist, kann die LED Strips auch selber programmieren. 

Hier möchte ich dir zeigen, wie LED Strips mit dem Raspberry Pi Zero programmierbar sind. Möchtest du die LED Strips mit einem Arduino programmieren schaue dir das Tutorial (Adressierung von LED Strips (WS2812B) mit dem Arduino) an. 

Mit dem Raspberry Pi hast du jedoch noch weitere Möglichkeiten.
Du kannst den Raspberry Pi Zero per App steuern ohne eine extra Bluetoothmodul zu kaufen.
Der RPi Zero ist leicht in SmartHome Systeme integrierbar.

Dieses Tutorial beschreibt die Einrichtung, anhand der rpi281xx  Python library und stellt dir zudem Beipsielprogramm zur Adressierung der LEDs zur Benutzung bereit.

 

1. RP281xx Library downloaden und installieren

 

►Lade den Python Paket Manager herunter.
$sudo apt-get install python3-pip

►Downloade die rpi_ws281x library mittels pip:
$sudo pip3 install rpi_ws281x

►Teste als nächstes, ob du die rpi_ws281x library importieren kannst. Öffne dafür Python3 und importiere die library.
$python3
>>>import rpi_ws281x
>>>exit()


♦Sollte die library nicht gefunden werden, schreibe mir einen Kommentar. 

 

2. Testprogramm installieren und starten in der rpi_ws281x library:

 

►Die library ist installiert. Upgrade nun den Raspberry Pi um die volle Github library inclusive Testprogramme zu downloaden. Update dafür als erstes die respositorys.
$sudo apt update


►Installiere daraufhin die git library
$sudo apt-get install git

►Wechsel nun in den Ordner /usr/local/lib/python3.7/dist-packages 
$cd /usr/local/lib/python3.7/dist-packages 
und clone das ws281x-python git in den Ordner
$git clone https://github.com/rpi-ws281x/rpi-ws281x-python.git

►Öffne den Ornder /examples:
$cd /usr/local/lib/python3.7/dist-packages/rpi-ws281x-python/examples/

►Öffne die Datei "strandtest.py": und trage die folgenden Angaben ein.
$sudo nano strandtest.py

LED_COUNT = ANZAHL DER LEDS AUF DEM LED STRIP
LED_PIN = 13
LED_CHANNEL = 1

Der Raspberry Pi hat 3 Hardwareschnitstellen für den LED Strip (PCM (PIN 21/31), SPI (10/38) und  PWM(12/18). Soltest du die Ansteuerung über SPI machen, ändere in der Datei /boot/config.txt  den SPI Speicher auf 32kb in spidev.bufsize=32768 und die Frequenz in core_freq=250
 

 

 

 

3. Verbindung Raspberry Pi Zero <--> LED Strip

 

Verbinde als nächstes den Raspberry Pi Zero mit dem LED Streifen.


Das ist ganz einfach !.


►Verbinde die Leitung DIN(LED Strip) an GPIO13 (Rpi)

GND(LED Strip) an PIN6(RRi) und an Netzteil -

+5V (LED Strip)an Netzteil +

RaspberryPi Zero WS2812B

 

Um ausfindig zu machen, wo PIN33 ist, schaue dir das Raspbery Pi Zero Pinout Diagramm an:
Raspberry Pi Zero Pinout

 

4. LED Streifen testen mit strandtest.py

Wenn du nun alles richtig angeschlossen hast, teste den LED Streifen mit dem Beispielprogramm (strandtest.py) smiley

►Wechsel, falls noch nicht angewählt in den Ordner : "/usr/local/lib/python3.7/dist-packages/examples"
$cd /usr/local/lib/python3.7/dist-packages/examples


►Öffne die Dateio
$sudo python3 strandtest.py

 

 

 

 

Im nächsten Tutorial erkläre ich, wie die Library für eigene Animationen angewendet werden kann.

Bauteiliste:

Bauteil Beschreibung Link
RGB LED Streifen WS2812B LED Streifen amazon*
affiliate
Bestellen
1x Raspberry Pi Zero WH 1GHZ, 512MB, Bluetooth, Wlan amazon*
affiliate
Bestellen
32 GB Micro SD Karte Speicherkarte + Adapter bis zu 98 MB/Sek, Class10 amazon*
affiliate
Bestellen
300-500Ohm Widerstand Widerstand 1/4W  
Schaltnetzteil 5V, 2A, 10W amazon*
affiliate
Bestellen
Elektroausrüstung Kabel, Stecker, Lochrasterplatine  

 

Raspberry Pi Zero ohne Netzwerk und Bildschirm einrichten

Auf den Rasperry Pi Zero kann großen Aufwand und zusätzliches Material Software installiert werden. Dafür wird keine Netzwerkverbindung verwendet. Die Raspbian Strech Lite Version wird dabei installiert. Die WLAN Einstellungen werden im Dateisystem des installierten Raspbian mittels SSH über USB gesetzt. Somit kannst du für weitere Benutzung den Raspberry PI per PuttY im Wlan erreichen.

Du benötigst dafür:

1x Rasperry PI Zero
1x Mirco SD Card Class 10
1x Micro USB Kabel

 

 

 


 

1. Raspbian Lite Stretch Version downloaden

Als Software empfiehlt sich die Raspbian Strech Lite Version. Sie hat keine Grafikausgabe und eignet sich daher für den Raspberry Pi Zero. 

Auf der offiziellen Raspian Seite für den Raspberry PI kannst du die Stretch Version downloaden:
https://www.raspberrypi.org/downloads/raspbian/

 

2. Raspbian Lite Stretch auf MicroSD Karte flashen

Um Raspbin Lite Stretch auf die Micro SD Karte zu flashen, musst du ein Image Flash Programm wie z.B. Win32DiskImager downloaden:
https://www.heise.de/download/product/win32-disk-imager-92033

Öffne nach dem Download die Setup Datei und installiere des Programm. Nach dem Öffnen von Win32DiskImager musst du die img. Datei wählen und mit dem Klick auf Write auf die SD Karte, wie im folgenden Bild flashen.

Win32DiskImager

 

Achte darauf das die SD Karte im FAT32 Format formatiert und leer ist.

 

 

 

3. Config.txt und cmdline.txt ändern

Als nächstes musst du im boot Verzeichnis des Raspbians die cmdline.txt editieren. Damit die Formatierung nicht zerstört wird, empfehle ich dafür Notepad++ zu downloaden:
https://www.chip.de/downloads/Notepad_12996935.html

► Gehe in das boot Verzeichnis des Raspians und öffne die Datei "config.txt" 

►Scrolle an das Ende der Datei und gebe die Zeile:
dtoverlay=dwc2 
ein.
Speichere die Datei ab.

► Öffne die Datei "cmdline.txt"

► Füge hinter rootwait: "modules-load=dwc2,g_ether" ein, oder kopiere den folgenden Text:

console=serial0,115200 console=tty1 root=PARTUUID=6c586e13-02 rootfstype=ext4 elevator=deadline fsck.repair=yes rootwait modules-load=dwc2,g_ether quiet init=/usr/lib/raspi-config/init_resize.sh

► Erstelle im Boot Verzeichnis eine neue Textdatei und nenne Sie ssh . Die Warnung über den nichtvorhanden Dateityp bestätigen.

♦Die SSH Verbindung wird nun beim booten des Pi's aktiviert.

 

Sollte der Pi vom Strom genommen werden, muss die SSH Datei neu erstellt werden.

 

 

 

 

4. SSH Verbindung und WLAN Verbindung einrichten

Nun ist die Einrichtung für das USB Ethernet fertig. Damit du nun über PuttY eine Verbindung zu dem Pi aufbauen kannst musst du noch die Bonjour Dienste von Apple downloaden und installieren:
https://support.apple.com/kb/DL999

Zudem wird für das USB Ethernet ein Treiber benötigt. Den Treiber dafür findest du im Anhang des Posts.! 
Download rndis_Treiber

►Schließe nun das Mirco USB Kabel an den USB Port des Rasperry Pi Zero an. Achtung: Nicht den Powerport benutzen!

♦Wenn alles richtig eingebeben wurde, sollte nun ein neues Gerät von Windows erkannt werden.(USB Ethernet/RNDIS Gadget)

Sollte kein neues Gerät erkannt werden nochmals prüfen, ob die SD Karte auch wirklich auf FAT32 formatiert wurde. Zudem müssen zwei Partitionen erkannt werden, einmal die boot Partition und das rootfs Partition, sobald man die SD Karte anschließt.

►Stelle nun eine Verbindung über PuttY zu dem Pi her. (user: pi@raspberrypi.local port:22)

►Öffne die Datei "wpa_supplicant"
$sudo nano /etc/wpa_supplicant/wpa_supplicant.conf

►Füge die Zeilen:
network={
             ssid="YOUR_NETWORK_NAME"
             psk="YOUR_NETWORK_PASSWORD"

►Speichere die Datei mit STRG + O und bestäige mit Y(Yes)

►Nun verbinde den Raspberry Pi mit Wlan0
$sudo wpa_cli -i wlan0 reconfigure

►Ermittle die IP Adresse deines Pi's.
$ifconfig

Aktiviere dauerhaft die SSH Verbindung des Pi's.
sudo raspi-config - 5.Interfacing Options- P2 SSH - Mit Yes bestätigen 

►Den Pi rebooten
sudo reboot now

Nun kannst du den Pi aus dem Wlan Netzwerk per PuttY erreichen. (user: 192.168...... port:22)

smiley

 

LCD Display 16x2 HD44780 ansteuern (Arduino und Python)

Um Daten oder Informationen eines Raspberry Pi oder Arduino Projekts, ohne den seriellen Austausch zum PC darzustellen, eignet sich das I2C Dislay Modul. Es ist in den Ausführungen 16x2 (Ziffern x Zeilen) und 16x4 erhältlich. Auf den Zeilen können Buchstaben, Zahlen oder sonstige Ziffern dargestellt werden. Sollte man einen Zugriff auf den Programmablauf benötigen, kann das Modul auch als Auswahlmenü verwendet werden.

 

Wie kommuniziert das LCD Modul mit dem Raspberry PI oder Arduino?

 

Das LCD Modul kommuniziert über das I2C Interface mit den Controllern. Dafür ist der Treiberchip HD44780 auf der Platine integriert. Du musst nur 4 Kabel anschließen um die Übertragung der Messwerte zu starten.

Zusätzlich kannst du die I2C Adresse mit Lötbrücken an den Stellen A0-A2 einstellen, damit keine Adressierungskonflikte mit anderen I2C Geräten entstehen können.

 

<Okay, dann zeig mir mal wie ich das Display benutzen kann!

 

 Also gut!

Ich zeige dir in diesem Tutorial, wie du das Display Modul mit dem Raspberry Pi und dem Arduino benutzen kannst. Für beide Plattformen gibt es bereits librarys, mit denen das Programmieren einfacher wird.

Im Anhang des Posts sind 3 typische Anwendungen als Code zum Download verfügbar. Dabei können mit dem Codes die folgenden Anwendungen ausgeführt werden:

 

►Einen Text auf dem Display ausgeben.

►Längere Texte als Laufschriften darstellen.

►Ein einfaches Menü programmieren.

An welchen Stellen die Variablen der Codes für deine Anwendung angepasst werden müssen, werde ich erklären.

 

1. Anschluss des I2C Display

 

Sowohl für den Arduino als auch für den Raspberry Pi sind I2C fähige Pins auf der Platine integriert. Dafür werden die SDA(Serial Data) und SCL (Serial Clock) Pins benötigt.

Auf den folgenden Skizzen sind die Pins markiert.

I2C Verbindung Arduino LCD Display

 

 

 

I2C Verbindung RaspberryPi LCD Display

 

2.1 Text auf LCD Display ausgeben (LiquidCrystal_I2C Arduino library)

 

Um das Modul mit dem Arduino zu nutzen, benötigst du die LiquidCrystal_I2C library. Sie kann in der Bibliotheksverwaltung der Arduino IDE gedownloadet werden.

• Starte die Arduino IDE- Sketch-Bibliothek einbinden- Bibliothek verwalten.

• Suche die LiquidCrystal_I2C library und lade die aktuelle Version herunter.

• Lade den nachfolgenden Sketch auf den Arduino um das Display zu testen.

Die Funktion der Befehle sind durch die Kommentarzeilen erklärt.

include  //LCD-Bibliothek laden
LiquidCrystal_I2C lcd(0x27, 16, 2)//(Adresse des LCD Treiber 0x26, Ziffern pro Zeile, Zeilen)

void setup() 
{
lcd.init(); 						//lcd wird gestartet 
lcd.backlight(); } 					//backlight wird angeschalten.

void loop() 
{
lcd.setCursor(0, 0); 				//Zeile 1 festgelegt 
lcd.print("Hallo"); 				//Text Zeile 1: Hallo
lcd.setCursor(0, 1); 				//Zeile 2 festgelegt.
lcd.print("Welt"); 					//Text Zeile 2: Welt
}
Hm, alles klar, aber ich sehe gar keine Ziffern.

 

Das Treibermodul ist nun richtig angeschlossen.
Auf dem LCD Modul ist jedoch nichts zu sehen..

Nicht wundern..das ist normal...die Hintergrundbeleuchtung des LCD Displays wird durch das Überbrücken der seitlichen Pins eingeschalten. Ohne die Überbrückung fließt kein Strom. Anstatt die Pins zu überbrücken, kannst du ebenfalls einen Schalter benutzen.

Zusätzlich musst du eventuell an dem Poti drehen um den Kontrast zwischen dem LCD Display und der Hintergrundbeleuchtung einzustellen.

 

LCDDisplay Hintergrundbeleuchtung

 

2.2 Text auf LCD Display Modul ausgeben (RPLCD Python library)

 

Um das Display mit dem Raspberry Pi zu nutzen benötigst du vorerst die RPLCD library. Sie kann über den Paket Manager (PIP) von Python installieren oder du lädst dir die library direkt von herunter.
Auf den neueren Raspbian Versionen ist der PIP Manager bereits vorinstalliert, weshalb du damit die library installieren kannst.
sudo pip install RPLCD

Zusätzlich benötigst du noch die aktuelle I2C Treiber Software.
sudo apt-get install python-smbus

►Starte nun den folgenden Python Sketch um das Display zu testen:

 

from RPLCD.i2c import CharLCD
lcd = CharLCD('PCF8574', 0x27)   			
#Initialisiere LCD Modul 
#'PFC8574' ->Chip des Treibers  
#0x27 -> I2C Adresse 
lcd.cursor_pos = (0,0)				
#Setze Cursor auf Zeile 0 und Spalte 0
lcd.write_string(u'Raspberry Pi')
#Schreibe den String von links nach rechts.
lcd.cursor_pos = (1,0)
lcd.write_string(u'I2C Display')

 

3.1 Lauftexte (LiquidCrystal_I2C Arduino library)

 

Es ist gut möglich, dass der auszugebende Text die Größe der Zeile von 16 Ziffern überschreitet. Sollte der Text zu groß sein, wird die Zeichenfolge abgeschnitten und nur die ersten Ziffern sind lesbar. Die Abhilfe ist ganz einfach!

Programmiere den Schriftzug als Lauftext!

Den folgenden Sketch kannst du dafür verwenden. Ändere die Variable "message" in deinen Text.

#include  
LiquidCrystal_I2C lcd(0x27, 16, 2); 

char message[] = "Beispielsketch für eine Laufschrift";

void setup() {
  lcd.init();
  lcd.backlight();
}

void loop() {
  scroll_text(message, 0);                                                                    /*Ausgabe des Textes in der ersten Zeile (lcd_row = =0) */
}

void scroll_text(char *message, int lcd_row){    
  
for (int printStart = 15; printStart >= 0; printStart--)  {                                   /*Scrollt den Text auf das LCD Modul von rechts nach links. (Print_Start = 15, Letters nach 15 werden abgeschnitten. Print_Start wird verringert bis auf 0. Textfeld voll. */
    showLetters(printStart, 0, message, lcd_row);                                             /*Setzt den Cursor auf Ziffer 15. Die Ziffer wird mit der for-schleife in void show_letters dekrementiert, bis der ganze Schriftzug auf der Zeile zu sehen ist. */
  }
for (int letter = 1; letter <= strlen(message); letter++) {                                   /*Scrollt den Text links aus dem LCD Modul raus. (Print_Start =1 , anzuzeigende Letters  des Strings verringert, bis Text aus dem Feld gescrollt.) */
    showLetters(0, letter, message, lcd_row);                                                 /*Setzt den Cursor auf Ziffer 1 und verringert die Länge des Schriftzugs nach jedem Durchlauf, bis der Text nach links aus dem Anzeigefeld rausgescrollt ist. */
  }
}


void showLetters(int printStart, int startLetter, char *message, int lcd_row) {            
  lcd.setCursor(printStart, lcd_row);                                                         /*Setzt den Cursor auf die Position print_Start */
  for (int currentLetter = startLetter; currentLetter < strlen(message); currentLetter++) {   /*Greift auf die Buchstaben des Text zu. */ 
    lcd.print(message[currentLetter]);                                                        /*Zeigt, die in den Funktionsargumenten übergebenen Ziffern an. */
  } 
  lcd.print(" ");                                                                             /*Falls keine Buchstaben nachrücken, schreibt leer */ 
  delay(400);                                                                                 /*Zeit zwischen dem Scrollen */
}

3.2 Lauftexte (RPLCD I2C Python library)

 

Der Sketch für die Ansteuerung mit dem Raspberry Pi mit Python. Das Prinzip ist das gleiche, wie bei der Arduino Version. Als erste wird der Text mit der for schleife (for shifts in range(1,digits+1,1):) von rechts nach links in das LCD Feld eingeschoben und sobald alle Ziffern zu sehen sind, wird der Text auf der rechten Seite abgeschnitten (for outshift in range(1,len(text)+,1):)

Um den Text zu ändern, kannst du das String Argument für den Funktionsaufruf "scroll_text('String', 16, lcd)" mit einem beliebigen Text ersetzen.

 

import time
from RPLCD.i2c import CharLCD
lcd = CharLCD('PCF8574', 0x27)

def scroll_text(text, digits, lcd):
    
    for shifts in range(1,digits+1,1):
		lcd.clear()
        lcd.cursor_pos = (0,(digits-shifts))
        lcd.write_string(text[:shifts])
        time.sleep(0.4)
              
    for outshift in range(1,len(text)+1,1):
		lcd.clear()
        lcd.cursor_pos = (0, (digits-shifts))
        lcd.write_string(text[outshift:len(text)])
        time.sleep(0.4)
        
scroll_text('Beispielcode für einen Lauftext', 16, lcd) 

Ok, der Code funktioniert zwar... ABER... der hintere Teil des Textes wird immer auf die zweite Zeile von meinem LCD Moduls umgebrochen? So bringt mir das nichts!

 

Ja das stimmt. Das liegt an der RPLCD library. In dem Code wird in der Zeile lcd eine Instanz der Klasse CharLCD mit den Parametern (PCF8547, 0x27) angelegt. Dabei steht PCF8574 für den Treiberchip. Der Wert 0x27 steht für den Adressierungswert im I2C Interface. Die Klasse beinhaltet noch einen weiteren Parameter "auto_linebreaks".

Ändere die Zeile 3 in: 

lcd = CharLCD('PCF8574', 0x27, auto_linebreaks = True)

Wie du siehst, gibt es einen weiteren paramater "auto_linebreaks". Um die Zeilenumbrüche zu deaktivieren, musst du den Parameter auto_linebreaks auf False stellen (auto_linebreaks = False).

 

3. LCD Display Auswahlmenü (LiquidCrystal I2C library)

 

Zum Schluss ist hier das Auswahlmenü für den Arduino . Die Navigation des Auswahlmenüs kannst du mit Tastatureingaben über den seriellen Monitor ausführen kannst. Dabei soll mit den Tasten "u" für up, "d" für down und "e" die Auswahl "Schrift""Alphabet" und "Countdown" ausgewählt werden können.

Die Kommunikation verläuft über die serielle Verbindung zum PC. Sobald eine Eingabe gesendet wurde, werden die zugehörigen Funktionen (void Schrift{}, void Alphabet{}, void Countdown{} aufgerufen.)

Die aktuelle Auswahl ist als Lauftext gekennzeichnet. Den Code findest du im Anhang im Ordner Arduino_I2C_Display.rar.

Die Menünamen kannst du ändern, indem du char select1, char select2, char select3 in deine gewünschten Menünamen änderst. Wenn du mehr Menüauswahlen haben möchtest, kannst du weitere char Variablen hinzufügen.

char select1[] = "Schrift";
char select2[] = "Alphabet";
char select3[] = "Countdown";
/* char select4 = {"Weitere Auswahlmöglichkeit"}..
 *  .....
 *  weitere Auswahlmöglichkeiten mit char4,char5... hinzufügbar
 */

typedef void (* GenericFP)();

char *auswahl[] = {select1, select2, select3);
 GenericFP f_menu[3] = {&Schrift, &Alphabet, &Countdown};		/*Funktionszuweisung zu Auswahlmöglichkeiten */

Beachte jedoch, dass du die neu erstellen Menünamen zudem in den Pointer char *auswahl (Zeile 15) eintragen musst.

Weiterhin sind die Menünamen Funktionen zugeordnet. Sollest du andere Menünamen verwenden, musst du zudem die Funktionnamen als auch die Zuweisung in GenericFP f_menu[3] (Zeile 16) ändern.

Solltest du mehr als 3 Menüs benötigen musst du die Listengröße [3] dementsprechend vergrößern.

Die Funktionen (void Schrift{}, void Alphabet{}, void Countdown{}) sind separaten Tabs eingefügt. Solltest du die Menünamen geändert haben, musst der Funktionsname anstatt void Schrift{} --> void (dein Menüname){} lauten.

Falls es nicht funktioniert, schreibe mir einen Kommentar oder eine Mail.


 

3.1 LCD Display Auswahl Menü (RPLCD python library)

 

Das Auswahlmenü in Python funktioniert ähnlich wie das in C. Der Unterschied liegt in der Darstellung des aktuell angewählten Menüs. Das auszuwählende Menü ist durch einen Pfeil gekennzeichnet.

Den Code findest du im Anhang als Python_LCD_Display.rar
 

Die Auswahlmöglichkeiten kannst du anpassen, indem du die Werte des Tuple "menu_home" änderst. Der erste String Wert wird auf dem LCD Modul angezeigt, der zweite ist die jeweilige Funktion, die bei der Auswahl ausgeführt wird.

Die Navigation erfolgt mit den Tasten u(up), d(down), e(enter).

Auswahlmenü


Der Code könnte beliebig mit Untermenüs aufgefüllt werden. Ich hoffe ich konnte dir mit Tutorial weiterhelfen.

 

7 Segmentanzeige HT16K33 mit Raspberry Pi im I2C ansteuern

Eine einfache Methode zur Darstellung von Informationen sind 7 Segmentanzeigen. Sie werden in vielen Geräten (Backofen, DVD Player...) genutzt, um Werte anzuzeigen.

Für Elektronikprojekte sind die Anzeigen sehr praktisch, weshalb es diverse 7 Segmentanzeigen im Internet zu kaufen gibt. Sie können direkt über die I/O Pins angesteuert werden, wobei mehrere Leitungen benötigt werden. Dafür sind jedoch mehrere Kabel nötig, weshalb es zudem fertige 7 Segmentmodule mit I2C Treiber zum bestellen gibt.

Die Möglichkeit das Modul in das I2C Interface zu integrieren ist für mein Projekt sinnvoller, weshalb ich mir 7 Segmentanzeigen mit den HT16K33 Treiber bestellt habe.

Zudem kann über die Verbindung der Stellen A0-A2 mit Lötbrücken die I2C Adresse zwischen 0x70 und 0x77 eingestellt werden. Damit lassen sich Adressüberschneidungen mit anderen I2C Geräten verhindern.

Die Ansteuerung ist dank der bereits veröffentlichen Library von Adafruit sehr simpel.

Angeschlossen habe ich die 7 Segmentanzeige an einen Rasperry Pi. Für den Arduino gibt es ebenfalls eine library. Dieses Tutorial erklärt die Ansteuerung mit dem Raspberry Pi.

Na gut. Ich habe zwar im Moment noch keine Ahnung wozu ich die 7 Segmentanzeigen einsetzen soll, aber eine Uhr lässt sich doch gut mit den 4 Ziffern darstellen. Kannst du mir erklären, wie ich die Uhrzeit auf den 7 Segmentanzeigen anzeigen lassen kann?

 

 Na gut, ich erkläre dir in diesem Tutorial, mit welchen Funktionen du die 7 Segmentanzeige ansprechen kannst. Als Anwendungsbeispiel füge ich den Code zur Uhranzeige hinzu. Danach weisst du, wie die 7 Segmentanzeigen funktionieren.

 

1. Installation der Python library

 

►Als ersten lädst du dir die Library von github auf den Pi:
git clone https://github.com/adafruit/
Adafruit_Python_LED_Backpack.git


►Wechsel in den gedownloadeten Ordner:
cd /home/pi/Adafruit_Python_LED_Backpack

►Installiere die library:
sudo python setup.py install (Installation für Python2)
oder
sudo python3 setup.py install (Installation für Python3)

Da die library direkt aus Github eingefügt wurde, empfiehlt es sich den Ordner in den library Ordner deiner angewendeten Python Version kopieren. Der Vorteil dabei ist, dass du von jedem Ort im Linuxdateisystem die library in deine Python Skripte importieren kannst. Ich benutze die libray für Python3, weshalb ich den Ordner nach usr/local/lib/pythob3.5/dist-packages kopiere.
sudo cp -R /home/pi/Adafruit_Python_LED_Backpack /usr/local/lib/python3.5/dist-packages

 

2. Verkabelung des Moduls

 

Für das Modul sind 4 Kabel notwendig. Das nachfolgende Bild zeigt die Verbindung.

7SegmentVerkabelung

Die Pinouttabelle des Raspberry Pi findest du auf google.

Die Verbindung zum I2C Bus kannst du testen. Solltest du den I2C Bus noch nicht aktiviert haben, aktiviere zuerst den I2C Interface des Raspberry Pi.

►Gehe dafür in das Raspberry Pi Software Configuration Tool:

►Wechsel in das Menü "Interfacing Options" und aktivier den I2C interface unter Punkt 5.
 

I2C aktivieren
 

►Reboote den Rasperry Pi und suche nach verbunden I2C Geräten:
sudo i2cdetect -y 1

♦Dort müsste jetzt das Modul unter der Adresse "0x70" gefunden werden.
 

I2C Devices auflisten


So, das wars. Jetzt kann die 7 Segmentanzeige mit der library programmiert werden. Falls das Modul nicht gefunden wurde, überprüfe nochmals die Verkabelung.

 

3. Testen der 7 Segmentanzeige

Im nächsten Schritt programmiere ich die 7 Segmentanzeige. Da per default in der library bereits die Adresse "0x70" eingestellt ist, kann das Modul direkt getestet werden.

►Wechsel dafür in den Ordner home/pi/examples:
cd home/pi/Adafruit_Python_LED_Backpack/examples

und starte das Testskript:
sudo python3 sevensegment_test.py

Es müssten einige Ziffern und Zeichen ausgeben werden.

Ok, es funktioniert. Wie importiere ich die Library in mein Python Skript und mit welchen Befehlen kann ich das Modul ansprechen.

 

4. Beispielcode zur Anwendung des HT16K33 Modul

Die Funktionen der library sind einfach. Schau dir das nächste Codebeispiel an.


from Adafruit_LED_Backpack import SevenSegment as ss
import time

sv1 = ss.SevenSegment()    #Instanziert Klasse SevenSegment als sv1 um mit sv1.[Funktionsname ] auf Funktionen zuzugreifen

sv1.begin()                #Beginnt Übertragung

numbers = [1,2,3,4,5,6,7,8,9]

bitmask = [0x64, 0x1B, 0x7F]

def show_numbers(numbers):               
    for i in numbers:
        sv1.clear()             #Löschen der aktuellen Displayausgabe
        sv1.set_colon(True)     #Doppelpunkt in der Mitte setzen
        sv1.set_digit(3, i)     #Setzt Nummern (i) an Stelle 3 (recht)
        sv1.write_display()     #Schreibt Werte auf Display 
        time.sleep(1)           #Warten 1 Sekunde

def show_bitmask(bitmask):
    for i in bitmask:
        sv1.clear()
        sv1.set_brightness(15)          #Helligkeit zwischen 1 und 15   
        sv1.set_colon(False)            #Doppelpunkt nicht setzen
        sv1.set_digit_raw(0, i)   		#Setzt die Segmente aus Bitmaske
        sv1.write_display()             #Schreibt Werte auf Display
        time.sleep(1)   				#Warten 1 Sekunde

    
show_numbers(numbers)       
show_bitmask(bitmask)

Um das mit Python anzusteuern muss es am Anfang des Skripts importiert werden:
from Adafruit_LED_Backpack import SevenSegment as ss

Als nächstes wird in der Datei SevenSegment.py die Klasse Sevensegment als sv1 instanziiert.

Durch die Instanz sv1 wird auf die Funktionen zugegriffen werden. Mit dem Befehl sv1.begin() wird die Kommunikation zwischen dem Raspberry Pi und dem Modul gestartet.

Die 7 Segmentanzeige hat 4 Ziffern. Um eine Ziffer anzuwählen wird die Funktion sv1.set_digit(ziffer, wert) verwendet. Mit den Werten (0-3) kann die Ziffer ausgewählt werden. Welches Zeichen angezeigt werden soll, wird in die Variable Wert eingetragen. Die Werte können vom Zahlen (integer als Datentyp) oder Buchstaben (string als Datentyp) sein.

Um den gesetzten Wert auf die gewählte Ziffer zu übertragen wird die Funktion sv1.write_display() verwendet.

Über die Funktion sv1.set_colon(boolean) kann der Doppelpunkt in der Mitte mit False oder True an bzw. ausgeschalten werden.

Eine einfache Möglichkeit mehrere Werte auf der Anzeige auszugeben, ist in der Funktion def show_chars(chars): zu finden.

In der Funktion def show_bitmask(bitmask) wird die 7 Segmentanzeige mit nicht mit Zeichen beschrieben sondern direkt mit binären Daten. Jedes Segment benötigt die Information (an oder aus), welche in einer Bitfolge an das Segment gesendet werden. Wie die Bitreihenfolge mit der Segmentanordnung zusammenhängt, siehst du auf der nachfolgenden Grafik.

7 Segment Bitmasken

 

Mit dem Befehl sv1.set_digit_raw(ziffer, wert) können direkt binär oder hex Werte gesetzt. Die Ziffern in der Funktion sv1.set_digit(ziffer, wert) werden in der library bereits zu HEX Werten für die 7 Segmentanzeige umgewandelt, da der Treiber in bytes arbeitet und nicht mit integer oder strings.

Mit dem Befehl sv1.set_brightness(int) können Helligkeitswerte zwischen 1 und 15 eingestellt werden.

 

 

5. Datetime Python Modul auf 7 Segmentanzeige

 

Zum Schluss habe ich noch einen Code erstellt, mit dem die die aktuelle Uhrzeit auf der 7 Segmentanzeige darstellen kannst. Dafür wird zusätzlich die datetime library benötigt, mit der die aktuelle Uhrzeit in Python Programme importiert wird.

from Adafruit_LED_Backpack import SevenSegment as ss
import time,datetime

sv1 = ss.SevenSegment()							#Instanziert Klasse SevenSegment als sv1 um mit sv1.[Funktionsname] auf Funktionen zuzugreifen

sv1.begin()                						#Beginnt Übertragung

global switch_colon
switch_colon = 0

def show_clock():
    global switch_colon					
    switch_colon = 1 - switch_colon 		    #Switch Variable 0->1(True); 1->0(False) für blinkenden Doppelpunkt
    now = datetime.datetime.now()				#Aktuelle Uhrzeit aus datetime modul laden	
    hour = str(now.hour).zfill(2)				#Stunden zweistellig darstellen 4 Uhr-> 04; zfill(2) stellt 0 voran.
    minute =str(now.minute).zfill(2)			#Minuten zweistellig darstellen 3 Minuten-> 03; zfill(2) stellt 0 voran.
    time_now = "".join((hour, minute))  		#Minuten und Stunden als String umkonvertieren
    sv1.clear()									#Siebensegement Ausgabe löschen
    sv1.set_colon(switch_colon)					#Doppelpunkt setzen	
    for index, digit in enumerate(time_now, 0): #Anzahl Elemente in time_now durchgehen und nummererien in variable 'digit' 1. Zahl ->0 2.Zahl-1
        sv1.set_digit(index, int(digit))		#Setzt Wert aus time_now und an die Stelle auf der 7 Segmentanzeige	

         
    sv1.write_display()							#Schreibt werte auf Display
    time.sleep(1)								#1 Sekunde warten
     
while True:
    
    show_clock()								#Endlosschleife für Uhrzeitanzeige 

Die Uhrzeit wird auf der 7 Segmentanzeige angezeigt. Ich hoffe ich konnte dir mit dem Tutorial helfen. Die Codebeispiele kannst du im Anhang downloaden. 

wink

 

Direkte Verbindung zwischen Raspberry Pi und Windows PC aufbauen

Falls man unterwegs den Raspberry Pi benutzen möchte und nicht in seinem Heimnetzwerk eingeloggt ist, kann dies mit einem Crossoverkabel und der Internetfreigabefunktion von Windows ermöglicht werden.
Du benötigst dafür ein Crossoverkabel Ethernet Kabel. Wie du den Rasperry Pi und die WLAN Verbindung deines Laptops auf die LAN-Verbindung zum Raspberry Pi weiterleiten kannst, zeige ich dir in der folgenden Anleitung:
Als erstes muss der Laptop mit dem Internet über WLAN verbunden sein. Die Ethernetbuchse des Laptops ist demnach frei. Über den Etherneteingang wird eine Verbindung mittels Crossoverkabel zum Raspberry Pi hergestellt.

► Sobald die Verbindung zwischen Windows und dem Raspberry Pi hergestellt is, sollte unter Systemsteuerung-Netzwerk und Freigabecenter ein "Nicht identifziertes Netzwerk" mit dem "Verbindungstyp: LAN-Verbindung aufgelistet sein.

 

Ethernet Verbindung

 

►Klicke nun auf "LAN-Verbindung" und dann auf "Details", jetzt öffnet sich eine Liste über die Details der Verbindung. Die Adresse aufschreiben(rot), da sie im 2ten Teil als Gateway am Raspberry Pi eingetragen werden muss.

 

DNS Server

 

►Als nächstes die Wlan- Internetverbindung für die LAN Verbindug freigeben. Unter Systemsteuerung/Netzwerk und Freigabecenter auf Drahtlosverbindung(Name des Routers) klicken. Nun auf Eigenschaften und unter dem Reiter "Freigabe" klicken.
♦Nun geht ein Fenster auf das so aussieht.
 

Internetfreigabe

►Häkchen setzen und in der Listbox die LAN-Verbindung zum Raspberry Pi auswählen. Nun hat der Raspberry Pi ein Internetverbindung!

► Leider ändert sich nach jedem Boot des Raspberry Pi die IP Adresse. Abhilfe schafft es, indem du dem Raspberry Pi eine statische IP zuweist.
Dafür die datei "dhcpcd.conf" über das Terminal öffnen. sudo nano /etc/dhcpcd.conf öffnet das config file für Netzwerkverbindungen.

►An das Ende der .config Datei gehen und folgende Zeilen eintragen. Meine Settings sehen so aus:

 

DHCP Config

 

♦static ip_adress: Der IP Bereich kann zwischen (0-255 zugewiesen werden). Hier: 248

♦static routers: Die IPv4 Verbindung die in Punkt 2 angezeigt wird.

♦static domain_name_servers: (Gateway IP ist die gleiche wie die IPv4 Verbindung in static routers)

Nun hat dein Ethernetport des Raspberry Pi's, immer die gleiche IP Adresse, sobald eine Ethernetverbindung aufgebaut wurde.

 

 

Raspberry Pi per grafischer Oberfläche über Windows bedienen TightVNC

Manchmal bediene ich den Raspberry Pi im Raspbian Desktop Modus. Jedoch nervt es mich immer Tastatur, Bildschirm und Maus einzustecken. Jetzt habe ich zwei Möglichkeiten im Internet gefunden, wie die Raspberry Pi Oberfläche über das Netzwerk auf meinen Laptop übertragen werden kann.
Es gibt das Netzwerkprotokoll X11, dass Daten aus dem Netzwerk empfängt und die Eingabe und Ausgabe über eine grafische Benutzeroberfläche ermöglicht. Die Schnittstelle am Raspberry Pi ist lxde(Lightweight X11 Desktop Environment). Für private Zwecke ist die Software (XMing) kostenlos verfügbar. Das Programm dient als Server für die Kommunikation.

In diesem Post zeige ich dir, wie du:
 

♦I. Die lxde Oberfläche per Xming zur Eingabe/Ausgabe benutzen kannst.

♦II. TightVNCServer zur Netzwerkausgabe des Raspbian Bildschirm installierst.

 

Bevor der Xming Server oder auf deinem PC Daten vom Raspberry PI empfangen kann muss bereits eine SSH Verbindung zum Raspberry Pi möglich sein. Hier habe ich bereits eine Anleitung gepostet. -> Raspberry Pi Einrichten und SSH Verbindung aufbauen
Im folgendem ist eine Schritt-für-Schritt Anleitung, wie du PuttY und XMing, sowie die sshd_config am Raspberry Pi einrichtest, damit es funktioniert.

 

I. Remote Control mit lxde

1. Xming downloaden:

► Xming auf sourceforge downloaden. Xming Server für Windows
► Xming installieren. Einstellungen gibt es da keine die du ändern musst.

2. Putty einstellen:

Unter dem Reiter SSH auf X11 Forwarding klicken und Häckchen bei "Enable X11 forwarding".
Bei X display location: "1" eintragen (Das ist der Port über den Xming Daten empfängt)

X11 Forwarding

 

3. sshd_config in etc/ssh ändern:

►Über Putty am Raspberry Pi einloggen und: $sudo nano /etc/ssh/sshd_config eingeben.
►In der Datei nach unten scrollen und die Kommentar Raute bei "AllowTcpForwarding" und "X11 Forwarding" entfernen. Hinter den Namen muss "yes" stehen.

sshd config

 

4. Xming Starten:

►In den Ordner C:\Program Files (x86)\Xming gehen.
►XLaunch.exe als Administrator ausführen (!!)
►Im Textfeld Display number "1" eingeben. Das ist der Port den du auch schon bei Putty eingegeben hast. In diesem Menü kannst du einstellen was übertragen werden soll. Ich habe es auf "One window" gestellt. Dann ist alles da, Taskleiste, Desktopsymbole usw...

Xming 

 

5. lxde (Desktopumgebung für X11) starten:

► Einloggen in Putty.
► startlxde eingeben, nicht sudo startlxde dass geht nicht.

Start LXDE

►Nach einer kurzen Ladezeit startet die Desktopumgebung und sieht so aus -> lxde

LXDE Oberfläche

 

II. Remote Control mit TightVNCServer

1. TightVNCServer in Windows installieren:

►TightVNCServer downloaden und installieren-> TightVNCServer

 

2. TightVNCServer auf dem Raspberry Pi donwloaden und installieren:

►Im LXTerminal eingeben: $sudo apt-get install tightvncserver
►TightVNCServer starten: $tightvncserver
►Passwort einrichten. Es muss später bei zum Zugriff über Windows eingegeben werden!
► Nun läuft der TightVNCServer auf Port 1. So sollte die Terminalausgabe aussehen

 

3. TightVNCServer beenden:

►Falls du den Server stoppen willst, musst du den Prozess beenden. Dabei muss die Prozess ID rausgesucht werden. Im LXTerminal: "$ps -ax | less"
►Mit der "Pfeil nach unten Taste" den Prozess Namen suchen indem irgendwo "tightvncserver" (gelb) steht. Die Prozess ID(PID)(rot) merken. 

Stop Tight VNC

► Q drücken. ->Prozessliste beenden
► $sudo kill (Prozess ID) beendet den Prozess.

 

4. TightVNCServer Einstellungen:

►Falls du du andere Bildschirmeinstellungen einstellen willst, kannst du sie einstellen indem du beispielsweise: 
$tightvncserver :1 -geometry 1920x1080 -depth 24 -dpi 96 eingibst
► Der Raspbian Desktop wird dadurch mit der Auflösung 1920x1080 (-geometry 1920x1080), Farbtiefe 24 Bit( -depth 24) und mit 96 Bildpunkten/Zoll(- dpi 96) ausgegeben.

 

5. TightVNCView in Windows starten:

►TightVNCView starten und deine IP:Port eingeben.

Tight VNC Windows


►Auf Connect drücken und das erstelle Passwort in Punkt 2 eingeben. 

 

TightVNCView
 

Nach jedem Neustart muss $tightvncserver, oder wie in Pkt.4 erklärt mit den extra Argumenten für die Bildschirmausgabe eingeben werden.

Raspberry Pi Einrichten und SSH Verbindung aufbauen

Der RaspberryPi ist ein kostengünstiger Mini Computer, der für vielerlei Anwendungen benutzt werden kann. Es können sowohl sämtliche Peripheriegeräte über USB als auch Module über Bus Schnittstellen angeschlossen werden. Die Bedienung ist einerseits direkt mit einem Bildschirm (HDMI) und einer Tastatur (USB) möglich, jedoch kann ebenfalls eine Verbindung über WLAN mittels SSH Tunnel aufgebaut werden. Im zweiten Teil dieses Posts, findest du eine Anleitung wie die SSH Verbindung eingerichtet werden kann. Außerdem wird ein Root Passwort erstellt um über SSH Dateien übertragen zu können.

Als erstes wird mit dem Programm Win32DiskImager die neuste Raspbian Version auf der Micro SD Karte installiert. Es gibt noch weitere Linux bzw. Debian Distributionen und komprimierte Windows10 Version, die mit dem RaspberryPi kompatibel sind, jedoch ist Raspbian das am weitesten verbreiteste System. Falls du den RaspberryPi als Mediacenter verwenden willst, bietet sich die Kodi Distribution openELEC an. In dieser Anleitung installiere ich Raspbian.

 

1. Download von Raspbian und Win32DiskImager:

►Raspbian: 
www.raspberrypi.org/downloads/raspbian/

►Win32DiskImager: 
www.chip.de/downloads/Win32-Disk-Imager_46121030.html

 

2. Raspbian mit Win32DiskImager auf SD Karte flashen:


►"Win32DiskImager" öffnen

Raspbian.img auswählen und "Write" drücken.

 

Win32DiskImager

 

3. RaspberryPI booten und WLAN Verbindung aufbauen (Bei Kabelverbindung diesen Schritt überspringen):


►Auf WLAN Symbol in Taskleiste klicken.

►Verbinden.

4. Zeitzone und deutsche Tastatur(QWERTZ) einstellen:

►Nach der Installation von Raspbian ist die US Zeitzone (CST) eingestellt. In der raspi-config kann bei über Punkt 4. Localisations Options die Mitteleuropäische Zeitzone (MEZ) eingestellt werden. Das gleiche gilt für das Tastaturlayout. Im Englischen ist die Tastaturbelegung (QWERTY) und Sonderzeichen liegen auf anderen Tasten.

► Den Bindestrich für den Befehl "$raspi-config" mit der Taste -->ß eingeben.
 

QWERTZ Tastatur einrichten
 

5. SSH Verbindung einrichten:


►Im Terminal "$sudo raspi-config" eingeben

►Einrichtung (siehe nächstes gif)
 

SSH Verbindung aktivieren
 

6. IP anzeigen:

 

►Im Terminal "$ifconfig" eingeben

►IP aufschreiben, bei Ethernet Verbindung die IP bei eth0 aufschreiben.
 

IP Adresse anzeigen
 

7. Root Passwort vergeben:


►Damit ein voller Zugriff auf das Dateisystem möglich ist muss ein root Passwort vergeben per "$sudo passwd" werden. Nachdem das Passwort vergeben wurde ist eine Anmeldung neben pi@raspberrypi auch die Anmeldung root@raspberrypi möglich.

►Root Passwort einstellen.
 


 

8. PuTTy und FileZilla downloaden und installieren:


►PuTTy: 
www.chip.de/downloads/PuTTY_12997392.html

►FileZilla: 
www.chip.de/downloads/FileZilla_13011076.html
 

9. SSH Connection Aufbauen:


►PuTTy Verbindung: Nach dem Start von puTTy wirst du nach der IP gefragt auf die du zugreifen willst. Dort die IP eingeben, die in Punkt 5 ausgeben wurde. Um die SSH Verbindung zu beenden "exit" eingeben.

►Filezilla Verbindung: Damit Dateien kopiert und geschrieben werden können, muss als Root User eingeloggt werden. Dafür im Textfeld Host: sftp://192.168...(IP) und Port:22 eingeben und über Quickconnect Verbindung aufbauen. Um die Verbindung zu beenden, die Tastenkombination "STRG+D" drücken.

►Falls mit dem Username root keine Verbindung möglich ist, die Datei "sshd_config" ändern. 

►Die Datei mit STRG + O abspeichern und mit ENTER bestätigen.

 

SSH Verbindung Filezilla