CHAPTER 7
COUNTERS
        By Sefneh Getachew
                             1
                    Content
 Synchronous (Parallel) Counters
 Asynchronous counters
 Up/Down Synchronous Counters
 Designing Synchronous Counters
                                    2
                           Introduction: Counters
 Counters are sequential circuits which count through a specific state sequence.
 They can count up, count down, or count through other fixed sequences.
 A Counter is constructed from two or more flip-flops which change states in a
  prescribed sequence.
 Two types of counters:
    synchronous (parallel) counters
    asynchronous (ripple) counters
                                                                                    3
       Asynchronous (Ripple) Counters
 The flip-flops do not change states at exactly the same time
 Do not have a common clock pulse.
 The Output of the preceding flip-flop connected to the input
  clock of the next flip-flop.
 For ‘n’ flip-flops : we need 2n Asynchronous(ripple) counter.
 Also known as ripple counters, as the input clock pulse
  “ripples” through the counter – cumulative delay is a
  drawback.
                                                                  4
          Asynchronous (Ripple) Counters…
   Example: 2-bit ripple binary counter.
   Output of one flip-flop is connected to the clock input of the next
      more-significant flip-flop.
CLK       1       2       3       4
 Q0
 Q0   0       1       0       1       0
 Q1   0       0       1       1       0
 Timing diagram
 00  01  10  11  00 ...
                                                                          5
        Asynchronous (Ripple) Counters…
 Example: 3-bit ripple binary counter.
        HIGH
                    J                 Q0           J               Q1           J               Q2
         CLK            C                              C                            C
                                  Q0                           Q1
                    K                              K                            K
                        FF0                            FF1                      FF2
 CLK        1       2         3            4           5       6        7               8
   Q0   0       1       0         1            0           1       0        1               0
   Q1   0       0       1         1            0           0       1        1               0
   Q2   0       0       0         0            1           1       1        1               0
                                                                                            Recycles back to 0
                                                                                                                 6
      Asynchronous (Ripple) Counters…
 Example: 4-bit ripple binary counter (negative-edge triggered).
                                                                    7
          Asynchronous Down Counters
 Down counters, count downward from a maximum value to zero,
  and repeat.
 Example: A 3-bit binary down counter.
                1
                                    Q0                   Q1                    Q2
                        J       Q            J       Q            J       Q
                                              C
                                                                                     3-bit binary up counter
          CLK            C                                         C
                           Q'                K Q'                 K Q'
                        K
           1
                                Q0                   Q1                       Q2
                    J                    J                    J
                            Q                    Q                    Q             3-bit binary down counter
         CLK         C                    C                    C
                    K
                       Q'                K Q'                 K Q'
                                                                                                                8
Asynchronous Down Counters…
 Example: A 3-bit binary (MOD-8) down counter.
                                                                                                000
                                                                                 001                  111
    1
                         Q0               Q1                   Q2
             J   Q                J   Q            J   Q                    010                             110
  CLK         C                    C                C
             K
                Q'                K Q'             K Q'
                                                                                  011                 101
                                                                                                100
   CLK           1            2       3        4       5            6        7          8
        Q0   0       1            0       1        0       1            0        1          0
        Q1   0       1            1       0        0       1            1        0          0
        Q2   0       1            1       1        1       0            0        0          0
                                                                                                                  9
                    Synchronous (Parallel) Counters
 Apply the same clock pulse to all flip-flop
 All flip-flops change state at the same time , with no ripple
 The problem with Asynchronous counters is that they suffer from “Propagation
  Delay”.
 The result of this synchronization is that all the individual output bits changing state at
  exactly the same time in response to the common clock signal with no ripple effect
  and therefore, no propagation delay.
                                                                                           10
                Synchronous (Parallel) Counters…
 Example: 2-bit synchronous binary counter.
                                                   11
       Synchronous (Parallel) Counters…
 Example: 4-bit synchronous binary counter.
                          TA3 = A2 . A1 . A0
                          TA2 = A1 . A0
                          TA1 = A0
                          TA0 = 1
         1                             A1.A0            A2.A1.A0
                     A0   J       A1       J       A2       J          A3
             J   Q            Q                Q                   Q
              C            C                C                C
             K
                Q'        K Q'             K Q'             K Q'
 CLK
                                                                            12
          Synchronous (Parallel) Counters..
 Example: Synchronous decade/BCD counter
           T0 = 1
           T1 = Q3'.Q0
           T2 = Q1.Q0
           T3 = Q2.Q1.Q0 + Q3.Q0
                 Q0
      1     T              T         Q1   T        Q2   T        Q3
                 Q              Q             Q             Q
             C              C             C             C
                 Q'             Q'            Q'            Q'
CLK
                                                                      13
        Up/Down Synchronous Counters
 a bidirectional counter that is capable of counting either up or
  down.
 An input (control) line Up/Down (or simply Up) specifies the
  direction of counting.
    Up/Down = 1  Count upward
    Up/Down = 0  Count downward
                                                                     14
     Up/Down Synchronous Counters…
 Example: A 4-bit up/down synchronous binary counter.
                           TQ0 = 1
                           TQ1 = (Q0.Up) + (Q0'.Up' )
                           TQ2 = ( Q0.Q1.Up ) + (Q0'. Q1'. Up' )
                                                                   15
16