def main(): # Initialize CPU cpu = Cpu() # Initialize graphics key_lookup = initialize_io() key = None # Specify Rom (TODO: Build CLI) rom_path = "~Barend/Github/Chip-8/Roms/EMULOGO.ch8" # Load ROM load_rom(cpu.memory, cpu.pc, rom_path) # Main cycle while cpu.pc <= 4096: # Get pressed keys for event in pygame.event.get(): if event.type == pygame.KEYDOWN: key = key_lookup[event.unicode] # fetch opcode from memory opcode = cpu.fetch_opcode(cpu.pc) hex_opcode = hex(opcode) program_counter = cpu.pc # Execute opcode cpu.execute_operation(opcode, key)
def __init__(self): self.screen = Screen(640, 320) self.input_handler = InputHandler(self.screen) self.cpu = Cpu(self.screen, self.input_handler) self.loop()
def BIT(cpu: Cpu, token1: Token, token2: Token) -> None: bit = int(token1.value.strip(',')) # If the bit is not set if not cpu.register[token2.token_type] & (1 << bit): cpu.flags["Z"] = True cpu.flags["N"] = False cpu.flags["H"] = True return
def __init__(self, rom): self.rom = rom self.cpu = Cpu() self.gpu = Gpu() self.cpu.gpu = self.gpu # fill ram/rom for index, byte in enumerate(self.rom.rom): self.cpu.write_8bit(index, byte)
def __init__(self, debug, graphicsScale): self.rom = Rom() self.gpu = Gpu(graphicsScale) self.cpu = Cpu(self.gpu) self.gpu.setCpu(self.cpu) self.debugger = None self.debugger = Debugger(self.cpu) if True == debug: self.debugger.activate()
def DEC(cpu: Cpu, token1: Token) -> None: # Check if the register isn't already at 0 if not cpu.register[token1.token_type] == 0: cpu.register[token1.token_type] -= 1 # Set the subtract flag since a subtraction was performed cpu.flags["N"] = True # Set the zero flag to true since the register value is now zero if cpu.register[token1.token_type] == 0: cpu.flags["Z"] = True return
class TestMiscOpcodes(unittest.TestCase): def setUp(self): self.cpu = Cpu(MMU()) self.cpu.mmu.rom = [0] * 128 self.cpu.mmu.load('C:/Users/cjpowell/workspace/Python/gbpy/resources/test_file.gb') def test_daa(self): self.cpu.registers.a = 0xc9 self.cpu._op_27() self.assertEqual(self.cpu.registers.a, 0x29) self.assertEqual(self.cpu.registers.carry_flag, 1)
def part1(): target = 19690720 part1_code = _code.copy() cpu = Cpu(_code) for noun in range(100): for verb in range(100): part1_code[1] = noun part1_code[2] = verb cpu.flash(part1_code) memory = cpu.run() if memory[0] == target: return 100 * noun + verb
def AND(cpu: Cpu, token1: Token) -> None: # Check if the token is of type value if token1.token_type == tt.VALUE: cpu.register[tt.REGISTER_A] &= get_value(token1) # Otherwise it must be a register else: cpu.register[tt.REGISTER_A] &= cpu.register[token1.token_type] # Setup flags if cpu.register[tt.REGISTER_A] == 0: cpu.flags["Z"] = True cpu.flags["N"] = False cpu.flags["H"] = True cpu.flags["C"] = False return
def symbbl(inst, arch="i386", preDefineMem={}, startPC=0): assert arch in ["i386", "amd64"] instmem = InstMemory() for addr in xrange(len(inst)): instmem.putchar(addr, inst[addr]) datamem = DataMemory({'i386': 32, 'amd64': 64}[arch]) PC0 = startPC cpu = Cpu(instmem, datamem, arch) cpu.PC = startPC for k in preDefineMem.keys(): _doPreDefineMem(k[0], k[1], preDefineMem[k], datamem, cpu) #RUN while PC0 <= cpu.PC < len(inst) + PC0: if issymbolic(cpu.PC): pcs = getallvalues(cpu.PC) if len(pcs) == 1: cpu.PC = pcs[0] else: print "Stop Execution because symbolic PC" print pcs print cpu.PC raw_input() break print cpu.getInstruction(cpu.PC) cpu.execute() return cpu
def setUp(self): self.cpu = Cpu(MMU()) self.cpu.mmu.rom = [0] * 128 self.cpu.mmu.load('C:/Users/cjpowell/workspace/Python/gbpy/resources/test_file.gb') self.cpu.mmu.rom[0] = 0x1 self.cpu.mmu.rom[1] = 0xed self.cpu.registers.sp = 0xfffe
class Machine(object): def __init__(self): self.cpu = Cpu(self) self.memory = Memory(self) self.ppu = Ppu(self) self.apu = Apu(self) self.pads = [JoyStick(self), JoyStick(self)] self.rom = None self.total_cycles = 0 def load_rom(self, file_path): nes_rom = read_ines(file_path) self.rom = nes_rom.to_mapper() def run(self): while True: cycles = self.cpu.step() self.total_cycles += cycles for i in xrange(3 * cycles): # self.ppu.step() pass for i in xrange(cycles): # self.apu.step() pass
def __init__(self, program, arguments, environment={}, symbolic=[]): # guess architecture from file from elftools.elf.elffile import ELFFile arch = {'x86':'i386','x64':'amd64'}[ELFFile(file(args.program)).get_machine_arch()] bits = {'i386':32, 'amd64':64}[arch] self.trace = [] logger.info("Loading %s ELF program %s", arch, program) logger.info("Arguments: %s", arguments) logger.info("Environment: %s", environment) solver = Solver() mem = SMemory(solver, bits, 12) cpu0 = Cpu(mem, arch) os = SLinux(solver, [cpu0], mem) self.os=os environment = [ '%s=%s' % (key, val) for (key,val) in environment.items() ] arguments = [program] + [ self.makeSymbolic(arguments[i], 'ARGV%02d'%i) for i in xrange(0, len(arguments)) ] environment = [ self.makeSymbolic(environment[i], 'ENV%02d'%i) for i in xrange(0, len(environment)) ] #pass arguments to exe os.exe(program, arguments, environment) #FIXME: Find a way to set symbolic files from command line # open standard files stdin, stdout, stderr assert os._open(SymbolicFile(solver, 'stdin','rb')) == 0 assert os._open(File('stdout','wb')) == 1 assert os._open(File('stderr','wb')) == 2 self.trace = []
def main(): rom = file_explorer() if rom is None: sys.exit() renderer = Renderer() keyboard = Keyboard() cpu = Cpu(renderer, keyboard) game_starter(rom, cpu, renderer, keyboard)
def on_init(self): pygame.init() self._display_surf = pygame.display.set_mode( self.size, pygame.HWSURFACE | pygame.DOUBLEBUF, 8) # Set NES color palette. self._display_surf.set_palette([(0x75, 0x75, 0x75), (0x27, 0x1b, 0x8f), (0x00, 0x00, 0xab), (0x47, 0x00, 0x9f), (0x8f, 0x00, 0x77), (0xab, 0x00, 0x13), (0xa7, 0x00, 0x00), (0x7f, 0x0b, 0x00), (0x43, 0x2f, 0x00), (0x00, 0x47, 0x00), (0x00, 0x51, 0x00), (0x00, 0x3f, 0x17), (0x1b, 0x3f, 0x5f), (0x00, 0x00, 0x00), (0x00, 0x00, 0x00), (0x00, 0x00, 0x00), (0xbc, 0xbc, 0xbc), (0x00, 0x73, 0xef), (0x23, 0x3b, 0xef), (0x83, 0x00, 0xf3), (0xbf, 0x00, 0xbf), (0xe7, 0x00, 0x5b), (0xdb, 0x2b, 0x00), (0xcb, 0x4f, 0x0f), (0x8b, 0x73, 0x00), (0x00, 0x97, 0x00), (0x00, 0xab, 0x00), (0x00, 0x93, 0x3b), (0x00, 0x83, 0x8b), (0x00, 0x00, 0x00), (0x00, 0x00, 0x00), (0x00, 0x00, 0x00), (0xff, 0xff, 0xff), (0x3f, 0xbf, 0xff), (0x5f, 0x97, 0xff), (0xa7, 0x8b, 0xfd), (0xf7, 0x7b, 0xff), (0xff, 0x77, 0xb7), (0xff, 0x77, 0x63), (0xff, 0x9b, 0x3b), (0xf3, 0xbf, 0x3f), (0x83, 0xd3, 0x13), (0x4f, 0xdf, 0x4b), (0x58, 0xf8, 0x98), (0x00, 0xeb, 0xdb), (0x00, 0x00, 0x00), (0x00, 0x00, 0x00), (0x00, 0x00, 0x00), (0xff, 0xff, 0xff), (0xab, 0xe7, 0xff), (0xc7, 0xd7, 0xff), (0xd7, 0xcb, 0xff), (0xff, 0xc7, 0xff), (0xff, 0xc7, 0xdb), (0xff, 0xbf, 0xb3), (0xff, 0xdb, 0xab), (0xff, 0xe7, 0xa3), (0xe3, 0xff, 0xa3), (0xab, 0xf3, 0xbf), (0xb3, 0xff, 0xcf), (0x9f, 0xff, 0xf3), (0x00, 0x00, 0x00), (0x00, 0x00, 0x00), (0x00, 0x00, 0x00)]) self._running = True self.cartridge = Cartridge("../../test/ff.nes") self.ppu = Ppu(self._display_surf) self.papu = Papu() self.cpu = Cpu(self.ppu, self.papu, self.cartridge, KeyboardController(self._display_surf)) self.cpu.power_on()
def __init__(self): self.cpu = Cpu() self.ppu = Ppu() self.rom = None self.memory = None self.is_running = False
def run(fp): program_contents = "" while True: read = os.read(fp, 4096) if len(read) == 0: break program_contents += read os.close(fp) cpu = Cpu(1024 * 1024, program_contents) start = time.time() cpu.run() end = time.time() print print "Executed %sops in %ss ( %sops/sec )" % (printpretty( cpu.counter), printpretty(end - start), printpretty(cpu.counter / (end - start)))
class Nes(object): __metaclass__ = Singleton def __init__(self): self.cpu = Cpu() self.ppu = Ppu() self.rom = None self.memory = None self.is_running = False def reset(self): if self.memory: self.memory.reset() self.cpu.reset() self.ppu.reset() def start(self): pass def stop(self): pass def load(self, filename): if self.is_running: self.stop() self.rom = Rom() self.rom.load(filename) if self.rom.is_valid: self.memory = Mapper(self.rom.mapper_type) if self.memory == None: raise Exception('Unknown mapper: %d' % self.rom.mapper_type) self.memory.load() self.ppu.set_mirroring(self.rom.get_mirrowing()) return self.rom.is_valid def reload(self): if self.rom and self.rom.filename: self.load(self.rom.filename)
def __init__(self): self.cpu = Cpu(self) self.memory = Memory(self) self.ppu = Ppu(self) self.apu = Apu(self) self.pads = [JoyStick(self), JoyStick(self)] self.rom = None self.total_cycles = 0
def XOR(cpu: Cpu, token1: Token) -> None: # Check if the token is of type value if token1.token_type == tt.VALUE: cpu.register[tt.REGISTER_A] ^= get_value(token1) # Check if the token is of type direct elif token1.token_type == tt.DIRECT: cpu.register[tt.REGISTER_A] ^= cpu.memory[get_direct_value( cpu, token1)] # Otherwise it must be a register else: cpu.register[tt.REGISTER_A] ^= cpu.register[token1.token_type] # Setup flags if cpu.register[tt.REGISTER_A] == 0: cpu.flags["Z"] = True cpu.flags["N"] = False cpu.flags["H"] = False cpu.flags["C"] = False return
def main(): cpu = Cpu() cpu.load_rom('games/UFO') while cpu.running: # each instruction is 2bytes long # so they need to be put together high_byte = cpu.memory[cpu.program_counter] low_byte = cpu.memory[cpu.program_counter+1] opcode = high_byte << 8 | low_byte cpu.opcode = OpCode(opcode) instruction = cpu.instruction_mapping.get(cpu.opcode.identifier, None) if not instruction: raise Exception('Instruction not found {:x}'.format(cpu.opcode)) else: instruction() cpu.program_counter += 2
def SUB(cpu: Cpu, token1: Token) -> None: # check if the token is of type value if token1.token_type == tt.VALUE: cpu.register[tt.REGISTER_A] -= get_value(token1) # check if the token is of type direct elif token1.token_type == tt.DIRECT: cpu.register[tt.REGISTER_A] -= cpu.memory[get_direct_value( cpu, token1)] # Otherwise it must be an register else: cpu.register[tt.REGISTER_A] -= cpu.register[token1.token_type] # Set flags if cpu.register[tt.REGISTER_A] <= 0: cpu.register[ tt. REGISTER_A] = 0 # Make sure that the register isn't a negative value cpu.flags["Z"] = True cpu.flags["N"] = True return
def setUp(self): self.mManager = Mock() self.mHandler = Mock() self.cpu = Cpu(self.mManager,self.mHandler) self.aPcb = Mock() when(self.aPcb).getPid().thenReturn(0) when(self.aPcb).basePointer().thenReturn(0) when(self.aPcb).programCounter().thenReturn(0) when(self.aPcb).size().thenReturn(0) when(self.aPcb).displazament().thenReturn(0) self.instruction = Mock()
def SWAP(cpu: Cpu, token1: Token) -> None: # Check if we are dealing with a value in memory (direct) if token1.token_type == tt.DIRECT: value = cpu.memory[get_direct_value(cpu, token1)] # Otherwise it must be a register else: value = cpu.register[token1.token_type] result = ((value & 0x0F) << 4 | (value & 0xF0) >> 4) # Set flags if result <= 0: result = 0 cpu.flags["Z"] = True cpu.flags["N"] = False cpu.flags["H"] = False cpu.flags["C"] = False if token1.token_type == tt.DIRECT: cpu.memory[get_direct_value(cpu, token1)] = result else: cpu.register[token1.token_type] = result return
def initCpuList(statFile): """ This function only runs once to initialize the cpuList. It creates placeholder Cpu objects for the cpuList so they can be used to store all cpu information later in the code. """ global cpuList statsAllCpu = re.findall(r'cpu\d+.* ', statFile) for statsForOneCpu in statsAllCpu: cpuCols = statsForOneCpu.split() cpuName = cpuCols[0] tempCpu = Cpu(cpuName) cpuList.append(tempCpu)
def INC(cpu: Cpu, token1: Token) -> None: # TODO: Set H flag # Check if the token is of type direct if token1.token_type == tt.DIRECT: cpu.memory[get_direct_value(cpu, token1)] += 1 # Otherwise an register is incremented else: cpu.register[token1.token_type] += 1 # Reset the the subtract flag since a increment was performed cpu.flags["N"] = False return
class Chip8: cpu = None screen = None input_handler = None MAX_MEMORY = 4096 def __init__(self): self.screen = Screen(640, 320) self.input_handler = InputHandler(self.screen) self.cpu = Cpu(self.screen, self.input_handler) self.loop() def loop(self): self.cpu.load_rom(sys.argv[1]) while True: self.cpu.cycle()
class Emu(object): def __init__(self, debug, graphicsScale): self.rom = Rom() self.gpu = Gpu(graphicsScale) self.cpu = Cpu(self.gpu) self.gpu.setCpu(self.cpu) self.debugger = None self.debugger = Debugger(self.cpu) if True == debug: self.debugger.activate() def run(self, binPath): self.rom.load(binPath) self.cpu.execProg(self.rom.romData, self.debugger) self.pyGameMainLoop() def pyGameMainLoop(self): while 1: event = pygame.event.wait() if event.type == pygame.KEYDOWN: keysPressed = pygame.key.get_pressed() self.cpu.keyboard.keyPressedIndication(keysPressed) if keysPressed[pygame.K_q]: self.cpu.stop() if event.type == pygame.QUIT: self.cpu.stop() if False == self.cpu.running: raise SystemExit
def LD(cpu: Cpu, token1: Token, token2: Token) -> None: # Check if the second token is of type value if token2.token_type == tt.VALUE: # Check if the first token is of type direct if token1.token_type == tt.DIRECT: cpu.memory[get_direct_value(cpu, token1)] = get_value(token2) return # Otherwise it must be a register cpu.register[token1.token_type] = get_value(token2) # Check if the second token is of type direct elif token2.token_type == tt.DIRECT: cpu.register[token1.token_type] = cpu.memory[get_direct_value( cpu, token2)] return # Otherwise it must be register else: # Check if the first token is of type direct if token1.token_type == tt.DIRECT: cpu.memory[get_direct_value( cpu, token1)] = cpu.register[token2.token_type] return # Otherwise it must be register to register operations cpu.register[token1.token_type] = cpu.register[token2.token_type] return
def test_cpu_init(): c = Cpu(Machine()) print c.__dict__ c.set_carry(True) out1 = bin(c.p.value) print out1 c.set_interrupt(True) out2 = bin(c.p.value) print out2 c.test_and_set_negative(0x80) out4 = bin(c.p.value) print out4
class Chip16: def __init__(self, rom): self.rom = rom self.cpu = Cpu() self.gpu = Gpu() self.cpu.gpu = self.gpu # fill ram/rom for index, byte in enumerate(self.rom.rom): self.cpu.write_8bit(index, byte) def step(self): self.cpu.step() def print_debug(self): self.cpu.print_state()
def parseInfo(statFile, readTime): """ This function takes the information from /proc/stat and parses it for relevant information. Parameters: statFile (str): The contents of /proc/stat. readTime (float): The time at which /proc/stat was read. Returns: list: Returns a list of Cpu objects for each cpu on the system. """ global cpuList try: statsAllCpu = re.findall(r'cpu\d+.* ', statFile) for statsForOneCpu in statsAllCpu: cpuName, utime, _, stime, idle, *_ = statsForOneCpu.split() cpuIndex = cpuList.index(Cpu(cpuName)) cpuList[cpuIndex].updateAll(utime, stime, idle, readTime) return cpuList except: print("Error occurred while parsing cpustat file") return []
def runner(cpu: Cpu, parsed_tokens: List[List[Token]], display: Display = None) -> None: # Is the program finished? if cpu.register[TokenType.REGISTER_PC] >= len(parsed_tokens): print(f"[info] The program has jumped {JP.counter} times\n") return # Are the labels found yet? if cpu.labels is None: cpu.labels = search_labels(parsed_tokens) # Unpack current line opcode, *params = parsed_tokens[cpu.register[TokenType.REGISTER_PC]] # Check if the to be executed line isn't an invalid line if opcode.token_type == TokenType.INVALID: raise ASMSyntaxError(opcode.line, f"Invalid syntax: {opcode.value}") # Execute current line pc_value = cpu_opcodes[opcode.token_type](cpu, *params) # If the pc_value is not none, set the PC register to that value (happens with jump-like instructions) if pc_value: cpu.register[TokenType.REGISTER_PC] = pc_value # Otherwise up the program counter by one else: cpu.register[TokenType.REGISTER_PC] += 1 # Check if a display is supplied if display: if display.draw(cpu): raise DisplayClosed(None, "Display has been closed") # call the runner recursively return runner(cpu, parsed_tokens, display)
def on_init(self): pygame.init() self._display_surf = pygame.display.set_mode(self.size, pygame.HWSURFACE | pygame.DOUBLEBUF, 8) # Set NES color palette. self._display_surf.set_palette([ (0x75, 0x75, 0x75), (0x27, 0x1b, 0x8f), (0x00, 0x00, 0xab), (0x47, 0x00, 0x9f), (0x8f, 0x00, 0x77), (0xab, 0x00, 0x13), (0xa7, 0x00, 0x00), (0x7f, 0x0b, 0x00), (0x43, 0x2f, 0x00), (0x00, 0x47, 0x00), (0x00, 0x51, 0x00), (0x00, 0x3f, 0x17), (0x1b, 0x3f, 0x5f), (0x00, 0x00, 0x00), (0x00, 0x00, 0x00), (0x00, 0x00, 0x00), (0xbc, 0xbc, 0xbc), (0x00, 0x73, 0xef), (0x23, 0x3b, 0xef), (0x83, 0x00, 0xf3), (0xbf, 0x00, 0xbf), (0xe7, 0x00, 0x5b), (0xdb, 0x2b, 0x00), (0xcb, 0x4f, 0x0f), (0x8b, 0x73, 0x00), (0x00, 0x97, 0x00), (0x00, 0xab, 0x00), (0x00, 0x93, 0x3b), (0x00, 0x83, 0x8b), (0x00, 0x00, 0x00), (0x00, 0x00, 0x00), (0x00, 0x00, 0x00), (0xff, 0xff, 0xff), (0x3f, 0xbf, 0xff), (0x5f, 0x97, 0xff), (0xa7, 0x8b, 0xfd), (0xf7, 0x7b, 0xff), (0xff, 0x77, 0xb7), (0xff, 0x77, 0x63), (0xff, 0x9b, 0x3b), (0xf3, 0xbf, 0x3f), (0x83, 0xd3, 0x13), (0x4f, 0xdf, 0x4b), (0x58, 0xf8, 0x98), (0x00, 0xeb, 0xdb), (0x00, 0x00, 0x00), (0x00, 0x00, 0x00), (0x00, 0x00, 0x00), (0xff, 0xff, 0xff), (0xab, 0xe7, 0xff), (0xc7, 0xd7, 0xff), (0xd7, 0xcb, 0xff), (0xff, 0xc7, 0xff), (0xff, 0xc7, 0xdb), (0xff, 0xbf, 0xb3), (0xff, 0xdb, 0xab), (0xff, 0xe7, 0xa3), (0xe3, 0xff, 0xa3), (0xab, 0xf3, 0xbf), (0xb3, 0xff, 0xcf), (0x9f, 0xff, 0xf3), (0x00, 0x00, 0x00), (0x00, 0x00, 0x00), (0x00, 0x00, 0x00) ]) self._running = True self.cartridge = Cartridge("../../test/ff.nes") self.ppu = Ppu(self._display_surf) self.papu = Papu() self.cpu = Cpu(self.ppu, self.papu, self.cartridge, KeyboardController(self._display_surf)) self.cpu.power_on()
class TestCallOpcodes(unittest.TestCase): def setUp(self): self.cpu = Cpu(MMU()) self.cpu.mmu.rom = [0] * 128 self.cpu.mmu.load('C:/Users/cjpowell/workspace/Python/gbpy/resources/test_file.gb') self.cpu.mmu.rom[0] = 0x1 self.cpu.mmu.rom[1] = 0xed self.cpu.registers.sp = 0xfffe def test_standard_call(self): self.cpu._op_cd() self.assertEqual(self.cpu.registers.sp, 0xfffc) self.assertEqual(self.cpu.registers.pc, 1) self.cpu._op_cd() self.assertEqual(self.cpu.registers.sp, 0xfffa) self.assertEqual(self.cpu.registers.pc, 0xed) def test_call_if(self): self.cpu._op_c4() self.cpu._op_cc() self.cpu._op_d4() self.cpu._op_dc() self.assertTrue(False)
class TestJumpOpcodes(unittest.TestCase): def setUp(self): self.cpu = Cpu(MMU()) self.cpu.mmu.rom = [0] * 128 self.cpu.mmu.load('C:/Users/cjpowell/workspace/Python/gbpy/resources/test_file.gb') def test_jump_to_addr_nn(self): self.cpu._op_c3() self.assertEqual(self.cpu.registers.pc, 0xff00) def test_jump_to_addr_if(self): self.cpu._op_c2() self.assertEqual(self.cpu.registers.pc, 0xff00) self.assertEqual(self.cpu.registers.zero_flag, 0) self.cpu.registers.pc = 0 self.cpu.registers.zero_flag = 1 self.cpu._op_ca() self.assertEqual(self.cpu.registers.pc, 0xff00) self.cpu.registers.pc = 0 self.cpu._op_d2() self.assertEqual(self.cpu.registers.pc, 0xff00) self.assertEqual(self.cpu.registers.carry_flag, 0) self.cpu.registers.pc = 0 self.cpu.registers.carry_flag = 1 self.cpu._op_da() self.assertEqual(self.cpu.registers.pc, 0xff00) def test_jump_to_address_in_HL(self): self.cpu.registers.h = 0 self.cpu.registers.l = 0x41 self.cpu._op_e9() self.assertEqual(self.cpu.registers.pc, 0x24) def test_jump_to_addr_add_n(self): self.cpu._op_18() self.assertEqual(self.cpu.registers.pc, 0xff) def test_jump_to_add_add_n_if(self): self.cpu._op_20() self.assertEqual(self.cpu.registers.pc, 0xff) self.assertEqual(self.cpu.registers.zero_flag, 0) self.cpu.registers.pc = 0 self.cpu.registers.zero_flag = 1 self.cpu._op_28() self.assertEqual(self.cpu.registers.pc, 0xff) self.cpu.registers.pc = 0 self.cpu._op_30() self.assertEqual(self.cpu.registers.pc, 0xff) self.assertEqual(self.cpu.registers.carry_flag, 0) self.cpu.registers.pc = 0 self.cpu.registers.carry_flag = 1 self.cpu._op_38() self.assertEqual(self.cpu.registers.pc, 0xff)
def main(fileName): cpu = Cpu() cpu.load_rom(fileName) pygame.init() size = (640, 320) screen = pygame.display.set_mode(size) pygame.display.set_caption("Chip8") BLACK = (0, 0, 0) WHITE = (255, 255, 255) carryOn = True clock = pygame.time.Clock() while carryOn: for event in pygame.event.get(): # User did something if event.type == pygame.QUIT: # If user clicked close carryOn = False # Flag that we are done so we exit this loop #cpu.clear_keyboard() if event.type == pygame.KEYDOWN: if event.key == pygame.K_1: cpu.keyboard[0] = True if event.key == pygame.K_2: cpu.keyboard[1] = True if event.key == pygame.K_3: cpu.keyboard[2] = True if event.key == pygame.K_4: cpu.keyboard[3] = True if event.key == pygame.K_q: cpu.keyboard[4] = True if event.key == pygame.K_w: cpu.keyboard[5] = True if event.key == pygame.K_e: cpu.keyboard[6] = True if event.key == pygame.K_r: cpu.keyboard[7] = True if event.key == pygame.K_a: cpu.keyboard[8] = True if event.key == pygame.K_s: cpu.keyboard[9] = True if event.key == pygame.K_d: cpu.keyboard[10] = True if event.key == pygame.K_f: cpu.keyboard[11] = True if event.key == pygame.K_z: cpu.keyboard[12] = True if event.key == pygame.K_x: cpu.keyboard[13] = True if event.key == pygame.K_c: cpu.keyboard[14] = True if event.key == pygame.K_v: cpu.keyboard[15] = True if event.type == pygame.KEYUP: if event.key == pygame.K_1: cpu.keyboard[0] = False if event.key == pygame.K_2: cpu.keyboard[1] = False if event.key == pygame.K_3: cpu.keyboard[2] = False if event.key == pygame.K_4: cpu.keyboard[3] = False if event.key == pygame.K_q: cpu.keyboard[4] = False if event.key == pygame.K_w: cpu.keyboard[5] = False if event.key == pygame.K_e: cpu.keyboard[6] = False if event.key == pygame.K_r: cpu.keyboard[7] = False if event.key == pygame.K_a: cpu.keyboard[8] = False if event.key == pygame.K_s: cpu.keyboard[9] = False if event.key == pygame.K_d: cpu.keyboard[10] = False if event.key == pygame.K_f: cpu.keyboard[11] = False if event.key == pygame.K_z: cpu.keyboard[12] = False if event.key == pygame.K_x: cpu.keyboard[13] = False if event.key == pygame.K_c: cpu.keyboard[14] = False if event.key == pygame.K_v: cpu.keyboard[15] = False pass # Do clock cycle cpu.clock_cycle() if (cpu.quit): pygame.quit() return screen.fill(WHITE) #Clear screen #Draw on screen if cpu.display.draw: cpu.display.draw = False pixels = cpu.display.pixels for x in range(64): for y in range(32): if (pixels[y][x]): pygame.draw.rect(screen, WHITE, (x * 10, y * 10, 10, 10)) else: pygame.draw.rect(screen, BLACK, (x * 10, y * 10, 10, 10)) pygame.display.flip() #Show screen clock.tick(60) pygame.quit() pass
from cpu import Cpu from interpreter import Interpreter import struct if __name__ == "__main__": src = './code/factorial.asm' i = Interpreter() i.asm_decoder(src) vm = Cpu("./code/factorial.o") # print(vm.__get_data_from_memory(0)) # memory = 4 + 2 * 4 # pos = 0 vm.start() # vm.mm[0:4] = bytearray(struct.pack('I', 42)) # print(struct.unpack('I', vm.mm[pos:pos + 4])) vm.close()
class Pynes: def __init__(self): self._running = True self._display_surf = None self.size = self.width, self.height = 512, 448 def on_init(self): pygame.init() self._display_surf = pygame.display.set_mode(self.size, pygame.HWSURFACE | pygame.DOUBLEBUF, 8) # Set NES color palette. self._display_surf.set_palette([ (0x75, 0x75, 0x75), (0x27, 0x1b, 0x8f), (0x00, 0x00, 0xab), (0x47, 0x00, 0x9f), (0x8f, 0x00, 0x77), (0xab, 0x00, 0x13), (0xa7, 0x00, 0x00), (0x7f, 0x0b, 0x00), (0x43, 0x2f, 0x00), (0x00, 0x47, 0x00), (0x00, 0x51, 0x00), (0x00, 0x3f, 0x17), (0x1b, 0x3f, 0x5f), (0x00, 0x00, 0x00), (0x00, 0x00, 0x00), (0x00, 0x00, 0x00), (0xbc, 0xbc, 0xbc), (0x00, 0x73, 0xef), (0x23, 0x3b, 0xef), (0x83, 0x00, 0xf3), (0xbf, 0x00, 0xbf), (0xe7, 0x00, 0x5b), (0xdb, 0x2b, 0x00), (0xcb, 0x4f, 0x0f), (0x8b, 0x73, 0x00), (0x00, 0x97, 0x00), (0x00, 0xab, 0x00), (0x00, 0x93, 0x3b), (0x00, 0x83, 0x8b), (0x00, 0x00, 0x00), (0x00, 0x00, 0x00), (0x00, 0x00, 0x00), (0xff, 0xff, 0xff), (0x3f, 0xbf, 0xff), (0x5f, 0x97, 0xff), (0xa7, 0x8b, 0xfd), (0xf7, 0x7b, 0xff), (0xff, 0x77, 0xb7), (0xff, 0x77, 0x63), (0xff, 0x9b, 0x3b), (0xf3, 0xbf, 0x3f), (0x83, 0xd3, 0x13), (0x4f, 0xdf, 0x4b), (0x58, 0xf8, 0x98), (0x00, 0xeb, 0xdb), (0x00, 0x00, 0x00), (0x00, 0x00, 0x00), (0x00, 0x00, 0x00), (0xff, 0xff, 0xff), (0xab, 0xe7, 0xff), (0xc7, 0xd7, 0xff), (0xd7, 0xcb, 0xff), (0xff, 0xc7, 0xff), (0xff, 0xc7, 0xdb), (0xff, 0xbf, 0xb3), (0xff, 0xdb, 0xab), (0xff, 0xe7, 0xa3), (0xe3, 0xff, 0xa3), (0xab, 0xf3, 0xbf), (0xb3, 0xff, 0xcf), (0x9f, 0xff, 0xf3), (0x00, 0x00, 0x00), (0x00, 0x00, 0x00), (0x00, 0x00, 0x00) ]) self._running = True self.cartridge = Cartridge("../../test/ff.nes") self.ppu = Ppu(self._display_surf) self.papu = Papu() self.cpu = Cpu(self.ppu, self.papu, self.cartridge, KeyboardController(self._display_surf)) self.cpu.power_on() def on_event(self, event): if event.type == pygame.QUIT: self._running = False def on_loop(self): if self.cpu.registers['pc'] in BREAKPOINTS: raise Exception("Breakpoint at {0:#4x}".format(self.cpu.registers['pc'])) self.cpu.tick() nmi = self.ppu.tick() if nmi: self.cpu.interrupt('NMI') def on_render(self): pass def on_cleanup(self): pygame.quit() def on_execute(self): if self.on_init() == False: self._running = False while( self._running ): for event in pygame.event.get(): self.on_event(event) self.on_loop() self.on_render() self.on_cleanup()
def test_same_page(): a1 = 0x3244 a2 = 0x3256 assert Cpu.same_page(a1, a2)
from cpu import Cpu if __name__ == "__main__": proc = Cpu() proc.memory = [ 6502, # Store the integer of 6502 in location 0x00 42, # Store the integer of 42 in location 0x01 0xA5, 0x00, # LDA 00 ; Store the value at 0x00 in the A register 0xA6, 0x01, # LDX 01 ; Store the value at 0x01 in the X register 0x85, 0x01, # STA 01 ; Store the value in the A register in location 0x01 0x86, 0x00, # STX 00 ; Store the value in the X register in location 0x00 00 # BRK ; End our glorious program ] # our first instruction is LDA, which is at location 0x02, let's start there proc.pc=0x02 # Examine the memory before we start print("Before -- 0x00: %d 0x01: %d" % (proc.memory[0x0], proc.memory[0x1])) proc.run() # The results. The values at 0x0 and 0x1 should be swapped print("After -- 0x00: %d 0x01: %d" % (proc.memory[0x0], proc.memory[0x1]))
#* You should have received a copy of the GNU General Public License * #* along with this program. If not, see <http://www.gnu.org/licenses/>. * #* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ import sys import os from optparse import OptionParser from cpu import Cpu # Options, usage and stuff... ver = "%prog - version 0.1" usage = "usage: '%prog [options] GAME'\n\n" usage += "chipy8 is a Chip8 emulator written in Python using pygame.\n" parser = OptionParser(usage, version=ver) parser.add_option('-v', '--verbose', action='store_true', dest='verbose', default=False, help='Print debug information') parser.add_option('-i', '--ips', action='store', dest='ips', type='float', default=60, help='How many instructions to execute each second') parser.add_option('-s', '--scale', action='store', dest='scale', type='int', default=1, help='Increase the window size with the scale factor') (options, args) = parser.parse_args() if len(args) != 1: parser.error("Wrong number of arguments specified") else: if not os.path.exists(args[0]): parser.error("File doesn't exist") else: if os.path.getsize(args[0]) > 0x0fff: parser.error("File to large") cpu = Cpu(options.verbose, options.scale) cpu.read_rom(args[0]) cpu.run(options.ips)
def _init_cpu(self): bus = Bus(self._memory) self.cpu = Cpu(bus) self.cpu.pc = 0x200 self.gen = self.cpu.start()
def game_loop(): pygame.init() beep = pygame.mixer.Sound("bell.ogg") size = width, height = 640, 320 clock = pygame.time.Clock() black = 0, 0, 0 white = 255, 255, 255 fps = 60 gfx_width = 64 gfx_height = 32 scale_factor = 10 screen = pygame.display.set_mode(size) game = load_game("PONG2") cpu = Cpu() cpu.reset() i = 0 for x in range(len(game)): cpu.memory[i + 0x200] = game[i] i += 1 run = True while (run): for event in pygame.event.get(): if event.type == pygame.QUIT: run = False keys = pygame.key.get_pressed() if keys[pygame.K_ESCAPE]: run = False #Row 1 of keys cpu.key[1] = keys[pygame.K_1] cpu.key[2] = keys[pygame.K_2] cpu.key[3] = keys[pygame.K_3] cpu.key[0xc] = keys[pygame.K_4] #Row 2 of keys cpu.key[4] = keys[pygame.K_q] cpu.key[5] = keys[pygame.K_w] cpu.key[6] = keys[pygame.K_e] cpu.key[0xd] = keys[pygame.K_r] #Row 3 of keys cpu.key[7] = keys[pygame.K_a] cpu.key[8] = keys[pygame.K_s] cpu.key[9] = keys[pygame.K_d] cpu.key[0xe] = keys[pygame.K_f] #Row 4 of keys cpu.key[0xa] = keys[pygame.K_z] cpu.key[0x0] = keys[pygame.K_x] cpu.key[0xb] = keys[pygame.K_c] cpu.key[0xf] = keys[pygame.K_v] cpu.cycle() if cpu.play_sound: pygame.mixer.Sound.play(beep) cpu.play_sound = False if cpu.draw_flag: clock.tick(fps) for i in range(gfx_height): for j in range(gfx_width): if cpu.gfx[i * gfx_width + j]: screen.fill(white, (j * scale_factor, i * scale_factor, scale_factor, scale_factor)) else: screen.fill(black, (j * scale_factor, i * scale_factor, scale_factor, scale_factor)) pygame.display.flip() cpu.draw_flag = False pygame.quit()
class TestRetOpcodes(unittest.TestCase): def setUp(self): self.cpu = Cpu(MMU()) self.cpu.mmu.rom = [0] * 128 self.cpu.mmu.load('C:/Users/cjpowell/workspace/Python/gbpy/resources/test_file.gb') def test_standard_return(self): self.cpu._op_c9() self.assertTrue(False) def test_return_if(self): self.cpu._op_c0() self.cpu._op_c8() self.cpu._op_d0() self.cpu._op_d8() self.assertTrue(False) def test_return_enable_interrupts(self): self.cpu._op_d9() self.assertTrue(False)
class TestArithmeticOpcodes(unittest.TestCase): def setUp(self): self.cpu = Cpu(MMU()) self.cpu.mmu.rom = [0] * 128 self.cpu.mmu.load('C:/Users/cjpowell/workspace/Python/gbpy/resources/test_file.gb') def test_registers_0_at_init(self): self.assertEqual(0, self.cpu.registers.a) self.assertEqual(0, self.cpu.registers.b) self.assertEqual(0, self.cpu.registers.c) self.assertEqual(0, self.cpu.registers.d) self.assertEqual(0, self.cpu.registers.e) self.assertEqual(0, self.cpu.registers.h) self.assertEqual(0, self.cpu.registers.l) def test_flags_0_at_init(self): self.assertEqual(0, self.cpu.registers.carry_flag) self.assertEqual(0, self.cpu.registers.hc_flag) self.assertEqual(0, self.cpu.registers.zero_flag) self.assertEqual(0, self.cpu.registers.sub_flag) def test_direct_add(self): self.cpu.registers.b = 0 self.cpu.registers.c = 15 # should trip sub flag self.cpu.registers.d = 255 # should trip carry flag, sub flag reset self.cpu.registers.e = 7 self.cpu.registers.h = 234 # should trip zero flag self.cpu._op_80() self.assertEqual(self.cpu.registers.a, 0) self.assertListEqual([1, 0, 0, 0], self.cpu.flags()) self.cpu.registers.a = 1 self.cpu._op_81() self.assertEqual(self.cpu.registers.a, 16) self.assertListEqual([0, 0, 1, 0], self.cpu.flags()) self.cpu._op_82() self.assertEqual(self.cpu.registers.a, 15) self.assertListEqual([0, 0, 0, 1], self.cpu.flags()) self.cpu._op_83() self.cpu._op_84() self.assertEqual(self.cpu.registers.a, 0) self.assertListEqual([1, 0, 1, 1], self.cpu.flags()) def test_direct_adc(self): self.cpu.registers.b = 0 self.cpu.registers.c = 15 # should trip sub flag self.cpu.registers.d = 255 # should trip carry flag, sub flag reset self.cpu.registers.e = 7 self.cpu.registers.h = 233 # should trip zero flag self.cpu._op_88() self.assertEqual(self.cpu.registers.a, 0) self.assertListEqual([1, 0, 0, 0], self.cpu.flags()) self.cpu.registers.a = 1 self.cpu._op_89() self.assertEqual(self.cpu.registers.a, 16) self.assertListEqual([0, 0, 1, 0], self.cpu.flags()) self.cpu._op_8a() self.assertEqual(self.cpu.registers.a, 15) self.assertListEqual([0, 0, 0, 1], self.cpu.flags()) self.cpu._op_8b() self.cpu._op_8c() self.assertEqual(self.cpu.registers.a, 0) self.assertListEqual([1, 0, 1, 1], self.cpu.flags()) def test_indirect_add(self): self.cpu._op_86() self.assertEqual(self.cpu.registers.a, 0xff) self.assertEqual(self.cpu.registers.hc_flag, 0) self.cpu._op_c6() self.assertEqual(self.cpu.registers.a, 0xfe) self.assertEqual(self.cpu.registers.carry_flag, 1) self.assertEqual(self.cpu.registers.hc_flag, 1) def test_indirect_adc(self): self.cpu.registers.a = 1 self.cpu.registers.sub_flag = 1 self.cpu._op_8e() self.assertEqual(self.cpu.registers.a, 0) self.assertEqual(self.cpu.registers.zero_flag, 1) self.assertEqual(self.cpu.registers.sub_flag, 0) self.assertEqual(self.cpu.registers.carry_flag, 1) self.assertEqual(self.cpu.registers.hc_flag, 1) self.cpu._op_ce() self.assertEqual(self.cpu.registers.a, 1) self.assertEqual(self.cpu.registers.zero_flag, 0) self.assertEqual(self.cpu.registers.carry_flag, 0) self.assertEqual(self.cpu.registers.hc_flag, 0) def test_direct_sub(self): self.cpu.registers.a = 1 self.cpu.registers.b = 1 self.cpu.registers.c = 1 self.cpu._op_90() self.assertEqual(self.cpu.registers.sub_flag, 1) self.assertEqual(self.cpu.registers.zero_flag, 1) self.cpu._op_91() def test_direct_sbc(self): self.cpu.registers.b = 1 self.cpu._op_98() self.assertEqual(self.cpu.registers.a, 0xff) self.assertEqual(self.cpu.registers.sub_flag, 1) self.assertEqual(self.cpu.registers.zero_flag, 0) self.assertEqual(self.cpu.registers.carry_flag, 1) self.assertEqual(self.cpu.registers.hc_flag, 1) def test_indirect_sub(self): self.cpu.registers.a = 0xff self.cpu._op_96() self.assertEqual(self.cpu.registers.a, 0) self.assertEqual(self.cpu.registers.zero_flag, 1) self.assertEqual(self.cpu.registers.sub_flag, 1) self.cpu._op_96() self.assertEqual(self.cpu.registers.a, 0x01) self.assertEqual(self.cpu.registers.zero_flag, 0) self.assertEqual(self.cpu.registers.sub_flag, 1) self.assertEqual(self.cpu.registers.hc_flag, 1) self.assertEqual(self.cpu.registers.carry_flag, 1) self.cpu.registers.a = 0xff self.cpu.registers.pc = 0 # Just to be sure self.cpu._op_d6() # subtracts value in memory at location of current PC from A self.assertEqual(self.cpu.registers.a, 0) self.assertEqual(self.cpu.registers.pc, 1) self.assertEqual(self.cpu.registers.zero_flag, 1) self.assertEqual(self.cpu.registers.sub_flag, 1) self.assertEqual(self.cpu.registers.carry_flag, 0) self.assertEqual(self.cpu.registers.hc_flag, 0) def test_indirect_sbc(self): self.cpu._op_9e() self.assertEqual(self.cpu.registers.a, 0x01) self.assertEqual(self.cpu.registers.carry_flag, 1) self.assertEqual(self.cpu.registers.hc_flag, 1) self.assertEqual(self.cpu.registers.zero_flag, 0) self.assertEqual(self.cpu.registers.sub_flag, 1) self.cpu.registers.pc = 1 self.cpu._op_de() self.assertEqual(self.cpu.registers.a, 0) # Carry flag is set, so 1-1 = 0 self.assertEqual(self.cpu.registers.carry_flag, 0) self.assertEqual(self.cpu.registers.zero_flag, 1) self.assertEqual(self.cpu.registers.hc_flag, 0) self.assertEqual(self.cpu.registers.sub_flag, 1) def test_increment(self): self.cpu._op_04() self.assertEqual(self.cpu.registers.b, 1) self.cpu.registers.c = 0xf self.cpu._op_0c() self.assertEqual(self.cpu.registers.c, 0x10) self.assertEqual(self.cpu.registers.hc_flag, 1) self.cpu._op_34() self.assertEqual(self.cpu.registers.zero_flag, 1) self.assertEqual(self.cpu.registers.hc_flag, 1) def test_decrement(self): self.cpu.registers.b = 1 self.cpu._op_05() self.assertEqual(self.cpu.registers.b, 0) self.assertEqual(self.cpu.registers.zero_flag, 1) self.assertEqual(self.cpu.registers.sub_flag, 1) self.assertEqual(self.cpu.mmu.rom[0], 0xff) self.cpu._op_35() self.assertEqual(self.cpu.mmu.rom[0], 0xfe)
print "\nCAPTURING" print " b [address] \n\tSet one or more brakepoints." print " \tIf no address given a list of all breakpoints is displayed.\n" print " d[elete] <nr> \n\tDeletes breakpoint number <nr>.\n" print " w[watch] <register> \n\tTriggers changes in a register specified." print " \tIf no register is specified lists all watchpoints set.\n" print " dw <nr> \n\tDeletes watchpoint number <nr>.\n" def print_no_cpu(): print "No cpu loaded." print "AUA interactive debugging shell 0.1" c = Cpu() c.load("../../as/boot") input = readline.get_line_buffer() while len(input) == 0 or input[0] != "q": if len(input) > 0: if input[0] == "b": if len(input) > 1: c.add_breakpoint(input[1:]) else: breakpoints = c.list_breakpoints() if len(breakpoints) > 0: for i in range(len(breakpoints)): print i+1, "\t", hex(breakpoints[i])
def setUp(self): self.cpu = Cpu(MMU()) self.cpu.mmu.rom = [0] * 128 self.cpu.mmu.load('C:/Users/cjpowell/workspace/Python/gbpy/resources/test_file.gb')
class TestLogicalArithmeticOpcodes(unittest.TestCase): def setUp(self): self.cpu = Cpu(MMU()) self.cpu.mmu.rom = [0] * 128 self.cpu.mmu.load('C:/Users/cjpowell/workspace/Python/gbpy/resources/test_file.gb') def test_direct_xor(self): self.cpu._op_a8() self.assertEqual(self.cpu.registers.a, 0) self.assertEqual(self.cpu.registers.zero_flag, 1) self.cpu.registers.b = 0xf self.cpu._op_a8() self.assertEqual(self.cpu.registers.a, 0xf) self.assertEqual(self.cpu.registers.zero_flag, 0) self.cpu.registers.b = 0x5f self.cpu._op_a8() self.assertEqual(self.cpu.registers.a, 0x50) def test_indirect_xor(self): self.cpu._op_ae() self.assertEqual(self.cpu.registers.a, 0xff) self.assertEqual(self.cpu.registers.zero_flag, 0) self.cpu._op_ae() self.assertEqual(self.cpu.registers.a, 0) self.assertEqual(self.cpu.registers.zero_flag, 1) def test_direct_or(self): self.cpu.registers.b = 0 self.cpu._op_b0() self.assertEqual(self.cpu.registers.a, 0) self.assertEqual(self.cpu.registers.zero_flag, 1) self.cpu.registers.b = 0x8 self.cpu._op_b0() self.assertEqual(self.cpu.registers.a, 0x8) self.assertEqual(self.cpu.registers.zero_flag, 0) self.cpu.registers.b = 0xf7 self.cpu._op_b0() self.assertEqual(self.cpu.registers.a, 0xff) def test_indirect_or(self): self.cpu._op_b6() self.assertEqual(self.cpu.registers.a, 0xff) self.assertEqual(self.cpu.registers.zero_flag, 0) self.cpu._op_b6() self.assertEqual(self.cpu.registers.a, 0xff) def test_and(self): self.cpu.registers.b = 0xf self.cpu._op_a0() self.assertEqual(self.cpu.registers.a, 0) self.assertEqual(self.cpu.registers.zero_flag, 1) self.cpu.registers.a = 0xff self.cpu._op_a6() self.assertEqual(self.cpu.registers.a, 0xff) self.assertEqual(self.cpu.registers.zero_flag, 0) self.cpu.registers.pc = 1 self.cpu._op_e6() self.assertEqual(self.cpu.registers.a, 0) self.assertEqual(self.cpu.registers.zero_flag, 1) self.assertEqual(self.cpu.registers.pc, 2) def test_compare(self): self.cpu._op_b8() self.assertEqual(self.cpu.registers.a, 0) self.assertEqual(self.cpu.registers.zero_flag, 1) self.assertEqual(self.cpu.registers.carry_flag, 0) self.cpu._op_be() self.assertEqual(self.cpu.registers.zero_flag, 0) self.assertEqual(self.cpu.registers.carry_flag, 1) self.assertEqual(self.cpu.registers.hc_flag, 1) self.cpu.registers.a = 0xff self.cpu._op_fe() self.assertEqual(self.cpu.registers.zero_flag, 1) self.assertEqual(self.cpu.registers.carry_flag, 0)
class TestLoadOpcodes(unittest.TestCase): def setUp(self): self.cpu = Cpu(MMU()) self.cpu.mmu.rom = [0] * 128 self.cpu.mmu.load('C:/Users/cjpowell/workspace/Python/gbpy/resources/test_file.gb') def test_direct_load(self): self.cpu.registers.b = 10 self.cpu._op_48() self.assertEqual(self.cpu.registers.b, self.cpu.registers.c) self.assertEqual(self.cpu.registers.c, 10) def test_indirect_load_HL(self): self.cpu.registers.h = 0x0 self.cpu.registers.l = 0x0 self.cpu._op_46() self.assertEqual(self.cpu.registers.b, 0xff) # All GB roms will start with this reset op def test_indirect_load_PC(self): # Reads from memory at address stored in pc (next byte read) self.cpu.registers.pc = 0x0 self.cpu._op_06() self.assertEqual(self.cpu.registers.b, 0xff) # roms begin with 0xff and that is what we are at. self.assertEqual(self.cpu.registers.pc, 0x01) # pc should increment, as we read next value for load def test_indirect_load_inc(self): self.cpu._op_22() self.assertEqual(self.cpu.registers.a, 0xff) self.assertEqual(self.cpu.registers.l, 1) self.assertEqual(self.cpu.registers.h, 0) self.cpu.registers.l = 0xff self.cpu._op_22() self.assertEqual(self.cpu.registers.l, 0) self.assertEqual(self.cpu.registers.h, 1) def test_indirect_load_dec(self): self.cpu.registers.l = 1 self.cpu._op_32() self.assertEqual(self.cpu.registers.a, 0) self.assertEqual(self.cpu.registers.l, 0) self.cpu._op_32() self.assertEqual(self.cpu.registers.a, 0xff) self.assertEqual(self.cpu.registers.l, 0xff) self.assertEqual(self.cpu.registers.h, 0xff)
class TestShiftAndRotateOpcodes(unittest.TestCase): def setUp(self): self.cpu = Cpu(MMU()) self.cpu.mmu.rom = [0] * 128 self.cpu.mmu.load('C:/Users/cjpowell/workspace/Python/gbpy/resources/test_file.gb') def test_rlca(self): self.cpu.registers.a = 0x80 # 1000 0001 self.cpu._op_07() self.assertEqual(self.cpu.registers.a, 1) self.assertEqual(self.cpu.registers.carry_flag, 1) self.assertEqual(self.cpu.registers.zero_flag, 0) def test_rla(self): self.cpu.registers.a = 0x80 self.cpu._op_17() self.assertEqual(self.cpu.registers.a, 0) self.assertEqual(self.cpu.registers.carry_flag, 1) self.assertEqual(self.cpu.registers.zero_flag, 1) def test_rrca(self): self.cpu.registers.a = 1 self.cpu._op_0f() self.assertEqual(self.cpu.registers.a, 0x80) self.assertEqual(self.cpu.registers.carry_flag, 1) self.assertEqual(self.cpu.registers.zero_flag, 0) def test_rra(self): self.cpu.registers.a = 1 self.cpu._op_1f() self.assertEqual(self.cpu.registers.a, 0x0) self.assertEqual(self.cpu.registers.carry_flag, 1) self.assertEqual(self.cpu.registers.zero_flag, 1) def test_rlc(self): # TODO: part of extended opcodes self.assertTrue(False) def test_rl(self): # TODO: part of extended opcodes self.assertTrue(False) def test_rrc(self): # TODO: part of extended opcodes self.assertTrue(False) def test_rr(self): # TODO: part of extended opcodes self.assertTrue(False) def test_sla(self): # TODO: part of extended opcodes self.assertTrue(False) def test_sra(self): # TODO: part of extended opcodes self.assertTrue(False) def test_srl(self): # TODO: part of extended opcodes self.assertTrue(False)
import sys from helpers.utilities import Utilities import lexer import token_parser import run from cpu import Cpu from display import Display if __name__ == "__main__": sys.setrecursionlimit(10**6) code = Utilities.read_asm_file("src/display_test.asm") print("\n----- Stage 1 (Lexer) ----\n") tokens = lexer.lexer(code) for token in tokens: print(token) print("\n----- Stage 2 (Parser) ----\n") # Parse the token list parsed = token_parser.parser(tokens) for parsed_item in parsed: print(parsed_item) print("\n----- Stage 3 (Execution) ----\n") z80 = Cpu() display = Display() run.runner(z80, parsed, display) print(z80)
class CpuTest(unittest.TestCase): def setUp(self): self.mManager = Mock() self.mHandler = Mock() self.cpu = Cpu(self.mManager,self.mHandler) self.aPcb = Mock() when(self.aPcb).getPid().thenReturn(0) when(self.aPcb).basePointer().thenReturn(0) when(self.aPcb).programCounter().thenReturn(0) when(self.aPcb).size().thenReturn(0) when(self.aPcb).displazament().thenReturn(0) self.instruction = Mock() def test_changeRoundRobin(self): self.cpu.changeRoundRobin(8) assert (self.cpu.roundRobin == 8) def test_pcIncrease(self): self.cpu.currentPcb = self.aPcb self.cpu.pcIncrease() verify(self.aPcb).pcIncrease() def test_assignPcb(self): self.cpu.assignPcb(self.aPcb) assert (self.cpu.currentPcb == self.aPcb) def test_removePcb(self): self.cpu.currentPcb = self.aPcb self.cpu.removePcb() assert (self.cpu.currentPcb == None) def test_havePcbWithPcb(self): self.cpu.currentPcb = self.aPcb assert (self.cpu.havePcb()) def test_havePcbWithOutPcb(self): self.assertFalse(self.cpu.havePcb()) def test_executeWithFullQuantum(self): when(self.cpu).getCurrentPcb().thenReturn(self.aPcb) when(self.cpu).getMemory().thenReturn(self.mManager) when(self.mManager).getInstruction(self.aPcb.getPid(),self.aPcb.getDisplacement()).thenReturn(self.instruction) when(self.instruction).execute().thenReturn(False) when(self.instruction).isIOInstruction().thenReturn(False) self.cpu.quantum = 1 self.cpu.execute() verify(self.cpu.handler,times(1)).toWait(self.aPcb) verify(self.cpu.handler,times(0)).toKill(self.aPcb) verify(self.cpu.handler,times(0)).toIO(self.aPcb) assert self.cpu.quantum == 0 def test_executeWithOutFullQuantum(self): when(self.cpu).getCurrentPcb().thenReturn(self.aPcb) when(self.cpu).getMemory().thenReturn(self.mManager) when(self.mManager).getInstruction(self.aPcb.getPid(),self.aPcb.getDisplacement()).thenReturn(self.instruction) when(self.instruction).execute().thenReturn(False) when(self.instruction).isIOInstruction().thenReturn(False) self.cpu.execute() verify(self.aPcb).pcIncrease() verify(self.cpu.handler,times(0)).toWait(self.aPcb) verify(self.cpu.handler,times(0)).toKill(self.aPcb) verify(self.cpu.handler,times(0)).toIO(self.aPcb) assert self.cpu.quantum == 1 def test_executeWithKillIntruction(self): when(self.cpu).getCurrentPcb().thenReturn(self.aPcb) when(self.cpu).getMemory().thenReturn(self.mManager) when(self.mManager).getInstruction(self.aPcb.getPid(),self.aPcb.getDisplacement()).thenReturn(self.instruction) when(self.instruction).execute().thenReturn(True) when(self.instruction).isIOInstruction().thenReturn(False) self.cpu.execute() verify(self.cpu.handler,times(0)).toWait(self.aPcb) verify(self.cpu.handler,times(1)).toKill(self.aPcb) verify(self.cpu.handler,times(0)).toIO(self.aPcb) assert self.cpu.quantum == 0 def test_executeWithIOIntruction(self): when(self.cpu).getCurrentPcb().thenReturn(self.aPcb) when(self.cpu).getMemory().thenReturn(self.mManager) when(self.mManager).getInstruction(self.aPcb.getPid(),self.aPcb.getDisplacement()).thenReturn(self.instruction) when(self.instruction).execute().thenReturn(False) when(self.instruction).isIOInstruction().thenReturn(True) self.cpu.execute() verify(self.cpu.handler,times(0)).toWait(self.aPcb) verify(self.cpu.handler,times(0)).toKill(self.aPcb) verify(self.cpu.handler,times(1)).toIOInput(self.aPcb) assert self.cpu.quantum == 0
class Orion(QWidget): def __init__(self): super(Orion, self).__init__() self.ui = Ui_window() self.ui.setupUi(self) self.ui.tableWidget.setHorizontalHeaderLabels(['Endereço', 'Palavra']) self._memory = Memory() load_program(self._memory) self.ui.tableWidget.setRowCount(len(self._memory)) self._init_cpu() self._fill_table() self._connect_edits() self.ui.pushButtonNext.clicked.connect(self.next_cpu) self.ui.tableWidget.itemChanged.connect(self._update_word) def next_cpu(self): try: info = self.gen.send(None) self.ui.lineEditStatus.setText(info) self.ui.lineEditPC.setText(hex(self.cpu.pc)) self.ui.lineEditIR.setText(hex(self.cpu.ir)) self.ui.lineEditAH.setText(hex(self.cpu.ula.ah)) self.ui.lineEditBH.setText(hex(self.cpu.ula.bh)) self.ui.lineEditAC.setText(hex(self.cpu.ula.ac)) self.ui.lineEditAX.setText(hex(self.cpu.ax)) self.ui.lineEditBX.setText(hex(self.cpu.bx)) self.ui.lineEditCX.setText(hex(self.cpu.cx)) self.ui.lineEditDX.setText(hex(self.cpu.dx)) self.ui.lineEditSTS.setText(bin(self.cpu.sts)) self.ui.lineEditInstruction.setText(instrucoes[self.cpu.ir]) if self.cpu.ir == 0x8: self._update_table() self._select_row(hex(self.cpu.pc)) except StopIteration: QMessageBox.information(self, "Orion", "Execução Finalizada") def _init_cpu(self): bus = Bus(self._memory) self.cpu = Cpu(bus) self.cpu.pc = 0x200 self.gen = self.cpu.start() def _fill_table(self): for i in range(1, len(self._memory)): item_endereco = QTableWidgetItem(hex(i)) item_endereco.setFlags(item_endereco.flags() ^ Qt.ItemIsEditable) data = self._memory.operate(i, None, 0) if data is not None: data = hex(data) item_palavra = QTableWidgetItem(data) self.ui.tableWidget.setItem(i-1, 0, item_endereco) self.ui.tableWidget.setItem(i-1, 1, item_palavra) def _update_table(self): for i in range(1, len(self._memory)): item_palavra = self.ui.tableWidget.item(i-1, 1) data = self._memory.operate(i, None, 0) if data is not None: data = hex(data) item_palavra.setText(data) def _select_row(self, pc): item = self.ui.tableWidget.findItems(pc, Qt.MatchExactly)[0] self.ui.tableWidget.selectRow(item.row()) self.ui.tableWidget.scrollToItem(item) def _update_word(self, item): self.cpu.bus.transfer(int(self.ui.tableWidget.item(item.row(), 0).text(), 16), int(item.text(), 16), 1) def _connect_edits(self): self.ui.lineEditAH.editingFinished.connect(self._update_register) self.ui.lineEditBH.editingFinished.connect(self._update_register) self.ui.lineEditAC.editingFinished.connect(self._update_register) def _update_register(self): sender = self.sender().objectName() value = int(self.sender().text(), 16) if sender == 'lineEditAH': self.cpu.ula.ah = value elif sender == 'lineEditBH': self.cpu.ula.bh = value elif sender == 'lineEditAC': self.cpu.ula.ac = value
argv.append('matrizlinha.txt') argv.append('matrizcoluna.txt') argv.append('matrizlinha.txt') argv.append('matrizcoluna.txt') argv.append('matrizlinha.txt') argv.append('matrizcoluna.txt') argv.append('matrizlinha.txt') argv.append('matrizcoluna.txt') argv.append('matrizlinha.txt') argv.append('matrizcoluna.txt') argv.append('matrizlinha.txt') argv.append('matrizcoluna.txt') argv.append('matrizlinha.txt') argv.append('matrizcoluna.txt') argv.append('matrizlinha.txt') argv.append('matrizcoluna.txt') argv.append('matrizlinha.txt') argv.append('matrizcoluna.txt') argv.append('matrizlinha.txt') if len(argv) <= 1: print("Usage: pyton main.py programa1.txt programa2.txt...") exit() c = Cpu() mmu = Mmu(int(MEMORIA() / PAGINA()), PAGINA()) dados = Dados(MEMORIA(), PAGINA()) controlador = Controlador() timer = Timer() so = So(timer, argv, dados) controlador.inicia(c, argv, dados, mmu, so, timer)