LPD-6803 led strip 5 metres et arduino

bonjour,

j'ai fait l’acquisition de ce strip led (dream color) sur e-bay, 60€ avec driver 99 programmes et télécommande 866 mhz
bien que cela soit parfait au vue de ses 99 programmes, mon projet est d'utiliser un arduino pour driver ce strip en musique

quelqu'un sur ce forum a-t-il déjà expérimenté ce LPD-6803 avec la librairie adafruit

merci

Salut, pour ma part je n'ais pas essayer le LPD-6803 j'utilise le WS2801 mais une chose est sûre c'est que je te recommande d'utiliser la librairie FastSPI disponible ici : Google Code Archive - Long-term storage for Google Code Project Hosting.. Elle est très simple d'utilisation tu pourras en juger par toi même en regardant l'exemple qui est fourni avec la librairie.

En cherchant un peu sur google tu trouveras facilement comment interfacer ta guirlande avec l'arduino

Tu n'auras juste qu'a insérer dans ton setup() ceci :

#define NUM_LEDS 50 (ici tu remplaces 50 par le nombre de LED de ta guirlande)
unsigned short Display[NUM_LEDS];

void setup() {

memset(Display, 0, sizeof(unsigned short)*NUM_LEDS);
FastSPI_LED.setLeds(NUM_LEDS);
FastSPI_LED.setChipset(CFastSPI_LED::SPI_LPD6803);
FastSPI_LED.setCPUPercentage(70);
FastSPI_LED.init();
FastSPI_LED.start();
show();
}

Les possibilités sont infinies mais l'inspiration pour les effets n'est pas facile a trouver

SPI ? j'avais l'impression d'avoir comme un bus I2C , car le driver branché ne comporte que 4 fils (gnd . d . ck . 5V), enfin si ce n'est pas de l'I2C ça y ressemble fortement

pour moi le SPI ça ressemble a (SCLK . MOSI . MISO. gnd . VCC )

je fait confiance a ta reponse et je vais essayer merci !

pour l'alim il y a un 7805 , cool s'est du 5V compatible avec mon Arduino !

Tu t'es inspiré de ca??

Bonjour,

Le SPI pour les rubans de led est une chose trés classique (permet de chainer les rubans sans réel limite).

Quand il n'y a pas besoin de communication esclave -> maitre, le bus SPI peut se résumer à :
SCLK + MOSI (souvent annoté DIN sur les rubans de led)

Quelques info sur ton ruban de led + tutoriel arduino :
Tutoriel + code : RGB LED digital pixels tutorial (LPD6803)
Datasheet : http://www.adafruit.com/datasheets/LPD6803.pdf

j'ai pas réussi a faire quoi que ce soit avec fast_spi , par contre le strip fonctionne bien avec la librairie adafruit a condition d'inverser D et CK,

si je prend a les reperes a la sortie de mon boitier , j'ai GND.S.D.CK.L

S n'est pas utilisé
D je suppose que s'est data
CK logiquement ce serait clock
L 12V

ors quand je déclare dans le sketch adafruit les ports je suis obligé de brancher comme ceci

int dataPin = 4;       //       CK
int clockPin = 5;      //        D

y a certainement une chinoiserie quelque part !! :roll_eyes:

pour fast spi impossible a faire tourner, l'exemple n'est pas trés bien commenté, j'utilise un arduino mega 2560,

// Duemilanove and mini w/328
#if defined(__AVR_ATmega328P__)
#define SPI_PORT PORTB
#define SPI_DDR  DDRB
#define SPI_PIN  PINB
#define SPI_MOSI 3       // Arduino pin 11.
#define SPI_MISO 4       // Arduino pin 12.
#define SPI_SCK  5       // Arduino pin 13.
#define SPI_SSN  2       // Arduino pin 10.
#define DATA_PIN 11
#define SLAVE_PIN 12
#define CLOCK_PIN 13
#define LATCH_PIN 10

// Mega.
#elif defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
#define SPI_PORT PORTB
#define SPI_DDR  DDRB
#define SPI_PIN  PINB
#define SPI_MOSI 2       // Arduino pin 51.
#define SPI_MISO 3       // Arduino pin 50.
#define SPI_SCK  1       // Arduino pin 52.
#define SPI_SSN  0       // Arduino pin 53.
#define DATA_PIN 51
#define SLAVE_PIN 50
#define CLOCK_PIN 52
#define LATCH_PIN 53
#endif

en théorie je doit utiliser les broches 3 et 1 ?

Normalement quand tu met ceci:

#define NUM_LEDS 50 (ici tu remplaces 50 par le nombre de LED de ta guirlande)
unsigned short Display[NUM_LEDS];

void setup() {

memset(Display, 0, sizeof(unsigned short)*NUM_LEDS);
FastSPI_LED.setLeds(NUM_LEDS);
FastSPI_LED.setChipset(CFastSPI_LED::SPI_LPD6803);
FastSPI_LED.setCPUPercentage(70);
FastSPI_LED.init();
FastSPI_LED.start();
show();
}

Le constructeur définit les PIN 11 et 13 par défaut si il n'en reçoit pas en paramètre, alors je ne sais plus laquelle est data l'autre clock mais il n'y a pas de danger a inverser et une petite recherche sur google te permettrais de trouver facilement des exemples de code avec cette librairie et les LDP6803

j'ai eu droit a une fumée de toute beauté

en branchant +12 sur Vin le régulateur s'est envoyé en l'air, j'ai des doutes sur la qualité de ces arduino's vendus sur E-Bay, car aucune erreur de branchement de ma part !

je suis donc revenu en arriere pour repasser en alimentation par usb

pour le Mega 2560 les broches SPI par défaut sont en 50-51-52-53 , je n'ai pas réussi a faire fonctionner fast spi,
je vais tenter avec un arduino nano 328 pour voir ce que cela dit

Blizzard27:
Normalement quand tu met ceci:

#define NUM_LEDS 50 (ici tu remplaces 50 par le nombre de LED de ta guirlande)
unsigned short Display[NUM_LEDS];

void setup() {

memset(Display, 0, sizeof(unsigned short)*NUM_LEDS);
FastSPI_LED.setLeds(NUM_LEDS);
FastSPI_LED.setChipset(CFastSPI_LED::SPI_LPD6803);
FastSPI_LED.setCPUPercentage(70);
FastSPI_LED.init();
FastSPI_LED.start();
show();
}

Le constructeur définit les PIN 11 et 13 par défaut si il n'en reçoit pas en paramètre, alors je ne sais plus laquelle est data l'autre clock mais il n'y a pas de danger a inverser et une petite recherche sur google te permettrais de trouver facilement des exemples de code avec cette librairie et les LDP6803

j'ai ressoudé un bon vieux 7805 en TO220 a la place de ce petit MC xxxx, pas este tique mais efficace

je pense rester avec la librairie adafruit , j'ai besoin de rapidité d’exécution du code sur ce projet, Fast Spi VS Adafruit ??? lequel des 2 est le plus rapide en exécution ?, pour moi Adafruit n'est pas si complexe que ça a mettre en oeuvre !

J'ai écrit pour un autre membre du forum un soft pour piloter des bandeaux Adafruit a base de LPD-6803 en utilisant une version optimisée de la lib Adafruit
Il y avait 25 bandeaux de 2m chacun (62 leds) pilotés par une seule Mega2560.
Total 1550 Leds
La mise à jour des 1550 leds est super rapide ce qui permet des animations très fluides.

Je n'ai fait que le soft. Les vrais artistes sont ceux qui ont fait la mise en scène.

Cette page du site Adafruit envoie vers l'article qui décrit cette lib optimisée ici.

Le pilotage des ces bandeaux ressemble à du SPI mais ce n'est pas du vrai SPI.

Tiens nous au courant moi je possède uniquement une UNO donc il est possible que la librarie ne fonctionne pas pareil avec la MEGA
Jolie travail pour le soft barbudor et également très belle mise en scène

J'ai développé et debuggué sous UNO mais a cause de la RAM limitée je m'étais limité à 4 bandeaux de 62 leds (800 octets)
Damien utilisait une Mega pour avoir le nombre d'IO nécessaires (50) ainsi que la RAM pour mémoriser l'état des 1550 leds (4700 octets !)

la lib donné dans l'article d'origine est pour une UNO
J'ai du faire une version spéciale pour la Mega

trés belle vidéo :astonished:

j'ai suivi le lien pour la librairies optimisée, elle est faite pour des chip 8806, ou je n'ai pas tout compris, (anglais)
il y a certainement des modifications a apporter pour le Mega2560 et le 6803, car ça ne fonctionne pas chez moi ?

Alors c'est ma faute, j'ai lu trop vite.
C'est effectivement fait pour le LPD8806

LPD-6803, c'est la guirlande comme çà ?

Donc si je comprend bien, tu veux utiliser la guirlande ci-dessus avec un Mega2560 ?
Désolé de reposer les questions mais comme j'ai mal interprété, je préfère être sur.

s'est un strip led de 150 led , avec 50 chip 6803 : 3 led par chip (le meme que pour la guirlande)

j'utilise maintenant la librairies adafruit pour ce chip 6803 avec un mega 2560, toutes les autres lirairies ne fonctionne pas avec mon application

simplement je demande si il existe une librairie optimisée pour ce chip, car rien qu'a 50 pixels, y a comme du mou dans la regeingotte (expression vosgienne)

je pense que sa viens du chip 6803

du coup, je vais faire avec

S'il faut apprendre le vosgien maintenant...

Problème de performance donc ?

je fais bien l'effort d’essayer de comprendre le C++ :sweat_smile:

je pensait pouvoir arriver a plus de 30 rafraîchissement /secondes pour 50 diodes, je suis a 25 au maxi,

j'utilise cette librairies

/*****************************************************************************
 * Example to control LPD6803-based RGB LED Modules in a strand
 * Original code by Bliptronics.com Ben Moyes 2009
 * Use this as you wish, but please give credit, or at least buy some of my LEDs!
 *
 * Code cleaned up and Object-ified by ladyada, should be a bit easier to use
 *
 * Library Optimized for fast refresh rates 2011 by michu@neophob.com
 *****************************************************************************/

qui a l'air optimisée

d’après ton expérience, est-il possible d'atteindre les 30 rafraîchissement secondes (avec 50 led)

Avec les bandeaux de LEDs AdaFruit j'arrive à bien plus que cela mais ce n'est pas le même chip.

Je ne trouve pas lib sur le site ni BlipTronics ni neophob. Tu peux me donner le lien exact ? trouvé. je regarde

merci

quand je dit 50 led je dit 50 chip

J'ai regardé comment ca marche et j'ai utilisé mon analyseur logique pour les détails.
La lib utilise la liaison SPI hardware pour transmettre les octets sous interruption.
Le SPI est configuré avec une horloge à 8MHz ce qui fait 1µs pour transmettre un octet.
A la fin de chaque transmission, le contrôleur SPI génère une interruption et le code de lib lance l'envoi de l'octet suivant.

Voir l'image "transmission_octet" où :

  • ISR représente le temps d'éxécution de la routine d'interruption (ISR) : je fais un digitalWrite(, HIGH) sur un pin au début et un digitalWrite( , LOW) à la fin.
  • SCK représente les 8 impulsion du signal SCK pour transmettre les 2 bits d'un octet.

Seulement je constate qu'il faut 1,8µs pour que le code retourne dans la routine d'interruption et encore 1.7µs pour que l'octet suivant parte.

Bref, il faut donc au total 4µs pour transmettre un octet. Au total pour 50 LEDs, je constate environ environ 520µs.
Voir l'image "execution_globale"

Le problème de performance ne donc pas de là.

Je vois 2 problèmes possible :
a) C'est ton code de création des effets qui n'est pas assez performant
b) La transmission et les interruptions SPI ne s'arrêtent jamais. Hors on constate sur le diagramme "transmission_octet" que l'on passe presque la moitié du temps dans la routine d'interruption. On gâche donc en permanence 50% du CPU pour transmettre des 0 entre chaque mise à jour utile.

D'après la datasheet, je ne vois aucune raison a cette transmission permanente.
J'ai modifié la lib pour arrêter ces transmissions lorsqu'on en n'a pas besoin et donc récupérer ces 50% de capacité de traitement en plus.
Cela devrait régler le b)
Je te laisse essayer et donner ton retour.

Pour le a), c'est à toi

execution_globale.png

BLIP_LEDS_SPI_LPD6803.cpp (8.95 KB)