Répondre à la discussion
Affichage des résultats 1 à 6 sur 6

Problème de liaison entre deux Circuits intégrés



  1. #1
    INFINITY100

    Question Problème de liaison entre deux Circuits intégrés


    ------

    BONSOIR mes amis

    Comme vous le voyez, ici j'ai un schéma d'un panneau d'affichage LED contrôlé par Bluetooth pour une dimension de 48x10 (Voir IMAGE 01), sauf que je voudrai faire un autre panneau pour une dimension de 48x20 basé sur le même principe. Seulement j'arrive pas à trouver la bonne liaison entre (Circuit intégré CD4017 A) et le (Circuit intégré CD4017 B) comme indiqué dans l'image (Voir IMAGE 02).

    Donc voila si quelqu'un peut m'aider il sera d'une grande gentillesse

    IMAGE 01

    Pièce jointe 449163


    IMAGE 02

    Pièce jointe 449164


    Je vous fais savoir que les éléments nécessaires à la fabrication de ce panneau LED d'affichage d'un texte sont :

    1) Arduino NANO (Rév 3.0)
    2) Module Bluetooth HC-05
    3) Circuit intégré CI 74HC595
    4) Circuit intégré CD4017
    5) Transistor 2N3904
    6) Résistances de 100 ohms
    7) Résistances 1k ohm
    8) Résistances de 220 ohms


    Merci beaucoup

    -----

  2. Publicité
  3. 📣 Nouveau projet éditorial de Futura
    🔥🧠 Le Mag Futura est lancé, découvrez notre 1er magazine papier

    Une belle revue de plus de 200 pages et 4 dossiers scientifiques pour tout comprendre à la science qui fera le futur. Nous avons besoin de vous 🙏 pour nous aider à le lancer...

    👉 Je découvre le projet

    Quatre questions à explorer en 2022 :
    → Quels mystères nous cache encore la Lune 🌙 ?
    → Pourra-t-on bientôt tout guérir grâce aux gènes 👩‍⚕️?
    → Comment nourrir le monde sans le détruire 🌍 ?
    → L’intelligence artificielle peut-elle devenir vraiment intelligente 🤖 ?
  4. #2
    sar0

    Re : Problème de liaison entre deux Circuits intégrés

    impossible de voir ton schema.
    desole.

  5. #3
    INFINITY100

    Re : Problème de liaison entre deux Circuits intégrés

    Voici les images en pièce jointe
    Images attachées Images attachées

  6. #4
    carcan

    Re : Problème de liaison entre deux Circuits intégrés

    Hello !

    ton 2e 4017 doit avoir ses pin CLK et Reset reliées vers 2 sorties inutilisées du MCU (par exemple D6 et D7), MAIS ce n'est pas tout, il faut aussi que les bornes EN des 4017 ne soient plus mises à la masse (= tout le temps actif), mais gérées par le MCU.
    Raison : le 4017 a toujours une sortie active (Q0 après ou pendant un Reset) ... et tu ne peux pas avoir 2 colonnes actives dans ton cas --> donc les 2 EN devront aller vers 2 autres pin libres du MCU (ou 1 pin + un inverseur sur un des 2 4017).

    Après, il y aura un petit peu d'adaptation du code

    A+
    LAurent

  7. A voir en vidéo sur Futura
  8. #5
    INFINITY100

    Re : Problème de liaison entre deux Circuits intégrés

    Merci pour le fil

    Donc en image j'aurai ceci (voir image jointe)
    Images attachées Images attachées  

  9. #6
    INFINITY100

    Re : Problème de liaison entre deux Circuits intégrés

    et pour mon code Arduino je devrai changer quoi ?

    Code PHP:
    #define BA {B01110000,B10001000,B10001000,B11111000,B10001000,B10001000}
    #define BB {B11110000,B10001000,B10001000,B11110000,B10001000,B11111000}
    #define BC {B11111000,B10000000,B10000000,B10000000,B10000000,B11111000}
    #define BD {B11110000,B10001000,B10001000,B10001000,B10001000,B11110000}
    #define BE {B11111000,B10000000,B10000000,B11110000,B10000000,B11111000}
    #define BF {B11111000,B10000000,B10000000,B11110000,B10000000,B10000000}
    #define BG {B01110000,B10001000,B10000000,B10011000,B10001000,B01110000}
    #define BH {B10001000,B10001000,B11111000,B10001000,B10001000,B10001000}
    #define BI {B11111000,B00100000,B00100000,B00100000,B00100000,B11111000}
    #define BJ {B00111000,B00010000,B00010000,B00010000,B10010000,B01100000}
    #define BM {B10001000,B11011000,B10101000,B10101000,B10001000,B10001000}
    #define BN {B10001000,B11001000,B10101000,B10101000,B10011000,B10001000}
    #define BL {B10000000,B10000000,B10000000,B10000000,B10000000,B11111000}
    #define BO {B01110000,B10001000,B10001000,B10001000,B10001000,B01110000}
    #define BP {B11110000,B10001000,B10001000,B11110000,B10000000,B10000000}
    #define BQ {B01110000,B10001000,B10101000,B10011000,B01111000,B00001000}
    #define BR {B11110000,B10001000,B10001000,B11110000,B10001000,B10001000}
    #define BS {B01110000,B10001000,B01100000,B00010000,B10001000,B01110000}
    #define BK {B10001000,B10010000,B11100000,B11100000,B10010000,B10001000}
    #define BT {B11111000,B00100000,B00100000,B00100000,B00100000,B00100000}
    #define BU {B10001000,B10001000,B10001000,B10001000,B10001000,B01110000}
    #define BV {B10001000,B10001000,B10001000,B10001000,B01010000,B00100000}
    #define BW {B10001000,B10001000,B10101000,B10101000,B10101000,B01010000}
    #define BX {B10001000,B01010000,B00100000,B00100000,B01010000,B10001000}
    #define BY {B10001000,B01010000,B00100000,B00100000,B00100000,B00100000}
    #define BZ {B11111000,B00001000,B00110000,B01100000,B10000000,B11111000}
    #define LA{B00000000,B01110000,B00001000,B01111000,B10001000,B01111000}
    #define LB{B10000000,B10000000,B10110000,B11001000,B10001000,B11110000}
    #define LC{B00000000,B01110000,B10000000,B10000000,B10001000,B01110000}
    #define LD{B00001000,B00001000,B01111000,B10001000,B10001000,B01111000}
    #define LE{B00000000,B01110000,B10001000,B11111000,B10000000,B01110000}
    #define LF{B00110000,B01001000,B01000000,B11100000,B01000000,B01000000}
    #define LG{B00000000,B01111000,B10001000,B01111000,B00001000,B01110000}
    #define LH{B10000000,B10000000,B10110000,B11001000,B10001000,B10001000}
    #define LI{B00100000,B00000000,B01100000,B00100000,B00100000,B01111000}
    #define LJ{B00010000,B00000000,B00111000,B00010000,B10010000,B01100000}
    #define LK{B10000000,B10010000,B10100000,B11000000,B10100000,B10010000}
    #define LL{B01100000,B00100000,B00100000,B00100000,B00100000,B01111000}
    #define LM{B00000000,B00000000,B11010000,B10101000,B10101000,B10001000}
    #define LN{B00000000,B00000000,B10110000,B11001000,B10001000,B10001000}
    #define LO{B00000000,B01110000,B10001000,B10001000,B10001000,B01110000}
    #define LP{B00000000,B11110000,B10001000,B11110000,B10000000,B10000000}
    #define LQ{B00000000,B01101000,B10011000,B01111000,B00001000,B00001000}
    #define LR{B00000000,B00000000,B10110000,B11001000,B10000000,B10000000}
    #define LS{B00000000,B01110000,B10000000,B01110000,B00001000,B11110000}
    #define LT{B01000000,B01000000,B11100000,B01000000,B01001000,B00110000}
    #define LU{B00000000,B00000000,B10001000,B10001000,B10011000,B01101000}
    #define LV{B00000000,B00000000,B10001000,B10001000,B01010000,B00100000}
    #define LW{B00000000,B00000000,B10001000,B10101000,B10101000,B01010000}
    #define LX{B00000000,B10001000,B01010000,B00100000,B01010000,B10001000}
    #define LY{B00000000,B10001000,B10001000,B01111000,B00001000,B01110000}
    #define LZ{B00000000,B11111000,B00010000,B00100000,B01000000,B11111000}
    #define SPACE{B00000000,B00000000,B00000000,B00000000,B00000000,B00000000}
    #define NUM0{B01110000,B10011000,B10101000,B10101000,B11001000,B01110000}
    #define NUM1{B00100000,B01100000,B10100000,B00100000,B00100000,B01110000}
    #define NUM2{B01110000,B10001000,B00001000,B01110000,B10000000,B11111000}
    #define NUM3{B11110000,B00001000,B00001000,B01111000,B00001000,B11110000}
    #define NUM4{B10001000,B10001000,B10001000,B11111000,B00001000,B00001000}
    #define NUM5{B11111000,B10000000,B11110000,B00001000,B10001000,B01110000}
    #define NUM6{B11111000,B10000000,B11111000,B10001000,B10001000,B11111000}
    #define NUM7{B11111000,B00001000,B00001000,B01111000,B00001000,B00001000}
    #define NUM8{B11111000,B10001000,B11111000,B10001000,B10001000,B11111000}
    #define NUM9{B11111000,B10001000,B11111000,B00001000,B00001000,B11111000}
    #define DEVIDE{B00001000,B00010000,B00100000,B00100000,B01000000,B10000000}
    #define TWODOTS{B01100000,B01100000,B00000000,B00000000,B01100000,B01100000}
    #define DOT{B00000000,B00000000,B00000000,B00000000,B01100000,B01100000}
    #define COMA{B00000000,B00000000,B00000000,B00110000,B00110000,B01100000}
    #define LINE{B00000000,B00000000,B11111000,B11111000,B00000000,B00000000}
    #define QUASTION{B01110000,B10001000,B00010000,B00100000,B00000000,B00100000}
    #define MARK{B00100000,B01110000,B01110000,B00100000,B00000000,B00100000}

    int latchPin 10;
    int clockPin 13;
    int dataPin 11;
    int clock 9;
    int Reset 8;
    int latchPinPORTB latchPin 8;
    int clockPinPORTB clockPin 8;
    int dataPinPORTB dataPin 8;
    int i 0;
    int incomingByte[44];
    long scrolling_word[6];
    int array_turn=0;
    byte patterns[100][6];
    byte dummy_array[70][6] ={BA,BB,BC,BD,BE,BF,BG,BH,BI,BJ,BK,BL,BM,BN,BO,BP,BQ,BR,BS,BT,BU,BV,BW,BX,BY,BZ,SPACE,NUM0,NUM1,NUM2,NUM3,NUM4,NUM5,NUM6,NUM7,NUM8,NUM9,DEVIDE,TWODOTS,DOT,COMA,LINE,QUASTION,MARK,LA,LB,LC,LD,LE,LF,LG,LH,LI,LJ,LK,LL,LM,LN,LO,LP,LQ,LR,LS,LT,LU,LV,LW,LX,LY,LZ};
    void setup(){
      
    Serial.begin(9600);
      
    pinMode(dataPin,OUTPUT);
      
    pinMode(clockPin,OUTPUT);
      
    pinMode(latchPin,OUTPUT);
      
    pinMode(clock,OUTPUT);
      
    pinMode(Reset,OUTPUT);
      
    digitalWrite(Reset,HIGH);
      
    digitalWrite(Reset,LOW);
      
    setupSPI();
    }

    void display_word(int loops,byte word_print[][6],int num_patterns,int delay_langth){// this function displays your symbols
      
    0;// resets the counter fot the 4017
      
    for(int g=0;g<6;g++)//resets the the long int where your word goes
        
    scrolling_word[g] = 0;
      for(
    int x=0;x<num_patterns;x++){//main loop, goes over your symbols
       // you will need to find a better way to make the symbols scroll my way is limited for 24 columns

       
    for(int r=0;r<6;r++)//puts the buildes the first symbol
          
    scrolling_word[r] |= word_print[x][r]; 
        for (
    int z=0;z<6;z++){//the sctolling action
            
    for(int p=0;p<6;p++)
              
    scrolling_word[p] = scrolling_word[p] << 1;
    // end of the scrolling funcion
          
    for(int t=0;t<delay_langth;t++){// delay function, it just loops over the same display
            
    for(int y=0;y<6;y++){// scaning the display
              
    if(== 6){// counting up to 6 with the 4017
                
    digitalWrite(Reset,HIGH);
                
    digitalWrite(Reset,LOW);
                
    0;
              }
              
    latchOff();
              
    spi_transfer(make_word(0x01000000,y));// sending the data
              
    spi_transfer(make_word(0x00010000,y));
              
    spi_transfer(make_word(0x00000100,y));
              
    latchOn();
              
    delayMicroseconds(800);//waiting a bit
              
    latchOff();
              
    spi_transfer(0);// clearing the data
              
    spi_transfer(0);
              
    spi_transfer(0);
              
    latchOn();
              
    digitalWrite(clock,HIGH);//counting up with the 4017
              
    digitalWrite(clock,LOW);
              
    i++;
            }
          }
        }
      }
      
    finish_scroll(delay_langth);
    }

    void finish_scroll(int delay_scroll){// this function is the same as the funcion above, it just finishing scrolling
      
    for (int n=0;n<24;n++){
            for(
    int h=0;h<6;h++)
              
    scrolling_word[h] = scrolling_word[h] << 1;
          for(
    int w=0;w<delay_scroll;w++){
            for(
    int k=0;k<6;k++){
              if(
    == 6){
                
    digitalWrite(Reset,HIGH);
                
    digitalWrite(Reset,LOW);
                
    0;
              }
              
    latchOff();
              
    spi_transfer(make_word(0x01000000,k));
              
    spi_transfer(make_word(0x00010000,k));
              
    spi_transfer(make_word(0x00000100,k));
              
    latchOn();
              
    delayMicroseconds(800);
              
    latchOff();
              
    spi_transfer(0);
              
    spi_transfer(0);
              
    spi_transfer(0);
              
    latchOn();
              
    digitalWrite(clock,HIGH);
              
    digitalWrite(clock,LOW);
              
    i++;
            }
          }
        }
    }

    byte make_word (long posistion,byte turn){
      
    byte dummy_word 0;
      for(
    int q=0;q<8;q++){
        if(
    scrolling_word[turn] & (posistion<<q))
          
    dummy_word |= 0x01<<q;
      }
      return 
    dummy_word;
    }   


      
    void loop() {

      
    // send data only when you receive data:
      
    if(Serial.available() > 0){
        
    delay(100);
        
    incomingByte[array_turn] = Serial.read();
                    
    array_turn++;
      }
               else{
                 if(
    array_turn != 0){ 
                   for(
    int az=0;az<array_turn;az++){
                     if((
    incomingByte[az] > 64 && incomingByte[az] < 91) || (incomingByte[az] > 96 && incomingByte[az] < 123)){
                      if(
    incomingByte[az] > 64 && incomingByte[az] < 91){
                       for(
    int lal=0;lal<6;lal++)                 
                     
    patterns[az][lal] = dummy_array[incomingByte[az] - 65][lal];
                   }
                   else{
                     for(
    int lal=0;lal<6;lal++)                 
                     
    patterns[az][lal] = dummy_array[incomingByte[az] - 53][lal];
                   }}
                   else{
                     switch(
    incomingByte[az]){
                    case 
    32://space
                     
    for(int lol=0;lol<6;lol++)                 
                     
    patterns[az][lol] = dummy_array[26][lol];
                     break;
                    case 
    33://mark
                     
    for(int lol=0;lol<6;lol++)                 
                     
    patterns[az][lol] = dummy_array[43][lol];
                     break;
                    case 
    45://line
                     
    for(int lol=0;lol<6;lol++)                 
                     
    patterns[az][lol] = dummy_array[41][lol];
                     break;                 
                     case 
    44://coma
                     
    for(int lol=0;lol<6;lol++)                 
                     
    patterns[az][lol] = dummy_array[40][lol];
                     break;
                     case 
    46://dot
                     
    for(int lol=0;lol<6;lol++)                 
                     
    patterns[az][lol] = dummy_array[39][lol];
                     break;
                     case 
    47://dvide
                     
    for(int lol=0;lol<6;lol++)                 
                     
    patterns[az][lol] = dummy_array[37][lol];
                     break;
                     case 
    48://0
                     
    for(int lol=0;lol<6;lol++)                 
                     
    patterns[az][lol] = dummy_array[27][lol];
                     break;
                     case 
    49://1
                     
    for(int lol=0;lol<6;lol++)                 
                     
    patterns[az][lol] = dummy_array[28][lol];
                     break;
                     case 
    50://2
                     
    for(int lol=0;lol<6;lol++)                 
                     
    patterns[az][lol] = dummy_array[29][lol];
                     break;
                     case 
    51://3
                     
    for(int lol=0;lol<6;lol++)                 
                     
    patterns[az][lol] = dummy_array[30][lol];
                     break;
                     case 
    52://4
                     
    for(int lol=0;lol<6;lol++)                 
                     
    patterns[az][lol] = dummy_array[31][lol];
                     break;
                     case 
    53://5
                     
    for(int lol=0;lol<6;lol++)                 
                     
    patterns[az][lol] = dummy_array[32][lol];
                     break;
                     case 
    54://6
                     
    for(int lol=0;lol<6;lol++)                 
                     
    patterns[az][lol] = dummy_array[33][lol];
                     break;
                     case 
    55://7
                     
    for(int lol=0;lol<6;lol++)                 
                     
    patterns[az][lol] = dummy_array[34][lol];
                     break;
                     case 
    56://8
                     
    for(int lol=0;lol<6;lol++)                 
                     
    patterns[az][lol] = dummy_array[35][lol];
                     break;
                     case 
    57://9
                     
    for(int lol=0;lol<6;lol++)                 
                     
    patterns[az][lol] = dummy_array[36][lol];
                     break;
                     case 
    58://tow dots
                     
    for(int lol=0;lol<6;lol++)                 
                     
    patterns[az][lol] = dummy_array[38][lol];
                     break;
                     case 
    63://quastion
                     
    for(int lol=0;lol<6;lol++)                 
                     
    patterns[az][lol] = dummy_array[42][lol];
                     break;
                     default:
                     for(
    int lol=0;lol<6;lol++)                 
                     
    patterns[az][lol] = dummy_array[26][lol];
                     break; 
                     }
                   }               
                 }
               }
              
    display_word(1,patterns,array_turn,15);
              
    array_turn =0
             } 
           }
      
      
    //display_word(1,patterns,43,15);// calls for the display_pattern function and says that int loop = 15(if you do more loop the pattern whould scrrol slower).

    void latchOn(){
      
    bitSet(PORTB,latchPinPORTB);
    }

    void latchOff(){
      
    bitClear(PORTB,latchPinPORTB);
    }


    void setupSPI(){
      
    byte clr;
      
    SPCR |= ( (1<<SPE) | (1<<MSTR) ); // enable SPI as master
      //SPCR |= ( (1<<SPR1) | (1<<SPR0) ); // set prescaler bits
      
    SPCR &= ~( (1<<SPR1) | (1<<SPR0) ); // clear prescaler bits
      
    clr=SPSR// clear SPI status reg
      
    clr=SPDR// clear SPI data reg
      
    SPSR |= (1<<SPI2X); // set prescaler bits
      //SPSR &= ~(1<<SPI2X); // clear prescaler bits

      
    delay(10);
    }
    byte spi_transfer(byte data)
    {
      
    SPDR data;        // Start the transmission
      
    while (!(SPSR & (1<<SPIF)))     // Wait the end of the transmission
      
    {
      };
      return 
    SPDR;        // return the received byte, we don't need that


  10. Publicité

Discussions similaires

  1. [Outils/Fab/Comp] Circuits integres
    Par JOTH dans le forum Électronique
    Réponses: 2
    Dernier message: 12/08/2016, 19h22
  2. connexion entre 2 circuits integres
    Par ahmedcssforever dans le forum Électronique
    Réponses: 17
    Dernier message: 18/08/2011, 16h16
  3. Circuits intégrés
    Par santaro dans le forum Électronique
    Réponses: 4
    Dernier message: 16/05/2011, 18h28
  4. probleme de documentation de mes circuits intégrés
    Par pogogrunge dans le forum Électronique
    Réponses: 3
    Dernier message: 18/05/2007, 19h48
  5. Réponses: 2
    Dernier message: 29/09/2006, 12h55
Découvrez nos comparatifs produits sur l'informatique et les technologies.