¿Cómo utilizar un ánodo común de 7 segmentos, pantalla de 4 dígitos?

Tome esta pregunta como ejemplo para responder (la mía) a continuación.

Tengo una pantalla LED de 7 segmentos y 4 dígitos, pero no tengo idea de cómo conectarla.

No entiendo la diferencia entre el ánodo / cátodo común, y no tengo 2 pines por LED, lo cual es extraño. Recientemente, se eliminó una pregunta sobre un "ánodo común de 7 dígitos y 4 dígitos". En ese mismo momento estaba escribiendo una respuesta.

Sin embargo, todavía quiero compartir mi respuesta con usted o con la persona que la preguntó. Verifique / actualice mi respuesta con más información. Específicamente, podría alguien agregar código de trabajo, no puedo en este momento.

Como complemento a la respuesta de Paul, escribí un breve programa para mostrar cómo manejar la pantalla de 7 segmentos y 4 dígitos de su figura:

Esta es en realidad una pantalla de cátodo común, por lo que el programa asume eso, así como el cableado particular de la figura. La parte interesante es la refresh_display()función, que debe llamarse periódicamente. El algoritmo es como sigue:

• conducir los 7 ánodos con las señales apropiadas para uno de los dígitos que queremos mostrar
• establecer HIGHla salida que controla el cátodo de ese dígito a través del transistor NPN
• esperar 2.5 ms (para una frecuencia de actualización de 100 Hz)
• establecer LOWla salida de control del cátodo
• pasar al siguiente dígito.

Cabe señalar que la espera se realiza sin bloquear la CPU, mediante el uso de la técnica descrita en el tutorial Arduino de parpadeo sin demora . Aquí está el programa:

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 proporcionó un enlace a un tutorial sobre Parallax que sugiere usar la biblioteca Multiplex7Seg Arduino. Esa biblioteca es más general que el código de ejemplo anterior, ya que no hace suposiciones sobre los pines utilizados. Pero la gran diferencia entre la biblioteca y este código está en la forma en que se manejan los tiempos:

• La biblioteca es controlada por la interrupción de desbordamiento del temporizador 2. Esto debería proporcionar un tiempo muy estable, a costa de tener un temporizador dedicado a este trabajo.
• El código anterior se basa en que el usuario llama con la refresh_display()frecuencia suficiente. No requiere recursos de hardware dedicados, pero no funciona bien con programas que requieren demasiado tiempo loop(): no le gustará que llame delay().

Trataré de llevarlo a través de los conceptos básicos completos de los LED, etc. Como las pantallas de 4 dígitos y 7 segmentos son una combinación de múltiples "técnicas de LED".

LED de cableado

Los LED, o diodos emisores de luz, son una de las cosas divertidas de Arduino.

Esencialmente, son fáciles de usar, enciéndelos y se encenderán.

Pueden ser molestos, porque tienen algún tipo de polaridad, lo que significa que solo funcionarán cuando los conecte correctamente. Si invierte el voltaje positivo y negativo, no se iluminarán en absoluto.

Por molesto que sea, también es bastante útil.

Cátodo vs Ánodo

En un LED tradicional, el cable largo es el (+), Ánodo. El otro líder es el (-) cátodo.

"O, si alguien ha recortado las patas, intente encontrar el borde plano en la carcasa exterior del LED. El pin más cercano al borde plano será el pin negativo del cátodo". - Sparkfun

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

Cableado básico

No estoy seguro de si esto es correcto, ya que arranqué la imagen de Internet.

Cablear un LED es bastante fácil, el Ánodo (+) se conecta a voltaje positivo, preferiblemente a través de una resistencia limitadora de corriente. El cátodo (-) se conecta a tierra (con una resistencia limitadora de corriente, si no tenía una en el lado positivo).

La resistencia limitadora de corriente evitará que el LED se cortocircuite, dañando el LED o el Microcontrolador / Arduino.

Múltiples LED, matrices, leds RGB

Con múltiples LED, a menudo los tiene con el lado positivo conectado (+), "Ánodo común" o todos conectados al (-) "Cátodo común".

Básicamente todo se reducirá a esto.

Para un cátodo común, suministra corriente a los pines que desea tener.

Para un ánodo común, hunde la corriente a través del LED.

Multiplexación (dígitos múltiples, 7 segmentos)

Debe consultar el tutorial de paralaje: http://learn.parallax.com/4-digit-7-segment-led-display-arduino-demo

Cuando tienes muchos LED, a menudo es inteligente "multiplexarlos". Por lo general, atraviesas rápidamente "grupos" de LED, de modo que parece que están todos encendidos al mismo tiempo.

Por lo general, hunde la corriente de una columna de LED y suministra corriente a los LED individuales de una fila.

O bien, suministra corriente a una columna de LED y hunde la corriente de los LED individuales de una fila.

Para que pueda elegir qué columna activar y qué LED de esa columna se iluminarán. Cambiar estas columnas / filas rápidamente le permitirá controlar múltiples LED con muchos menos pines.

Incluso hay controladores de pantalla para esto, si no desea encargarse del cambio en su software.

Entonces, cuando tiene un ánodo común multiplexado de 7 dígitos y 4 segmentos

El diagrama será más parecido a esto:

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