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 :
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 ?)
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(Arduino Playground - 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).
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)
Si l'utilisation des registres ne te fais pas trop peur, un truc dans le genre devrait marcher :
#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...
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.
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.
