$29
Project 2 - Interrupts
We have spent the last few weeks implementing our 32-bit datapath. The simple 32-bit LC-2222 is capable of performing advanced computational tasks and logical decision making. Now it is time for us to move on to something more advanced—the upgraded LC-2222a enables the ability for programs to be interrupted. Your assignment is to fully implement and test interrupts using the provided datapath and CircuitSim. You will hook up the interrupt and data lines to the new timer device, modify the datapath and microcontroller to support interrupt operations, and write an interrupt handler to operate this new device. You will also use the tiny, inexpensive LC-2222a as an embedded system to monitor a kitchen appliance.
Requirements
Before you begin, please ensure you have done the following:
Download the proper version of CircuitSim. A copy of CircuitSim is available under Files on Grade-scope. You may also download it from the CircuitSim website (https://ra4king.github.io/CircuitSim/). In order to run CircuitSim, Java must be installed. If you are a Mac user, you may need to right-click on the JAR file and select “Open” in the menu to bypass Gatekeeper restrictions.
CircuitSim is still under development and may have unknown bugs. Please back up your work using some form of version control, such as a local/private git repository or Dropbox. Do not use public git repositories; it is against the Georgia Tech Honor Code.
The LC-2222a assembler is written in Python. If you do not have Python 2.6 or newer installed on your system, you will need to install it before you continue.
What We Have Provided
A reference guide to the LC-2222a is located in Appendix A: LC-2222a Instruction Set Architecture. Please read this first before you move on! The reference introduces several new instructions that you will implement for this project.
A microcode file (microcode.xlsx) that meets the requirements of Project 1; however, feel free to supply your own. This microcode file has a new configuration with additional bits for the new signals that will be added in this project
A timer device that will generate an interrupt signal at regular intervals. The pinout and functionality of this device are described in Adding an External Timer Device.
A distance tracker that will generate an interrupt signal at regular intervals, and provides distance tracker readings. The pinout and functionality of this device are described in Adding a Distance Tracker.
An incomplete assembly program prj2.s that you will complete and use to test your interrupt capa-bilities.
An assembler with support for the new instructions to assemble the test program.
A completed LC-2222 datapath circuit (LC-2222a.sim) from Project 1 is provided. Use this as a base to add the basic interrupt support for the LC-2222a or build off of your own Project 1 datapath, but you must rename the file toLC-2222a.sim. Most of the work can be easily carried over from one datapath to another.
Project 2 Computer Systems and Networks Fall 2023
Phase 1 - Implementing a Basic Interrupt
Datapath
DrData
DATA
Project 2 Computer Systems and Networks Fall 2023
by using a specific gate to act like a pull-down resistor so that there is always a value asserted (See Appendix C for more information)..
When a device receives an IntAck signal, it will drive a 32-bit device ID onto the I/O Data Bus. To prevent devices from interfering with the processor, the I/O Data Bus is attached to the Main Bus with a tri-state driver. Create this driver and the bus, and attach the microcontroller’s DrDATA signal to the driver.
Modify the datapath so that the PC starts at 0x08 when the processor is reset. Normally the PC starts at 0x00, however we need to make space for the interrupt vector table (IVT). Therefore, when you actually load in the test code that you will write, it needs to start at 0x08. Please make sure that your solution ensures that datapath can never execute from below 0x08 - or in other words, force the PC to drive the value 0x08 if the PC is pointing in the range of the interrupt vector table.
Create hardware to support selecting the register $k0 within the microcode. This is needed by some interrupt related instructions. Because we need to access $k0 outside of regular instructions, we cannot use the Rx / Ry / Rz bits. HINT: Use only the register selection bits that the main ROM already outputs to select $k0. Notice that there is an unused input to the RegSel multiplexer.
4.2 Adding an External Timer Device
Hardware timers are an essential device in any CPU design. They allow the CPU to monitor the passing of various time intervals, without dedicating CPU instructions to the cause.
The ability of timers to raise interrupts also enables preemptive multitasking, where the operating system periodically interrupts a running process to let another process take a turn. Timers are also essential to ensuring a single misbehaving program cannot freeze up your entire computer.
You will connect an external timer device to the datapath. It is internally configured to have a device ID of 0x0 and interrupt every 2000 clock ticks.
The pinout of the timer device is described below. If you like, you may also examine the internals of the device in CircuitSim.
CLK: The clock input to the device. Make sure you connect this to the same clock as the rest of your circuit.
INT: The device will begin to assert this line when its time interval has elapsed. It will not be lowered until the cycle after it receives an INTA signal.
INTA IN: When the INTA IN line is asserted while the device has asserted the INT line, it will drive its device ID to the DATA line and lower its INT line on the next clock cycle.
INTA OUT: When the INTA IN line is asserted while the device does not have an interrupt pending, its value will be propagated to INTA OUT. This allows for daisy chaining of devices.
DATA: The device will drive its ID (0x0) to this line after receiving an INTA.
The INT and DATA lines from the timer should be connected to the appropriate buses that you added in the previous section.
4.3 Microcontroller Interrupt Support
Before beginning this part, be sure you have read through Appendix A: LC-2222a Instruction Set Architecture and Appendix B: Microcontrol Unit and pay special attention to the new instructions. However, for this part of the project, you do not need to worry about the LdDAR signal or the IN instruction.
In this part of the assignment you will modify the microcontroller and the microcode of the LC-2222a to support interrupts. You will need to do the following:
Project 2 Computer Systems and Networks Fall 2023
Be sure to read the appendix on the microcontroller before starting this section.
Modify the microcontroller to support asserting four new signals:
LdEnInt & EnInt to control whether interrupts are enabled/disabled. You will use these 2 signals to control the value of your interrupts enabled register.
IntAck to send an interrupt acknowledge to the device.
DrDATA to drive the value on the I/O Data Bus to the Main Bus.
Extend the size of the ROM accordingly.
Add the fourth ROM described in Appendix B: Microcontrol Unit to handle onInt.
Modify the FETCH macrostate microcode so that we actively check for interrupts. Normally this is done within the INT macrostate (as described in Chapter 4 of the book and in the lectures) but we are rolling this functionality in the FETCH macrostate for the sake of simplicity. You can accomplish this by doing the following:
First check to see if the CPU should be interrupted. To be interrupted, two conditions must be true: (1) interrupts are enabled (i.e., the IE register must hold a ’1’), and (2), a device must be asserting a ’1’ on the INT signal line.
If not, continue with FETCH normally.
If the CPU should be interrupted, then perform the following:
Save the current PC to the register $k0.
Disable interrupts.
Assert the interrupt acknowledge signal (IntAck). Next, drive the device ID from the I/O Data Bus and use it to index into the interrupt vector table to retrieve the new PC value. The device will drive its device ID onto the I/O Data Bus one clock cycle after it receives the IntAck signal.
This new PC value should then be loaded into the PC.
Note: onInt works in the same manner that CmpOut did in Project 1. The processor should branch to the appropriate microstate depending on the value of onInt. onInt should be true when interrupts are enabled AND when there is an interrupt to be acknowledged. Note: The mode bit mechanism and user/kernel stack separation discussed in the textbook has been omitted for simplicity.
Implement the microcode for three new instructions for supporting interrupts as described in Chapter
These are the EI, DI, and RETI instructions. You need to write the microcode in the main ROM controlling the datapath for these three new instructions. Keep in mind that:
EI sets the IE register to 1.
DI sets the IE register to 0.
RETI loads $k0 into the PC, and enables interrupts.
4.4 Implementing the Timer Interrupt Handler
Our datapath and microcontroller now support receiving interrupts from devices, BUT we must now imple-ment the interrupt handler timer_handler within the prj2.s file to handle interrupts from the timer device while also not interfering with the correct operation of any user programs.
In prj2.s, we provide you with a modified version of pow.s that will run while you are waiting for interrupts.
For this part of the project, you need to write the interrupt handler for the timer device (device ID 0x0).
Project 2 Computer Systems and Networks Fall 2023
You should refer to Chapter 4 of the textbook to see how to write a correct interrupt handler. As detailed in that chapter, your handler will need to do the following:
First save the current value of $k0 (the return address to where you came from to the current handler)
Enable interrupts (which should have been disabled implicitly by the processor within the INT macrostate).
Save the state of the interrupted program.
Implement the actual work to be done in the handler. In the case of this project, we want you to increment a counter variable in memory, which we have already provided.
Restore the state of the original program and return using RETI.
The handler you have written for the timer device should run every time the device’s interrupt is triggered. Make sure to write the handler such that interrupts can be nested. With that in mind, interrupts should be disabled for as few instructions as possible within the handlers.
You will need to do the following:
Write the interrupt handler (should follow the above instructions or simply refer to Chapter 4 in your book). In the case of this project, we want the interrupt handler to keep track of time in memory at the predetermined location: 0xFFFF
Load the starting address of the first handler you just implemented in prj2.s into the interrupt vector table at the appropriate addresses (the table is indexed using the device ID of the interrupting device).
Test your design before moving onto the next section. If it works correctly, you should see the value at address 0xFFFF in memory increment as the program runs.
Project 2 Computer Systems and Networks Fall 2023
Phase 2 - Implementing Interrupts from Input Devices
Project 2 Computer Systems and Networks Fall 2023
Modify the microcontroller to support a new control signal, LdDAR. This signal will be used in order to enable writing to the DAR.
Implement the IN instruction in your microcode. This instruction takes a device address an immediate offset (IR[19:0]), loads it into the DAR, and writes the value on the data bus into a register. When it is done, it must clear the DAR (since interrupts use the data bus to communicate device IDs). Examine the format of the IN instruction and consider what signals you might raise in order to write a constant zero into the DAR.
5.2 Adding a Distance Tracker
You will connect a distance tracker to your datapath that simulates a distance tracker by returning the current distance. Its internals are similar to the timer device, meaning it asserts interrupts and handles acknowledgments in the same way. Every 1000 cycles, it will assert an interrupt signaling that a distance value has been captured. This distance can be fetched as a 32-bit word by writing the device’s address to the ADDR line.
The distance tracker is internally configured to have a device ID of 0x1.
Place the distance tracker in your datapath circuit. This device will share the INT and DATA lines with the timer you added previously. However, it should receive its INTA signal from the INTA OUT pin on the timer device. This ensures that if both the timer and distance tracker raise an interrupt at the same time, the timer will be acknowledged first, and the distance tracker will be acknowledged after. This is known as “daisy chaining” devices.
5.3 Implementing the Distance Tracker Handler
Now that your LC-2222a datapath can accept data from your distance tracker, we need to decide what to do with the data. In this case, we want to keep track of the maximum and minimum distance we have seen so far in two particular memory locations, 0xFFFD and 0xFFFC. You’ll have to implement this logic in your handler, which will work similarly to the one you wrote for the timer device. However, instead of incrementing a timer at a memory location, you will be keeping track of the maximum and minimum distance we have seen so far. You will also keep track of the range between the maximum and minimum distances we have seen so far.
In addition to the usual overhead of an interrupt handler, your distance tracker handler must do the following:
Use the IN instruction to obtain the most recently captured distance value from the distance tracker.
Write the value obtained from the distance tracker to the memory location with the address 0xFFFD only if the value is greater than the current maximum or the address 0xFFFC only if the value is less than the current minimum.
Calculate the range and store it in address 0xFFFE.
Make sure that you properly install the location of the new handler into the IVT.
The distance tracker hardware is designed to emit a sequence of numbers representing distance readings. If your design is working properly, you should see the value stored in the memory location 0xFFFD increase and 0xFFFC decrease after a few thousand clock cycles as it updates when a new distance value is pushed onto the datapath.
To validate you’re updating the distance expended correctly, you can check the values that the distance tracker will emit by inspecting the internals of the circuit and checking the values in the ROM labeled ‘Key Buffer’.
Project 2 Computer Systems and Networks Fall 2023
Autograder
Similar to the autograder for Project 1, Project 2 autograder will execute your prj2.s using your datapath and simulate the interrupt handling process. It will tell you if your handler codes complete their jobs. Your final grade will not be determined by whether you pass the autograder or not. Feel free to use it as a tool to help you debug your circuit and assembly code, but you won’t be able to rely on it entirely. You must still figure out which part of your datapath/microcode/handler code is not functioning as expected. If you want to use the autograder, you must follow a few rules:
Don’t rename the components that already exist
Name your IE register as “IE”
Name your Interrupt ROM as “INT”
Use only one clock globally.
Use only one RAM as memory.
Don’t change the layout of the microcode Excel sheet
If you changed the constants in devices for debugging purposes, remember to change them back.
If the autograder fails you, please first double-check if you meet all the rules above and those in Project 1. If the autograder points you to a device handler, try to load the assembled HEX of your prj2.s program into your RAM, clock it until the device interrupts, and check state by state to see if any component goes wrong when handling that interrupt. Sometimes, you may not reproduce the error when that device interrupts for the first time. In that case, you need to monitor all the following interrupts of that device to locate the problem.
When you get an error message, please first try to reproduce it locally and think about what you observe. If you still don’t know how to approach it, come to office hours or make a private post with a detailed explanation of your attempts of debugging, instead of just a post with the error message and a screenshot of your datapath. TAs won’t be able to help you solve the problem with that little amount of information.
Deliverables
To submit your project, you need to upload the following files to Gradescope:
CircuitSim datapath file (LC-2222a.sim)
Microcode file (microcode.xlsx)
Assembly code (prj2.s)
If you are missing any of those files, you will get a 0, so make sure that you have uploaded all three of them.
Always re-download your assignment from Gradescope after submitting to ensure that all necessary files were properly uploaded. If what we download does not work, you will get a 0 regardless of what is on your machine.
This project will be demoed. In order to receive full credit, you must sign up for a demo slot and complete the demo. We will announce when demo times are released.
Project 2 Computer Systems and Networks Fall 2023
Appendix A: LC-2222a Instruction Set Architecture
The LC-2222a is a simple, yet capable computer architecture. The LC-2222a combines attributes of both ARM and the LC-2200 ISA defined in the Ramachandran & Leahy textbook for CS 2200.
The LC-2222a is a word-addressable, 32-bit computer. All addresses refer to words, i.e. the first word (four bytes) in memory occupies address 0x0, the second word, 0x1, etc.
All memory addresses are truncated to 16 bits on access, discarding the 16 most significant bits if the address was stored in a 32-bit register. This provides roughly 64 KB of addressable memory.
8.1 Registers
The LC-2222a has 16 general-purpose registers. While there are no hardware-enforced restraints on the uses of these registers, your code is expected to follow the conventions outlined below.
Table 1: Registers and their Uses
Register Number
Name
Use
Callee Save?
0
$zero
Always Zero
NA
1
$at
Assembler/Target Address
NA
2
$v0
Return Value
No
3
$a0
Argument 1
No
4
$a1
Argument 2
No
5
$a2
Argument 3
No
6
$t0
Temporary Variable
No
7
$t1
Temporary Variable
No
8
$t2
Temporary Variable
No
9
$s0
Saved Register
Yes
10
$s1
Saved Register
Yes
11
$s2
Saved Register
Yes
12
$k0
Reserved for OS and Traps
NA
13
$sp
Stack Pointer
No
14
$fp
Frame Pointer
Yes
15
$ra
Return Address
No
Register 0 is always read as zero. Any values written to it are discarded. Note: for the purposes of this project, you must implement the zero register. Regardless of what is written to this register, it should always output zero.
Register 1 is used to hold the target address of a jump. It may also be used by pseudo-instructions generated by the assembler.
Register 2 is where you should store any returned value from a subroutine call.
Registers 3 - 5 are used to store function/subroutine arguments. Note: registers 2 through 8 should be placed on the stack if the caller wants to retain those values. These registers are fair game for the callee (subroutine) to trash.
Registers 6 - 8 are designated for temporary variables. The caller must save these registers if they want these values to be retained.
Registers 9 - 11 are saved registers. The caller may assume that these registers are never tampered with by the subroutine. If the subroutine needs these registers, then it should place them on the stack and restore them before they jump back to the caller.
Register 12 is reserved for handling interrupts. While it should be implemented, it otherwise will not have any special use on this assignment.
Project 2 Computer Systems and Networks Fall 2023
Register 13 is the everchanging top of the stack; it keeps track of the top of the activation record for a subroutine.
Register 14 is the anchor point of the activation frame. It is used to point to the first address on the activation record for the currently executing process.
Register 15 is used to store the address a subroutine should return to when it is finished executing.
8.2 Instruction Overview
The LC-2222a supports a variety of instruction forms, only a few of which we will use for this project. The instructions we will implement in this project are summarized below.
Table 2: LC-2222a Instruction Set
31302928272625242322212019181716151413121110 9 8 7 6 5 4 3 2 1 0
ADD
0000
DR
SR1
unused
SR2
NAND
0001
DR
SR1
unused
SR2
ADDI
0010
DR
SR1
immval20
LW
0011
DR
BaseR
offset20
SW
0100
SR
BaseR
offset20
BEQ
0101
SR1
SR2
offset20
JALR
0110
AT
RA
unused
HALT
0111
unused
BLT
1000
SR1
SR2
offset20
LEA
1001
DR
unused
PCoffset20
BGT
1010
SR1
SR2
offset20
OR
1011
DR
SR1
unused
0
SR2
XOR
1011
DR
SR1
unused
1
SR2
EI
1100
unused
DI
1101
unused
RETI
1110
unused
IN
1111
DR
0000
addr20
8.2.1 Conditional Branching
Branching in the LC-2222a ISA is a bit different than usual. We have a set of branching instructions including BEQ, BLT, and BGT, which offer the ability to branch upon a certain condition being met. These instructions use comparison operators, comparing the values of two source registers. If the comparisons are true (for example, with the BGT instruction, if SR1 > SR2), then we will branch to the target destination of incrementedPC + offset20.
Project 2 Computer Systems and Networks Fall 2023
8.3 Detailed Instruction Reference
8.3.1
ADD
Assembler Syntax
ADD
DR, SR1, SR2
Encoding
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10
9
8
7
6
5
4
3
2
1
0
Project 2
Computer Systems and Networks
Fall 2023
8.3.3
ADDI
Assembler Syntax
ADDI
DR, SR1, immval20
Encoding
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10
9
8
7
6
5
4
3
2
1
0
Project 2 Computer Systems and Networks Fall 2023
8.3.7 JALR
Assembler Syntax
JALR AT, RA
Encoding
31302928272625242322212019181716151413121110 9 8 7 6 5 4 3 2 1 0
Project 2
Computer Systems and Networks
Fall 2023
8.3.10
LEA
Assembler Syntax
LEA
DR, label
Encoding
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10
9
8
7
6
5
4
3
2
1
0
Project 2 Computer Systems and Networks Fall 2023
8.3.14 EI
Assembler Syntax
EI
Encoding
31302928272625242322212019181716151413121110 9 8 7 6 5 4 3 2 1 0
Project 2 Computer Systems and Networks Fall 2023
8.3.16 RETI
Assembler Syntax
RETI
Encoding
31302928272625242322212019181716151413121110 9 8 7 6 5 4 3 2 1 0
Project 2 Computer Systems and Networks Fall 2023
Appendix B: Microcontrol Unit
You will make a microcontrol unit which will drive all of the control signals to various items on the datapath. This Finite State Machine (FSM) can be constructed in a variety of ways. You could implement it with combinational logic and flip flops, or you could hard-wire signals using a single ROM. The single ROM solution will waste a tremendous amount of space since most of the microstates do not depend on the opcode or the conditional test to determine which signals to assert. For example, since the condition line is an input for the address, every microstate would have to have an address for condition = 0 as well as condition = 1, even though this only matters for one particular microstate.
To solve this problem, we will use a four ROM microcontroller which will also handle interrupts. In this arrangement, we will have 4 ROMs:
the main ROM, which outputs the control signals,
the sequencer ROM, which helps determine which microstate to go to at the end of the FETCH state,
the condition ROM, which helps determine whether or not to skip during BLT instructions,
and the interrupt ROM, which helps determine whether the next state is fetch2 or the start of the INT macrostate.
Examine the following:
Figure 3: Four ROM Microcontrol Unit
As you can see, there are four different locations that the next state can come from: part of the output from the previous state (main ROM), the sequencer ROM, the condition ROM, and the interrupt ROM. The mux controls which of these sources gets through to the state register. If the previous state’s “next state” field
Project 2 Computer Systems and Networks Fall 2023
determines where to go, neither the OPTest nor ChkCmp signals will be asserted. If the opcode from the IR determines the next state (such as at the end of the FETCH state), the OPTest signal will be asserted. If the comparison circuitry determines the next state (such as in the BLT instruction), the ChkCmp signal will be asserted. If an interrupt needs to be dealt with (entering the INT macrostate), the OPTest and ChkCmp signal will be asserted.
Note that these two signals should never be asserted at the same time since nothing is input into the “11” pin on the MUX.
The sequencer ROM should have one address per instruction, and the condition ROM should have one address for condition true and one for condition false.
Before getting down to specifics you need to determine the control scheme for the datapath. To do this examine each instruction, one by one, and construct a finite state bubble diagram showing exactly what control signals will be set in each state. Also determine what are the conditions necessary to pass from one state to the next. You can experiment by manually controlling your control signals on the bus you’ve created in Phase 1 - Implementing a Basic Interrupt to make sure that your logic is sound.
Once the finite state bubble diagram is produced, the next step is to encode the contents of the Control Unit ROM. Then you must design and build (in CircuitSim) the Control Unit circuit which will contain the four ROMs, a MUX, and a state register. Your design will be better if it allows you to single step and ensure that it is working properly. Finally, you will load the Control Unit’s ROMs with the hexadecimal generated by your filled out microcode.xlsx.
Note that the input address to the ROM uses bit 0 for the lowest bit of the current state and 5 for the highest bit for the current state.
Table 3: ROM Output Signals
Bit
Purpose
Bit
Purpose
Bit
Purpose
Bit
Purpose
Bit
Purpose
Bit
Purpose
0
NextState[0]
6
DrREG
12
LdPC
18
WrREG
24
OPTest
30
LdDAR
1
NextState[1]
7
DrMEM
13
LdIR
19
WrMEM
25
ChkCmp
2
NextState[2]
8
DrALU
14
LdMAR
20
RegSel[0]
26
LdEnInt
3
NextState[3]
9
DrALU2
15
LdA
21
RegSel[1]
27
EnInt
4
NextState[4]
10
DrPC
16
LdB
22
ALU[0]
28
IntAck
5
NextState[5]
11
DrOFF
17
LdCmp
23
ALU[1]
29
DrData
Table 4: Register Selection Map
RegSel[1]
RegSel[0]
Register
0
0
RX (IR[27:24])
0
1
RY (IR[23:20])
1
0
RZ (IR[3:0])
1
1
$k0 (1100)
Table 5: ALU Function Map
Func[1]
Func[0]
Function
0
0
ADD
0
1
SUB
1
0
NAND
1
1
A + 1
Project 2 Computer Systems and Networks Fall 2023
10 Appendix C: Pull Down and Pull Up Resistors
10.1 Intro
In CS 2200 and CS 2110, you’ve built functional logic gates that don’t need to consider the physical variables of real circuit logic. There is another way that only needs half the number of transistors. This method works best with discrete components (but our two-transistor style is better with integrated circuits as the transistors takes less chip space overall).
10.2 How we build our logic gates
We build our gates so that the output is either connected to Vcc or Ground depending on the calculated output value. What we could do is build the gate so that the output is connected to one side of the power bus (either Vcc or Ground) when the output should be that value. When the output is the opposite value, we leave the output floating. This by itself would give us an unpredictable output value, but not if we connect a small resistor (known as a pull-up or pull down resistor depending on whether it is connected to Vcc or Ground, respectively) between the gate’s output line and the opposite side of the power bus.
This resistor allows a tiny bit of current to flow; that current is overwhelmed when the output is connected to Vcc or Ground, but when the output is floating the resistor provides just enough charge to ”pull” the output to the opposite potential. The downstream device is none the wiser, but this saves us about half the transistors in each gate. If you look at most other introductory digital logic textbooks, you may see that the authors build their gates with pull-up and pull-down resistors instead of the ”two- transistor both sides switched” approach that CircuitSim, Patt et al., and Ramachandran et al. use.
See http://www.cs.unca.edu/brock/classes/Fall2012/csci255/labs/lab05.html for a more thorough explanation of the different methods for building gates.
10.3 Why are we telling you this?
Because the INT line is one of the very few situations that we can’t handle with our two-transistor logic style. We need to combine several different signals on the INT line (which are connected by tri-state buffers) that are either 1 or floating (we can’t allow devices to assert a 0 on the INT line because it will cause a short circuit when one of our devices asserts a 1 signal to signal an interrupt).
The way we would handle this in a real circuit would be to simply add a pull-down resistor from the INT line to Ground so that if none of the tri- state buffers are open to assert an interrupt 1 signal, the INT line will reliably read as 0. The immediate issue is that CircuitSim doesn’t understand pull-up and pull-down resistors, so it instead has a reality-distorting ”feature” that allows us to implement the interrupt line without pull-down resistors. The feature is this: A CircuitSim OR gate will consider a floating input line to be a 0.
This is not guaranteed in real life, but it is in CircuitSim. To implement the INT line, you can connect a signal line that is either 1 or floating to one side of an OR gate and connect a 0 to the other input. The output of the OR gate will be 1 if the first input is 1. If the first input is floating (or 0), the output will definitely be 0. The diagram below shows an implementation of the INT line circuit for 3 devices:
Project 2 Computer Systems and Networks Fall 2023
