ROM - Mask, EProm, EEProm, Flash

RAM - SRAM, DRAM, Magnetic

****

Know the basic boolean rules.

  Identity     A+0=A            A*1=A

  Null         A+1=1            A*0=0

  IdemPotent   A+A=A            A*A=A

  Inverse      A+!A=1           A*!A=0
   (complement

  Cancellation !!A=A

  Commutative  A+B=B+A          A*B=B*A

  Associative  (A+B)+c=A+(B+C)  (A*B)*C=A*(B*C)

  Distributive A*(B+C)=A*B+A*C  A+BC=(A+B)*(A+C)

  DeMorgan     !A*!B=!(A+B)     !(A*B)=!A+!B

If given the name, can you write the rule.


Be able to simplify a given boolean statement.

******************

  Simplify :
            !(A+B)*!(A+C)*!(B+C)
    DeMorgan    
            !A*!B*!A*!C*!B*!C
    IdemPotent  
            !A*!B*!C
    DeMorgan     
            !(A+B+C)

  Proof by application.  Example :

   A B C   !(A+B)*!(A+C)*!(B+C)        !A*!B*!C      !(A+B+C)
   ----------------------------------------------------------
   0 0 0   !(0+0)*!(0+0)*!(0+0) = 1   !0*!0*!0 = 1 = !(0+0+0)
   0 0 1   !(0+0)*!(0+1)*!(0+1) = 0   !0*!0*!1 = 0 = !(0+0+1)
   0 1 0   !(0+1)*!(0+0)*!(1+0) = 0   !0*!1*!0 = 0 = !(0+1+0)
   0 1 1   !(0+1)*!(0+1)*!(1+1) = 0   !0*!1*!1 = 0 = !(0+1+1)
   1 0 0   !(1+0)*!(1+0)*!(0+0) = 0   !1*!0*!0 = 0 = !(1+0+0)
   1 0 1   !(1+0)*!(1+1)*!(0+1) = 0   !1*!0*!1 = 0 = !(1+0+1)
   1 1 0   !(1+1)*!(1+0)*!(1+0) = 0   !1*!1*!0 = 0 = !(1+1+0)
   1 1 1   !(1+1)*!(1+1)*!(1+1) = 0   !1*!1*!1 = 0 = !(1+1+1)

******************
  Simplify :

             A*!B*C+!(B+C)
    DeMorgans    
             A*!B*C+!B*!C
    Distributive 
             !B*(A*C+!C)

       Note that inside the () looks like the AND form of distribution.
          (!C+A*C)  ~ A+B*C = (A+B)*(A+C)  ~ (!C+A)*(!C+C)

             !B*(!C+A)*(!C+C)
     Inverse
             !B*(!C+A)*(1)
     Identity     
             !B*(!C+A)


Proof by application

   A B C |  A*!B*C+!(B+C)             !B*(!C+A)
   ------------------------------------------------
   0 0 0    0*!0*0+!(0+0) = 1         !0*(!0+0) = 1
   0 0 1    0*!0*1+!(0+1) = 0         !0*(!1+0) = 0
   0 1 0    0*!1*0+!(1+0) = 0         !1*(!0+0) = 0
   0 1 1    0*!1*1+!(1+1) = 0         !1*(!1+0) = 0
   1 0 0    1*!0*0+!(0+0) = 1         !0*(!0+1) = 1
   1 0 1    1*!0*1+!(0+1) = 1         !0*(!1+1) = 1
   1 1 0    1*!1*0+!(1+0) = 0         !1*(!0+1) = 0
   1 1 1    1*!1*1+!(1+1) = 0         !1*(!1+1) = 0

******************
  Simplify :
             !a+a*b
    Cancelation  
             !a+!!(a*b)
    deMorgan     
             !a+!(!a+!b)
    deMorgan     
             !(a*(!a+!b))
    Distribution  
             !(a*!a+a*!b)
    Inverse      
             !(0+a*!b)
    Null         
             !(a*!b)
    deMorgan     
             !a+!!b
    Cancellation 
             !a+b

Quicker way :
             !a+a*b     Note distributive form a+b*c = (a+b)*(a+c)
    Distributive 
             (!a+a)*(!a+b)
    Inverse         
             (1)*(!a+b)
    Identity     
             !a+b

************************

Draw the basic gates NOT, AND, NAND, OR, NOR, XOR and their truth tables.

Draw a half-adder, or a decoder and the truth table for each.

Draw the gates for a given boolean statement.

Draw the truth table for a given boolean statement.


Know the generic fetch/execute pseudocode.