public void LoadAwithValueWhenOperationIsLDAn() { var fakeBus = A.Fake <IBus>(); var program = new Dictionary <ushort, byte> { // Program Code { 0x0080, 0x3E }, { 0x0081, 0x02 }, { 0x0082, 0x00 }, { 0x0083, 0x00 }, { 0x0084, 0x00 }, }; A.CallTo(() => fakeBus.Read(A <ushort> ._, A <bool> ._)) .ReturnsLazily((ushort addr, bool ro) => program[addr]); // Load 2 into register A, which starts out having a value of 3... var cpu = new Z80() { A = 0x03, PC = 0x0080 }; cpu.ConnectToBus(fakeBus); cpu.Step(); Assert.Equal(0x02, cpu.A); // No affect on Condition Flags FlagsUnchanged(cpu); }
public void Initialize() { Ports = new TVCPorts(); Memory = new TVCMemory(this); Memory.LoadSystemMemory(@"..\..\roms\rom.bin"); Memory.LoadExtMemory(@"..\..\roms\ext.bin"); Memory.LoadCartMemory(@"d:\Stuff\tvc\szanko.rom"); //Memory.LoadCartMemory(@"c:\Temp\tvc\mralex.rom"); //Memory.LoadCartMemory(@"c:\Temp\tvc\invaders.rom"); //Memory.LoadCartMemory(@"c:\Temp\tvc\vili.rom"); Video = new TVCVideo(this); Keyboard = new TVCKeyboard(this); Interrupt = new TVCInterrupt(this); CPU = new Z80(Memory, Ports, null, true); Cards = new ITVCCard[ExpansionCardCount]; InsertCard(0, new HBFCard()); Ports.AddPortReader(0x5a, PortRead5AH); Reset(); }
private void HandleStrayOpCodes2() { var fakeBus = A.Fake <IBus>(); var program = new Dictionary <ushort, byte> { // Program Code { 0x0080, 0xDD }, { 0x0081, 0xDD }, { 0x0082, 0xDD }, { 0x0083, 0xFD }, { 0x0084, 0xDD }, // LD IX &1000 { 0x0085, 0x21 }, { 0x0086, 0x00 }, { 0x0087, 0x10 }, { 0x0088, 0x00 }, }; A.CallTo(() => fakeBus.Read(A <ushort> ._, A <bool> ._)) .ReturnsLazily((ushort addr, bool ro) => program[addr]); var cpu = new Z80() { A = 0x00, IX = 0x00, PC = 0x0080 }; cpu.ConnectToBus(fakeBus); while (cpu.PC < 0x0088) { cpu.Step(); } Assert.Equal(0x1000, cpu.IX); }
private void JumpToIY() { var fakeBus = A.Fake <IBus>(); var program = new Dictionary <ushort, byte> { // Program Code { 0x0080, 0xFD }, // JR IY { 0x0081, 0xE9 }, { 0x0082, 0x00 }, { 0x0083, 0x00 }, { 0x0084, 0x00 }, { 0x0085, 0x00 }, { 0x0086, 0x00 }, // <- jump here { 0x0087, 0x00 }, }; A.CallTo(() => fakeBus.Read(A <ushort> ._, A <bool> ._)) .ReturnsLazily((ushort addr, bool ro) => program[addr]); var cpu = new Z80() { A = 0x00, IY = 0x0086, PC = 0x0080 }; cpu.ConnectToBus(fakeBus); cpu.Step(); Assert.Equal(0x086, cpu.PC); FlagsUnchanged(cpu); }
private void Push(Z80 z80, Register16 register) { z80.SP.Value++; z80.Memory.Set(z80.SP.Value, register.High.Value); z80.SP.Value++; z80.Memory.Set(z80.SP.Value, register.Low.Value); }
private void LoadProgramCounterWithAddressForJPNN() { var fakeBus = A.Fake <IBus>(); var program = new Dictionary <ushort, byte> { // Program Code { 0x0080, 0xC3 }, // JP 0191h { 0x0081, 0x91 }, { 0x0082, 0x01 }, { 0x0083, 0x00 }, { 0x0084, 0x00 }, { 0x0190, 0x00 }, { 0x0191, 0x00 }, // <- jump here { 0x0192, 0x00 }, }; A.CallTo(() => fakeBus.Read(A <ushort> ._, A <bool> ._)) .ReturnsLazily((ushort addr, bool ro) => program[addr]); var cpu = new Z80() { A = 0x00, PC = 0x0080 }; cpu.ConnectToBus(fakeBus); cpu.Step(); Assert.Equal(0x0191, cpu.PC); FlagsUnchanged(cpu); }
private void NotJumpBackFourForDJNZ_WhenZero() { var fakeBus = A.Fake <IBus>(); var program = new Dictionary <ushort, byte> { // Program Code { 0x007C, 0x00 }, // <- jump here { 0x007D, 0x00 }, { 0x007E, 0x00 }, { 0x007F, 0x00 }, { 0x0080, 0x10 }, // DJNZ $-4 { 0x0081, 0xFA }, // Assembler with compensate for PC incrementing twice { 0x0082, 0x00 }, { 0x0083, 0x00 }, { 0x0084, 0x00 }, { 0x0085, 0x00 }, { 0x0086, 0x00 }, { 0x0087, 0x00 }, }; A.CallTo(() => fakeBus.Read(A <ushort> ._, A <bool> ._)) .ReturnsLazily((ushort addr, bool ro) => program[addr]); var cpu = new Z80() { B = 0x01, PC = 0x0080 }; cpu.ConnectToBus(fakeBus); cpu.Step(); Assert.Equal(0x082, cpu.PC); }
private void SwapAFandAFPrime() { var fakeBus = A.Fake <IBus>(); var program = new Dictionary <ushort, byte> { // Program Code { 0x0080, 0x08 }, // EX AF,AF' { 0x0081, 0x00 }, { 0x0082, 0x00 }, { 0x0083, 0x00 }, { 0x0084, 0x00 }, }; A.CallTo(() => fakeBus.Read(A <ushort> ._, A <bool> ._)) .ReturnsLazily((ushort addr, bool ro) => program[addr]); var cpu = new Z80() { A = 0x11, F = (Flags)0x22, PC = 0x0080 }; cpu.ConnectToBus(fakeBus); cpu.Step(); Assert.Equal(0x0000, cpu.AF); Assert.Equal(0x1122, cpu.AF1); FlagsUnchanged(cpu); }
private void SwapRegistersWithEXX() { var fakeBus = A.Fake <IBus>(); var program = new Dictionary <ushort, byte> { // Program Code { 0x0080, 0xD9 }, // EXX { 0x0081, 0x00 }, { 0x0082, 0x00 }, { 0x0083, 0x00 }, { 0x0084, 0x00 }, }; A.CallTo(() => fakeBus.Read(A <ushort> ._, A <bool> ._)) .ReturnsLazily((ushort addr, bool ro) => program[addr]); var cpu = new Z80() { B = 0x11, C = 0x22, D = 0x12, E = 0x23, H = 0x14, L = 0x24, PC = 0x0080 }; cpu.ConnectToBus(fakeBus); cpu.Step(); Assert.Equal(0x0000, cpu.BC); Assert.Equal(0x1122, cpu.BC1); Assert.Equal(0x0000, cpu.DE); Assert.Equal(0x1223, cpu.DE1); Assert.Equal(0x0000, cpu.HL); Assert.Equal(0x1424, cpu.HL1); FlagsUnchanged(cpu); }
void UpdateListing(Z80 z80) { if (z80 == null) { return; } Disassembler.DisassembleROM = true; if (Disassembler.SourceLines[z80.PC].Text == null) { if (addresses == null) { addresses = new List <int>(); } addresses.Add(z80.PC); Disassembler.Disassemble(z80.Memory); Disassembler.Disassemble(0, addresses, 0, 65535, z80.Memory, true, true, true); //MonitorWindow.ReadOnly = false; scintillaZ80Monitor1.ForceText = Disassembler.Listing.ToString(); //MonitorWindow.ReadOnly = true; } else if (scintillaZ80Monitor1.Text.Length == 0) { scintillaZ80Monitor1.ForceText = Disassembler.Listing.ToString(); } int line = scintillaZ80Monitor1.LineFromPosition(Disassembler.SourceLines[z80.PC].Start); scintillaZ80Monitor1.GotoPosition(Disassembler.SourceLines[z80.PC].Start); scintillaZ80Monitor1.SelectionStart = Disassembler.SourceLines[z80.PC].Start; scintillaZ80Monitor1.SelectionEnd = Disassembler.SourceLines[z80.PC].Start + Disassembler.SourceLines[z80.PC].Length; Globals.DoEvents(); }
private void SwapDEandHL() { var fakeBus = A.Fake <IBus>(); var program = new Dictionary <ushort, byte> { // Program Code { 0x0080, 0xEB }, // EX DE,HL { 0x0081, 0x00 }, { 0x0082, 0x00 }, { 0x0083, 0x00 }, { 0x0084, 0x00 }, }; A.CallTo(() => fakeBus.Read(A <ushort> ._, A <bool> ._)) .ReturnsLazily((ushort addr, bool ro) => program[addr]); var cpu = new Z80() { D = 0x11, E = 0x22, H = 0x33, L = 0x44, PC = 0x0080 }; cpu.ConnectToBus(fakeBus); cpu.Step(); Assert.Equal(0x3344, cpu.DE); Assert.Equal(0x1122, cpu.HL); FlagsUnchanged(cpu); }
public void Initialize() { Ports = new TVCPorts(); Memory = new TVCMemory(this); CPU = new Z80(Memory, (IZ80Port)Ports, null, true); Video = new TVCVideo(this); Keyboard = new TVCKeyboard(this); Interrupt = new TVCInterrupt(this); Sound = new TVCSound(this); Cards = new ITVCCard[TVComputerConstants.ExpansionCardCount]; Ports.AddPortReader(0x5a, PortRead5AH); // cartridge init Cartridge = new TVCCartridge(); Cartridge.Initialize(this); //((TVCCartridge)Cartridge).ReadCartridgeFile(@"d:\Projects\Retro\TVCDOC\Multicart4\test.bin"); Reset(); }
private void SetInterruptMode2() { var fakeBus = A.Fake <IBus>(); var program = new Dictionary <ushort, byte> { // Program Code { 0x0080, 0xED }, // IM 2 { 0x0081, 0x5E }, { 0x0082, 0x00 }, { 0x0083, 0x00 }, { 0x0084, 0x00 }, }; A.CallTo(() => fakeBus.Read(A <ushort> ._, A <bool> ._)) .ReturnsLazily((ushort addr, bool ro) => program[addr]); var cpu = new Z80() { A = 0x00, PC = 0x0080 }; cpu.ConnectToBus(fakeBus); cpu.Step(); Assert.True(cpu.InterruptMode == InterruptMode.Mode2); }
private void EnableInterruptBySettingIFF() { var fakeBus = A.Fake <IBus>(); var program = new Dictionary <ushort, byte> { // Program Code { 0x0080, 0xFB }, // EI { 0x0081, 0x00 }, { 0x0082, 0x00 }, { 0x0083, 0x00 }, { 0x0084, 0x00 }, }; A.CallTo(() => fakeBus.Read(A <ushort> ._, A <bool> ._)) .ReturnsLazily((ushort addr, bool ro) => program[addr]); var cpu = new Z80() { A = 0x00, PC = 0x0080 }; cpu.ConnectToBus(fakeBus); cpu.Step(); Assert.True(cpu.IFF1); Assert.True(cpu.IFF2); }
private void OpenFile() { if (openFileDia.ShowDialog() != DialogResult.OK) { return; } var fileName = openFileDia.FileName; if (File.Exists(fileName) == false) { return; } var fileBytes = File.ReadAllBytes(fileName); if (fileBytes.Length > Memory.MEMORY_SIZE) { MessageBox.Show("The program file is too big.\nMax file size = " + Memory.MEMORY_SIZE + " bytes", "Large File", MessageBoxButtons.OK, MessageBoxIcon.Error); return; } Memory mem = new Memory(fileBytes.Length); mem.LoadRom(fileBytes); _cpu = new Z80(mem); RefreshMemory(); RefreshRegisters(); RefreshFlags(); }
public TStates SetRegister(Z80 z80, Register8 register) { var address = ByteHelper.CreateUShort(z80.B.Value, z80.C.Value); register.Value = z80.Ports.GetByte(address); return(TStates.Count(12)); }
private void DecrementRegisterFlagsTest2() { var fakeBus = A.Fake <IBus>(); var program = new Dictionary <ushort, byte> { // Program Code { 0x0080, 0x15 }, { 0x0081, 0x00 }, { 0x0082, 0x00 }, { 0x0083, 0x00 }, }; A.CallTo(() => fakeBus.Read(A <ushort> ._, A <bool> ._)) .ReturnsLazily((ushort addr, bool ro) => program[addr]); var cpu = new Z80() { D = 0x80, PC = 0x0080 }; cpu.ConnectToBus(fakeBus); cpu.Step(); Assert.Equal(0x7F, cpu.D); Assert.True((cpu.F & Z80.Flags.N) == Z80.Flags.N); Assert.False((cpu.F & Z80.Flags.Z) == Z80.Flags.Z); Assert.False((cpu.F & Z80.Flags.S) == Z80.Flags.S); Assert.True((cpu.F & Z80.Flags.H) == Z80.Flags.H); Assert.True((cpu.F & Z80.Flags.P) == Z80.Flags.P); Assert.False((cpu.F & Z80.Flags.C) == Z80.Flags.C); Assert.True((cpu.F & Z80.Flags.U) == Z80.Flags.U); Assert.True((cpu.F & Z80.Flags.X) == Z80.Flags.X); }
protected override void LoadRegisters(Z80 cpu) { cpu.RaiseRESET(); cpu.IV = this.Peek(Offset_I); cpu.HL.Word = this.PeekWord(Offset_HL_); cpu.DE.Word = this.PeekWord(Offset_DE_); cpu.BC.Word = this.PeekWord(Offset_BC_); cpu.AF.Word = this.PeekWord(Offset_AF_); cpu.Exx(); cpu.HL.Word = this.PeekWord(Offset_HL); cpu.DE.Word = this.PeekWord(Offset_DE); cpu.BC.Word = this.PeekWord(Offset_BC); cpu.IY.Word = this.PeekWord(Offset_IY); cpu.IX.Word = this.PeekWord(Offset_IX); cpu.IFF2 = (this.Peek(Offset_IFF2) >> 2) != 0; cpu.REFRESH = this.Peek(Offset_R); cpu.ExxAF(); cpu.AF.Word = this.PeekWord(Offset_AF); cpu.SP.Word = this.PeekWord(Offset_SP); cpu.IM = this.Peek(Offset_IM); }
private void DoNotJumpForwardFourForJRCPositiveSix_CarryNotSet() { var fakeBus = A.Fake <IBus>(); var program = new Dictionary <ushort, byte> { // Program Code { 0x0080, 0x38 }, // JR C $+6 { 0x0081, 0x04 }, // Assembler with compensate for PC incrementing twice { 0x0082, 0x00 }, { 0x0083, 0x00 }, { 0x0084, 0x00 }, { 0x0085, 0x00 }, { 0x0086, 0x00 }, { 0x0087, 0x00 }, }; A.CallTo(() => fakeBus.Read(A <ushort> ._, A <bool> ._)) .ReturnsLazily((ushort addr, bool ro) => program[addr]); var cpu = new Z80() { A = 0x00, PC = 0x0080 }; cpu.ConnectToBus(fakeBus); cpu.Step(); Assert.Equal(0x082, cpu.PC); FlagsUnchanged(cpu); }
public MasterSystem() { Clock = new SystemClock(); Interconnect = new Interconnect(); CPU = new Z80(Clock, Interconnect); }
private void JumpForwardFourForJRNZPositiveSix_NotZeroSet() { var fakeBus = A.Fake <IBus>(); var program = new Dictionary <ushort, byte> { // Program Code { 0x0080, 0x20 }, // JR NZ $+6 { 0x0081, 0x04 }, // Assembler with compensate for PC incrementing twice { 0x0082, 0x00 }, { 0x0083, 0x00 }, { 0x0084, 0x00 }, { 0x0085, 0x00 }, { 0x0086, 0x00 }, // <- jump here { 0x0087, 0x00 }, }; A.CallTo(() => fakeBus.Read(A <ushort> ._, A <bool> ._)) .ReturnsLazily((ushort addr, bool ro) => program[addr]); var cpu = new Z80() { A = 0x00, PC = 0x0080 }; cpu.F = (Flags)0b00000000; // Reset Z flag cpu.ConnectToBus(fakeBus); cpu.Step(); Assert.Equal(0x086, cpu.PC); }
public void LoadRfromA() { var fakeBus = A.Fake <IBus>(); var program = new Dictionary <ushort, byte> { // Program Code { 0x0080, 0xED }, { 0x0081, 0x4F }, { 0x0082, 0x00 }, { 0x0083, 0x00 }, { 0x0084, 0x00 }, }; A.CallTo(() => fakeBus.Read(A <ushort> ._, A <bool> ._)) .ReturnsLazily((ushort addr, bool ro) => program[addr]); var cpu = new Z80() { A = 0x17, R = 0x00, IFF2 = true, PC = 0x0080 }; cpu.ConnectToBus(fakeBus); cpu.Step(); Assert.Equal(0x17, cpu.A); Assert.Equal(0x17, cpu.R); // No affect on Condition Flags FlagsUnchanged(cpu); }
public void Initialize() { Ports = new TVCPorts(); Memory = new TVCMemory(this); Memory.LoadSystemMemory(@"..\..\roms\rom.bin"); Memory.LoadExtMemory(@"..\..\roms\ext.bin"); //Memory.LoadCartMemory(@"d:\Stuff\tvc\szanko.rom"); //Memory.LoadCartMemory(@"c:\Temp\tvc\mralex.rom"); //Memory.LoadCartMemory(@"c:\Temp\tvc\invaders.rom"); //Memory.LoadCartMemory(@"c:\Temp\tvc\vili.rom"); //Memory.LoadCartMemory(@"c:\Users\laszlo.arvai\Downloads\cfcart128.crt"); Video = new TVCVideo(this); Keyboard = new TVCKeyboard(this); Interrupt = new TVCInterrupt(this); CPU = new Z80(Memory, Ports, null, true); Cards = new ITVCCard[TVComputerConstants.ExpansionCardCount]; //InsertCard(0, new HBF.HBFCard()); Ports.AddPortReader(0x5a, PortRead5AH); // cartridge init Cartridge = new TVCCartridge(); Cartridge.Initialize(this); //Cartridge = new TVCMultiCart(); //Cartridge.Initialize(this); Reset(); }
private void DisassembleDDCBandFDCBOpcodesCorrectly() { var fakeBus = A.Fake <IBus>(); var ram = HexFileReader.Read("../../../HexFiles/TestDDCBandFDCB.hex"); var expectedDisassembly = new Dictionary <ushort, string> { { 0x8000, "RL (IX+2)" }, { 0x8004, "RL (IY-3)" }, }; A.CallTo(() => fakeBus.Read(A <ushort> ._, A <bool> ._)) .ReturnsLazily((ushort addr, bool ro) => ram[addr]); var cpu = new Z80() { A = 0x00, PC = 0x8000 }; cpu.ConnectToBus(fakeBus); var disassembledCode = cpu.Disassemble(0x8000, 0x8007); Assert.Equal(expectedDisassembly, disassembledCode); }
private void DisassembleMultiplicationHexFileCorrectly() { var fakeBus = A.Fake <IBus>(); var ram = HexFileReader.Read("../../../HexFiles/Multiplication.hex"); var expectedDisassembly = new Dictionary <ushort, string> { { 0x8000, "LD BC,&0015" }, { 0x8003, "LD B,&08" }, { 0x8005, "LD DE,&002A" }, { 0x8008, "LD D,&00" }, { 0x800A, "LD HL,&0000" }, { 0x800D, "SRL C" }, { 0x800F, "JR C,$+3" }, { 0x8011, "ADD HL,DE" }, { 0x8012, "SLA E" }, { 0x8014, "RL D" }, { 0x8016, "DEC B" }, { 0x8017, "JP NZ,&800D" }, }; A.CallTo(() => fakeBus.Read(A <ushort> ._, A <bool> ._)) .ReturnsLazily((ushort addr, bool ro) => ram[addr]); var cpu = new Z80() { A = 0x00, PC = 0x8000 }; cpu.ConnectToBus(fakeBus); var disassembledCode = cpu.Disassemble(0x8000, 0x8017); Assert.Equal(expectedDisassembly, disassembledCode); }
private void DisassembleArithmetic1HexFileCorrectly() { var fakeBus = A.Fake <IBus>(); var expectedDisassembly = new Dictionary <ushort, string> { { 0x0080, "LD A,&05" }, { 0x0082, "LD B,&0A" }, { 0x0084, "ADD A,B" }, { 0x0085, "ADD A,A" }, { 0x0086, "LD C,&0F" }, { 0x0088, "SUB A,C" }, { 0x0089, "LD H,&08" }, { 0x008B, "LD L,&FF" }, { 0x008D, "LD (HL),A" }, { 0x008E, "NOP" }, }; var ram = HexFileReader.Read("../../../HexFiles/Arithmetic1.hex"); A.CallTo(() => fakeBus.Read(A <ushort> ._, A <bool> ._)) .ReturnsLazily((ushort addr, bool ro) => ram[addr]); var cpu = new Z80() { A = 0x00, PC = 0x0080 }; cpu.ConnectToBus(fakeBus); var disassembledCode = cpu.Disassemble(0x0080, 0x008E); Assert.Equal(expectedDisassembly, disassembledCode); }
public static void frame() { Thread.Sleep(2); int fclk = Z80.Clock.t + 70224; do { try { Z80.step(); GPU.step(); } catch (Exception e) { Console.WriteLine("Registers:"); Console.WriteLine("A : " + Z80.Registers.a.ToString("X")); Console.WriteLine("B : " + Z80.Registers.b.ToString("X")); Console.WriteLine("C : " + Z80.Registers.c.ToString("X")); Console.WriteLine("D : " + Z80.Registers.d.ToString("X")); Console.WriteLine("E : " + Z80.Registers.e.ToString("X")); Console.WriteLine("H : " + Z80.Registers.h.ToString("X")); Console.WriteLine("L : " + Z80.Registers.l.ToString("X")); Console.WriteLine("PC : " + Z80.Registers.pc.ToString("X")); Console.WriteLine("SP : " + Z80.Registers.sp.ToString("X")); Console.WriteLine("F (Decimal) : " + Z80.Registers.f.ToString("X")); Console.WriteLine("Clock m : " + Z80.Clock.m.ToString("X")); Console.WriteLine("Clock t : " + Z80.Clock.t.ToString("X")); } } while (Z80.Clock.t < fclk); }
static void Main(string[] args) { var ram = new byte[65536]; Array.Clear(ram, 0, ram.Length); var romData = File.ReadAllBytes(_rom); if (romData.Length != 16384) { throw new InvalidOperationException("Not a valid ROM file"); } Array.Copy(romData, ram, 16384); _cpu = new Z80(); IBus simpleBus = new SimpleBus(ram); _cpu.ConnectToBus(simpleBus); Console.Clear(); while (!(Console.KeyAvailable && (Console.ReadKey(true).Key == ConsoleKey.Escape))) { try { _cpu.Step(); Console.Write($"\rPC: {_cpu.PC.ToString("X4")}"); } catch (Exception ex) { Console.WriteLine(ex.Message); Console.WriteLine(ex.StackTrace); Console.ReadLine(); } } Console.WriteLine(); Console.WriteLine(); for (var i = 0x4000; i < 0x5800; i++) { if (i % 16 == 0) { Console.Write("{0:X4} | ", i); } { Console.Write("{0:x2} ", ram[i]); } if (i % 8 == 7) { Console.Write(" "); } if (i % 16 == 15) { Console.WriteLine(); } } }
static public void OptReset() { Z80.Reset(); CRTC.Reset(); PPI.Reset(); UPD.Reset(); VGA.Reset(); }
private void Jump(Z80 z80, bool performJump) { if (performJump) { var address = BitConverter.ToUInt16(new[] { z80.Buffer[2], z80.Buffer[1] }, 0); z80.PC.Value = address; } }
/// <summary> /// Constructor. /// </summary> /// <param name="cpu"></param> /// <param name="memory"></param> public ZAsm(Z80 cpu, int[] memory) { Cpu = cpu; Memory = memory; ReadOpcodeMap(); Registers = new List<string>(); ReadListFromFile("Registers.txt", Registers); Mnemonics = new List<string>(); ReadListFromFile("Mnemonics.txt", Mnemonics); SymbolTable = new Dictionary<string,int>(); }
public MainEmulator() { _memoryMapper = new MemoryMapper(); _portMapper = new PortMapper(); _cpu = new Z80 { MemProvider = _memoryMapper, PortProvider = _portMapper }; _graphics = new Graphics(); _memoryMapper.Register(0x1000, 0x1fff, _graphics, true, false); _portMapper.Register(5, 7, _graphics); _ram = new Ram(); _memoryMapper.Register(0, 0xffff, _ram, true, true); _portMapper.Register(0, 0, _ram); _tickCounter = new TickCounter(_cancellationTokenSource.Token); _portMapper.Register(130, 133, _tickCounter); _diskController = new DiskController(_memoryMapper, () => _cpu.Reset()); _portMapper.Register(160, 169, _diskController); _serial = new Serial(_memoryMapper); _portMapper.Register(170, 179, _serial); _led = new Led(); _portMapper.Register(3, 3, _led); _speaker = new Speaker(); _portMapper.Register(4, 4, _speaker); _keyboard = new Keyboard(); _portMapper.Register(128, 129, _keyboard); //FBootLoader = new BootLoader(FMemoryMapper); _memoryMapper.FinishRegistration(); OriginalSpeed = true; }
public Z80ALU(Z80 proc) { this.proc = proc; }