Exemplo n.º 1
0
        protected virtual void GetOutput(bool forceUpdate)
        {
            int loops = 0;
            UniqueQueue <Guid> queue       = new UniqueQueue <Guid>();
            UniqueQueue <Guid> outputQueue = new UniqueQueue <Guid>();

            // This is a new update loops so make sure gates and chips are not dirty
            foreach (Chip chip in Chips)
            {
                chip.Dirty.SetAll(false);
            }
            foreach (Gate gate in Gates)
            {
                gate.SetClean();
            }

            // Update input wires
            foreach (Wire wire in WireDict[ID])
            {
                if (forceUpdate || FirstRun || (OldInput[wire.FromIndex] != Input[wire.FromIndex]))
                {
                    if (wire.IsChip)
                    {
                        Chip chip = Chips[wire.CircuitIndex];
                        chip.SetInputBit(wire.ToIndex, Input[wire.FromIndex] ^ wire.InvertValue);
                        chip.Update(forceUpdate);

                        if (forceUpdate || FirstRun || chip.IsDirty())
                        {
                            queue.Enqueue(chip.ID);
                        }
                    }
                    else
                    {
                        Gate gate = Gates[wire.CircuitIndex];
                        gate.SetInputBit(wire.ToIndex, Input[wire.FromIndex] ^ wire.InvertValue);
                        gate.Update(ScrubOutput);

                        if (forceUpdate || FirstRun || gate.IsDirty())
                        {
                            queue.Enqueue(gate.ID);
                        }
                    }
                }
            }

            //Update internal components
            while (queue.Count > 0)
            {
                //Stop infinite loops from continuing
                loops++;
                if (loops >= 100)
                {
                    Debug.Log("Infinite loop, breaking");
                    return;
                }

                Guid guid = queue.Dequeue();

                BitArray FromValues;
                BitArray FromDirty;

                // The output of the previous gate
                Gate previousGate = FindGate(guid);
                if (previousGate != null)
                {
                    FromValues = new BitArray(1, previousGate.Output);
                    FromDirty  = new BitArray(1, previousGate.IsDirty());
                }
                else
                {
                    Chip c = FindChip(guid);
                    FromValues = c.Output;
                    FromDirty  = c.Dirty;
                }

                foreach (Wire wire in WireDict[guid])
                {
                    if (wire.IsChip)
                    {
                        if (wire.CircuitIndex == -1)
                        {
                            outputQueue.Enqueue(guid);
                            Output[wire.ToIndex] = FromValues[wire.FromIndex] ^ wire.InvertValue;
                            //Debug.Log("Updated output: " + wire.ToIndex);
                        }
                        else if (FromDirty[wire.FromIndex])
                        {
                            Chip chip = Chips[wire.CircuitIndex];
                            chip.SetInputBit(wire.ToIndex, FromValues[wire.FromIndex] ^ wire.InvertValue);
                            chip.Update(false);
                            //Debug.Log("Updated chip: " + (char)(Chips.FindIndex(x => x.ID == guid) + 65) + "->" + (char)(wire.CircuitIndex + 65));

                            if (chip.IsDirty())
                            {
                                queue.Enqueue(chip.ID);
                            }
                        }
                    }
                    else if (FromDirty[wire.FromIndex])
                    {
                        Gate gate = Gates[wire.CircuitIndex];
                        gate.SetInputBit(wire.ToIndex, FromValues[wire.FromIndex] ^ wire.InvertValue);
                        gate.Update(ScrubOutput);
                        //Debug.Log("Updated gate: " + (char)(wire.CircuitIndex + 65));

                        if (forceUpdate || FirstRun || gate.IsDirty())
                        {
                            queue.Enqueue(gate.ID);
                        }
                    }
                }
            }

            //Update output wires
            while (outputQueue.Count > 0)
            {
                Guid guid = outputQueue.Dequeue();

                BitArray FromValues;

                Gate gate = FindGate(guid);
                if (gate != null)
                {
                    FromValues = new BitArray(1, gate.Output);
                }
                else
                {
                    FromValues = FindChip(guid).Output;
                }

                foreach (Wire wire in WireDict[guid])
                {
                    if (wire.IsChip && wire.CircuitIndex == -1)
                    {
                        Output[wire.ToIndex] = FromValues[wire.FromIndex] ^ wire.InvertValue;
                    }
                }
            }
        }
Exemplo n.º 2
0
        public D_Register_4Bit() : base(10, 4)
        {
            // Output control
            Gate gateA = AddGateIndexed(new ANDGate());

            // Data Enable
            Gate gateB = AddGateIndexed(new ANDGate());

            Gate gateC = AddGateIndexed(new NotGate());
            Gate gateD = AddGateIndexed(new NotGate());
            Gate gateE = AddGateIndexed(new NotGate());

            // Q1
            Gate gateF = AddGateIndexed(new ANDGate());
            Gate gateG = AddGateIndexed(new ANDGate());
            Gate gateR = AddGateIndexed(new ORGate());
            Chip chipH = AddChipIndexed(new D_FlipFlop_Re());
            Gate gateV = AddGateIndexed(new TriBufferGate());

            // Q2
            Gate gateI = AddGateIndexed(new ANDGate());
            Gate gateJ = AddGateIndexed(new ANDGate());
            Gate gateS = AddGateIndexed(new ORGate());
            Chip chipK = AddChipIndexed(new D_FlipFlop_Re());
            Gate gateW = AddGateIndexed(new TriBufferGate());

            // Q3
            Gate gateL = AddGateIndexed(new ANDGate());
            Gate gateM = AddGateIndexed(new ANDGate());
            Gate gateT = AddGateIndexed(new ORGate());
            Chip chipN = AddChipIndexed(new D_FlipFlop_Re());
            Gate gateX = AddGateIndexed(new TriBufferGate());

            // Q4
            Gate gateO = AddGateIndexed(new ANDGate());
            Gate gateP = AddGateIndexed(new ANDGate());
            Gate gateU = AddGateIndexed(new ORGate());
            Chip chipQ = AddChipIndexed(new D_FlipFlop_Re());
            Gate gateY = AddGateIndexed(new TriBufferGate());

            // Output control
            AddInputWire(new Wire(0, 0, gateA, true));
            AddInputWire(new Wire(1, 1, gateA, true));
            AddWire(gateA.ID, new Wire(0, 1, gateV));
            AddWire(gateA.ID, new Wire(0, 1, gateW));
            AddWire(gateA.ID, new Wire(0, 1, gateX));
            AddWire(gateA.ID, new Wire(0, 1, gateY));

            // Data Enable
            AddInputWire(new Wire(3, 0, gateB, true));
            AddInputWire(new Wire(4, 1, gateB, true));
            AddWire(gateB, new Wire(0, 0, gateC));
            AddWire(gateB, new Wire(0, 1, gateG));
            AddWire(gateB, new Wire(0, 1, gateJ));
            AddWire(gateB, new Wire(0, 1, gateM));
            AddWire(gateB, new Wire(0, 1, gateP));
            AddWire(gateC, new Wire(0, 1, gateF));
            AddWire(gateC, new Wire(0, 1, gateI));
            AddWire(gateC, new Wire(0, 1, gateL));
            AddWire(gateC, new Wire(0, 1, gateO));

            // CLK
            AddInputWire(new Wire(6, 0, gateD));
            AddWire(gateD, new Wire(0, 0, chipH, true));
            AddWire(gateD, new Wire(0, 0, chipK, true));
            AddWire(gateD, new Wire(0, 0, chipN, true));
            AddWire(gateD, new Wire(0, 0, chipQ, true));

            // CLR
            AddInputWire(new Wire(9, 0, gateE));
            AddWire(gateE, new Wire(0, 2, chipH, true));
            AddWire(gateE, new Wire(0, 2, chipK, true));
            AddWire(gateE, new Wire(0, 2, chipN, true));
            AddWire(gateE, new Wire(0, 2, chipQ, true));

            // Q1
            AddInputWire(new Wire(2, 0, gateG));
            AddWire(gateF, new Wire(0, 0, gateR));
            AddWire(gateG, new Wire(0, 1, gateR));
            AddWire(gateR, new Wire(0, 1, chipH));
            AddWire(chipH, new Wire(0, 0, gateF));
            AddWire(chipH, new Wire(0, 0, gateV));
            AddWire(gateV, new Wire(0, 0, -1, true));

            // Q2
            AddInputWire(new Wire(5, 0, gateJ));
            AddWire(gateI, new Wire(0, 0, gateS));
            AddWire(gateJ, new Wire(0, 1, gateS));
            AddWire(gateS, new Wire(0, 1, chipK));
            AddWire(chipK, new Wire(0, 0, gateI));
            AddWire(chipK, new Wire(0, 0, gateW));
            AddWire(gateW, new Wire(0, 1, -1, true));

            // Q3
            AddInputWire(new Wire(7, 0, gateM));
            AddWire(gateL, new Wire(0, 0, gateT));
            AddWire(gateM, new Wire(0, 1, gateT));
            AddWire(gateT, new Wire(0, 1, chipN));
            AddWire(chipN, new Wire(0, 0, gateL));
            AddWire(chipN, new Wire(0, 0, gateX));
            AddWire(gateX, new Wire(0, 2, -1, true));

            // Q4
            AddInputWire(new Wire(8, 0, gateP));
            AddWire(gateO, new Wire(0, 0, gateU));
            AddWire(gateP, new Wire(0, 1, gateU));
            AddWire(gateU, new Wire(0, 1, chipQ));
            AddWire(chipQ, new Wire(0, 0, gateO));
            AddWire(chipQ, new Wire(0, 0, gateY));
            AddWire(gateY, new Wire(0, 3, -1, true));
        }
Exemplo n.º 3
0
 protected void AddWire(Chip chip, Wire wire)
 {
     AddWire(chip.ID, wire);
 }
Exemplo n.º 4
0
 protected void AddWires(Chip chip, Wire[] wires)
 {
     AddWires(chip.ID, wires);
 }
Exemplo n.º 5
0
 protected int AddChip(Chip chip)
 {
     return(AddChipIndexed(chip).index);
 }
Exemplo n.º 6
0
        /// <summary>
        /// OE = 0,
        /// RCLK = 1,
        /// SRCLR = 2,
        /// SRCLK = 3,
        /// SER = 4
        /// </summary>
        public Shift_Register_8Bit() : base(6, 9)
        {
            KeepDirty = true;

            // Shift Latches
            Chip S1 = AddChipIndexed(new D_FlipFlop_Re());
            Chip S2 = AddChipIndexed(new D_FlipFlop_Re());
            Chip S3 = AddChipIndexed(new D_FlipFlop_Re());
            Chip S4 = AddChipIndexed(new D_FlipFlop_Re());
            Chip S5 = AddChipIndexed(new D_FlipFlop_Re());
            Chip S6 = AddChipIndexed(new D_FlipFlop_Re());
            Chip S7 = AddChipIndexed(new D_FlipFlop_Re());
            Chip S8 = AddChipIndexed(new D_FlipFlop_Re());

            // Register Latches
            Chip R1 = AddChipIndexed(new D_FlipFlop_Re());
            Chip R2 = AddChipIndexed(new D_FlipFlop_Re());
            Chip R3 = AddChipIndexed(new D_FlipFlop_Re());
            Chip R4 = AddChipIndexed(new D_FlipFlop_Re());
            Chip R5 = AddChipIndexed(new D_FlipFlop_Re());
            Chip R6 = AddChipIndexed(new D_FlipFlop_Re());
            Chip R7 = AddChipIndexed(new D_FlipFlop_Re());
            Chip R8 = AddChipIndexed(new D_FlipFlop_Re());

            // Output Enables
            Gate O1 = AddGateIndexed(new ANDGate());
            Gate O2 = AddGateIndexed(new ANDGate());
            Gate O3 = AddGateIndexed(new ANDGate());
            Gate O4 = AddGateIndexed(new ANDGate());
            Gate O5 = AddGateIndexed(new ANDGate());
            Gate O6 = AddGateIndexed(new ANDGate());
            Gate O7 = AddGateIndexed(new ANDGate());
            Gate O8 = AddGateIndexed(new ANDGate());

            // INs
            Gate OE   = AddGateIndexed(new NotGate());
            Gate RCLK = AddGateIndexed(new BufferGate());

            // SER
            AddInputWire(new Wire(4, 1, S1));

            // SRCLR
            AddInputWires(Wire.Create(2, 2, true, S1, S2, S3, S4, S5, S6, S7, S8));

            AddInputWires(Wire.Create(5, 3, false, S1, S2, S3, S4, S5, S6, S7, S8, R1, R2, R3, R4, R5, R6, R7, R8));

            // SRCLK
            AddInputWires(Wire.Create(3, 0, false, S1, S2, S3, S4, S5, S6, S7, S8));

            // RCLK
            AddInputWire(new Wire(1, 0, RCLK));
            AddWires(RCLK, Wire.Create(0, 0, false, R1, R2, R3, R4, R5, R6, R7, R8));

            // OE
            AddInputWire(new Wire(0, 0, OE));
            AddWires(OE, Wire.Create(0, 1, false, O1, O2, O3, O4, O5, O6, O7, O8));

            // OEs
            AddWire(O1, new Wire(0, 0, -1, true));
            AddWire(O2, new Wire(0, 1, -1, true));
            AddWire(O3, new Wire(0, 2, -1, true));
            AddWire(O4, new Wire(0, 3, -1, true));
            AddWire(O5, new Wire(0, 4, -1, true));
            AddWire(O6, new Wire(0, 5, -1, true));
            AddWire(O7, new Wire(0, 6, -1, true));
            AddWire(O8, new Wire(0, 7, -1, true));
            //AddWire(S1, new Wire(0, 0, -1, true));
            //AddWire(S2, new Wire(0, 1, -1, true));
            //AddWire(S3, new Wire(0, 2, -1, true));
            //AddWire(S4, new Wire(0, 3, -1, true));
            //AddWire(S5, new Wire(0, 4, -1, true));
            //AddWire(S6, new Wire(0, 5, -1, true));
            //AddWire(S7, new Wire(0, 6, -1, true));
            //AddWire(S8, new Wire(0, 7, -1, true));

            //SR->R
            AddWires(S1, Wire.Create(0, 1, false, R1, S2));
            AddWires(S2, Wire.Create(0, 1, false, R2, S3));
            AddWires(S3, Wire.Create(0, 1, false, R3, S4));
            AddWires(S4, Wire.Create(0, 1, false, R4, S5));
            AddWires(S5, Wire.Create(0, 1, false, R5, S6));
            AddWires(S6, Wire.Create(0, 1, false, R6, S7));
            AddWires(S7, Wire.Create(0, 1, false, R7, S8));

            AddWire(S8, new Wire(0, 1, R8));
            AddWire(S8, new Wire(1, 8, -1, true));

            //R->OE
            AddWire(R1, new Wire(0, 0, O1));
            AddWire(R2, new Wire(0, 0, O2));
            AddWire(R3, new Wire(0, 0, O3));
            AddWire(R4, new Wire(0, 0, O4));
            AddWire(R5, new Wire(0, 0, O5));
            AddWire(R6, new Wire(0, 0, O6));
            AddWire(R7, new Wire(0, 0, O7));
            AddWire(R8, new Wire(0, 0, O8));
        }
Exemplo n.º 7
0
 protected int AddChip(Chip chip)
 {
     Chips.Add(chip);
     return(Chips.Count - 1);
 }
Exemplo n.º 8
0
        protected virtual void GetOutput(bool forceUpdate)
        {
            int          loops = 0;
            Queue <Guid> queue = new Queue <Guid>();

            foreach (Chip chip in Chips)
            {
                chip.Dirty.SetAll(false);
            }

            foreach (Wire wire in WireDict[ID])
            {
                if (wire.IsChip)
                {
                    Chip chip = Chips[wire.CircuitIndex];
                    chip.SetInputBit(wire.ToIndex, Input[wire.FromIndex]);
                    chip.Update(forceUpdate);

                    if (forceUpdate || GetCardinality(chip.Dirty) > 0)
                    {
                        if (!queue.Contains(chip.ID))
                        {
                            queue.Enqueue(chip.ID);
                        }
                    }
                }
                else
                {
                    Gate gate = Gates[wire.CircuitIndex];
                    gate.SetInputBit(wire.ToIndex, Input[wire.FromIndex]);
                    gate.Update();

                    if (forceUpdate || gate.IsDirty())
                    {
                        if (!queue.Contains(gate.ID))
                        {
                            queue.Enqueue(gate.ID);
                        }
                    }
                }
            }

            while (queue.Count > 0)
            {
                //Stop infinite loops from continuing
                loops++;
                if (loops >= 1000)
                {
                    Console.WriteLine("Infinite loop, breaking");
                    return;
                }

                Guid guid = queue.Dequeue();

                BitArray FromValues;

                int findIndex = Gates.FindIndex(x => x.ID == guid);
                if (findIndex != -1)
                {
                    FromValues = new BitArray(1, Gates[findIndex].Output);
                }
                else
                {
                    FromValues = Chips.Find(x => x.ID == guid).Output;
                }

                foreach (Wire wire in WireDict[guid])
                {
                    if (wire.IsChip)
                    {
                        if (wire.CircuitIndex == -1)
                        {
                            Output[wire.ToIndex] = FromValues[wire.FromIndex];
                        }
                        else
                        {
                            Chip chip = Chips[wire.CircuitIndex];

                            if (chip.Dirty[wire.FromIndex])
                            {
                                chip.SetInputBit(wire.ToIndex, FromValues[wire.FromIndex]);
                                chip.Update(forceUpdate);

                                if (forceUpdate || GetCardinality(Dirty) > 0)
                                {
                                    if (!queue.Contains(chip.ID))
                                    {
                                        queue.Enqueue(chip.ID);
                                    }
                                }
                            }
                        }
                    }
                    else
                    {
                        Gate gate = Gates[wire.CircuitIndex];
                        gate.SetInputBit(wire.ToIndex, FromValues[wire.FromIndex]);
                        gate.Update();

                        if (forceUpdate || gate.IsDirty())
                        {
                            if (!queue.Contains(gate.ID))
                            {
                                queue.Enqueue(gate.ID);
                            }
                        }
                    }
                }
            }
        }
Exemplo n.º 9
0
        protected virtual void GetOutput(bool forceUpdate)
        {
            int          loops       = 0;
            Queue <Guid> queue       = new Queue <Guid>();
            Queue <Guid> outputQueue = new Queue <Guid>();

            foreach (Chip chip in Chips)
            {
                chip.Dirty.SetAll(false);
            }
            foreach (Gate gate in Gates)
            {
                gate.SetClean();
            }

            // Update input wires
            foreach (Wire wire in WireDict[ID])
            {
                if (forceUpdate || FirstRun || (OldInput[wire.FromIndex] != Input[wire.FromIndex]))
                {
                    if (wire.IsChip)
                    {
                        Chip chip = Chips[wire.CircuitIndex];
                        chip.SetInputBit(wire.ToIndex, Input[wire.FromIndex] ^ wire.invertValue);
                        chip.Update(forceUpdate);
                        //Debug.Log("Updated chip: " + (char)(wire.CircuitIndex + 65));

                        if (forceUpdate || FirstRun || GetCardinality(chip.Dirty) > 0)
                        {
                            if (!queue.Contains(chip.ID))
                            {
                                queue.Enqueue(chip.ID);
                            }
                        }
                    }
                    else
                    {
                        Gate gate = Gates[wire.CircuitIndex];
                        gate.SetInputBit(wire.ToIndex, Input[wire.FromIndex] ^ wire.invertValue);
                        gate.Update(ScrubOutput);
                        //Debug.Log("Updated gate: " + (char)(wire.CircuitIndex + 65));

                        if (forceUpdate || FirstRun || gate.IsDirty())
                        {
                            if (!queue.Contains(gate.ID))
                            {
                                queue.Enqueue(gate.ID);
                            }
                        }
                    }
                }
            }

            //Update internal components
            while (queue.Count > 0)
            {
                //Stop infinite loops from continuing
                loops++;
                if (loops >= 100)
                {
                    Debug.Log("Infinite loop, breaking");
                    return;
                }

                Guid guid = queue.Dequeue();

                BitArray FromValues;
                BitArray FromDirty;

                // Find a better way to get values
                int findIndex = Gates.FindIndex(x => x.ID == guid);
                if (findIndex != -1)
                {
                    FromValues = new BitArray(1, Gates[findIndex].Output);
                    FromDirty  = new BitArray(1, Gates[findIndex].IsDirty());
                }
                else
                {
                    Chip c = Chips.Find(x => x.ID == guid);
                    FromValues = c.Output;
                    FromDirty  = c.Dirty;
                }

                foreach (Wire wire in WireDict[guid])
                {
                    if (wire.IsChip)
                    {
                        if (wire.CircuitIndex == -1)
                        {
                            if (!outputQueue.Contains(guid))
                            {
                                outputQueue.Enqueue(guid);
                            }
                            Output[wire.ToIndex] = FromValues[wire.FromIndex] ^ wire.invertValue;
                            //Debug.Log("Updated output: " + wire.ToIndex);
                        }
                        else if (FromDirty[wire.FromIndex])
                        {
                            Chip chip = Chips[wire.CircuitIndex];
                            chip.SetInputBit(wire.ToIndex, FromValues[wire.FromIndex] ^ wire.invertValue);
                            chip.Update(false);
                            //Debug.Log("Updated chip: " + (char)(Chips.FindIndex(x => x.ID == guid) + 65) + "->" + (char)(wire.CircuitIndex + 65));

                            if (GetCardinality(chip.Dirty) > 0)
                            {
                                if (!queue.Contains(chip.ID))
                                {
                                    queue.Enqueue(chip.ID);
                                }
                            }
                        }
                    }
                    else if (FromDirty[wire.FromIndex])
                    {
                        Gate gate = Gates[wire.CircuitIndex];
                        gate.SetInputBit(wire.ToIndex, FromValues[wire.FromIndex] ^ wire.invertValue);
                        gate.Update(ScrubOutput);
                        //Debug.Log("Updated gate: " + (char)(wire.CircuitIndex + 65));

                        if (forceUpdate || FirstRun || gate.IsDirty())
                        {
                            if (!queue.Contains(gate.ID))
                            {
                                queue.Enqueue(gate.ID);
                            }
                        }
                    }
                }
            }

            //Update output wires
            while (outputQueue.Count > 0)
            {
                Guid guid = outputQueue.Dequeue();

                BitArray FromValues;

                int findIndex = Gates.FindIndex(x => x.ID == guid);
                if (findIndex != -1)
                {
                    FromValues = new BitArray(1, Gates[findIndex].Output);
                }
                else
                {
                    Chip c = Chips.Find(x => x.ID == guid);
                    FromValues = c.Output;
                }

                foreach (Wire wire in WireDict[guid])
                {
                    if (wire.IsChip && wire.CircuitIndex == -1)
                    {
                        Output[wire.ToIndex] = FromValues[wire.FromIndex] ^ wire.invertValue;
                    }
                }
            }
        }