-. -. Learning Outcomes piral unction synthesis with: Mues (hannon's Theorem) Memories I can implement logic for any truth table by using hannon's theorem to decompose the function to create two smaller functions and a to mu I can recursively apply hannon's theorem k times to decompose any sie truth table to arrive at k smaller functions and a k to mu I can implement logic for any truth table by using a memory as a look up table I understand how to determine the necessary dimensions of the memory I understand how to reinterpret input combinations as address inputs to determine the correct row to place the desired output Mark Redekopp -. -. unction ynthesis Techniques Given a combination function (i.e. truth table or other description) what methods can we use to arrive at a circuit? Neither of these to larger number of inputs Now we will see a few others X Z P Primes between - Implementing functions with mues HANNON' THEOREM
-. -. implify This to Mu: Another View Given (,y,) = y + y, simplify (,y,) = then simplify (,y,) = Old Views: I I -bit wide -to- mu (I ) IN IN if(s==) = IN else = IN Given G(a,b,c,d) = bd + ab cd + ac d G(,,c,d) = New View: We can show the function of a -to- mu as a splitter where the variable 's' decides which input passes upwards s I I -. -.8 bit Prime Number unction unction Implementation w/ Mues X Z P X Z P O-set y Implementing a function using mues relies is based on hannon s epansion theorem which states: Primes between - Truth Table ON-set (X,X,,X n ) = X (,X,,X n ) + X (,X,,X n ) X can be pulled out of if we substitute an appropriate constant and qualify it with X or X Now recall a to mu can be built as: if(==) output else output I I = I + I Comparing the two equations, hannon s theorem says we can use X as our select bit to a to mu with (,X, X n ) as input of our mu and (,X,,X n ) as input
-.9 -. Binary Decision Trees & Mues plitting on X X Z (,y,) Z (,y,) Z (,y,) Z (,,) Z (,,) Z (,,) Z (,,) y (,y,) (,y,) (,y,) y (,,) (,,) (,,) (,,) (,y,) (,y,) (,y,) (,,) (,,) (,,) (,,) We can use smaller mues by breaking the truth table into fewer disjoint sets This increases the amount of logic at the inputs though Break the truth table into groups based on some number (k) of MB s or each group, describe as a function of the n k LB s X Z I I X Put the k MB s on the selects -. -. Implement G hannon s Theorem X Z G (X,X,,X n ) = X (,X,,X n ) + X (,X,,X n ) Now recall a to mu can be built as: I I X G = I + I Comparing the two equations, hannon s theorem says we can use X as our select bit to a to mu with (,X, X n ) as input of our mu and (,X,,X n ) as input We can recursively apply hannon s theorem to pull out more variables: (X,X,,X n ) = X X (,,,X n ) + X X (,,,X n ) + X X (,,,X n ) + X X (,,,X n ) +
-. -. Mues allow us to break a function into some number of smaller, disjoint functions Use MB s to choose which small function we want By including the use of inverters we can use a mu with n select bits (given a function of n var s) Break the truth table into groups of rows or each group, put in terms of:,,, or Additional Logic X Z (,y,) can be broken into several disjoint functions () () () () D D D D y Put the n- MB s on the selects X Z G More Practice D D D D y G -. -. As ar as We like plitting on Z We can take this tactic all the way down and use ONL a mu to implement any function Connect the input variables to the select bits of the mu The output of the mu is the output of the function Whatever the output should be for each input value, attach that to the input of the mu X Z D D D D D D D D y We can always rearrange our variables if it helps make the function simpler to implement X Z Z X y y
Implementing Logic unctions We can use mues to implement any arbitrary logic function Choose one variable to the large function into two smaller functions: and to mu will produce the bit and the chosen "split" variable will be the Implement f(,,, ) using any known method and connect it to of the to mu Implement f(,,, ) using any known method and connect it to of the to mu -. Implementing an Initial tate ince the NL is just a combinational function of the current state and inputs, we can use hannon's theorem (i.e. mues)to find an implementation rather than K Maps Q(t) Q(t) NL (Net tate Logic) CLK D D Current tate eedback OL M (Output (tate Memory) unction Logic) PRE Q(t) D Q CLK CLR REET PRE D Q CLK CLR REET Q(t) A -.8 Eample Implement D & D using to mues with as the select Current tate tate Q Q tate Net tate = = Q*= D Q*= D tate Q* =D Q* =D G G G G G G G G G G G G Output A -.9 Eample Implement D and D using () to mues with Q,Q as the selects Current tate Net tate = = Output tate Q Q tate Q * Q * tate Q * Q * G MTG MG M MT N/A X d d X d d d d d MT M M M -.
Eample Implement D using a mu Current tate Net tate H L = H L = H L = H L = ymbol Q ym. Q* ym. Q* ym. Q* ym. Q* O ON O O X d ON ON ON O X d Note: The tate Value, Q forms the Pump output (i.e. when we want the pump to be on and othewise) L O P= L H ON P= -. H Eample Implement D using a mu. Current tate Net tate X = X = tate Q Q Q tate* D D D tate* D D D Z init init init -. Outp ut ummary -. -. hannon's theorem allows us to decompose an large function into smaller functions This allows a method that can for a function with It is at the heart of many computer algorithms that will find logic implementation given highlevel descriptions of a function Using a LookUp Table to implement a function MEMORIE
-. -. Memories as Look Up Tables Implementing unctions w/ Memories One major application of memories in digital design is to use them as s (Look Up Tables) to implement logic functions Given a logic function use a memory to hold all the and feed the inputs of the function to the address inputs to look up the answer X Z Arbitrary Logic unction Z X 8 Memory A A D X,,Z inputs look up the correct answer 8 Memory A A D -. -.8 Implementing unctions w/ Memories Eample X C i C o C i X 8 Memory A A 8 Memory A A Implement D & D using a memory Current tate Net tate = = tate Q Q tate Q* Q* tat e Q* Q* G G G G G G G G G G G G 8 Memory A A ull Adder D D D D D D C o ++ =
-.9 -. Eample L Eample Implement D using a memory Current tate Net tate H L = H L = H L = H L = ymbol Q ym. Q* ym. Q* ym. Q* ym. Q* O ON O O X d ON ON ON O X d L O P= A A H 8 Memory ON P= H Implement D and D using a memory Current tate Net tate = = Output tate Q Q tate Q * Q * tate Q * Q * G MTG MG M MT 8 Memory A A N/A X d d X d d d d d MT M M M D D D Multiplier Eample -. Implementing unctions w/ Memories -. Determine the dimensions of the memory that would be necessary to implement a bit unsigned multiplier with inputs X[:] and [:] and outputs P[??:] (Question: How many bits are needed for P). Eample: X X X X = =... ROM To implement a function w/ n variables and m outputs Just place the output truth table values in the memory Memory will have dimensions: n rows and m columns till does not terribly well (i.e. n inputs requires memory w/ n outputs) But it is easy and since we can change the contents of memories it allows us to create " " logic This idea is at the heart of P = X * = * = =