Home Micro Programmer's Manual

The Home Micro uses a MOS Technology 6502 or compatible CPU. To generate code for the CPU to execute, programs are written in 6502 assembly language and translated to machine code using an assembler.

A tutorial on 6502 assembly language can be found at http://obelisk.me.uk/6502/index.html

To convert human-readable assembly language programs into binary code the computer can run, we use an assembler. Programs in the Home Micro repository have been tested with the freely available assembler xa. This assembler can be installed on Raspbian using

sudo aptitude install xa65

Here is a simple program for the Home Micro 1000:

        pagesize = 32
        cls = $e003

        * = $0000
        .byt "HM",0,1
        .word _start
        .word pagesize
        .word _endhdr
        .word _end-_start
        .word _start
        .word 0
_endhdr:
        * = $0300
_start:
        jsr cls
        lda #$a0
        sta $2000
        lda #$05
        sta $2001
_halt:
        jmp _halt
_end:

The first few lines of the code define a number of constants. This way, we can use the names in the code, instead of the numeric values. This makes the code easier to read and modify.

The next part is the program header. It describes how to load and run the program and is discussed in more detail in the 3 chapter.

The part of the program that actually does things is after the _start label. It first calls the procedure cls, which clears the screen. It then writes a few bytes to the beginning of video memory, causing some dot patterns to appear. Finally, it enters an infinite loop, repeatedly jumping to the _halt label.

At startup, the Home Micro looks for a cartridge to load a program from. The program is identified by a header, whose format is given below. As is usual for the 6502, values that span multiple bytes are stored least significant byte first; for example, $1080 would be stored as $80, $10.

For example, a header of

48 4D
00 01
00 20
20 00
40 00
00 10
00 30
00 00

would cause the ROM to start reading at cartridge address 64 ($0400) and load 4096 bytes ($1000) into memory starting at address 768 ($0300). Once done loading, it would jump to address 512 ($0200). It would also store 32 ($0020) in the variable that holds the cartridge page size. This value is used when writing to the cartridge.

• Freely available to user programs:
  • $00 through $7f.
  • $300 through $17ff.
  • $4000 through $57ff.
  • $8000 through $bfff.
• Available, but not preserved by ROM procedures:
  • Registers a, x, and y.
  • Memory locations $a0 through $af.
• Available when not used for video (see [Video Modes] for details):
  • $1800 through $3fff.
  • $5800 through $7fff.
• Reserved memory ranges:
  • $80 through $9f.
  • $b0 through $ff.
  • $200 through $2ff.
  • $c000 through $dfff.
• ROM:
  • $e000 through $ffff.