public Object visit(NAND nand, string s)
{
Label label = getBaseLabel();
label.Content = s + " - " + "NAND";
return(label);
}
//The logic for storing a bit - 4 nand gates
public MemoryUnit()
{
InputA = new Wire();
Output = new Wire();
SetWire = new Wire();
EnableWire = new Wire();
nand1 = new NAND();
nand2 = new NAND();
nand3 = new NAND();
nand4 = new NAND();
enabler = new AND();
nand1.InputA = InputA;
nand1.InputB = SetWire;
nand2.InputB = nand1.Output;
nand2.InputA = SetWire;
nand3.InputA = nand1.Output;
nand3.InputB = nand4.Output;
nand4.InputB = nand2.Output;
nand4.InputA = nand3.Output;
//The enabler section for enabling outputing the value stored in the memory unit
enabler.InputA = nand3.Output;
enabler.InputB = EnableWire;
Output = enabler.Output;
}
private void createGateDueToType(PaintEventArgs e)
{
//switch can be replaced by a one line of code using runtime Creation ((gotta GOOGLE it))
Gate g;
switch (gateType)
{
case "OR":
g = new OR();
break;
case "NOT":
g = new NOT();
break;
case "AND":
g = new AND();
break;
case "NAND":
g = new NAND();
break;
default:
g = null;
break;
}
g.Draw(e);
}
public void NAND_Events_GateOn()
{
// arrange
var nand = new NAND("test");
nand.V.V = VoltageSignal.HIGH;
bool fired = false;
nand.O.Changed += _ => fired = true;
// act, assert
nand.B.V = VoltageSignal.HIGH;
Assert.IsFalse(fired, "Gate on -- A: L; B: ^; no event");
nand.B.V = VoltageSignal.HIGH;
Assert.IsFalse(fired, "Gate on -- A: L; B: -->H; no event");
nand.B.V = VoltageSignal.LOW;
Assert.IsFalse(fired, "Gate on -- A: L; B: v; no event");
nand.B.V = VoltageSignal.LOW;
Assert.IsFalse(fired, "Gate on -- A: L; B: -->L; no event");
nand.A.V = VoltageSignal.HIGH;
Assert.IsFalse(fired, "Gate on -- B: L; A: ^; no event");
nand.A.V = VoltageSignal.HIGH;
Assert.IsFalse(fired, "Gate on -- B: L; A: -->H; no event");
nand.A.V = VoltageSignal.LOW;
Assert.IsFalse(fired, "Gate on -- B: L; A: v; no event");
nand.A.V = VoltageSignal.LOW;
Assert.IsFalse(fired, "Gate on -- B: L; A: -->L; no event");
// setup
nand.A.V = VoltageSignal.HIGH;
nand.B.V = VoltageSignal.LOW;
fired = false;
// test
nand.B.V = VoltageSignal.HIGH;
Assert.IsTrue(fired, "Gate on -- A: H; B: ^; event");
fired = false;
nand.B.V = VoltageSignal.HIGH;
Assert.IsFalse(fired, "Gate on -- A: H; B: -->H; no event");
nand.B.V = VoltageSignal.LOW;
Assert.IsTrue(fired, "Gate on -- A: H; B: v; event");
fired = false;
nand.B.V = VoltageSignal.LOW;
Assert.IsFalse(fired, "Gate on -- A: H; B: -->L; no event");
// setup
nand.A.V = VoltageSignal.LOW;
nand.B.V = VoltageSignal.HIGH;
fired = false;
// test
nand.A.V = VoltageSignal.HIGH;
Assert.IsTrue(fired, "Gate on -- B: H; A: ^; event");
fired = false;
nand.A.V = VoltageSignal.HIGH;
Assert.IsFalse(fired, "Gate on -- B: H; A: -->H; no event");
nand.A.V = VoltageSignal.LOW;
Assert.IsTrue(fired, "Gate on -- B: H; A: v; event");
fired = false;
nand.A.V = VoltageSignal.LOW;
Assert.IsFalse(fired, "Gate on -- B: H; A: -->L; no event");
}
public void TestNand()
{
Source srctrue = new Source(true);
Source srcfalse = new Source(false);
NAND nand = new NAND();
nand.addInput(srcfalse);
nand.addInput(srcfalse);
NAND nand2 = new NAND();
nand2.addInput(srcfalse);
nand2.addInput(srctrue);
NAND nand3 = new NAND();
nand3.addInput(srctrue);
nand3.addInput(srcfalse);
NAND nand4 = new NAND();
nand4.addInput(srctrue);
nand4.addInput(srctrue);
srctrue.Execute();
srcfalse.Execute();
Assert.AreEqual(nand.state, true);
Assert.AreEqual(nand2.state, true);
Assert.AreEqual(nand3.state, true);
Assert.AreEqual(nand4.state, false);
}
public L_Nand(int input, int id, NAND v_Nand) : base(input, 2, id) //Output[0] = Normal [1] = Negiert
{
this.v_Nand = v_Nand;
output[0] = !output[1]; //output[0] = Q output[1] = !Q
for (int i = 0; i < input; i++)
{
this.input[i] = false;
}
}
public void NAND_Event_GateOnOff()
{
// arrange
var nand = new NAND("test");
bool fired = false;
nand.O.Changed += _ => fired = true;
// act, assert
nand.V.V = VoltageSignal.HIGH;
Assert.IsTrue(fired, "A: L; B: L; V: ^; event");
fired = false;
nand.V.V = VoltageSignal.HIGH;
Assert.IsFalse(fired, "A: L; B: L; V: --->H; no event");
nand.V.V = VoltageSignal.LOW;
Assert.IsTrue(fired, "A: L; B: L; V: v; event");
fired = false;
nand.V.V = VoltageSignal.LOW;
Assert.IsFalse(fired, "A: L; B: L; V: --->L; no event");
nand.A.V = VoltageSignal.HIGH;
fired = false;
nand.V.V = VoltageSignal.HIGH;
Assert.IsTrue(fired, "A: H; B: L; V: ^; event");
fired = false;
nand.V.V = VoltageSignal.HIGH;
Assert.IsFalse(fired, "A: H; B: L; V: --->H; no event");
nand.V.V = VoltageSignal.LOW;
Assert.IsTrue(fired, "A: H; B: L; V: v; event");
fired = false;
nand.V.V = VoltageSignal.LOW;
Assert.IsFalse(fired, "A: H; B: L; V: --->L; no event");
nand.A.V = VoltageSignal.LOW;
nand.B.V = VoltageSignal.HIGH;
fired = false;
nand.V.V = VoltageSignal.HIGH;
Assert.IsTrue(fired, "A: L; B: H; V: ^; event");
fired = false;
nand.V.V = VoltageSignal.HIGH;
Assert.IsFalse(fired, "A: L; B: H; V: --->H; no event");
nand.V.V = VoltageSignal.LOW;
Assert.IsTrue(fired, "A: L; B: H; V: v; event");
fired = false;
nand.V.V = VoltageSignal.LOW;
Assert.IsFalse(fired, "A: L; B: H; V: --->L; no event");
nand.A.V = VoltageSignal.HIGH;
nand.V.V = VoltageSignal.HIGH;
Assert.IsFalse(fired, "A: H; B: H; V: ^; no event");
nand.V.V = VoltageSignal.HIGH;
Assert.IsFalse(fired, "A: H; B: H; V: --->H; no event");
nand.V.V = VoltageSignal.LOW;
Assert.IsFalse(fired, "A: H; B: H; V: v; no event");
nand.V.V = VoltageSignal.LOW;
Assert.IsFalse(fired, "A: H; B: H; V: --->L; no event");
}
public void NAND_Constructor()
{
var nand = new NAND("test");
Assert.AreEqual(VoltageSignal.LOW, nand.V.V, "NAND Constructor: Voltage");
Assert.AreEqual(VoltageSignal.LOW, nand.A.V, "NAND Constructor: A");
Assert.AreEqual(VoltageSignal.LOW, nand.B.V, "NAND Constructor: B");
Assert.AreEqual(VoltageSignal.LOW, nand.O.V, "NAND Constructor: O");
Assert.AreEqual("LOW", nand.ToString(), "NAND Constructor: ToString()");
}
public XOR(string name)
{
_or = new OR($"{name}-xor.in");
_nand = new NAND($"{name}-xor.in");
_and = new AND($"{name}-xor.o");
DoWireUp();
Components.Record(nameof(XOR));
}
public void NAND(VoltageSignal voltage, VoltageSignal a, VoltageSignal b, VoltageSignal expected)
{
// arrage
var nand = new NAND("test");
// act
nand.V.V = voltage;
nand.A.V = a;
nand.B.V = b;
// assert
Assert.AreEqual(expected, nand.O.V, $"V:{nand.V}; A:{nand.A}; B:{nand.B}");
}
public void NAND_TwoPositive_NegativeOutput()
{
// Arrange
var port = new NAND();
port.Previous.Add(new Input {
Value = Bit.HIGH
});
port.Previous.Add(new Input {
Value = Bit.HIGH
});
// Act
port.Calculate();
// Assert
Assert.AreEqual(Bit.LOW, port.Value);
}
public void NAND_InputsChanged_OutputUpdateCorrectly()
{
//When both inputs are off output should be on
NAND nandGate = new NAND();
Assert.IsTrue(nandGate.Output.value);
//When InputA only is on output should be on
nandGate.InputA.value = true;
Assert.IsTrue(nandGate.Output.value);
//When both inputs are on output should be off
nandGate.InputB.value = true;
Assert.IsFalse(nandGate.Output.value);
//When InputB only is on output should be on
nandGate.InputA.value = false;
Assert.IsTrue(nandGate.Output.value);
//When both inputs are off again output should be on
nandGate.InputB.value = false;
Assert.IsTrue(nandGate.Output.value);
}
public List <StandardComponent> parcourir_copier()
{
UIElement[] tableau = new UIElement[1000];
List <StandardComponent> liste = new List <StandardComponent>();
int length = canvas.Children.Count;
canvas.Children.CopyTo(tableau, 0);
for (int i = 0; i < length; i++)
{
StandardComponent newChild = null;
if (!(typeof(Line) == tableau[i].GetType()) && ((tableau[i] as StandardComponent).IsSelect))
{
if (typeof(AND) == tableau[i].GetType())
{
newChild = new AND((tableau[i] as AND).nbrInputs());
for (int j = 0; j < (tableau[i] as AND).nbrInputs(); j++)
{
Terminal terminal_1 = (Terminal)((tableau[i] as AND).inputStack.Children[j]);
Terminal terminal_2 = (Terminal)((newChild as AND).inputStack.Children[j]);
if (terminal_1.IsInversed)
{
terminal_2.IsInversed = true;
terminal_2.input_inversed();
}
}
}
else if (typeof(OR) == tableau[i].GetType())
{
newChild = new OR((tableau[i] as OR).nbrInputs());
for (int j = 0; j < (tableau[i] as OR).nbrInputs(); j++)
{
Terminal terminal_1 = (Terminal)((tableau[i] as OR).inputStack.Children[j]);
Terminal terminal_2 = (Terminal)((newChild as OR).inputStack.Children[j]);
if (terminal_1.IsInversed)
{
terminal_2.IsInversed = true;
terminal_2.input_inversed();
}
}
}
else if (typeof(NAND) == tableau[i].GetType())
{
newChild = new NAND((tableau[i] as NAND).nbrInputs());
for (int j = 0; j < (tableau[i] as NAND).nbrInputs(); j++)
{
Terminal terminal_1 = (Terminal)((tableau[i] as NAND).inputStack.Children[j]);
Terminal terminal_2 = (Terminal)((newChild as NAND).inputStack.Children[j]);
if (terminal_1.IsInversed)
{
terminal_2.IsInversed = true;
terminal_2.input_inversed();
}
}
}
else if (typeof(NOR) == tableau[i].GetType())
{
newChild = new NOR((tableau[i] as NOR).nbrInputs());
for (int j = 0; j < (tableau[i] as NOR).nbrInputs(); j++)
{
Terminal terminal_1 = (Terminal)((tableau[i] as NOR).inputStack.Children[j]);
Terminal terminal_2 = (Terminal)((newChild as NOR).inputStack.Children[j]);
if (terminal_1.IsInversed)
{
terminal_2.IsInversed = true;
terminal_2.input_inversed();
}
}
}
else if (typeof(Not) == tableau[i].GetType())
{
newChild = new Not();
Terminal terminal_1 = (Terminal)((tableau[i] as Not).inputStack.Children[0]);
Terminal terminal_2 = (Terminal)((newChild as Not).inputStack.Children[0]);
if (terminal_1.IsInversed)
{
terminal_2.IsInversed = true;
terminal_2.input_inversed();
}
}
else if (typeof(Output) == tableau[i].GetType())
{
newChild = new Output();
}
else if (typeof(Input) == tableau[i].GetType())
{
newChild = new Input();
(newChild as Input).state = (tableau[i] as Input).state;
}
else if (typeof(XNOR) == tableau[i].GetType())
{
newChild = new XNOR((tableau[i] as XNOR).nbrInputs());
for (int j = 0; j < (tableau[i] as XNOR).nbrInputs(); j++)
{
Terminal terminal_1 = (Terminal)((tableau[i] as XNOR).inputStack.Children[j]);
Terminal terminal_2 = (Terminal)((newChild as XNOR).inputStack.Children[j]);
if (terminal_1.IsInversed)
{
terminal_2.IsInversed = true;
terminal_2.input_inversed();
}
}
}
else if (typeof(XOR) == tableau[i].GetType())
{
newChild = new XOR((tableau[i] as XOR).nbrInputs());
for (int j = 0; j < (tableau[i] as XOR).nbrInputs(); j++)
{
Terminal terminal_1 = (Terminal)((tableau[i] as XOR).inputStack.Children[j]);
Terminal terminal_2 = (Terminal)((newChild as XOR).inputStack.Children[j]);
if (terminal_1.IsInversed)
{
terminal_2.IsInversed = true;
terminal_2.input_inversed();
}
}
}
else if (typeof(Comparateur) == tableau[i].GetType())
{
newChild = new Comparateur((tableau[i] as Comparateur).nbrInputs(), (tableau[i] as Comparateur).nbrOutputs());
}
else if (typeof(Decodeur) == tableau[i].GetType())
{
newChild = new Decodeur((tableau[i] as Decodeur).nbrInputs(), (tableau[i] as Decodeur).nbrOutputs());
}
else if (typeof(Demultiplexer) == tableau[i].GetType())
{
newChild = new Demultiplexer((tableau[i] as Demultiplexer).nbrInputs(), (tableau[i] as Demultiplexer).nbrOutputs(), (tableau[i] as Demultiplexer).nbrSelections());
}
else if (typeof(Encodeur) == tableau[i].GetType())
{
newChild = new Encodeur((tableau[i] as Encodeur).nbrInputs(), (tableau[i] as Encodeur).nbrOutputs());
}
else if (typeof(FullAdder) == tableau[i].GetType())
{
newChild = new FullAdder((tableau[i] as FullAdder).nbrInputs(), (tableau[i] as FullAdder).nbrOutputs());
}
else if (typeof(FullSub) == tableau[i].GetType())
{
newChild = new FullSub((tableau[i] as FullSub).nbrInputs(), (tableau[i] as FullSub).nbrOutputs());
}
else if (typeof(HalfAdder) == tableau[i].GetType())
{
newChild = new HalfAdder((tableau[i] as HalfAdder).nbrInputs(), (tableau[i] as HalfAdder).nbrOutputs());
}
else if (typeof(HalfSub) == tableau[i].GetType())
{
newChild = new HalfSub((tableau[i] as HalfSub).nbrInputs(), (tableau[i] as HalfSub).nbrOutputs());
}
else if (typeof(Multiplexer) == tableau[i].GetType())
{
newChild = new Multiplexer((tableau[i] as Multiplexer).nbrInputs(), (tableau[i] as Multiplexer).nbrOutputs(), (tableau[i] as Multiplexer).nbrSelections());
}
else if (typeof(SequentialComponent.Clock) == tableau[i].GetType())
{
newChild = new SequentialComponent.Clock((tableau[i] as SequentialComponent.Clock).LowLevelms, (tableau[i] as SequentialComponent.Clock).HighLevelms, MainWindow.Delay);
}
liste.Add(newChild);
newChild.AllowDrop = true;
newChild.PreviewMouseLeftButtonDown += fenetre.MouseLeftButtonDown;
newChild.PreviewMouseMove += fenetre.MouseMove;
newChild.PreviewMouseLeftButtonUp += fenetre.PreviewMouseLeftButtonUp;
newChild.SetValue(Canvas.LeftProperty, tableau[i].GetValue(Canvas.LeftProperty));
newChild.SetValue(Canvas.TopProperty, tableau[i].GetValue(Canvas.TopProperty));
(newChild as StandardComponent).PosX = (tableau[i] as StandardComponent).PosX;
(newChild as StandardComponent).PosY = (tableau[i] as StandardComponent).PosY;
try
{
StandardComponent component = newChild as StandardComponent;
component.recalculer_pos();
}
catch { };
}
}
return(liste);
}
//Methods
public Proposition InsertInBinaryTree(ref string s)
{
Proposition root = null;
switch (s[0])
{
case '>':
{
root = new Implication();
s = s.Substring(2);
while (s[0] != ',')
{
root.LeftNode = InsertInBinaryTree(ref s);
s = s.Substring(1);
}
s = s.Substring(1);
while (s[0] != ')')
{
root.RightNode = InsertInBinaryTree(ref s);
s = s.Substring(1);
}
break;
}
case '=':
{
root = new BiImplication();
s = s.Substring(2);
while (s[0] != ',')
{
root.LeftNode = InsertInBinaryTree(ref s);
s = s.Substring(1);
}
s = s.Substring(1);
while (s[0] != ')')
{
root.RightNode = InsertInBinaryTree(ref s);
s = s.Substring(1);
}
break;
}
case '&':
{
root = new And();
s = s.Substring(2);
while (s[0] != ',')
{
root.LeftNode = InsertInBinaryTree(ref s);
s = s.Substring(1);
}
s = s.Substring(1);
while (s[0] != ')')
{
root.RightNode = InsertInBinaryTree(ref s);
s = s.Substring(1);
}
break;
}
case '|':
{
root = new Or();
s = s.Substring(2);
while (s[0] != ',')
{
root.LeftNode = InsertInBinaryTree(ref s);
s = s.Substring(1);
}
s = s.Substring(1);
while (s[0] != ')')
{
root.RightNode = InsertInBinaryTree(ref s);
s = s.Substring(1);
}
break;
}
case '~':
{
root = new Negation();
s = s.Substring(2);
while (s[0] != ')')
{
root.LeftNode = InsertInBinaryTree(ref s);
s = s.Substring(1);
}
break;
}
case '%':
{
root = new NAND();
s = s.Substring(2);
while (s[0] != ',')
{
root.LeftNode = InsertInBinaryTree(ref s);
s = s.Substring(1);
}
s = s.Substring(1);
while (s[0] != ')')
{
root.RightNode = InsertInBinaryTree(ref s);
s = s.Substring(1);
}
break;
}
default:
{
root = new Pro();
(root as Pro).Notation = s[0].ToString();
break;
}
}
return(root);
}
