public Memory(int iAddressSize, int iWordSize)
{
AddressSize = iAddressSize;
WordSize = iWordSize;
int registerNum = (int)Math.Pow(2.0, AddressSize);
Input = new WireSet(WordSize);
Output = new WireSet(WordSize);
Address = new WireSet(AddressSize);
Load = new Wire();
WireSet newLoad = new WireSet(1);
newLoad[0].ConnectInput(Load);
demux = new BitwiseMultiwayDemux(1, AddressSize);
mux = new BitwiseMultiwayMux(WordSize, AddressSize);
registers = new MultiBitRegister[registerNum];
WireSet AddressMirror = new WireSet(AddressSize);
for (int j = 0; j < AddressSize; j++)
{
AddressMirror[j].ConnectInput(Address[AddressSize - 1 - j]);
}
demux.ConnectControl(AddressMirror);
demux.ConnectInput(newLoad);
for (int i = 0; i < registerNum; i++)
{
registers[i] = new MultiBitRegister(WordSize);
registers[i].ConnectInput(Input);
registers[i].Load.ConnectInput(demux.Outputs[i][0]);
mux.ConnectInput(i, registers[i].Output);
}
mux.ConnectControl(Address);
Output.ConnectInput(mux.Output);
}
//your code here
public Memory(int iAddressSize, int iWordSize)
{
AddressSize = iAddressSize;
WordSize = iWordSize;
Input = new WireSet(WordSize);
Output = new WireSet(WordSize);
Address = new WireSet(AddressSize);
Load = new Wire();
int numOfbits = (int)Math.Pow(2, AddressSize);
var mBitwiseMultiwayDemux = new BitwiseMultiwayDemux(1, AddressSize);
var mBitwiseMultiwayMux = new BitwiseMultiwayMux(WordSize, AddressSize);
var mRegisters = new MultiBitRegister[numOfbits];
mRegisters[0] = new MultiBitRegister(iWordSize);
for (int i = 0; i < numOfbits; i++)
{
if (i == 0)
{
mBitwiseMultiwayDemux.Input[0].ConnectInput(Load);
mBitwiseMultiwayDemux.ConnectControl(Address);
mRegisters[0].ConnectInput(Input);
mRegisters[0].Load.ConnectInput(mBitwiseMultiwayDemux.Outputs[0][0]);
mBitwiseMultiwayMux.ConnectInput(0, mRegisters[0].Output);
continue;
}
mRegisters[i] = new MultiBitRegister(iWordSize);
mRegisters[i].ConnectInput(Input);
mRegisters[i].Load.ConnectInput(mBitwiseMultiwayDemux.Outputs[i][0]);
mBitwiseMultiwayMux.ConnectInput(i, mRegisters[i].Output);
}
mBitwiseMultiwayMux.ConnectControl(Address);
Output = mBitwiseMultiwayMux.Output;
}
static void Main(string[] args)
{
AndGate and = new AndGate();
OrGate or = new OrGate();
XorGate xor = new XorGate();
MuxGate mux = new MuxGate();
Demux demux = new Demux();
HalfAdder ha = new HalfAdder();
FullAdder fa = new FullAdder();
if (!and.TestGate())
{
Console.WriteLine("bugbug");
}
Console.WriteLine("done And");
if (!or.TestGate())
{
Console.WriteLine("bugbug");
}
Console.WriteLine("done Or");
if (!xor.TestGate())
{
Console.WriteLine("bugbug");
}
Console.WriteLine("done Xor");
if (!mux.TestGate())
{
Console.WriteLine("bugbug");
}
Console.WriteLine("done Mux");
if (!demux.TestGate())
{
Console.WriteLine("bugbug");
}
Console.WriteLine("done Demux");
if (!ha.TestGate())
{
Console.WriteLine("bugbug");
}
Console.WriteLine("done HalfAdder");
if (!fa.TestGate())
{
Console.WriteLine("bugbug");
}
Console.WriteLine("done FullAdder");
WireSet num = new WireSet(4);
num.SetValue(6);
Console.WriteLine(num.ToString());
Console.WriteLine(num.GetValue());
Console.WriteLine("trying 2's complement");
WireSet num2 = new WireSet(4);
num2.Set2sComplement(6);
Console.WriteLine(num2.Get2sComplement());
WireSet num3 = new WireSet(4);
num3.Set2sComplement(-2);
Console.WriteLine(num3.Get2sComplement());
BitwiseAndGate BWAnd = new BitwiseAndGate(3);
BWAnd.TestGate();
BitwiseNotGate BWNot = new BitwiseNotGate(3);
BWNot.TestGate();
BitwiseOrGate BWOr = new BitwiseOrGate(3);
BWOr.TestGate();
BitwiseMux BWMux = new BitwiseMux(3);
BWMux.TestGate();
BitwiseDemux BWDemux = new BitwiseDemux(3);
BWDemux.TestGate();
MultiBitAndGate multiAnd = new MultiBitAndGate(3);
multiAnd.TestGate();
MultiBitAdder multiAdd = new MultiBitAdder(5);
multiAdd.TestGate();
BitwiseMultiwayMux multimux = new BitwiseMultiwayMux(8, 2);
WireSet[] inp = new WireSet[4];
inp[0] = new WireSet(8);
inp[0].Set2sComplement(1);
multimux.ConnectInput(0, inp[0]);
inp[1] = new WireSet(8);
inp[1].Set2sComplement(2);
multimux.ConnectInput(1, inp[1]);
inp[2] = new WireSet(8);
inp[2].Set2sComplement(3);
multimux.ConnectInput(2, inp[2]);
inp[3] = new WireSet(8);
inp[3].Set2sComplement(4);
multimux.ConnectInput(3, inp[3]);
WireSet control = new WireSet(2);
control.Set2sComplement(3);
multimux.ConnectControl(control);
multimux.TestGate();
BitwiseMultiwayDemux multidemux = new BitwiseMultiwayDemux(8, 1);
ALU alu = new ALU(16);
alu.TestGate();
SingleBitRegister sbr = new SingleBitRegister();
if (sbr.TestGate())
{
Console.WriteLine("sbr IS OK");
}
MultiBitRegister mbr = new MultiBitRegister(8);
if (mbr.TestGate())
{
Console.WriteLine("mbr IS OK");
}
Memory mem = new Memory(3, 6);
if (mem.TestGate())
{
Console.WriteLine("mem IS OK");
}
Console.ReadLine();
}
public ALU(int iSize)
{
Size = iSize;
InputX = new WireSet(Size);
InputY = new WireSet(Size);
ZeroX = new Wire();
ZeroY = new Wire();
NotX = new Wire();
NotY = new Wire();
F = new Wire();
NotOutput = new Wire();
Negative = new Wire();
Zero = new Wire();
//Create and connect all the internal components
Output = new WireSet(Size);
m_wsZero = new WireSet(Size);
for (int i = 0; i < Size; i++)
{
m_wsZero[i].Value = 0;
}
m_gZxMux = new BitwiseMultiwayMux(Size, 1);
m_gZxMux.ConnectInput(0, InputX);
m_gZxMux.ConnectInput(1, m_wsZero);
m_gZxMux.Control[0].ConnectInput(ZeroX);
m_gNxNot = new BitwiseNotGate(Size);
m_gNxNot.ConnectInput(m_gZxMux.Output);
m_gNxMux = new BitwiseMultiwayMux(Size, 1);
m_gNxMux.ConnectInput(0, m_gZxMux.Output);
m_gNxMux.ConnectInput(1, m_gNxNot.Output);
m_gNxMux.Control[0].ConnectInput(NotX);
m_gZyMux = new BitwiseMultiwayMux(Size, 1);
m_gZyMux.ConnectInput(0, InputY);
m_gZyMux.ConnectInput(1, m_wsZero);
m_gZyMux.Control[0].ConnectInput(ZeroY);
m_gNyNot = new BitwiseNotGate(Size);
m_gNyNot.ConnectInput(m_gZyMux.Output);
m_gNyMux = new BitwiseMultiwayMux(Size, 1);
m_gNyMux.ConnectInput(0, m_gZyMux.Output);
m_gNyMux.ConnectInput(1, m_gNyNot.Output);
m_gNyMux.Control[0].ConnectInput(NotY);
m_gFAdder = new MultiBitAdder(Size);
m_gFAdder.ConnectInput1(m_gNxMux.Output);
m_gFAdder.ConnectInput2(m_gNyMux.Output);
m_gFAnd = new BitwiseAndGate(Size);
m_gFAnd.ConnectInput1(m_gNxMux.Output);
m_gFAnd.ConnectInput2(m_gNyMux.Output);
m_gFMux = new BitwiseMultiwayMux(Size, 1);
m_gFMux.ConnectInput(0, m_gFAnd.Output);
m_gFMux.ConnectInput(1, m_gFAdder.Output);
m_gFMux.Control[0].ConnectInput(F);
m_gNoNot = new BitwiseNotGate(Size);
m_gNoNot.ConnectInput(m_gFMux.Output);
m_gNoMux = new BitwiseMultiwayMux(Size, 1);
m_gNoMux.ConnectInput(0, m_gFMux.Output);
m_gNoMux.ConnectInput(1, m_gNoNot.Output);
m_gNoMux.Control[0].ConnectInput(NotOutput);
Output.ConnectInput(m_gNoMux.Output);
m_gZrOr = new MultiBitOrGate(Size);
m_gZrOr.ConnectInput(Output);
m_gZrNot = new NotGate();
m_gZrNot.ConnectInput(m_gZrOr.Output);
Zero.ConnectInput(m_gZrNot.Output);
Negative.ConnectInput(Output[Size - 1]);
}
