Chris Tyler's Wiki

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
======  6502 Program Lab  ======

In this lab, you will write code with arithmetic/math and strings in [[6502]] assembly language, including text output, graphical output, and keyboard input, in preparation for learning more complex x86_64 and AArch64 assembly language.

=====  Resources  =====
  *  [[6502]]
  *  [[6502 Emulator]]
  *  [[6502 Math]]
  *  [[6502 Jumps, Branches, and Procedures]]
  *  [[6502 Emulator Example Code]] - Specifically:
    *  [[6502_Emulator_Example_Code#Place_a_Graphic_on_the_Screen|Place a Graphic on the Screen]] - for an example of defining a graphic using DCB, and copying a graphic to the screen
    *  [[6502_Emulator_Example_Code#Etch-a-Sketchtm_Style_Drawing|Etch-a-Sketch Style Drawing]] - for an example of converting (ROW,COL) co-ordinates to a screen address, and reading the keyboard
  *  [[https://github.com/ctyler/6502js-code/|6502js-code]] repo on GitHub - Specifically:
    *  Wordle-like example (wordle-6502)
  *  Opcode/Instruction References
    *  [[http://www.6502.org/tutorials/6502opcodes.html|6502 Opcodes with Register Definitions]] at 6502.org
    *  [[https://www.masswerk.at/6502/6502_instruction_set.html|6502 Opcodes with Detailed Operation Information]] at Masswerk
    * [[https://www.pagetable.com/c64ref/6502/?tab=2|6502 Instructions]] organized differently on the Ultimate Commodore 64 Reference site
===== Tips and Techniques =====

  *  Keyboard
    *  Access the keyboard using the CHRIN [[6502_Emulator#ROM_Routines|ROM routine]].

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

  *  Drawing a Line
    *  To draw a line between two arbitrary points (X<sub>1</sub>,Y<sub>1</sub>)(X<sub>2</sub>,Y<sub>2</sub>) where X<sub>2</sub>-X<sub>1</sub> > Y<sub>2</sub>-Y<sub>1</sub> and all coordinates are positive, calculate the rise/run, then set Y=Y<sub>1</sub> and iterate for X=X<sub>1</sub>>X<sub>2</sub> incrementing Y by the rise/run each step.
    *  Do something similar with run/rise where X<sub>2</sub>-X<sub>1</sub> < Y<sub>2</sub>-Y<sub>1</sub>
    *  Suggestion: Use fixed-point math for the rise/run (aka deltaY) value. 16-bit values with the radix point between the bytes is a good option.

=====  Lab 3  =====

====  Decide What to Write  ====

For this lab, write a program that meets these criteria:
  -  Your program must work in the [[6502 Emulator]]
  -  You must output to the character screen as well as the graphics (bitmapped) screen.
  -  You must accept user input from the keyboard in some form.
  -  You must use some arithmetic/math instructions (to add, subtract, do bitwise operations, or rotate/shift)

For example, you could write a simple game:
  *  [[https://en.wikipedia.org/wiki/Pong|Pong]]
  *  [[https://en.wikipedia.org/wiki/Breakout_(video_game)|Breakout]]
  *  [[https://en.wikipedia.org/wiki/Mastermind_(board_game)|Mastermind]]
  *  [[https://en.wikipedia.org/wiki/Hangman_(game)|Hangman]]
  *  A drawing program
  *  A maze
  *  A number guessing game (try to guess a random number in the shortest number of tries, getting feedback of "too high" or "too low" for each wrong guess)
  *  Or any other type of game...

Or a calculator/converter:
  *  An adding or subtracting calculator
  *  A decimal-to-binary or hexidecimal-to-decimal converter
  *  A inches-and-feet to centimeter converter
  *  A [[https://en.wikipedia.org/wiki/Electronic_color_code|resistor colour band]] calculator
  *  A program to draw bar or line graphs based on user input
  *  Or any other type of calculator or converter...

**Or anything else that meets the criteria above**

You can interact with the user using either display. For example:
  *  The main interaction could be on the graphical display, and instructions could be printed on the text display (which keys to use to move, for example); or
  *  The main interaction could be on the text display, and an appropriate pattern could be shown on the bitmap display (for example, a version of hangman could display the words on the text display and the victim on the bitmapped display, or a calculator could use the text display for input and show a binary representation or a colour code on the graphical display (such as green for positive numbers, yellow for negative numbers, red for bad input)).

**Tip:** Keep it really simple! Assembly language is hard. Start simple, you can always add features later.

====  Write it!  ====

Write the code for your selected program in the [[6502 Emulator]].

It can be helpful and fun to write this code with one or two other people in a live session. Acknowledge each person's input, and add your own customizations or tweaks.

**Remember to save your work periodically**, either by pasting the text into a file, or using the Save button. Tip: the Save/Load/Chose File buttons work really well with a directory that is managed by Git.

** Acknowledge Other's Code ** - Feel free to incorporate other people's code into your program __with their permission__, but you **must** __acknowledge the source of any incorporated code__ (include a link to the source(s)), identify __how you attained permission__ to use the code (for example, if the code is distributed under an open source license, show which license applies) and __clearly identify exactly which lines of the code you wrote__ (recommendation: colour-code your portion in the blog post). **Do not** in any circumstances remove attribution, copyright, or license messages from the borrowed code.

**__Important__: Failure to fully comply with the terms under which others have shared code with you, failure to fully acknowledge the source and license terms of all code which you incorporate from other sources, or failure to accurately identify exactly which portions of the code were written by you will be considered a violation of Seneca's [[https://www.senecapolytechnic.ca/about/policies/academic-integrity-policy.html|Academic Integrity Policy]].**

** You must write __at least half (50%) of the code__ in this lab, counted by lines of code. ** Do not take an existing program and just make minor changes to messages or colours.

====  Blog it  ====

Write up your adventures in your blog. Remember to include the source code, some narrative about how it went, perhaps a screenshot of the program running, a reflection on the experience, and some ideas for further enhancement of the program.

Ensure that your program works and is free from major bugs. Document any limitations or remaining minor bugs.

Make sure that others (including your prof!) can run you code by pasting it into the [[6502 Emulator|emulator]] or loading it from a file (e.g., public git repository or downloadable file).

Remember to follow the [[Blog Guidelines]] as you write.

====  Examples  ====

For some examples of games and demos, see the [[#Resources]] section above, and also take a look at the http://txt3.de/ website - which uses an earlier version of the [[6502 Emulator|6502 emulator]] used in this course. The "Open Project" control on that page provides access to some interesting and inspiring code (check out "Skier", for example). You can copy-and-paste any of those examples into our SPO600 [[6502 Emulator]]. Be sure to check for permission (or licensing terms) before copying any code from that site (or any other source) and incorporating it into your code.

Another interesting example that pushes the emulator capability is the Peter Staley's Bad Apple video; see his [[https://www.youtube.com/watch?v=qsx5hKWRqpY|YouTube demo]] and [[https://github.com/pstaleystudent/|GitHub repo]]