8 Way DMux

In the last exercise, we implemented a 4 way DMux.

In this exercise, we will implement an 8 way DMux. For an 8 way DMux, we need 3 selector pins.

Here we can use one regular (2 way) DMux, and two 4 way DMux's we created in the previous exercise.

Till now, when cascading, I have started from selector[0] and then moved towards selector[n]. In this example I am going the opposite way. We will start with selector[2] and then move on to selector[1] and selector[0].

If you look at the truth table, selector 0 can be used to create 2 sets. The first set, when selector[0] is 0, can result in the output being routed to 'a', 'b', 'c', or 'd'. The second set, when selector[2] is 1, can result in the output being routed to 'e', 'f', 'g', or 'h'.

Here, since we are fanning out into 2 sets, we need to use a regular (2 way) DMux. This DMux will have 2 output lines. Each of these output lines will be fed into a 4 way DMux to create a total of 8 output lines.

The code for the exercise is embedded below.

4 Way DMux

In this exercise, we will build a 4 way DMux.

We have already implemented a simple (2 way) DMux. In that there is one input line, and one selector. The value of the selector, determines, which output line the input is routed to.

In a 4 way DMux, we have 1 input line, 4 possible output lines, and 2 selectors. Based on the value of the selector, the input line is router to one of the 4 output lines.

We can implement a 4 way DMux, using multiple regular (2 way) DMux's. If we look at the truth table, we will notice that if selector[0] is 0, then in can be routed to either 'a', or 'c' (based on the value of selector[1]). If selector[0] is 1, then the input can be sent to either 'b', or 'd' (based on the value of selector[1]).


The code for the 4 way DMux us specified below.

Mux 8 way, 16 bit

In this exercise, we build an 8 way, 16 bit Mux. What this means is that there are eight input arrays (of 16 bits each), for which we will need 3 selectors, and these selectors will select one of the eight input lines to appear as the output.

If we look at the truth table below, we notice that we can apply a 4 way Mux to lines A,B,C,D (using sel[0], ans sel[1]) and another 4 way Mux to E, F, G, H (using sel[0], ans sel[1]). This will result in two lines (one from each set moving ahead). We can then apply a simple Mux to select from one of them, using sel[2].

The code for the 8 way 16 bit Mux is embedded below:

Mux 4 way 16 bit

A 4 way, 16 bit Mux is a Mux which which can select among 4 input lines. To select from 4 input lines, we need log24 selectors.

Because this is a 16 bit Mux, each input line is an array of 16 bits.

Looking at the truth table for the Mux, we know that if sel[0] is 0, then line 'a', and 'c', can be selected. While if sel[0] is 1, then line 'b', or line 'd' are selected. So basically sel[0] will cause one set ('a','c' or 'b','d') to be selected.

sel[1], will select one line from the winner.

So, if sel[0] is 0, then the set 'a', 'c' is the winning set, from which one line will be selected by sel[1]. If sel[0] is 1, then set 'b', 'd' is the winning set from which one line will be selected by sel[1].

The code for the 4 way, 16 bit Mux is specified below.

Built an 8 way OR chip

In this activity, we have to build an 8 way OR chip. An 8 way chip is a specific case of an n-ary chip. It takes n (in this case 8) inputs.

An 8 way Or chip, basically takes 8 inputs and applies the OR function on all of them, and finally provides the output on it's 'out' line.

We will built an 8 way OR chip, using the regular 2 pin OR chip, which we have already built.

We have to cascade multiple of these chips to get the output. There are different ways to cascade them... some more efficient than others.

The code for this activity is embedded below.

Built a 16 bit Mux

Built a 16 bit Mux. A 16 bit Mux is very similar to a regular Mux, except that instead of receiving it's input from 2 pins, it receives it's input from an 2, 16 bit arrays. Code for the 16 bit Mux is embedded below.

Or 16 bit chip

The 16 bit Or chip is again very similar to the 16 bit And chip, except that we use the Or chip to connect the input lines with their corresponding output lines.

And 16 bit chip

The 16 bit And chip is similar to the 16 bit Not chip, except that we use the And chip to connect all the 16 input lines to their corresponding 16 output lines. The code is embedded below.

Not16 Chip

The Not16 chip is very similar to the Not chip, except that it has 16 input lines and corresponding 16 output lines.

We need to use 16 Not chips, where we connect each input line to the corresponding output line. I thought HDL might have a loop structure where I could specify the 6 Not chips, but looks like it does not. Had to manually specify the 16 Not chips. The code for the chip is specified below.