Pages: [1]   Go Down
Author Topic: Matrice de led  (Read 1218 times)
0 Members and 1 Guest are viewing this topic.
0
Offline Offline
Newbie
*
Karma: 0
Posts: 30
Arduino rocks
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Bonjour,

J'essaie de faire une matrice de led de 11 * 11 led blanche en démultiplexage en suivant ce schéma :
http://www.arduino.cc/playground/Main/MAX72XXHardware

J'ai vu sur certain schéma qu'il faut placer des condensateurs d'un côté et des resistances de l'autre, dans certain cas il n'y a rien, j'ai un peu de mal à comprendre
es-ce que quelqu'un peut m'aider sur ce point et me dire ce que je dois faire.

Merci d'avance

Francki
Logged

0
Offline Offline
Newbie
*
Karma: 0
Posts: 3
Arduino rocks
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Si tu alimentes en 5 V tes 11 LED (3.8 V) à mon sens tu n'as pas pas besoin de resistance.

Pour les condensateurs, comme toujours cela dépend du nombre de LED allumés en même temps.

Tiens nous au courant de ton projet.
CPHIL33
Logged

0
Offline Offline
Newbie
*
Karma: 0
Posts: 30
Arduino rocks
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Merci pour ces infos, pour les led, je vais quand même mettre une resistance qui d'aprés ce que j'ai lu doit ce calculer avec la valeur d'une seule led.

Maintenant, je suis en train de brancher des 74HC595.

En fait je m'appuie sur les projets 16 et 17 de la doc Eathshine design et sur le tuto shiftout de arduino.cc.

Mais je pense qu'il y a deux facons de faire mon branchement :
  - Soit je duplique deux fois le projet 16 (=tuto shiftout de arduino.cc), ce qui me fait utiliser 6 I/O de l'arduino, 3 pour les lignes et 3 pour les colonnes
  - soit je fais un mix des 2 projets et je mets 3 (8*3 suffisant pour gérer mes 22 leds) 74HC595 en série.

Il me semble que la deuxième solution va complexifier la programmation derrière, es-ce que quelqu'un peut m'aider?

Merci

Francki
Logged

0
Offline Offline
Newbie
*
Karma: 0
Posts: 30
Arduino rocks
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Bonjour,

Je fais donc des essais et je ne m'en sort pas trop, voir pas du tout.

J'ai branché 4 shiftRegister 74 HC595 en série :
  - les 16 premiers bits serviront pour controler mes 11 lignes (5 pates du deuxième 74HC595 ne sont pas branchées)
  - les 16 suivants pour les 11 colonnes (idem 5 bits ne serviront pas)

Ca c'est la cible, pour faire un test j'ai branché mes 4 registres sur une matrice 2 * 2.
Le principe il me semble est de pousser les bits les uns après les autres pour remplir dans mon cas les 32 bytes de mes 4 registres.

J'aimerais savoir si je pars bien ou bien si je suis en train de me compliquer la vie.

En tout cas, je n'arrive pas à trouver d'info et je ne sais plus quoi faire.

Quelqu'un peut-il m'orienter?

Francki
Logged

0
Offline Offline
Newbie
*
Karma: 0
Posts: 30
Arduino rocks
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Bonjour,

Donc j'ai avancé mais là j'ai un problème de code.

J'ai donc fait une matrice de 16*16.
J'ai mis 4 shift Register 74HC595 en série, les deux premiers sont brancher sur les sorties + de la matrice et les deux suivants sur la sortie -.

Mon code consiste à envoyer 4 octets par boucle :
 - Les deux premiers injectés étant le masque permettant de balayer les colonnes.
 - Les deux suivants injectés étant la lecture de la matrice fait en binaire et pas en hexa.

J'ai fait du pas à pas pour contrôler tout ca, pour moi c'est ok mais ca ne fonctionne pas, je n'arrive pas à allumer ce que je veux.

Voila le code :
Code:
#include <TimerOne.h>
#include <stdio.h>

//Pin connected to Pin 12 of 74HC595 (Latch)
int latchPin = 8;
//Pin connected to Pin 11 of 74HC595 (Clock)
int clockPin = 12;
//Pin connected to Pin 14 of 74HC595 (Data)
int dataPin = 11;

uint8_t myMatrice[32];

long counter1 = 0;
long counter2 = 0;

void setup()
{
          Serial.begin(9600) ;

      //set pins to output
      pinMode(latchPin, OUTPUT);
      pinMode(clockPin, OUTPUT);
      pinMode(dataPin, OUTPUT);

      myMatrice[31]  = B00000000; myMatrice[30]  = B00000000;
      myMatrice[29]  = B00000000; myMatrice[28]  = B00000000;
      myMatrice[27]  = B00000000; myMatrice[26]  = B00000000;
      myMatrice[25]  = B00000000; myMatrice[24]  = B00000000;
      myMatrice[23]  = B00000000; myMatrice[22]  = B00000000;
      myMatrice[21]  = B00000000; myMatrice[20]  = B00000000;
      myMatrice[19]  = B00000000; myMatrice[18]  = B00000000;
      myMatrice[17]  = B00000000; myMatrice[16]  = B00000000;

      myMatrice[15] = B00000000; myMatrice[14] = B00000000;
      myMatrice[13] = B00000000; myMatrice[12] = B00000000;
      myMatrice[11] = B00000000; myMatrice[10] = B00000000;
      myMatrice[9]  = B00000000; myMatrice[8]  = B00000000;
      myMatrice[7]  = B00000000; myMatrice[6]  = B00000000;
      myMatrice[5]  = B00000000; myMatrice[4]  = B00000000;
      myMatrice[3]  = B00000000; myMatrice[2]  = B00000000;
      myMatrice[1]  = B00000000; myMatrice[0]  = B00000000;

        Timer1.initialize(1000);
        Timer1.attachInterrupt(screenUpdate);
}

void loop()
{
  
}

void screenUpdate()
{
  uint8_t myRow1 = B00000001;
  uint8_t myRow2 = B00000001;

  int j = 0;
  boolean passe = false;
  for( byte k = 0; k < 16; k++)
  {
    //Serial.print("k : ");Serial.println(k,BIN);
    digitalWrite(latchPin, LOW);
    if( (k < 8)) {
      shiftIt(~myRow1);
      shiftIt(B00000000);
      //Serial.print("shift 1 : ");Serial.println(B00000000,BIN);      
      //Serial.print("shift 2 : ");Serial.println(~myRow1,BIN);      
    } else {
      shiftIt(B00000000);
      shiftIt(~myRow2);
      //Serial.print("shift 1 : ");Serial.println(~myRow2,BIN);
      //Serial.print("shift 2 : ");Serial.println(B00000000,BIN);
    }

    //Serial.print("shift 3 : ");Serial.println(j);
    //Serial.print("shift 3 : ");Serial.println(j+1);
    
    shiftIt(myMatrice[j]);
    shiftIt(myMatrice[j+1]);
    digitalWrite(latchPin, HIGH);
    myRow1 = myRow1 << 1;
    if( (k >= 8)) {
      myRow2 = myRow2 << 1;
    }

    j = j+2;
    
    //delay(5000);
  }

}

void shiftIt(byte dataOut)
{
      // Shift out 8 bits LSB first,
      // on rising edge of clock
      boolean pinState;
      
      //clear shift register read for sending data
      digitalWrite(dataPin, LOW);
      digitalWrite(clockPin, LOW);
      
      // for each bit in dataOut send out a bit
      for (int i=0; i<8; i++)
      {
            //set clockPin to LOW prior to sending bit
            digitalWrite(clockPin, LOW);
            
            // if the value of DataOut and (logical AND) a bitmask
            // are true, set pinState to 1 (HIGH)
            if ( dataOut & (1<<i) )
            {pinState = HIGH;}
            else
            //{!pinState = LOW;}
            {pinState = LOW;}

            //sets dataPin to HIGH or LOW depending on pinState
            digitalWrite(dataPin, pinState);
            
            //send bit out on rising edge of clock
            digitalWrite(clockPin, HIGH);
            digitalWrite(dataPin, LOW);
      }
      //stop shifting
      digitalWrite(clockPin, LOW);
}
Logged

0
Offline Offline
Newbie
*
Karma: 0
Posts: 30
Arduino rocks
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Hello,

Donc voila j'ai avancé, j'ai finalement codé ca en Hexa pour gérer une matrice de 16*16 avec 4 shift register en serie et le code est le suivant :

Code:
#include <TimerOne.h>
#include <stdio.h>

int latchPin = 8;
int clockPin = 12;
int dataPin = 11;

boolean myDebug = false;

uint16_t myMatrice[16] = {0x0000, 0x0000, 0x0000, 0x0000,
                    0x0000, 0x0000, 0x0000, 0x0040,
                    0x0000, 0x0000, 0x0000, 0x0000,
                    0x0000, 0x0000, 0x0000, 0x0000};

void setup()
{
        Serial.begin(9600) ;

      pinMode(latchPin, OUTPUT);
      pinMode(clockPin, OUTPUT);
      pinMode(dataPin, OUTPUT);

        myDebug = false;
      Timer1.initialize(500);
      Timer1.attachInterrupt(screenUpdate);
        
}

void loop()
{
  if(myDebug){
  screenUpdate();
  delay(10000);
  }
}

void screenUpdate()
{
  uint16_t myRow = 0x0001;

  for( uint16_t k = 0; k < 16; k++)
  {
      digitalWrite(latchPin, LOW);

        if(myDebug){Serial.print("k : ");Serial.println(k);}
      shiftIt(~myRow);
        if(myDebug){Serial.print("shift 4 et 3 : ");Serial.println(~myRow,BIN);}
      shiftIt(myMatrice[k]);

        if(myDebug){
        Serial.print("shift 2 et 1 : ");Serial.println(myMatrice[k],BIN);
        delay(500);
        }

      digitalWrite(latchPin, HIGH);

      myRow = myRow << 1;
  }
}

void shiftIt(uint16_t dataOut)
{
      // Shift out 8 bits LSB first, on rising edge of clock
      boolean pinState;

      //clear shift register read for sending data
      digitalWrite(dataPin, LOW);

      // for each bit in dataOut send out a bit
      for (int i=0; i<16; i++)
      {
            //set clockPin to LOW prior to sending bit
            digitalWrite(clockPin, LOW);

            // if the value of DataOut and (logical AND) a bitmask are true, set pinState to 1 (HIGH)
            if ( dataOut & (1<<i) )
                  {pinState = HIGH;}
            else
                  {pinState = LOW;}

            //sets dataPin to HIGH or LOW depending on pinState
            digitalWrite(dataPin, pinState);

            //send bit out on rising edge of clock
            digitalWrite(clockPin, HIGH);
            digitalWrite(dataPin, LOW);
      }
      //stop shifting
      digitalWrite(clockPin, LOW);

}

void setMatrice1(int* myMat)
{
      myMat[15]  = 0x0000; //B 1100 0000 0000 0000
      myMat[14]  = 0x4000; //B 0100 0000 0000 0000
      myMat[13]  = 0x0000; //B 0000 0000 0000 0000
      myMat[12]  = 0x0000; //B 0000 0000 0000 0000
      myMat[11]  = 0x0000; //B 0000 0000 0000 0000
      myMat[10]  = 0x0000; //B 0000 0000 0000 0000
      myMat[9]   = 0x0000; //B 0000 0000 0000 0000
      myMat[8]   = 0x0000; //B 0000 0000 0000 0000

      myMat[7]   = 0xC000; //B 0000 0000 0000 0000
      myMat[6]   = 0x0000; //B 0000 0000 0000 0000
      myMat[5]   = 0x0000; //B 0000 0000 0000 0000
      myMat[4]   = 0x0000; //B 0000 0000 0000 0000
      myMat[3]   = 0x0000; //B 0000 0000 0000 0000
      myMat[2]   = 0x0000; //B 0000 0000 0000 0000
      myMat[1]   = 0x0000; //B 0000 0000 0000 0000
      myMat[0]   = 0x0000; //B 0000 0000 0000 0000

}


Par contre, étant débutant j'ai besoin d'aide sur les branchements.
EN sachant que ma matrice fait 11*10 led blanches.
Je dois brancher :
  - des resistances sur le + des leds
  - des transistors sur le -  des leds pour gérer la luminosité

Je n'arrive pas à calculer tout ca, je me mélange avec tous les paramétres à prendre en compte, es-ce que quelqu'un peut m'aider.

Je suis en 5V mais :
  1 - Tout est relié à une seule sortie de l'arduino qui est connecté à 4 shift register, donc je n'arrive pas à savoir le voltage et ampérage qui sort.
  2 - Sur une matrice en multiplexage, je ne sais pas si je dois calculer ma resistance avec une led ou toute la ligne
  3 - Pour les transistors même problème je ne sais pas quoi prendre.

Merci de votre aide

Francki
Logged

Pages: [1]   Go Up
Jump to: