6502 Assembly Language Math Lab

Purpose of this Lab
In this lab, you will write code with arithmetic/math in 6502 assembly language, in preparation for learning more complex x86_64 and AArch64 assembly language.

Resources

• 6502
• 6502 Emulator
• 6502 Emulator Example Code - Specifically:
  • Place a Graphic on the Screen - for an example of defining a graphic using DCB, and copying a graphic to the screen
  • Etch-a-Sketch Style Drawing - for an example of converting (ROW,COL) co-ordinates to a screen address, and reading the keyboard
• Opcode/Instruction References
  • 6502 Opcodes with Register Definitions
  • 6502 Opcodes with Detailed Operation Information

Techniques

• Bouncing Object
  • To bounce an object around the screen:
    • Use two variables for deltaX and deltaY values -- the amount that the object will move in each direction for each update. Add these values to the X,Y position of the object on the screen each time you update the position.
      • These values can simply be -1 or +1 if the object is going to bounce at 45-degree angles.
      • These values will need to include a fractional component for angles other than 45 degrees. This can be handled by using two bytes for each element of the X,Y position and for the deltaX and deltaY values, where one byte represents the integer portion and one byte represents the fractional portion (fixed-point representation).
  • Detect when the object has collided with the edge of the screen or other objects, and reverse the sign of the deltaX or deltaY value (or both). For example, when bouncing off the top of the display, set deltaX = -deltaX

• Keyboard
  • The last key pressed is stored in memory location $FF. Clear this location (to 0) after reading it. Printable characters, ENTER, and Backspace are represented by their ASCII codes; the arrow keys are represented by the codes $80-$83 (up/right/down/left).

• Random number generator
  • A random byte is available at memory location $FE.

• Drawing a Line
  • To draw a line between two arbitrary points (X₁,Y₁)(X₂,Y_{2</sub) where X2-X1 > Y2-Y1 and all coordinates are positive, calculate the rise/run, then set Y=Y1 and iterate for X=X1:X2 incrementing Y by the rise/run each step.}
  • Use fixed-point math for the rise/run (aka deltaY) value.

Lab 2

Setup

1. Organize a group of 4-6 students around one of the monitor/whiteboard groups in the classroom. Arrange the furniture so that everyone has a comfortable view of the display.

2. Gather these supplies:

• HDMI cable
• Whiteboard markers

3. Select one person to be the "Driver", who will type/operate the computer for the group. That person should connect a device (laptop, table) to the HDMI display and open the 6502 Emulator at [1] as well as this Lab page. It's a good idea to ensure that the Speed slider on the emulator is at its lowest setting (left) and that the Text Screen is turned off (unchecked).

Sharing Results
Decide how group results will be shared between the members of the group. (Suggestion: consider using a git repository).

Save Your Work
The emulator does not save your work. Remember to periodically save it to a file (copy-and-paste the code).

Pick an Option

4. Select and complete one of these options for this lab:

Option I: Bouncing Graphic

1. Create a simple graphic in a square that is 5x5 or 7x7 pixels in size. Use the colours available in the emulator's bitmapped display. The graphic could be a ball, a happy face, a logo, an emoji, or anything else (appropriate!) that you want to use.
2. Encode that graphic in bytes using DCB (declare constant byte) instructions.
3. Write code to make the graphic bounce around the screen, reflecting off the edges when it hits. Note: for simplicity, it is OK if the object always bounces at 45-degree angles.
4. Make the speed keyboard-adjustable (faster/slower) and perturb the object's path once in a while.

Challenge: randomize the starting position, and make the object bounce at angles other than 45 degrees.

Option 2: Numeric Display

1. Create or find (under an appropriate license) the bitmapped font patterns for the digits 0-9 on an 8x8 pixel matrix.
2. Encode the font patterns for these characters using DCB (declare constant byte) instructions.
3. Write code to display a 2-digit unsigned decimal number (0-99). The + and - keys should increment and decrement this number.

Challenge: extend the code to suppress leading zeros and display a signed number (-99 to +99).

Option 3: Pong

1. Create a single-user version of the classic Pong game: one paddle, controlled by the keyboard, and one single-pixel ball that bounces off the paddle plus the three sides of the screen not guarded by the paddle. The game is over if the ball hits the fourth side of the screen.

Challenge: extend the code to play a game similar to Breakout.

Option 4: Kaleidoscope

1. Create code that permits the user to draw pixels on one-quarter of the screen in any of several different colours (for example, the user might position a cursor with the arrow keys and colour a pixel with the a digit from 0-9 which would select the colour for that pixel).
2. Mirror the pixel to the other three quadrants of the screen like a kaleidoscope. For example, a pixel drawn at (0,0) should be mirrored to (31,31), (0,31), and (31,0); if a pixel is drawn at (2,10) is should be mirrored to (29,10), (2,21), and (29,21)

Challenge: replay the drawing of the image, i.e., when a key is pressed, the screen is cleared and the pixels are redrawn to the screen in the order in which they were originally added by the user, with the kaleidoscope effect, as an animation.

Option 5: Line draw

Division
This option may be harder than the others and typically requires division arithmetic!

1. Create code that has two pixel-sized cursors, moved by two separate sets of keys (e.g., cursor keys for one cursor, and a/w/s/z for the other cursor).
2. Draw a line between the cursors which moves whenever one of the cursors is moved.

Challenge: extend the code to allow a line to be dropped onto the screen, i.e., it will be left behind while the cursors are moved to new locations.

Write-Up

Post an entry on your blog describing your experiments in this lab. Include:

1. An introduction, so that someone who happens across your blog will understand the context of what you're writing about.
2. The results from the two Writing Code portions of the lab, including the code, a description of how the code works, and the results produced. Credit other sources appropriately (i.e., font/graphics data, code snippets) and ensure that you are in compliance with the licenses of any code snippets used.
3. Your experiences with this lab -- your impressions of the Assembly Language, what you learned, and your reflections of the process.

Remember to follow the Blog Guidelines as you write.