next topic »

[on:]

Hello,

J'ai trouvé des tutoriels expliquant l'utilisation du registre à décalage 74hc595. Je souhaiterais en utiliser 8 ensembles pour contrôler 8x8 = 64 LEDs. (60 en réalité, c'est pour créer une horloge à leds)

Je pense savoir comment cabler le circuit d'après ce tut :
http://www.protostack.com/blog/2010/05/introduction-to-74hc595-shift-register-controlling-16-leds/

Il suffit de relier les pattes 11 ensembles, et les pattes 12 ensembles, puis la patte 9 (Q7"    Serial Out) du premier registre, à la patte 14 (DS Serial data input) du second registre... Etc...

Mon soucis se porte sur la programmation, comment transmettre les données ?
Pour 1 seul registre à décalage j'ai réussit, en utilisant shiftOut(dataPin, clockPin, MSBFIRST, number); (avec "number" étant de type "int")

Mon soucis c'est que la variable number étant de type int, il me semble qu'elle est insuffisante pour contrôler 60 leds.
Je m'explique :

0xFh       = 1111b (ce nombre me permet de contrôler 4 leds indépendamment)
0xFFFFFFFFh   = 1111 1111 1111 1111 1111 1111 1111 1111 b (ce nombre de type 'int' me permet de contrôler seulement 32 LEDs mais pas 60).

Comment puis-je contrôler 60 LEDs ? (il me faudrait passer un QWORD au lieu d'un DWORD, mais comment ?)

Merci.

[Reply #1 on:]

Bonsoir,
Je suis actuellement en train de construire une horloge à Led à base d'une matrice de Led et j'utilise plutôt un MAX7219 associé à la librairie LedControl(http://arduino.cc/playground/Main/LedControl ).
C'est extrèmement simple à utiliser et n'utilise que 3 pins sur l'Arduino pour commander 64 Led.

Sinon on peut aussi n'utiliser que deux 74hc595 pour commander 64 Led, mais il faut gérer soi-même le multiplexage de la matrice de 8*8 (ce que le MAX7219 fait automatiquement).

[Reply #2 on:]

Yep!

La solution la plus simple est de définir dans ta boucle for, une valeur de i < 60 et mettre les shiftout en série tout simplement entre les ST_CP (latch)

Code:

       
digitalWrite(ST_CP, LOW);
shiftOut(DS, SH_CP, MSBFIRST, B00010001); // 1er 595
shiftOut(DS, SH_CP, MSBFIRST, B11101110); // 2eme 595
digitalWrite(ST_CP, HIGH);
delay(200);

Si l'utilisation des registres ne te fais pas trop peur, un truc dans le genre devrait marcher :

Code:

#include <avr/io.h>
#include <util/delay.h>

#define number_of_74hc595s 1 //How many of the shift registers are there daisey chained?

void setup() {
}

void loop(){
PORTB = 0x00;
        /*
char counter = 0;

while(1){
counter++; // Counter used for displaying a number in binary via the shift register
shift(PB4, PB0, PB3, counter); // PB1 = SERCLK  PB2 = RCLK  PB3 = SER
_delay_ms(500);
shift(PB4, PB0, PB3, 0x00); // Set all pins to off
_delay_ms(500);
}
        */
        shift(PB4, PB0, PB3, B11100000);
        delay(500);
        shift(PB4, PB0, PB3, 0x00);
        delay(500);

}

void shift(int SRCLK_Pin, int RCLK_Pin, int SER_Pin, unsigned long data){
PORTB &= ~(1 << RCLK_Pin); // Set the register-clock pin low

for (int i = 0; i < (8 * number_of_74hc595s); i++){ // Now we are entering the loop to shift out 8+ bits

PORTB &= ~(1 << SRCLK_Pin); // Set the serial-clock pin low

PORTB |= (((data&(0x01<<i))>>i) << SER_Pin ); // Go through each bit of data and output it

PORTB |= (1 << SRCLK_Pin); // Set the serial-clock pin high

PORTB &= ~(((data&(0x01<<i))>>i) << SER_Pin ); // Set the datapin low again
}

PORTB |= (1 << RCLK_Pin); // Set the register-clock pin high to update the output of the shift-register
}

Comme j'avais qu'un seul chip sous la main, je n'ai pas pû tester plus avant.
Faut vérifier l'ordre des bits, je crois qu'ils sont inversés dans ce dernier code, B00000001 signifie que l'on active le dernier bit...

@+

Zoroastre.

[Reply #3 on:]

Salut,

Ta première solution reste la plus simple. J'y avais pensé mais pas testé non plus car pas encore le matériel.
J'expérimenterai ta seconde aussi. Car un shifting est à mon avis tout à fait adapté à une horloge.

Et puis pendant que j'y suis je testerai aussi avec seulement deux Registres le multiplexage, je pense avoir compris... et si ça complique un peu la programmation, en contre partie ça a l'avantage de simplifier grandement le cablage.

Merci pour vos deux réponses, je crois que j'ai les clefs en main.
Bye.

[Reply #4 on:]

Bonjour,

J'ai fait un tutoriel sur shiftOut() si besoin
http://skyduino.wordpress.com/2011/11/10/tutoriel-arduino-communication-par-spi-hard-et-soft-et-par-i2c/

Je te conseille quand même d'utiliser le port SPI hardware si possible vu le nombre de 74HC595 que tu va devoir chainer.
Cela te donnera une plus grande vitesse de rafraichissement et une meilleur fiabilité que shiftOut.

[Reply #5 on:]

Merci pour ce lien.
La vidéo était un peu longue. Il va falloir que je la revisionne... Mais pour l'instant je vais faire plus simple.

Bye

[Reply #6 on:]

Merci pour ce lien.
La vidéo était un peu longue. Il va falloir que je la revisionne... Mais pour l'instant je vais faire plus simple.

C'est vrai que je fait des vidéos un peu longue mais c'est qu'il ya beaucoup de chose a dire