Circuit integrat CD4017BE, numărător decadic CMOS, 10 ieșiri decodificate, 3-18V, DIP-16

Questo tutorial utilizza la scheda Arduino Uno, che genera il segnale di clock per il circuito integrato CD4017BE e legge lo stato delle sue uscite. Arduino Uno è la scelta giusta perché lavora a 5 V, tensione alla quale il CD4017BE funziona direttamente, e le 10 uscite più l'uscita di riporto possono essere lette con i pin digitali della scheda.

Il CD4017BE è un contatore decimale CMOS con 10 uscite decodificate, in package DIP-16. A ogni impulso di clock, il livello alto passa da un'uscita alla successiva, da Q0 a Q9, poi il circuito ricomincia da capo. Si usa per luci sequenziali, sequenziatori, temporizzazioni a gradini, selettori di canale e divisori di frequenza con rapporto 10.

Come funziona:

Il CD4017BE contiene un contatore Johnson a 5 stadi, seguito da un decodificatore. Grazie al decodificatore, in ogni momento una sola uscita tra Q0 e Q9 è a livello alto, mentre le altre nove sono a livello basso. Ogni uscita resta a livello alto esattamente per un periodo completo del segnale di clock.

Il contatore avanza sul fronte di salita del segnale sul pin CLOCK, a condizione che il pin CLOCK INHIBIT sia a livello basso. Se CLOCK INHIBIT è a livello alto, gli impulsi di clock vengono ignorati e il contatore resta fermo. Un livello alto sul pin RESET riporta il contatore alla posizione zero, cioè Q0 diventa alto e le altre uscite basse. I pin RESET e CLOCK INHIBIT non vanno mai lasciati in aria, devono essere collegati o a VDD o a massa.

L'uscita CARRY OUT è a livello alto finché il contatore si trova nelle posizioni Q0 - Q4 e a livello basso nelle posizioni Q5 - Q9. Compie un ciclo completo ogni 10 impulsi di clock, quindi la frequenza di CARRY OUT è la frequenza del clock divisa per 10. Ad esempio, un clock di 1000 Hz dà 100 Hz su CARRY OUT. Ogni uscita Qn ha anch'essa la frequenza del clock divisa per 10, ma resta alta solo per un decimo del periodo. L'uscita CARRY OUT si collega all'ingresso CLOCK di un secondo CD4017BE per contare fino a 100.

Il circuito si alimenta tra 3 V e 18 V. In questo tutorial lo alimentiamo a 5 V, dalla scheda Arduino, così che i livelli delle uscite siano compatibili con i pin di Arduino Uno.

Collegamento:

Posizionate il circuito sulla breadboard con la tacca del package verso sinistra, in modo che il pin 1 sia il primo pin in basso a sinistra. Alimentate il circuito a 5 V e collegate un condensatore ceramico da 100 nF tra i pin 16 e 8, il più vicino possibile al circuito, affinché gli impulsi di commutazione non producano conteggi falsi. Le uscite del CD4017BE a 5 V possono erogare solo una corrente molto piccola, per questo non collegate LED direttamente su di esse in questo montaggio. Le leggiamo solo con gli ingressi digitali della scheda Arduino. Non usate il pin D13 come uscita, perché ha collegato il LED della scheda e caricherebbe l'uscita. I livelli logici sono di 5 V, quindi non serve un convertitore di livello, e RESET e CLOCK INHIBIT sono comandati dalla scheda, quindi non sono necessarie resistenze pull-up.

Scheda e librerie:

Nell'Arduino IDE selezionate la scheda Arduino Uno da Tools > Board, dal pacchetto Arduino AVR Boards, che viene installato insieme all'Arduino IDE. Il programma usa solo le funzioni di base di Arduino, quindi non è necessario installare alcuna libreria.

Codice:

Il programma resetta il contatore, invia 10 impulsi di clock, legge dopo ogni impulso l'uscita attiva e CARRY OUT, poi verifica i pin RESET e CLOCK INHIBIT.

/*
  CD4017BE decade counter test
  Board: Arduino Uno (Arduino AVR Boards, installed with Arduino IDE)
  Libraries: none, only the core Arduino functions are used
  Wiring (CD4017BE pin -> Arduino Uno pin):
    VDD (16)           -> 5V
    VSS (8)            -> GND
    CLOCK (14)         -> D2
    RESET (15)         -> D3
    CLOCK INHIBIT (13) -> D4
    Q0 (3)  -> D5
    Q1 (2)  -> D6
    Q2 (4)  -> D7
    Q3 (7)  -> D8
    Q4 (10) -> D9
    Q5 (1)  -> D10
    Q6 (5)  -> D11
    Q7 (6)  -> D12
    Q8 (9)  -> A0
    Q9 (11) -> A1
    CARRY OUT (12) -> A2
  A 100 nF ceramic capacitor goes between pins 16 and 8.
*/
const uint8_t PIN_CLOCK   = 2;   // Clock input of the counter
const uint8_t PIN_RESET   = 3;   // Reset input, HIGH sets the counter to Q0
const uint8_t PIN_INHIBIT = 4;   // Clock inhibit, HIGH blocks counting
const uint8_t PIN_CARRY   = A2;  // Carry out output
// Arduino pins connected to outputs Q0 - Q9, in order
const uint8_t OUT_PINS[10] = {5, 6, 7, 8, 9, 10, 11, 12, A0, A1};
int seq[10];    // Active output after each clock pulse
int carry[10];  // Carry out level after each clock pulse
// Send one clock pulse, the counter advances on the rising edge
void pulseClock() {
  digitalWrite(PIN_CLOCK, HIGH);
  delayMicroseconds(20);
  digitalWrite(PIN_CLOCK, LOW);
  delayMicroseconds(20);
}
// Send a short reset pulse, the counter returns to Q0
void resetCounter() {
  digitalWrite(PIN_RESET, HIGH);
  delayMicroseconds(20);
  digitalWrite(PIN_RESET, LOW);
  delayMicroseconds(20);
}
// Return the number of the single HIGH output, or -1 if not exactly one is HIGH
int readActiveOutput() {
  int active = -1;
  int count = 0;
  for (int i = 0; i < 10; i++) {
    if (digitalRead(OUT_PINS[i]) == HIGH) {
      active = i;
      count++;
    }
  }
  if (count != 1) {
    return -1;
  }
  return active;
}
// Print the output name, for example Q3
void printOutput(int index) {
  if (index < 0) {
    Serial.print("Q?");
  } else {
    Serial.print("Q");
    Serial.print(index);
  }
}
void setup() {
  Serial.begin(9600);
  pinMode(PIN_CLOCK, OUTPUT);
  pinMode(PIN_RESET, OUTPUT);
  pinMode(PIN_INHIBIT, OUTPUT);
  pinMode(PIN_CARRY, INPUT);
  for (int i = 0; i < 10; i++) {
    pinMode(OUT_PINS[i], INPUT);
  }
  digitalWrite(PIN_CLOCK, LOW);
  digitalWrite(PIN_RESET, LOW);
  digitalWrite(PIN_INHIBIT, LOW);   // LOW allows counting
  Serial.println("CD4017 test started");
}
void loop() {
  // Step 1: reset the counter and show the start position
  resetCounter();
  Serial.print("Reset: active output ");
  printOutput(readActiveOutput());
  Serial.println();
  // Step 2: ten clock pulses, record the outputs after each one
  for (int i = 0; i < 10; i++) {
    pulseClock();
    seq[i] = readActiveOutput();
    carry[i] = digitalRead(PIN_CARRY);
  }
  Serial.print("Sequence after each clock pulse: ");
  for (int i = 0; i < 10; i++) {
    printOutput(seq[i]);
    Serial.print(" ");
  }
  Serial.println();
  Serial.print("Carry out after each pulse:      ");
  for (int i = 0; i < 10; i++) {
    Serial.print(" ");
    Serial.print(carry[i]);
    Serial.print(" ");
  }
  Serial.println();
  if (seq[9] == 0) {
    Serial.println("Result: counter wrapped back to Q0 after 10 pulses");
  } else {
    Serial.println("Error: counter did not return to Q0, check wiring");
  }
  // Step 3: clock inhibit HIGH, pulses must be ignored
  digitalWrite(PIN_INHIBIT, HIGH);
  for (int i = 0; i < 3; i++) {
    pulseClock();
  }
  Serial.print("Clock inhibit HIGH, 3 pulses: output stays ");
  printOutput(readActiveOutput());
  Serial.println();
  // Step 4: clock inhibit LOW, one pulse moves the counter
  digitalWrite(PIN_INHIBIT, LOW);
  pulseClock();
  Serial.print("Clock inhibit LOW, 1 pulse: output moves to ");
  printOutput(readActiveOutput());
  Serial.println();
  // Step 5: reset returns the counter to Q0
  resetCounter();
  Serial.print("Reset HIGH: output returns to ");
  printOutput(readActiveOutput());
  Serial.println();
  delay(3000);   // Wait before repeating the test
}

Come funziona il codice:

All'inizio vengono definiti i pin: PIN_CLOCK (D2), PIN_RESET (D3), PIN_INHIBIT (D4) e PIN_CARRY (A2). Il vettore OUT_PINS contiene, in ordine, i pin di Arduino collegati alle uscite Q0 - Q9. I vettori seq e carry memorizzano l'uscita attiva e il livello di CARRY OUT dopo ogni impulso di clock.

La funzione pulseClock() porta il pin di clock a livello alto per 20 microsecondi, poi a livello basso, quindi produce un fronte di salita al quale il contatore avanza di una posizione. La funzione resetCounter() invia un impulso breve sul pin RESET e riporta il contatore a Q0.

La funzione readActiveOutput() legge le 10 uscite e restituisce il numero dell'unica uscita che si trova a livello alto. Se non esiste esattamente un'uscita alta, restituisce -1, che indica un problema di collegamento. La funzione printOutput() stampa il nome dell'uscita, ad esempio Q3, oppure Q? quando il valore non è valido.

In setup() viene avviata la porta seriale a 9600 baud, i pin CLOCK, RESET e CLOCK INHIBIT sono configurati come uscite e i pin di lettura come ingressi. I tre pin di comando vengono portati a livello basso, così il conteggio è permesso.

In loop() si eseguono cinque passi. Per prima cosa si resetta il contatore e si stampa la posizione di partenza. Poi si inviano 10 impulsi di clock e si memorizzano l'uscita attiva e il livello di CARRY OUT. Se dopo il decimo impulso l'uscita attiva è di nuovo Q0, il contatore ha compiuto un ciclo completo. Nel passo 3 il pin CLOCK INHIBIT viene portato a livello alto e si inviano 3 impulsi, che devono essere ignorati. Nel passo 4 il pin torna a livello basso e un solo impulso sposta il contatore su Q1. Nel passo 5 un nuovo reset riporta il contatore a Q0, poi il programma aspetta 3 secondi e ripete il test.

Risultato:

Aprite il Serial Monitor dell'Arduino IDE alla velocità di 9600 baud. A ogni ciclo di test vedrete la posizione dopo il reset, la sequenza delle uscite dopo ogni impulso di clock, il livello di CARRY OUT (1 nelle posizioni Q0 - Q4 e 0 nelle posizioni Q5 - Q9) e il risultato delle verifiche per CLOCK INHIBIT e RESET.

CD4017 test started
Reset: active output Q0
Sequence after each clock pulse: Q1 Q2 Q3 Q4 Q5 Q6 Q7 Q8 Q9 Q0 
Carry out after each pulse:       1  1  1  1  0  0  0  0  0  1 
Result: counter wrapped back to Q0 after 10 pulses
Clock inhibit HIGH, 3 pulses: output stays Q0
Clock inhibit LOW, 1 pulse: output moves to Q1
Reset HIGH: output returns to Q0

Problemi frequenti:

Sul monitor seriale appare Q? invece di un'uscita. La causa è di solito un collegamento sbagliato o la mancanza di alimentazione del circuito, quindi non esiste esattamente un'uscita a livello alto. Verificate i pin 16 e 8 e la corrispondenza tra le uscite Q0 - Q9 e i pin D5 - D12, A0 e A1.

Il contatore salta alcune posizioni o conta più volte per un impulso. La causa è di solito la mancanza del condensatore da 100 nF tra i pin 16 e 8 oppure fili lunghi sul pin CLOCK. Montate il condensatore vicino al circuito e accorciate i fili.

Il contatore resta sempre sulla stessa uscita. Verificate che il pin CLOCK INHIBIT (13) sia a livello basso e che il pin CLOCK (14) sia collegato a D2. Un pin RESET rimasto a livello alto mantiene il contatore su Q0.

I risultati sono instabili o diversi a ogni esecuzione. I pin RESET e CLOCK INHIBIT sono probabilmente lasciati scollegati. Collegateli a D3 e D4 come indicato nella tabella.

Le uscite sembrano deboli o il livello alto cala quando si aggiunge un carico. Le uscite possono erogare solo una corrente piccola, quindi non collegate LED o altri carichi direttamente su di esse. Usate un transistor o un circuito buffer.

Limiti e consigli:

Il circuito si alimenta tra 3 V e 18 V, ma in questo montaggio lo alimentate solo a 5 V. A una tensione più alta, le uscite supererebbero il livello accettato dai pin di Arduino Uno. La frequenza massima di clock cresce con la tensione di alimentazione, e a 5 V è molto superiore alla velocità usata in questo test.

Le uscite hanno una corrente ridotta, quindi per LED, relè o altri carichi usate uno stadio di amplificazione a transistor o un circuito driver.

In seguito potete costruire un sequenziatore a 10 passi, una sequenza di luci, un divisore di frequenza con rapporto 10 oppure un contatore fino a 100, collegando l'uscita CARRY OUT all'ingresso CLOCK di un secondo CD4017BE. Per un ciclo più corto, collegate al pin RESET l'uscita Qn desiderata.