Messages

Ah ben tout va bien alors  ;)

En tout cas, bravo pour ce projet :)

Salut,

Pour les connecteurs, ceci pourrait faire l'affaire? C'est du 300v 15A. : ebay

Salut,

Au premier abord, ça à  l'air pas mal du tout mais en fin de compte je sais pas si ça peut etre adapté à  des circuits complexes. De plus ce procédé ne fixe pas les composants sur la plaquette, dès lors il faudra les coller là  où la soudure fait le contact et la fixation en un coup....

Peut etre en remplacement des breadbords, pour des essais rapides.... Autre chose sur la video on dirait du papier ou du carton (bravo en cas de surchauffe ^^), qu'en est-il de la tenue sur support lisse?

Bref il y a de l'idée, mais ça ne me convainc pas du tout :)

Actuellement 2 solutions :

Le perchlo ou la cnc, l'un est casse-bonbons, l'autre est cher, les deux sont lents. Pourtant le problème est simple en fin de compte ^^ des idées? :)

Il reste les plaques prétrouées (avec des plots en cuivre, seuls ou par groupe de 2 ou trois ou autres....) qui sont tres pratique pour le prototypage rapide.

Merci pour l'info en tout cas :)

ne pas oublier....

https://www.youtube.com/watch?v=sqBLWoWT5Is

;D

Salut GTR,

Regarde ce schéma avec 1 led, V1 = 5V :



On considère que cette led aura une chute de tension en mode passant à  ses bornes de 2.2V. On a donc aux bornes de la résistance de 1K une tension de 2.8V.

Pas oublier qu'une LED n'est pas une résistance, c'est une diode et donc, la chute de tension à  ses bornes ne varie pas (en théorie) en fonction du courant qui la traverse

On a donc dans la R un courant de 2.8mA (2.8V/1000Ohms).

Donc dans la led on a aussi un courant de 2.8mA. Normalement c'est trop peu pour allumer la led correctement, mais pour l'exemple on va dire que c'est OK, la led s'allume correctement.

Maintenant on met une LED en // avec la 1ere :



Si on mesure la tension aux bornes de la résistance, on a de nouveau 2.8V, aux bornes de chaque LED, on a bien 2.2V. Mais on voit que les LED éclairent 2X moins fort. Pourquoi? et bien aux bornes de la R on a toujours 2.8V donc le courant qui circule dans la résistance est toujours de 2.8mA mais par contre dans les LED c'est une autre histoire. On n'a plus les 2.8mA du montage avec une seule LED, mais 1.4mA par LED. (2.8mA/2 voir la loi des noeud et des mailles ;) )

Donc il ya 2 X moins de courant qui circule dans chaque led et donc celle-ci éclairent mois fort.

La puissance dissipée par la R dans les 2 cas est 2.8V * 0.0028A = 7,8mW

Ta solution est d'augmenter le voltage. Voyons un peu...

Passons à  20V, comme la chute de tension aux bornes d'une diode est constante, on a donc 17.8V aux bornes de la R, donc 17.8mA dans la R. Le courant dans chaque led sera de 8.9 mA elle éclaireront donc bien plus fort (rappel : on considère qu'elles fonctionnent correctement à  2.8mA). La puissance dissipée par la R est montée à  0.316W. (17.8V*0.0178A)

Alors tu comprends que plus tu mets de LED, moins elles éclaireront. Plus tu augmente la tension, plus tu augmentes le courant dans la R et donc le courant dans les LED. Mais tu vois les limites de cette solution :

1. Tu dois augmenter la tension d'autant plus haut que tu ajoutes des leds
2. Tu dois augmenter la puissance de la R en fonction de l'augmentation de la tension et donc en fonction du nombre de leds.

Ce qui peut être problématique avec un grand nombre de leds :)

Tu peux aussi diminuer la valeur de la R pour augmenter le courant qui passe dedans sans pour autant augmenter la tension mais alors la puissance de la R augmentera en fonction.

Toujours le meme truc en fait : I=U/R et P=U*I -> tu ne peux alterer une variable sans influencer les autres ;)

Alors, quel intérêt d'allumer 15 LED avec 40v et une résistance de 1k qui chauffe alors que je peux allumer le tout sans résistance avec seulement 2v?

Ben déjà  avec une alimentation de lab, qui limite le courant de sortie, c'est ok, mais n'essaye pas d'allumer une led sans résistances avec une pile par exemple :) le courant augmenterais à  l'infini et ta led cramera en moins de temps qu'il ne faut pour l'écrire ^^ donc les led sans résistances, faut éviter. Pour l'intéret de faire ça, ben y'en a pas vraiment, le plus simple est d'avoir une R par led  ;)

Voilà  j'espère que ça a éclairé un peu ta lanterne :)

Voilà  un petit schéma réalisé avec fritzing (premiere fois que j'utilise ce logiciel ;) ). Vous devriez y voir plus clair.



Je n'ai mis que 6 Leds, on voit que la connexion data out de la led 3 entre dans le data in de la led 6. Dans le code que j'utilise il y a une "option" qui permet de définir si les rangées impaires sont dans l'ordre inverse ou pas, ça permet de faciliter la tâche lors de la soudure des rangées de leds en question. On aurait très bien pu passer directement du data out led 3 dans data in led 4, il suffit de changer la variable dans le code :)

voici le commentaire de la définition de la variable en question dans le code (dans l'exemple "XYMatrix" fourni avec la librairie Fastled) le principe y est illustré :

Code Sélectionner Étendre

// Param for different pixel layouts
const bool    kMatrixSerpentineLayout = true;
// Set 'kMatrixSerpentineLayout' to false if your pixels are
// laid out all running the same way, like this:
//
//     0 >  1 >  2 >  3 >  4
//                         |
//     .----<----<----<----'
//     |
//     5 >  6 >  7 >  8 >  9
//                         |
//     .----<----<----<----'
//     |
//    10 > 11 > 12 > 13 > 14
//                         |
//     .----<----<----<----'
//     |
//    15 > 16 > 17 > 18 > 19
//
// Set 'kMatrixSerpentineLayout' to true if your pixels are
// laid out back-and-forth, like this:
//
//     0 >  1 >  2 >  3 >  4
//                         |
//                         |
//     9 <  8 <  7 <  6 <  5
//     |
//     |
//    10 > 11 > 12 > 13 > 14
//                        |
//                        |
//    19 < 18 < 17 < 16 < 15
//
// Bonus vocabulary word: anything that goes one way
// in one row, and then backwards in the next row, and so on
// is call "boustrophedon", meaning "as the ox plows."


L'alim externe est représentée par les piles, les GND de l'arduino et de l'alim externe sont en commun, la R de 470 Ohms est optionnelle mais peut servir de protection en cas de court-circuit dans le réseau de leds. Toutes les Vdd des leds doivent être au +5v et toutes les Vss à  la masse, je ne les ai pas toutes connectées dans le schéma pour que ça reste clair ;)

Il est plus facile d'utiliser des bandes (strips) que l'on peut découper, ça evite de souder chaque led l'une apres l'autre. :)

Le seul truc "décevant" c'est qu'il n'y a pratiquement pas d'électronique à  réaliser autour de ce leds ^^ tout est déjà  fait  :D Mais ça donne un tas d'idées sympas :)

Je vous mets le lien pour Fritzing :) : http://fritzing.org/download/

Salut,

J'adore les LEDs ^^ Je me suis procuré une cinquantaine de led rgb classiques dans l'idée de faire un petit jeu de lumière coloré. Le soucis c'est que je me suis rendu compte que ça peut etre un projet tres fastidieux, en effet il faut pour chaque led, gérer 3 PWM pilotées par des sequences binaires elles même produites par un microcontroleur.... avec plein de convertisseurs série paralleles... bref une usine a gaz, ne fut-ce que pour 8 leds....

En cherchant je suis tombé sur un nouveau type de leds rgb, les leds adressables :D

4 pins :

- 5V
- Data in
- Data Out
- GND

pas tres cher, moins de 15 euros pour 100 chez les chinois, on en trouve aussi sous forme de bandes (strips) ;)

Il suffit de les souder en série (data out dans data in de la suivante), et on peut en utiliser autant que l'on veut :) on peut aussi en faire des tableaux (un petit exemple par GreatScott : https://www.youtube.com/watch?v=D_QBlFIQk-o )

La datasheet des ws2812b : https://cdn-shop.adafruit.com/datasheets/WS2812B.pdf

On y voit que le traitement des données est assez particulier, l'état bas et l'état haut étant définit par le duty cycle du signal. 0.4µs pour l'etat bas et 0.8µs pour l'etat haut.

Pour piloter celà , un arduino est idéal, il existe 2 librairies qui fonctionnent bien : Neopixel et Fastled. La fréquence du signal de sortie des ports de l'arduino tournent autour de 500 Hz, c'est trop peu pour faire fonctionner les leds donc ces librairies vont parametrer l'AtMega de l'arduino de sorte qu'il puisse fournir ces fréquences plus élevées.

J'ai donc réalisé un petit tableau de 3X3 leds et fais des essais, ça marche impeccable, il suffit d'une résistance de 470 Ohms entre l'arduino et la première led et le tour est joué :) Il convient d'alimenter les leds avec une alim qui peut délivrer du courant avec aisance, on peut vite se retrouver avec 1 ou 2 Ampères (environ 60mA max par led, 100 led ça fait 6 ampères ). Apres ce n'est plus que de la programmation d'effets en tout genre :)






Le microcontrolleur : un arduino entier pour ça c'est un peu exagéré, pour les essais c'est ok mais pour un projet fini, on peut se contenter de quelque chose de plus petit vu que l'on a besoin que d'une sortie. J'ai donc choisi un AtTiny monté sur pcb, il y a une prise USB mais je n'ai pas réussi à  le faire fonctionner correctement avec le pc, j'ai donc utilisé un arduino pour le programmer et ça a fonctionné, le petit AtTiny à  su faire fonctionner le petit tableau de led sans aucun soucis. Je suppose que de telles librairies doivent exister pour les PICs :)

A savoir : j'ai choppé sur banggood une copie de l'arduino UNO pour moins de 4 euros (marque "geekcreit", celui sur les photos), à  part un petit driver à  installer il fonctionne identiquement à  l'arduino d'origine.

Les applications sont nombreuses : jeux de lumieres, affichage coloré, lumière d'ambiance pour salon.... et surtout plein de fun ^^ On peut aussi piloter le réseau de led directement par le pc via une interface USB-Série (je crois), avec le logiciel gratuit GLEDIATOR ;)

Quelques liens :

Led leds adressables et l'arduino : http://www.tweaking4all.com/hardware/arduino/arduino-ws2812-led/
La librairie neopixel : https://learn.adafruit.com/adafruit-neopixel-uberguide/arduino-library-installation
La librairie Fastled : http://fastled.io/
Programmer un attiny avec un arduino : http://www.instructables.com/id/Program-an-ATtiny-with-Arduino/step6/Program-the-ATtiny/
Le pcb AtTiny que j'ai utilisé : http://www.banggood.com/ATTINY85-Mini-Usb-MCU-Development-Board-For-Arduino-p-971122.html
L'arduino UNO "geekcreit" : http://www.banggood.com/UNO-R3-ATmega328P-Development-Board-For-Arduino-No-Cable-p-964163.html
Glediator : http://solderlab.de/index.php/downloads/category/4-glediator
Les ws2812 sous divers formats : http://www.banggood.com/search/ws2812.html