Comprendre le multiplexeur PWM TLC5940

TLC5940 pins

A quoi sert le composant TLC5940 ?

Le composant TLC5940 est un multiplexeur PWM (Pulse Width Modulation) qui peut gérer jusqu’à 16 canaux PWM. Ainsi avec seulement 3 pins de votre Arduino vous allez pouvoir utiliser jusqu’à 16 canaux PWM.

Tout comme le composant Shift Register 74HC595, le circuit intégré TLC5940 peut être connecté en cascade, ce qui permet d’étendre considérablement le nombre de canaux PWM utilisables.

Cela va donc être parfaitement adapté à mon projet EasyLight pour multiplexer des leds RGB.

Comment utiliser le composant TLC5940 avec Arduino ?

Il existe une bibliothèque nommée TLC5940Arduino qui permet de contrôler simplement un ou plusieurs composants TLC5940 directement avec Arduino.

La librairie TLC5940Arduino peut être téléchargée sur ce site.

 Comment fonctionne le composant TLC5940 ?

Le plus simple pour comprendre le fonctionnement du composant TLC5940 est de lire la fiche technique TLC5940.

Voici le schéma du composant TLC5940:

TLC5940 pins

 

Comme on peut le voir, on a bien nos 16 sorties PWM (de OUT0 à OUT15). Voici le détail des autres pins:

  • XERR: open collector, wire or-ed output that lets you know a TLC5940 is over heated or has a burnt out LED. We can ignore this as it will always be on unless you have current using elements on all of the outputs.
  • SOUT: serial data out from the TLC5940. Unless you wish to try to read the error bits you do not need this to come to the Arduino. If you have more than one TLC5940 this is the line you daisy chain to the SIN of the next package.
  • DCPRG: this selects the source of the current limiter register, you could just tie it high.
  • XLAT: you will need this to latch data after shifting.
  • SCLK: you will need this to shift data.
  • SIN: serial in to TLC5940, this is the output from the Arduino.
  • VPRG: you need this to select either the current limit registers or the duty cycle registers for writing.
  • GSCLK: this is the clock for the PWM. We will reprogram TIMER2 in the Arduino to make this signal. That will cost us the native PWM on that timer, digital 11 on a mega8, 11 and 3 on a mega168.
  • BLANK: this marks the end of a PWM cycle in addition to blanking the output. We will reprogram TIMER1 to generate this signal. That will cost us the native PWMs on digital 9 and digital 10. (Tie a real, physical pull-up resistor on this line to keep things blanked while your Arduino boots. Depending on your hardware, it is possible that the TLC5940 would come up in a configuration that would dissipate too much power.)

 La broche 20 du TLC5940: IREF

Sur la broche numérotée 20 du composant TLC5940, il faut brancher une résistance. Pour trouver la valeur de la résistance à utiliser, il suffit d’appliquer la formule suivante:

valeur de la résistance = 39.06 / intensité de la LED

Ainsi dans le cas où l’intensité de vos leds est de 30mA, vous devrez utiliser une résistance de 1302 ohms. On utilisera donc une résistance de 2K ohms.

Si vous utilisez des leds avec des intensités différentes, prenez l’intensité la plus faible comme base.

Comment brancher le composant TLC5940?

Voici le schéma électronique de branchement du composant TLC5940:

tlc5940 schema electronique

Et le schéma de connection e ntre un Arduino et un composant TLC5940:

tlc5940 schema arduino

Comment brancher le composant TLC5940 en cascade ?

Un des intérêts à utiliser le multiplexeur TLC5940 est qu’on peut chainer plusieurs composants ensemble afin d’augmenter de nombre de canaux PWM. On dit alors qu’on met les composants TLC5940 en cascade.

Voici le schéma électronique:

tlc5940 schema electronique cascade

Et voici le schéma de connection entre plusieurs multiplexeur TLC5940 en cascade et un Arduino:

tlc5940 schema arduino cascade

Lorsque l’on utilise les multiplexeurs TLC5940 en cascade, il faut penser à modifier le fichier tlc_config.h de la librairie TLC5940Arduino:

Changez la ligne #define NUM_TLCS 1 pour #define NUM_TLCS n (ou n est le nombre de TLC5940 que vous avez chainé).

Conclusion sur le multiplexeur TLC5940

Les multiplexeurs TLC5940 sont des composants qui ne coûtent pas cher et qui permettent d’augmenter le nombre de canaux PWM de votre Arduino.

Ils sont relativement pratique si vous devez utiliser des leds RGB par exemple. Le schéma suivant illustre parfaitement leur utilisation:

tlc5940 schema led rgb

Attention toutefois lorsque vous utilisez des leds RGB avec le multiplexeur TLC5940 à verifier que vos leds soient à anode commune:

led rgb common anode

51 Responses to Comprendre le multiplexeur PWM TLC5940

  1. Guillaume says:

    Bonjour,
    juste pour dire à l’auteur de corriger PWN vers PWM.
    M comme Modulation.
    Merci ;)
    Guillaume

  2. Damien says:

    Bonjour
    excellent, ou peut on trouver le composant en cms ?

  3. Mathieu says:

    Salut, j’ai moi aussi un projet de matrice rgb et du coup je m’interroge.
    Je commanderais le composant avec la arduino mais l’alimenterais avec une alim externe (une alim de pc 5V/22A) pour avoir assez d’intensité nécessaire au 64 x 3 leds (disons 5 ou 6 ampères en tout). Ca va marcher ?

    Ou alors doit-je vraiment mettre un transistor par led… ?

    • jhd says:

      Normalement cela va marcher mais je suis en train de tester pour mon projet avec 50 leds et les TLC5940 chauffe enormement et lorsqu’ils chauffent cela fait n’importe quoi…

  4. Ironic says:

    Bonjour.

    Je souhaite utiliser 2 TLC5940 en cascade pour contrôler :
    - 8 petits rubans de LED RGB en 12V (6 LED SMD 5050 en parallele par ruban).

    8 groupes de LED * 3 couleurs = 24 PWM (l’anode entant directement relié au +12V).

    Le problème c’est que ces rubans de LED ont déjà les résistances de LED pour etre utilisé directement en 12V. On ne peut pas les retirer.

    Peut on utiliser les sorties PWM en +12V (40mA-12V par sortie).
    Que faut il mettre a la place de la résistance IREF (une 1 ohm ?).
    J’ai cru voir 17V max sur les PWM.
    En 12V je peux “tirer” combien de mA par PWM ?

    Merci pour les éventuelles infos.
    Je vais reconsulter le datasheet.
    Cordialement.

    • jhd says:

      Je pense qu’il faut quand même mettre une résistance. Essaye en les mettants et si tes leds ne s’allume pas assez alors retire les :)

  5. Ironic says:

    Le souci c’est que j’ai pas encore commandé les 5940, je voulais être sur de pouvoir le faire avant d’acheter le matos.
    Je cherche un peu partout un montage similaire mais je trouve que des utilisations en 5v du 5940.
    Après je peux mettre 1 transistor par sortie PWM mais ca m’en fait 24 !!
    30 même car maintenant je veux gérer 10 lignes RVB.

    J’ai déjà fait le montage avec que des transistors npn et pnp en multiplexant avec un arduino. Ça fonctionne mais je voudrais remplacer ces transistors.
    J’aurais pu utiliser 2 ULN2803 à la place des transistors mais avoir 30 sorties PWM c’est plus confortable qu’une bidouille logiciel de multiplexage avec 3 PWM.

    Il me faut des PWM en 12v et seulement 40mA (voir un peu plus), c’est pas la mort ;)
    ….
    Bon j’ai commandé le matos, on verra bien.
    Je continue quand même a chercher l’info.

    • jhd says:

      Pour le 12V il y a aucun probleme par contre comme je disais j’ai un souci les tlc5940 chauffe et devienne fou et je ne sais pas comment éviter qu’ils chauffent :/

  6. Ironic says:

    J’ai lu pas mal de truc et c’est de plus en plus confus.

    Beaucoup de personnes ont des problèmes de chauffe.
    Soit on tire trop par sortie, surtout si elles sont toutes utilisées en même temps.
    Soit il faut mettre des dissipateurs sur le 5940 mais ca c’est dommage.
    Soit il faut utiliser 1 transistor par sortie mais ca c’est encore pire.

    En trouvant les specs de ce C.I. je croyais avoir trouvé le Graal mais c’est pas le cas. C’est une bébête qu’il faut apprendre à maitriser.

  7. Ironic says:

    “Normalement cela va marcher mais je suis en train de tester pour mon projet avec 50 leds et les TLC5940 chauffe enormement et lorsqu’ils chauffent cela fait n’importe quoi…
    Reply”

    Comment t’as cablé tes LED ?
    50 led sur 50 sorties pwm ?
    Si t’as mis 1 LED par sortie et que ca chauffe je comprend pas.

    J’ai lu quelque part que quand le 5940 recevait moins de 0.6v sur une sortie, il comprenait que la LED etait HS et compensait en donnait plus de jus.
    Tu as des LED sur chaque sortie ?

    Bon j’y connais pas grand chose sur le 5940 mais ca fait 3h que je matte des fofos anglais et j’ai la tête qui va exploser.

    Je pense que je vais suivre les conseils de Texas Instruments et mettre un MOSFET N ou un transistor NPN par sortie. Ça va grandement augmenter la taille du PCB mais au moins ca devrait pas chauffer.

  8. Ironic says:

    T’as essayé d’alimenter le 5940 en 3.3 volts ?
    J’ai lu que ca chauffait beaucoup moins comme ca.
    Mais t’as plus 120mA par sortie mais 60mA.
    une LED RGB = environ 20 mA a 30mA soit 7mA a 10mA par couleur.
    4 couleurs par sortie = 28mA a 40mA donc ca passe en 3.3 volts.

    T’as essayé d’alimenter ton 5940 avec du 5 volts autre que la sortie de l’Arduino ?

    • jhd says:

      J’alimente avec le 5 volts d’une alimentation de pc.

      J’ai pas essayé avec du 3.3V. Je crois que mes leds tire en tout 60mA, vu que j’en ai 4 par pattes ca fait 4*60 non ?

  9. Ironic says:

    Bon, j’ai reçu mes 5940 et aujourd’hui c’est journée expérience.

    Une LED RGB consomme 20mA ou 30mA si les 3 couleurs sont utilisées simultanément.

    J’ai mesuré a l’ampèremètre une LED SMD 5050 RGB sensé faire 20mA. Et bien c’est 20mA/3 (si on met les résistances adaptées) pour chaque couleur. J’ai pas de LED RGB traditionnelle donc jeux peux pas mesurer.

    Si je prends 4 LED RGB j’utilise 3 sortie PWM et 1 commun +5V. (les 4 broches de la LED).
    Les 4 rouges sont en parallèle ainsi que les 4 verts et 4 bleus. (Et les 4 communs).
    Avec mes SMD RGB ca fait 4*6mA par couleur soit 24mA par sortie.

    Je suis pas plus compétant que toi, je t’explique juste mes découvertes sur les LED RGB.

    C’est pas 4*60mA (en supposant que tu ai raison sur la consommation).
    Si tes LED consomment 60mA c’est donc 20mA par couleur.
    Ca fait beaucoup, mes SMD 5050 a 3*6mA éclairent plus qu’une LED RGB standard. [LED 5mm 2V:(rouge) / 3.2V:(vert) / (bleu):3.2V].

    Donc 20mA*4LED = 80mA par patte du 5940 (donc par couleur).
    Si t’as un ampèremètre ca serait intéressant de faire des relevé. La résistance du 5940 est peut être a ajuster pour baiser la consommation des LED.

    Bon j’espère ne pas avoir dis de conneries, en tout cas c’est ce que j’ai constaté chez moi.
    Je parts expérimenter tout ca…

  10. Ironic says:

    Bon… perplexe…v
    J’utilise un Clone Arduino nano Atmega168 qui je pense est compatible pin a pin avec un Arduino Uno.
    J’arrive a allumer un led (rose ;) et a la faire varier mais le 5940 fait n’importe quoi.

    void loop()
    {
    Tlc.clear();
    Tlc.set(1, 4095);
    Tlc.update();
    }

    Il fait varier la LED tout seul et l’éteint .. l’allume.. l’éteint….. et la coupe au bout d’un moment.
    Même débrancher l’alim de l’arduino ne relance pas le sketch, ni un reset.
    Par contre si je débranche la LED et que je la remet, ca refonctionne.
    Pas de chauffe du 5940, ya qu’une led.

    J’ai un doute sur mon arduino nano tout neuf.
    Faut que je regarde le câblage aussi de plus prêt.

  11. Ironic says:

    Bon j’espère pas trop polluer ta page avec mes commentaires.
    J’ai trouvé mon problème de 5940 fou.
    C’était simplement une LED traditionnelle rose de 3.2v a 30mA qui pétait les plombs.
    J’ai jamais vu ca, une LED neuve complétement folle.

  12. Ironic says:

    D’après ton lien tu as des LED de 10mm a 60mA.
    Donc c’est plus puissant que des LED 3mm ou 5mm.
    60mA par LED c’est a dire 3*20mA (avec des pointes de 30mA max).
    Le problème c’est qu’il n’y a qu’une résistance pour toutes les LED sur le 5940 et tes LED ont des tensions différentes en fonction des couleurs donc en principe des résistances différentes.

    Rouge : 20mA – Tension : 1.9v/2.1v/2.3v (2.1Volts)
    Vert : 20mA – Tension : 3.2v/3.4v/3.6v (3.4Volts)
    Bleu : 20mA – Tension : 3.2v/3.4v/3.6v (3.4Volts)

    Donc c’est bien 20mA par couleur donc si tu as 4 LED en parallèle ca fait 4*20mA soit 80mA. C’est en dessous des 120mA par sortie du 5940 mais les 120mA par sortie c’est pour une sortie. Si tu utilises 120mA par sortie et sur toutes les sorties ca chauffe énormément.
    Apparemment, 80mA sur toutes les sorties ca chauffe aussi beaucoup de ton coté. J’ai pas trop de solution. (peut être augmenter la résistance de limitation de courant du 5940 et/ou utiliser des valeurs PWM de 3000 maxi au lieu de 4095). A essayer…

    Pour les rubans de LED je veux bien te donner le lien mais j’ai pas encore validé cette solution. Comme c’est en 12Volts et que la résistance est déjà sur les ruban de LED, je sais pas quoi mettre comme résistance de limitation.

    http://www.ebay.fr/itm/5M-5050-SMD-IP65-Waterproof-RGB-300-LED-Strip-24-44-KEY-IR-12V-5A-Power-Supply-/160961383512?pt=LH_DefaultDomain_0&var=&hash=item257a0bcc58

    J’achète les ruban de LED (LED Strip) uniquement.

  13. Mathieu says:

    Hello !
    J’ai recu mon matos aujourd’hui également. Enfin à l’exception de mes led rgb ^^
    Du coup je test le montage que tu as dans ton article, je charges le programmes exemple de la librairie : matrix.

    Mais rien ne s’allume et le tlc chauffe également à mort…

  14. Ironic says:

    J’ai fais mon montage ce matin suivant le schéma du haut de la page (celui avec 1 seul 5940) et ca fonctionne parfaitement. (Arduino Nano)
    Par contre il faut y aller doucement.
    J’ai commencé par essayé de le faire fonctionner avec 1 seule LED monochrome sur la sortie 0, j’ai pas directement chargé la mule.

    Le programme minimum.

    #include “Tlc5940.h”
    void setup()
    {
    Tlc.init();
    }
    void loop()
    {
    Tlc.clear();
    Tlc.set(0, 4095);
    Tlc.update();
    }

    Après une fois que cela fonctionne, on peut aller plus loin.
    J’ai mis 10 LED Bleues sur les sorties de 0 a 9 et chargé le programme :”fade” ou “circular light buffer”.

    Après j’ai remplacé les LED par 6 LED RGB (un morceau de 10cm de LED STRIP 5050 RGB) sur les sorties 0, 1 et 2. Ça fonctionne aussi mais 5 volts de l’Arduino c’est trop faible, les strips fonctionnent en 12V.

    J’ai donc ajouté une alim externe de 12Volts
    Le (-) relié au ground de l’Arduino.
    Le (+) a l’anode du morceau de strip.
    Les 3 cathodes sont sur 0, 1 et 2 du 5940.
    J’ai aussi remplacé la résistance de limitation d’intensité par une de 100 Ohms.

    Résultat parfait !! J’ai 12V en sortie pour les LED (relevé au voltmètre) et les LED s’allument a 100%.
    Ça ne chauffe pas du tout mais j’utilise que 3 sorties et 1 seul 5940.
    La je vais câbler 15 (3*5) sorties, je vais mettre 5 morceaux de Strip de 6 LED RGB.
    En esperant toujours que ca ne chauffera pas.

    Est ce que je 5940 chauffe si tu mets rien en sortie ?
    Procède par étape comme moi.

  15. Mathieu says:

    Merci !
    Tout marche nickel, je pilote 16 leds pour le moment.
    Demain j’essayerais de mettre plusieurs tlc en cascade.

  16. Ironic says:

    Quelques heures plus tard et un millier de fils de plus, le résultat est la !!

    2 TLC 5940 en cascade (exactement comme le schéma du début).
    Alimentés en 5V depuis l’Arduino (5v USB = Arduino + 2 TLC5940).

    8 morceaux de 10cm de bande de LED 5050 RGB (donc 6 LED RGB par morceau).
    Câblés sur 24 sorties PWM en 12volts.

    Tout fonctionne parfaitement et sans chauffer.
    Ça fait que 40mA par sortie PWM, c’est un peu normal que ca chauffe pas.

    Au total on a 6*8 = 48 LED * 3 couleurs sans aucun problème de chauffe.

    1er 5940: 5*6 LED – 30 LED : 30*20mA = 600mA.
    2eme 5940: 3*6 LED – 18 LED : 18*20mA = 360mA.

    Je pense que gérer 64 LED RGB de 20mA (des 3mm ou 5mm) ne pose aucun problème avec 2 5940.
    Mais 64 LED RGB de 60mA (10mm), c’est peut être pas la même histoire mais ca doit être faisable.

    • jhd says:

      Trop cool. On pourrai se parler via gtalk car jpense kon a un projet similaire :)

      • Mathieu says:

        Si y’a moyen j’aimerais bien m’inviter dans la conversation aussi ^^

        • jhd says:

          Pas de souci pr moi mais on peut faire ca comment ? Irc ? Gtalk? Mon gmail c est jhdscript.

          Je vous explique. J ai réalisé un logiciel qui permet d analyser le contenu de l ecran pour faire une sorte d ambilight. Du coup un ou deux testeurs seraient les bienvenue avant une publication officielle ;)

  17. Ironic says:

    Je connais pas gtalk, j’imagine que c’est un truc du genre team speak ou skype.
    J’ai pas de micro désolé. Irc ou autre pourquoi pas mais je suis pas disponible a 100%.

    De plus j’ai déjà l’ambilight spectra 2 sur ma tv donc ca m’apporterai pas grand chose.
    Mais le spectra 2 je peux en parler (ya le spectra 3 je crois) ya moyen de faire mieux que ca.

    Le spectra 2 c’est 24 LED RGB de chaque coté de la TV.
    Il y a 4 canaux de chaque coté donc 4 groupes de 6 LED a gauche et a droite.

    C’est marrant parce que en tout ca fait 8 paquets de 6 LED RGB et c’est exactement ce que j’ai fait avec l’arduino, deux 5940 et 8 morceaux de LED Strip RGB 5050.

    J’ai la TV qui est a 50cm de moi et je peux te dire que mes 64 LED sont plus puissantes et plus colorées que le système Ambilight.

    Voila ce que ca donne mais ca rend pas terrible le téléphone sature.
    http://www.youtube.com/watch?v=K81POCd7vyQ

  18. jhd says:

    bon j ai commandé 5m de leds je pense que les miennes tirent trop de jus

  19. Ironic says:

    J’ai encore parcouru le net à la recherche d’infos.
    J’ai trouvé ce post :
    http://www.instructables.com/id/30-channel-LED-RGB-Ambilight-Clone/#step1
    Un ambilight avec des LED Strip RGB 12v (60LED/m).
    Il contrôle 10 bandes de 15 LED, soit 25cm.
    Il a relevé l’intensité sur une bande de 25cm : 90mA pour le rouge et 75mA pour le vert/bleu.
    J’ai lu qu’il a mis une résistance de limitation de 390 Ohms, moi j’ai mis une 100 Ohms. Je me suis dis, inutile de limiter le courant, les Strips le fonts déjà avec leurs résistance interne.
    Mais si j’ai un court-jus dans un strip, aïe, je crois que je vais faire des essais avec une 390 Ohms, ca permet de limiter le courant a 100 Ohms.
    Il dis aussi que ca chauffe un peu au niveau de 5940 mais rien d’alarmant. Il a quand même mis un dissipateur.
    Bref, si on sait lire l’anglais, c’est une mine d’infos.

  20. Mathieu says:

    Hum vous faites comment quand vous mettez des tlc en cascade pour acceder à toutes les leds ? Après les 16 premières. Moi je pensais que c’étais tout simplement en agissant sur la led 32 par exemple mais apparement ça n’est pas le cas…

  21. Ironic says:

    Ah si, une fois que tu as mis les 5940 en cascade, c’est comme si tu avait un seul 5940 avec 32 sorties.
    Par contre la 32eme sortie c’est pas la 32 mais la 31.
    Les 32 sorties vont de 0 à 31.
    N’oublie pas que les sorties 0 (première) et 15 (dernière) sont de l’autre coté du 5940.
    Je n’utilise pas la 1ere sortie 0, comme ca mes 8 groupe de LED RGB vont de 1 a 24.

    1) Câbler correctement le 2eme 5940, n’oublie pas qu’il y a 5 ficelles à câbler entre les 2 5940.

    2) Modifier le fichier (texte) : “tlc_config.h”

    Il faut modifier la valeur : “#define NUM_TLCS”
    #define NUM_TLCS 1 => #define NUM_TLCS 2

    Après tu peux faire : Tlc.set(31,4095);

  22. Mathieu says:

    Ouaip je disait 32 au hasard, mais j’ai essayé en dessous aussi et ça ne fonctionne pas chez moi :/ Je regarderais ça demain.

  23. Ironic says:

    Ouais je veux bien te faire un article complet sur “mon projet” mais le soucis c’est que…
    j’ai pas vraiment de projet, je suis un touche à tout et c’est rare que je finalise quelque chose.

    En fait à l’origine je voulais faire un Vu-metre géant à base de LED RGB forcement, mais aussi avec de grosses plaques de plexiglas.
    Voici quelques exemples :
    https://www.youtube.com/watch?v=mbOuIPbKuxs
    https://www.youtube.com/watch?v=xgTkldgVGr4
    https://www.youtube.com/watch?v=r0M_ro1Cc2w
    https://www.youtube.com/watch?v=lASJL47g-Bc
    https://www.youtube.com/watch?v=yvUftvJz0xI
    Yen a plein…

    Mais je suis incapable de trouver des plaques de plexiglas de 20mm d’épaisseur et découpées aux bonnes dimensions, cela à un prix décent.

    J’ai quand même l’intention de faire quelques chose de tous mes trucs, j’ai 7 TLC5940, 5m de LED RGB, 3 Arduino…

    Je pense que je vais rester sur un système de bandes de LED RGB verticales mais derrière une tour carré en panneaux blancs pour diffuser les couleurs. Ça pourrait faire une lampe déco d’ambiance “tendance” avec plusieurs programmes sélectionnable.
    Afficheur LCD, potars et poussoirs en façade pour les programmes.
    J’ai tout ce qu’il faut mais encore que je trouve la bonne matière pour diffuser correctement les LED et surtout la bonne taille.

    Ca sera, je pense, une tour carré de 25cm sur 25cm et de 50cm à 80cm de haut.
    Avec un socle pour contenir toute l’électronique.
    Ca pourrait servir de lampe déco, de vu-mètre, d’avertisseur de mails…
    Je voudrais quelques chose de très beau et très visuel.
    Voila le projet plus ou moins en cours mais faut que je fasse quelques essais.

    Sinon pour l’article je suis partant mais ca va se faire petit à petit.

    • jhd says:

      Super pr diffused tes leds tu peux mettre de la colle genre pistolet a colle dessus ( une fine couche )

      J attend ton article no pbm :)

  24. Ironic says:

    Encore une petite info sur le TCL5940.

    J’ai été plusieurs fois confronté à un problème lors de mes essais câblages/programmations. La séquence ne se déroulait absolument pas comme prévu.
    Soit certaines sorties ne fonctionnaient pas, soit rien ne fonctionnait.

    Comme mon Arduino et mes TCL5940 sont recouvert de fils de câblage, à chaque fois que j’en câblais ou décablais, je pouvais éventuellement faire une connerie (court-circuit/faux contact..).
    Comme je modifiais en même temps mon code, j’avais aussi des doute sur lui aussi.

    MAIS, que neni !!
    Alors je sais pas si ca vient de l’Arduino, du TCL5940 ou des deux mais faite attention à une chose.

    NE faites PAS de câblage (même les sorties TCL5940) sous tension. Ça détraque le TCL5940. C’est pas systématique mais ca arrive et après on comprend plus rien.

    Pas de gros problème pour moi, il suffit de couper et remettre l’alimentation des Arduino/TCL5940 et tout refonctionne.

    Sinon j’ai réalisé a la va vite une lampe tour de plexiglas de 15cm/15cm/50cm avec 8 bandeau (10cm) de LED RGB horizontalement et 8 bandeau (5cm) de LED RGB verticalement.
    Un Arduino, deux TCL5940 et “un peu” de code.
    Je pensait pouvoir faire une lampe moderne et animée mais le résultat n’est pas la, les couleurs se mélangent beaucoup trop. Projet a repenser depuis le début :/

  25. Ironic says:

    Encore une petite news.
    J’ai constaté quelques bugs, probablement dans la librairie du TCL5940.
    Après avoir fait quelques petites modifications de mon code, plus rien ne fonctionnait ou alors plus que quelques LED fonctionnaient.
    Même après un Reset ou une coupure de l’alimentation Arduino/5940, le problème était la.
    J’ai même eu des impossibilité de charger le sketch.

    J’ai trouvé que ca arrivait après l’ajout d’un “Tlc.update();”
    Pour résoudre ce problème, j’ajoute un “delay(1);”
    Ce qui fait : “Tlc.update(); delay(1);”

    Ce qui est étrange c’est que ca n’arrive pas a tous les endroits du sketch.

    2eme chose étrange, j’ai 10 paquets de LED RGB donc 30 sorties PWM
    Tout fonctionne parfaitement, couleurs a gogo, cyclage, transition, j’ai essayé pleins de trucs.
    Par contre si j’allume tout en blanc, ca merde, ca bug, des couleurs apparaissent, des LED se coupent et je n’ai pas d’autre possibilité que de couper l’alim Arduino/5940 pour résoudre le problème. C’est pas l’alim 12V, c’est une 5A. Peut être que l’Arduino ne fourni pas assez de courant pour commuter toutes les entrées a fond.
    A méditer…

  26. Ironic says:

    Encore une petite info.
    J’ai réussi a reproduire le bug en bougeant accidentellement la prise USB qui alimente l’Arduino/TCL5940. Humm…

    Sinon, voile le résultat :
    http://www.youtube.com/watch?v=4jAyYAjAJrw

    C’est pas mon projet définitif, je suis pas satisfait du résultat.
    Je pense que l’association plexiglas/papier 80g n’est pas un bon diffuseur.
    De plus j’ai du rapprocher les LED a 3cm du plexiglas sinon le mélange des couleurs est total et impossible de faire des effets intéressants.
    Donc la tour ne fait plus 15cm sur 15cm de base mais 15cm sur 3cm de profondeur, arf…

    • jhd says:

      J avais constaté ce problème. Ce composant a vraiment l air super sensible…

      Pour ton projet tu devrai cloisonné chaque led je pense

  27. jhd says:

    d ailleur je trouve le résultat pas mal du tout:)

  28. JB says:

    Merci pour ces détails ! L’un de vous pourrais m’indiquer où acheter ce composant au meilleur prix ? Sur ebay j’en trouve à 9$ les 10 ce qui est déjà pas mal mais je me demandais si on ne pouvais pas trouver encore moins cher…

    • jhd says:

      Tout dépend du volume que tu souhaites commander. Pour moins de 100 unités, Ebay reste ma plateforme préférée car pas trop cher, presque tout est disponible. L’inconvénient est les délai de livraison.

      Pour de gros volumes, je fais faire des propales aux gros sites d’electronique

      • JB says:

        Merci pour la rapidité ! Je vais donc poursuivre sur Ebay car pour l’instant c’est pour moins de 30 …

        J’en profite pour une petite question, si je comprend bien ton explication il n’y a qu’une seule résistance pour les 16 sorties ? Au niveau puissance est-ce suffisant avec la même alim que l’arduino pour alimenter tout le circuit ? Je réfléchi à un montage de 60 LED RGB pour une horloge style Equinox avec un Arduino Nano V3.0 AVR ATmega328 et donc 12 TCL5940 car je veux pouvoir régler la couleur de chaque LED.

  29. Jon says:

    Salut,
    Je réanime ce post pour te dire que non seulement ton tuto m a bien aide mais que je fais tourner 4 TLC avec 12led blanche et et 12 led rvb et ça marche bien avec un uno. Ça marche depuis plus de 4 mois et ça chauffe convenablement :-) il y a même 6 capteurs capacitiv gèré en plus par l arduino :-)
    Après, tout ça est branché en USB sur un raspberrypi B qui contrôle le tout en série depuis un server nodejs. Ça marche super bien.

Leave a Reply

Your email address will not be published. Required fields are marked *

You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>