Le concept

"Réaliser une œuvre de  Mapping Vidéo transportable."

L’œuvre comprend le système de projection, le support de projection, le contenu projeté ainsi qu’un système de calibration & de bande LED.

Ce système étant pliable et transportable, il peut ainsi être déployé rapidement.

Historique

Ce projet est une évolution du projet réalisé lors de la seconde session. Celui-ci se présentait sous forme d’un livre de 30x20 pouces en mousse, avec deux faces recouvertes de quatre surfaces blanches en papier, support de la projection.

Aux quatre extrémités, un détecteur de lumière. Ceux-ci étaient connectés à un Arduino Uno qui se chargeait de récupérer les informations transmises par le vidéoprojecteur et les envoyaient à un Raspberry PI qui réalisait une auto calibration de la projection avant de projeter le vidéo.

Inconvénients de ce prototype

Le support de projection

Celui-ci était en mousse recouverte de papier. Cela lui donnait une apparence plutôt cheap. Les surfaces de projections étaient en papier.

 

Le système de calibration

À l’arrière, le système électronique était simplement posé et non protégé. Les liaisons faites via une plaque de prototypage, ce qui réduit la fiabilité des résultats.

 

Transmission filaire

L’Arduino transmettait les informations des capteurs via le port série en USB. Celui-ci était alimenté en USB via le Raspberry Pi lui également alimenté via une batterie. Ce système filaire limitait le positionnement du projecteur.

 

Du prototype vers le projet final

Je me suis fixé une série d'objectifs basés sur une amélioration du prototype vers le projet final

  • 1. Le support devra être plus grand, plus solide et avec une apparence plus solide
  • 2. Le système de calibration Arduino/Raspberry Pi devra être sans fil
  • 3. Le système électronique devra être transposé sur une carte dédiée et plus compacte.
  • 4. Le système électronique sera protégé dans des boites sur mesure imprimées en 3D
  • 5. Une bande de LED sera ajoutée afin d’ajouter une dimension visuelle supplémentaire a l’œuvre.

Le système de calibration

Le système de calibration utilise un Arduino et 4 capteurs de lumières. Durant la réalisation du projet, celui-ci transcodait le signal lumineux de chaque capteur en signal en 0 et 1 au Raspberry Pi. Ce code était interprété par le Raspberry Pi qui adaptait sa projection afin de positionner au mieux l’image.

Cependant, pour améliorer la fiabilité de la détection, l'interprétation du signal lumineux a été déporté directement sur le Raspberry Pi. Désormais, l'arduino ne transmet que la moyenne de 5 valeurs brutes (entre 0 et 1024) mesurées sur les capteurs et les transmet en UDP au Raspberry Pi.

Prototype d’origine

Dans ce prototype, un Arduino Uno classique a été utilisé. La carte est imposante, mais permet de réaliser un prototype rapidement du projet. Chaque capteur est connecté à l’un des ports analogiques. L’alimentation se fait en USB par le Raspberry Pi. Le signal est transmis via le port série en USB.

C’est cette version qui a été utilisée pour le prototype de la seconde session.

Celle-ci est fonctionnelle, mais est plutôt imposante et oblige une connexion USB au Raspberry Pi pour la communication et l’alimentation.

Prototype V2

Cette version remplace l’Arduino Uno par un Arduino mini pro. Celui-ci a les mêmes propriétés qu’un Arduino Uno, mais bien plus compact, et peu couteuse. Pour pallier la problématique du sans-fil, j’ai pensé inclure un transmetteur 433Mhz.

Le problème de l’utilisation d’un transmetteur 433Mhz, c’est qu’il est nécessaire une connaissance plus poussée en transmission de signal et créer un protocole de communication entre l’Arduino et le Raspberry Pi. De plus, c’est moins fiable que le protocole Wifi.

Ce prototype n’a pas été réalisé.

Prototype V3

Pour la version 3, j’ai remplacé l’Arduino par une carte Wemos D1 (ESP 8266). Cette carte a l’avantage d’être peu couteuse, dispose d’un chipset Wifi. Elle est compatible avec le code des Arduino à condition d’utiliser des librairies adaptées à celui-ci.

Cependant, elle a comme inconvénient de ne disposer que d’une seule entrée analogique. Or nous en avons besoin de 4 pour les capteurs.

J’ai pallié au problème en utilisant un Multiplexeur 8 canaux. Cette puce se comporte comme un interrupteur. Sur 3 entrées, nous envoyons du courant ou pas. Cela permet de coder sur 3 bits un signal permettant d’adresser 8 codes différents. Chaque code fait passer le courant du canal correspondant.

À chaque passage dans la boucle, 4 canaux sont écoutés à la suite afin de récupérer presque simultanément le signal des 4 récepteurs.

Le reste fonctionne de la même manière que l’Arduino classique, sauf pour la transmission du signal qui se fera en Wifi via le protocole UDP.

V4 : Réalisation de la première carte

La première carte a été réalisée sur une plaque à souder. Cependant, après les premiers tests, j’ai constaté des courts-circuits dus à un manque de précision dans la soudure. 

De plus lors des tests, le wemos a été grillé 😖

V5 : Réalisation de la seconde carte (partie 1)

Grâce à plus de pratique, la seconde carte a été faite proprement. De plus, des connecteurs à vis ont étés rajoutés pour plus de flexibilité dans le montage.

Code

Ce code permet la lecture de chaque capteur et d’envoyer les données en temps réel via trames UDP directement au Raspberry Pi.

Code
#include 
#include 

// Connexion au Wifi du raspberry
const char* ssid     = "carton";
const char* password = "raspberry";

WiFiUDP Udp;

int port = 8898;  // port d'envoi
IPAddress ip(172, 24, 1, 255); //Envoi sur le broadcast du reseau
char valeur[50]; 

//config des pins
#define pinS0 2
#define pinS1 14
#define pinS2 0

//config des variables
int capteur1, capteur2, capteur3, capteur4, i;
int compte;

void setup()
{
  Serial.begin(115200);
  Serial.println();

  Serial.printf("Connexion à %s ", ssid);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED)
  {
    delay(500);
    Serial.print(".");
  }
  Serial.println(" Connécté");
   
    // Initialisation des Pins du multiplexeur CD4051
    pinMode(pinS0, OUTPUT);
    pinMode(pinS1, OUTPUT);
    pinMode(pinS2, OUTPUT);

    capteur1=0;
    capteur2=0;
    capteur3=0;
    capteur4=0;
    compte=0;

}

void loop(void)
{
      // Capteur 1
      // lecture du capteur relié a l'entrée Y0 du CD4051
      digitalWrite(pinS2, LOW);
      digitalWrite(pinS1, HIGH);
      digitalWrite(pinS0, HIGH);
      capteur1 += analogRead(0);     

      // Capteur 2
      // lecture du capteur relié a l'entrée Y1 du CD4051
      digitalWrite(pinS2, LOW);
      digitalWrite(pinS1, LOW);
      digitalWrite(pinS0, LOW);      
      capteur2 += analogRead(0); 

      // Capteur 3
      // lecture du capteur relié a l'entrée Y2 du CD4051
      digitalWrite(pinS2, LOW);
      digitalWrite(pinS1, LOW);
      digitalWrite(pinS0, HIGH);
      capteur3 += analogRead(0); 

      // Capteur 4
      // lecture du capteur relié a l'entrée Y3 du CD4051
      digitalWrite(pinS2, LOW);
      digitalWrite(pinS1, HIGH);
      digitalWrite(pinS0, LOW);
      capteur4 += analogRead(0);

      compte++;

     
      if( compte==5 ) { //On fait une moyenne de 5 lectures par capteurs afin de ne pas saturer le réseau tout en concervant toutes les lectures
        sprintf(valeur,"%04d %04d %04d %04d",capteur1,capteur2,capteur3,capteur4);


        //On envoi en UDP les valeurs moyenne des 4 capteurs
        Udp.beginPacket(ip, port);
        Udp.write(valeur);
        Udp.endPacket();
  
        compte=0;
        capteur1=0;
        capteur2=0;
        capteur3=0;
        capteur4=0;
      }
      delay(10);
     
}

Comme expliqué en 5.1.3, nous ne disposons que d’une seule entrée analogique sur le Wemos. Nous devons par conséquent dans la boucle lire chaque capteur l’un après l’autre via un multiplexeur.

digitalWrite(pinS2, LOW);
digitalWrite(pinS1, HIGH);
digitalWrite(pinS0, HIGH);
valeur4 = analogRead(A0);

Dans cet exemple, nous envoyons un signal de 3.3v dans les pins S0 & S1, et rien dans le pin S2. Ainsi le signal redirigé par le multiplexeur vers l’entrée analogique sera celui du capteur 4.

Chaque passage de la boucle permet une lecture des 4 capteurs. Tous les 5 lectures de chaque capteurs, une moyenne est faite et la moyenne de chacun des 4 capteurs est transmise en UDP au raspberry pi.

La problématique première fut la gestion du bruit lumineux. En effet, le projecteur ayant une faible intensité lumineuse et les capteurs peu de sensibilité, comment déterminer qu’un capteur reçoit pleinement de la lumière ou du noir? Les capteurs de lumière de ce type ne sont pas très précis et la différence captée par ceux-ci entre de la lumière et du noir est minime. Pour que le Raspberry Pi puisse interpréter correctement les positions, il a besoin de valeurs numériques 0 ou 1.

Pour cela, en début de projection, nous envoyons 3 signaux lumière puis noir. Cela nous permet de déterminer une valeur minimum et maximum qui sera détectée.

Nous faisons une adaptation des valeurs entre 0 et 1 (min et max). En utilisant une valeur seuil, nous attribuons a toutes les valeurs inférieures a 0.5 moins le seuil un "0", a toutes les valeurs supérieures a 0.5 + le seuil un "1". Les valeurs dans le seuil auront un "X" pour considérer la valeur comme indéterminée et non fiable

Un message est ensuite composé sur 4 bits.

  • 0110 donnera « Réception de la lumière sur le capteur 2 & 3 »
  • 0111 donnera « Réception de la lumière sur le capteur 2,3 & 4 »

La bande de led

La bande de led me permet de rajouter une dimension visuelle supplémentaire au projet.

Le prototype

Pour simplifier le projet, et éviter les erreurs du Wemos, j’ai choisi de séparer les deux besoins (détecter la lumière et gérer la bande de LED) sur deux Wemos distincts.

La bande de LED est une WS2811 de 1 mètre (60 leds) qui a la particularité d’avoir les LEDs individuellement adressable. Celles-ci sont disposées par blocs de 3. Par rapport aux besoins, j’ai utilisé 54 LED (18 blocs adressables)

 

Cependant, après des tests sur la plaque de prototypage, j’ai constaté que les LED certifiées pour du 12 volts ne démarraient même pas avec du 5v fourni par le Wemos. J’ai donc dû utiliser une alimentation dédiée de 12 volts.

Fabrication de la carte (partie 2)

La partie détection et la partie LED ont étés assemblées sur la même carte par souci d’optimisation.

J’ai eu besoin de gérer 3 voltages différents sur la même carte :

  • 3v pour l’alimentation des détecteurs du premier Wemos
  • 5v pour l’alimentation des deux Wemos et du multiplexeur

12v pour alimenter la bande de LEDs

Le plus simple est donc de partir sûr du 12 volt. Cette alimentation est connectée directement à la bande de LED. En dérivation, j’ai connecté un transformateur 12v -> 5v. Les 5V alimentent les deux Wemos.

Le 3.3v est généré directement par le Wemos.

Le code

Code

Pour faire fonctionner la bande de LED, nous utilisons la librairie FastLed qui fonctionne plutôt bien sur Wemos. Pour plus de facilité de prise en main, j’ai utilisé le script de démonstration « ShowReel100 » plutôt simple à comprendre et qui fait une bonne démonstration visuelle de la bande de LED.

Cependant ce script de démonstration n’est qu’une démonstration en automatique des effets visuels. J’y ai inclus le support du Wifi et des requêtes UDP

Au lancement du Wemos, celui-ci affiche un arc-en-ciel et se connecte au wifi du Raspberry Pi.

Via différentes requêtes UDP en hexadécimal, il est possible de :

  1. Changer la luminosité : b0, b1, ..., b34, ... b100 (Variation entre 0% et 100%)
  2. Changer le modèle (l’effet visuel) : p0,p1,p2,...,p234 (Choix entre 0 & 5)
  3. Activer ou désactiver le défilement automatique des effets visuels: a0 ou a1

Il suffit ensuite que le Raspberry envoie le code approprié pour changer l’effet visuel choisi

Système de projection

Fabrication

Le boitier laisse la place pour deux boutons à pression incluant une LED. Ceux-ci servent à lancer la calibration et lancer la projection. Ils sont reliés aux PINs GPIO du Raspberry Pi.

Une des paires sont connecté pour allumer la LED quand l'étape (calibration ou lecture) est prête. 

La seconde est pour établir un contact entre les GPIOs afin de lancer l'action (lecture ou calibration)

Code

Pour la calibration nous utilisons la lumière structuré de type “Code de Gray”. Cette technique consiste à projeter des informations structurées sur la surface de manière large puis de plus en plus précis.

Les détecteurs renvoient les signaux reçus selon leurs position via le Wemos en Wifi.

Le Raspberry-Pi interprète ensuite leurs position et adapte sa projecton.

Sur la pression du second bouton, il lance la lecture e la vidéo en prenant en compte la déformation calculée. Il lance en parallèle la lecture audio. 

Supports imprimés en 3D

Imprimer un support en 3D permet de créer sur mesure le support nécessaire a nos besoins.

Dans ce cas-ci, j’ai besoin de deux objets à imprimer

Le boitier de protection de la carte

Celui-ci permet de contenir la carte soudée avec les passages pour câbles. Il est basé sur une forme de boite simple que j’ai déformée pour avoir les bonnes dimensions, mais aussi pouvoir passer les câbles.

Le support projecteur v1

Celui-ci est basé sur un boitier de Raspberry Pi 3. Je l’ai modifié pour y rajouter de la hauteur et des emplacements pour les boutons. De son autre côté, j’y ai inclus le socle dans lequel va s’insérer le vidéoprojecteur, en tenant compte des boutons et accès ventilations.

Le support de projecteur v2

Après tests d'impression, il c'est avéré que la forme est difficile à imprimer, notamment à cause des formes nécessitant la création d'un pont, chose difficile à produire par une imprimante. J'ai modifié la forme afin que cela soit plus facile à imprimer. 

Le contenu video

Création de la vidéo

La vidéo a été entièrement réalisée sur after effects. J'ai utilisé les plug-ins Plexus pour les polygones de première partie, Trapcode Mir pour les effets lumineux et Element 3D pour la seconde partie.

La vidéo est réalisée pour s'adapter directement à la projection sur la surface, le projecteur parallèle à la surface. Ainsi il est plus aisé de la déformer dans le processus de calibration. Des masques délimitent les zones visibles. 

 

Démarche créative

En première partie, nous voyons  un nuage de points qui se relient pour créer des polygones. S'en viennent ensuite des effets de lumière pour montrer la manière dont sont définies les zones. 

En seconde partie, un effet de profondeur est créé afin de donner un ressenti de 3 dimensions à la projection. 

La musique utilisée est Greenland de Daily Holla légèrement modifiée afin de durer la longueur nécessaire.

Fonctionnement

Le fonctionnement de l'installation se fait en trois étapes
  • Mise en place de la structure
  • Calibration
  • Projection

Premièrement nous devons ouvrir le livre, le poser à la verticale et connecter l’alimentation. Face à celui-ci, le système de projection comprenant le RaspberryPi 3 ainsi que le Pico Projecteur. Ceux-ci sont alimentés via une batterie.

Le projecteur doit être positionné de façon à recouvrir intégralement la surface de projection

Une fois sous-tension, le Raspberry Pi va émettre un point d’accès wifi auquel vont se connecter les Wemos.

Une fois le système prêt, le témoin s’allume sur le Raspberrypi. En appuyant dessus, cela lance le processus de calibration.

Une fois celui-ci réussi, le deuxième témoin s’allume : le système est prêt à lancer le Video.

Le rendu final

Rendu final du projet : Scan + Projection du vidéo