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

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.

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:

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().

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

Câblage de base

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

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.

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

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:

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