THE TABLE PROVIDED MUST BE USED FOR THE CIRCUIT. I CAN’T MAKE MY OWN VALUES.

for example 0011 MUST equal the hexadecimal value C for the project

- You will need Logisim to complete this project assignment. Further information about LogiSim is at http://www.cburch.com/logisim/. If you have not done so already, download and install Logisim 2.7.1 from http://sourceforge.net/projects/circuit/.

The objective of this project is to reinforce your understanding of binary codes, combinational logic design, and logic simulation. You must: (i) design a combinational logic circuit that displays the hexadecimal value of a gray code input according to the specifications given below; (ii) debug and test your design by simulating it using the Logisim simulator; and (iii) document your work in a short report.

Consider a system where a value is changed by being incremented or decremented by one. The value is encoded by *n* binary signals. As a specific example, consider a value, represented with 4 bits, being incremented from 3 to 4. In a traditional weighted binary encoding, 3 is represented as 0011 and 4 is represented as 0100. For the change from 3 to 4, three bits must change. Since the time of the transitions in the actual signals will always be different if examined at a sufficiently fine scale, the value will not change instantaneously from 3 to 4. As an example, the transition could occur as follows, where the transitions to value 7 and then value 5 are transient in nature.

0011 (3) ® 0111 (7) ® 0101 (5) ® 0100 (4)

The physical reality of such signal transitions can create problems for applications including mechanical encoders and asynchronous (clock-free) systems. This problem can be overcome using Gray codes, which are non-weighted codes that can be used to represent values. Gray codes have the special property that any two adjacent values differ in just one bit. For example, the standard four-bit Gray code for 3 is 0010 and the code for 4 is 0110. These two codes differ in just one bit, the second bit from the left. So, only a single signal needs to change from 0 to 1 (or 1 to 0 for other values) to represent an adjacent value. You can read more about Gray codes at http://en.wikipedia.org/wiki/Gray_code.

For this project we consider a special type of Gray code called a Balanced Gray code. In a Balanced Gray code, the number of transitions for each bit position is the same when counting through the values. For example, a four-bit Balanced Gray code can be used to count from 0 to 15 (hexadecimal F). There are 16 transitions as the count goes from 0 to 1 to 2 and so on to 15 and then back to 0. For a Balanced Gray code, there are four bit transitions for each of the four bit positions during the 16 total transitions. This property is useful in some applications.

Table I below shows the encoding of hexadecimal values 0 through F using a 4-bit Balanced Gray code.

Table I. Hexadecimal Values and Associated 4-bit Balanced Gray Code and Binary Code

HexadecimalValue |
Balanced Gray Code( X_{3 }X_{2 }X_{1 }X_{0}) |
BinaryCode ( Y_{3 }Y_{2 }Y_{1 }Y_{0}) |

0 | 0 0 0 0 | 0 0 0 0 |

1 | 1 0 0 0 | 0 0 0 1 |

2 | 1 1 0 0 | 0 0 1 0 |

3 | 1 1 0 1 | 0 0 1 1 |

4 | 1 1 1 1 | 0 1 0 0 |

5 | 1 1 1 0 | 0 1 0 1 |

6 | 1 0 1 0 | 0 1 1 0 |

7 | 0 0 1 0 | 0 1 1 1 |

8 | 0 1 1 0 | 1 0 0 0 |

9 | 0 1 0 0 | 1 0 0 1 |

A | 0 1 0 1 | 1 0 1 0 |

B | 0 1 1 1 | 1 0 1 1 |

C | 0 0 1 1 | 1 1 0 0 |

D | 1 0 1 1 | 1 1 0 1 |

E | 1 0 0 1 | 1 1 1 0 |

F | 0 0 0 1 | 1 1 1 1 |

You are to design a combinational logic circuit that accepts a four-bit Balanced Gray code (*X*_{3}* X*_{2}* X*_{1}* X*_{0}) as its input and creates a four-bit output (*Y*_{3}* Y*_{2}* Y*_{1}* Y*_{0}) that uses standard binary encoding to represent the same hexadecimal value. In other words, the circuit translates between the Balanced Gray code input and the binary code output as indicated in Table I. Figure 1 provides a block diagram of the function. You do not need to minimize the logic function or associated circuit, but you may choose to do so.

Note that Table I is not a true truth table in that it is not ordered by input. You can rearrange the rows in Table I to construct a standard truth table with inputs *X*_{3}* X*_{2}* X*_{1}* X*_{0} appearing in order from 0000, 0001, 0010, …, 1111.

Figure 1. Block diagram of the converter function.

Use the Pin device in Logisim’s Wiring library to control the four inputs (*X*_{3}* X*_{2}* X*_{1}* X*_{0}) to the combinational circuit. The Pin device is also available on Logisim’s toolbar. Each pin can be interactively set to 0 or 1 using Logisim’s Poke tool to test the circuit for different Balanced Gray code input values. If the proper connections are in place when Logisim is running, signals with logic level 1 appear in bright green and signals with logic level 0 are shown in dark green.

The circuit’s four output bits should be used to control a hexadecimal display to show values 0 through F, inclusive. Use the Hex Digit Display device in Logisim’s Input/Output library. It accepts a 4-bit binary encoded value as input and displays the hexadecimal digit corresponding to the binary-encoded input. Use the Splitter device in Logisim’s Wiring library to interface the four individual single bits produced by the combinational circuit (*Y*_{3}* Y*_{2}* Y*_{1}* Y*_{0}) to the four-bit wide input to the Hex Digit Display. The Hex Digit Display device has a second input to control the decimal (hexadecimal) point. The decimal point input can be left unconnected.

Figure 2 shows a possible layout for the design. The associated Logisim circuit file is provided with this assignment.

Figure 2. Possible circuit layout including logic to produce output *Y*_{0} (input is for Balanced Gray Code value 0011 which produces output 1100 or hexadecimal C).

The design in Figure 2 includes the combinational logic to produce output Y0. By observation, we see that output Y0 is true if and only if there are an odd number of logic 1 inputs. Thus, Y0 is implemented by the exclusive-or (XOR) function, i.e., Y0 = X3 Å X2 Å X1 Å X0. For the Logisim XOR Gate, the Multiple-Input Behavior attribute needs to be set to “When an odd number are on.”

After you create your design, use Logisim to simulate the code conversion circuit. You should test all 16 possible input combinations and verify that the correct values of *Y*_{3}, *Y*_{2},* Y*_{1}, and* Y*_{0} are produced and that the correct hexadecimal value is displayed.

Basic features

- Free title page and bibliography
- Unlimited revisions
- Plagiarism-free guarantee
- Money-back guarantee
- 24/7 support

On-demand options

- Writer’s samples
- Part-by-part delivery
- Overnight delivery
- Copies of used sources
- Expert Proofreading

Paper format

- 275 words per page
- 12 pt Arial/Times New Roman
- Double line spacing
- Any citation style (APA, MLA, Chicago/Turabian, Harvard)