IC CD4017BE, dekadischer CMOS-Zähler, 10 decodierte Ausgänge, 3-18V, DIP-16

Dieses Tutorial verwendet das Arduino-Uno-Board, das das Taktsignal für den integrierten Schaltkreis CD4017BE erzeugt und dessen Ausgangszustände einliest. Das Arduino Uno ist die passende Wahl, weil es mit 5 V arbeitet, einer Spannung, bei der der CD4017BE direkt funktioniert, und die 10 Ausgänge sowie der Übertragsausgang können mit den digitalen Pins des Boards gelesen werden.

Der CD4017BE ist ein CMOS-Dezimalzähler mit 10 decodierten Ausgängen im DIP-16-Gehäuse. Bei jedem Taktimpuls wechselt der High-Pegel von einem Ausgang zum nächsten, von Q0 bis Q9, danach beginnt der Schaltkreis wieder von vorn. Er wird für Lauflichter, Sequenzer, stufenweise Zeitverzögerungen, Kanalwahlschalter und Frequenzteiler mit dem Teilungsverhältnis 10 eingesetzt.

Funktionsweise:

Der CD4017BE enthält einen Johnson-Zähler mit 5 Stufen, gefolgt von einem Decoder. Dank des Decoders ist zu jedem Zeitpunkt genau einer der Ausgänge Q0 bis Q9 auf High-Pegel, die übrigen neun sind auf Low-Pegel. Jeder Ausgang bleibt genau eine vollständige Periode des Taktsignals auf High-Pegel.

Der Zähler schaltet bei der steigenden Flanke des Signals am Pin CLOCK weiter, vorausgesetzt, der Pin CLOCK INHIBIT liegt auf Low-Pegel. Liegt CLOCK INHIBIT auf High-Pegel, werden die Taktimpulse ignoriert und der Zähler bleibt stehen. Ein High-Pegel am Pin RESET setzt den Zähler auf die Position null, also wird Q0 high und die übrigen Ausgänge werden low. Die Pins RESET und CLOCK INHIBIT dürfen niemals in der Luft hängen, sie müssen entweder an VDD oder an Masse angeschlossen werden.

Der Ausgang CARRY OUT ist auf High-Pegel, solange sich der Zähler in den Positionen Q0 - Q4 befindet, und auf Low-Pegel in den Positionen Q5 - Q9. Er durchläuft alle 10 Taktimpulse einen vollständigen Zyklus, daher ist die Frequenz am CARRY OUT die Taktfrequenz geteilt durch 10. Zum Beispiel ergibt ein Takt von 1000 Hz 100 Hz am CARRY OUT. Jeder Ausgang Qn hat ebenfalls die Taktfrequenz geteilt durch 10, bleibt aber nur ein Zehntel der Periode auf High-Pegel. Der Ausgang CARRY OUT wird an den Eingang CLOCK eines zweiten CD4017BE angeschlossen, um bis 100 zu zählen.

Der Schaltkreis wird mit 3 V bis 18 V versorgt. In diesem Tutorial speisen wir ihn mit 5 V vom Arduino-Board, damit die Pegel der Ausgänge mit den Pins des Arduino Uno kompatibel sind.

Anschluss:

Setzen Sie den Schaltkreis so auf das Breadboard, dass die Kerbe des Gehäuses nach links zeigt, sodass Pin 1 unten links der erste Pin ist. Versorgen Sie den Schaltkreis mit 5 V und verbinden Sie einen Keramikkondensator von 100 nF zwischen den Pins 16 und 8, so nah wie möglich am Schaltkreis, damit die Schaltimpulse keine Fehlzählungen verursachen. Die Ausgänge des CD4017BE können bei 5 V nur einen sehr kleinen Strom liefern, deshalb schließen Sie in dieser Schaltung keine LEDs direkt an sie an. Wir lesen sie nur mit den digitalen Eingängen des Arduino-Boards. Verwenden Sie den Pin D13 nicht für einen Ausgang, da daran die LED des Boards angeschlossen ist und den Ausgang belasten würde. Die Logikpegel betragen 5 V, daher ist kein Pegelwandler nötig, und RESET sowie CLOCK INHIBIT werden vom Board gesteuert, deshalb sind keine Pull-up-Widerstände erforderlich.

Board und Bibliotheken:

Wählen Sie in der Arduino IDE unter Tools > Board das Board Arduino Uno aus dem Paket Arduino AVR Boards, das bereits mit der Arduino IDE installiert wird. Das Programm verwendet nur die Grundfunktionen von Arduino, daher muss keine Bibliothek installiert werden.

Der Code:

Das Programm setzt den Zähler zurück, sendet 10 Taktimpulse, liest nach jedem Impuls den aktiven Ausgang und CARRY OUT aus und prüft anschließend die Pins RESET und 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
}

Wie der Code funktioniert:

Zu Beginn werden die Pins definiert: PIN_CLOCK (D2), PIN_RESET (D3), PIN_INHIBIT (D4) und PIN_CARRY (A2). Der Vektor OUT_PINS enthält in der Reihenfolge die Arduino-Pins, die mit den Ausgängen Q0 - Q9 verbunden sind. Die Vektoren seq und carry speichern den aktiven Ausgang und den Pegel von CARRY OUT nach jedem Taktimpuls.

Die Funktion pulseClock() setzt den Taktpin 20 Mikrosekunden lang auf High-Pegel und danach auf Low-Pegel, erzeugt also eine steigende Flanke, bei der der Zähler um eine Position weiterschaltet. Die Funktion resetCounter() sendet einen kurzen Impuls an den Pin RESET und setzt den Zähler auf Q0 zurück.

Die Funktion readActiveOutput() liest die 10 Ausgänge und gibt die Nummer des einzigen Ausgangs auf High-Pegel zurück. Gibt es nicht genau einen High-Ausgang, liefert sie -1, was auf ein Verbindungsproblem hinweist. Die Funktion printOutput() zeigt den Namen des Ausgangs an, zum Beispiel Q3, oder Q?, wenn der Wert nicht gültig ist.

In setup() wird die serielle Schnittstelle mit 9600 Baud gestartet, die Pins CLOCK, RESET und CLOCK INHIBIT werden als Ausgänge konfiguriert und die Lesepins als Eingänge. Die drei Steuerpins werden auf Low-Pegel gesetzt, sodass das Zählen erlaubt ist.

In loop() werden fünf Schritte ausgeführt. Zuerst wird der Zähler zurückgesetzt und die Startposition angezeigt. Dann werden 10 Taktimpulse gesendet, und der aktive Ausgang sowie der Pegel von CARRY OUT werden gespeichert. Wenn nach dem zehnten Impuls der aktive Ausgang wieder Q0 ist, hat der Zähler einen vollständigen Zyklus durchlaufen. In Schritt 3 wird der Pin CLOCK INHIBIT auf High-Pegel gesetzt und es werden 3 Impulse gesendet, die ignoriert werden müssen. In Schritt 4 wird der Pin wieder auf Low-Pegel gesetzt, und ein einziger Impuls schaltet den Zähler auf Q1. In Schritt 5 setzt ein erneuter Reset den Zähler auf Q0 zurück, danach wartet das Programm 3 Sekunden und beginnt den Test erneut.

Ergebnis:

Öffnen Sie den Serial Monitor der Arduino IDE mit 9600 Baud. Bei jedem Testzyklus sehen Sie die Position nach dem Reset, die Abfolge der Ausgänge nach jedem Taktimpuls, den Pegel von CARRY OUT (1 in den Positionen Q0 - Q4 und 0 in den Positionen Q5 - Q9) und das Ergebnis der Prüfungen für CLOCK INHIBIT und 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

Häufige Probleme:

Auf dem seriellen Monitor erscheint Q? statt eines Ausgangs. Die Ursache ist meist eine falsche Verbindung oder eine fehlende Versorgung des Schaltkreises, sodass nicht genau ein Ausgang auf High-Pegel liegt. Prüfen Sie die Pins 16 und 8 sowie die Zuordnung der Ausgänge Q0 - Q9 zu den Pins D5 - D12, A0 und A1.

Der Zähler überspringt Positionen oder zählt bei einem Impuls mehrfach. Die Ursache ist meist ein fehlender Kondensator von 100 nF zwischen den Pins 16 und 8 oder lange Leitungen am Pin CLOCK. Montieren Sie den Kondensator neben dem Schaltkreis und kürzen Sie die Leitungen.

Der Zähler bleibt immer auf demselben Ausgang. Prüfen Sie, ob der Pin CLOCK INHIBIT (13) auf Low-Pegel liegt und ob der Pin CLOCK (14) mit D2 verbunden ist. Ein Pin RESET, der auf High-Pegel hängen bleibt, hält den Zähler auf Q0.

Die Ergebnisse sind unbeständig oder bei jedem Durchlauf unterschiedlich. Die Pins RESET und CLOCK INHIBIT sind wahrscheinlich unverbunden. Verbinden Sie sie wie in der Tabelle gezeigt mit D3 und D4.

Die Ausgänge wirken schwach oder der High-Pegel sinkt, wenn eine Last angeschlossen wird. Die Ausgänge liefern nur einen kleinen Strom, daher schließen Sie LEDs oder andere Lasten nicht direkt an sie an. Verwenden Sie einen Transistor oder eine Pufferschaltung.

Grenzen und Tipps:

Der Schaltkreis kann mit 3 V bis 18 V versorgt werden, doch in dieser Schaltung speisen Sie ihn nur mit 5 V. Bei einer höheren Spannung würden die Ausgänge den Pegel überschreiten, den die Pins des Arduino Uno vertragen. Die maximale Taktfrequenz steigt mit der Versorgungsspannung, und bei 5 V liegt sie weit über der Geschwindigkeit, die in diesem Test verwendet wird.

Die Ausgänge haben einen geringen Strom, deshalb verwenden Sie für LEDs, Relais oder andere Lasten eine Verstärkerstufe mit Transistoren oder einen Treiberschaltkreis.

Anschließend können Sie einen Sequenzer mit 10 Schritten, eine Lichtsequenz, einen Frequenzteiler mit Teilungsverhältnis 10 oder einen Zähler bis 100 aufbauen, indem Sie den Ausgang CARRY OUT an den Eingang CLOCK eines zweiten CD4017BE anschließen. Für einen kürzeren Zyklus verbinden Sie den gewünschten Ausgang Qn mit dem Pin RESET.