Lumière ambiante IoT :lampe Zerynth
Composants et fournitures
Applications et services en ligne
À propos de ce projet
Les normes sans fil à faible consommation combinées à des LED, des capteurs et des dispositifs de communication ultra-miniatures à faible coût ont fait de l'éclairage intelligent un catalyseur pour l'Internet des objets et la domotique.
Dans ce tutoriel, nous verrons comment contrôler une bande LED NeoPixel via un mobile à l'aide de l'application Zerytnh, qui affiche un sélecteur de couleurs et un menu pour la sélection de diverses animations préconfigurées.
Étape 1 :Matériel requis 
Le projet nécessite peu d'éléments :
- Zerynth Studio :un environnement de développement Python multiplateforme et basé sur un navigateur avec des fonctionnalités de synchronisation dans le cloud et de gestion de cartes. Quel que soit le système d'exploitation que vous utilisez, Zerynth fonctionne ! Téléchargez simplement Zerynth et installez-le (http://www.zerynth.com/zerynth-studio/).
- Application Zerynth : l'interface mobile Zerynth pour les objets intelligents et les systèmes IoT. N'importe quel mobile deviendra l'affichage des objets et la télécommande. Téléchargement :http://www.zerynth.com/zerynth-app/
- Bouclier Zerynth (disponible ici :https://store.open-electronics.org/index.php?_route_=Shield_ZERYNTH&search=toi ). Une carte multi-capteurs prête à l'emploi qui ajoute des fonctions intelligentes à vos objets de la vie quotidienne
- Arduino DUE ou ST Nucleo F401RE ou ParticlePhoton . ou UDOO ou Flip&Clip par Mikroelektronika . Quelle que soit la carte que vous utilisez, Zerynth est compatible avec plusieurs cartes ! Vous pouvez trouver tous les détails des cartes prises en charge ici :http://www.zerynth.com/zerynth-studio/
- Si vous n'utilisez pas Particle Photon (qui intègre un module wifi), vous avez besoin d'un élément qui connecte la carte au Web, comme le bouclier wi-fi de Adafruit . Cependant, vous pouvez utiliser n'importe quel autre adaptateur qui monte la puce wifi CC3000 Texas Instruments (http://www.ti.com/product/cc3000).
- une bande (ou un anneau) de NeoPixel LED de Adafruit (disponible ici https://www.adafruit.com/products/1426)
- une lampe en verre ou imprimée en 3D . Le choix vous appartient.
Étape 2 :Assemblage 
- Il suffit de superposer le wifi Shield et le Zerynth Shield sur votre Arduino (ou ST Nucleo ou UDOO). Si vous utilisez Particle Photon, il suffit de le superposer sur les connecteurs dédiés du Zerynth Shield.
- Connectez les LED NeoPixel au port correspondant sur le Zerynth Shield.
- Mettez toutes les cartes et les LED dans la lampe.
Étape 3 : Programmation 
Utiliser Zerynth est très simple !
- connectez et "virtualisez" votre tableau (déjà expliqué ici http://bit.ly/Hackster-VIPER-Theremin)
- créer un nouveau projet dans Zerynth (déjà expliqué ici http://bit.ly/Hackster-IoT-Notes-Printer). Attention :vous devez créer 3 (+1) fichiers :main.py, animation.py, template.html (et project.md)
- liez le code sur votre tableau et vous avez terminé !
Après avoir allumé la lampe, celle-ci se connectera automatiquement au réseau prédéfini.
Ensuite, ouvrez simplement l'application Zerynth, qui partira à la recherche des objets Zerynth connectés au réseau, sélectionnez l'objet d'intérêt, en l'occurrence la "Lampe Zerytnh", et vous pourrez interagir avec lui ! Dans ce cas, l'application Zerynth affiche un sélecteur de couleurs et un menu pour la sélection de diverses animations préconfigurées.
Le code est très simple et a beaucoup de commentaires. Pour toute question ou suggestion, n'hésitez pas à poster sur les forums de la communauté Zerynth :http://community.zerynth.com/
Étape 4 :Rendez l'IoT plus lumineux ! 
As-tu aimé? Passons au hardcore !
Le Zerynth Shield présente un ensemble de capteurs et d'actionneurs, comprenant des capteurs pour la détection tactile, une LED infrarouge, un microphone, un capteur de lumière et un capteur de température. Vous pouvez commencer à partir de cet exemple de code très simple pour développer le comportement que vous préférez. Utilisez le Zerynth Shield pour étendre les fonctionnalités de la lampe !
Luigi F. Cerfeda (@L_F_Cerfeda) - Équipe Zerynth
Code
- main.py
- modèle.html
- animation.py
main.pyPython
################################################ #################################### Lampe Zerynth## Créé par l'équipe Zerynth 2015 CC# Auteurs :G. Baldi , D. Mazzei############################################## #################################### importer les modules nécessaires importer les flux de bcm43362 importer bcm43362 en tant que pilote_wifi à partir d'une importation sans fil wifiimporter une animation à partir de l'importation de toishield toishield# et importer le module zerynthapp de zerynthapp import zerynthappstreams.serial()# se connecter à un réseau wifitry:wifi_driver.auto_init() print("Establishing Link...") wifi.link("SSID",wifi.WIFI_WPA2,"password ") print("Ok!") sauf exception comme e:print(e)# enregistre le template.html dans le flash du forum avec new_resourcenew_resource("template.html")#### ZerynthApp Setup# ::Javascript to Python ::# les fonctions suivantes seront appelées lorsque les boutons sont enfoncésdef change_color(r, g, b):animation.setup_color(r, g, b)def change_animation(n):animation.setup_anim(n)def change_speed(n):animation .mettre en place un nim_speed(n)# configure l'application Zerynth avec un nom, une description et le modèle urlvp =zerynthapp.ZerynthApp("Zerynth Lamp", "Try me!", "resource://template.html")# chaque fois que Javascript génère des événements les fonctions correspondantes s'appellentvp.on("change_color", change_color)vp.on("change_animation", change_animation)vp.on("change_speed", change_speed)# exécuter le ZerynthApp!vp.run()# depuis le démarrage de vp.run un nouveau fil, vous pouvez faire tout ce que vous voulez ici !# contrôlons ledsanimation.start(D6, 24) template.htmlHTML
Lampe Zerynth
Powered by Zerynth (www.zerynth.com)
animation.pyPython
################################################ #################################### Lampe Zerynth## Créé par l'équipe Zerynth 2015 CC# Auteurs :G. Baldi , D. Mazzei############################################## ####################################Fonctions d'animation de lampe à partir de bandes de led d'importation neopixel comme neoimport threadinglock =threading.Lock() # la couleur Zerynth :)color =[0x54,0x9a,0x97]anim =0anim_speed =50leds =Nonelayer0 =Nonelayer1 =Nonelayer2 =Nonenpins =0 stop=Falsestopcolor =[0xff,0xff,0xff]# créer tous les calques nécessaires# définissons quelques coefficients pour une animation fluide (une demi-onde sinusoïdale)animation_coefficients =[ 0, 0.2588190451, 0.5, 0.7071067812, 0.8660254038, 0.9659258263, 1, 0.9659258263, 0.8660254038, 0.7071067812, 0.5, 0.2588190451]arc-en-ciel =[ (0x00,0, (x00,00x) 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 # remplir les calques avec leurs valeurs initiales l ock.acquire() leds.clear() layer2.clear() layer0.clear() layer1.clear() n=n%4 si n==0:layer0[0]=(100,0,0) layer0[ 1]=(100,0,0) couche0[2]=(100,0,0) couche1[0]=(0,100,0) couche1[1]=(0,100,0) couche1[2]=(0,100, 0) elif n==1 :pour x dans la plage(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 for x in range(npins):step =x*len(rainbow)/npins rx =(arc-en-ciel[int(step)][0]+arc-en-ciel[int(pstep)][0])//4 gx =(arc[int(step)][1]+arc-en-ciel[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):couleur globale #print(" Color : ",r,g,b) color[0]=r color[1]=g color[2]=b# Créer une fonction pour gérer l'animation de fond animate_background(delay):global color step=0 while True :if ( anim==3 ou anim==0) et non arrêté :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 else:lock.acquire() layer2.clear(); layer2.setall(stopcolor[0],stopcolor[1],stopcolor[2]) lock.release() sleep(delay+500-5*anim_speed)def animate_foreground(delay) :tandis que True :si non arrêté :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) # démarrer le thread d'animation d'arrière-plan (animate_background,500) # démarrer le thread d'animation de premier plan (animate_foreground,50) tandis que True :# effacer les leds leds.clear() # maintenant, acquérez le verrou lock.acquire() # fusionnez la première et la deuxième couche leds.merge(layer0) leds.m erge(layer1) # fusionne le calque d'arrière-plan uniquement là où les leds sont transparentes (0,0,0) leds.merge(layer2,neo.first_color) # libère le verrou lock.release() # et allume-le ! leds.on() sleep(50)def stop(r,g,b) :global arrêté global stopcolor stopcolor[0]=r stopcolor[1]=g stopcolor[2]=b stoppé=True def resume() :global arrêté arrêté =False setup_anim(anim) Schémas
