next topic »

[on:]

Bonjour,
J'essaie de faire fonctionner un ruban de LED adressable de 5 mètres : Digital RGB LED Strip de adafruit lerning system (LPD8806). C'est pour le téléthon (il reste une semaine !).
Impossible d'allumer ne serait-ce qu'une LED. J'ai essayé les 2 programmes fournis par le constructeur : longstrandtest.ino et strandtest.ino, sans succès.
J'utilise une carte arduino MEGA2560. J'ai une alimentation +5V/7A pour l'alimentation du bandeau, un bloc d'alim 12V pour la carte Arduino. La masse du 5V/7A est connectée à la masse de la carte (GND). J'utilise les sorties SPI (Data : pin 51, Clock : pin 52).
J'obtiens bien mes signaux en sortie (visualisés avec analyseur logique). J'ai constaté que sur le connecteur à l'autre bout du ruban, les signaux SCK et DATA n'arrivent pas, est-ce normal ? En revanche, pas de soucis pour l'alimentation. Pendant mes nombreux essais, quelques LED du bandeau se sont allumées au hasard. Maintenant, plus rien ne s'allume.
Il y a certainement quelque chose que je ne fais pas bien. Si quelqu'un a une idée, je suis preneur car là je ne vois plus !
J'envoie mon programme simplifié au maximum.
Merci d'avance,

[Reply #1 on:]

Jpense pas que ça soir normal que ça arrive pas à l'autre bout. Y'a une soudure qui doit pas être bonne. Vérifie les connexions à l’ohmmètre ou avec l'analyseur logique

[Reply #2 on:]

Merci pour l'idée.
Fils de masse et de +5V : OK à l'ohmètre. Fils SCK et DATA : Aucun bip, et toujours à +5V.
J'ai essayé avec un autre ruban de 5 mètres : résultats identiques. J'espère ne pas les avoir "flingués".
Ceci dit, c'est peut-être normal pour l'ohmètre, chaque puce LPD8806 décale les signaux, donc les éventuels signaux n'arriveraient qu'après 160 * 3 décalages (si j'ai bien compris). J'ai essayé de mettre plus de 160 LED dans le programme, mais toujours rien en sortie.
S'il y a une coupure de pistes, cela va être difficile à localiser vu que le tout est enveloppé dans du plastique transparent. Un coup de cutter, d'accord mais où et quid de la garantie du produit.
Des idées ?
Merci pour vos réponses

[Reply #3 on:]

Que pensez-vous du programme ? Quelqu'un a-t-il déjà fait fonctionner ce ruban de LED adressable ? Y a-t-il un programme simple pour allumer juste les premières LED du bandeau, sans effet ?
Merci d'avance pour vos réponses.
Ci-dessous, le programme que j'utilise, mais rien ne se passe !

Code:

#include "LPD8806.h"
#include "SPI.h"

// Simple test for 160 (5 meters) of LPD8806-based RGB LED strip

/*****************************************************************************/

// Number of RGB LEDs in strand:
int nLEDs = 160;

// Chose 2 pins for output; can be any valid output pins:
int dataPin  = 51;
int clockPin = 52;

// First parameter is the number of LEDs in the strand.  The LED strips
// are 32 LEDs per meter but you can extend or cut the strip.  Next two
// parameters are SPI data and clock pins:
//LPD8806 strip = LPD8806(nLEDs, dataPin, clockPin);

// You can optionally use hardware SPI for faster writes, just leave out
// the data and clock pin parameters.  But this does limit use to very
// specific pins on the Arduino.  For "classic" Arduinos (Uno, Duemilanove,
// etc.), data = pin 11, clock = pin 13.  For Arduino Mega, data = pin 51,
// clock = pin 52.  For 32u4 Breakout Board+ and Teensy, data = pin B2,
// clock = pin B1.  For Leonardo, this can ONLY be done on the ICSP pins.

// Creation d'un objet strip
LPD8806 strip = LPD8806(nLEDs);

void setup() {
  // Start up the LED strip
  strip.begin();

  // Update the strip, to start they are all 'off'
  strip.show();
}

void loop() {
   unsigned long couleurPWM;
   int pix;
   
   // fabrication bleu avec G, R et B : bleu -> 0x8080FF
   couleurPWM = strip.Color(  0,  0, 127); // Blue
 
   // Envoi en série de tous les codes couleurs pour chaque LED (3 octets / LED)
   for(pix = 0; pix < strip.numPixels(); pix++)
   {
     strip.setPixelColor(pix, couleurPWM);  // Set new pixel 'on'
     strip.show();                          // Refresh LED states
//     strip.setPixelColor(pix, 0);           // Erase pixel, but don't refresh!
     delay(100);
   }

   // Envoi des valeurs des registres PWM sur les sorties LED
   strip.setPixelColor(pix, 0); // MSB à 0 pour 3 octets
   strip.show(); // registre -> PWM (envoi sur sortie LED)
   
   // attends avant la prochaine séquence
   // je sais qu'au prochain tour ce sera encore tout bleu
   delay(1000);
}

Je vous aurai bien mis une image avec les signaux obtenus avec un analyseur logique, mais je ne sais pas comment utiliser les balises
Merci d'avance pour vos réponses.

[Reply #4 on:]

Si t'as repris celui du site je vois pas pourquoi ça marcherait pas :s

Après à tout hasard la librairie fonctionne sur n'importe quel pin apparemment, tu peux toujours essayer ça déjà !

[Reply #5 on:]

Yop boby!

j'ai vu que tu m'avais envoyer en mp un msg. Perso moi j'ai branché , j'ai chargé et ca marchais le programme de teste. Je vois pas trop ce qu'il pourrait y avoir.
Pour moi le programme est bon.

sinon perso moi j'ai utilisé un arduino teensy 2+


Le mieux prend une photo du montage que t'as fait ou envoie la moi en mp ou envoie ton num. pasque un truc comme ca ca devrais fonctionner du premier coup!

[Reply #6 on:]

[Résolu]
Ca y est ! Le ruban fonctionne super bien.
Je suis le roi des c... Le ruban de LED de 5m est équipé de 2 connecteurs 4 broches, un de chaque côté (un mâle et un femelle). Par commodité, j'ai fait tous mes essais avec le connecteur femelle par commodité, n'ayant pas de connecteur adapté pour le côté mâle. Je pensais que l'on pouvait injecter les signaux indifféremment des 2 côtés, comme un bus I2C, RS485... Et bien non, IL FAUT connecter la carte arduino au connecteur mâle pour que cela fonctionne.
Merci B@tto de m'avoir ouvert l'esprit, ta dernière remarque m'a mis sur la voie...
Bon, je poste le code que j'ai utilisé pour tester le ruban de LED adressables (pris sur le site du constructeur).

Code:

/***************************************************************************************
 Chenillard pour tester le ruban de 5 mètres de LED strip adressables (160 LED)
 Commande du ruban de LED basé sur le LPD8806
 Allumage successif de chacune des 160 LED (point RGB) dans l'ordre croissant
 1er passage en rouge, 2ème en vert, 3ème en bleu, 4ème en blanc
****************************************************************************************/
#include "LPD8806.h" // utilisation des méthodes de la classe LPD8806
#include "SPI.h" // utilisation des méthodes de la classe SPI

const int DUREE_ON = 25;  // durée allumage de chaque LED
int nLEDs = 160;   // nombre de LED RGB dans le ruban
int dataPin  = 51; // signal DATA du bus SPI
int clockPin = 52;   // signal CLOCK du bus SPI

// Avec une carte Uno classique, il faut utiliser les broches 11 (data) et
// 13 (clock).
LPD8806 strip = LPD8806(nLEDs);  // création d'un objet strip de type LPD8806

void setup() {
  // Initialise la connexion SPI : MSB first, mode 0, clock 2 MHz, RAZ registres LED
  strip.begin();

  // envoi (n registres LED -> n PWM LED), PWM = 0 -> n LED éteintes
  strip.show();
}

void loop() {
  colorChase(strip.Color(127,  0,  0), DUREE_ON);  // chenillard, rouge défile
  colorChase(strip.Color(  0,127,  0), DUREE_ON);  // chenillard, vert défile
  colorChase(strip.Color(  0,  0,127), DUREE_ON);  // chenillard, bleu défile
  colorChase(strip.Color(127,127,127), DUREE_ON);  // chenillard, blanc défile
}

// Une lumière (point) descend le long du ruban
// c : couleur de la lumière,  wait : durée d'allumage
void colorChase(uint32_t c, uint8_t wait) {
  int i;
  
  // un seul point est affiché à la fois
  for(i=0; i<strip.numPixels(); i++) {
    strip.setPixelColor(i, c); // charge couleur allumage du point dans registre
    strip.show();              // allume le point, registre LED -> PWM LED
    strip.setPixelColor(i, 0); // RAZ registre LED, mais PWM tjs active
    delay(wait);               // temporisation
  }

  strip.show(); // Eteint le dernier point
}

[Reply #7 on:]

Oé faut faire attention au sens! normalement si tu regarde sur ta stripled il y a marqué DI et CI (Data IN , Clock IN) et de l'autre coté en sortie DO et CO (Data OUT, Clock OUT). en faite c'est pas un bus comme tu parlais de l'I2C, RSXXX . Chaque trame est régénéré a chaque passage dans les micro-contrôleur intermédiaire. L’intérêt de ce système c'est de ne pas avoir à adresser chaque led, l'adressage ce fait en fonction de l'ordre de câblage.

[Reply #8 on:]

Et oui ! Quand on est pressé, on ne fait rien de bon. Je n'avais pas fait le rapprochement DO DOutput. Voilà, je ferai plus attention la prochaine fois.
Question projet téléthon, cela fonctionne très bien avec des couleurs simples (rouge, vert, bleu, jaune, blanc). Quand je veux allumer des LED en violet (R=64, G=0, B=127), indigo (R=32, G=0, B=127) ou encore orange (R=127, G=64, B=0), le ruban devient instable (les couleurs se mélangent et font un peu n'importe quoi). Bizarre ! Certains mélanges fonctionnent très bien : jaune (127, 127, 0), par contre violet foncé fonctionne mal (127, 0, 127). Je ne vois pas pourquoi !
De toute façon, je n'ai plus le temps de chercher. Peut-être un prochain post... Pour le téléthon, je me contenterai des couleurs qui ne me posent pas de problème : rouge, vert, bleu, jaune et blanc.