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); }