Théâtre d'Ombres DIY : Créez un Spectacle Lumineux avec Arduino et Bandeau LED Adressable

Composants et fournitures

• 1x Arduino 101
• 1x Bandeau RGB adressable (SparkFun, mais tout bandeau adressable fonctionne avec ajustements mineurs)
• 1x Adaptateur jack mâle (SparkFun, disponible en magasin d'électronique local)
• 1x Adaptateur jack femelle (SparkFun)
• 1x Support de piles 3xAA avec interrupteur (SparkFun)
• 3x Piles AA (SparkFun, mais piles génériques fonctionnent)
• 1x Régulateur step-up 12V (Pololu) - permet d'alimenter l'Arduino 101 avec les mêmes piles que le bandeau LED
• 4x Feuilles papier imprimante standard 8,5x11"
• 4x Feuilles carton 100lb 8,5x11"
• 1x Plaque mousse blanche 3/16", assez pour quatre pièces 8,5x11"

Outils et machines nécessaires

• Pistolet à colle chaude
• Fer à souder
• Cutter Xacto
• Lames de rechange Xacto (#11)
• Pince à dénuder 12-20 AWG
• Accès à une imprimante (capable d'imprimer sur carton)
• Petit tournevis pour serrer les bornes des connecteurs jack

Applications et services en ligne

• Arduino IDE
• Blynk (application de contrôle à distance)
• Bibliothèque Adafruit NeoPixel

À propos de ce projet

Vue d'ensemble

Ce projet utilise un Arduino 101, un bandeau de LED adressables, de la plaque mousse et du carton pour créer un théâtre d'ombres animé contrôlable par téléphone. L'électronique est utilisée de façon non destructive, vous pourrez la réutiliser pour d'autres projets. Voici une liste de souhaits SparkFun avec 99% de l'électronique nécessaire.

Comment ça marche :

Un bandeau de LED adressables est enroulé sur une pièce de plaque mousse au centre du théâtre. Les LED du bas s'allument lentement en séquence et brillent à travers des trous d'épingle pour créer une ombre animée. Les LED plus hautes sont canalisées vers les bâtiments du dessus, et la dernière LED du bandeau illumine toute la scène, créant l'ombre principale.

L'Arduino 101 possède une radio Bluetooth intégrée, et j'utilise une application de prototypage rapide appelée Blynk pour contrôler la scène à distance. Dans le code d'exemple, vous pouvez contrôler les couleurs dans les bâtiments, activer un feu scintillant, et contrôler la luminosité de la lumière d'ombre principale.

Partie 1 : Mise en place de l'électronique

Étape 1

Récupérez le connecteur de fin de votre bandeau LED en coupant environ 1 cm depuis l'extrémité des lumières. Dénudez les fils.

Étape 2

Séparez les broches de header courbées fournies avec votre régulateur de tension, et soudez-en deux aux extrémités des fils vert et jaune. Cela permettra de les brancher facilement sur les pins de l'Arduino 101.

Étape 3

Soudez le fil rouge sur la borne VIN du régulateur de tension, et soudez deux headers droits sur les bornes GND et VOUT comme montré.

Étape 4

Connectez maintenant les adaptateurs jack. Dénudez d'abord les fils venant du boîtier de piles, puis montez-les dans les bornes du jack mâle et serrez avec un tournevis. ROUGE sur borne (+), NOIR sur borne (-).

Ensuite, connectez l'adaptateur jack femelle sur les fils libres au début du bandeau LED. JAUNE sur borne (-), ROUGE sur borne (+).

Étape 5

Connectez maintenant votre harnais à l'Arduino 101. Le fil VERT va sur PIN 6, le fil JAUNE sur le GND près du #13.

Avec les deux broches header sur le régulateur, GND va sur GND et VOUT sur la broche "Vin" de l'Arduino 101. Ne vous trompez pas ! Brancher à l'envers mène à des odeurs et des brûlures. Je sais de quoi je parle.

Partie 2 : Assemblage de la scène en plaque mousse

Imprimez le patron de la plaque mousse sur papier imprimante standard (4 feuilles) et le patron du carton sur papier carton (4 feuilles).

Étape 1

Prenez les pages du patron plaque mousse et utilisez-les pour découper vos pièces. Vous pouvez poser un patron sur la plaque mousse, puis tracer légèrement le contour avec un cutter pour transférer les traits.

Étape 2

Une fois les pièces découpées, commencez par assembler le support de bandeau LED comme suit :

Prenez votre bandeau LED et fixez la première LED en bas avec du ruban adhésif ou de la colle chaude, puis enroulez vos LED comme montré. L'idée est de garder le bandeau intact. Pas besoin d'un enroulement super serré.

Après trois tours, laissez l'extrémité libre et fixez le haut avec du ruban ou de la colle chaude.

Étape 3

Ce bandeau a des LED adressables, ce qui signifie qu'on peut dire "toi au milieu, deviens rouge !". Mais elles ne répondent pas à "hé toi", il faut connaître leurs numéros.

Les LED sous le pli brilleront par l'arrière du théâtre et serviront pour l'animation. Dans l'exemple ci-dessous, mes LED d'animation sont 0, 1, 2, 20, 21, 22, 40, 41, 42. Deux LED dans la section haute brilleront vers les maisons. J'utilise la LED 23 pour la maison arrière, et la 25 pour simuler la lumière du feu dans les maisons avant.

Comptez vos LED et dessinez une carte de référence simple qui a du sens pour vous, afin de pouvoir entrer les bons numéros de LED dans le code plus tard. N'oubliez pas de commencer votre comptage au début du bandeau en partant de zéro, parce que les ordinateurs.

Étape 4

Collez le support LED sur la pièce de base en plaque mousse. Positionnez-le comme montré et de façon que la large bande de lumières soit centrée longitudinalement avec la base.

Ajoutez maintenant les pièces latérales courbées en plaque mousse aux extrémités avec de la colle chaude comme montré.

Étape 5

Ajoutez maintenant les séparateurs de lumière et la pièce supérieure en plaque mousse. Les séparateurs empêchent les lumières d'animation de déborder vers les maisons, et vice-versa. Positionnez le plus grand séparateur près du pli du support LED, et le plus petit au-dessus de façon qu'au moins une LED soit entre eux (voir photos). Positionnez la pièce supérieure pour qu'elle soit d'équerre avec la base comme dans le diaporama ci-dessous et fixez avec de la colle chaude.

Étape 6

Fixez l'extrémité du bandeau LED sur le bord supérieur avant avec de la colle chaude pour que la dernière LED de la chaîne puisse briller sur la scène. C'est la LED d'ombre principale.

Partie 3 : Programmation de l'Arduino 101 et configuration de Blynk

Connectez un câble USB de programmation à l'Arduino 101, et connectez le bandeau LED, le boîtier de piles et l'Arduino 101 ensemble (laissez l'interrupteur du boîtier de piles sur "off").

Vous aurez besoin de l'Arduino IDE installé sur votre ordinateur, avec le core Intel Curie (voir guide de démarrage Arduino 101). Vous devrez aussi installer la bibliothèque Adafruit NeoPixel et la bibliothèque Blynk.

Si vous êtes novice avec Arduino, lancez quelques sketches d'exemple de base pour vérifier que tout fonctionne.

Étape 1

Installez l'application Blynk sur votre téléphone.

Blynk est un excellent outil pour le prototypage rapide et le contrôle à distance de votre Arduino 101. Le support BLE a encore quelques bugs, mais Blynk est de loin le moyen le plus rapide que j'ai trouvé pour contrôler un projet Arduino 101 depuis un téléphone.

Étape 2

Chargez le code d'exemple dans votre Arduino IDE et modifiez les numéros de pixels LED si nécessaire en utilisant la carte que vous avez faite plus tôt.

Le programme anime les numéros de LED dans le tableau pos[] pour créer l'illusion de neige qui tombe. Changez ces nombres si nécessaire pour correspondre à votre montage (les LED d'animation sont celles sous le pli de votre support LED). Arrangez les nombres dans l'ordre où vous voulez qu'elles s'allument. Les lumières traversent des trous d'épingle pour faire la "neige", donc allumer du bas vers le haut fera tomber la neige vers le bas, de gauche à droite fera souffler la neige de droite à gauche.

//# LED d'animation neige
int pos[] = {0, 1, 2, 20, 21, 22, 40, 41, 42};

//# combien de pixels d'animation dans le tableau ci-dessus ?
int numLeds = 9;

//# LED principale projetant l'ombre au bout du bandeau (sur un bandeau 60 pixels, c'est le pixel #59)
int shadowPixel = 59;

//# pixel pour les lumières dans la maison arrière
int lightHousePixel = 23;

//# pixel pour la lumière de feu clignotante dans les maisons avant
int firePixel = 24;

Une fois le code modifié, compilez et téléversez sur votre Arduino 101. Une fois le téléversement réussi, débranchez le câble USB et mettez l'interrupteur du boîtier de piles sur "on". Vous devriez voir le shadowPixel s'allumer, et les pixels d'animation s'allumer en séquence. Les pixels maison et feu resteront éteints jusqu'à ce que vous les contrôliez avec Blynk.

Étape 3

Chargement de votre application Blynk :

Ouvrez l'application Blynk sur votre téléphone et appuyez sur le bouton "scan" en haut à droite. Scannez ce QR code et l'interface de contrôle devrait se charger automatiquement.

Une fois chargée, l'interface devrait ressembler à ceci :

Si vous préférez construire votre interface Blynk manuellement au lieu de scanner le code, commencez avec un widget BLE et 3 curseurs réglés pour sortir 0-100 vers V0, V1 et V2.

Étape 4

Connectez-vous en BLE à votre Arduino 101. Appuyez sur le widget BLE et si votre Arduino 101 est alimenté, vous devriez voir "ShadowTheatre". Connectez-vous, puis appuyez sur l'icône "play" (flèche) en haut à droite pour contrôler votre projet. Vous devrez peut-être vous reconnecter après la mise en veille de votre téléphone.

OK, c'est fait pour la partie difficile, passons au bricolage ! Vous pouvez tout éteindre jusqu'à la révélation finale.

Partie 4 : Silhouettes en carton, bâtiments et finitions

Étape 1

Trouvez vos quatre feuilles de carton imprimées. Avec un cutter et des lames neuves, découpez la silhouette d'arrière-plan. Changez souvent la lame ! Couper avec une lame émoussée est super frustrant. J'ai changé la lame 3 fois pour découper cette silhouette.

Étape 2

Découpez les pièces des maisons et collez les dos avec de la colle chaude. Les côtés imprimés doivent faire face à l'arrière, pour ne pas voir l'encre depuis l'avant. Parcourez les photos ci-dessous.

Étape 3

Ajoutez les maisons sur la scène. Utilisez de la colle chaude ou du ruban adhésif. Essayez de fermer tous les espaces pour que la lumière entre dans les maisons mais ne déborde pas sur les côtés.

Étape 4

Pliez maintenant les côtés de la feuille de silhouette et fixez le bas au bord arrière de la scène avec de la colle chaude (face imprimée tournée vers l'extérieur).

Étape 5

Découpez une scène de neige à projeter sur le mur derrière le théâtre d'ombres. Vous pouvez utiliser des épingles ou des cure-dents, ou découper des formes complexes. Une fois la feuille prête, collez-la sur les bords courbés pour créer une surface de projection.

Étape 6

Fixez la feuille de gauche et la feuille avant avec de la colle chaude.

Fixez la feuille de droite légèrement avec du ruban adhésif, pour pouvoir encore accéder à l'intérieur pour allumer/éteindre le boîtier de piles.

C'est terminé ! Trouvez un endroit sombre avec un mur à proximité pour l'essayer ! Quand vous allumez, le théâtre d'ombres devrait projeter une scène d'ombre et de la neige qui tombe. Avec l'application Blynk, vous pouvez contrôler la lumière principale et les lumières dans les bâtiments.

Code

Sketch Arduino pour Théâtre d'Ombres

Ce sketch utilise la bibliothèque Adafruit NeoPixel et la bibliothèque Blynk. Il permet de contrôler à distance des LED dans un bandeau adressable pour créer des effets dans un théâtre d'ombres.

/* Copyright (c) 2016 Intel Corporation. All rights reserved. See license notice at end of file. */
///////////////////////CES SONT LES VARIABLES QUE VOUS DEVEZ MODIFIER POUR VOTRE THÉÂTRE D'OMBRES////////////////////////////////////////
// LED d'animation neige
int pos[] = {0, 1, 2, 20, 21, 22, 40, 41, 42}; // quelles LED sont disponibles pour l'animation ? Elles seront appelées dans l'ordre de gauche à droite.
int numLeds = 9; // combien de pixels d'animation dans le tableau ci-dessus ?
int shadowPixel = 59; /// LED principale projetant l'ombre au bout du bandeau.
int lightHousePixel = 23; // pixel pour les lumières dans la maison arrière
int firePixel = 24; // pixel pour la lumière de feu clignotante pour les maisons avant.
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#include <Adafruit_NeoPixel.h>
#include <BlynkSimpleCurieBLE.h>
#include <CurieBLE.h>
#define PIN 6
int v0 = 0; // variables pour stocker les valeurs entrantes de Blynk
int v1 = 0;
int v2 = 0;
int fadeup = 0; // variables pour lissage de l'animation lumineuse
int fadedown = 0;
int firetimer = 0; /// variables pour faire scintiller le feu
int fireinterval = 50;
int flicker = 0;
unsigned long lightcounter = 0; // variable pour compter à travers les lumières d'animation indéfiniment
int stp = 0; /// étapes de lumière pour l'animation. Une pour la lumière courante pour l'allumer, et une pour l'ancienne pour l'éteindre.
int stpOld = 0;
unsigned long timer = 0;
int interval = 0;
char auth[] = "YourAuthToken"; /// Le Auth Token n'est pas utilisé par Blynk pour le BLE actuellement. S'il est activé plus tard, vous pouvez obtenir votre token depuis l'app Blynk et le coller dans les "".
BLEPeripheral blePeripheral; /// configure la connexion BLE
Adafruit_NeoPixel strip = Adafruit_NeoPixel(60, PIN, NEO_GRB + NEO_KHZ800); //// configure le bandeau LED. Si votre bandeau a plus ou moins de 60 pixels, changez le premier nombre pour correspondre.

void setup() {
  delay(1000);
  timer = millis();
  strip.begin();
  strip.show(); // Initialise tous les pixels à 'off'
  blePeripheral.setLocalName("ShadowTheatre");
  blePeripheral.setDeviceName("ShadowTheatre");
  blePeripheral.setAppearance(384);
  Blynk.begin(auth, blePeripheral);
  blePeripheral.begin();
  interval = 350; // intervalle de 350ms pour l'animation neige
}

void loop() {
  Blynk.run(); // Blynk pour contrôle temps réel
  blePeripheral.poll();

  //////// allume le pixel d'ombre et contrôle avec Blynk
  strip.setPixelColor(shadowPixel, 200 - v2, 160 - v2, 160 - v2); // allume la lumière d'ombre, v2 (depuis app Blynk) change la lumière.

  // feu
  if ((millis() - firetimer) > fireinterval) {
    firetimer = millis();
    flicker = random(0, 40); // quand un intervalle de temps passe, change la luminosité du feu aléatoirement entre 0 et 40.
  }
  if (v0 > 1) {
    strip.setPixelColor(firePixel, 80 + v0 + flicker, v0 + flicker, 0); // le feu = luminosité du curseur Blynk + valeur flicker, pondéré vers le rouge
  } else {
    strip.setPixelColor(firePixel, 0, 0, 0); // allume le feu seulement si curseur Blynk > 0.
  }

  // lumières maison
  if (v1 > 1) {
    strip.setPixelColor(lightHousePixel, 200 - v1, v1, 0); /// si curseur Lumières Maison Blynk > 0, contrôle les lumières maison arrière. sinon éteint.
  } else {
    strip.setPixelColor(lightHousePixel, 0, 0, 0);
  }

  // animation neige
  if ((millis() - timer) > interval) {
    // chaque fois que l'intervalle passe, avance d'un pas et réinitialise les fades
    stpOld = stp;
    timer = millis();
    lightcounter++;
    stp = (lightcounter % numLeds); /// compte encore et encore de zéro à numLeds-1
    fadeup = 0; // réinitialise les valeurs de fade à chaque intervalle
    fadedown = 170;
  }
  fadeup += 2;
  fadeup = constrain(fadeup, 0, 170);
  fadedown -= 2;
  fadedown = constrain(fadedown, 0, 170);
  for (int i = 0; i < numLeds; i++) {
    // éteint toutes les LED d'animation
    strip.setPixelColor(pos[i], 0, 0, 0);
  }
  strip.setPixelColor(pos[stp], fadeup, fadeup, fadeup); /// Définit le pixel sélectionné à la valeur "fadeup" courante
  strip.setPixelColor(pos[stpOld], fadedown, fadedown, fadedown); // Définit l'ancien pixel à la valeur "fadedown" courante
  strip.show(); // enfin, envoie toutes les valeurs de couleur courantes au bandeau LED pour affichage.
}

//// quand de nouveaux signaux arrivent de Blynk, ils mettent à jour les variables globales v0, v1, v2.
BLYNK_WRITE(V0) // Le curseur Cheminée écrit sur la broche V0
{
  v0 = param.asInt();
}
BLYNK_WRITE(V1) // Le curseur Lumières Maison écrit sur la broche V1
{
  v1 = param.asInt();
}
BLYNK_WRITE(V2) // Le curseur LED Ombre Principale écrit sur la broche V2
{
  v2 = param.asInt();
}
////////////////////////////////////////////////////////////////////////////////////////////
/* This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */

Schémas

Imprimez ces patrons sur papier imprimante standard pour guider la découpe de la plaque mousse. Vous pouvez les poser dessus et tracer avec un cutter pour transférer le motif.

Imprimez sur papier carton 8,5 x 11" (4 feuilles). Ce sont les maisons, côtés et silhouettes d'ombre.

Si vous avez la chance d'avoir accès à une découpeuse laser ou vinyle, vous pouvez utiliser ce patron pour découper vos pièces en carton.

30bn6Le68V1Lpp2spRMw.svg