Comment utiliser un affichage à 7 segments et 4 chiffres à anode commune?


9

Veuillez prendre cette question comme exemple pour (la mienne) répondre ci-dessous.

J'ai un écran LED à 7 segments et 4 chiffres, mais je n'ai aucune idée de la façon de le câbler.

Je ne comprends pas la différence entre une anode / cathode commune et je n'ai pas 2 broches par LED, ce qui est étrange. Tout récemment, une question sur une "anode commune à 4 segments à 7 segments" a été supprimée. À ce moment précis, je tapais une réponse.

Cependant, je veux toujours partager ma réponse avec vous, ou la personne qui l'a demandée. Veuillez vérifier / mettre à jour ma réponse avec plus d'informations. Plus précisément, quelqu'un pourrait-il ajouter du code de travail, je ne peux pas pour le moment.


Juste curieux. Avez-vous posté une question pour pouvoir y répondre?
PhillyNJ

Il y a en fait une option pour cela. Cependant, les commentaires dans ma question racontent également "l'histoire de fond". Je répondais à une question qui a été supprimée. Et j'ai néanmoins ressenti le besoin de poster ma réponse. Alors oui, je l'ai fait. Mais c'est une méthode valable et j'avais la réponse avant la question. Cela avait donc un sens pour moi. Si vous avez une très bonne question (et réponse), je ne peux que vous encourager à faire de même, car cela pourrait être utile à quelqu'un à un moment donné.
Paul

Réponses:


7

Pour compléter la réponse de Paul, j'ai écrit un court programme pour montrer comment piloter l'affichage à 4 chiffres à 7 segments de sa figure:

schéma de câblage

Il s'agit en fait d'un affichage à cathode commun, donc le programme suppose cela, ainsi que le câblage particulier de la figure. La partie intéressante est la refresh_display()fonction, qui devrait être appelée périodiquement. L'algorithme est le suivant:

  • piloter les 7 anodes avec les signaux appropriés pour l'un des chiffres que nous voulons montrer
  • définir HIGHla sortie qui contrôle la cathode de ce chiffre via le transistor NPN
  • attendre 2,5 ms (pour un taux de rafraîchissement de 100 Hz)
  • définir LOWla sortie de contrôle de cathode
  • passer au chiffre suivant.

Il est à noter que l'attente se fait sans bloquer le CPU, en utilisant la technique décrite dans le tutoriel Arduino Blink Without Delay . Voici le programme:

const int NB_DIGITS     = 4;  // 4-digit display
const int FIRST_ANODE   = 2;  // anodes a..g on pins 2..8
const int FIRST_CATHODE = 9;  // cathodes, right to left, on pins 9..12

// Digits to display, from right to left.
uint8_t digits[NB_DIGITS];

// Set all the used pins as outputs.
void init_display()
{
    for (int i = 0; i < 7; i++)
        pinMode(FIRST_ANODE + i, OUTPUT);
    for (int i = 0; i < NB_DIGITS; i++)
        pinMode(FIRST_CATHODE + i, OUTPUT);
}

// This should be called periodically.
void refresh_display()
{
    // Our 7-segment "font".
    static const uint8_t font[10] = {
        //abcdefg
        0b1111110, // 0
        0b0110000, // 1
        0b1101101, // 2
        0b1111001, // 3
        0b0110011, // 4
        0b1011011, // 5
        0b1011111, // 6
        0b1110000, // 7
        0b1111111, // 8
        0b1111011  // 9
    };

    // Wait for 2.5 ms before switching digits.
    static uint32_t last_switch;
    uint32_t now = micros();
    if (now - last_switch < 2500) return;
    last_switch = now;

    // Switch off the current digit.
    static uint8_t pos;
    digitalWrite(FIRST_CATHODE + pos, LOW);

    // Set the anodes for the next digit.
    pos = (pos + 1) % NB_DIGITS;
    uint8_t glyph = font[digits[pos]];
    for (int i = 0; i < 7; i++)
        digitalWrite(FIRST_ANODE + i, glyph & 1 << (6-i));

    // Switch digit on.
    digitalWrite(FIRST_CATHODE + pos, HIGH);
}

/***********************************************************************
 * Example usage.
 */

void setup()
{
    init_display();
}

void loop()
{
    uint32_t now = millis();

    // Change the number displayed every second.
    static uint32_t last_change;
    if (now - last_change >= 1000) {
        digits[3] = digits[2];
        digits[2] = digits[1];
        digits[1] = digits[0];
        digits[0] = (digits[0] + 1) % 10;
        last_change = now;
    }

    refresh_display();
}

Paul a fourni un lien vers un tutoriel sur Parallax qui suggère d'utiliser la bibliothèque Arduino Multiplex7Seg . Cette bibliothèque est plus générale que l'exemple de code ci-dessus, car elle ne fait pas d'hypothèses sur les broches utilisées. Mais la grande différence entre la bibliothèque et ce code réside dans la façon dont les timings sont gérés:

  • La bibliothèque est pilotée par l'interruption de dépassement du temporisateur 2. Cela devrait fournir un calendrier très stable, au prix d'avoir un minuteur dédié à ce travail.
  • Le code ci-dessus repose sur l'utilisateur appelant refresh_display()assez souvent. Il ne nécessite pas de ressources matérielles dédiées, mais il ne fonctionne pas bien avec des programmes qui prennent trop de temps loop(): il n'aimera pas que vous appeliez delay().

C'est pourquoi j'aime les choses open-source. Vous pouvez partager la charge de travail avec le reste du monde et créer quelque chose de vraiment sympa. Ce qui est ensuite partagé avec le reste du monde :) Vous pouvez apprendre beaucoup des autres développeurs et cette connaissance sera persistante et pas seulement cachée à tout le monde.
Paul

J'ai une question à l'esprit concernant la valeur de la résistance de base de Tranistor. J'ai un gros problème avec le calcul de la valeur de la résistance. Quelle est la raison d'utiliser une résistance de 4,7 K dans quatre transistors 2N2222? Si un seul segment consomme 10 mA, il y aura un courant maximal de 80 mA pour tous les segments, y compris DP. Si V (BE * sat) = 1,3 v et I (B) = 15 mA, alors 300 ohms suffiront. Y a-t-il un problème avec mon calcul?
maruf

@maruf: Le I_B minimum requis est le I_C attendu divisé par le gain minimum du transistor. Si vous voulez 80 mA sur le collecteur et attendez un gain d'au moins 100 (cela peut être optimiste, je n'ai pas vérifié la fiche technique), alors vous avez besoin d'au moins 80/100 = 0,8 mA sur la base. Ensuite, la valeur maximale de la résistance de base est la chute de tension à travers elle (environ 5 V - 0,7 V) divisée par ce courant, soit environ 5,3 kΩ.
Edgar Bonet

5

Je vais essayer de vous guider à travers les bases complètes des LED, etc. Comme les écrans à 4 chiffres à 7 segments sont une combinaison de plusieurs "techniques LED".

LED de câblage

Les LED, ou diodes électroluminescentes, sont l'une des choses amusantes d'Arduino.

Essentiellement, ils sont faciles à utiliser, alimentez-les et ils s'allumeront.

Ils peuvent être ennuyeux, car ils ont une sorte de polarité, ce qui signifie qu'ils ne fonctionneront que lorsque vous les câblerez correctement. Si vous inversez la tension positive et négative, ils ne s'allumeront pas du tout.

Aussi ennuyeux que ce soit, il est également très utile.

Cathode vs Anode

Sur une LED traditionnelle, le long fil est le (+), anode. L'autre piste étant la cathode (-).

"Ou, si quelqu'un a coupé les jambes, essayez de trouver le bord plat sur le boîtier extérieur de la LED. La broche la plus proche du bord plat sera la broche de cathode négative." - Sparkfun

Source: https://learn.sparkfun.com/tutorials/polarity/diode-and-led-polarity

Sparkfun

Câblage de base

Je ne sais pas si c'est correct, car j'ai déchiré l'image d'Internet.

Câblage LED de base

Le câblage d'une LED est assez simple, l'anode (+) se connecte à une tension positive, de préférence via une résistance de limitation de courant. La cathode (-) se connecte à la masse (avec une résistance de limitation de courant, si vous n'en aviez pas du côté positif).

La résistance de limitation de courant évitera que la LED ne court-circuite, endommageant la LED ou le microcontrôleur / Arduino.

Plusieurs LED, matrices, LED RGB

Avec plusieurs LED, vous les avez souvent avec le côté positif connecté (+), "anode commune" ou tous connectés à la (-) "cathode commune".

Fondamentalement, cela se résumera à cela.

Cathode / anode commune RVB

Pour une cathode commune, vous fournissez du courant aux broches que vous souhaitez avoir.

Pour une anode commune, vous faites passer le courant à travers la LED.

Multiplexage (plusieurs chiffres, 7 segments)

Vous devriez consulter le tutoriel de parallaxe: http://learn.parallax.com/4-digit-7-segment-led-display-arduino-demo

Parallax 4digit7seg

Lorsque vous avez beaucoup de LED, il est souvent judicieux de les «multiplexer». Habituellement, vous passez rapidement par des «groupes» de LED, de sorte qu'il semble qu'ils sont tous allumés en même temps.

Habituellement, vous absorbez le courant d'une colonne de LED et fournissez du courant aux LED individuelles d'une rangée.

Ou, vous fournissez du courant à une colonne de LED et absorbez le courant des LED individuelles d'une rangée.

Pour que vous puissiez choisir la colonne à activer et les LED de cette colonne à allumer. La modification rapide de ces colonnes / rangées vous permettra de contrôler plusieurs LED avec beaucoup moins de broches.

Il existe même des contrôleurs d'affichage pour cela, si vous ne voulez pas vous occuper de la commutation dans votre logiciel.

Donc, quand vous avez une anode commune à 4 chiffres et multiplexée à 7 segments

Le diagramme ressemblera plus à ceci:

entrez la description de l'image ici

http://www.mytutorialcafe.com/Microcontroller%20Application%20C%207segmen.htm

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.