Matrice de LED

Matériel

Arduino Uno
Un shield Matrice de Led (http://openmicros.org/index.php/articles/88-ciseco-product-documentation/176-led-matrix-shield-how-to-build-a-sample-code)
Plaque d'essai (breadboard)
Straps ou fils de liaison

Principe

Comme on l'a vu avec l'afficheur 7 segments, les LED sont un moyen commode pour afficher une information simple. Le principal problème des montages que nous avons vus jusqu'à présent est que le nombre de broches utilisées est égal au nombre de LED.

La matrice de LED est un arrangement particulier d'un ensemble de LED pour constituer un tableau où l'on peut éclairer chaque LED indépendamment. Les LED sont rangées en lignes et colonnes. Comme pour l'afficheur 7 segments, il existe deux types de matrice :

Matrice à anode commune.
Matrice à cathode commune.

Les exemples ci-dessous sont écrits pour être compatible avec le Lumex LDM-24488NI Matrix (http://sigma.octopart.com/140413/datasheet/Lumex-LDM-24488NI.pdf). C'est une matrice 8x8 à cathode commune assez standard. Ils devraient être assez facile de les adapter pour d'autres modèles de matrices.

Une matrice 8x8 (64 LED) utilise au total 16 entrées (8 pour les lignes et 8 pour les colonnes). Pour éviter de passer trop de temps à câbler une matrice, nous avons préféré utiliser un shield (une carte fille de l'arduino) qui relie chaque broche de la matrice à une broche de l'Arduino.

Le brochage de la matrice sur le shield est le suivant :

Pin conceptuelle	Pin Arduino	Pin physique
Colonne 1	6	13
Colonne 2	11	3
Colonne 3	10	4
Colonne 4	3	10
Colonne 5	17	6
Colonne 6	4	11
Colonne 7	8	15
Colonne 8	9	16
Ligne 1	2	9
Ligne 2	7	14
Ligne 3	19	8
Ligne 4	5	12
Ligne 5	13	1
Ligne 6	18	7
Ligne 7	12	2
Ligne 8	16	5

Les broches 16, 17, 18, 19 correspondent au pin A2 ,A3 ,A4, A5 de l'Arduino quand elles sont utilisées comme des sorties numériques.

Pour éclairer une LED de coordonnée (x,y), il faut relier la broche de la colonne x à la masse et celle de la ligne y au 5v. On peut alimenter plusieurs LED d'une même colonne mais les colonnes doivent être mises à la masse une seule à la fois sinon on obtient deux fois la même colonne.

Programme

Voici le programme qu'il faut éditer dans l'IDE Arduino, puis compiler et charger dans la carte Arduino.

/*
 Ce programme met en oeuvre l'utilisation d'une matrice de LED. L'objectif est d'éclairer 
les LED paires de la première colonne.
*/
 
const int nbLignes = 8;
const int lignes[nbLignes] = {2, 7, 19, 5, 13, 18, 12, 16};

const int nbColonnes = 8;
const int colonnes[nbColonnes] = {6, 11, 10, 3, 17, 4, 8, 9};
 
// représentation de l'image à dessiner
int pixels[8][8];           
void setup() {
      for (int i = 0; i < nbColonnes; i++) {
          pinMode(colonnes[i], OUTPUT);  
          // Mettre les pins des colonnes à l'état haut pour éteindre toutes les led
          digitalWrite(colonnes[i], HIGH);    
      }
      
      for (int i = 0; i < nbLignes; i++) { 
          pinMode(lignes[i], OUTPUT);
      } 
     
      // initialisation de la matrice image
      for (int x = 0; x < nbColonnes; x++) {
          for (int y = 0; y < nbLignes; y++) {
              pixels[x][y] = 1;
          }
      }
}
 
void loop() {
    digitalWrite(colonnes[0], LOW);
    
    digitalWrite(lignes[0], HIGH);
    digitalWrite(lignes[2], HIGH);
    digitalWrite(lignes[4], HIGH);
    digitalWrite(lignes[6], HIGH);
    digitalWrite(lignes[8], HIGH);   
}

On peut aussi animer le programme précédent en allumant et éteignant les LED de la diagonale les unes après les autres.

/*
 Ce programme met en oeuvre l'utilisation d'une matrice de LED. L'objectif est de découvrir le principe du balaiement en éclairant une après l'autre les LED de la diagonale
*/
 
const int nbLignes = 8;
const int lignes[nbLignes] = {2, 7, 19, 5, 13, 18, 12, 16};

const int nbColonnes = 8;
const int colonnes[nbColonnes] = {6, 11, 10, 3, 17, 4, 8, 9};

// Variables globales
int indiceColonneCourante = 0;

// représentation de l'image à dessiner
int pixels[8][8];


void setup() {
      for (int i = 0; i < nbColonnes; i++) {
          pinMode(colonnes[i], OUTPUT);  
          // Mettre les pins des colonnes à l'état haut pour éteindre toutes les led
          digitalWrite(colonnes[i], HIGH);    
      }
      
      for (int i = 0; i < nbLignes; i++) { 
          pinMode(lignes[i], OUTPUT);
      } 
     
      // initialisation de la matrice image
      for (int x = 0; x < nbColonnes; x++) {
          for (int y = 0; y < nbLignes; y++) {
              pixels[x][y] = 1;
          }
      }
}
 
void loop() {
    digitalWrite(colonnes[indiceColonneCourante], LOW);
    digitalWrite(lignes[indiceColonneCourante], HIGH);
    
    delay(200); 
    
    digitalWrite(lignes[indiceColonneCourante], LOW);
    digitalWrite(colonnes[indiceColonneCourante], HIGH);
    
    // Passer à la led suivante
    ++indiceColonneCourante;
  
    //Lorsque l'on dépasse le dernier indice possible, on retourne à 0
    if(indiceColonneCourante >= nbColonnes){
        indiceColonneCourante = 0;
    }
}

/*
 Ce programme met en oeuvre l'utilisation d'une matrice de LED. L'objectif est de découvrir le principe du balaiement en affichant une image colonne après colonne
*/

#define SPACE { \
    {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, 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} \
}

#define H { \
    {0, 1, 0, 0, 0, 0, 1, 0}, \
    {0, 1, 0, 0, 0, 0, 1, 0}, \
    {0, 1, 0, 0, 0, 0, 1, 0}, \
    {0, 1, 1, 1, 1, 1, 1, 0}, \
    {0, 1, 0, 0, 0, 0, 1, 0}, \
    {0, 1, 0, 0, 0, 0, 1, 0}, \
    {0, 1, 0, 0, 0, 0, 1, 0}, \
    {0, 1, 0, 0, 0, 0, 1, 0}  \
}

#define E  { \
    {0, 1, 1, 1, 1, 1, 1, 0}, \
    {0, 1, 0, 0, 0, 0, 0, 0}, \
    {0, 1, 0, 0, 0, 0, 0, 0}, \
    {0, 1, 1, 1, 1, 1, 1, 0}, \
    {0, 1, 0, 0, 0, 0, 0, 0}, \
    {0, 1, 0, 0, 0, 0, 0, 0}, \
    {0, 1, 0, 0, 0, 0, 0, 0}, \
    {0, 1, 1, 1, 1, 1, 1, 0}  \
}

#define L { \
    {0, 1, 0, 0, 0, 0, 0, 0}, \
    {0, 1, 0, 0, 0, 0, 0, 0}, \
    {0, 1, 0, 0, 0, 0, 0, 0}, \
    {0, 1, 0, 0, 0, 0, 0, 0}, \
    {0, 1, 0, 0, 0, 0, 0, 0}, \
    {0, 1, 0, 0, 0, 0, 0, 0}, \
    {0, 1, 0, 0, 0, 0, 0, 0}, \
    {0, 1, 1, 1, 1, 1, 1, 0}  \
}

#define O { \
    {0, 0, 0, 1, 1, 0, 0, 0}, \
    {0, 0, 1, 0, 0, 1, 0, 0}, \
    {0, 1, 0, 0, 0, 0, 1, 0}, \
    {0, 1, 0, 0, 0, 0, 1, 0}, \
    {0, 1, 0, 0, 0, 0, 1, 0}, \
    {0, 1, 0, 0, 0, 0, 1, 0}, \
    {0, 0, 1, 0, 0, 1, 0, 0}, \
    {0, 0, 0, 1, 1, 0, 0, 0}  \
}

#define SMILEY { \
    {0, 0, 1, 1, 1, 1, 0, 0}, \
    {0, 1, 0, 0, 0, 0, 1, 0}, \
    {1, 0, 1, 0, 0, 1, 0, 1}, \
    {1, 0, 0, 0, 0, 0, 0, 1}, \
    {1, 0, 1, 1, 1, 1, 0, 1}, \
    {1, 0, 0, 1, 1, 0, 0, 1}, \
    {0, 1, 0, 0, 0, 0, 1, 0}, \
    {0, 0, 1, 1, 1, 1, 0, 0}  \
}



const int nbLignes = 8;
const int lignes[nbLignes] = {2, 7, 19, 5, 13, 18, 12, 16};

const int nbColonnes = 8;
const int colonnes[nbColonnes] = {6, 11, 10, 3, 17, 4, 8, 9};

// Variables globales
int indiceColonneCourante = 0;

// représentation de l'image à dessiner
int pixels[8][8] = SMILEY;

void afficherColonne(int indiceColonne, int delai){
    
    digitalWrite(colonnes[indiceColonne], LOW);//Activation de la colonne à afficher
    
    for (int i = 0; i < nbLignes; ++i) {
        digitalWrite(lignes[i], pixels[i][indiceColonne]);
    }

    delay(delai);

    for (int i = 0; i < nbLignes; ++i) {
        digitalWrite(lignes[i], LOW);
    }
    
    digitalWrite(colonnes[indiceColonne], HIGH); //Désactivation de la colonne à afficher
    
}


void setup() {
      for (int i = 0; i < nbColonnes; ++i) {
          pinMode(colonnes[i], OUTPUT);  
          // Mettre les pins des colonnes à l'état haut pour éteindre toutes les led
          digitalWrite(colonnes[i], HIGH);    
      }
      
      for (int i = 0; i < nbLignes; ++i) { 
          pinMode(lignes[i], OUTPUT);
      } 
}
 
void loop() {
    afficherColonne(indiceColonneCourante, 2);
    
    // Passer à la led suivante
    ++indiceColonneCourante;
  
    //Lorsque l'on dépasse le dernier indice possible, on retourne à 0
    if(indiceColonneCourante >= nbColonnes){
        indiceColonneCourante = 0;
    }
}

/*
 Ce programme met en oeuvre l'utilisation d'une matrice de LED. L'objectif est de découvrir le principe du balaiement en éclairant une après l'autre les LED de la diagonale
*/

#define SPACE { \
    {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, 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} \
}

#define H { \
    {0, 1, 0, 0, 0, 0, 1, 0}, \
    {0, 1, 0, 0, 0, 0, 1, 0}, \
    {0, 1, 0, 0, 0, 0, 1, 0}, \
    {0, 1, 1, 1, 1, 1, 1, 0}, \
    {0, 1, 0, 0, 0, 0, 1, 0}, \
    {0, 1, 0, 0, 0, 0, 1, 0}, \
    {0, 1, 0, 0, 0, 0, 1, 0}, \
    {0, 1, 0, 0, 0, 0, 1, 0}  \
}

#define E  { \
    {0, 1, 1, 1, 1, 1, 1, 0}, \
    {0, 1, 0, 0, 0, 0, 0, 0}, \
    {0, 1, 0, 0, 0, 0, 0, 0}, \
    {0, 1, 1, 1, 1, 1, 1, 0}, \
    {0, 1, 0, 0, 0, 0, 0, 0}, \
    {0, 1, 0, 0, 0, 0, 0, 0}, \
    {0, 1, 0, 0, 0, 0, 0, 0}, \
    {0, 1, 1, 1, 1, 1, 1, 0}  \
}

#define L { \
    {0, 1, 0, 0, 0, 0, 0, 0}, \
    {0, 1, 0, 0, 0, 0, 0, 0}, \
    {0, 1, 0, 0, 0, 0, 0, 0}, \
    {0, 1, 0, 0, 0, 0, 0, 0}, \
    {0, 1, 0, 0, 0, 0, 0, 0}, \
    {0, 1, 0, 0, 0, 0, 0, 0}, \
    {0, 1, 0, 0, 0, 0, 0, 0}, \
    {0, 1, 1, 1, 1, 1, 1, 0}  \
}

#define O { \
    {0, 0, 0, 1, 1, 0, 0, 0}, \
    {0, 0, 1, 0, 0, 1, 0, 0}, \
    {0, 1, 0, 0, 0, 0, 1, 0}, \
    {0, 1, 0, 0, 0, 0, 1, 0}, \
    {0, 1, 0, 0, 0, 0, 1, 0}, \
    {0, 1, 0, 0, 0, 0, 1, 0}, \
    {0, 0, 1, 0, 0, 1, 0, 0}, \
    {0, 0, 0, 1, 1, 0, 0, 0}  \
}

#define SMILEY { \
    {0, 0, 1, 1, 1, 1, 0, 0}, \
    {0, 1, 0, 0, 0, 0, 1, 0}, \
    {1, 0, 1, 0, 0, 1, 0, 1}, \
    {1, 0, 0, 0, 0, 0, 0, 1}, \
    {1, 0, 1, 1, 1, 1, 0, 1}, \
    {1, 0, 0, 1, 1, 0, 0, 1}, \
    {0, 1, 0, 0, 0, 0, 1, 0}, \
    {0, 0, 1, 1, 1, 1, 0, 0}  \
}



const int nbLignes = 8;
const int lignes[nbLignes] = {2, 7, 19, 5, 13, 18, 12, 16};

const int nbColonnes = 8;
const int colonnes[nbColonnes] = {6, 11, 10, 3, 17, 4, 8, 9};

// Variables globales
int indiceColonneCourante = 0;

const int nbPatterns = 8;
int patterns[nbPatterns][8][8] = {
  H,E,L,L,O,SPACE, SMILEY, SPACE
};

int pattern = 0;
int debutPattern;


void afficherColonne(int indiceColonne, int delai){
    
    digitalWrite(colonnes[indiceColonne], LOW);//Activation de la colonne à afficher
    
    for (int i = 0; i < nbLignes; ++i) {
        digitalWrite(lignes[i], patterns[pattern][i][indiceColonne]);
    }

    delay(delai);

    for (int i = 0; i < nbLignes; ++i) {
        digitalWrite(lignes[i], LOW);
    }
    
    digitalWrite(colonnes[indiceColonne], HIGH); //Désactivation de la colonne à afficher
    
}


void setup() {
      for (int i = 0; i < nbColonnes; ++i) {
          pinMode(colonnes[i], OUTPUT);  
          // Mettre les pins des colonnes à l'état haut pour éteindre toutes les led
          digitalWrite(colonnes[i], HIGH);    
      }
      
      for (int i = 0; i < nbLignes; ++i) { 
          pinMode(lignes[i], OUTPUT);
      } 
      
      debutPattern = millis();
}
 
void loop() {
    afficherColonne(indiceColonneCourante, 2);
    
    // Passer à la led suivante
    ++indiceColonneCourante;
  
    //Lorsque l'on dépasse le dernier indice possible, on retourne à 0
    if(indiceColonneCourante >= nbColonnes){
        indiceColonneCourante = 0;
        int finPattern = millis();
        if(finPattern - debutPattern > 1000 || debutPattern > finPattern){
            pattern = (pattern + 1)% nbPatterns;
            debutPattern = finPattern;
        }
    }
}

Matrice de LED

Matériel

Principe

Programme

Menu de navigation

Outils personnels

Espaces de noms

Variantes

Affichages

Plus

Rechercher

Navigation

Site Web

Wiki

Outils