So let's see what my goals were for this RetroChallenge, as I set them out at the beginning of the project:
Starting today, I'm going to attempt to better learn 6502 asm in my copious amounts of free time for the RC2016/01 Retrocmputing Competition. To prepare for this, over the past year I've gotten into working with Oscar Vermeulen's awesome KIM Uno kit, as well as pushing out my own updated firmware for it in the form of my Kim Uno Remix project on github.
For the challenge, I want to use this system to make a simple integer programmer's calculator which I can run on the KIM Uno itself. Press keys to shift in the nibbles, then switch it into a mode where i can affect the data. Convert hex to decimal, do bitshifts, add, multiply, etc.In short, even though I didn't accomplish everything I outlined here, I feel like I was completely successful in the project. The calculator application is incomplete according to the above feature set, but that wasn't really the goal of this whole thing. I wanted to learn 6502 Asm, which I did. (I didn't finish the BCD to HEX conversions, nor did I implement multiply/divide math functions.)
What were my problems?
I think that one thing that held me back was getting my head around doing multibyte math with only a carry bit. For some reason I got it into my head that this wasn't enough, which of course it is.
Another thing that kept me from getting everything done was that I spent a lot of time to understand the BCD/Hex algorithms. The code that I used was ultimately very similar to sample code online, but I decided that I really wanted to understand how it worked, so I didn't put it in until that was true.
And of course, just the general lack of time because of various other things including: my daytime job, playing with my kid, two contracts to work on at home, being sick, etc.
What did I achieve?
Over the course of the month, I learned a lot about how to work with such a limited set of registers. I came from Z80 world where you have a bunch of 16 bit registers. 6502 has one 8 bit accumulator (A), two 8 bit indexing registers (X,Y) which each can only be used for certain operations.
Most everything, seemingly, is done by interacting with memory locations, specifically those in the "zero page". The 6502 has this idea where the 16 byte address's top byte is the "page" of memory. the memory in the zero page would be bytes from $0000 through $00FF. This is generally used for OS and general use variables, etc since there are small opcodes specifically for working with them.
I'm getting into too much detail. I'll instead outline all of my accomplishments for the month...
- Learned 6502 ASM
- Improved the "KIM Uno Remix" Desktop application (QT for portability)
- Added a memory snooper
- Better graphics palette
- More speed support
- Learned indexing (using X and Y registers)
- Wrote the LlamaCalc input routine 3 times, learning 6502 opcodes better each time
- Came up with a decent user interface for LlamaCalc that's somewhat learned-intuitive
- LlamaCalc features implemented:
- Display/UI states for LlamaCalc (Splash, Result, Menu, Error)
- centralized interface for doing math functions, error handling, etc
- 8 level stack of numbers to be used (changeable at build time)
- Push/Pop stack functions
- Hexadecimal to BCD conversion
- bit shift left by one bit
- bit shift right by one bit
- 24 bit addition
- 24 bit subtraction
- Designed an RLE compression scheme for graphics
- Added RLE decompressor to the source code projects
- Played with optimizing screen display
- Oh yeah, created a full repository for 6502 code, with libraries etc. on github
- Every time I learned something new, I created another project in the Projects6502 repo
So yeah. I feel like i was successful...
I will soon have a walkthrough of using LlamaCalc using a KIM-Uno device.
Here's the source code for everything: