Example #1
0
        public void TestToString()
        {
            Clock  clock  = new Clock();
            TicTok tictok = new TicTok();

            tictok.Init();

            int  TState = 0;
            AReg areg   = new AReg();
            TReg treg   = new TReg();
            BReg breg   = new BReg();
            CReg creg   = new CReg();
            IReg ireg   = new IReg();

            IPort1 port1 = new IPort1();
            IPort2 port2 = new IPort2();

            MDR mdr = new MDR();
            RAM ram = new RAM();

            mdr.SetRefToRAM(ref ram);

            ALU alu = new ALU(ref areg, ref treg);

            OReg3 oreg3 = new OReg3(ref alu);
            OReg4 oreg4 = new OReg4(ref alu);

            HexadecimalDisplay hexadecimalDisplay = new HexadecimalDisplay(ref oreg3);


            Flag flagReg = new Flag(ref alu);
            PC   pc      = new PC(ref flagReg);
            MAR  mar     = new MAR(ref ram);
            SEQ  seq     = SEQ.Instance();

            Wbus.Instance().Value = string.Concat(Enumerable.Repeat('0', 16));

            Instruction currentInstruction = new Instruction
            {
                OpCode         = "ADD B",
                BinCode        = "10000000",
                TStates        = 4,
                AffectsFlags   = true,
                AddressingMode = AddressingMode.Register,
                Bytes          = 1
            };

            Frame frame = new Frame(currentInstruction, TState, port1, port2, pc, mar, ram,
                                    ram.RAMDump(), mdr, ireg, SEQ.Instance(),
                                    Wbus.Instance().Value, areg, alu, flagReg,
                                    treg, breg, creg, oreg3, oreg4, hexadecimalDisplay);

            _ = frame.ToString();
            _ = frame.OutputRegister();
        }
Example #2
0
        public Frame(Instruction instruction, int TState, IPort1 ip1, IPort2 ip2, PC pc, MAR mar, RAM ram,
                     List <string> ramContents, MDR mdr, IReg ireg, SEQ seq, string wbus_string,
                     AReg areg, ALU alu, Flag flagReg, TReg treg, BReg breg, CReg creg,
                     OReg3 oreg3, OReg4 oreg4, HexadecimalDisplay hexadecimalDisplay)
        {
            InstructionData = instruction;
            if (InstructionData.OpCode.Contains(','))
            {
                InstructionData.OpCode = InstructionData.OpCode.Replace(",", string.Empty);
            }

            this.TState = TState;

            this.AReg = areg.ToString_Frame_Use();
            this.BReg = breg.ToString_Frame_Use();
            this.CReg = creg.ToString_Frame_Use();
            this.TReg = treg.ToString_Frame_Use();
            this.IReg = ireg.ToString_Frame_Use();  // The real ToString() is in use with a substring in it.  This is needed for proper operation
            this.MAR  = mar.ToString_Frame_Use();
            this.MDR  = mdr.RegContent;

            this.PC   = pc.RegContent;
            this.ALU  = alu.ToString();
            this.WBus = wbus_string;

            this.OPort1             = oreg3.ToString_Frame_Use();
            this.OPort2             = oreg4.ToString_Frame_Use();
            this.HexadecimalDisplay = hexadecimalDisplay.RegContent;

            this.RAM = ramContents;

            this.SEQ     = seq.ToString();
            this.WBus    = wbus_string; // I didnt want to mess with the Singleton in the frame, so the value will just be passed as a string
            this.RAM_Reg = ram.ToString_Frame_Use();
            this.Flags   = flagReg.RegContent;

            if (instruction == null)
            {
                this.IReg = "???";
            }

            if (TState > 3)
            {
                Instruction = InstructionData.OpCode;
            }
            else
            {
                Instruction = "???";
            }
        }
Example #3
0
        // *************************************************************************

        // *************************************************************************
        // Engine Runtime
        // *************************************************************************
        public void Run()
        {
            Clock  clock  = new Clock();
            TicTok tictok = new TicTok();

            tictok.Init();

            AReg areg = new AReg();
            TReg treg = new TReg();
            BReg breg = new BReg();
            CReg creg = new CReg();
            IReg ireg = new IReg();

            IPort1 iport1 = new IPort1();
            IPort2 iport2 = new IPort2();

            MDR mdr = new MDR();
            RAM ram = new RAM();

            mdr.SetRefToRAM(ref ram);

            ALU alu = new ALU(ref areg, ref treg);

            areg.SetALUReference(ref alu);
            breg.SetALUReference(ref alu);
            creg.SetALUReference(ref alu);

            OReg3 oreg3 = new OReg3(ref alu);
            OReg4 oreg4 = new OReg4(ref alu);
            HexadecimalDisplay hexadecimalDisplay = new HexadecimalDisplay(ref oreg3);

            Flag flagReg = new Flag(ref alu);
            PC   pc      = new PC(ref flagReg);
            MAR  mar     = new MAR(ref ram);
            SEQ  seq     = SEQ.Instance();

            Wbus.Instance().Value = string.Concat(Enumerable.Repeat('0', 16));

            areg.Subscribe(clock);
            treg.Subscribe(clock);
            breg.Subscribe(clock);
            creg.Subscribe(clock);
            ireg.Subscribe(clock);
            mar.Subscribe(clock);

            pc.Subscribe(clock);
            alu.Subscribe(clock); // ALU must come after A and T
            flagReg.Subscribe(clock);
            ram.Subscribe(clock);
            mdr.Subscribe(clock);

            oreg3.Subscribe(clock);
            hexadecimalDisplay.Subscribe(clock);
            oreg4.Subscribe(clock);

            // Load the program into the RAM
            ram.LoadProgram(Program);

            // Load the intsructionSet into the SEQ
            seq.Load(InstructionSet);

            Frame tempFrame;

            #region Program_Exec

            // Since T1-T3 for all of the Intruction is the same,
            // LDA or "0000" will be used as the intruction for all T1-T3's
            clock.IsEnabled = true;

            int max_loop_count = 10_000;
            int loop_counter   = 0;

            int TState = 1;

            // A basic empty instruction state with 3 TStates since on the 4th the instruction
            // will be known and set to a new object reference.
            Instruction currentInstruction = new Instruction()
            {
                OpCode  = "???",
                TStates = 4 // Since by 4 TStates it should know what instruction it is on
            };

            List <string> controlWords = new List <string>();
            bool?         didntJump    = null;

            while (clock.IsEnabled)
            {
                // Log the Instruction
                if (TState == 4)
                {
                    currentInstruction = InstructionSet.Instructions.FirstOrDefault(i => i.BinCode.Equals(ireg.RegContent));
                    seq.LoadBackupControlWords(currentInstruction.MicroCode);

                    string iname      = currentInstruction.OpCode;
                    int    operandVal = Convert.ToInt32(ireg.RegContent, 2);
                    string hexOperand = "0x" + operandVal.ToString("X");
                }

                if (TState <= 3)
                {
                    seq.UpdateControlWordReg(TState, "00000000", didntJump);

                    if (didntJump ?? false)
                    {
                        pc.SkipByte();
                        didntJump = null;
                    }
                }
                else
                {
                    seq.UpdateControlWordReg(TState, ireg.RegContent);
                }

                clock.SendTicTok(tictok);
                tictok.ToggleClockState();
                clock.SendTicTok(tictok);
                tictok.ToggleClockState();

                tempFrame = new Frame(currentInstruction, TState, iport1, iport2, pc, mar, ram,
                                      ram.RAMDump(), mdr, ireg, SEQ.Instance(),
                                      Wbus.Instance().Value, areg, alu, flagReg,
                                      treg, breg, creg, oreg3, oreg4, hexadecimalDisplay);

                _FrameStack.Add(tempFrame);

                // HLT
                if (ireg.RegContent.Equals("01110110", StringComparison.Ordinal) && TState == 5)
                {
                    clock.IsEnabled = false;

                    _RAMDump = ram.RAMDump();
                }

                if (loop_counter >= max_loop_count)
                {
                    throw new EngineRuntimeException("Engine Error: Infinite Loop Detected");
                }
                else
                {
                    loop_counter++;
                }

                if (TState == 7 && currentInstruction.OpCode.StartsWith('J'))
                {
                    pc.CheckForJumpCondition();

                    // PC is going to jump so do not let it fetch the next byte and immediately endx
                    if (!pc.WontJump)
                    {
                        currentInstruction.TStates = 7;
                        didntJump = true;
                    }
                }

                if (TState < currentInstruction.TStates)
                {
                    TState++;
                }
                else
                {
                    TState             = 1;
                    currentInstruction = new Instruction()
                    {
                        OpCode  = "???",
                        TStates = 4 // Since by 4 TStates it should know what instruction it is on
                    };
                }
            }

            OutputReg = oreg3.ToString();

            #endregion Program_Exec
        }