Feb 222016
 

Mein neustes Projekt ist eine Uhr aus einem 60er Neopixel Ring und einem Raspberry Pi.

Man nehme:

4x Neopixel Viertelkreise mit je 15 WS2812 RGB LEDs
Adafruit NeoPixel 1/4 60 Ring – WS2812 5050 RGB LED w/ Integrated Drivers oder 1 x http://www.ebay.de/itm/272023696005

Raspberry Pi (Modell B+ geht beispielweise)
Vilros Raspberry Pi 2 Model B (1GB) Ultimate Starter Kit Mit 15 Wesentlich Zubehör

1 x Diode 1N4001
1N4001 DO-41 Gleichrichterdioden, 50 V, 1 A, axial bedrahtet, 50 Stück

Breadboard
KIMILAR Breadboard Steckbrett Laborsteckboard Lochraster Experimentierbrett Steckboard mit 400 Kontakte

Verbindungskabel
Extra Netzteil 5V für den LED-Ring

 

Werkzeug:

Lötkolben, Lötzinn

 

Den Ring bzw. die 4 Viertelkreise habe ich beim Chinesen meines Vertrauens bestellt. Bei http://zackzack.de gab es zufälligerweise ein Raspberry Starterset für wenig Geld.

Das schwierigste war, die 4 Viertelreise gescheit aneinanderzulöten 😉

Es werden immer alle 3 Lötpunkte mit den Nachbarlötpunkten verbunden, bis auf den „Eingang“, da wird nur das Kabel für das Steuersignal angelötet.

Neopixel löten

Neopixel löten

Neopixel 60 Ring

Neopixel 60 Ring

 

Als Bibliothek zum Ansteuern habe ich verwendet:

rpi_ws281x

Software

Update des Pis:

sudo apt-get update

Installieren von python und Kompilieren der Bibliothek:

sudo apt-get install build-essential python-dev git scons swig
git clone https://github.com/jgarff/rpi_ws281x.git
cd rpi_ws281x
scons

Damit werden die Werkzeuge und die Bibliothek runtergeladen und kompiliert.

cd python
sudo python setup.py install

Nun schließen wir den Neopixel Ring an den Pi an. Dazu wird Pin 18 mit dem DATA IN Kabel verbunden, +5V des extra Netzteils via der Diode (Polung beachten!) an VCC des Rings, GND an GND des Rings und an GND des Pis:

 

Neopixel mit Diode 1N4001

Neopixel mit Diode 1N4001

 

 

Neopixel Complete Clock

Neopixel Complete Clock

 

Mein Programm (clock.py) für die Uhr lautet:

from datetime import datetime
import time

from neopixel import *

# LED strip configuration:
LED_COUNT      = 60      # Number of LED pixels.
LED_PIN        = 18      # GPIO pin connected to the pixels (must support PWM!).
LED_FREQ_HZ    = 800000  # LED signal frequency in hertz (usually 800khz)
LED_DMA        = 5       # DMA channel to use for generating signal (try 5)
LED_BRIGHTNESS = 8     # Set to 0 for darkest and 255 for brightest
LED_INVERT     = False   # True to invert the signal (when using NPN transistor level shift)

if __name__ == '__main__':
        # Create NeoPixel object with appropriate configuration.
        strip = Adafruit_NeoPixel(LED_COUNT, LED_PIN, LED_FREQ_HZ, LED_DMA, LED_INVERT, LED_BRIGHTNESS)
        # Intialize the library (must be called once before other functions).
        strip.begin()
        sek=0
        min=0
        hour=0
        old_sek=0
        old_min=0
        old_hour=0
        while True:
                old_sek=sek
                old_min=min
                old_hour=hour
                strip.setPixelColorRGB(old_sek,0,0,0)
                strip.setPixelColorRGB(old_min,0,0,0)
                strip.setPixelColorRGB(old_hour,0,0,0)
                # weiße Punkte alle 5 Min
                strip.setPixelColorRGB(5,128,128,128)
                strip.setPixelColorRGB(10,128,128,128)
                strip.setPixelColorRGB(15,128,128,128)
                strip.setPixelColorRGB(20,128,128,128)
                strip.setPixelColorRGB(25,128,128,128)
                strip.setPixelColorRGB(30,128,128,128)
                strip.setPixelColorRGB(35,128,128,128)
                strip.setPixelColorRGB(40,128,128,128)
                strip.setPixelColorRGB(45,128,128,128)
                strip.setPixelColorRGB(50,128,128,128)
                strip.setPixelColorRGB(55,128,128,128)
                strip.setPixelColorRGB(0,128,64,64)

                print datetime.now().strftime('%I:%M:%S')

                sek=int(datetime.now().strftime('%S'))
                min=int(datetime.now().strftime('%M'))
                hour=int(datetime.now().strftime('%I'))*5+int(min/12)

                strip.setPixelColorRGB(sek,255,0,0)
                strip.setPixelColorRGB(min,0,255,0)
                strip.setPixelColorRGB(hour,0,0,255)

                strip.show()
                time.sleep(1)

gestartet wird das ganze per

sudo python rpi_ws281x-master/python/examples/clock.py
Neopixel Clock Pi

Neopixel Clock Pi

Nun wird mit weißen LEDs ein Zifferblatt dargestellt, rot ist der Sekundenzeiger, blau ist der „kleine“ Zeiger und grün der Minutenzeiger.

Aufgrund der Tatsache, dass immer nur 15 LEDs mit Helligkeit „8“ auf einmal leuchten ist es auch möglich, die 5V vom Raspberry Netzteil liefern zu lassen (das heißt nicht, dass man die 5V an den PINs abgreifen kann! Sondern dass man die Versorgungsspannung auf der Platine vor der Sicherung und dem Spannungsteiler auflötet/abgreift)

Um die Neopixels vor Spannungsspitzen beim Einschalten zu schützen empfiehlt sich das parallele Vorschalten von einem passenden Elko.

 

Ausblick:

– Es wird noch ein Lautsprecher an den Klinkeanschluß angeschlossen und dann kann man stündlich oder zumindest tagsüber ein „Kuckuck“-mp3 abspielen lassen 😉
– Es kann noch Wecker realisert werden. Dazu habe ich mir flic- Bluetooth Knöpfe bestellt, die dann den Wecker ein und Auschalten und den Sleep steuern…

Jul 212015
 

Den Wasserstand meiner Zisterne habe ich lange mit einem 8-Stufen LED überwacht. Die Einteilung in 8 Stufen ist recht grob, pro Stufe werden ca 875 Liter dargestellt.

Um hier eine genauere Messung durchführen zu können, habe ich einen Ultraschall-Sensor in die Zisterne gebaut, der mit einem Raspberry-Pi angesteuert und ausgewertet wird.

Alle 5 Minuten wird ein Ultraschallimpuls losgeschickt und wieder aufgefangen und an der Laufzeit errechnet, wie weit die Wasseroberfläche vom Sensor entfernt ist.

Die Messung schwankt mit ± 1,5 cm, ab und zu ist auch ein ganz krummer Wert dabei, daher messe ich in kurzem Abstand 10 mal und bilde dann den Mittelwert.

Die gemssenen Werte schreibe ich in eine Round-Robin-Database und erzeuge daraus Grafiken:





 

Verwendete Hardware:

Raspberry PI 2
mit Gehäuse,
Netzteil
und SD-Karte
Ultraschallsensor oder Ultraschallsensor wasserdicht Kabel Schlagschrauber

 

Gehäuse für Ultraschallsensor

 

Werkzeug:

Lötkolben

Schraubendreher für Lüsterklemmen

Schlagschrauber

Verwendete Bookware:

In ein schwarzes Plastikgehäuse habe ich Löcher für den Ultraschallsensor gefräst, den Sensor eingepasst und daran ein übrig gebliebenes 4 x 2 Cat 7 Netzwerkkabel angelötet (Lötfett leistet hier wunderbare Dienste!)

 

Gehäuse noch offen, 4 der 8 Adern in Gebrauch

Gehäuse noch offen, 4 der 8 Adern in Gebrauch

 

Sensor anlöten

Sensor anlöten

Dieses habe ich dann mit der Makita an die Innenwand des Zisternenschachts getackert 🙂

von oben

von oben

Ultraschallsensor pi im Gehäuse

Ultraschallsensor pi im Gehäuse

 

Das Kabel wird durch das Rohr bis nach außen geführt, um dann gleich wieder im Lichtschacht zu verschwinden.

Kabel in Zisterne

Kabel in Zisterne

Von dort geht es weiter durch den Fensterrahmen in den Heizungskeller, wo der Raspberry sitzt und das ganze ansteuert.

Durch den Kunststofffensterrahmen gebohrt

Durch den Kunststofffensterrahmen gebohrt

Raspberry transparentes Gehäuse

Raspberry transparentes Gehäuse

 

Software:

Es läuft per cronjob alle 5 Minuten ein Python-Script, das 10 x die Entfernung zur Wasseroberfläche misst, den Mittelwert bildet und per ftp auf die Homepage schiebt. Dort wird sie durch ein WordPress Plugin dargestellt:

#!/usr/bin/python
# coding=utf8
import time
import ftplib
import RPi.GPIO as GPIO
#from __future__         import print_function

GPIO.setmode(GPIO.BOARD)
trig=11
echo=13
GPIO.setup(echo,GPIO.IN)
GPIO.setup(trig,GPIO.OUT)
voll=50 # 50 cm von Sensor bis Wasseroberfläche = voll
leer=230 # 230 cm von Sensor bis Wasseroberfläche= leer
entfernung=0
gesamt=0

liter_pro_cm=3.1415*112.5*112.5*1/1000  #pi * radius * radius * 1cm /1000 sonst milliliter
print "Liter pro cm: ",liter_pro_cm

for i in range(0,10):
        GPIO.output(trig,True)
        time.sleep(0.00001)
        GPIO.output(trig,False)
        while GPIO.input(echo) == 0:
                pass
        start=time.time();
        while GPIO.input(echo) == 1:
                pass
        ende = time.time();
        entfernung=((ende - start) * 34300) / 2
        print entfernung
        gesamt=gesamt+entfernung
        time.sleep(0.75)

mittelwert=gesamt/10
volumen=(leer-mittelwert)*liter_pro_cm
print "Entfernung: ",  mittelwert, " cm"
print "Volumen: ", volumen
print "- - - - - - - - - - - - - - - - - - - - - "
f1=open('/home/pi/entfernung.txt','w')
print >> f1, '%d' % (mittelwert)
f1.close()

f2=open('/home/pi/volumen.txt','w')
print >> f2, '%d' %(volumen)
f2.close()

f1l=open('/home/pi/entfernung.txt','r')
f2l=open('/home/pi/volumen.txt','r')

serverftp = ftplib.FTP('ftp.server.de', 'user', 'pass')
serverftp.storbinary('Stor entfernung.txt', f1l)
serverftp.storbinary('Stor volumen.txt', f2l)
serverftp.quit()

f1l.close()
f2l.close()