Page 77 - DCAP108_DIGITAL_CIRCUITS_AND_LOGIC_DESIGNS
P. 77

Digital Circuits and Logic Design



                   Notes

                                       Use the K-map to simplify the expression y =  ABC +  BC +  AB.
                                       Solution:
                                       In this problem we are not given the truth table from which to fill in the K-map instead, we
                                       must fill in the K-map by taking each of the product terms in the expression and placing
                                       1s in the corresponding squares.

                                       The first term,  ABC  tells us to enter a 1 in the  ABC  square of the map (see 4.23). The
                                       second term,  BC, tells us to enter a 1 in each square that contains a  BC, in its label. In
                                       Figure 4.23 this would be the  ABC and ABC squares. Likewise, the AB term tells us to
                                       place a 1 in the  ABC and  ABC squares. All other squares will be filled with 0s.

                                       Now the K-map can be looped for simplification. The result is y =  (A +  BC ,)  as shown in
                                       the Figure 4.23.
                                                               Figure 4.22: Example K-map















                                       “Don’t Care” Conditions

                                       Some logic circuits can be designed so that there are certain input conditions for which
                                       there are no specified output levels, usually because these input conditions will never
                                       occur. In other words, there will be certain combinations of input levels where we “don’t
                                       care” whether the output is HIGH or LOW. This is illustrated in the truth table of Figure
                                       4.24 (a).
                                        Figure 4.23: “Don’t Care” Conditions should be Changed to 0 or 1 to Produce
                                                  K-map Looping that Yields the Simplest Expression

                                                                   C    C                C   C
                                      AB   C    z
                                      0  0  0   0             AB   0    0           AB  0    0
                                      0  0  1   0
                                      0  1  0   0             AB   0    x           AB  0    0
                                      0  1  1   x  "don't
                                      1  0  0   x  care"      AB   1    1           AB  1    1       z= A
                                      1  0  1   1
                                      1  1  0   1             AB   x    1           AB  1    1
                                      1  1  1   1
                                           (a)                       (b)                  (c)
                                       Here the output z is not specified as either 0 or 1 for the conditions A,B,C = 1, 0, 0 and
                                       A, B, C = 0, 1, 1. Instead, an x is shown for these conditions. T represents the “don’t care”
                                       condition. A “don’t care” condition can come about several reasons, the most common
                                       being that in some situations certain input combinations can never occur, and so there is
                                       no specified output for these conditions.




        72                                LOVELY PROFESSIONAL UNIVERSITY
   72   73   74   75   76   77   78   79   80   81   82