StudyBox host script
This script is from January 2022. IIRC, it was used for verifying hardware properties. Not sure if this script currently works.
This commit is contained in:
parent
7f21176c2f
commit
83894d3097
GPG Key ID:
70A1AB767AAB9C20
|
|
@ -0,0 +1,720 @@
|
|||
math.randomseed(os.time())
|
||||
|
||||
-- create the module's table
|
||||
local studybox = {}
|
||||
|
||||
-- import required modules
|
||||
local nes = require "scripts.app.nes"
|
||||
local dict = require "scripts.app.dict"
|
||||
local dump = require "scripts.app.dump"
|
||||
local flash = require "scripts.app.flash"
|
||||
local buffers = require "scripts.app.buffers"
|
||||
|
||||
-- file constants
|
||||
local mapname = "SBX"
|
||||
|
||||
-- local functions
|
||||
|
||||
local function create_header( file, prgKB, chrKB )
|
||||
|
||||
--write_header( file, prgKB, chrKB, mapper, mirroring )
|
||||
nes.write_header( file, prgKB, 0, op_buffer[mapname], 0)
|
||||
end
|
||||
|
||||
|
||||
--local function wr_flash_byte(addr, value, debug)
|
||||
|
||||
--base is the actual NES CPU address, not the rom offset (ie $FFF0, not $7FF0)
|
||||
--local function wr_bank_table(base, entries)
|
||||
--Action53 not susceptible to bus conflicts, no banktable needed
|
||||
|
||||
local function sb_write_string(start_addr, value, log)
|
||||
value = string.format("'%s' starting at $%04X", value, start_addr)
|
||||
print(string.format("Writing %s starting at address $%04X\n", value, start_addr))
|
||||
for i = 1, #value do
|
||||
local c = value:sub(i,i)
|
||||
dict.nes("NES_CPU_WR", start_addr + (i - 1), string.byte(c))
|
||||
end
|
||||
end
|
||||
|
||||
local function sb_write_and_verify(start_addr, stop_addr, value, log)
|
||||
log:write(string.format("Writing $%X from address $%X to $%X\n", value, start_addr, stop_addr))
|
||||
addr = start_addr
|
||||
while (addr < stop_addr) do
|
||||
dict.nes("NES_CPU_WR", addr, value)
|
||||
addr = addr + 1
|
||||
end
|
||||
|
||||
log:write("Verifying data\n")
|
||||
addr = start_addr
|
||||
while(addr < stop_addr) do
|
||||
rv = dict.nes("NES_CPU_RD", addr)
|
||||
if rv ~= value then
|
||||
log:write(string.format("$%X not $%X\n", addr, value))
|
||||
end
|
||||
addr = addr + 1
|
||||
end
|
||||
end
|
||||
|
||||
-- Write and verify random values in RAM
|
||||
local function sb_random_ram(start_addr, stop_addr, log)
|
||||
log:write(string.format("\nStarting random ram test from address $%04X to address $%04X\n", start_addr, stop_addr))
|
||||
values = {}
|
||||
for i = 0, (stop_addr - start_addr) do
|
||||
val = math.random(0, 255)
|
||||
values[i] = val
|
||||
dict.nes("NES_CPU_WR", start_addr + i, val)
|
||||
end
|
||||
|
||||
for i = 0, (stop_addr - start_addr) do
|
||||
rv = dict.nes("NES_CPU_RD", start_addr + i)
|
||||
if rv ~= values[i] then
|
||||
log:write(string.format("$%04X: expected $%02X received $%02X\n", start_addr + i, values[i], rv))
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
local function sb_write_ram(start_addr, stop_addr, value)
|
||||
print(string.format("Writing $%02X from $%04X to $%04X", value, start_addr, stop_addr))
|
||||
while (start_addr < stop_addr) do
|
||||
dict.nes("NES_CPU_WR", start_addr, value)
|
||||
start_addr = start_addr + 1
|
||||
end
|
||||
end
|
||||
|
||||
local function sb_verify_value_ram(start_addr, stop_addr, value, log)
|
||||
print(string.format("Verifying $%02X from $%04X to $%04X", value, start_addr, stop_addr))
|
||||
while (start_addr < stop_addr) do
|
||||
rv = dict.nes("NES_CPU_RD", start_addr)
|
||||
if rv ~= value then
|
||||
log:write(string.format("$%04X: expected $%02X received $%02X\n", start_addr, value, rv))
|
||||
end
|
||||
start_addr = start_addr + 1
|
||||
end
|
||||
end
|
||||
|
||||
local function sb_ram_dump(start_addr, stop_addr, filename)
|
||||
file = io.open(filename, "wb")
|
||||
while (start_addr < stop_addr) do
|
||||
rv = dict.nes("NES_CPU_RD", start_addr)
|
||||
file:write(string.char(rv))
|
||||
start_addr = start_addr + 1
|
||||
end
|
||||
|
||||
file:flush()
|
||||
file:close()
|
||||
end
|
||||
|
||||
-- Write data to ram and read it back
|
||||
local function sb_verify_ram()
|
||||
logfile = io.open("studybox.log", "w")
|
||||
print("Starting sb_verify_ram()")
|
||||
|
||||
--print("Write/Verify $00")
|
||||
--sb_write_and_verify(0x4020, 0x8000, 0x00, logfile)
|
||||
--print("Write/Verify $88")
|
||||
--sb_write_and_verify(0x4020, 0x8000, 0x88, logfile)
|
||||
--print("Write/Verify $FF")
|
||||
--sb_write_and_verify(0x4020, 0x8000, 0xFF, logfile)
|
||||
|
||||
--print("Write/Verify random")
|
||||
--sb_random_ram(0x4020, 0x8000, logfile)
|
||||
|
||||
-- Select first bank
|
||||
--sprint("\n$4200 value of $00")
|
||||
--dict.nes("NES_CPU_WR", 0x4200, 0x00)
|
||||
--val = math.random(0, 255)
|
||||
--sb_write_ram(0x5000, 0x5FFF, val)
|
||||
--sb_verify_value_ram(0x4400, 0x8000, val, logfile)
|
||||
|
||||
--sprint("\n$4200 value of $01")
|
||||
--sdict.nes("NES_CPU_WR", 0x4200, 0x01)
|
||||
--sval = math.random(0, 255)
|
||||
--ssb_write_ram(0x5000, 0x5FFF, val)
|
||||
--ssb_verify_value_ram(0x4400, 0x8000, val, logfile)
|
||||
|
||||
--sprint("\n$4200 value of $00 verify")
|
||||
--sdict.nes("NES_CPU_WR", 0x4200, 0x00)
|
||||
--ssb_verify_value_ram(0x4400, 0x5FFF, val, logfile)
|
||||
|
||||
--print("\n$4200 value of $00")
|
||||
--dict.nes("NES_CPU_WR", 0x4200, 0x00)
|
||||
--val = math.random(0, 255)
|
||||
--sb_write_ram(0x6000, 0x8000, val)
|
||||
--sb_verify_value_ram(0x6000, 0x8000, val, logfile)
|
||||
|
||||
--logfile:write("\n==== Second verify with $4200 value $40 ====\n")
|
||||
|
||||
--print("\n$4200 value of $40")
|
||||
--dict.nes("NES_CPU_WR", 0x4200, 0x40)
|
||||
--sb_verify_value_ram(0x6000, 0x8000, val, logfile)
|
||||
|
||||
print("Clearing ram")
|
||||
sb_write_ram(0x4400, 0x8000, 0x00)
|
||||
|
||||
--41 b01000001
|
||||
--82 b10000010
|
||||
--82 b11000011
|
||||
dict.nes("NES_CPU_WR", 0x4200, 0x41)
|
||||
sb_write_ram(0x4400, 0x8000, 0x00)
|
||||
dict.nes("NES_CPU_WR", 0x4200, 0x82)
|
||||
sb_write_ram(0x4400, 0x8000, 0x00)
|
||||
dict.nes("NES_CPU_WR", 0x4200, 0xC3)
|
||||
sb_write_ram(0x4400, 0x8000, 0x00)
|
||||
|
||||
|
||||
print("Writing strings")
|
||||
dict.nes("NES_CPU_WR", 0x4200, 0x00)
|
||||
sb_write_string(0x5400, "|< page $00 >|")
|
||||
sb_write_string(0x6000, "|< page $00 >|")
|
||||
|
||||
dict.nes("NES_CPU_WR", 0x4200, 0x41)
|
||||
sb_write_string(0x5000, "|< page $01 >|")
|
||||
sb_write_string(0x6000, "|< page $01 >|")
|
||||
|
||||
dict.nes("NES_CPU_WR", 0x4200, 0x82)
|
||||
sb_write_string(0x5000, "|< page $02 >|")
|
||||
sb_write_string(0x6000, "|< page $02 >|")
|
||||
|
||||
dict.nes("NES_CPU_WR", 0x4200, 0xC3)
|
||||
sb_write_string(0x5000, "|< page $03 >|")
|
||||
sb_write_string(0x6000, "|< page $03 >|")
|
||||
|
||||
--sb_write_string(0x5000, "|< page $00 at $5000 >|")
|
||||
|
||||
print("dumping 4200_00.dmp")
|
||||
dict.nes("NES_CPU_WR", 0x4200, 0x00)
|
||||
sb_ram_dump(0x4400, 0x8000, "4200_00.dmp")
|
||||
|
||||
print("dumping 4200_01.dmp")
|
||||
dict.nes("NES_CPU_WR", 0x4200, 0x01)
|
||||
sb_ram_dump(0x4400, 0x8000, "4200_01.dmp")
|
||||
|
||||
print("dumping 4200_01.dmp")
|
||||
dict.nes("NES_CPU_WR", 0x4200, 0x01)
|
||||
sb_ram_dump(0x4400, 0x8000, "4200_01.dmp")
|
||||
|
||||
--print("\n$4200 value of $01")
|
||||
--dict.nes("NES_CPU_WR", 0x4200, 0x01)
|
||||
--sb_ram_dump(0x4400, 0x8000, "4200_01.dmp")
|
||||
|
||||
--print("\n$4200 value of $02")
|
||||
--dict.nes("NES_CPU_WR", 0x4200, 0x02)
|
||||
--sb_ram_dump(0x4400, 0x8000, "4200_02.dmp")
|
||||
|
||||
--print("\n$4200 value of $03")
|
||||
--dict.nes("NES_CPU_WR", 0x4200, 0x03)
|
||||
--sb_ram_dump(0x4400, 0x8000, "4200_03.dmp")
|
||||
|
||||
--print("\n$4200 value of $40")
|
||||
--dict.nes("NES_CPU_WR", 0x4200, 0x40)
|
||||
--sb_ram_dump(0x4400, 0x8000, "4200_40.dmp")
|
||||
|
||||
--print("\n$4200 value of $80")
|
||||
--dict.nes("NES_CPU_WR", 0x4200, 0x80)
|
||||
--sb_ram_dump(0x4400, 0x8000, "4200_80.dmp")
|
||||
|
||||
--print("\n$4200 value of $C0")
|
||||
--dict.nes("NES_CPU_WR", 0x4200, 0x80)
|
||||
--sb_ram_dump(0x4400, 0x8000, "4200_C0.dmp")
|
||||
|
||||
logfile:flush()
|
||||
logfile:close()
|
||||
end
|
||||
|
||||
--initialize mapper for dump/flash routines
|
||||
local function init_mapper( debug )
|
||||
|
||||
--//Setup as CNROM, then scroll through outer banks.
|
||||
--cpu_wr(0x5000, 0x80); //reg select mode
|
||||
--dict.nes("NES_CPU_WR", 0x5000, 0x80)
|
||||
|
||||
--// xxSSPPMM SS-size: 0-32KB, PP-prg mode: 0,1 32KB, MM-mirror
|
||||
--cpu_wr(0x8000, 0b00000000); //reg value 256KB inner, 32KB banks
|
||||
--dict.nes("NES_CPU_WR", 0x8000, 0x00)
|
||||
--cpu_wr(0x5000, 0x81); //outer reg select mode
|
||||
--dict.nes("NES_CPU_WR", 0x5000, 0x81)
|
||||
--cpu_wr(0x8000, 0x00); //first 32KB bank
|
||||
--dict.nes("NES_CPU_WR", 0x8000, 0x00)
|
||||
--
|
||||
--cpu_wr(0x5000, 0x01); //inner prg reg select
|
||||
--dict.nes("NES_CPU_WR", 0x5000, 0x01)
|
||||
--cpu_wr(0x8000, 0x00); //controls nothing in this size
|
||||
--dict.nes("NES_CPU_WR", 0x8000, 0x00)
|
||||
--cpu_wr(0x5000, 0x00); //chr reg select
|
||||
--dict.nes("NES_CPU_WR", 0x5000, 0x00)
|
||||
--cpu_wr(0x8000, 0x00); //first chr bank
|
||||
--dict.nes("NES_CPU_WR", 0x8000, 0x00)
|
||||
--selecting CNROM means that mapper writes to $8000-FFFF will only change the CHR-RAM bank which
|
||||
--doesn't affect anything we're concerned about
|
||||
|
||||
end
|
||||
|
||||
local function sb_dump_rom()
|
||||
|
||||
file = io.open("prg.dat", "wb")
|
||||
for i = 0x00,0x0F,1 do
|
||||
print(string.format("$4201: %02X", i))
|
||||
dict.nes("NES_CPU_WR", 0x4201, i)
|
||||
start_addr = 0x8000
|
||||
stop_addr = 0xC000
|
||||
while (start_addr < stop_addr) do
|
||||
rv = dict.nes("NES_CPU_RD", start_addr)
|
||||
file:write(string.char(rv))
|
||||
start_addr = start_addr + 1
|
||||
end
|
||||
--sb_ram_dump(0x8000, 0xC000, string.format("raw/prg_8000_%02X.dat", i))
|
||||
end
|
||||
file:flush()
|
||||
file:close()
|
||||
|
||||
--dict.nes("NES_CPU_WR", 0x4201, 0x00)
|
||||
--sb_ram_dump(0x8000, 0xC000, "prg_8000_00.dat")
|
||||
--sb_ram_dump(0xC000, 0x10000, "prg_C000_00.dat")
|
||||
|
||||
--dict.nes("NES_CPU_WR", 0x4201, 0x01)
|
||||
--sb_ram_dump(0x8000, 0xC000, "prg_8000_01.dat")
|
||||
--sb_ram_dump(0xC000, 0x10000, "prg_C000_01.dat")
|
||||
|
||||
--dict.nes("NES_CPU_WR", 0x4201, 0x02)
|
||||
--sb_ram_dump(0x8000, 0xC000, "prg_8000_02.dat")
|
||||
--sb_ram_dump(0xC000, 0x10000, "prg_C000_02.dat")
|
||||
|
||||
--dict.nes("NES_CPU_WR", 0x4201, 0x03)
|
||||
--sb_ram_dump(0x8000, 0xC000, "prg_8000_03.dat")
|
||||
--sb_ram_dump(0xC000, 0x10000, "prg_C000_03.dat")
|
||||
end
|
||||
|
||||
local function sb_write_save()
|
||||
print("Clearing ram")
|
||||
dict.nes("NES_CPU_WR", 0x4200, 0x00)
|
||||
sb_write_ram(0x600, 0x8000, 0x00)
|
||||
sb_write_string(0x5400, "|< page $00 >|")
|
||||
sb_write_string(0x6000, "|< page $00 >|")
|
||||
end
|
||||
|
||||
local function sb_dump_save()
|
||||
print("Dumping ram")
|
||||
dict.nes("NES_CPU_WR", 0x4200, 0x00)
|
||||
sb_ram_dump(0x4400, 0x8000, "raw/ram.dat")
|
||||
end
|
||||
|
||||
local function sb_read_registers()
|
||||
data = dict.nes("NES_CPU_RD", 0x4202)
|
||||
print(string.format("$4202: $%02X", data))
|
||||
end
|
||||
|
||||
--read PRG-ROM flash ID
|
||||
local function prgrom_manf_id( debug )
|
||||
|
||||
init_mapper()
|
||||
|
||||
if debug then print("reading PRG-ROM manf ID") end
|
||||
--A0-A14 are all directly addressable in CNROM mode
|
||||
--and mapper writes don't affect PRG banking
|
||||
dict.nes("NES_CPU_WR", 0xD555, 0xAA)
|
||||
dict.nes("NES_CPU_WR", 0xAAAA, 0x55)
|
||||
dict.nes("NES_CPU_WR", 0xD555, 0x90)
|
||||
rv = dict.nes("NES_CPU_RD", 0x8000)
|
||||
if debug then print("attempted read PRG-ROM manf ID:", string.format("%X", rv)) end
|
||||
rv = dict.nes("NES_CPU_RD", 0x8001)
|
||||
if debug then print("attempted read PRG-ROM prod ID:", string.format("%X", rv)) end
|
||||
|
||||
--exit software
|
||||
dict.nes("NES_CPU_WR", 0x8000, 0xF0)
|
||||
|
||||
end
|
||||
|
||||
local function mirror_test( debug )
|
||||
init_mapper()
|
||||
|
||||
end
|
||||
|
||||
local function bank0(bank)
|
||||
dict.nes("NES_CPU_WR", 0x4201, bank)
|
||||
|
||||
print("selecting bank: ", bank)
|
||||
--rv = dict.nes("NES_CPU_RD", 0x8000)
|
||||
--if debug then print("attempted read PRG-ROM $8000:", string.format("%X", rv)) end
|
||||
--rv = dict.nes("NES_CPU_RD", 0x8001)
|
||||
--if debug then print("attempted read PRG-ROM $8001:", string.format("%X", rv)) end
|
||||
end
|
||||
|
||||
local function sb_write_ppu_string(start_addr, value)
|
||||
value = string.format("'%s' starting at $%04X", value, start_addr)
|
||||
print(string.format("Writing %s starting at address $%04X\n", value, start_addr))
|
||||
for i = 1, #value do
|
||||
local c = value:sub(i,i)
|
||||
dict.nes("NES_PPU_WR", start_addr + (i - 1), string.byte(c))
|
||||
end
|
||||
end
|
||||
|
||||
local function sb_ppu_test()
|
||||
dict.nes("NES_CPU_WR", 0x4200, 0x00)
|
||||
dict.nes("NES_CPU_WR", 0x4201, 0x00)
|
||||
dict.nes("NES_CPU_WR", 0x4203, 0x00)
|
||||
print("Clearing ppu ram")
|
||||
for i=0x0000,0x2FFF,1 do
|
||||
dict.nes("NES_PPU_WR", i, 0x00)
|
||||
end
|
||||
|
||||
sb_write_ppu_string(0x0000, "|< chr page $00 >|")
|
||||
|
||||
print("Writing nametable 1")
|
||||
for i=0x2000,0x23FF,1 do
|
||||
dict.nes("NES_PPU_WR", i, 0x01)
|
||||
end
|
||||
|
||||
print("Writing nametable 2")
|
||||
for i=0x2400,0x27FF,1 do
|
||||
dict.nes("NES_PPU_WR", i, 0x02)
|
||||
end
|
||||
|
||||
print("Writing nametable 3")
|
||||
for i=0x2800,0x2BFF,1 do
|
||||
dict.nes("NES_PPU_WR", i, 0x03)
|
||||
end
|
||||
|
||||
print("Writing nametable 4")
|
||||
for i=0x2C00,0x2FFF,1 do
|
||||
dict.nes("NES_PPU_WR", i, 0x04)
|
||||
end
|
||||
|
||||
print("dumping ppu ram")
|
||||
dict.nes("NES_CPU_WR", 0x4200, 0xFF)
|
||||
dict.nes("NES_CPU_WR", 0x4201, 0xFF)
|
||||
dict.nes("NES_CPU_WR", 0x4203, 0xFF)
|
||||
file = io.open("raw/ppu.dat", "wb")
|
||||
for i=0x0000,0x2FFF,1 do
|
||||
val = dict.nes("NES_PPU_RD", i)
|
||||
file:write(string.char(val))
|
||||
end
|
||||
file:flush()
|
||||
file:close()
|
||||
end
|
||||
|
||||
local function sb_ppu_high_ram_test()
|
||||
|
||||
print("Testing PPU RAM $3000-$3FFF")
|
||||
file = io.open("raw/ppu_high_init.dmp", "wb")
|
||||
for i=0x3000,0x3FFF,1 do
|
||||
val = dict.nes("NES_PPU_RD", i)
|
||||
file:write(string.char(val))
|
||||
end
|
||||
file:flush()
|
||||
file:close()
|
||||
|
||||
print("writing $B1")
|
||||
for i=0x3000,0x3FFF,1 do
|
||||
dict.nes("NES_PPU_WR", i, 0xB1)
|
||||
end
|
||||
|
||||
print("dump 2")
|
||||
file = io.open("raw/ppu_high_post.dmp", "wb")
|
||||
for i=0x3000,0x3FFF,1 do
|
||||
val = dict.nes("NES_PPU_RD", i)
|
||||
file:write(string.char(val))
|
||||
end
|
||||
file:flush()
|
||||
file:close()
|
||||
|
||||
print("dump ppu main")
|
||||
file = io.open("raw/ppu_main.dmp", "wb")
|
||||
for i=0x0000,0x2FFF,1 do
|
||||
val = dict.nes("NES_PPU_RD", i)
|
||||
file:write(string.char(val))
|
||||
end
|
||||
file:flush()
|
||||
file:close()
|
||||
|
||||
end
|
||||
|
||||
-- Test CPU vs PPU ram
|
||||
local function sb_ram_full_test()
|
||||
--print("Clearing ram")
|
||||
--sb_write_ram(0x4400, 0x8000, 0x00)
|
||||
|
||||
--dict.nes("NES_CPU_WR", 0x4200, 0x41)
|
||||
--sb_write_ram(0x4400, 0x8000, 0x00)
|
||||
--dict.nes("NES_CPU_WR", 0x4200, 0x82)
|
||||
--sb_write_ram(0x4400, 0x8000, 0x00)
|
||||
--dict.nes("NES_CPU_WR", 0x4200, 0xC3)
|
||||
--sb_write_ram(0x4400, 0x8000, 0x00)
|
||||
|
||||
--dict.nes("NES_CPU_WR", 0x4200, 0x00)
|
||||
--dict.nes("NES_CPU_WR", 0x4201, 0x00)
|
||||
--dict.nes("NES_CPU_WR", 0x4203, 0x00)
|
||||
--print("Clearing ppu ram")
|
||||
--for i=0x0000,0x2FFF,1 do
|
||||
-- dict.nes("NES_PPU_WR", i, 0x00)
|
||||
--end
|
||||
|
||||
print("Writing values")
|
||||
-- Only using 0x6000-0x7FFF here because it's
|
||||
-- the same memory as the first block
|
||||
dict.nes("NES_CPU_WR", 0x4200, 0x00)
|
||||
sb_write_ram(0x6000, 0x7FFF, 01)
|
||||
|
||||
dict.nes("NES_CPU_WR", 0x4200, 0x40)
|
||||
sb_write_ram(0x6000, 0x7FFF, 02)
|
||||
|
||||
dict.nes("NES_CPU_WR", 0x4200, 0x80)
|
||||
sb_write_ram(0x6000, 0x7FFF, 03)
|
||||
|
||||
dict.nes("NES_CPU_WR", 0x4200, 0xC0)
|
||||
sb_write_ram(0x6000, 0x7FFF, 04)
|
||||
|
||||
--print("Clearing ppu ram")
|
||||
--for i=0x0000,0x2FFF,1 do
|
||||
-- dict.nes("NES_PPU_WR", i, 0x00)
|
||||
--end
|
||||
|
||||
-- print("Writing values")
|
||||
|
||||
print("Writing nametable 1")
|
||||
for i=0x2000,0x23FF,1 do
|
||||
dict.nes("NES_PPU_WR", i, 0xA1)
|
||||
end
|
||||
|
||||
print("Writing nametable 2")
|
||||
for i=0x2400,0x27FF,1 do
|
||||
dict.nes("NES_PPU_WR", i, 0xA2)
|
||||
end
|
||||
|
||||
print("Writing nametable 3")
|
||||
for i=0x2800,0x2BFF,1 do
|
||||
dict.nes("NES_PPU_WR", i, 0xA3)
|
||||
end
|
||||
|
||||
print("Writing nametable 4")
|
||||
for i=0x2C00,0x2FFF,1 do
|
||||
dict.nes("NES_PPU_WR", i, 0xA4)
|
||||
end
|
||||
|
||||
print("writing CHR at 0x0000")
|
||||
for i=0x0000,0x0FFF,1 do
|
||||
dict.nes("NES_PPU_WR", i, 0xA5)
|
||||
end
|
||||
print("writing CHR at 0x1000")
|
||||
for i=0x1000,0x1FFF,1 do
|
||||
dict.nes("NES_PPU_WR", i, 0xA6)
|
||||
end
|
||||
|
||||
print("dumping ppu ram")
|
||||
--dict.nes("NES_CPU_WR", 0x4200, 0xFF)
|
||||
--dict.nes("NES_CPU_WR", 0x4201, 0xFF)
|
||||
--dict.nes("NES_CPU_WR", 0x4203, 0xFF)
|
||||
file = io.open("raw/cpu-ppu.dmp", "wb")
|
||||
for i=0x0000,0x2FFF,1 do
|
||||
val = dict.nes("NES_PPU_RD", i)
|
||||
file:write(string.char(val))
|
||||
end
|
||||
file:flush()
|
||||
file:close()
|
||||
|
||||
print("dumping 4200_00.dmp")
|
||||
dict.nes("NES_CPU_WR", 0x4200, 0x00)
|
||||
sb_ram_dump(0x6000, 0x7FFF, "raw/ppu-cpu_4200_00.dmp")
|
||||
|
||||
print("dumping 4200_40.dmp")
|
||||
dict.nes("NES_CPU_WR", 0x4200, 0x40)
|
||||
sb_ram_dump(0x6000, 0x7FFF, "raw/ppu-cpu_4200_40.dmp")
|
||||
|
||||
print("dumping 4200_80.dmp")
|
||||
dict.nes("NES_CPU_WR", 0x4200, 0x80)
|
||||
sb_ram_dump(0x6000, 0x7FFF, "raw/ppu-cpu_4200_80.dmp")
|
||||
|
||||
print("dumping 4200_C0.dmp")
|
||||
dict.nes("NES_CPU_WR", 0x4200, 0xC0)
|
||||
sb_ram_dump(0x6000, 0x7FFF, "raw/ppu-cpu_4200_C0.dmp")
|
||||
end
|
||||
|
||||
local function check_ppu_mirror(a, b)
|
||||
vala = dict.nes("NES_PPU_RD", 0x2800)
|
||||
valb = dict.nes("NES_PPU_RD", 0x2C00)
|
||||
if vala ~= a then
|
||||
print(string.format("value at $2000 changed to %02X! [%02X]", vala, i & 0x3C))
|
||||
end
|
||||
if valb ~= b then
|
||||
print(string.format("value at $2400 changed to %02X! [%02X]", valb, i & 0x3C))
|
||||
end
|
||||
end
|
||||
|
||||
local function sb_mirror_test()
|
||||
dict.nes("NES_PPU_WR", 0x2800, 0xA1)
|
||||
dict.nes("NES_PPU_WR", 0x2C00, 0xA2)
|
||||
|
||||
print("checking $4200")
|
||||
for i=0xC4,0xFF,4 do
|
||||
--print(string.format(" %02X", i))
|
||||
dict.nes("NES_CPU_WR", 0x4200, i)
|
||||
vala = dict.nes("NES_PPU_RD", 0x2800)
|
||||
valb = dict.nes("NES_PPU_RD", 0x2C00)
|
||||
if vala ~= 0xA1 then
|
||||
print(string.format("value at $2000 changed to %02X! [%02X]", vala, i & 0x3C))
|
||||
end
|
||||
if valb ~= 0xA2 then
|
||||
print(string.format("value at $2400 changed to %02X! [%02X]", valb, i & 0x3C))
|
||||
end
|
||||
end
|
||||
|
||||
print("checking $4201")
|
||||
for i=0x00,0xF0,0x10 do
|
||||
--print(string.format(" %02X", i))
|
||||
dict.nes("NES_CPU_WR", 0x4201, i)
|
||||
vala = dict.nes("NES_PPU_RD", 0x2800)
|
||||
valb = dict.nes("NES_PPU_RD", 0x2C00)
|
||||
if vala ~= 0xA1 then
|
||||
print(string.format("value at $2000 changed to %02X! [%02X]", vala, i & 0x3C))
|
||||
end
|
||||
if valb ~= 0xA2 then
|
||||
print(string.format("value at $2400 changed to %02X! [%02X]", valb, i & 0x3C))
|
||||
end
|
||||
end
|
||||
|
||||
print("checking $4202")
|
||||
dict.nes("NES_CPU_WR", 0x4202, 0x40)
|
||||
check_ppu_mirror(0xA1, 0xA2)
|
||||
dict.nes("NES_CPU_WR", 0x4202, 0x08)
|
||||
check_ppu_mirror(0xA1, 0xA2)
|
||||
|
||||
print("checking $4203")
|
||||
for i=0x00,0xFF,0x01 do
|
||||
--print(string.format(" %02X", i))
|
||||
dict.nes("NES_CPU_WR", 0x4203, i)
|
||||
vala = dict.nes("NES_PPU_RD", 0x2800)
|
||||
valb = dict.nes("NES_PPU_RD", 0x2C00)
|
||||
if vala ~= 0xA1 then
|
||||
print(string.format("value at $2000 changed to %02X! [%02X]", vala, i & 0x3C))
|
||||
end
|
||||
if valb ~= 0xA2 then
|
||||
print(string.format("value at $2400 changed to %02X! [%02X]", valb, i & 0x3C))
|
||||
end
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
--Cart should be in reset state upon calling this function
|
||||
--this function processes all user requests for this specific board/mapper
|
||||
local function process(process_opts, console_opts)
|
||||
local test = process_opts["test"]
|
||||
local read = process_opts["read"]
|
||||
local erase = process_opts["erase"]
|
||||
local program = process_opts["program"]
|
||||
local verify = process_opts["verify"]
|
||||
local dumpfile = process_opts["dump_filename"]
|
||||
local flashfile = process_opts["flash_filename"]
|
||||
local verifyfile = process_opts["verify_filename"]
|
||||
|
||||
local rv = nil
|
||||
local file
|
||||
local prg_size = console_opts["prg_rom_size_kb"]
|
||||
local chr_size = console_opts["chr_rom_size_kb"]
|
||||
local wram_size = console_opts["wram_size_kb"]
|
||||
|
||||
--initialize device i/o for NES
|
||||
dict.io("IO_RESET")
|
||||
dict.io("NES_INIT")
|
||||
|
||||
mirror_test(true)
|
||||
|
||||
--test cart by reading manf/prod ID
|
||||
if test then
|
||||
prgrom_manf_id(true)
|
||||
end
|
||||
|
||||
--sb_verify_ram()
|
||||
--sb_read_registers()
|
||||
--sb_dump_rom()
|
||||
--sb_write_save()
|
||||
--sb_dump_save()
|
||||
--sb_ppu_test()
|
||||
--sb_ram_full_test()
|
||||
--sb_ppu_high_ram_test()
|
||||
sb_mirror_test()
|
||||
dict.io("IO_RESET")
|
||||
do return end
|
||||
|
||||
-- Poke some registers
|
||||
init_mapper(debug)
|
||||
dict.nes("NES_CPU_WR", 0x4202, 0x20)
|
||||
--for i=0, 8, 1 do
|
||||
-- dict.nes("NES_CPU_WR", 0x4202, 0x10)
|
||||
|
||||
-- rv = dict.nes("NES_CPU_RD", 0x4201)
|
||||
-- print(i, "initial read:", string.format("$%02X", rv))
|
||||
-- while (rv & 0x40 == 0) do
|
||||
-- rv = dict.nes("NES_CPU_RD", 0x4201)
|
||||
-- io.write(".")
|
||||
-- end
|
||||
-- print("")
|
||||
--end
|
||||
|
||||
--dump the cart to dumpfile
|
||||
read = false
|
||||
if read then
|
||||
print("Attempting to read StudyBox stuff")
|
||||
--initialize the mapper for dumping
|
||||
init_mapper(debug)
|
||||
|
||||
rv = dict.nes("NES_CPU_RD", 0x4200)
|
||||
print("$4200:", string.format("$%X", rv))
|
||||
rv = dict.nes("NES_CPU_RD", 0x4201)
|
||||
print("$4201:", string.format("$%X", rv))
|
||||
rv = dict.nes("NES_CPU_RD", 0x4202)
|
||||
print("$4202:", string.format("$%X", rv))
|
||||
rv = dict.nes("NES_CPU_RD", 0x4203)
|
||||
print("$4203:", string.format("$%X", rv))
|
||||
|
||||
file = assert(io.open(dumpfile, "wb"))
|
||||
|
||||
--create header: pass open & empty file & rom sizes
|
||||
--create_header(file, prg_size, chr_size)
|
||||
|
||||
for bank=0, 16, 1 do
|
||||
dict.nes("NES_CPU_WR", 0x4201, bank)
|
||||
|
||||
print("dumping bank: ", bank)
|
||||
rv = dict.nes("NES_CPU_RD", 0x4201)
|
||||
print("$4201:", string.format("$%X", rv))
|
||||
--dump cart into file
|
||||
dump.dumptofile( file, prg_size, "186", "PRGROM", true )
|
||||
end
|
||||
|
||||
--close file
|
||||
assert(file:close())
|
||||
end
|
||||
|
||||
|
||||
--verify flashfile is on the cart
|
||||
verify = false
|
||||
if verify then
|
||||
--for now let's just dump the file and verify manually
|
||||
|
||||
--initialize the mapper for dumping
|
||||
init_mapper(debug)
|
||||
|
||||
file = assert(io.open(verifyfile, "wb"))
|
||||
|
||||
--dump cart into file
|
||||
dump.dumptofile( file, 512, "A53", "PRGROM", true )
|
||||
|
||||
--close file
|
||||
assert(file:close())
|
||||
end
|
||||
|
||||
dict.io("IO_RESET")
|
||||
end
|
||||
|
||||
|
||||
-- global variables so other modules can use them
|
||||
|
||||
|
||||
-- call functions desired to run when script is called/imported
|
||||
|
||||
|
||||
-- functions other modules are able to call
|
||||
studybox.process = process
|
||||
|
||||
-- return the module's table
|
||||
return studybox
|
||||
Loading…
Reference in New Issue