Saturday, July 23, 2016

Displaying the 6502 MPU Register States


Displaying the 6502 MPU Register States

Moving slowly along in the summer of coding project, an emulated 6502 MPU written in the Python 3.5 scripting language. As the project is taking shape, I am moving some cleaned up scripts into libraries. One great convenience I have found in this project is the overGrive for Raspberry Pi systems. This software sets up a Google Drive on your Raspberry Pi desktop. I found this to be advantageous since I can code anywhere on any platform I have Internet connectivity and Google Drive access. On the ride into the city of San Francisco I can code on my old iPad 2, using the amazing Pythonista, or at home on my mac or my  Raspberry Pi. My goal is to write platform independent code for the 6502 MPU emulator software. On my Raspberry Pi desktop, the Google Drive appears as a folder and is accessible as a folder.

Python Source Directory on Google Drive





That's pretty much how I setup my development sandbox. I tend to spend a lot of time on the iPad 2, coding in Pythonista, which is great. I am BETA testing the Python 3.5 release for that now. The big hangup is that the iPad is clunky for coding. But when you're mobile and you need to code that's perfect. The source code on Google Drive has allowed me to code essentially everywhere I have network connectivity. For the Raspberry Pi it's been a huge bonus. The only downfall to the OverGrive is that it seems to take minutes to automatically update where Google Drive on the Mac and iPad are seemingly instantaneous. But we're all in the development stages in all of this stuff. So I hope this gets resolved soon on the Raspberry Pi OverGrive release.

Now to the current task at hand. Last entry, Software Emulating the 6502 Status Register, I explained the Python code I implemented to toggle the bits in the Processor Status Register. This is essentially an 8-bit register that contains 7 individual binary flags on operation states of the 6502 register. With the bits toggling I needed to write some code to display the individual bits for debug purposes. And from that effort I found myself writing the code to display the current values in all the registers of the 6502 MPU. This was another crucial tool needed in developing the Machine Language monitor and displaying the register contents at every cycle step for debugging purposes. So here goes. Let's take a look at the Processor Status Register (commonly referred to as the SR, and sometimes called the P register) tool for displaying the state of this register.

Displaying the SR State

In other Python 6502 emulators, I have seen developers choose to create individual flags for all 7 states (see my last article,  Software Emulating the 6502 Status Register). I choose to keep the SR register as designed and just toggle bits in the register, just like the real McCoy. A quick refresher from last time, I can set, get, and clear bits in the Sr.


>>> bin (get_Processor_Status_Bits())
'0b110000'
>>>

What I need for the machine language monitor is a formatted output to tell me what flags are being set. This is the formatted processor output tool I developed.


>>> print( get_Format_Processor_Status_Bits_Output() )
NV-BDIZC
00110000
>>>

What was initially a headache and failure of testing various snippets, the code actually emerged as a simple few lines of code. There are more comments then lines of code.


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# function: get_format_processor_status_bits_output
#
# Retrieves the current flags in the processor
# status register and returns binary flags of
# the current bits set as STRING for
# formatted output to console.
#
# Arguments: none
#
# Returns: String
#
# Example Usage:
#
# >>> print( get_Format_Processor_Status_Bits_Output() )
# NV-BDIZC
# 00110000
# >>> 
#
def get_Format_Processor_Status_Bits_Output():
    
    # get the processor status register bits
    sr_bits = get_Processor_Status_Bits()
    return ("NV-BDIZC\n%s" % format(sr_bits,'08b') )

Note: the Python format command, with argument '08b' passed in strips the "0b" from the Python string, so all we see are the bits. This is the magic helper of this operation. The results are the bits are perfectly aligned to their corresponding bit flags. Now with this little confidence builder, I moved on to tackle a similar problem, but display the status of all the registers. This would come in handy as the machine language monitor takes shape and we start stepping through machine code instructions.

Displaying the 6502 Current Register States

Interesting enough, to this point I haven't really coded any of the registers (except for the SR) for the 6502 emulator. I have been writing a lot of preparatory source code. The time has come for adding the general purpose registers.

The 6502 MPU Registers

As I developed this code, I completely have the future goal in mind of writing the ML monitor as well. I found a nice formatted output from a classic book, Machine Language for Beginners, at the Atari Archive site. This is an online copy of the classic book. I think I still have a copy in storage at my parents house.  Anyhow, my vision for formatted output comes from this book.

Program 4-1. Current Status Of The Registers.

  PC  IRQ  SR AC XR YR SP
 0005 E455 30 00 5E 04 F8

What evolved in my code, is this formatted output from that example. I initialized my emulated registers with the same values, since they weren't really doing anything yet.


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
#--------------------------------------------------------#
#                    6502 MPU Registers                  #
#--------------------------------------------------------#

# notes: http://www.atariarchives.org/mlb/chapter4.php
#
#
#  PC  IRQ  SR AC XR YR SP
# 0005 E455 30 00 5E 04 F8
#

AC = 0x0      # Accumulator         8-bt
XR = 0x5E     # X index register    8-bit
YR = 0X04     # Y index register    8-bit
SP = 0XF8     # Stack Pointer       8-bit
IRQ = 0xE455  # Interrupt Request  16-bit

Now I have something to display with my register state code. With Python, the formatted output code for this is fairly straight forward and very simple.


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# function: format_Register_States_Output()
#
# Display the 6502 MPU register states.
# The desired output is modelled after the machine
# language output display for found in the book,
# Machine Language for Beginners.
# http://www.atariarchives.org/mlb/chapter4.php
# Program 4-1. Current Status of the Registers
#
#  PC  IRQ  SR AC XR YR SP
# 0005 E455 30 00 5E 04 F8
#
# Arguments: none
#
# Returns: formatted string  - displays the 6502 MPU register states
#
def format_Register_States_Output():
    global AC, XR,YR, SP, PC, IRQ

    # get the processor status register bits
    sr_bits = get_Processor_Status_Bits()

    return ("PC   IRQ  AC XR YR SP SR NV-BDIZC\n%04x %04x %02x %02x %02x %02x %02x %s") % (PC, IRQ, AC, XR, YR, SP, sr_bits, format(sr_bits,'08b'))

This is still a lot of dirty code on the workbench I want to clean up. But you're starting to get the idea of where I am going with this code. This function provides us with the following output.


>>> print(format_Register_States_Output())
PC   IRQ  AC XR YR SP SR NV-BDIZC
008d e455 00 5e 04 f8 30 00110000
>>>

Sample Output on Raspberry Pi Python 3.4.2 Console

Which is the beginnings of a dev tool to implement in a machine language monitor. We can use this function to step through each cycle in the emulated 6502 MPU.

Were slowly making progress. But that's what is on my Raspberry Pi workbench and development IDE for Saturday July 23, 2016. As the code starts to take shape further I will move this out to a github repository. The DIY Atari and NES Hacking Emulator are becoming more of a reality now. Until next time... Happy Hacking!



Posted by at
Labels: , , , , , , ,

No comments:

Post a Comment

Subscribe to: Post Comments (Atom)