Light painting

présentation

Peindre avec la lumière ! Ici il s'agit d'utiliser des leds pilotées par un micro-controleur pour créer des images.

Réalisation

liste du matériel :

• Module de carte SD
• carte SD
• arduino
• ruban de 60 LEDs adressable : WDS2812B, néopixel
• un bouton poussoir
• un tasseau de 20mmX20mm

Voici l'image passée à la moulinette :

code Arduino

  1  
  2 ////////////////////
  3 //   PIXELSTICK   //
  4 ////////////////////
  5 
  6 /*
  7  * 
  8                                        +-----+
  9                             +----------| USB |----------+
 10                             |          +-----+          |
 11       SCK module carte SD - | [X]D13/SCK    MISO/D12[X] | - MISO du module carte 
 12    VCC du module carte SD - | [X]3.3V       MOSI/D11[X]~| - MOSI du module carte SD   
 13                             | [ ]V.ref    _   SS/D10[ ]~|    
 14                             | [ ]A0     / N \     D9[ ]~|    
 15                             | [ ]A1   /   A   \   D8[ ] |    
 16                             | [ ]A2   \   N   /   D7[ ] |    
 17                             | [ ]A3     \ 0 /     D6[X]~| - Ruban de led   
 18                             | [ ]A4/SDA           D5[ ]~|    
 19                             | [ ]A5/SCL           D4[X] | - broche CS du module carte SD   
 20                             | [ ]A6          INT1/D3[ ]~|    
 21                             | [ ]A7          INT0/D2[X] | - broche bouton   
 22                             | [ ]5V              GND[ ] |     
 23                             | [ ]RST             RST[ ] |    
 24                             | [ ]GND 5V MOSI GND TX1[ ] |    
 25                             | [ ]Vin [ ] [ ] [ ] RX1[ ] |   
 26                             |        [ ] [ ] [ ]        |
 27                             |        MISO SCK RST       |
 28                             | NANO-V3                   |
 29                             |___________________________|
 30          
 31              ______________________________
 32             |        SD CARD  _____________|
 33            -|[ ]GND   MODULE |         /   
 34  VCC       -|[ ]3,3V  [XXX]  |       / |
 35            -|[ ]5V      =    |     /   |
 36  broche 4  -|[ ]CS      =    |    |    |
 37  broche 11 -|[ ]MOSI    =    |    |    |
 38  broche 13 -|[ ]SCK .   =    |     \   |
 39  broche 12 -|[ ]MISO    =    |       \ |
 40  GND       -|[ ]GND     =    |_________\___
 41             |______________________________|  
 42  
 43 
 44 Matériel :
 45 - Module de carte SD
 46 - carte SD
 47 - arduino
 48 - ruban de 60 Leds adressables : WDS2812B, néopixel
 49 - un bouton poussoir
 50 
 51 Fortement inspiré de pixelstick par Lucas Berbesson for LA FABRIQUE DIY
 52 LICENSE MIT
 53 Voir https://github.com/LucasBerbesson/pixelstick
 54 
 55 Schéma de l'Arduino en ASCII-ART CC-By http://busyducks.com/ascii-art-arduinos
 56 Sous licence CC-By-Sa (http://creativecommons.org/licenses/by-nc-sa/3.0/)
 57 */
 58 /*
 59    ___
 60  / ___ \
 61 |_|   | |
 62      /_/ 
 63      _   ___   _ 
 64     |_| |___|_| |_
 65          ___|_   _|
 66         |___| |_|
 67 Les petits Débrouillards - CC-By-Sa http://creativecommons.org/licenses/by-nc-sa/3.0/
 68 */
 69 #include <SPI.h>
 70 #include <SD.h>
 71 #include <Adafruit_NeoPixel.h>
 72 // Parameter 1 = number of pixels in strip
 73 // Parameter 2 = pin number (most are valid)
 74 // Parameter 3 = pixel type flags, add together as needed:
 75 //   NEO_KHZ800  800 KHz bitstream (most NeoPixel products w/WS2812 LEDs)
 76 //   NEO_KHZ400  400 KHz (classic 'v1' (not v2) FLORA pixels, WS2811 drivers)
 77 //   NEO_GRB     Pixels are wired for GRB bitstream (most NeoPixel products)
 78 //   NEO_RGB     Pixels are wired for RGB bitstream (v1 FLORA pixels, not v2)
 79 
 80 // Broche "data" pour les données du ruban de Led
 81 #define brocheLED 6
 82 // Broche CS de la carte SD
 83 #define brocheSD 4
 84 
 85 int brocheBouton = 2;
 86 //bool playAnimation = true;
 87 int positionDuFichier = 0;
 88 int nombreDeFichiers = 0;
 89 bool Animation = true;
 90 String nomDuFichier[10];
 91 File root;
 92 File dataFile;
 93 String nomDuFichierCourant = "";
 94 
 95 int nombreDeLED = 60;
 96 Adafruit_NeoPixel strip = Adafruit_NeoPixel(nombreDeLED, brocheLED, NEO_GRB + NEO_KHZ800);
 97 
 98 void setup() {
 99  Serial.begin(115200);
100  pinMode(13, OUTPUT);
101  pinMode(brocheBouton, INPUT_PULLUP);
102  strip.begin();
103  strip.show();
104  setupSDcard();
105  delay(100);
106 }
107 
108 void loop() {
109   if (digitalRead(brocheBouton) == LOW) {
110      digitalWrite(13,HIGH);
111      positionDuFichier++;
112      Serial.println(positionDuFichier);
113      delay(100);
114      digitalWrite(13,LOW);
115    }
116   delay(500);
117    Serial.print("envois du fichier");
118    if ( positionDuFichier >= nombreDeFichiers) {
119     positionDuFichier = 0;
120    }
121    SendFile(nomDuFichier[positionDuFichier]);
122    ClearStrip();
123 
124 }
125 
126 
127 void setupSDcard() {
128  pinMode(brocheSD, OUTPUT);
129 
130  while (!SD.begin(brocheSD)) {
131    Serial.println("échec de l'initialisation de carte SD ! ");
132    delay(500);
133  }
134  Serial.println("la carte SD est initialisée ");
135  delay(1000);
136  root = SD.open("/");
137  Serial.println("Exploration des fichiers ");
138  delay(500);
139  GetFileNamesFromSD(root);
140 }
141 
142 // Cette fonction liste les fichiers de la carte SD
143 void GetFileNamesFromSD(File dir) {
144  int fileCount = 0;
145  String nomDuFichierCourant = "";
146  while(1) {
147    File entry =  dir.openNextFile();
148    if (! entry) {
149      // no more files / plus de fichier
150      nombreDeFichiers = fileCount;
151      Serial.println("nombre de fichiers ");
152      Serial.println(fileCount);
153    entry.close();
154      break;
155    }
156    else {
157        nomDuFichierCourant = entry.name();
158        if (nomDuFichierCourant.endsWith(".TXT")) { //seulement les fichiers .txt
159          if(nomDuFichierCourant.startsWith("_")){      // Si la carte SD est utilisée sur mac, le système ajoute des fichiers "sidecar".
160           // Ils débutent par le caractère _, et ils ne doivent pas être pris en compe.
161          }else{
162            nomDuFichier[fileCount] = entry.name();
163            fileCount++;
164          }
165        }
166    }
167    entry.close();
168  }
169 }
170 
171 // Cette fonction fait clignoter la première led et lance les animations.
172 void SendFile(String Filename) {
173  char temp[14];
174  Animation = true;
175  Filename.toCharArray(temp,14);
176  Serial.println(Filename);
177  dataFile = SD.open(temp);
178  // Si le fichier est accessible, l'envoyer au ruban de led
179  if (dataFile) {
180    int i = 0;
181    int red, green, blue;
182    strip.setPixelColor(1,255,255,255);
183    strip.show();
184    delay(500);
185    strip.setPixelColor(1,0,0,0);
186    strip.show();
187    delay(500);
188    strip.setPixelColor(1,255,255,255);
189    strip.show();
190    delay(500);
191    strip.setPixelColor(1,0,0,0);
192    strip.show();
193    delay(2000);
194    while(dataFile.available() && Animation){
195 
196      if (digitalRead(brocheBouton) == LOW) {
197        Animation = false;
198        break;
199        delay(100);
200      }
201      if (i == (nombreDeLED)) {
202        i=0;
203        strip.show();
204        delay(120);
205        }
206      red = dataFile.parseInt();
207      green = dataFile.parseInt();
208      blue = dataFile.parseInt();
209      strip.setPixelColor(i, red, green, blue);
210      i++;
211    }
212    Serial.print("Fermeture du fichier ");
213    dataFile.close();
214  } else {
215    Serial.print("Erreur de lecture ");
216    setupSDcard();
217    return;
218    }
219  }
220 
221 // Cette fonction éteint toute les leds du pixelstick
222 void ClearStrip() {
223  int x;
224  for(x=0;x<nombreDeLED;x++) {
225    strip.setPixelColor(x, 0);
226  }
227  strip.show();
228 }

Traitement de l'image

Il faut d'abord créer une image qui fait le même nombre de pixel de large que le baton de pixel. Pour cela j'utilise GIMP (échelle et taille de l'image).

Ensuite il faut utiliser le script python de Lucas Berbesson (Voir https://github.com/LucasBerbesson/pixelstick) ou voir ici : Script Python "generate"

Prendre la photo

Celle qui est ici à été réalisée avec un réflexe numérique :

• exposition : 13 secondes.
• sensibilité : 100 iso
• ouverture : f/6 (f/3 à F/5 serait mieux d'après mes recherches)

Rappel des principes de la photo

• La durée d'exposition : Elle s'exprime en secondes, plus elle est grande, plus le de capteur reçoit de lumière (attention il ne faut pas bouger sinon la photo sera floue !). Sur l'appareil, vous pouvez prédéfinir la durée en secondes, ou bien en mode "bulb" c'est la durée de votre choix (à utiliser avec un pied et une télécommande).
• La sensibilité : c'est la capacité du capteur à réagir à la lumière : un film de 100 iso est très peu sensible, un film de 4000 iso est très sensible mais sa définition sera moins bonne (Il y aura un "grain" sur la photo).
• l'Ouverture c'est l'ouverture du diaphragme : Attention il y a un piège : plus le chiffre est grand, plus le trou est petit ! f/1 c'est une très grande ouverture, f/11 c'est un petit trou. Il est à noter que la profondeur de champs (la zone ou la photo est nette, est d'autant plus grande que le chiffre est grand (le trou petit).

et sur la vidéo ? comment c'est fait ?

l'auteur de la vidéo à utilisé le mode echo effect du logicel after effect d'abode.

documentation

• Sur wikipédia : https://fr.wikipedia.org/wiki/Light_painting
• Pochoir de lightpainting à Brest : https://www.posethelight.com/quest-ce-que-le-pochoir-lumineux-en-light-painting/
• 35 photos d'artistes de lightpainting : http://www.marevueweb.com/photographies/light-painting/
• Voir également le projet HP19 : Roger, Gérard, Bernard réalisé dans le cadre du Hackathon pédagogique 2019 de la ville de Brest à l'IMT Atlantique.
• Le pixelstick sur github : https://github.com/LucasBerbesson/pixelstick
• Sur Instructable : https://www.instructables.com/id/Arduino-Pixel-Stick/
• site commercial pixelstick : http://thepixelstick.com/index.html
• Avec un raspberry pi chez Adafruit : https://learn.adafruit.com/dotstar-pi-painter
• Un autre : https://learn.adafruit.com/light-painting-with-raspberry-pi
• Avec un arduino chez Adafruit : https://learn.adafruit.com/neopixel-painter
• un autre : https://github.com/TheMasterFX/LED-Lightpainter/blob/master/platformio.ini

Pour de la vidéo :

• https://www.lesnumeriques.com/photo/looz-du-lightpainting-en-temps-reel-pu116989.html

• Picasso et les couvertures de Life magasine en light painting : https://time.com/3746330/behind-the-picture-picasso-draws-with-light/