IC CD4017BE, CMOS decade counter, 10 decoded outputs, 3-18V, DIP-16

This tutorial uses the Arduino Uno board, which generates the clock signal for the CD4017BE integrated circuit and reads the state of its outputs. The Arduino Uno is a suitable choice because it works at 5 V, the voltage at which the CD4017BE works directly, and the 10 outputs plus the carry output can be read with the digital pins of the board.

The CD4017BE is a CMOS decade counter with 10 decoded outputs, in a DIP-16 package. On each clock pulse, the high level moves from one output to the next, from Q0 to Q9, and then the circuit starts over. It is used in sequential lights, sequencers, step timers, channel selectors and frequency dividers with a ratio of 10.

How it works:

The CD4017BE contains a 5-stage Johnson counter, followed by a decoder. Thanks to the decoder, at any moment only one output between Q0 and Q9 is at high level, while the other nine are at low level. Each output stays at high level for exactly one full period of the clock signal.

The counter advances on the rising edge of the signal at the CLOCK pin, provided that the CLOCK INHIBIT pin is at low level. If CLOCK INHIBIT is at high level, the clock pulses are ignored and the counter stays in place. A high level on the RESET pin brings the counter to the zero position, meaning Q0 becomes high and the other outputs low. The RESET and CLOCK INHIBIT pins should never be left floating, they must be connected either to VDD or to ground.

The CARRY OUT output is at high level while the counter is in positions Q0 - Q4, and at low level in positions Q5 - Q9. It completes a full cycle every 10 clock pulses, so the frequency at CARRY OUT is the clock frequency divided by 10. For example, a 1000 Hz clock gives 100 Hz at CARRY OUT. Each output Qn also has the clock frequency divided by 10, but it stays high for only one tenth of the period. The CARRY OUT output is connected to the CLOCK input of a second CD4017BE to count up to 100.

The circuit operates between 3 V and 18 V. In this tutorial we power it from 5 V, from the Arduino board, so that the output levels are compatible with the Arduino Uno pins.

Connection:

Place the circuit on the breadboard with the notch of the package to the left, so that pin 1 is the first pin at the bottom left. Power the circuit from 5 V and connect a 100 nF ceramic capacitor between pins 16 and 8, as close as possible to the circuit, so that the switching spikes do not cause false counts. The CD4017BE outputs at 5 V can supply only a very small current, so do not connect LEDs directly to them in this setup. We read them only with the digital inputs of the Arduino board. Do not use pin D13 for an output, because it has the board LED connected and would load the output. The logic levels are 5 V, so no level converter is needed, and since RESET and CLOCK INHIBIT are driven by the board, no pull-up resistors are required.

Board and libraries:

In the Arduino IDE, select the Arduino Uno board from Tools > Board, from the Arduino AVR Boards package, which comes installed with the Arduino IDE. The program uses only the basic functions of Arduino, so no library needs to be installed.

The code:

The program resets the counter, sends 10 clock pulses, reads the active output and CARRY OUT after each pulse, and then checks the RESET and CLOCK INHIBIT pins.

/*
  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
}

How the code works:

At the beginning the pins are defined: PIN_CLOCK (D2), PIN_RESET (D3), PIN_INHIBIT (D4) and PIN_CARRY (A2). The OUT_PINS array contains, in order, the Arduino pins connected to the outputs Q0 - Q9. The seq and carry arrays store the active output and the CARRY OUT level after each clock pulse.

The pulseClock() function brings the clock pin to high level for 20 microseconds, then to low level, so it produces a rising edge at which the counter advances by one position. The resetCounter() function sends a short pulse on the RESET pin and brings the counter back to Q0.

The readActiveOutput() function reads the 10 outputs and returns the number of the only output at high level. If there is not exactly one high output, it returns -1, which indicates a connection problem. The printOutput() function displays the output name, for example Q3, or Q? when the value is not valid.

In setup() the serial port is started at 9600 baud, the CLOCK, RESET and CLOCK INHIBIT pins are configured as outputs, and the reading pins as inputs. The three control pins are brought to low level, so counting is enabled.

In loop() five steps are executed. First the counter is reset and the start position is displayed. Then 10 clock pulses are sent and the active output and the CARRY OUT level are stored. If after the tenth pulse the active output is Q0 again, the counter has completed a full cycle. In step 3 the CLOCK INHIBIT pin is brought to high level and 3 pulses are sent, which must be ignored. In step 4 the pin returns to low level and a single pulse moves the counter to Q1. In step 5 a new reset brings the counter back to Q0, then the program waits 3 seconds and repeats the test.

Result:

Open the Serial Monitor in the Arduino IDE at 9600 baud. At each test cycle you will see the position after the reset, the sequence of outputs after each clock pulse, the CARRY OUT level (1 in positions Q0 - Q4 and 0 in positions Q5 - Q9) and the results of the checks for CLOCK INHIBIT and 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

Common problems:

The Serial Monitor shows Q? instead of an output. The cause is usually a wrong connection or missing power to the circuit, so that there is not exactly one output at high level. Check pins 16 and 8, and the correspondence between outputs Q0 - Q9 and pins D5 - D12, A0 and A1.

The counter skips positions or counts several times per pulse. The cause is usually the missing 100 nF capacitor between pins 16 and 8, or long wires on the CLOCK pin. Mount the capacitor close to the circuit and shorten the wires.

The counter always stays on the same output. Check that the CLOCK INHIBIT pin (13) is at low level and that the CLOCK pin (14) is connected to D2. A RESET pin left at high level keeps the counter at Q0.

The results are unstable or different on each run. The RESET and CLOCK INHIBIT pins are probably left unconnected. Connect them to D3 and D4 as shown in the table.

The outputs look weak, or the high level drops when a load is added. The outputs can supply only a small current, so do not connect LEDs or other loads directly to them. Use a transistor or a buffer circuit.

Limitations and tips:

The circuit operates between 3 V and 18 V, but in this setup you power it only from 5 V. At a higher voltage, the outputs would exceed the level accepted by the Arduino Uno pins. The maximum clock frequency increases with the supply voltage, and at 5 V it is well above the speed used in this test.

The outputs have a low current capability, so for LEDs, relays or other loads use an amplifier stage with transistors or a driver circuit.

You can further build a 10-step sequencer, a light sequence, a frequency divider with a ratio of 10 or a counter up to 100, by connecting the CARRY OUT output to the CLOCK input of a second CD4017BE. For a shorter cycle, connect the desired Qn output to the RESET pin.