Led matrix

International Français
1

Bonjour à tous. Je m'appelle Yan et j'ai 35 ans. Je débute en électronique et me suis lancé dans l'aventure il y a à peine un mois et demi. Après avoir fait l'acquisition d'un Arduino uno j'ai commencé à écumer le net pour mettre en application les tutos que je trouvais. J'ai donc commencé par faire clignoter une led (waouh! génial!!! :slight_smile: ) Puis je suis parvenu à faire fonctionner un bar graph. Ce qui m'a donné l'idée de faire un compteur numérique pour mon véhicule de piste (Je suis mécanicien de métier) J'ai donc fait pas mal de recherches ce qui m'a permit de comprendre le fonctionnement des registres à décalage, des optocoupleurs et des ponts diviseurs. Bref, j'en arrive au cœur du problème, l'affichage de la vitesse du véhicule avec des matrices à led 7X5 LTP-1557AC, 2 74HC595 et 1 ULN2803A. Pour le moment je suis parvenu à écrire un petit bout de code qui me permet d'afficher chaque led indépendamment :

//Connecté à ST_CP des 74HC595 1&2
int latchPin = 8;
//Connecté à SH_CP des 74HC595 1&2
int clockPin = 12;
//Connecté à DS du 74HC595 1
int dataPin = 11;
 
void setup() {
  
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
}
 
void loop() {
  
   for (int x = 0; x < 5; x++)
   for (int y = 0; y < 7; y++)
  {
  byte rowBitsToSend = 0;
  byte columnBitsToSend = 0;
  digitalWrite(latchPin, LOW);
  bitWrite(columnBitsToSend, x, HIGH);
  shiftOut(dataPin, clockPin, MSBFIRST, columnBitsToSend);
  bitWrite(rowBitsToSend, y, HIGH);
  shiftOut(dataPin, clockPin, MSBFIRST, rowBitsToSend);
  digitalWrite(latchPin, HIGH);
  delay(100);
}}

En revanche, toutes mes tentatives pour afficher un caractère se sont toutes soldées par un échec. J'ai tenté de décortiquer le code des différents tutos sur lesquels j'ai pu mettre la main mais ils sont tous dédiés à du scroling text, ce qui amène le code à un niveau bien loin de ce que je suis capable d'intégrer pour l'instant.
D'où ma question: Comment coder le scan d'un caractère ?

2

Bonjour,
Pour afficher plusieurs points sur ta matrice, il faut peut être te pencher (mais sans tomber) sur la technique du multiplexage.
Regarde si cela correspond à ton souhait : http://arduino.cc/en/Tutorial/RowColumnScanning#.UwHXaVOXCG8

3

Mon afficheur est effectivement multiplexé via un 74HC595N pour les anodes et un 74HC595N couplé à un ULN2803A pour les cathodes. J'ai 3 afficheurs 7X5 à faire fonctionner et 35 leds avec une arduino UNO, donc pas trop le choix de passer par des registres à décalage pour limiter le nombre de sorties.

J'ai donc continué à bricoler mon bout de code et je suis parvenu à afficher mes chiffres. Seulement j'ai des différences de luminosité selon le nombre de led affiché sur une même ligne donc je pense que mon code n'allume pas une led à la fois. Il me reste à variabiliser mes chiffres car pour le moment je ne peux les afficher que manuellement en changeant la variable letter. Je ne sais pas si ce code est bien propre, ça reste du bricolage pour le moment.

//Connecté à ST_CP des 74HC595 1&2
int latchPin = 8;
//Connecté à SH_CP des 74HC595 1&2
int clockPin = 12;
//Connecté à DS du 74HC595 1
int dataPin = 11;

int number;

int leds[7][5] = {
{0, 0, 0, 0, 0},
{0, 0, 0, 0, 0},
{0, 0, 0, 0, 0},
{0, 0, 0, 0, 0},
{0, 0, 0, 0, 0},
{0, 0, 0, 0, 0},
{0, 0, 0, 0, 0}
};

int letter0[7][5] = {
{0, 1, 1, 1, 1}, 
{0, 1, 0, 0, 1}, 
{0, 1, 0, 0, 1}, 
{0, 1, 0, 0, 1}, 
{0, 1, 0, 0, 1}, 
{0, 1, 0, 0, 1}, 
{0, 1, 1, 1, 1}
};

int letter1[7][5] = {
{0, 0, 0, 0, 1}, 
{0, 0, 0, 0, 1}, 
{0, 0, 0, 0, 1}, 
{0, 0, 0, 0, 1}, 
{0, 0, 0, 0, 1}, 
{0, 0, 0, 0, 1}, 
{0, 0, 0, 0, 1}
};

int letter2[7][5] = {
{0, 1, 1, 1, 1}, 
{0, 0, 0, 0, 1}, 
{0, 0, 0, 0, 1}, 
{0, 1, 1, 1, 1}, 
{0, 1, 0, 0, 0}, 
{0, 1, 0, 0, 0}, 
{0, 1, 1, 1, 1}
};

int letter3[7][5] = {
{0, 1, 1, 1, 1}, 
{0, 0, 0, 0, 1}, 
{0, 0, 0, 0, 1}, 
{0, 1, 1, 1, 1}, 
{0, 0, 0, 0, 1}, 
{0, 0, 0, 0, 1}, 
{0, 1, 1, 1, 1}
};

int letter4[7][5] = {
{0, 1, 0, 0, 1}, 
{0, 1, 0, 0, 1}, 
{0, 1, 0, 0, 1}, 
{0, 1, 1, 1, 1}, 
{0, 0, 0, 0, 1}, 
{0, 0, 0, 0, 1}, 
{0, 0, 0, 0, 1}
};

int letter5[7][5] = {
{0, 1, 1, 1, 1}, 
{0, 1, 0, 0, 0}, 
{0, 1, 0, 0, 0}, 
{0, 1, 1, 1, 1}, 
{0, 0, 0, 0, 1}, 
{0, 0, 0, 0, 1}, 
{0, 1, 1, 1, 1}
};

int letter6[7][5] = {
{0, 1, 1, 1, 1}, 
{0, 1, 0, 0, 0}, 
{0, 1, 0, 0, 0}, 
{0, 1, 1, 1, 1}, 
{0, 1, 0, 0, 1}, 
{0, 1, 0, 0, 1}, 
{0, 1, 1, 1, 1}
};

int letter7[7][5] = {
{0, 1, 1, 1, 1}, 
{0, 0, 0, 0, 1}, 
{0, 0, 0, 0, 1}, 
{0, 0, 0, 0, 1}, 
{0, 0, 0, 0, 1}, 
{0, 0, 0, 0, 1}, 
{0, 0, 0, 0, 1}
};

int letter8[7][5] = {
{0, 1, 1, 1, 1}, 
{0, 1, 0, 0, 1}, 
{0, 1, 0, 0, 1}, 
{0, 1, 1, 1, 1}, 
{0, 1, 0, 0, 1}, 
{0, 1, 0, 0, 1}, 
{0, 1, 1, 1, 1}
};

int letter9[7][5] = {
{0, 1, 1, 1, 1}, 
{0, 1, 0, 0, 1}, 
{0, 1, 0, 0, 1}, 
{0, 1, 1, 1, 1}, 
{0, 0, 0, 0, 1}, 
{0, 0, 0, 0, 1}, 
{0, 1, 1, 1, 1}
};

void setup() {
  
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
  
}

void loop() {

int x;
int y;
  
byte columnbitsToSend = 0;
byte rowbitsToSend = 0;

for (x = 0; x < 7; x++) {
columnbitsToSend = 0;
rowbitsToSend = 0;

  for (y = 0; y < 5; y++) {
     if (leds[x][y] = letter0[x][y]) {
     bitWrite(rowbitsToSend, y, HIGH);
     }
  }

digitalWrite(latchPin, LOW);
bitWrite(columnbitsToSend, x, HIGH);
shiftOut(dataPin, clockPin, MSBFIRST, rowbitsToSend);
shiftOut(dataPin, clockPin, MSBFIRST, columnbitsToSend);
digitalWrite(latchPin, HIGH);
//delay(2);
}
}
4

Tu n'as pas de resistances de limitation de courant ?

5

Une 150ohm sur chaque anode.

6

Le problème c'est que les sorties des 595 ne peuvent pas fournir suffisamment de courant lorsque toutes les LEDs d'une ligne sont allumées. Ce qui explique le phénomène observé.

7

Un schéma électronique de ton montage serait le bienvenu.
En effet, les variations de luminosité peuvent aussi bien venir de l'électronique que du programme.
Si fonction du nombre de LED allumées l'alimentation où les transistors de commutation se mettent "à genoux", tu va constater des baisses d'intensité. Mais il y a aussi le programme. Pour que l'intégralité de ton visuel soit homogène en intensité lumineuse, il faut que chaque LED soit illuminée durant un délai strictement identique. C'est précisément en jouant sur le rapport cyclique que l'on peut graduer à convenance la clarté de l'afficheur.
Éventuellement sur
http://www.abcelectronique.com/bigonoff/realisations.php?par=7a79a
tu trouveras une application dans laquelle j'explique en détails comment multiplexer, avec tous les schémas électroniques et les organigrammes.
Je ne sais pas si ça te sera utile, mais dans cette application le multiplexage est fondamental.

P.S : Mince, quand je clique sur le lien je tombe sur la page où figurent plein d'applications.
C'est celle dont l'auteur est Auteur Michel Droui qu'il te faut télécharger.

8

Si tu veux un conseil avisé, pour ne pas griller ton Arduino, soit tu ne te sert de ton Arduino que pour commander et tu mets une alim sur ce qui doit être la consommation en sortie (pour toi les leds) et/ou fonctionnes à l'envers au niveau des sorties de l'Arduino, car en commutation les transistors de sortie de l'Arduino sont commutés à la masse et du coup peuvent supporter plusieurs milliampères donc bien plus que s'ils devaient fournir le 5v.