Treppenstufenbeleuchtung mit dem Raspberry / Schritt zum Arduino

don

Wieder was gelernt
Und werde weiter probieren.

don

.

Python

def lights(order='up', mode='on'):
    start = 0
    stop = pixels.count()
    direction = 1  
    if order == 'down':
        start = 31
        stop = -1
        direction = -1
    hue = 0
    if mode == 'on':
        hue = 255
    for i in range(start, stop, direction):
        pixels.set_pixel(i, Adafruit_WS2801.RGB_to_color(hue, hue, hue))
        pixels.show()
        time.sleep(0.05)

Alles anzeigen

Warum es bis -1 zählen muss bei Zählrichtung -1 ist mir nicht klar.
Von 32 runter auf 0 erzeugt ein "out of range". Von 31 auf -1 geht hingegen.
Aber läuft.
Jetzt wird getestet, ob US-Sensor oder doch PIR besser läuft.
Dank an @BJ1 für's an die Hand nehmen

PvD

Bei range(x,y) wird ab einschließlich x bis ausschließlich y gezählt. range(0,10) ergibt 0...9, negativen Werte range(31,-1,-1) ergeben 31...0. Frei nach Peter Lustig: 'Klingt komisch, ist aber so'

Schön, dass es funktioniert.

DaVu

@BJ1

Wenn ich da mal nachhaken darf (gerade weil mich python grundlegend interessiert )....

Zitat von don

Von 32 runter auf 0 erzeugt ein "out of range". Von 31 auf -1 geht hingegen.

Für mich klingt es so, als würde:

range(32,0,-1) bei @don ein "out of range" ergeben, ein range(31,-1,-1) funktioniert aber. Warum das erste einen out of range ergibt, würde mich aus Neugierde auch interessieren. Die Schritte sind doch gleichen (also zumindest die grundlegende Anzahl). Nur die Werte, diie rauskommen, sind unterschiedlich. Beim ersten wird von 32 bis 1 (einschließlich) gezählt. Beim zweiten von 31 bis 0 (einschließlich). Die Anzahl ist aber identisch.

ClaudiaF

Grundsätzlich funktioniert das eine wie das andere,
die Frage ist, was wird mit dem Integer gemacht?
Heisst wenn Du zum Beispiel versucht,
das 32ste Elemenet einer Liste die bei 0 das zählen anfängt haben willst,
musste Du tatsächlich 31 abfragen. 32 wäre da out of range.

DaVu

Richtig, das wäre das einzige.

Wenn ich es richtig verstehe meinst du, wenn ich 31 LEDs habe ich nicht mit range(32,0,-1) anfangen kann, da es keine 32. LED gibt?!

ClaudiaF

Jein, wenn Du 32 Leds hast,
diese aber als 0-31 addressiert werden,
dann würde beim Versuch die 32 zu bekommen
etwas fehlschalgen.

Wo ist den der Code? Ist der öffentlich?
Kann man den sich anschauen?

don

Kommt heute. Habe gestern alle Varianten durchgespielt und dokumentiert.

don

Ich habe alle Varianten durch. 1x oder 2x Ultraschall oder Bewegungsmelder sowie gemischt.
Das habe ich vor allem dafür gemacht, um durch Wiederholung und leichter Abwandlung etwas zu lernen.
Hier die Scripte (ist nur für Anfänger interessant, die Unterschiede abzuarbeiten. Der Laufzeilencode "def lights" ist immer identisch.)

2x Bewegungsmelder:

Python

import RPi.GPIO as GPIO
import time
import Adafruit_WS2801
import Adafruit_GPIO.SPI as SPI


SENSOR_PIN = 23
GPIO.setmode(GPIO.BCM)
GPIO.setup(SENSOR_PIN, GPIO.IN)


SENSOR_PIN2 = 22
GPIO.setmode(GPIO.BCM)
GPIO.setup(SENSOR_PIN2, GPIO.IN)


PIXEL_COUNT = 32
SPI_PORT   = 0
SPI_DEVICE = 0
pixels = Adafruit_WS2801.WS2801Pixels(PIXEL_COUNT, spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE))




def lights(order='up', mode='on'):
    start = 0
    stop = pixels.count()
    direction = 1  
    if order == 'down':
        start = 31
        stop = -1
        direction = -1
    hue = 0
    if mode == 'on':
        hue = 255
    for i in range(start, stop, direction):
        pixels.set_pixel(i, Adafruit_WS2801.RGB_to_color(hue, hue, hue))
        pixels.show()
        time.sleep(0.05)


def up(channel):
    print('unten (1)')
    pixels.clear()
    lights()
    time.sleep(1)
    lights(mode='off')


def down(channel):
    print('oben (2)')
    pixels.clear()
    lights(order='down')
    time.sleep(2)
    lights(order='down', mode='off')


try:
    GPIO.add_event_detect(SENSOR_PIN , GPIO.RISING, callback=up)
    GPIO.add_event_detect(SENSOR_PIN2 , GPIO.RISING, callback=down)
    while True:
        time.sleep(0.001)
except KeyboardInterrupt:
    print "Beende..."
GPIO.cleanup()

Alles anzeigen

2x Ultraschall:

Python

import RPi.GPIO as GPIO
import time
import Adafruit_WS2801
import Adafruit_GPIO.SPI as SPI


GPIO.setmode(GPIO.BCM)
GPIO_TRIGGER1 = 18
GPIO_ECHO1 = 24
GPIO_TRIGGER2 = 17
GPIO_ECHO2 = 23


GPIO.setup(GPIO_TRIGGER1, GPIO.OUT)
GPIO.setup(GPIO_ECHO1, GPIO.IN)
GPIO.setup(GPIO_TRIGGER2, GPIO.OUT)
GPIO.setup(GPIO_ECHO2, GPIO.IN)


PIXEL_COUNT = 32
SPI_PORT   = 0
SPI_DEVICE = 0
pixels = Adafruit_WS2801.WS2801Pixels(PIXEL_COUNT, spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE))




def lights(order='up', mode='on'):
    start = 0
    stop = pixels.count()
    direction = 1  
    if order == 'down':
        start = 31
        stop = -1
        direction = -1
    hue = 0
    if mode == 'on':
        hue = 255
    for i in range(start, stop, direction):
        pixels.set_pixel(i, Adafruit_WS2801.RGB_to_color(hue, hue, hue))
        pixels.show()
        time.sleep(0.05)




def distanz1():
    # setze Trigger auf HIGH
    GPIO.output(GPIO_TRIGGER1, True)
    # setze Trigger nach 0.01ms aus LOW
    time.sleep(0.00001)
    GPIO.output(GPIO_TRIGGER1, False)
    StartZeit = time.time()
    StopZeit = time.time()
    # speichere Startzeit
    while GPIO.input(GPIO_ECHO1) == 0:
        StartZeit = time.time()
    # speichere Ankunftszeit
    while GPIO.input(GPIO_ECHO1) == 1:
        StopZeit = time.time()
    # Zeit Differenz zwischen Start und Ankunft
    TimeElapsed = StopZeit - StartZeit
    # mit der Schallgeschwindigkeit (34300 cm/s) multiplizieren
    # und durch 2 teilen, da hin und zurueck
    distanz1 = (TimeElapsed * 34300) / 2
    return distanz1


def distanz2():
    # setze Trigger auf HIGH
    GPIO.output(GPIO_TRIGGER2, True)
    # setze Trigger nach 0.01ms aus LOW
    time.sleep(0.00001)
    GPIO.output(GPIO_TRIGGER2, False)
    StartZeit = time.time()
    StopZeit = time.time()
    # speichere Startzeit
    while GPIO.input(GPIO_ECHO2) == 0:
        StartZeit = time.time()
    # speichere Ankunftszeit
    while GPIO.input(GPIO_ECHO2) == 1:
        StopZeit = time.time()
    # Zeit Differenz zwischen Start und Ankunft
    TimeElapsed = StopZeit - StartZeit
    # mit der Schallgeschwindigkeit (34300 cm/s) multiplizieren
    # und durch 2 teilen, da hin und zurueck
    distanz2 = (TimeElapsed * 34300) / 2
    return distanz2




if __name__ == '__main__':
    try:
        while True:
            abstand = distanz1()
            time.sleep(1.0)


            if distanz1() < 40:
                print('unten')
                pixels.clear()
                lights()
                # von unten nach oben Licht an
                time.sleep(2)
                lights(mode='off')
            if distanz2() < 40:
                print('oben')
                pixels.clear()
                #lights()
                # von unten nach oben Licht an
                #time.sleep(2)
                #lights(mode='off')
                # von unten nach oben Licht aus
                #time.sleep(2)
                lights(order='down')
                # von oben nach unten Licht an
                time.sleep(2)
                lights(order='down', mode='off')
                # von oben nach unten Licht aus                
        # Beim Abbruch durch STRG+C resetten
    except KeyboardInterrupt:
        print("Messung vom User gestoppt")
        pixels.clear()
        GPIO.cleanup()

Alles anzeigen

1x Ultraschall

Python

import RPi.GPIO as GPIO
import time
import Adafruit_WS2801
import Adafruit_GPIO.SPI as SPI


GPIO.setmode(GPIO.BCM)
GPIO_TRIGGER = 18
GPIO_ECHO = 24


GPIO.setup(GPIO_TRIGGER, GPIO.OUT)
GPIO.setup(GPIO_ECHO, GPIO.IN)


PIXEL_COUNT = 32
SPI_PORT   = 0
SPI_DEVICE = 0
pixels = Adafruit_WS2801.WS2801Pixels(PIXEL_COUNT, spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE))




def lights(order='up', mode='on'):
    start = 0
    stop = pixels.count()
    direction = 1  
    if order == 'down':
        start = 31
        stop = -1
        direction = -1
    hue = 0
    if mode == 'on':
        hue = 255
    for i in range(start, stop, direction):
        pixels.set_pixel(i, Adafruit_WS2801.RGB_to_color(hue, hue, hue))
        pixels.show()
        time.sleep(0.05)




def distanz():
    # setze Trigger auf HIGH
    GPIO.output(GPIO_TRIGGER, True)
    # setze Trigger nach 0.01ms aus LOW
    time.sleep(0.00001)
    GPIO.output(GPIO_TRIGGER, False)
    StartZeit = time.time()
    StopZeit = time.time()
    # speichere Startzeit
    while GPIO.input(GPIO_ECHO) == 0:
        StartZeit = time.time()
    # speichere Ankunftszeit
    while GPIO.input(GPIO_ECHO) == 1:
        StopZeit = time.time()
    # Zeit Differenz zwischen Start und Ankunft
    TimeElapsed = StopZeit - StartZeit
    # mit der Schallgeschwindigkeit (34300 cm/s) multiplizieren
    # und durch 2 teilen, da hin und zurueck
    distanz = (TimeElapsed * 34300) / 2
    return distanz




if __name__ == '__main__':
    try:
        while True:
            abstand = distanz()
            time.sleep(1.0)


            if distanz() < 40:
                print('Unter 8cm')
                pixels.clear()
                lights()
                # von unten nach oben Licht an
                time.sleep(2)
                lights(mode='off')
                # von unten nach oben Licht aus
                time.sleep(2)
                lights(order='down')
                # von oben nach unten Licht an
                time.sleep(2)
                lights(order='down', mode='off')
                # von oben nach unten Licht aus
        # Beim Abbruch durch STRG+C resetten
    except KeyboardInterrupt:
        print("Messung vom User gestoppt")
        pixels.clear()
        GPIO.cleanup()

Alles anzeigen

Und 1x Ultraschall mit 1x Bewegungsmelder kombiniert:

Python

import RPi.GPIO as GPIO
import time
import Adafruit_WS2801
import Adafruit_GPIO.SPI as SPI


GPIO.setmode(GPIO.BCM)
GPIO_TRIGGER1 = 18
GPIO_ECHO1 = 24
SENSOR_PIN2 = 22


GPIO.setup(SENSOR_PIN2, GPIO.IN)
GPIO.setup(GPIO_TRIGGER1, GPIO.OUT)
GPIO.setup(GPIO_ECHO1, GPIO.IN)


PIXEL_COUNT = 32
SPI_PORT   = 0
SPI_DEVICE = 0
pixels = Adafruit_WS2801.WS2801Pixels(PIXEL_COUNT, spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE))




def lights(order='up', mode='on'):
    start = 0
    stop = pixels.count()
    direction = 1  
    if order == 'down':
        start = 31
        stop = -1
        direction = -1
    hue = 0
    if mode == 'on':
        hue = 255
    for i in range(start, stop, direction):
        pixels.set_pixel(i, Adafruit_WS2801.RGB_to_color(hue, hue, hue))
        pixels.show()
        time.sleep(0.05)


def distanz():
    # setze Trigger auf HIGH
    GPIO.output(GPIO_TRIGGER1, True)
    # setze Trigger nach 0.01ms aus LOW
    time.sleep(0.00001)
    GPIO.output(GPIO_TRIGGER1, False)
    StartZeit = time.time()
    StopZeit = time.time()
    # speichere Startzeit
    while GPIO.input(GPIO_ECHO1) == 0:
        StartZeit = time.time()
    # speichere Ankunftszeit
    while GPIO.input(GPIO_ECHO1) == 1:
        StopZeit = time.time()
    # Zeit Differenz zwischen Start und Ankunft
    TimeElapsed = StopZeit - StartZeit
    # mit der Schallgeschwindigkeit (34300 cm/s) multiplizieren
    # und durch 2 teilen, da hin und zurueck
    distanz = (TimeElapsed * 34300) / 2
    return distanz


def up(channel):
    print('unten (bw)')
    pixels.clear()
    lights()
    time.sleep(1)
    lights(mode='off')


try:
    GPIO.add_event_detect(SENSOR_PIN2 , GPIO.RISING, callback=up)
    while True:
        time.sleep(0.001)


        abstand = distanz()
        time.sleep(1.0)


        if distanz() < 40:
            print('oben us')
            pixels.clear()
            lights(order='down')
            # von unten nach oben Licht an
            time.sleep(2)
            lights(order='down', mode='off')  
except KeyboardInterrupt:
    print "Beende..."
GPIO.cleanup()

Alles anzeigen

In der ZIP sind zusätzlich Hinweise für die Verkabelung und noch mal ein paar Bilder zur Pinbeschreibung am Rasp. Nur als Gedankenstütze.
Ich habe in meinen Verkabelungshinweisen die äußere Reihe als Reihe 1 und die innere Reihe als Reihe 2 bezeichnet. Gezählt wird von oben (kurze Seite ohne Anschlüsse).
Das ist zwar alles wenig professionell, aber wenn man etwas an die PINs steckt, dann zählt man ja doch von oben nach unten 1, 2, 3 ...
Es funktionieren alle.

freaksworth

Hast Du dich bei Deinen Übungen auch mal damit beschäftigt Music/Töne zu visualisieren?
Also im Prinzip 'ne Lichtorgel, nur cooler..

don

Nur in der Theorie.
Ich habe noch ein Projekt für eine Uhr, Ringförmig mit nach innen gerichteten LEDs, die dann die Zeiger ersetzen. Vielleicht 1m im Durchmesser, Stahl oder Lederoberfläche.
Da wollte ich dann ein VU-Meter von mitte-unten in Stereo nach links und rechts den Kreis raufwandern lassen.
Die Lichtorgel im Treppenbereich wollte ich ggf an das Telefon koppeln.
Und, weil es mir in den Sinn kam, tiefe Frequenzen (also richtig tiefe Effekte im Film) dazu nutzen, dort das Licht aufblitzen zu lassen. Abschaltbar

ClaudiaF

OK, hab, denke ich, den "Übeltäter" identfiziert.

Python

pixels = Adafruit_WS2801.WS2801Pixels(PIXEL_COUNT, spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE))

erstellt in der Klasse eine Liste mit n*3 Elementen.
In Python ist startet der Listenindex mit 0, somit
ist der letzte Index n*3 - 1

Über

Python

pixels.set_pixel(i, Adafruit_WS2801.RGB_to_color(hue, hue, hue))

wird der Index angesprochen und wenn Du da dann 32 angibst => index out of range

ClaudiaF

Code

Wenn ich die Library richtig verstehe wird durch show die gesammte Liste gesetzt,
heisst also,


    for i in range(start, stop, direction):
        pixels.set_pixel(i, Adafruit_WS2801.RGB_to_color(hue, hue, hue))
        pixels.show()
        time.sleep(0.05)


würde ich ändern in


    for i in range(start, stop, direction):
        pixels.set_pixel(i, Adafruit_WS2801.RGB_to_color(hue, hue, hue))


    pixels.show()
    time.sleep(0.05)


desweiteren besitzt die Show Methode selbst ein sleep


+    def show(self):
+        """Push the current pixel values out to the hardware.  Must be called to
+        actually change the pixel colors.
+        """
+        self._spi.write(self._pixels)
+        time.sleep(0.002)


Vielleicht mal deinen Code ohne sleep probieren?

Alles anzeigen

don

Ohne Sleep rennen die direkt durch. Dann ist es kaum wahrnehmbar, dass die nacheinander schalten.
Durch den Sleep bestimme ich die Schaltgeschwindigkeit. 0.05 sieht gleichmäßig animiert aus.
Schöner wäre es nur, wenn die LEDs faden würden und nicht einfach AN/AUS schalten.
Da bin ich aber noch nicht hintergestiegen. Generell kann ich schon ausblenden, aber nicht kaskadierend.

Python

sec = 1.0
iter = 25
while True: # Endlosschleife
    # alles auf Weiss:
    pixels.clear()
    # Farbe berechnen
    r,g,b = int(random.random()*255), int(random.random()*255), int(random.random()*255)
    # Position berechnen
    pos = int(random.random()*12)
    # alle 0.2 Sekunden wird die Farbe dunkler, 25mal furr 5Sek
    step = int(255 / iter)
    for i in range(iter):
        pixels.set_pixel(pos, Adafruit_WS2801.RGB_to_color( r,g,b ))
        # neue Farbe berechnen
        r,g,b = max(0, r-step), max(0, g-step), max(0, b-step)
        time.sleep(sec / iter)

Alles anzeigen

So in der Art (von hier: https://tutorials-raspberrypi.de/raspberry-pi-w…iessen-steuern/)
Das ist eine Zufallsreihenfolge für AN und danach gegen 0 ausblenden. Weihnachtsbeleuchtung.

Idealvorstellung ist: Die einzelnen LEDs nacheinander gegen 0,0,0 ausblenden.

-----
Ist bei deinem oberem Vorschlag noch etwas anders, als die Zeileneinrückung?
Langsam komme ich dahinter, was wo (und zum Teil auch warum) unterbrochen und eingerückt werden muss.

ClaudiaF

>Ohne Sleep rennen die direkt durch.
Ok, dann ist der Sleep in der Library nicht ausreichend.

>Ist bei deinem oberem Vorschlag noch etwas anders, als die Zeileneinrückung?
Nein, das einrücken war meine einzige Anmerkung.
Als ich anfing habe ich mir da so gemerkt,
alles was eingerückt, in einer Ebene (weiß nicht ob dass das richtige deutsche Wort ist, Level?)steht,
wird nur ausgeführt wenn das was darüber in der Ebene steht zur Ausführung kommt.

Ich schaue mir mal das Beispiel und die Library bezgl. dem Fading nochmals genauer an und geb Dir Bescheid.

ClaudiaF

Python

def brightness_decrease(pixels, wait=0.01, step=1):
    for j in range(int(256 // step)):
        for i in range(pixels.count()):
            r, g, b = pixels.get_pixel_rgb(i)
            r = int(max(0, r - step))
            g = int(max(0, g - step))
            b = int(max(0, b - step))
            pixels.set_pixel(i, Adafruit_WS2801.RGB_to_color( r, g, b ))
        pixels.show()
        if wait > 0:
            time.sleep(wait)

Alles anzeigen

Fading, denke ich,wird über die brightness_decrease funktion erledigt.
In diesem Szenario wird bei for j ... eine Liste von 0-255 erstellt
und als nächstes for i ... eine Liste von 0-31
Dann wird für jedes i der aktuelle Farbenwert ermittelt und die rot, grün, blaue Anteile zugwiesen.
Nun, denke ich, kommt das fading in dem die aktuellen rot, grün, blaue Werte um 1 reduziert werden ( r - step (etc...))

und gesetzt, sind alle 32 pixel gesetzt wird das angezeigt und die erste Schleife wieder durchlaufen.

Edit: was ich vergessen habe, für dein Beispiel würdest Du den Aufruf der Function ohne den pixels Parameter machen,
da Du den global definiert hast. Heisst also aus

def brightness_decrease(pixels, wait=0.01, step=1):

würde

def brightness_decrease(wait=0.01, step=1):

der Rest bleibt. Und Aufruf wäre dann brightness_decrease()

freaksworth

Also bei den Grundfarben brauch ich ja nur den einen Wert hoch, bzw. runter zählen. Wenn die Farbe zusammengesetzt ist, muss man doch auch proportional abziehen, sonst ändert sich ja die Farbe. Oder?
Für ein Lauflicht würde ich dass dann so verschachteln, dass immer bei "der Hälfte" (oder je nachdem wieviele Leuchten sollen), der nächste Pixel anfängt und wieder rückwärts.

ClaudiaF

Zitat von freaksworth

Also bei den Grundfarben brauch ich ja nur den einen Wert hoch, bzw. runter zählen. Wenn die Farbe zusammengesetzt ist, muss man doch auch proportional abziehen, sonst ändert sich ja die Farbe. Oder?

Ob das mit den Farben so ist, weiß ich nicht aber das wird sich nicht vermeiden lassen, da einer der drei Werte als erstes 0 erreichen wird und dann
ist es mit der Proportion vorbei. Es wird ja immer eine Ganzzahl abgezogen.

freaksworth

Ziel ist doch, dass sie gleichzeitig 0 ergeben.
Man muss ja auch nicht bei jedem durchlaufen alle Werte ändern, sondern eben gewichtet.

ClaudiaF

Angenommen wir haben die rgb werte r=90,g=60,b=30
Dann würdest Du sagen, für jeden Durchlauf
wird r um 3 veringert, g um 2 and b um 1.
Verstehe ich Dich da richtig?

Wenn ja, dann hast Du aber je nachdem welche Werte am Anfang gesetzt sind unterschiedliche Laufzeiten, oder?

Treppenstufenbeleuchtung mit dem Raspberry / Schritt zum Arduino

Jetzt mitmachen!

Benutzer online in diesem Thema