Hors-série. Des LED, du code et des images.

Salut à tous.

Cet article est un hors-série. Il n’intéressera peut-être que de rares personnes qui s’intéressent aux technologies, dont les technologies lumineuses etc… (amis bidouilleurs, salut!). D’avance désolé si il y a des erreurs sur l’électronique et / ou le code, je débute!

Je comptais poster cet article sur le forum (c’est la suite du post LED), mais à la réflexion, il mérite peut-être plus un article ici.

Je m’explique, contextualise, et récapitule.

Il y a quelques temps, j’étudiais de la physique et du code (plus précisément du langage C et du Python). Mais je stagnais plus ou moins. Je cherchais un moyen de « voir » plus concrètement du code, de voir vraiment ce que représentent les portes logiques, etc.

J’ai fini par découvrir, au hasard de Google, qu’il existe des petites cartes électroniques libres qui permettaient semble-t-il de coder dans un langage de programmation que j’avais déjà entrevu, et d’envoyer notre code sur la carte, qui se chargerait de traduire « en vrai » ce qu’on a écrit. En réalité, bien entendu, même le code qu’on écrit sur un ordinateur pour coder une application en C par exemple est traduit « en vrai », mais tout est « dans l’ordinateur », très miniature et immensément complexe.

Je cherchais visuel, simple, intuitif, mais quand même modulable et assez puissant.

Sur ces cartes, si par exemple, on désire allumer une LED, il suffit de coder un programme qui va dire à la carte : envoie +5V par ici à tel moment, puis arrête, etc. Si par exemple on branche cette même LED, via sa branche positive, à une broche de sortie programmable de cette carte, puis qu’on branche la borne négative de la LED à la borne négative de la carte, qu’on écrit ce petit programme :

void setup()

{

pinMode(3,OUTPUT);          // On définit la sortie 3 de la carte                                                                                           // en mode « envoie du courant »

}

void loop()

{

digitalWrite(3, HIGH);          // La LED s’allume.
delay(1000);                             // Le programme attend 1000 ans (1000 ms = 1s).

digitalWrite(3, LOW);          // La LED s’éteint.
delay(1000);                             // Le programme attend 1000 ans (1000 ms = 1s).

}

Qu’on l’envoie sur la carte, et qu’on alimente cette dernière… la LED va clignoter toutes les secondes tant qu’elle est sous tension.

C’est le rôle de la boucle nommée void loop entre accolades. Tout ce qui sera codé à l’intérieur de ces accolades sera lu en boucle par la carte. La première boucle void setup, ne sera lue qu’une seule fois.

J’ai d’abord été un peu surpris par ce code, mais j’avais mordu. Je me voyais déjà programmer mon robot personnel, pour qu’il m’apporte le café (ce qui, sans rire, n’est pas si impossible que cela !).

La carte était libre et coûtait environ 10 euros (pour une copie compatible), le software pour communiquer avec la carte était libre et gratuit.

Qu’à cela ne tienne. J’ai commandé une de ces cartes, une copie du modèle officiel Arduino Uno. Une copie non-officielle, mais entièrement compatible.

Je tenais l’outil parfait ! J’allais enfin pouvoir continuer d’apprendre à coder, mais… plus visuellement, plus « tactilement ». J’allais également au passage pouvoir apprendre de l’électronique (et réapprendre à aimer U = R x I et P = U x I ; de vieux souvenirs pour beaucoup d’entre nous, j’imagine…).

Une pierre deux coups…

Je partais d’à peu près zéro. Deux trois notions vagues d’électricité, quelques équations, mais sur le moment, je n’étais pas capable d’allumer une LED branchée en série avec une résistance… !

En allant plus loin, je me suis rendu compte que le « baptême de l’électronique », c’est de réussir à allumer une LED et de la faire clignoter. C’est un peu le printf(« Hello World »); des programmeurs…

Il n’a pas fallu beaucoup de temps pour que je mette plusieurs petites LED en série et en parallèle et que je m’amuse à faire clignoter tout ce beau monde.

Tiens, et si je fermais les yeux pendant que ça clignote, comme sur une Pandorastar ou une Lucia, je vois quoi ?

Même avec les toutes petites LED et un programme simplissime qui ne faisait que clignoter à fréquence stable, il n’a pas non plus fallu beaucoup de temps pour que j’estime probable, en progressant dans cette voie là, de finir par voir un certain parallèle, mais version cheap, avec les technologies lumineuses dont les modèles Pandorastar et Lucia Light sont les plus connus.

Mais je finis assez vite par me rendre compte de plusieurs choses :
1) Ce n’était pas si simple.
2) Ce n’était vraiment pas si simple.

Même si intellectuellement, j’arrivais à peu près (je croyais cela, en tout cas) à comprendre comment vaguement ces technologies fonctionnait, le reproduire à la main, sans plan, sans tuto, de manière empirique, sans faire de rétro-conception (sans avoir sous la main ces techno pour les désosser ; sans compter qu’au prix où elles sont, ce n’est pas forcément un projet rentable de mettre ses mains dedans pour bidouiller, sauf peut-être si on sait ce que l’on fait – ce qui n’était pas mon cas) et sans évidemment avoir de code ni de programme déjà fait à faire fonctionner, je bloquais à absolument toutes les étapes.

Je n’avais pas (et n’ai pas) du tout la prétention de reproduire ces technologies où d’arriver au niveau d’être capable de les reproduire, où de comparer mes prototypes d’amateur débutant à des produits finis et pensés par des pros de quelque manière. Je cherchais trois choses :

1) Comprendre.
2) Apprendre.
3) Progresser.

[Surtout : 4) M’amuser et faire mon robot porteur de café.]

Le reste, pour parler clairement, je m’en fichais éperdument. Et pour enfoncer le clou : je m’en fiche toujours éperdument. En fait, pour rigoler, j’ai juste décidé de pousser le concept du blinking program un peu plus loin, pour voir ce qu’on peut en tirer. Ça s’arrête là. Mais, il est vrai que pour un amateur de technologie et de physique comme je suis, on mord vite à l’hameçon…

Si je fais cet article, c’est que je sais qu’il y a comme moi qui sont intéressés par cela (si, si, j’en connais vraiment!), et comme, partant d’à peu près zéro, j’ai fini par réussir à piger deux trois trucs pourtant très simples et élémentaires, mais qui m’ont pris un million d’années à piger, et si je peux éventuellement faire gagner 5 minutes à quelqu’un, alors, c’est plutôt cool.

Pour toute la suite de l’article, je prendrais en ligne de mire la Pandorastar et autres modèles moins élaborés, pour une raison très simple :

Je suis à l’heure actuelle absolument incapable de comprendre comment marche les techno plus poussées comme la Lucia en profondeur. En effet, elle possède plusieurs caractéristiques qui paraissent anodines quand on ne se plonge pas dedans, mais qui nécessitent pourtant beaucoup de prises de tête et des personnes expertes, parmi elles, en vrac : la présence d’un ordinateur, avec un programme codé à la main qui pilote, par un module bluetooth intégré, un microcontroleur, voir un microordinateur type Raspberry Pi peut-être.

Sur le programme de contrôle de la Lucia, évidemment codé spécifiquement pour la lampe, en je ne sais quel langage, il y a par exemple un petit curseur de rien du tout qui sert à faire varier la luminosité globale de l’appareil.

Rien que ce petit détail nécessite au moins :
– un potentiomètre relié au circuit central (ou quelques astuces dans le code)
– commandé par un module bluetooth

Dis comme cela, on peut se dire « ah, mais ça a l’air tranquille en fait ».

Et bien… pas vraiment !

La Lucia ne fonctionne pas avec des petites LED de 20 mA, mais avec des High Power de plusieurs watts chacune, fonctionnant indépendamment (j’imagine), donc en parallèle (qui dit parallèle, dit fort ampérage…), et surtout un halogène central. Rien que ce fait est un casse-tête à alimenter (sans même réfléchir à poser un potentiomètre en amont !), car il faut alimenter tout cela avec un fort ampérage, sans griller le contrôleur, donc il faut des transistors, donc etc… Tout cela bien sûr, avec des besoins en voltage différents, donc il faut des abaisseurs, mais il faut qu’ils laissent passer beaucoup de courant malgré un faible voltage, donc il faut beaucoup de condensateurs electrolytiques, donc ça chauffe, donc il faut refroidir, donc il faut alimenter un ventilateur, mais ce dernier a aussi besoin d’un grand courant, et d’un voltage spécifique, mais il faut aussi l’asservir, donc sonder la température, etc… Et ce n’est que la partie matérielle…

Voici en vrac donc, pour des technos un peu moins complexes.

Selon le site officiel de Pandorastar par exemple :

  • Il y a 12 LED High Power. 9 Pure Light, donc froides (en couleur), 3 Warm Light, donc plus chaud.

> Il faut donc les alimenter avec une source différente du contrôleur. Une seule LED de ce type consomme, au moins, aux environs de 700mA par LED (pour une 3W par exemple). Une broche de sortie du contrôleur laisse grand max 20mA. Autre problème : ces LED ne prennent que du 3.3 V. Exit le 12V d’une alimentation, il faut un convertisseur, ou bien il faut ruser, cf plus loin.

  • The integrated controller facilitates extensive manipulation of strobe settings:
    Square and Sinusoidal stroboscopic waveform generation
    Frequency 0.1Hz to 200Hz
    • Duty 0% through 99% (applies only to square waveforms)
    Intensity 0% to 100%

> Donc il faut coder, empiriquement, un générateur de fréquences carrées et sinusoïdales qui varient entre 0,1 et 200 Hz. Ondes qui varient en amplitude, de 0 à 100%… le casse-tête démarre.

  • Il y a un écran LCD, et un bouton poussoir programmé pour switcher plusieurs programmes.

Donc tout cela est à programmer, et à brancher. Je laisse tomber pour l’instant dans mon cas. Autant limiter le casse-tête pour démarrer.

  • Il y a un système de refroidissement

> Il faut en effet refroidir les LED, et surtout les probables convertisseurs / multiples condensateurs qui doivent bien pouvoir nous chauffer en hiver pour passer d’un 12V en 3.3V avec autant d’ampères.

Au final, au vue de mon inexpertise complète, je décide pour commencer simple de construire un prototype qui doit répondre à ces caractéristiques :

Au niveau matériel

  • 9 x LED High Power 3W, 3.3V, 700mA branchées en parallèle, donc toutes indépendantes. Et une source stable de 3.3V.
  • Arduino Uno qui servira de contrôleur. N’ayant pas ouvert la bête, je ne sais ce qu’il y a dans une pando, mais probablement un équivalent, ou sûrement un Raspberry Pi ou équivalent. Pour le protéger, il faut des transistors sur chaque LED, qui joueront le rôle d’interrupteur régulé par le voltage / courant des pins de sorties de la carte. En gros, la LED devra être branchée sur l’alimentation 3.3V, mais en circuit ouvert, jusqu’à ce que la broche de sortie de l’Arduino envoie un petit courant qui ferme le circuit et donc allume la LED. Il sera alimenté par du 12V, qui passeront dans son régulateur interne pour qu’il prenne au final du 5V – 500mA dont il a besoin pour fonctionner.
  • Une alimentation qui me permette d’alimenter tout cela, en prenant compte des différences de voltages ! Un contrôleur arduino uno (une copie) ne coûte « que » dix euros mais il s’agit de ne pas « brûler » / endommager le pauvre contrôleur…

Au niveau logiciel

Il faut se creuser la tête pour trouver un code qui mathématiquement permette de générer des ondes, disons carrées pour commencer, c’est plus simple (car je me sers ici de la fonction digitalWrite et non de l’analogWrite, des sorties PMW etc…), et entre 0 et 200 Hz.

Avant de démarrer, voici quelques infos en vrac, que j’ai mis mille ans à comprendre (je suis lent), mais qui paraissent absolument évidentes après coup :

  • Un composant (un montage) drainera le courant (en ampère donc) dont il a besoin. Par exemple, un composant qui nécessite 12V – 1A ne prendra qu’un ampère sur l’alimentation, même si vous branchez une alimentation de 12V – 40A.
  • Les leds sont très sensibles au voltage. Il leur faut 3.3V (dans ce cas), avec une marge de manoeuvre très faible. Il faut donc veiller à leur donner un 3.3V le plus stable possible.
  • Si on monte tout en série, on aura besoin de moins de courant (il se partagera). Mais, en plus des inconvénients classiques d’un montage série, si une seule LED est défectueuse, tout le circuit est ouvert et ne fonctionnera donc plus.

Premier prototype

Matériel

Pour simplifier ce premier jet, je me suis servi de modules LED 3W, montés avec transistor et résistance adaptés. Chaque module LED a une puissance de 3W, possède une borne GND (pour ground, terre en anglais donc -), une borne + et une borne Source qui elle part vers la broche programmable de l’Arduino.

Mais comment alimenter, avec les moyens du bord, les 12V – 500mA de l’Arduino et sur la même prise, les 3.3V à fort ampérage des modules ?

Réponse de bidouilleur :

Je me suis servi d’une alimentation de vieux PC que j’ai reconverti pour l’occasion : j’ai +3.3V qui passe dans un morceau de breadboard, sur lequel est branché les bornes GND (-) et + des LED. Je me sers d’une sortie +12V que j’ai branché sur la broche Vin de l’Arduino, qui n’est autre que l’entrée du régulateur (le fameux régulateur, qui va transformer ce 12V en 5V et tirer les 500mA pour faire tourner la carte).

Code

J’étais initialement parti sur un code simple et lourd, mais « efficace » dont le début était :

int pinLed1, pinLed2, pinLed3, pinLed4, pinLed5, pinLed6, pinLed7, pinLed8, pinLed9, i;

void setup()

{

i=0;
pinLed1 = 2;
pinLed2 = 3;
pinLed3 = 4;
pinLed4 = 5;
pinLed5 = 6;
pinLed6 = 7;
pinLed7 = 8;
pinLed8 = 9;
pinLed9 = 10;

pinMode(pinLed1, OUTPUT);
pinMode(pinLed2, OUTPUT);
pinMode(pinLed3, OUTPUT);
pinMode(pinLed4, OUTPUT);
pinMode(pinLed5, OUTPUT);
pinMode(pinLed6, OUTPUT);
pinMode(pinLed7, OUTPUT);
pinMode(pinLed8, OUTPUT);
pinMode(pinLed9, OUTPUT);

digitalWrite(pinLed1, LOW);
digitalWrite(pinLed2, LOW);
digitalWrite(pinLed3, LOW);
digitalWrite(pinLed4, LOW);
digitalWrite(pinLed5, LOW);
digitalWrite(pinLed6, LOW);
digitalWrite(pinLed7, LOW);
digitalWrite(pinLed8, LOW);
digitalWrite(pinLed9, LOW);

}

void loop()

{

for (; i < 1; i++)

{

digitalWrite(pinLed1, HIGH);
digitalWrite(pinLed2, HIGH);
digitalWrite(pinLed3, HIGH);
digitalWrite(pinLed4, HIGH);
digitalWrite(pinLed5, HIGH);
digitalWrite(pinLed6, HIGH);
digitalWrite(pinLed7, HIGH);
digitalWrite(pinLed8, HIGH);
digitalWrite(pinLed9, HIGH);
delay(100);

digitalWrite(pinLed1, LOW);
digitalWrite(pinLed2, LOW);
digitalWrite(pinLed3, LOW);
digitalWrite(pinLed4, LOW);
digitalWrite(pinLed5, LOW);
digitalWrite(pinLed6, LOW);
digitalWrite(pinLed7, LOW);
digitalWrite(pinLed8, LOW);
digitalWrite(pinLed9, LOW);
delay(100);
}

}

Etc. C’est brut, lourd, pas optimisé, mais ça fonctionne bien, les boucles for (ce sont des boucles conditionnelles) permettent d’y voir assez clair, et ça permet de tester à peu près toutes les combinaisons d’allumage, avec en tête que c’est tout ou rien, il n’y a pas de fade, pas de LED à moitié allumée (c’est la fonction digitalWrite qui entraine cela).

Inconvénients

  • ll faut 800 lignes de codes pour un programme de 3 minutes (je n’exagère presque pas).
  • Il faut entrer « à la main » le delay(), calculé en millisecondes (10^-3 secondes) – on a de plus aucune idée de la fréquence – à chaque fois, sur chaque boucle.

Après beaucoup de prises de têtes mentales, j’ai donc modifié mon code. Voici un premier programme de cette nouvelle version de code, qui sert à tester différentes fréquences :

int i = 0;

const int pinLed1 = 2, pinLed2 = 3, pinLed3 = 4, pinLed4 = 5, pinLed5 = 6, pinLed6 = 7, pinLed7 = 8, pinLed8 = 9, pinLed9 = 10;

float fq, frequence;

void setup()

{

pinMode(pinLed1, OUTPUT);
pinMode(pinLed2, OUTPUT);
pinMode(pinLed3, OUTPUT);
pinMode(pinLed4, OUTPUT);
pinMode(pinLed5, OUTPUT);
pinMode(pinLed6, OUTPUT);
pinMode(pinLed7, OUTPUT);
pinMode(pinLed8, OUTPUT);
pinMode(pinLed9, OUTPUT);

digitalWrite(pinLed1, LOW);
digitalWrite(pinLed2, LOW);
digitalWrite(pinLed3, LOW);
digitalWrite(pinLed4, LOW);
digitalWrite(pinLed5, LOW);
digitalWrite(pinLed6, LOW);
digitalWrite(pinLed7, LOW);
digitalWrite(pinLed8, LOW);
digitalWrite(pinLed9, LOW);

}

void swg(float frequence)

{

float temps;

temps = (1/frequence)*1000;

digitalWrite(pinLed1, HIGH);
digitalWrite(pinLed2, HIGH);
digitalWrite(pinLed3, HIGH);
digitalWrite(pinLed4, HIGH);
digitalWrite(pinLed5, HIGH);
digitalWrite(pinLed6, HIGH);
digitalWrite(pinLed7, HIGH);
digitalWrite(pinLed8, HIGH);
digitalWrite(pinLed9, HIGH);
delay(temps);

digitalWrite(pinLed1, LOW);
digitalWrite(pinLed2, LOW);
digitalWrite(pinLed3, LOW);
digitalWrite(pinLed4, LOW);
digitalWrite(pinLed5, LOW);
digitalWrite(pinLed6, LOW);
digitalWrite(pinLed7, LOW);
digitalWrite(pinLed8, LOW);
digitalWrite(pinLed9, LOW);
delay(temps);

}

void loop()

{

fq = 5;

for (; i < 500 ; i++)

{
swg(fq);
fq = fq + 0.2;
}

for (; i < 1000 ; i++)

{
swg(41);
}

for (; i < 1100 ; i++)

{
swg(31);
}

for (; i < 1200 ; i++)

{
swg(21);
}

for (; i < 1300 ; i++)

{
swg(17);
}

for (; i < 1400 ; i++)

{
swg(25);
}

for (; i < 1500 ; i++)

{
swg(30);
}

for (; i < 1600 ; i++)

{
swg(35);
}

for (; i < 1700 ; i++)

{
swg(40);
}

for (; i < 1800 ; i++)

{
swg(45);
}

for (; i < 1900 ; i++)

{
swg(50);
}

for (; i < 2000 ; i++)

{
swg(55);

}

for (; i < 2500 ; i++)

{
swg(fq);
fq = fq – 0.2;
}

for (; i < 2600 ; i++)

{
swg(33);
}

for (; i < 2700 ; i++)

{
swg(34);
}

for (; i < 2800 ; i++)

{
swg(26);
}

for (; i < 2900 ; i++)

{
swg(28);
}

for (; i < 3000 ; i++)

{
swg(29);
}

for (; i < 3100 ; i++)

{
swg(39);
}

for (; i < 3200 ; i++)

{
swg(42);
}

for (; i < 3300 ; i++)

{
swg(44);
}

for (; i < 3400 ; i++)

{
swg(47);
}

for (; i < 3500 ; i++)

{
swg(53);
}

for (; i < 3600 ; i++)

{
swg(60);
}

for (; i < 3700 ; i++)

{
swg(65);
}

for (; i < 3800 ; i++)

{
swg(70);
}

for (; i < 3900 ; i++)

{
swg(75);
}

for (; i < 4000 ; i++)

{
swg(80);
}
}

Détails du code

J’ai codé une fonction qui calcule la fréquence. Ce faisant, je n’ai qu’à la rentrer telle quelle dans mes boucles, et rien d’autres. Ainsi, je n’ai qu’a appeler cette fonction dans la boucle loop. En argument, elle prendra une simple fréquence en Hz. Je l’ai appelé ici swg pour square wave generator (ce qu’on cherchait donc à faire).

swg(1) est, par exemple, calculé ainsi :

temps = (1/1) x 1000 = 1000 milliseconde, donc 1 seconde. Les LEDs s’allument toutes en même temps, puis on attend 1 seconde, on éteins, on attend 1 seconde à nouveau. On a donc… une onde carrée !

On peut changer « l’ordre de grandeur » de la fréquence ainsi, si on définit la valeur de la variable frequence a par exemple 1 :

temps = (1/1) x 1000 x 0,5 = 1 flash par seconde > le cycle complet dure une seconde.

temps = (1/1) x 1000 x 1 = 1 flash par 2 secondes, puisque le delay sera donc d’une seconde après chaque opération logique (allume – 1 seconde pause – éteins – 1 seconde pause).

etc…

Avantages

  • plus visuel
  • plus simple
  • plus performant
  • on peut coder des montées / descentes très souples avec des boucles for (ou des while, auquel cas il faudra bien penser à incrémenter le compteur – la variable i -, avec un simple i++; au risque de ne pas comprendre pourquoi diable votre programme ne fonctionne pas – cela cause en effet une boucle infinie, car la condition est toujours vraie ! On peut aussi bien sûr se servir des if / else if / else même, si on est motivé)

En effet, avec ce genre de portions de code par exemple, en appelant un float que j’ai appelé ici fq, on peut définir une fréquence de départ, et la faire augmenter progressivement (ici, à chaque tour, la fréquence prend 0,2 de plus). Cela donne une grande marge pour assouplir des courbes… !

fq = 5;

for (; i < 500 ; i++)

{
swg(fq);
fq = fq + 0.2;
}

Inconvénients
L’onde est mathématiquement « parfaite » (peut être moins parfaite, en pratique, en sortie) ; donc les LED s’allument à l’unisson. Ce n’est pas spécialement un problème, mais si on souhaite désynchroniser légèrement les LED, il faut s’y prendre autrement. Par exemple, on peut écrire une fonction par LED. Le montage le permet.

Une vidéo de ce que mon premier prototype, pas du tout présentable (et encore moins transportable), donne de loin sur le programme ci-dessus. A noter que le programme ci-dessus n’est qu’un programme de test, il enchaine simplement des fréquences.

Important / A prendre en compte

– cette vidéo montre des LED qui flashent à une fréquence type stroboscope, s’il-vous-plait, évitez de la regarder si vous êtes sujet à l’épilepsie. Évidemment, la luminosité de la vidéo n’est pas non plus hallucinante, mais, c’est toujours mieux de prévenir. Dans tous les cas, ça se visionne les yeux fermés quand on est devant la lampe, donc cette vidéo est juste là pour illustrer, il vaut mieux la regarder en baissant la luminosité de son écran, et dans une pièce bien éclairée.

– ce que l’on voit est vraiment très éloigné de ce qu’on voit en vrai. On peut se dire en voyant la vidéo : « Ah, tout ça pour ça ! ». Oui, mais non. En réalité, par exemple, on ne peut même pas fixer les LED sans devenir à moitié aveugle (j’exagère bien entendu, ça reste du petit wattage, mais tout de même, il vaut mieux éviter…). Impossible pour  une caméra de téléphone (60 fps max) de traduire fidèlement, visuellement, le programme. Donc cette vidéo ne sert un peu à rien finalement, sauf à illustrer l’article avec une image qui bouge.

 

Et bien sûr, il va sans dire, ça ne m’amuserait pas autant, et je n’aurais pas rédigé un tel article (ni poursuivi dans ces essais), si le résultat n’était pas a minima intéressant… !

Et il l’est déjà, en tout cas, à mes yeux.

Yeux fermés, au calme, je suis obligé de reconnaître que c’est assez étonnant, même en l’état.

En fouillant un peu pour chercher de la documentation sur les LED et sur l’Arduino, je suis tombé sur pas mal de posts finalement qui se posaient exactement les mêmes questions que moi, en cherchant à faire ce genre de montages. Parfois même explicitement. J’ai vu par exemple ce genre de messages : « je cherche à faire un appareil de ‘neurostimulation’ avec des fréquences modulables entre 0 Hz et 200 Hz… comment gérer le code ? etc ». Assez amusant de voir qu’on est finalement assez nombreux à s’être penché dessus par curiosité, ou pour d’autres raisons.

Je pense l’avoir déjà mentionné, mais il faut bien sûr garder en tête, mais de toute façon ça crève normalement bien les yeux (pun intended) quand on voit le montage, que ce n’est qu’un Arduino, quelques LED, un montage amateur, quelques lignes de code pas (encore ?) optimisées, et de la bidouille avec 20 euros de matériel…  On reste bien évidemment très loin d’une vraie machine, même d’entrée de gamme, sur de nombreux aspects.

Je m’arrête là pour cet épisode, de toute façon, je sens que tout le monde est déjà parti !

N’hésitez pas, si vous souhaitez plus de détails techniques et/ou s’il y a des erreurs etc… Si ce n’est pas trop compliqué, je pourrais peut-être répondre.

Publicités

3 réflexions sur “Hors-série. Des LED, du code et des images.

  1. Salut Pierre, oui je suis allé au bout !
    j’espère que tout roule pour toi, j’ai repensé en lisant ton post à quelques échanges que j’avais eu par messenger suite à la présentation de la LUCIA lors de notre rencontre à BALMA en….2015, avec Oli Vier, un gars de Clermont Ferrand qui cherchait à bricoler lui même une lumière hypnagogique….

    je viens de lui poster le lien vers ton blog, et voici le lien vers le forum où il échange avec d’autres sur ces sujets, et je pense qu’en explorant les 9 pages d’échanges tu trouveras peut-être des éléments qui peuvent « t’éclairer » :

    http://www.chercheursduvrai.tk/forum/index.php?act=Search&CODE=show&searchid=ac7fd06d16ce2ccf94df9a0e8317a0e5&search_in=posts&result_type=posts&highlite=hypnagogique

    son FB est OliVier avec un dessin de dragon chinois comme photo de profil, Clermont Ferrand. mais sur ce site son pseudo est Vilo176
    je ne sais pas si cela servira à quelque chose….On ne sait jamais, parfois 1+1 = 3 …..

    En tout cas, j’espère qu’on aura un jour l’occasion de se croiser à nouveau ! j’aime à penser que oui….
    le meilleur pour toi Pierre !
    A très bientôt
    Christophe.

    Aimé par 1 personne

    1. Salut Christophe!

      J’espère également qu’on aura l’occasion de se croiser à nouveau ! Deux années déjà depuis l’évènement de Balma!

      Haha, merci d’avoir été jusqu’au bout ! Et merci pour le lien, je n’ai pas encore pu tout parcourir, mais ce que j’en ai vu me parait vraiment très intéressant et riche d’informations!

      Le meilleur pour toi Christophe!

      J'aime

  2. juste passionnante ta recherche et le résultat est plutot bon!!je fait la meme chose en pârallele mais j’essaie de develloper un petite interface qui me permettra de selectionner et de faire varier les frequences des leds soit indépendament soit par grp

    Aimé par 1 personne

Laisser un commentaire

Entrez vos coordonnées ci-dessous ou cliquez sur une icône pour vous connecter:

Logo WordPress.com

Vous commentez à l'aide de votre compte WordPress.com. Déconnexion /  Changer )

Photo Google+

Vous commentez à l'aide de votre compte Google+. Déconnexion /  Changer )

Image Twitter

Vous commentez à l'aide de votre compte Twitter. Déconnexion /  Changer )

Photo Facebook

Vous commentez à l'aide de votre compte Facebook. Déconnexion /  Changer )

w

Connexion à %s