IoT-Umgebungslicht:Zerynth-Lampe
Komponenten und Verbrauchsmaterialien
Über dieses Projekt
Drahtlose Standards mit geringem Stromverbrauch in Kombination mit kostengünstigen Ultraminiatur-LEDs, Sensoren und Kommunikationsgeräten haben intelligente Beleuchtung zu einem Katalysator für das Internet der Dinge und die Heimautomatisierung gemacht.
In diesem Tutorial sehen wir, wie man einen NeoPixel-LED-Streifen über das Handy mit der Zerytnh-App steuert, die einen Farbwähler und ein Menü zur Auswahl verschiedener vorkonfigurierter Animationen anzeigt.
Schritt 1:Benötigtes Material 
Das Projekt erfordert wenige Elemente:
- Zerynth Studio :eine plattform- und browserbasierte Python-Entwicklungsumgebung mit Cloud-Sync- und Board-Management-Funktionen. Egal welches Betriebssystem Sie verwenden, Zerynth läuft! Laden Sie einfach Zerynth herunter und installieren Sie es (http://www.zerynth.com/zerynth-studio/).
- Zerynth-App: die mobile Schnittstelle von Zerynth für Smart Objects und IoT-Systeme. Jedes Handy wird zum Objektdisplay und zur Fernbedienung. Download:http://www.zerynth.com/zerynth-app/
- Zerynth-Schild (hier verfügbar:https://store.open-electronics.org/index.php?_route_=Shield_ZERYNTH&search=toi ). Ein gebrauchsfertiges Multisensor-Board, das Ihren Alltagsgegenständen intelligente Funktionen hinzufügt
- Arduino DUE oder ST Nucleo F401RE oder ParticlePhoton . oder UDOO oder Flip&Clip von Mikroelektronika . Egal welches Board du verwendest, Zerynth ist Multiboard-kompatibel! Alle Details zu den unterstützten Boards findest du hier:http://www.zerynth.com/zerynth-studio/
- Wenn Sie Particle Photon nicht verwenden (das über ein WLAN-Modul verfügt), benötigen Sie ein Element, das das Board mit dem Internet verbindet, wie zum Beispiel das Wi-Fi-Schild von Adafrucht . Sie können jedoch jeden anderen Adapter verwenden, der den WLAN-Chip montiert CC3000 Texas Instruments (http://www.ti.com/product/cc3000).
- ein Streifen (oder ein Ring) von NeoPixel LEDs von Adafruit (verfügbar hier https://www.adafruit.com/products/1426)
- eine Glas- oder 3D-gedruckte Lampe . Sie haben die Wahl.
Schritt 2:Zusammenbau 
- Tragen Sie einfach das WLAN-Schild und das Zerynth-Schild auf Ihren Arduino (oder ST Nucleo oder UDOO). Wenn Sie Particle Photon verwenden, stecken Sie es einfach auf die dedizierten Anschlüsse am Zerynth Shield.
- Verbinden Sie die NeoPixel-LEDs mit dem entsprechenden Port am Zerynth Shield.
- Setzen Sie alle Platinen und LEDs in die Lampe.
Schritt 3:Programmierung 
Die Verwendung von Zerynth ist sehr einfach!
- verbinde und "virtualisiere" dein Board (bereits hier erklärt http://bit.ly/Hackster-VIPER-Theremin)
- erstellen Sie ein neues Projekt in Zerynth (hier bereits erklärt http://bit.ly/Hackster-IoT-Notes-Printer). Achtung:Sie müssen 3 (+1) Dateien erstellen:main.py, animation.py, template.html (und project.md)
- kopieren Sie den geposteten Code
- Uplink den Code auf deinem Board und fertig!
Nach dem Einschalten der Lampe wird diese automatisch mit dem voreingestellten Netzwerk verbunden.
Öffnen Sie dann einfach die Zerynth App, die nach mit dem Netzwerk verbundenen Zerynth-Objekten sucht, wählen Sie das interessierende Objekt aus, in diesem Fall die "Zerytnh-Lampe", und Sie können damit interagieren! In diesem Fall zeigt die Zerynth App einen Farbwähler und ein Menü zur Auswahl verschiedener vorkonfigurierter Animationen.
Der Code ist sehr einfach und hat viele Kommentare. Bei Fragen oder Anregungen können Sie gerne in den Zerynth-Community-Foren posten:http://community.zerynth.com/
Schritt 4:IoT heller machen! 
Hat es dir gefallen? Lass uns hardcore werden!
Das Zerynth Shield präsentiert eine Reihe von Sensoren und Aktoren, darunter Sensoren zur Berührungserkennung, Infrarot-LED, Mikrofon, Lichtsensor und Temperatursensor. Sie können mit diesem sehr einfachen Beispielcode beginnen, um das von Ihnen bevorzugte Verhalten zu entwickeln. Verwenden Sie das Zerynth-Schild, um die Funktionen der Lampe zu erweitern!
Luigi F. Cerfeda (@L_F_Cerfeda) - Zerynth-Team
Code
- main.py
- template.html
- animation.py
main.pyPython
############################################## ################################## Zerynth Lampe## Erstellt von Zerynth Team 2015 CC# Autoren:G. Baldi , D. Mazzei############################################ #5 toishield# und importiere das zerynthapp modulefrom zerynthapp import zerynthappstreams.serial()# verbinde dich mit einem WLAN-Netzwerktry:wifi_driver.auto_init() print("Establishing Link...") wifi.link("SSID",wifi.WIFI_WPA2,"password ") print("Ok!") außer Ausnahme als e:print(e)# speichere die template.html im Board-Flash mit new_resourcenew_resource("template.html")#### ZerynthApp Setup# ::Javascript to Python ::# Folgende Funktionen werden beim Drücken von Buttons aufgerufendef change_color(r, g, b):animation.setup_color(r, g, b)def change_animation(n):animation.setup_anim(n)def change_speed(n):animation .setup_a nim_speed(n)# Konfigurieren Sie die Zerynth-App mit einem Namen, einer Beschreibung und dem Template urlvp =zerynthapp.ZerynthApp("Zerynth Lamp", "Try me!", "resource://template.html")# jedes Mal, wenn Javascript Ereignisse generiert die entsprechenden Funktionen heißen vp.on("change_color", change_color)vp.on("change_animation", change_animation)vp.on("change_speed", change_speed)# starte die ZerynthApp!vp.run()# seit vp.run startet ein neuer Thread, du kannst hier unten machen was du willst!# lass uns ledsanimation.start(D6, 24) kontrollieren template.htmlHTML
Zerynth-Lampe
Powered by Zerynth (www.zerynth.com)
animation.pyPython
############################################## ################################## Zerynth Lampe## Erstellt von Zerynth Team 2015 CC# Autoren:G. Baldi , D. Mazzei############################################ ################################### Lampenanimationsfunktionen aus Neopixel importieren LED-Streifen als Neoimport threadinglock =threading.Lock() # die Zerynth-Farbe :)color =[0x54,0x9a,0x97]anim =0anim_speed =50leds =Nonelayer0 =Nonelayer1 =Nonelayer2 =Nonenpins =0 gestoppt=Falsestopcolor =[0xff,0xff,0xff]# alle benötigten Ebenen erstellen# lass uns definieren einige Koeffizienten für eine glatte Animation (eine halbe Sinuswelle)animation_coefficients =[ 0, 0.2588190451, 0.5, 0.7071067812, 0.8660254038, 0.9659258263, 1, 0.9659258263, 0.8660254038, 0.7071067812, 0.5, 0.2588190451]Regenbogen =[ (00,0x00,0), (x 0xff,0x7f,0x00), (0xff,0xff,0x00), (0x00,0xff,0x00), (0x00,0x00,0xff), (0x4b,0x00,0x82), (0x8f,0x00,0xff)]def setup_anim( n):global layer0,layer1,layer2,anim # fülle die Ebenen mit ihren Anfangswerten l ock.acquire() leds.clear() layer2.clear() layer0.clear() layer1.clear() n=n%4 if n==0:layer0[0]=(100,0,0) layer0[ 1]=(100,0,0) Schicht0[2]=(100,0,0) Schicht1[0]=(0,100,0) Schicht1[1]=(0,100,0) Schicht1[2]=(0,100, 0) elif n==1:für x im Bereich(npins//2):layer0[x]=(100//(2*x+1),0,0) layer1[npins-x-1]=( 0,100//(2*x+1),0) layer2.clear() elif n==2:layer1.clear() pstep=0 für x im Bereich(npins):step =x*len(rainbow)/npins rx =(rainbow[int(step)][0]+rainbow[int(pstep)][0])//4 gx =(rainbow[int(step)][1]+rainbow[int(pstep)][ 1])//4 bx =(rainbow[int(step)][2]+rainbow[int(pstep)][2])//4 layer0[x]=(rx,gx,bx) pstep=step elif n==3:layer0.clear() layer1.clear() anim=n lock.release() def setup_anim_speed(n):global anim_speed anim_speed=n def setup_color(r,g,b):globale Farbe #print(" Color:",r,g,b) color[0]=r color[1]=g color[2]=b# Erzeuge eine Funktion für die Hintergrundanimationdef animate_background(delay):global color step=0 while True:if ( anim==3 oder anim==0) und nicht gestoppt:lock.acquire() layer2.setal l(int(color[0]*animation_coefficients[step]/2)),int(color[1]*animation_coefficients[step]/2),int(color[2]*animation_coefficients[step]/2)) lock.release () step +=1 if step>
=len(animation_coefficients):step=0 sonst:lock.acquire() layer2.clear(); layer2.setall(stopcolor[0],stopcolor[1],stopcolor[2]) lock.release() sleep(delay+500-5*anim_speed)def animate_foreground(delay):while True:wenn nicht gestoppt:lock.acquire () if anim ==0:layer0.lshift() layer1.rshift() elif anim ==1:layer0.rshift() layer1.rshift() elif anim ==2:layer0.rshift() layer1.rshift() elif anim ==3:layer0.lshift() layer1.lshift() lock.release() else:lock.acquire() layer0.clear() layer1.clear() lock.release() sleep(delay+100-anim_speed )def start(pin,numpins):global leds,layer0,layer1,layer2,npins npins=numpins leds =neo.LedStrip(pin,numpins) layer0 =neo.LedStrip(pin,numpins) layer1 =neo.LedStrip(pin, numpins) layer2 =neo.LedStrip(pin,numpins) setup_anim(0) setup_anim_speed(50) # Starte den Thread der Hintergrundanimation (animate_background,500) # starte den Thread der Vordergrundanimation (animate_foreground,50) während True:# LEDs löschen leds.clear() # jetzt die Sperre erwerben lock.acquire() # die erste und zweite Schicht zusammenführen leds.merge(layer0) leds.m erge(layer1) # füge die Hintergrundebene nur dort zusammen, wo LEDs transparent sind (0,0,0) leds.merge(layer2,neo.first_color) # löse die Sperre lock.release() # und zünde sie an! leds.on() sleep(50)def stop(r,g,b):global gestoppt global stopcolor stopcolor[0]=r stopcolor[1]=g stopcolor[2]=b gestoppt=True def restart():global gestoppt gestoppt =Falsch setup_anim(anim) Schaltpläne
