Light painting : Différence entre versions
(→documentation) |
|||
| (Une révision intermédiaire par le même utilisateur non affichée) | |||
| Ligne 25 : | Ligne 25 : | ||
[[Fichier:Logo-apdb-60px.png|400px]] | [[Fichier:Logo-apdb-60px.png|400px]] | ||
| − | code | + | ===code Arduino=== |
| − | < | + | <syntaxhighlight lang="Arduino" line> |
//////////////////// | //////////////////// | ||
// PIXELSTICK // | // PIXELSTICK // | ||
| Ligne 254 : | Ligne 254 : | ||
strip.show(); | strip.show(); | ||
} | } | ||
| − | </ | + | </syntaxhighlight> |
===Traitement de l'image=== | ===Traitement de l'image=== | ||
| Ligne 290 : | Ligne 290 : | ||
* Picasso et les couvertures de Life magasine en light painting : https://time.com/3746330/behind-the-picture-picasso-draws-with-light/ | * Picasso et les couvertures de Life magasine en light painting : https://time.com/3746330/behind-the-picture-picasso-draws-with-light/ | ||
| + | |||
| + | [[Catégorie:led]][[Catégorie:ruban de led]][[Catégorie:WS1812B]] | ||
Version actuelle datée du 3 décembre 2023 à 11:14
Sommaire
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 :
- Picasso et les couvertures de Life magasine en light painting : https://time.com/3746330/behind-the-picture-picasso-draws-with-light/
