Come utilizzare un anodo comune a 7 segmenti, display a 4 cifre?

Si prega di prendere questa domanda come esempio per (la mia) risposta di seguito.

Ho un display a LED a 7 segmenti e 4 cifre, ma non ho idea di come collegarlo.

Non capisco la differenza tra anodo / catodo comune e non ho 2 pin per LED, il che è strano. Recentemente, una domanda su un "anodo comune a 4 cifre a 7 segmenti" è stata eliminata. In quel momento stavo scrivendo una risposta.

Tuttavia, voglio ancora condividere la mia risposta con te o con la persona che l'ha chiesta. Verifica / aggiorna la mia risposta con ulteriori informazioni. In particolare, qualcuno potrebbe aggiungere un codice funzionante, al momento non posso.

Proprio come complemento della risposta di Paul, ho scritto un breve programma per mostrare come guidare il display a 7 cifre a 7 segmenti della sua figura:

Questo è in realtà un display catodico comune, quindi il programma presume che, oltre al particolare cablaggio della figura. La parte interessante è la refresh_display()funzione, che dovrebbe essere chiamata periodicamente. L'algoritmo è il seguente:

• guidare i 7 anodi con i segnali appropriati per una delle cifre che vogliamo mostrare
• imposta HIGHl'uscita che controlla il catodo di quella cifra attraverso il transistor NPN
• attendere 2,5 ms (per una frequenza di aggiornamento di 100 Hz)
• impostare LOWl'uscita di controllo del catodo
• passa alla cifra successiva.

Va notato che l'attesa viene eseguita senza bloccare la CPU, utilizzando la tecnica descritta nel tutorial di Blink Without Delay Arduino. Ecco il programma:

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 ha fornito un collegamento a un tutorial su Parallax che suggerisce l'utilizzo della libreria Arduino di Multiplex7Seg . Quella libreria è più generica del codice di esempio sopra, in quanto non fa ipotesi sui pin utilizzati. Ma la grande differenza tra la libreria e questo codice sta nel modo in cui i tempi sono gestiti:

• La libreria è guidata dall'interrupt di overflow del Timer 2. Ciò dovrebbe fornire un tempismo molto costante, al costo di avere un timer dedicato a questo lavoro.
• Il codice sopra si basa sull'utente che chiama refresh_display()abbastanza spesso. Non richiede risorse hardware dedicate, ma non funziona bene con programmi che impiegano troppo tempo loop(): non ti piacerà chiamarti delay().

Proverò a illustrarti le basi complete dei LED, ecc. Poiché i display a 7 segmenti a 4 cifre sono una combinazione di più "tecniche LED".

Cablaggio LED

I LED, o diodi ad emissione di luce, sono una delle cose divertenti di Arduino.

In sostanza, sono facili da usare, li accendono e si accendono.

Possono essere fastidiosi, perché hanno un qualche tipo di polarità, il che significa che funzioneranno solo quando li collegherai correttamente. Se inverti la tensione positiva e negativa, non si accenderanno affatto.

Per quanto sia fastidioso, è anche abbastanza utile.

Catodo vs Anodo

Su un LED tradizionale, il cavo lungo è (+), Anodo. L'altro vantaggio è il (-) catodo.

"Oppure, se qualcuno ha tagliato le gambe, prova a trovare il bordo piatto sull'involucro esterno del LED. Il perno più vicino al bordo piatto sarà il perno catodo negativo." - Sparkfun

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

Cablaggio di base

Non sono sicuro che sia corretto, dal momento che ho strappato l'immagine da Internet.

Il cablaggio di un LED è abbastanza semplice, l'Anodo (+) si collega a una tensione positiva, preferibilmente attraverso una resistenza di limitazione della corrente. Il catodo (-) si collega a terra (con un resistore limitatore di corrente, se non ne avevi uno sul lato positivo).

La resistenza di limitazione corrente eviterà che il LED si cortocircuiti, danneggiando il LED o il microcontrollore / Arduino.

LED multipli, matrici, led RGB

Con più LED li hai spesso con il lato positivo collegato (+), "Anodo comune" o tutti collegati al (-) "catodo comune".

Fondamentalmente scenderà a questo.

Per un catodo comune, si fornisce corrente ai pin che si desidera avere.

Per un anodo comune, affondi la corrente attraverso il LED.

Multiplexing (cifre multiple, 7 segmenti)

Dovresti dare un'occhiata al tutorial di parallasse: http://learn.parallax.com/4-digit-7-segment-led-display-arduino-demo

Quando hai molti LED, è spesso intelligente "multiplexarli". Di solito attraversi rapidamente "gruppi" di LED, in modo che sembri che siano tutti accesi contemporaneamente.

Di solito si affonda corrente da una colonna di LED e si fornisce corrente a singoli LED di fila.

Oppure, fornisci corrente a una colonna di LED e affondi corrente da singoli LED di fila.

In questo modo puoi scegliere quale colonna attivare e quali LED di quella colonna illuminare. La modifica rapida di queste colonne / righe ti consentirà di controllare più LED con molti meno pin.

Ci sono anche controller di visualizzazione per questo, se non vuoi occuparti della commutazione nel tuo software.

Quindi, quando si dispone di un anodo comune a 4 cifre, multiplex a 7 segmenti

Il diagramma sarà più simile a questo:

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