339 lines
16 KiB
Python
339 lines
16 KiB
Python
# -*- coding: utf8 -*-
|
|
import pygame, numpy, sys, datetime, wave, time
|
|
|
|
class CPU(object):
|
|
CARRY, ZERO, INTERRUPT, DECIMAL, BREAK, UNUSED, OVERFLOW, NEGATIVE = [2**i for i in range(8)]
|
|
|
|
def __init__(self, memory):
|
|
s, self.tape_out, self.filename, self.samples = self, None, None, 0
|
|
s.memory, s.tape, s.flipflop, s.last_sound_cycles, s.sndbuf = memory, None, 0, -20000, []
|
|
s.cycles, s.pc, s.flags, s.sp, s.a, s.x, s.y = 0, 0xFF89, 48, 0xFF, 0, 0, 0
|
|
|
|
s._opcodes = { 0x00:(s.BRK,s.no,7), 0x01:(s.ORA,s.ix,6), 0x05:(s.ORA,s.zp,3),
|
|
0x06:(s.ASL,s.zp,5), 0x08:(s.PHP,s.no,3), 0x09:(s.ORA,s.im,2), 0x0a:(s.ASL,s.no,2),
|
|
0x0d:(s.ORA,s.ab,4), 0x0e:(s.ASL,s.ab,6), 0x10:(s.BPL,s.re,4), 0x11:(s.ORA,s.iy,6),
|
|
0x15:(s.ORA,s.zx,4), 0x16:(s.ASL,s.zx,6), 0x18:(s.CLC,s.no,2), 0x19:(s.ORA,s.ay,5),
|
|
0x1d:(s.ORA,s.ax,5), 0x1e:(s.ASL,s.ax,7), 0x20:(s.JSR,s.jm,6), 0x21:(s.AND,s.ix,6),
|
|
0x24:(s.BIT,s.zp,3), 0x25:(s.AND,s.zp,3), 0x26:(s.ROL,s.zp,5), 0x28:(s.PLP,s.no,4),
|
|
0x29:(s.AND,s.im,2), 0x2a:(s.ROL,s.no,2), 0x2c:(s.BIT,s.ab,4), 0x2d:(s.AND,s.ab,4),
|
|
0x2e:(s.ROL,s.ab,6), 0x30:(s.BMI,s.re,4), 0x31:(s.AND,s.iy,6), 0x35:(s.AND,s.zx,4),
|
|
0x36:(s.ROL,s.zx,6), 0x38:(s.SEC,s.no,2), 0x39:(s.AND,s.ay,5), 0x3d:(s.AND,s.ax,5),
|
|
0x3e:(s.ROL,s.ax,7), 0x40:(s.RTI,s.no,6), 0x41:(s.EOR,s.ix,6), 0x45:(s.EOR,s.zp,3),
|
|
0x46:(s.LSR,s.zp,5), 0x48:(s.PHA,s.no,3), 0x49:(s.EOR,s.im,2), 0x4a:(s.LSR,s.no,2),
|
|
0x4c:(s.JMP,s.jm,3), 0x4d:(s.EOR,s.ab,4), 0x4e:(s.LSR,s.ab,6), 0x50:(s.BVC,s.re,4),
|
|
0x51:(s.EOR,s.iy,6), 0x55:(s.EOR,s.zx,4), 0x56:(s.LSR,s.zx,6), 0x58:(s.CLI,s.no,2),
|
|
0x59:(s.EOR,s.ay,5), 0x5d:(s.EOR,s.ax,5), 0x5e:(s.LSR,s.ax,7), 0x60:(s.RTS,s.no,6),
|
|
0x61:(s.ADC,s.ix,6), 0x65:(s.ADC,s.zp,3), 0x66:(s.ROR,s.zp,5), 0x68:(s.PLA,s.no,4),
|
|
0x69:(s.ADC,s.im,2), 0x6a:(s.ROR,s.no,2), 0x6c:(s.JMP,s.id,5), 0x6d:(s.ADC,s.ab,4),
|
|
0x6e:(s.ROR,s.ab,6), 0x70:(s.BVS,s.re,3), 0x71:(s.ADC,s.iy,6), 0x75:(s.ADC,s.zx,4),
|
|
0x76:(s.ROR,s.zx,6), 0x78:(s.SEI,s.no,2), 0x79:(s.ADC,s.ay,5), 0x7d:(s.ADC,s.ax,5),
|
|
0x7e:(s.ROR,s.ax,7), 0x81:(s.STA,s.ix,6), 0x84:(s.STY,s.zp,3), 0x85:(s.STA,s.zp,3),
|
|
0x86:(s.STX,s.zp,3), 0x88:(s.DEY,s.no,2), 0x8a:(s.TXA,s.no,2), 0x8c:(s.STY,s.ab,4),
|
|
0x8d:(s.STA,s.ab,4), 0x8e:(s.STX,s.ab,4), 0x90:(s.BCC,s.re,4), 0x91:(s.STA,s.iy,6),
|
|
0x94:(s.STY,s.zx,4), 0x95:(s.STA,s.zx,4), 0x96:(s.STX,s.zy,4), 0x98:(s.TYA,s.no,2),
|
|
0x99:(s.STA,s.ay,5), 0x9a:(s.TXS,s.no,2), 0x9d:(s.STA,s.ax,5), 0xa0:(s.LDY,s.im,2),
|
|
0xa1:(s.LDA,s.ix,6), 0xa2:(s.LDX,s.im,2), 0xa4:(s.LDY,s.zp,3), 0xa5:(s.LDA,s.zp,3),
|
|
0xa6:(s.LDX,s.zp,3), 0xa8:(s.TAY,s.no,2), 0xa9:(s.LDA,s.im,2), 0xaa:(s.TAX,s.no,2),
|
|
0xac:(s.LDY,s.ab,4), 0xad:(s.LDA,s.ab,4), 0xae:(s.LDX,s.ab,4), 0xb0:(s.BCS,s.re,4),
|
|
0xb1:(s.LDA,s.iy,6), 0xb4:(s.LDY,s.zx,4), 0xb5:(s.LDA,s.zx,4), 0xb6:(s.LDX,s.zy,4),
|
|
0xb8:(s.CLV,s.no,2), 0xb9:(s.LDA,s.ay,5), 0xba:(s.TSX,s.no,2), 0xbc:(s.LDY,s.ax,5),
|
|
0xbd:(s.LDA,s.ax,5), 0xbe:(s.LDX,s.ay,5), 0xc0:(s.CPY,s.im,2), 0xc1:(s.CMP,s.ix,6),
|
|
0xc4:(s.CPY,s.zp,3), 0xc5:(s.CMP,s.zp,3), 0xc6:(s.DEC,s.zp,5), 0xc8:(s.INY,s.no,2),
|
|
0xc9:(s.CMP,s.im,2), 0xca:(s.DEX,s.no,2), 0xcc:(s.CPY,s.ab,4), 0xcd:(s.CMP,s.ab,4),
|
|
0xce:(s.DEC,s.ab,3), 0xd0:(s.BNE,s.re,4), 0xd1:(s.CMP,s.iy,6), 0xd5:(s.CMP,s.zx,4),
|
|
0xd6:(s.DEC,s.zx,6), 0xd8:(s.CLD,s.no,2), 0xd9:(s.CMP,s.ay,5), 0xdd:(s.CMP,s.ax,5),
|
|
0xde:(s.DEC,s.ax,7), 0xe0:(s.CPX,s.im,2), 0xe1:(s.SBC,s.ix,6), 0xe4:(s.CPX,s.zp,3),
|
|
0xe5:(s.SBC,s.zp,3), 0xe6:(s.INC,s.zp,5), 0xe8:(s.INX,s.no,2), 0xe9:(s.SBC,s.im,2),
|
|
0xea:(s.NOP,s.no,2), 0xec:(s.CPX,s.ab,4), 0xed:(s.SBC,s.ab,4), 0xee:(s.INC,s.ab,6),
|
|
0xf0:(s.BEQ,s.re,4), 0xf1:(s.SBC,s.iy,6), 0xf5:(s.SBC,s.zx,4), 0xf6:(s.INC,s.zx,6),
|
|
0xf8:(s.SED,s.no,2), 0xf9:(s.SBC,s.ay,5), 0xfd:(s.SBC,s.ax,5), 0xfe:(s.INC,s.ax,7)}
|
|
|
|
s._kbd = {0x83FE: (112, 240, 185, 39), 0x83FF: (45, 48), # [p đ š ;] [- 0]
|
|
0x85FE: (232, 230, 190, 43), 0x85FF: (8, 94), # [č ć ž :] [BS ^]
|
|
0x86FE: (102, 104, 103, 110), 0x86FF: (98, 118), # [f h g n] [b v]
|
|
0x877E: (100, 97, 115, 122), 0x877F: (120, 99), # [d a s z] [x c]
|
|
0x87BE: (108, 106, 107, 109), 0x87BF: (44, 46), # [l j k m] [, .]
|
|
0x87DE: (101, 113, 119, 49), 0x87DF: (50, 51), # [e q w l] [2 3]
|
|
0x87EE: (111, 105, 117, 55), 0x87EF: (56, 57), # [o i u 7] [8 9]
|
|
0x87F6: (114, 121, 116, 54), 0x87F7: (53, 52), # [r y t 6] [5 4]
|
|
0x87FA: (282, 283, 284, 285), 0x87FD: (13, 306), # [f1f2f3f4] [cr l_ctrl]
|
|
0x87FC: (276, 273, 274, 275), 0x87FB: (32, 304)} # [arrows] [spc l_shift]
|
|
|
|
s.ticks = {s.im: 1, s.zp: 1, s.zx: 1, s.zy: 1, s.ab: 2, s.ax: 2, s.no: 0,
|
|
s.ay: 2, s.jm: 2, s.id: 2, s.ix: 1, s.iy: 1, s.re: 1}
|
|
|
|
self.screen = pygame.display.set_mode((800, 900))
|
|
self.terminal = pygame.Surface((256, 256), pygame.SRCALPHA, depth=32)
|
|
self.terminal.fill((255, 255, 255))
|
|
self.alphaarray = pygame.surfarray.pixels_alpha(self.terminal)
|
|
|
|
self.background = pygame.image.load("pozadina.png").convert_alpha()
|
|
|
|
def get_flag(self, flag): return self.flags & flag != 0
|
|
|
|
def set_flag(self, flag, boolean):
|
|
self.flags = self.flags | flag if boolean else self.flags & ~(flag)
|
|
|
|
def set_nz(self, src):
|
|
self.set_flag(self.ZERO, src & 0xFF == 0)
|
|
self.set_flag(self.NEGATIVE, src & 0x80)
|
|
return src
|
|
|
|
def get_word(self, addr): return 256 * self.get_byte(addr + 1) + self.get_byte(addr)
|
|
|
|
def get_filename(self): return 'wav/{0}.WAV'.format(str(self.memory[592:602]).rstrip())
|
|
|
|
def speaker(self):
|
|
self.flipflop ^= 1
|
|
|
|
self.samples = int((self.cycles - self.last_sound_cycles) / 22.675)
|
|
if 1 < self.samples < 1000: # Ogranici frekventno podrucje
|
|
self.sndbuf += [255] * self.samples + [0] * self.samples
|
|
self.last_sound_cycles = self.cycles
|
|
|
|
def get_byte(self, addr):
|
|
if addr == 0x87FF: # Adresa ulaza kasetofona
|
|
if not self.tape:
|
|
self.tape = (255*(ord(j)>128) for i in \
|
|
wave.open(self.get_filename()).readframes(2**24) for j in 2*i)
|
|
|
|
try:
|
|
return self.tape.next()
|
|
|
|
except StopIteration:
|
|
self.tape = None
|
|
return 0x00
|
|
|
|
if addr == 0x8800: self.speaker() # Zvucnik
|
|
return self.memory[addr] if addr is not None else self.a
|
|
|
|
def store_byte(self, addr, val):
|
|
if addr is None: # Akumulator
|
|
self.a = val & 0xFF
|
|
return
|
|
|
|
if addr == 0x8800: self.speaker() # Zvucnik
|
|
if 0x6000 <= addr <= 0x7FFF: # Video RAM
|
|
y, x = divmod((addr - 0x6000) * 8, 256)
|
|
for i in range(8):
|
|
self.alphaarray[x+i, y] = 255 if (val>>i) & 1 else 0 # Transparency mask
|
|
|
|
self.memory[addr] = val & 0xFF
|
|
|
|
def stack_push(self, value):
|
|
self.store_byte(256 + self.sp, value & 0xFF)
|
|
self.sp = (self.sp - 1) & 0xFF
|
|
|
|
def stack_pop(self):
|
|
self.sp = (self.sp + 1) & 0xFF
|
|
return self.get_byte(256 + self.sp)
|
|
|
|
def stack_push_word(self, val): map(self.stack_push, [(val >> 8) & 0xFF, val & 0xFF])
|
|
|
|
def stack_pop_word(self): return self.stack_pop() + (self.stack_pop() << 8)
|
|
###########################################################################
|
|
# Adresni nacini
|
|
def im(self): return self.pc
|
|
def zp(self): return self.get_byte(self.pc)
|
|
def zx(self): return (self.zp() + self.x) & 0xFF
|
|
def zy(self): return (self.zp() + self.y) & 0xFF
|
|
def ab(self): return self.get_word(self.pc)
|
|
def ax(self): return (self.ab() + self.x) & 0xFFFF
|
|
def ay(self): return (self.ab() + self.y) & 0xFFFF
|
|
def ix(self): return self.get_word((self.zp() + self.x) & 0xFF)
|
|
def iy(self): return (self.get_word(self.zp()) + self.y) & 0xFFFF
|
|
def id(self): return self.get_word(self.ab())
|
|
def jm(self): return self.ab()
|
|
def no(self): return None
|
|
|
|
def re(self):
|
|
loc = self.zp()
|
|
addr = loc - 256 * (loc > 127) if loc & self.NEGATIVE else loc
|
|
return (self.pc + addr) & 0xFFFF
|
|
###########################################################################
|
|
# Instrukcije
|
|
def TAX(self, d): self.x = self.set_nz(self.a)
|
|
def TXA(self, d): self.a = self.set_nz(self.x)
|
|
def TAY(self, d): self.y = self.set_nz(self.a)
|
|
def TYA(self, d): self.a = self.set_nz(self.y)
|
|
def TSX(self, d): self.x = self.set_nz(self.sp)
|
|
def TXS(self, d): self.sp = self.x
|
|
|
|
def LDA(self, addr): self.a = self.set_nz(self.get_byte(addr))
|
|
def LDX(self, addr): self.x = self.set_nz(self.get_byte(addr))
|
|
def LDY(self, addr): self.y = self.set_nz(self.get_byte(addr))
|
|
def STA(self, addr): self.store_byte(addr, self.a)
|
|
def STX(self, addr): self.store_byte(addr, self.x)
|
|
def STY(self, addr): self.store_byte(addr, self.y)
|
|
|
|
def AND(self, addr): self.a = self.set_nz(self.get_byte(addr) & self.a)
|
|
def ORA(self, addr): self.a = self.set_nz(self.get_byte(addr) | self.a)
|
|
def EOR(self, addr): self.a = self.set_nz(self.get_byte(addr) ^ self.a)
|
|
|
|
def CLC(self, d): self.set_flag(self.CARRY, False)
|
|
def SEC(self, d): self.set_flag(self.CARRY, True)
|
|
def CLD(self, d): self.set_flag(self.DECIMAL, False)
|
|
def SED(self, d): self.set_flag(self.DECIMAL, True)
|
|
def CLI(self, d): self.set_flag(self.INTERRUPT, False)
|
|
def SEI(self, d): self.set_flag(self.INTERRUPT, True)
|
|
def CLV(self, d): self.set_flag(self.OVERFLOW, False)
|
|
|
|
def INX(self, d): self.x = self.set_nz((self.x + 1) & 0xFF)
|
|
def INY(self, d): self.y = self.set_nz((self.y + 1) & 0xFF)
|
|
def DEX(self, d): self.x = self.set_nz((self.x - 1) & 0xFF)
|
|
def DEY(self, d): self.y = self.set_nz((self.y - 1) & 0xFF)
|
|
|
|
def INC(self, addr): self.store_byte(addr, self.set_nz(self.get_byte(addr) + 1))
|
|
def DEC(self, addr): self.store_byte(addr, self.set_nz(self.get_byte(addr) - 1))
|
|
|
|
def ASL(self, addr):
|
|
operand = self.get_byte(addr)
|
|
self.set_flag(self.CARRY, operand & 0x80)
|
|
operand = (operand << 1) & 0xFE
|
|
self.store_byte(addr, self.set_nz(operand))
|
|
|
|
def BIT(self, addr):
|
|
op = self.get_byte(addr)
|
|
self.set_flag(self.ZERO, op & self.a == 0)
|
|
self.set_flag(self.NEGATIVE, op & self.NEGATIVE)
|
|
self.set_flag(self.OVERFLOW, op & self.OVERFLOW)
|
|
|
|
def PHP(self, d): self.stack_push(self.flags | self.BREAK | self.UNUSED)
|
|
def PHA(self, d): self.stack_push(self.a)
|
|
def PLP(self, d): self.flags = self.stack_pop()
|
|
def PLA(self, d): self.a = self.set_nz(self.stack_pop())
|
|
def NOP(self, d): pass
|
|
|
|
def ROR(self, addr):
|
|
value = self.get_byte(addr) >> 1 | self.get_flag(self.CARRY) * 128
|
|
self.set_flag(self.CARRY, self.get_byte(addr) & 1)
|
|
self.store_byte(addr, self.set_nz(value))
|
|
|
|
def ROL(self, addr):
|
|
value = self.get_byte(addr) * 2 + self.get_flag(self.CARRY)
|
|
self.set_flag(self.CARRY, value > 255)
|
|
self.store_byte(addr, self.set_nz(value & 0xFF))
|
|
|
|
def BRK(self, d):
|
|
self.stack_push_word((self.pc + 1) & 0xFFFF)
|
|
self.set_flag(self.BREAK, True)
|
|
self.PHP(0)
|
|
self.SEI(0)
|
|
self.pc = self.get_word(0xFFFE) # IRQ
|
|
|
|
def JMP(self, addr): self.pc = addr - 2
|
|
|
|
def JSR(self, addr):
|
|
if addr == 0xE7B7 and self.pc > 0xC000: # samo i jedino ako rutinu poziva ROM
|
|
if not self.tape_out:
|
|
self.tape_out = wave.open(self.get_filename(), 'w')
|
|
self.tape_out.setparams((1, 1, 44100, 0, 'NONE', 'not compressed'))
|
|
self.tape_out.writeframes(chr(255 * self.flipflop) * (1 + (self.y > 15)) * 10)
|
|
|
|
self.stack_push_word((self.pc + 1) & 0xFFFF)
|
|
self.pc = addr - 2
|
|
|
|
def LSR(self, addr):
|
|
self.set_flag(self.NEGATIVE, False)
|
|
self.set_flag(self.CARRY, self.get_byte(addr) & 1)
|
|
self.store_byte(addr, (self.get_byte(addr) >> 1) & 0x7F)
|
|
self.set_flag(self.ZERO, self.get_byte(addr) == 0)
|
|
|
|
def RTI(self, d):
|
|
self.flags = self.stack_pop() | self.BREAK | self.UNUSED
|
|
self.pc = self.stack_pop_word()
|
|
|
|
def RTS(self, d):
|
|
self.pc = self.stack_pop_word()
|
|
self.pc = (self.pc + 1) & 0xFFFF
|
|
|
|
def ADDITION(self, arg):
|
|
result = (arg & 0XFF) + self.a + self.get_flag(self.CARRY)
|
|
self.set_flag(self.OVERFLOW, (~(arg ^ self.a)) & (self.a ^ result) & 0x80)
|
|
self.set_flag(self.CARRY, result > 255)
|
|
self.a = self.set_nz(result) & 0xFF
|
|
|
|
def ADC(self, addr): self.ADDITION(self.get_byte(addr))
|
|
def SBC(self, addr): self.ADDITION(~self.get_byte(addr))
|
|
|
|
def COMPARE(self, what, addr):
|
|
self.set_flag(self.CARRY, self.set_nz(what - self.get_byte(addr)) >= 0)
|
|
|
|
def CMP(self, addr): self.COMPARE(self.a, addr)
|
|
def CPX(self, addr): self.COMPARE(self.x, addr)
|
|
def CPY(self, addr): self.COMPARE(self.y, addr)
|
|
|
|
def BRANCH(self, addr, flag, condition):
|
|
if self.get_flag(flag) is condition:
|
|
self.pc = addr
|
|
self.cycles += 1 # Ako se grana, to je 1 ekstra ciklus
|
|
|
|
|
|
def BCS(self, addr): self.BRANCH(addr, self.CARRY, True)
|
|
def BCC(self, addr): self.BRANCH(addr, self.CARRY, False)
|
|
def BEQ(self, addr): self.BRANCH(addr, self.ZERO, True)
|
|
def BNE(self, addr): self.BRANCH(addr, self.ZERO, False)
|
|
def BMI(self, addr): self.BRANCH(addr, self.NEGATIVE, True)
|
|
def BPL(self, addr): self.BRANCH(addr, self.NEGATIVE, False)
|
|
def BVS(self, addr): self.BRANCH(addr, self.OVERFLOW, True)
|
|
def BVC(self, addr): self.BRANCH(addr, self.OVERFLOW, False)
|
|
|
|
def step(self):
|
|
opcode = self.memory[self.pc]
|
|
self.pc = self.pc + 1 & 0xFFFF
|
|
instruction, addressing, cycles = self._opcodes[opcode]
|
|
instruction(addressing())
|
|
self.pc += self.ticks[addressing]
|
|
self.cycles += cycles
|
|
|
|
|
|
cpu = CPU(bytearray([0xFF]*0xC000) + bytearray(open('ORAO13.ROM', 'rb').read()))
|
|
pygame.mixer.pre_init(44100, 8, 1, buffer=2048)
|
|
pygame.init()
|
|
ratio, cpu.channel, running = 0, pygame.mixer.Channel(0), True
|
|
pygame.time.set_timer(pygame.USEREVENT + 1, 40)
|
|
|
|
while running:
|
|
before, previous_loop_cycles = datetime.datetime.now(), cpu.cycles
|
|
time_elapsed = lambda: (datetime.datetime.now()-before).microseconds + 1
|
|
|
|
for i in range(5000):
|
|
cpu.step()
|
|
|
|
for event in pygame.event.get():
|
|
if event.type == pygame.QUIT:
|
|
running = False
|
|
|
|
if event.type == pygame.MOUSEBUTTONDOWN:
|
|
x, y = event.pos
|
|
if 650 < x < 700 and 720 < y < 790: # Reset button
|
|
cpu.__init__(cpu.memory[:]) # Warm reset
|
|
|
|
if event.type in [pygame.KEYDOWN, pygame.KEYUP]:
|
|
for address, keycodes in cpu._kbd.iteritems():
|
|
keys = map(pygame.key.get_pressed().__getitem__, keycodes)
|
|
cpu.memory[address] = ~numpy.dot(keys, [16,32,64,128][:len(keys)]) & 0xFF
|
|
|
|
if event.type == pygame.USEREVENT + 1:
|
|
cpu.screen.blit(cpu.background, [0, 0])
|
|
cpu.screen.blit(pygame.transform.smoothscale(cpu.terminal, (512, 512)), [150, 140])
|
|
|
|
pygame.display.set_caption('({0:.2f} MHz) Orao Emulator v0.1'.format(ratio))
|
|
pygame.display.update()
|
|
|
|
cpu.tape_out = None if cpu.cycles - cpu.last_sound_cycles > 20000 else cpu.tape_out
|
|
|
|
if len(cpu.sndbuf) > 4096 or cpu.sndbuf and cpu.cycles - cpu.last_sound_cycles > 20000:
|
|
while cpu.channel.get_queue():
|
|
if time_elapsed() > 10000: break
|
|
|
|
cpu.channel.queue(pygame.sndarray.make_sound(numpy.uint8(cpu.sndbuf)))
|
|
cpu.sndbuf = []
|
|
|
|
overshoot = cpu.cycles - previous_loop_cycles - time_elapsed()
|
|
pygame.time.wait((overshoot > 0) * overshoot // 1000) # Pričekaj da budemo cycle exact
|
|
|
|
ratio = 1.0 * (cpu.cycles - previous_loop_cycles) / time_elapsed()
|
|
|
|
pygame.quit()
|