

Hi,
I've been working on a simple step by step process for students to methodically move from each chip function (as described in each chip API box) to the actual implementation.
Let me provide a little context.
Say a student jumps in, takes a bruteforce approach toward implementation and gets stuck at Xor. He notices that the text provides a table of basic boolean functions, and sees the boolean function for xor. Aha, "x and not y or not x and y. I have all those gates and can do that."
Ideally, he then realizes that it's simple to use boolean functions to guide his implementation. Or that he can reduce the canonical form distilled from a truth table to help figure out the implementation.
This is a discovery I want my students to realize.
However, for some chips, for example Dmux, the student may get stuck again. For example, he sees the slightly different truth table and may not know how to proceed toward implementation. Or he sees the function definition and again isn't quite sure how to proceed from the chip function to the implementation.
I would appreciate any tips or ideas in how to set forth a methodical approach for students to follow, from the chip function definition to boolean function to implementation. Specifically, I'm having trouble distilling a simple process for moving from the chip function to a boolean function.
(or if you feel there's a better way, I am certainly listening)

Administrator

Here's my two cents. (1) A chip diagram goes a long way toward implementation. But, if it's too detailed it gives away the solution. Thus, the instructor can give the students a partial chip diagram, along with verbal explanation about missing parts. (2) The logical IF operation is implemented using a MUX chip. This is a useful tip, since MUX is a new concept for most students. (3) Our chip set is built gradually: new chips are based on those implemented before. Therefore, students should be advised to always implement new chips using the most recently developed ones, rather than going all the way back to primitive chips.  Shimon


ybakos wrote
However, for some chips, for example Dmux, the student may get stuck again. For example, he sees the slightly different truth table and may not know how to proceed toward implementation. Or he sees the function definition and again isn't quite sure how to proceed from the chip function to the implementation.
I'm studying the book by myself and have hit upon exactly the problem you described with DMux. Did you perchance formulate a strategy for how to proceed through the gates as you sought?
Thanks
Gerry


The approach I currently use is based on using the truth tables. It doesn't result in an optimum implementation, but that's ok.
Look at the truth tables, for which the output is 1. Write down a Boolean canonical expression, and implement from there. (The book mentions this approach, so spend time with the chapter.)
If you're stuck, post again.


Karnaugh maps are useful here, as part of the process to go from truth table to chip design.


Drawing the circuit to help visualize the problem you are trying to solve. Using the primitives(combined with canonical truthtables) or lowerlevel chips that you have already built, as elements in your visuals, might also be helpful.
Hope that helps!


Thanks Guys.
The thing is I have actually implemented the chip. I did so by pen and paper/trial and error.
My only concern is that I did not have a methodology to do so. I don't see how the truth table approach works when there are > 1 outputs. Do you do a separate statement for each output?
I used TTs and a Karnaugh map to solve the Mux problem rather nicely, but in a multi output world i don't see how they are applicable.


In a multioutput world, you will have the output section of your truth table show the number of outputs you have; just as you will have the input section of your truth table showing the number of inputs. Lets say we build a chip with 2inputs and 4outputs. We will do the canonical routine and determine when the outputs will be one and zero for each set of inputs. Afterwards, we will select the sets of inputs that give the "high" output(if that is what you want) then write out separate canonical forms for each output like so(high output case):
in1in2out1out2out3out4
0 0 0 0 0 1
0 1 0 0 1 0
1 0 0 1 0 0
1 1 1 0 0 0
out1=in1*in2
out2=in1*not(in2)
out3=not(in1)*in2
out4=not(in1)*not(in2)
Hope that helps.


Hi Todun,
That actually does help clear up my questions. thanks a lot!


Todun,
Thanks! That explanation also helped me greatly to figure out the dmux.


Thanks a lot for the above mentioned methodology....i had figured out half of it..but the other half i was unable to...after going through this forum topic i understood the rest of it too....the silly mistake which i did was i had taken out2=not(in2)*sel instead of out2=in2*not(sel)

