Utilisation d'un afficheur 7 segments avec décodeur BCD


Intro


Lorsque l'on ne possède pas de gros PIC avec beaucoup d'E/S comme les 16F877 par exemple, et que l'on à besoin d'utiliser un afficheur 7 segments, on fait appel à un décodeur BCD. En gros le décodeur BCD permet de ce passer de la moitié des E/S normalement utilisé par un afficheur, soit 4 E/S de libérer. Voici un lien vers la Datasheet du décodeur que j'utilise dans cet exemple: 74LS47. Ainsi vous comprendrez mieux son fonctionnement.

Schéma de câblage



La table de vérité



A7A6A5A4A3A2A1A0Chiffrehexa
0 0 0 0 0 0 0 0 0 0x00
0 0 0 0 0 0 0 1 1 0x01
0 0 0 0 0 0 1 0 2 0x02
0 0 0 0 0 0 1 1 3 0x03
0 0 0 0 0 1 0 0 4 0x04
0 0 0 0 0 1 0 1 5 0x05
0 0 0 0 0 1 1 0 6 0x06
0 0 0 0 0 1 1 1 7 0x07
0 0 0 0 1 0 0 0 8 0x08
0 0 0 0 1 0 0 1 9 0x09
0 0 0 0 1 0 1 0 erreur 0x0A

Une table bien plus simple que sans BCD non?

Un premier programme


  1.  
  2. #include <16f628A.h> //comme d'ab
  3. #use delay(clock=20000000) //comme d'ab
  4. #fuses HS, NOWDT, PUT, NOPROTECT, NOBROWNOUT, NOLVP, NOCPD //comme d'ab
  5. #define A pin_A0 // pin A BCD
  6. #define B pin_A1 // pin B BCD
  7. #define C pin_A2 // pin C BCD
  8. #define D pin_A3 // pin D BCD
  9. #define T1 pin_B0 // base transistor 1
  10. int i, H=0;
  11. void SEG7(int H);
  12.  
  13. void main()
  14. {
  15.    while(1)
  16.       {
  17.          output_low(T1);
  18.          for(i=0; i<=10; i++)
  19.             {
  20.                SEG7(i);
  21.                delay_ms(500);
  22.             }
  23.       }
  24. }
  25. void SEG7(int H)
  26. {
  27.         switch(H)
  28.                 {
  29.                         case 0: output_low(D);
  30.                                 output_low(C);
  31.                                 output_low(B);
  32.                                 output_low(A);
  33.                                 break;
  34.                         case 1: output_low(D);
  35.                                 output_low(C);
  36.                                 output_low(B);
  37.                                 output_high(A);
  38.                                 break;
  39.                         case 2: output_low(D);
  40.                                 output_low(C);
  41.                                 output_high(B);
  42.                                 output_low(A);
  43.                                 break;
  44.                         case 3: output_low(D);
  45.                                 output_low(C);
  46.                                 output_high(B);
  47.                                 output_high(A);
  48.                                 break;
  49.                         case 4: output_low(D);
  50.                                 output_high(C);
  51.                                 output_low(B);
  52.                                 output_low(A);
  53.                                 break;
  54.                         case 5: output_low(D);
  55.                                 output_high(C);
  56.                                 output_low(B);
  57.                                 output_high(A);
  58.                                 break;
  59.                         case 6: output_low(D);
  60.                                 output_high(C);
  61.                                 output_high(B);
  62.                                 output_low(A);
  63.                                         break;
  64.                         case 7: output_low(D);
  65.                                 output_high(C);
  66.                                 output_high(B);
  67.                                 output_high(A);
  68.                                 break;
  69.                         case 8: output_high(D);
  70.                                 output_low(C);
  71.                                 output_low(B);
  72.                                 output_low(A);
  73.                                 break;
  74.                         case 9: output_high(D);
  75.                                 output_low(C);
  76.                                 output_low(B);
  77.                                 output_high(A);
  78.                                 break;
  79.                         default:output_high(D);
  80.                                 output_low(C);
  81.                                 output_high(B);
  82.                                 output_low(A);
  83.                 }
  84. }
  85.  

Un deuxième programme


  1.  
  2. #include <16f628A.h> //comme d'ab
  3. #use delay(clock=20000000) //comme d'ab
  4. #fuses HS, NOWDT, PUT, NOPROTECT, NOBROWNOUT, NOLVP, NOCPD //comme d'ab
  5. #define A pin_A0 // pin A BCD
  6. #define B pin_A1 // pin B BCD
  7. #define C pin_A2 // pin C BCD
  8. #define D pin_A3 // pin D BCD
  9. #define T1 pin_B0 // base transistor 1
  10. int i, H=0;
  11. void SEG7(int H);
  12.  
  13. void main()
  14. {
  15.    while(1)
  16.       {
  17.          output_low(T1);
  18.          for(i=0; i<=10; i++)
  19.             {
  20.                SEG7(i);
  21.                delay_ms(500);
  22.             }
  23.       }
  24. }
  25. void SEG7(int H)
  26. {
  27.         switch(H)
  28.                 {
  29.                         case 0: output_a(0x00);
  30.                                 break;
  31.                         case 1: output_a(0x01);
  32.                                 break;
  33.                         case 2: output_a(0x02);
  34.                                 break;
  35.                         case 3: output_a(0x03);
  36.                                 break;
  37.                         case 4: output_a(0x04);
  38.                                 break;
  39.                         case 5: output_a(0x05);
  40.                                 break;
  41.                         case 6: output_a(0x06);
  42.                                 break;
  43.                         case 7: output_a(0x07);
  44.                                 break;
  45.                         case 8: output_a(0x08);
  46.                                 break;
  47.                         case 9: output_a(0x09);
  48.                                 break;
  49.                         default:output_a(0x0A);
  50.                 }
  51. }
  52.  

Explications


Bien, grâce au décodeur BCD la table de vérité et le programme sont beaucoup plus simple. Je n'ai pas commenter ce code tout simplement car il fait exactement la même chose que le code sans décodeur BCD, simplement il y a 4 E/S de moins à géré. Le premier programme est un exemple de ce que donnerais le code si on utilisais juste les fonction output_low() et output_high(), soit 40 ligne rien que pour la fonction SEG7. Le second, vous l'aurez compris nous montre l'intérêt de la fonction output_x() dans ce programme. Pour le reste il s'agit de la même chose que le programme sans décodeur BCD.

Le dossier


Je met à vôtre disposition un dossier compresser avec:

  • Le fichier source en .C

  • Tout les fichiers généré lors de la compilation (notamment le .hex utile à la simulation ou pour envoyer dans le PIC)

  • Le fichier de schéma fait sur proteus

  • La même capture d'écran qu'au dessus (pour le schéma de câblage)

  • Et la table de vérité sous excel


avec_bcd.rar

Bonne visite

Sugi

© robot-amateur.com - Tous droits réservés. Reproduction interdite sans autorisation.