http://www.sizecoding.org/api.php?action=feedcontributions&feedformat=atom&user=WilSizeCoding - User contributions [en]2026-05-02T03:09:09ZUser contributionsMediaWiki 1.27.0http://www.sizecoding.org/index.php?title=Commodore_64&diff=1884Commodore 642025-12-25T11:41:32Z<p>Wil: grammar</p>
<hr />
<div>== Commodore 64 ==<br />
The Commodore system consists of a 6502-compatible MOS 6510 processor with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Commodore systems is quite easy, first get the following tools:<br />
<br />
* Assembler: ACME, Mads Assembler ( https://mads.atari8.info/ )<br />
* Emulator(s): VICE is the way to go<br />
* Online Emulator + Assembler: https://lvllvl.com/c64/<br />
<br />
=== Memory map ===<br />
<br />
<syntaxhighlight lang="6502"><br />
0-1 $0-$1 PROCESSOR PORT REGISTERS, not usable as RAM<br />
0-255 $0-$FF ZEROPAGE, mostly used by BASIC interpreter and Kernal<br />
256-511 $100-$1FF SYSTEM STACK<br />
512-600 $200-$258 INPUT BUFFER<br />
601-630 $259-$276 FILE SYSTEM DATA<br />
631-640 $277-$280 KEYBOARD BUFFER, filled by Kernal ISR upon key presses <br />
641-678 $281-$2A6 VARIOUS KERNAL VARIABLES<br />
679-767 $2A7-$2FF Unused (89 byte)<br />
768-779 $300-$30B KERNAL VECTORS<br />
780-783 $30C-$30F REGISTER VALUES A,X,Y,SR for SYS<br />
784-819 $310-$333 KERNAL VECTORS<br />
820-827 $334-$33B Unused (8 byte)<br />
828-1019 $33C-$3FB DATASETTE BUFFER<br />
1020-1023 $3FC-$3FF Unused (4 byte)<br />
1024-2023 $400-$7E7 SCREEN MEMORY (25 lines times 40 columns)<br />
2024-2039 $7E8-$7F7 Unused (16 byte)<br />
2040-2047 $7F8-$7FF SPRITE COSTUME POINTERS<br />
2048 $800 must contain a value of 0 so that the BASIC program can be RUN<br />
2049-40959 $801-$9FFF BASIC AREA (code, variables, arrays, strings)<br />
40960-49151 $A000-$BFFF BASIC ROM (unused RAM underneath)<br />
49152-53247 $C000-$CFFF UPPER RAM AREA (unused)<br />
53248-53294 $D000-$D02E VIC-II, memory-mapped graphics chip registers)<br />
54272-54300 $D400-$D41C SID, memory-mapped sound chip registers)<br />
55296-56295 $D800-$DBE7 Color RAM, only lower 4 bits are stored, higher nibble undefined<br />
56296-56319 $DBE8-$DBFF Unused (24 half-bytes)<br />
56320-56335 $DC00-$DC0F CIA#1, memory-mapped I/O chip registers for keyboard, joystick, mouse, datasette, IRQ control<br />
56576-56591 $DD00-$DD0F CIA#1, memory-mapped I/O chip registers for serial bus, RS232, NMI control<br />
57344-65535 $E000-$FFFF KERNAL ROM<br />
65534-65535 $FFFE-$FFFF Execution address of interrupt service routine, can only be set if KERNAL is turned off<br />
</syntaxhighlight><br />
<br />
For a detailed explanation of the C64 memory map check out [https://sta.c64.org/cbm64mem.html Commodore 64 memory map] on Joe Forster/STA homepage.<br />
<br />
<br />
=== Video display ===<br />
Video display on the Commodore has the following native video modes:<br />
* Standard text mode, 40x25 characters, 1 individual foreground color per character, 1 common background color<br />
* Multicolor text mode, 40x25 characters, only 8 foreground colors, can be mixed with hires chars, foreground < 8 denotes a hires char, with foreground >= 8 a pair of two bits (brick pixel) define color: background, foreground & %111, common color 1+2<br />
* Extended background color text mode, 40x25 characters, 1 individual foreground color per character, 1 out of 4 background colors, only 64 chars<br />
* Hires bitmap, 320x200 pixels, an 8x8 field can have an individual foreground and an individual background color<br />
* Multicolor bitmap, 160x200 pixels, a pair of two bits (brick pixel) define color: background, screen color lower nibble, screen color higher nibble, color from color RAM<br />
<br />
==== Sync with frame ====<br />
<br />
Depending on the VIC type, there are 262/263 raster lines (NTSC) or 312 raster lines (PAL-B). Therefore, the VIC uses register at $D012 and the highest bit of register $D011 to represent the current raster line. Checking only the lower 8 bits and waiting for them to be 0 would therefore not work because this happens two times per frame. However, any number greater than 64 will only trigger once. Using a value of 255, we would sync to a rasterline at the end of the screen, well below the part where graphics are normally displayed:<br />
<br />
<syntaxhighlight lang="6502"><br />
waitsync:<br />
ldx $D012<br />
inx<br />
bne waitsync<br />
</syntaxhighlight><br />
<br />
As long as there have more than 63 cycles passed since the snyc, the next sync will happen at the next frame.<br />
This works fine as long as we don't miss the line 255 due to an interrupt. If your program has interrupts that are not synced to a rasterline, you can change the condition as follows<br />
<syntaxhighlight lang="6502"><br />
lda #$E3<br />
waitsync:<br />
cmp $D012<br />
bcs waitsync<br />
</syntaxhighlight><br />
<br />
Now we have a window between raster line $E4 and $FF to trigger our sync, which we will meet even if a standard Kernal interrupt comes in-between. Of course, our main program now has to burn around 1700 cycles to avoid a retriggering in the same frame.<br />
<br />
==== Rasters ====<br />
Here is a piece of code that will generate a simple rasterbar.]<br />
<syntaxhighlight lang="6502"><br />
To be added<br />
</syntaxhighlight><br />
<br />
==== Sprites ====<br />
The commodore 64 has access to 8 different sprites of 24x21 (or 12x21 multicolor) resolution.<br />
<syntaxhighlight lang="6502"><br />
To be added<br />
</syntaxhighlight><br />
<br />
==== Plot in Bitmap modes ====<br />
Here is a routine that will allow you to plot a single point in bitmap mode.<br />
<syntaxhighlight lang="6502"><br />
To be added<br />
</syntaxhighlight><br />
<br />
==== Text mode ====<br />
Output a character:<br />
<syntaxhighlight lang="6502"><br />
lda #C ;C must be the char code according to the PETSCII code table<br />
jsr $FFD2 ;function preserves A,X,Y and enables interrupt; you can also use the direct address $FC1A<br />
</syntaxhighlight><br />
<br />
Since the [https://en.wikipedia.org/wiki/PETSCII#Character_set PETSCII code table] contains also control characters, this method can be also used to clear the screen, move the cursor or set the text color. However, some functions are shorter (and faster) by directly calling the respective KERNAL function:<br />
<br />
<syntaxhighlight lang="6502"><br />
Clear screen JSR $E544<br />
Cursor home position JSR $E566<br />
Output newline character JSR $AAD7 ;sets A to $F2, preserves X,Y<br />
Set text color LDA #COLOR, STA $286<br />
Set border color LDA #COLOR, STA $D020 ;not possible with a PETSCII control code<br />
Set background color LDA #COLOR, STA $D021 ;not possible with a PETSCII control code<br />
</syntaxhighlight><br />
<br />
Copy characters directly to screen memory:<br />
<br />
<syntaxhighlight lang="6502"><br />
.macpack cbm ;scrcode macro<br />
SCREEN_BASE=$400<br />
LINE=5 ;for example<br />
COLUMN=10 ;for example<br />
<br />
ldx #endtext-text-1<br />
@loop: lda text,x<br />
sta SCREEN_BASE+LINE*40+COLUMN,x<br />
dex<br />
bpl @loop<br />
text: scrcode "hello world!"<br />
endtext:<br />
</syntaxhighlight><br />
<br />
Note that the text needs to be stored in '''screen code''' format, not in PETSCII (see [https://sta.c64.org/cbm64pettoscr.html Commodore 64 PETSCII code to screen code conversion] for the differences). Furthermore, the example above only writes to the screen memory, not the color RAM, assuming that the color RAM already contains the intended text color. This is the case after issuing a clear screen on most C64 machines, except for some old ROM revisions. To be on the save side you would have to write to color RAM as well, which costs another 5 byte:<br />
<br />
<syntaxhighlight lang="6502"><br />
.macpack cbm ;scrcode macro<br />
SCREEN_BASE=$400<br />
COLOR_RAM =$D800<br />
LINE =5 ;for example<br />
COLUMN =10 ;for example<br />
COLOR =1 ;white<br />
<br />
ldx #endtext-text-1<br />
@loop: lda text,x<br />
sta SCREEN_BASE+LINE*40+COLUMN,x<br />
lda #COLOR<br />
sta COLOR_RAM +LINE*40+COLUMN,x<br />
dex<br />
bpl @loop<br />
text: scrcode "hello world!"<br />
endtext:<br />
</syntaxhighlight><br />
<br />
=== Sound ===<br />
The Commodore 64 uses the famous SID chip to generate sound.<br />
To be added soon.<br />
<br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
<br />
=== Program file overhead ===<br />
<br />
A standard CBM file consists of a 2 byte loading address followed by the data that is placed into memory starting at this address. In addition, if your machine program should be able to be started with "RUN", you need a BASIC stub that is loaded into memory from $0801 to $080c, typically followed by your machine program:<br />
<br />
<syntaxhighlight lang="6502"><br />
*=$0801<br />
.word $080b ;address of next BASIC line<br />
.word LINENO ;line number, can be chosen between 0 and 63999<br />
.byte $9e ;token for SYS command<br />
.byte $32,$30,$35,$39 ;address to jump to in ASCII code: "2059" <br />
.byte $00 ;end of BASIC line<br />
start lax #0 ;actually address of next BASIC line, $xx00 means end of BASIC program, use $xx for an opcode<br />
; your code here<br />
</syntaxhighlight><br />
<br />
Together with the 2 byte load address, this makes an overhead of 14 bytes for your program, coming with A and X initialised to 0. To reduce this, you can<br />
* omit the BASIC line and tell users to start your program by directly entering "SYS ''address''"<br />
* save your program from $0802 on, the byte at $0801 is recovered automatically after loading by the relink function. This reduces your program file size by 1 byte<br />
* accept the loss and use the 2 byte establishing LINENO for something good, they are copied to zeropage addresses $39/$3a automatically, saving you the effort of initializing the addresses<br />
* use an autostart method (see below)<br />
<br />
Some compos also specify that the BASIC loader does not count towards the overall filesize, check the rules before you worry.<br />
<br />
=== Autostart ===<br />
<br />
Unlike the Commodore 128, the Commodore 64 has no dedicated built-in auto-boot feature, but it is possible to autorun a program after loading by specifying the load address so that it overwrites a vector or address that is called by the operating system. There are multiple possibilities:<br />
<br />
==== Overwriting CHROUT vector at $326-$327 ====<br />
<br />
The vector at address $326-$327 points at the CHROUT routine, normally at address $F1CA.<br />
If you put the entry address of your program into $326/27, your code will be called when the operating system wants to print "READY." after loading.<br />
Note that the vector at address $328-$329 points at the STOP routine that checks the status of Stop key indicator. Since this routine is called multiple times before your code is done loading, its default value $F6ED needs to be preserved. <br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$0326<br />
.word start <br />
.byte $ed,$f6<br />
start<br />
; rest of code<br />
</syntaxhighlight><br />
<br />
Together with the two byte load address, the overwritten CHROUT vector and the preserved STOP vector, your program file will have a deadweight of 6 byte: $26 $03 $0a $03 $ed $f6, less than half of the standard version with a BASIC stub with SYS<br />
<br />
Caveat:<br />
* If your program after $32a is longer than 214 byte, part of your program will load into the screen at $400. Thus, issuing a clear screen will overwrite your program. It is possible to move the screen memory somewhere else, but that requires storing a new value into address $D018, which when done with an LDA # / STA pair will cost you 5 byte<br />
* Since you changed the CHROUT pointer, standard KERNAL functions for printing won't work. For output of single characters, you can still use the direct address $F1CA. Alternatively, you can restore the vectors by calling $FD15, which will overwrite the memory $314 to $333 with the default values.<br />
* The memory area $33C-$3FB is the datasette buffer, thus loading a program into this area won't work when loading from a cassette.<br />
<br />
==== Overwriting BASIC idle loop vector at $302-$303 ====<br />
<br />
After loading the program, the BASIC idle loop will be called. By overwriting the vector at $302/$303 it is possible to autostart your program. Since the memory before $302 can be safely overwritten, the program would be arranged so that $303 is the '''last''' address of your program. If your program requires a loop back to the start, the vector can be used as part of a JMP where the following two bytes are already there, saving one byte in comparison to a loop done with a branch command.<br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$304 - (end - start)<br />
start:<br />
;your code here<br />
; ...<br />
jmp start ;the address for start lies in $302/$303, thus will be called by the Kernal after loading<br />
end:<br />
</syntaxhighlight><br />
<br />
In cases where the vector has a practical use, the overhead in filesize is only the 2 byte loading address. For programs larger than 93 byte keep in mind that addresses before $2A7 are in use by the Kernal.<br />
<br />
==== Overwriting return address on stack at $1F8 ====<br />
<br />
When the load routine is called, the stack pointer is always at $FA at a stock C64. Thus the return address from the loading process is stored in memory address $1F8 (low byte) and $1F9 (high byte). During the loading routine, stack usage will clobber the stack below $1F8, but a program loaded to $1F8 and above will be fine and the overwritten address stored at $1F8/$1F9 will be called after loading.<br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$1F8<br />
.word start-1 ;adjust for the RTS command pulling the address from stack and increasing it by 1<br />
start:<br />
;your code here<br />
</syntaxhighlight><br />
<br />
For programs larger than 95 byte keep in mind that addresses after $259 are in use by the Kernal, you might overwrite some values here if you don't have disk operations, but better check the memory map beforehand.<br />
<br />
Together with the two byte load address and the overwritten address at $1F8/$1F9, your program file will have a deadweight of 4 byte when using this method.<br />
<br />
==== Putting your program into zeropage overwriting part of CHRGET ====<br />
<br />
CHRGET is a machine code routine for the BASIC interpreter that is placed in the zero page at $73-$8A. By putting your program at $7C and following, the CHRGET routine runs directly into your code.<br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$7C<br />
start:<br />
;your code here<br />
</syntaxhighlight><br />
<br />
With this method, there is no need for a start address vector. The only deadweight in your program is the loading address. However, the zero page is a busy place, if your program extends beyond address $8f (that is it has more than 22 bytes on disk) you have to deal with some parts of your program being overwritten, for example, the status byte in $90 is set after loading.<br />
<br />
Loading data into address $A9 has an interesting side effect - the vector of $AE/$AF defines the address where the loaded bytes are written to. If $AE gets overwritten with, for example, $40, the next byte will be written to $41 (because the vector is incremented after the write). This can be used to split your program into different parts of memory.<br />
<br />
=== Useful Kernal functions ===<br />
<br />
==== Get a pseudo random number ====<br />
<br />
<syntaxhighlight lang="6502"><br />
lda #1 <br />
jsr $E09A<br />
lda $63<br />
</syntaxhighlight><br />
<br />
The sequence of random numbers is always the same after a cold start or reset, the first 20 numbers are:<br />
<syntaxhighlight lang="6502"><br />
4,24,231,4,177,170,193,101,231,18,196,1,75,48,149,36,124,53,65,154<br />
</syntaxhighlight><br />
<br />
==== Delay 1 Millisecond ====<br />
<br />
<syntaxhighlight lang="6502"><br />
jsr $EEB3<br />
</syntaxhighlight><br />
<br />
==== Delay ~ 2 Seconds ====<br />
<br />
This is actually Commodore's memory testing routine that is run every time the computer is turned on. Execution takes about 2 seconds to execute.<br />
<br />
<syntaxhighlight lang="6502"><br />
jsr $FD68<br />
</syntaxhighlight><br />
<br />
==== Increment a zero page counter, return in X register, clear Y register ====<br />
<br />
This is part of the string handling function in the BASIC ROM, but the code could be useful for some loop stuff.<br />
<br />
<syntaxhighlight lang="6502"><br />
jsr $B5FF ;does inc $23, ldx $23, ldy #$00, rts<br />
</syntaxhighlight><br />
<br />
=== Additional Resources ===<br />
* Codebase 64 https://codebase64.org/doku.php?id=base:start<br />
* Commodore 64 Memory map https://sta.c64.org/cbm64mem.html<br />
* C64 BASIC & KERNAL ROM Disassembly https://www.pagetable.com/c64ref/c64disasm/<br />
* No More Secrets https://csdb.dk/release/?id=226987 Everything about illegal opcodes and their use in a C64 system</div>Wilhttp://www.sizecoding.org/index.php?title=Commodore_64&diff=1883Commodore 642025-12-25T11:41:03Z<p>Wil: /* Text mode */ update details on newline call</p>
<hr />
<div>== Commodore 64 ==<br />
The Commodore system consists of a 6502-compatible MOS 6510 processor with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Commodore systems is quite easy, first get the following tools:<br />
<br />
* Assembler: ACME, Mads Assembler ( https://mads.atari8.info/ )<br />
* Emulator(s): VICE is the way to go<br />
* Online Emulator + Assembler: https://lvllvl.com/c64/<br />
<br />
=== Memory map ===<br />
<br />
<syntaxhighlight lang="6502"><br />
0-1 $0-$1 PROCESSOR PORT REGISTERS, not usable as RAM<br />
0-255 $0-$FF ZEROPAGE, mostly used by BASIC interpreter and Kernal<br />
256-511 $100-$1FF SYSTEM STACK<br />
512-600 $200-$258 INPUT BUFFER<br />
601-630 $259-$276 FILE SYSTEM DATA<br />
631-640 $277-$280 KEYBOARD BUFFER, filled by Kernal ISR upon key presses <br />
641-678 $281-$2A6 VARIOUS KERNAL VARIABLES<br />
679-767 $2A7-$2FF Unused (89 byte)<br />
768-779 $300-$30B KERNAL VECTORS<br />
780-783 $30C-$30F REGISTER VALUES A,X,Y,SR for SYS<br />
784-819 $310-$333 KERNAL VECTORS<br />
820-827 $334-$33B Unused (8 byte)<br />
828-1019 $33C-$3FB DATASETTE BUFFER<br />
1020-1023 $3FC-$3FF Unused (4 byte)<br />
1024-2023 $400-$7E7 SCREEN MEMORY (25 lines times 40 columns)<br />
2024-2039 $7E8-$7F7 Unused (16 byte)<br />
2040-2047 $7F8-$7FF SPRITE COSTUME POINTERS<br />
2048 $800 must contain a value of 0 so that the BASIC program can be RUN<br />
2049-40959 $801-$9FFF BASIC AREA (code, variables, arrays, strings)<br />
40960-49151 $A000-$BFFF BASIC ROM (unused RAM underneath)<br />
49152-53247 $C000-$CFFF UPPER RAM AREA (unused)<br />
53248-53294 $D000-$D02E VIC-II, memory-mapped graphics chip registers)<br />
54272-54300 $D400-$D41C SID, memory-mapped sound chip registers)<br />
55296-56295 $D800-$DBE7 Color RAM, only lower 4 bits are stored, higher nibble undefined<br />
56296-56319 $DBE8-$DBFF Unused (24 half-bytes)<br />
56320-56335 $DC00-$DC0F CIA#1, memory-mapped I/O chip registers for keyboard, joystick, mouse, datasette, IRQ control<br />
56576-56591 $DD00-$DD0F CIA#1, memory-mapped I/O chip registers for serial bus, RS232, NMI control<br />
57344-65535 $E000-$FFFF KERNAL ROM<br />
65534-65535 $FFFE-$FFFF Execution address of interrupt service routine, can only be set if KERNAL is turned off<br />
</syntaxhighlight><br />
<br />
For a detailed explanation of the C64 memory map check out [https://sta.c64.org/cbm64mem.html Commodore 64 memory map] on Joe Forster/STA homepage.<br />
<br />
<br />
=== Video display ===<br />
Video display on the Commodore has the following native video modes:<br />
* Standard text mode, 40x25 characters, 1 individual foreground color per character, 1 common background color<br />
* Multicolor text mode, 40x25 characters, only 8 foreground colors, can be mixed with hires chars, foreground < 8 denotes a hires char, with foreground >= 8 a pair of two bits (brick pixel) define color: background, foreground & %111, common color 1+2<br />
* Extended background color text mode, 40x25 characters, 1 individual foreground color per character, 1 out of 4 background colors, only 64 chars<br />
* Hires bitmap, 320x200 pixels, an 8x8 field can have an individual foreground and an individual background color<br />
* Multicolor bitmap, 160x200 pixels, a pair of two bits (brick pixel) define color: background, screen color lower nibble, screen color higher nibble, color from color RAM<br />
<br />
==== Sync with frame ====<br />
<br />
Depending on the VIC type, there are 262/263 raster lines (NTSC) or 312 raster lines (PAL-B). Therefore, the VIC uses register at $D012 and the highest bit of register $D011 to represent the current raster line. Checking only the lower 8 bits and waiting for them to be 0 would therefore not work because this happens two times per frame. However, any number greater than 64 will only trigger once. Using a value of 255, we would sync to a rasterline at the end of the screen, well below the part where graphics are normally displayed:<br />
<br />
<syntaxhighlight lang="6502"><br />
waitsync:<br />
ldx $D012<br />
inx<br />
bne waitsync<br />
</syntaxhighlight><br />
<br />
As long as there have more than 63 cycles passed since the snyc, the next sync will happen at the next frame.<br />
This works fine as long as we don't miss the line 255 due to an interrupt. If your program has interrupts that are not synced to a rasterline, you can change the condition as follows<br />
<syntaxhighlight lang="6502"><br />
lda #$E3<br />
waitsync:<br />
cmp $D012<br />
bcs waitsync<br />
</syntaxhighlight><br />
<br />
Now we have a window between raster line $E4 and $FF to trigger our sync, which we will meet even if a standard Kernal interrupt comes in-between. Of course, our main program now has to burn around 1700 cycles to avoid a retriggering in the same frame.<br />
<br />
==== Rasters ====<br />
Here is a piece of code that will generate a simple rasterbar.]<br />
<syntaxhighlight lang="6502"><br />
To be added<br />
</syntaxhighlight><br />
<br />
==== Sprites ====<br />
The commodore 64 has access to 8 different sprites of 24x21 (or 12x21 multicolor) resolution.<br />
<syntaxhighlight lang="6502"><br />
To be added<br />
</syntaxhighlight><br />
<br />
==== Plot in Bitmap modes ====<br />
Here is a routine that will allow you to plot a single point in bitmap mode.<br />
<syntaxhighlight lang="6502"><br />
To be added<br />
</syntaxhighlight><br />
<br />
==== Text mode ====<br />
Output a character:<br />
<syntaxhighlight lang="6502"><br />
lda #C ;C must be the char code according to the PETSCII code table<br />
jsr $FFD2 ;function preserves A,X,Y and enables interrupt; you can also use the direct address $FC1A<br />
</syntaxhighlight><br />
<br />
Since the [https://en.wikipedia.org/wiki/PETSCII#Character_set PETSCII code table] contains also control characters, this method can be also used to clear the screen, move the cursor or set the text color. However, some functions are shorter (and faster) by directly calling the respective KERNAL function:<br />
<br />
<syntaxhighlight lang="6502"><br />
Clear screen JSR $E544<br />
Cursor home position JSR $E566<br />
Output newline character JSR $AAD7 ;set A to $F2, preserves X,Y<br />
Set text color LDA #COLOR, STA $286<br />
Set border color LDA #COLOR, STA $D020 ;not possible with a PETSCII control code<br />
Set background color LDA #COLOR, STA $D021 ;not possible with a PETSCII control code<br />
</syntaxhighlight><br />
<br />
Copy characters directly to screen memory:<br />
<br />
<syntaxhighlight lang="6502"><br />
.macpack cbm ;scrcode macro<br />
SCREEN_BASE=$400<br />
LINE=5 ;for example<br />
COLUMN=10 ;for example<br />
<br />
ldx #endtext-text-1<br />
@loop: lda text,x<br />
sta SCREEN_BASE+LINE*40+COLUMN,x<br />
dex<br />
bpl @loop<br />
text: scrcode "hello world!"<br />
endtext:<br />
</syntaxhighlight><br />
<br />
Note that the text needs to be stored in '''screen code''' format, not in PETSCII (see [https://sta.c64.org/cbm64pettoscr.html Commodore 64 PETSCII code to screen code conversion] for the differences). Furthermore, the example above only writes to the screen memory, not the color RAM, assuming that the color RAM already contains the intended text color. This is the case after issuing a clear screen on most C64 machines, except for some old ROM revisions. To be on the save side you would have to write to color RAM as well, which costs another 5 byte:<br />
<br />
<syntaxhighlight lang="6502"><br />
.macpack cbm ;scrcode macro<br />
SCREEN_BASE=$400<br />
COLOR_RAM =$D800<br />
LINE =5 ;for example<br />
COLUMN =10 ;for example<br />
COLOR =1 ;white<br />
<br />
ldx #endtext-text-1<br />
@loop: lda text,x<br />
sta SCREEN_BASE+LINE*40+COLUMN,x<br />
lda #COLOR<br />
sta COLOR_RAM +LINE*40+COLUMN,x<br />
dex<br />
bpl @loop<br />
text: scrcode "hello world!"<br />
endtext:<br />
</syntaxhighlight><br />
<br />
=== Sound ===<br />
The Commodore 64 uses the famous SID chip to generate sound.<br />
To be added soon.<br />
<br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
<br />
=== Program file overhead ===<br />
<br />
A standard CBM file consists of a 2 byte loading address followed by the data that is placed into memory starting at this address. In addition, if your machine program should be able to be started with "RUN", you need a BASIC stub that is loaded into memory from $0801 to $080c, typically followed by your machine program:<br />
<br />
<syntaxhighlight lang="6502"><br />
*=$0801<br />
.word $080b ;address of next BASIC line<br />
.word LINENO ;line number, can be chosen between 0 and 63999<br />
.byte $9e ;token for SYS command<br />
.byte $32,$30,$35,$39 ;address to jump to in ASCII code: "2059" <br />
.byte $00 ;end of BASIC line<br />
start lax #0 ;actually address of next BASIC line, $xx00 means end of BASIC program, use $xx for an opcode<br />
; your code here<br />
</syntaxhighlight><br />
<br />
Together with the 2 byte load address, this makes an overhead of 14 bytes for your program, coming with A and X initialised to 0. To reduce this, you can<br />
* omit the BASIC line and tell users to start your program by directly entering "SYS ''address''"<br />
* save your program from $0802 on, the byte at $0801 is recovered automatically after loading by the relink function. This reduces your program file size by 1 byte<br />
* accept the loss and use the 2 byte establishing LINENO for something good, they are copied to zeropage addresses $39/$3a automatically, saving you the effort of initializing the addresses<br />
* use an autostart method (see below)<br />
<br />
Some compos also specify that the BASIC loader does not count towards the overall filesize, check the rules before you worry.<br />
<br />
=== Autostart ===<br />
<br />
Unlike the Commodore 128, the Commodore 64 has no dedicated built-in auto-boot feature, but it is possible to autorun a program after loading by specifying the load address so that it overwrites a vector or address that is called by the operating system. There are multiple possibilities:<br />
<br />
==== Overwriting CHROUT vector at $326-$327 ====<br />
<br />
The vector at address $326-$327 points at the CHROUT routine, normally at address $F1CA.<br />
If you put the entry address of your program into $326/27, your code will be called when the operating system wants to print "READY." after loading.<br />
Note that the vector at address $328-$329 points at the STOP routine that checks the status of Stop key indicator. Since this routine is called multiple times before your code is done loading, its default value $F6ED needs to be preserved. <br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$0326<br />
.word start <br />
.byte $ed,$f6<br />
start<br />
; rest of code<br />
</syntaxhighlight><br />
<br />
Together with the two byte load address, the overwritten CHROUT vector and the preserved STOP vector, your program file will have a deadweight of 6 byte: $26 $03 $0a $03 $ed $f6, less than half of the standard version with a BASIC stub with SYS<br />
<br />
Caveat:<br />
* If your program after $32a is longer than 214 byte, part of your program will load into the screen at $400. Thus, issuing a clear screen will overwrite your program. It is possible to move the screen memory somewhere else, but that requires storing a new value into address $D018, which when done with an LDA # / STA pair will cost you 5 byte<br />
* Since you changed the CHROUT pointer, standard KERNAL functions for printing won't work. For output of single characters, you can still use the direct address $F1CA. Alternatively, you can restore the vectors by calling $FD15, which will overwrite the memory $314 to $333 with the default values.<br />
* The memory area $33C-$3FB is the datasette buffer, thus loading a program into this area won't work when loading from a cassette.<br />
<br />
==== Overwriting BASIC idle loop vector at $302-$303 ====<br />
<br />
After loading the program, the BASIC idle loop will be called. By overwriting the vector at $302/$303 it is possible to autostart your program. Since the memory before $302 can be safely overwritten, the program would be arranged so that $303 is the '''last''' address of your program. If your program requires a loop back to the start, the vector can be used as part of a JMP where the following two bytes are already there, saving one byte in comparison to a loop done with a branch command.<br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$304 - (end - start)<br />
start:<br />
;your code here<br />
; ...<br />
jmp start ;the address for start lies in $302/$303, thus will be called by the Kernal after loading<br />
end:<br />
</syntaxhighlight><br />
<br />
In cases where the vector has a practical use, the overhead in filesize is only the 2 byte loading address. For programs larger than 93 byte keep in mind that addresses before $2A7 are in use by the Kernal.<br />
<br />
==== Overwriting return address on stack at $1F8 ====<br />
<br />
When the load routine is called, the stack pointer is always at $FA at a stock C64. Thus the return address from the loading process is stored in memory address $1F8 (low byte) and $1F9 (high byte). During the loading routine, stack usage will clobber the stack below $1F8, but a program loaded to $1F8 and above will be fine and the overwritten address stored at $1F8/$1F9 will be called after loading.<br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$1F8<br />
.word start-1 ;adjust for the RTS command pulling the address from stack and increasing it by 1<br />
start:<br />
;your code here<br />
</syntaxhighlight><br />
<br />
For programs larger than 95 byte keep in mind that addresses after $259 are in use by the Kernal, you might overwrite some values here if you don't have disk operations, but better check the memory map beforehand.<br />
<br />
Together with the two byte load address and the overwritten address at $1F8/$1F9, your program file will have a deadweight of 4 byte when using this method.<br />
<br />
==== Putting your program into zeropage overwriting part of CHRGET ====<br />
<br />
CHRGET is a machine code routine for the BASIC interpreter that is placed in the zero page at $73-$8A. By putting your program at $7C and following, the CHRGET routine runs directly into your code.<br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$7C<br />
start:<br />
;your code here<br />
</syntaxhighlight><br />
<br />
With this method, there is no need for a start address vector. The only deadweight in your program is the loading address. However, the zero page is a busy place, if your program extends beyond address $8f (that is it has more than 22 bytes on disk) you have to deal with some parts of your program being overwritten, for example, the status byte in $90 is set after loading.<br />
<br />
Loading data into address $A9 has an interesting side effect - the vector of $AE/$AF defines the address where the loaded bytes are written to. If $AE gets overwritten with, for example, $40, the next byte will be written to $41 (because the vector is incremented after the write). This can be used to split your program into different parts of memory.<br />
<br />
=== Useful Kernal functions ===<br />
<br />
==== Get a pseudo random number ====<br />
<br />
<syntaxhighlight lang="6502"><br />
lda #1 <br />
jsr $E09A<br />
lda $63<br />
</syntaxhighlight><br />
<br />
The sequence of random numbers is always the same after a cold start or reset, the first 20 numbers are:<br />
<syntaxhighlight lang="6502"><br />
4,24,231,4,177,170,193,101,231,18,196,1,75,48,149,36,124,53,65,154<br />
</syntaxhighlight><br />
<br />
==== Delay 1 Millisecond ====<br />
<br />
<syntaxhighlight lang="6502"><br />
jsr $EEB3<br />
</syntaxhighlight><br />
<br />
==== Delay ~ 2 Seconds ====<br />
<br />
This is actually Commodore's memory testing routine that is run every time the computer is turned on. Execution takes about 2 seconds to execute.<br />
<br />
<syntaxhighlight lang="6502"><br />
jsr $FD68<br />
</syntaxhighlight><br />
<br />
==== Increment a zero page counter, return in X register, clear Y register ====<br />
<br />
This is part of the string handling function in the BASIC ROM, but the code could be useful for some loop stuff.<br />
<br />
<syntaxhighlight lang="6502"><br />
jsr $B5FF ;does inc $23, ldx $23, ldy #$00, rts<br />
</syntaxhighlight><br />
<br />
=== Additional Resources ===<br />
* Codebase 64 https://codebase64.org/doku.php?id=base:start<br />
* Commodore 64 Memory map https://sta.c64.org/cbm64mem.html<br />
* C64 BASIC & KERNAL ROM Disassembly https://www.pagetable.com/c64ref/c64disasm/<br />
* No More Secrets https://csdb.dk/release/?id=226987 Everything about illegal opcodes and their use in a C64 system</div>Wilhttp://www.sizecoding.org/index.php?title=Commodore_64&diff=1281Commodore 642023-04-29T22:34:03Z<p>Wil: /* Getting something on screen */ changed comment for clarity</p>
<hr />
<div>== Commodore 64 ==<br />
The Commodore system consists of a 6502-compatible MOS 6510 processor with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Commodore systems is quite easy, first get the following tools:<br />
<br />
* Assembler: To be added<br />
* Emulator(s): VICE is the way to go<br />
<br />
=== Memory map ===<br />
<br />
<syntaxhighlight lang="6502"><br />
0-1 $0-$1 PROCESSOR PORT REGISTERS, not usable as RAM<br />
0-255 $0-$FF ZEROPAGE, mostly used by BASIC interpreter and Kernal<br />
256-511 $100-$1FF SYSTEM STACK<br />
512-600 $200-$258 INPUT BUFFER<br />
601-630 $259-$276 FILE SYSTEM DATA<br />
631-640 $277-$280 KEYBOARD BUFFER, filled by Kernal ISR upon key presses <br />
641-678 $281-$2A6 VARIOUS KERNAL VARIABLES<br />
679-767 $2A7-$2FF Unused (89 byte)<br />
768-779 $300-$30B KERNAL VECTORS<br />
780-783 $30C-$30F REGISTER VALUES A,X,Y,SR for SYS<br />
784-819 $310-$333 KERNAL VECTORS<br />
820-827 $334-$33B Unused (8 byte)<br />
828-1019 $33C-$3FB DATASETTE BUFFER<br />
1020-1023 $3FC-$3FF Unused (4 byte)<br />
1024-2023 $400-$7E7 SCREEN MEMORY (25 lines times 40 columns)<br />
2024-2039 $7E8-$7F7 Unused (16 byte)<br />
2040-2047 $7F8-$7FF SPRITE COSTUME POINTERS<br />
2048 $800 must contain a value of 0 so that the BASIC program can be RUN<br />
2049-40959 $801-$9FFF BASIC AREA (code, variables, arrays, strings)<br />
40960-49151 $A000-$BFFF BASIC ROM (unused RAM underneath)<br />
49152-53247 $C000-$CFFF UPPER RAM AREA (unused)<br />
53248-53294 $D000-$D02E VIC-II, memory-mapped graphics chip registers)<br />
54272-54300 $D400-$D41C SID, memory-mapped sound chip registers)<br />
55296-56295 $D800-$DBE7 Color RAM, only lower 4 bits are stored, higher nibble undefined<br />
56296-56319 $DBE8-$DBFF Unused (24 half-bytes)<br />
56320-56335 $DC00-$DC0F CIA#1, memory-mapped I/O chip registers for keyboard, joystick, mouse, datasette, IRQ control<br />
56576-56591 $DD00-$DD0F CIA#1, memory-mapped I/O chip registers for serial bus, RS232, NMI control<br />
57344-65535 $E000-$FFFF KERNAL ROM<br />
65534-65535 $FFFE-$FFFF Execution address of interrupt service routine, can only be set if KERNAL is turned off<br />
</syntaxhighlight><br />
<br />
For a detailed explanation of the C64 memory map check out [https://sta.c64.org/cbm64mem.html Commodore 64 memory map] on Joe Forster/STA homepage.<br />
<br />
=== Program file overhead ===<br />
<br />
A standard CBM file consists of a 2 byte loading address followed by the data that is placed into memory starting at this address. In addition, if your machine program should be able to be started with "RUN", you need a BASIC stub that is loaded into memory from $0801 to $080c, typically followed by your machine program:<br />
<br />
<syntaxhighlight lang="6502"><br />
*=$0801<br />
.word $080b ;address of next BASIC line<br />
.word LINENO ;line number, can be chosen between 0 and 63999<br />
.byte $9e ;token for SYS command<br />
.byte $32,$30,$35,$39 ;address to jump to in ASCII code: "2059" <br />
.byte $00 ;end of BASIC line<br />
start lax #0 ;actually address of next BASIC line, $xx00 means end of BASIC program, use $xx for an opcode<br />
; your code here<br />
</syntaxhighlight><br />
<br />
Together with the 2 byte load address, this makes an overhead of 14 bytes for your program, coming with A and X initialised to 0. To reduce this, you can<br />
* omit the BASIC line and tell users to start your program by directly entering "SYS ''address''"<br />
* save your program from $0802 on, the byte at $0801 is recovered automatically after loading by the relink function. This reduces your program file size by 1 byte<br />
* accept the loss and use the 2 byte establishing LINENO for something good, they are copied to zeropage addresses $39/$3a automatically, saving you the effort of initializing the addresses<br />
* use an autostart method (see below)<br />
<br />
Some compos also specify that the BASIC loader does not count towards the overall filesize, check the rules before you worry.<br />
<br />
=== Autostart ===<br />
<br />
Unlike the Commodore 128, the Commodore 64 has no dedicated built-in auto-boot feature, but it is possible to autorun a program after loading by specifying the load address so that it overwrites a vector or address that is called by the operating system. There are multiple possibilities:<br />
<br />
==== Overwriting CHROUT vector at $326-$327 ====<br />
<br />
The vector at address $326-$327 points at the CHROUT routine, normally at address $F1CA.<br />
If you put the entry address of your program into $326/27, your code will be called when the operating system wants to print "READY." after loading.<br />
Note that the vector at address $328-$329 points at the STOP routine that checks the status of Stop key indicator. Since this routine is called multiple times before your code is done loading, its default value $F6ED needs to be preserved. <br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$0326<br />
.word start <br />
.byte $ed,$f6<br />
start<br />
; rest of code<br />
</syntaxhighlight><br />
<br />
Together with the two byte load address, the overwritten CHROUT vector and the preserved STOP vector, your program file will have a deadweight of 6 byte: $26 $03 $0a $03 $ed $f6, less than half of the standard version with a BASIC stub with SYS<br />
<br />
Caveat:<br />
* If your program after $32a is longer than 214 byte, part of your program will load into the screen at $400. Thus, issuing a clear screen will overwrite your program. It is possible to move the screen memory somewhere else, but that requires storing a new value into address $D018, which when done with an LDA # / STA pair will cost you 5 byte<br />
* Since you changed the CHROUT pointer, standard KERNAL functions for printing won't work. For output of single characters, you can still use the direct address $F1CA. Alternatively, you can restore the vectors by calling $FD15, which will overwrite the memory $314 to $333 with the default values.<br />
* The memory area $33C-$3FB is the datasette buffer, thus loading a program into this area won't work when loading from a cassette.<br />
<br />
==== Overwriting BASIC idle loop vector at $302-$303 ====<br />
<br />
After loading the program, the BASIC idle loop will be called. By overwriting the vector at $302/$303 it is possible to autostart your program. Since the memory before $302 can be safely overwritten, the program would be arranged so that $303 is the '''last''' address of your program. If your program requires a loop back to the start, the vector can be used as part of a JMP where the following two bytes are already there, saving one byte in comparison to a loop done with a branch command.<br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$304 - (end - start)<br />
start:<br />
;your code here<br />
; ...<br />
jmp start ;the address for start lies in $302/$303, thus will be called by the Kernal after loading<br />
end:<br />
</syntaxhighlight><br />
<br />
In cases where the vector has a practical use, the overhead in filesize is only the 2 byte loading address. For programs larger than 93 byte keep in mind that addresses before $2A7 are in use by the Kernal.<br />
<br />
==== Overwriting return address on stack at $1F8 ====<br />
<br />
When the load routine is called, the stack pointer is always at $FA at a stock C64. Thus the return address from the loading process is stored in memory address $1F8 (low byte) and $1F9 (high byte). During the loading routine, stack usage will clobber the stack below $1F8, but a program loaded to $1F8 and above will be fine and the overwritten address stored at $1F8/$1F9 will be called after loading.<br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$1F8<br />
.word start-1 ;adjust for the RTS command pulling the address from stack and increasing it by 1<br />
start:<br />
;your code here<br />
</syntaxhighlight><br />
<br />
For programs larger than 95 byte keep in mind that addresses after $259 are in use by the Kernal, you might overwrite some values here if you don't have disk operations, but better check the memory map beforehand.<br />
<br />
Together with the two byte load address and the overwritten address at $1F8/$1F9, your program file will have a deadweight of 4 byte when using this method.<br />
<br />
==== Putting your program into zeropage overwriting part of CHRGET ====<br />
<br />
CHRGET is a machine code routine for the BASIC interpreter that is placed in the zero page at $73-$8A. By putting your program at $7C and following, the CHRGET routine runs directly into your code.<br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$7C<br />
start:<br />
;your code here<br />
</syntaxhighlight><br />
<br />
With this method, there is no need for a start address vector. The only deadweight in your program is the loading address. However, the zero page is a busy place, if your program extends beyond address $8f (that is it has more than 22 bytes on disk) you have to deal with some parts of your program being overwritten, for example, the status byte in $90 is set after loading.<br />
<br />
Loading data into address $A9 has an interesting side effect - the vector of $AE/$AF defines the address where the loaded bytes are written to. If $AE gets overwritten with, for example, $40, the next byte will be written to $41 (because the vector is incremented after the write). This can be used to split your program into different parts of memory.<br />
<br />
=== Video display ===<br />
Video display on the Commodore has the following native video modes:<br />
* Standard text mode, 40x25 characters, 1 individual foreground color per character, 1 common background color<br />
* Multicolor text mode, 40x25 characters, only 8 foreground colors, can be mixed with hires chars, foreground < 8 denotes a hires char, with foreground >= 8 a pair of two bits (brick pixel) define color: background, foreground & %111, common color 1+2<br />
* Extended background color text mode, 40x25 characters, 1 individual foreground color per character, 1 out of 4 background colors, only 64 chars<br />
* Hires bitmap, 320x200 pixels, an 8x8 field can have an individual foreground and an individual background color<br />
* Multicolor bitmap, 160x200 pixels, a pair of two bits (brick pixel) define color: background, screen color lower nibble, screen color higher nibble, color from color RAM<br />
<br />
==== Sync with frame ====<br />
<br />
Depending on the VIC type, there are 262/263 raster lines (NTSC) or 312 raster lines (PAL-B). Therefore, the VIC uses register at $D012 and the highest bit of register $D011 to represent the current raster line. Checking only the lower 8 bits and waiting for them to be 0 would therefore not work because this happens two times per frame. However, any number greater than 64 will only trigger once. Using a value of 255, we would sync to a rasterline at the end of the screen, well below the part where graphics are normally displayed:<br />
<br />
<syntaxhighlight lang="6502"><br />
waitsync:<br />
ldx $D012<br />
inx<br />
bne waitsync<br />
</syntaxhighlight><br />
<br />
As long as there have more than 63 cycles passed since the snyc, the next sync will happen at the next frame.<br />
This works fine as long as we don't miss the line 255 due to an interrupt. If your program has interrupts that are not synced to a rasterline, you can change the condition as follows<br />
<syntaxhighlight lang="6502"><br />
lda #$E3<br />
waitsync:<br />
cmp $D012<br />
bcs waitsync<br />
</syntaxhighlight><br />
<br />
Now we have a window between raster line $E4 and $FF to trigger our sync, which we will meet even if a standard Kernal interrupt comes in-between. Of course, our main program now has to burn around 1700 cycles to avoid a retriggering in the same frame.<br />
<br />
==== Getting something on screen ====<br />
<br />
Output a character:<br />
<syntaxhighlight lang="6502"><br />
lda #C ;C must be the char code according to the PETSCII code table<br />
jsr $FFD2 ;function preserves A,X,Y and enables interrupt; you can also use the direct address $FC1A<br />
</syntaxhighlight><br />
<br />
Since the [https://en.wikipedia.org/wiki/PETSCII#Character_set PETSCII code table] contains also control characters, this method can be also used to clear the screen, move the cursor or set the text color. However, some functions are shorter (and faster) by directly calling the respective KERNAL function:<br />
<br />
<syntaxhighlight lang="6502"><br />
Clear screen JSR $E544<br />
Cursor home position JSR $E566<br />
Output newline character JSR $AAD7<br />
Set text color LDA #COLOR, STA $286<br />
Set border color LDA #COLOR, STA $D020 ;not possible with a PETSCII control code<br />
Set background color LDA #COLOR, STA $D021 ;not possible with a PETSCII control code<br />
</syntaxhighlight><br />
<br />
Copy characters directly to screen memory:<br />
<br />
<syntaxhighlight lang="6502"><br />
.macpack cbm ;scrcode macro<br />
SCREEN_BASE=$400<br />
LINE=5 ;for example<br />
COLUMN=10 ;for example<br />
<br />
ldx #endtext-text-1<br />
@loop: lda text,x<br />
sta SCREEN_BASE+LINE*40+COLUMN,x<br />
dex<br />
bpl @loop<br />
text: scrcode "hello world!"<br />
endtext:<br />
</syntaxhighlight><br />
<br />
Note that the text needs to be stored in '''screen code''' format, not in PETSCII (see [https://sta.c64.org/cbm64pettoscr.html Commodore 64 PETSCII code to screen code conversion] for the differences). Furthermore, the example above only writes to the screen memory, not the color RAM, assuming that the color RAM already contains the intended text color. This is the case after issuing a clear screen on most C64 machines, except for some old ROM revisions. To be on the save side you would have to write to color RAM as well, which costs another 5 byte:<br />
<br />
<syntaxhighlight lang="6502"><br />
.macpack cbm ;scrcode macro<br />
SCREEN_BASE=$400<br />
COLOR_RAM =$D800<br />
LINE =5 ;for example<br />
COLUMN =10 ;for example<br />
COLOR =1 ;white<br />
<br />
ldx #endtext-text-1<br />
@loop: lda text,x<br />
sta SCREEN_BASE+LINE*40+COLUMN,x<br />
lda #COLOR<br />
sta COLOR_RAM +LINE*40+COLUMN,x<br />
dex<br />
bpl @loop<br />
text: scrcode "hello world!"<br />
endtext:<br />
</syntaxhighlight><br />
<br />
=== Sound ===<br />
The Commodore 64 uses the famous SID chip to generate sound.<br />
To be added soon.<br />
<br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Useful Kernal functions ===<br />
<br />
==== Get a pseudo random number ====<br />
<br />
<syntaxhighlight lang="6502"><br />
lda #1 <br />
jsr $E09A<br />
lda $63<br />
</syntaxhighlight><br />
<br />
The sequence of random numbers is always the same after a cold start or reset, the first 20 numbers are:<br />
<syntaxhighlight lang="6502"><br />
4,24,231,4,177,170,193,101,231,18,196,1,75,48,149,36,124,53,65,154<br />
</syntaxhighlight><br />
<br />
==== Delay 1 Millisecond ====<br />
<br />
<syntaxhighlight lang="6502"><br />
jsr $EEB3<br />
</syntaxhighlight><br />
<br />
==== Delay ~ 2 Seconds ====<br />
<br />
This is actually Commodore's memory testing routine that is run every time the computer is turned on. Execution takes about 2 seconds to execute.<br />
<br />
<syntaxhighlight lang="6502"><br />
jsr $FD68<br />
</syntaxhighlight><br />
<br />
==== Increment a zero page counter, return in X register, clear Y register ====<br />
<br />
This is part of the string handling function in the BASIC ROM, but the code could be useful for some loop stuff.<br />
<br />
<syntaxhighlight lang="6502"><br />
jsr $B5FF ;does inc $23, ldx $23, ldy #$00, rts<br />
</syntaxhighlight><br />
<br />
=== Additional Resources ===<br />
* Codebase 64 https://codebase64.org/doku.php?id=base:start<br />
* Commodore 64 Memory map https://sta.c64.org/cbm64mem.html<br />
* C64 BASIC & KERNAL ROM Disassembly https://www.pagetable.com/c64ref/c64disasm/<br />
* No More Secrets https://csdb.dk/release/?id=226987 Everything about illegal opcodes and their use in a C64 system</div>Wilhttp://www.sizecoding.org/index.php?title=Christmas_Tree&diff=1220Christmas Tree2023-01-07T16:40:21Z<p>Wil: /* Remarkable Entries */ added shortest BASIC entry for C64</p>
<hr />
<div>[[Category:Case Study]]<br />
==The challenge==<br />
During the [https://demozoo.org/parties/4398/ Vintage Computing Christmas Challenge 2021] the goal was to create the shape of a given Christmas tree with as few bytes as possible. All platforms and languages were allowed.<br />
The tree should be centered and look exactly like shown bellow.<br />
<code><br />
*<br />
***<br />
*****<br />
*******<br />
***<br />
*******<br />
***********<br />
***************<br />
***** <br />
*********** <br />
***************** <br />
*********************** <br />
***<br />
***<br />
</code><br />
There were mainly two kinds of approaches:<br />
* calculate stars using a formula<br />
* save amount of stars within data<br />
Do to the trunk of the tree, the second type was more efficient.<br />
<br />
The length measurement for the contest was defined as the shortest file size or source code. For Assembler, typically the filesize was relevant.<br />
<br />
==Remarkable Entries==<br />
=== Shortest DOS version ===<br />
The shortest DOS version with 44 bytes came from Hellmood:<br />
<syntaxhighlight lang=nasm><br />
org 100h ; define start of code for data access<br />
db 80 ; screen width, located at [SI], also "push ax"<br />
mov bx,d ; pointer to data for XLAT<br />
mov cx,1120 ; 14 lines with 80 chars each<br />
X: mov ax,cx ; get current sequence position<br />
div byte [si] ; transform to [X,Y] in AL, AH<br />
xlat ; get tree width for current line number<br />
sub ah,40 ; center tree in the middle<br />
jnc F ; - <br />
neg ah ; -<br />
F: sub ah,al ; inside or outside tree?<br />
salc ; set AL depending on carry flag<br />
imul ax,byte -42 ; transform into STAR or nothing<br />
int 29h ; write current char to screen<br />
loop X ; repeat unil all chars are plotter<br />
ret ; return to prompt (JMP to former AX=0x0000)<br />
d:db 2,2,12,9,6,3,8,6,4,2,4,3,2,1<br />
</syntaxhighlight><br />
=== Overall winning entry (C64) ===<br />
The shortest entry overall was for the C64 and was submitted by Serato with only 37 bytes:<br />
<syntaxhighlight lang="6502"><br />
!cpu 6510 ; enable unintended opcodes in ACME assembler<br />
<br />
chrout = $FFD2<br />
crlf = $AAD7<br />
pntr = $D3<br />
width = 40<br />
<br />
;; BASIC header<br />
*= $0801<br />
!word +, 10<br />
!byte $9e<br />
!text "2092"<br />
!byte 0<br />
+ !word 0<br />
table<br />
!byte -1 <br />
!byte -3 <br />
!byte -5 <br />
!byte -7 <br />
!byte -3 <br />
!byte -7 <br />
!byte -11 <br />
!byte -15 <br />
!byte -5 <br />
!byte -11 <br />
!byte -17 <br />
!byte -23 <br />
!byte -3 <br />
!byte -3 <br />
code<br />
-- lsr<br />
sbc #(128-width/2)<br />
sta pntr<br />
lda #'*'<br />
- jsr chrout<br />
inx<br />
bne -<br />
jsr crlf<br />
iny<br />
entry<br />
lax table,y<br />
bmi --<br />
rts<br />
end<br />
</syntaxhighlight><br />
Serato's entry was provided with the following comments:<br />
<nowiki>This entry to the Christmas Tree challenge saves space in six ways:<br />
<br />
1. Using the c64 kernal routines to output individual characters and carriage return/linefeed. These routines save/restore X/Y allowing the registers to be used as loop counters.<br />
<br />
2. Writing to the PNTR kernal variable to indent each row.<br />
<br />
3. Using the unintended LAX opcode to simultaneously load A and X with the table values.<br />
<br />
4. Storing the row widths as 2's complement negative values, to simplify the indent calculation to divide by two (LSR) and subtract (SBC). The inner loop simply counts back up to zero for rendering the correct width.<br />
<br />
5. BASIC loads the Y register from address $30d. This defaults to 0 on startup, so Y does not need to be initialised.<br />
<br />
6. Placing the table before the code in memory, the MSB of the table entries do not match the MSB of the first opcode (LSR), allowing the outer loop exit condition to be set implicitly in the Negative flag as the table values are read.<br />
<br />
These optimisations result in 37 bytes of machine code and data. Two further optimisations are possible each of which save 1 byte, but break the rules of this challenge:<br />
<br />
a - LSR and SBC can be replaced with the unintended opcode ARR, if you are willing to "centre" the tree on a virtual screen width of 32 chars.<br />
<br />
b - The BASIC interpreter leaves the line number in the zero page word at $39, so by setting the line number in the basic header to the address of the table, "LAX ($39),y" can be used for the table access.</nowiki><br />
<br />
=== Shortest BASIC entry for C64 ===<br />
<br />
While BASIC programs seem to have a structural disadvantage for this kind of challenge, some entries in the spirit of oneliners are remarkably compact.<br />
The shortest BASIC entry for the C64 was submitted by Wil with 68 bytes of source code length.<br />
<br />
<syntaxhighlight lang="basic"><br />
0dA-1,,1,2,,2,4,6,1,4,7,10,,:rEw:?sP18-w);:fOk=-2tow+w:?"*";:nE:?:gO<br />
</syntaxhighlight><br />
<br />
Expanded source code as produced by LIST:<br />
<br />
<syntaxhighlight lang="basic"><br />
0 data-1,,1,2,,2,4,6,1,4,7,10,,:readw:printspc(18-w);:fork=-2tow+w:print"*";:next:print:goto<br />
</syntaxhighlight><br />
<br />
==Optimized post-deadline versions==<br />
===36 bytes version for C64===<br />
The C64 version was shortened by altering the calculation so the default register values on start cause the first line to be drawn, shortening the table by one entry.<br />
<syntaxhighlight lang="6502"><br />
!cpu 6510 ; enable unintended opcodes in ACME assembler<br />
<br />
chrout = $FFD2<br />
crlf = $AAD7<br />
pntr = $D3<br />
width = 40<br />
<br />
;; BASIC header<br />
*= $0801<br />
!word +, 10<br />
!byte $9e<br />
!text "2074"<br />
!byte 0<br />
+ !word 0<br />
table<br />
; !byte -1 <br />
!byte -3 <br />
!byte -5 <br />
!byte -7 <br />
!byte -3 <br />
!byte -7 <br />
!byte -11 <br />
!byte -15 <br />
!byte -5 <br />
!byte -11 <br />
!byte -17 <br />
!byte -23 <br />
!byte -3 <br />
!byte -3 <br />
code<br />
-- adc #width-1<br />
lsr<br />
sta pntr<br />
lda #'*'<br />
- jsr chrout<br />
inx<br />
bmi -<br />
jsr crlf<br />
iny<br />
lax table-1,y<br />
bmi --<br />
rts<br />
end<br />
</syntaxhighlight><br />
===35 bytes version for C64===<br />
The C64 version was shortened by writing directly to the screen, saving one byte. This change prevents the Y register being used as a loop index, so a different approach is used to iterate over the table entries.<br />
<syntaxhighlight lang="6502"><br />
!cpu 6510 ; enable unintended opcodes in ACME assembler<br />
<br />
crlf = $AAD7<br />
pnt = $D1<br />
lnmx = $D5<br />
eal = $AE<br />
<br />
<br />
;; BASIC header<br />
*= $0801<br />
!word +, 10<br />
!byte $9e<br />
!text "2061"<br />
!byte 0<br />
+ !word 0<br />
<br />
code <br />
-- adc lnmx<br />
lsr<br />
tay<br />
lda #'*'<br />
- sta (pnt),y<br />
iny<br />
inx<br />
bmi -<br />
jsr crlf-8<br />
dec eal<br />
lax (eal+1,x)<br />
bmi --<br />
rts<br />
table<br />
!byte -3 <br />
!byte -3 <br />
!byte -23 <br />
!byte -17 <br />
!byte -11 <br />
!byte -5 <br />
!byte -15 <br />
!byte -11 <br />
!byte -7 <br />
!byte -3 <br />
!byte -7 <br />
!byte -5 <br />
!byte -3 <br />
; !byte -1 <br />
</syntaxhighlight><br />
===34 bytes version for C64===<br />
The C64 version was shortened by removing the ADC that indents the tree. Instead the offset to centre the tree is provided "for free" by suitably locating the EAL/EAH zp vector. This is possible because the C64 tape buffer is located immediately below the default screen location, and writing to the top line of the screen can be combined with the kernal routine to scroll the screen downward. This routine always leaves the Y register as $84, which added to the tape buffer zp vector TAPE1 points to the table ending at $3c0. The table values have their MSB clear so the centre of the tree has value $7f. When right shifted this gives an indent of $3f. The structure of the code is arranged so that the end of the binary ($3d4) plus the $3f offset give $413, ie 19 chars indented from the start of the screen matrix, centring the tree on screen. Although removing the ADC saves two bytes, one byte is lost adding the first row back into the table.<br />
<syntaxhighlight lang="6502"><br />
!cpu 6510 ; enable unintended opcodes in ACME assembler<br />
<br />
scroll_down = $E981<br />
eal = $AE<br />
tape1 = $b2<br />
<br />
*=$3c0-14<br />
; SYS 970 to draw tree<br />
; SYS 960 to draw with added "ground"<br />
<br />
table<br />
!byte 128-1<br />
!byte 128-3<br />
!byte 128-5<br />
!byte 128-7<br />
!byte 128-3<br />
!byte 128-7<br />
!byte 128-11<br />
!byte 128-15<br />
!byte 128-5<br />
!byte 128-11<br />
!byte 128-17<br />
!byte 128-23<br />
!byte 128-3<br />
!byte 128-3<br />
code <br />
-- lsr<br />
tay<br />
lda #'*'<br />
- sta (eal),y<br />
iny<br />
inx<br />
bpl -<br />
entry<br />
jsr scroll_down<br />
dec tape1<br />
lax (tape1),y<br />
bne --<br />
rts<br />
end<br />
</syntaxhighlight><br />
===33 bytes version for C64===<br />
This C64 version is most similar to the 35-byte version above. It saves 2 bytes over that version by omitting the table vector decrement, instead using the zp screen editor row variable which is incremented by the kernal with each linefeed. Fortuitously the high-byte of this vector is the "ASCII Value of Last Character Printed" which will always be $d. By locating the binary at $0dxx the table can be accessed with this vector.<br />
<syntaxhighlight lang="6502"><br />
!cpu 6510 ; enable unintended opcodes in ACME assembler<br />
<br />
crlf = $AAD7<br />
pnt = $D1<br />
lnmx = $D5<br />
tblx = $D6<br />
<br />
*=$d0b<br />
; SYS 3352 to draw tree, SYS should be typed with the cursor on row 10.<br />
<br />
table<br />
; !byte -1<br />
!byte -3<br />
!byte -5<br />
!byte -7<br />
!byte -3<br />
!byte -7<br />
!byte -11<br />
!byte -15<br />
!byte -5<br />
!byte -11<br />
!byte -17<br />
!byte -23<br />
!byte -3<br />
!byte -3<br />
code <br />
-- adc lnmx<br />
lsr<br />
tay<br />
lda #'*'<br />
- sta (pnt),y<br />
iny<br />
inx<br />
bmi -<br />
jsr crlf-8<br />
lax (tblx+1,x)<br />
bmi --<br />
rts<br />
end<br />
</syntaxhighlight><br />
===32 bytes version for ZX Spectrum===<br />
After the deadline following entry for the ZX Spectrum with only 35 bytes was submitted by reddie and optimized by char to 32 bytes:<br />
<syntaxhighlight lang="z80"><br />
# Christmas Tree post-event build, ZX Spectrum version<br />
# tnx to Manwe for info about event, better late than never =)<br />
# first version - 35 bytes - (c) reddie, 2021.12.25<br />
# optimized to 32 bytes by char, 2021.12.26 - huge thanks from me!<br />
# full final object len = 32 bytes (from label "data" to label "end")<br />
# data array len = 14 bytes; code len = 18 bytes, 13 Z80 instructions<br />
# execute from Basic only! entry point = 61455, or just run TRD image<br />
# and then run "ctree32b" Basic-program, it will load & start the code<br />
# TRD file also contains source text in ALASM format<br />
<br />
data org -16*256+1<br />
defb -5,-5,-25,-19,-13,-7,-17,-13,-9,-5,-9,-7,-5,-3<br />
<br />
start dec c<br />
jr z,$ ;stop when finished<br />
ld a,23 ;set coords via ROM procedure<br />
rst 16<br />
ld a,(bc) ;line len in negative format<br />
ld e,a<br />
rra<br />
sub b ;centering<br />
print rst 16<br />
ld a,"*"<br />
inc e<br />
jr nz,print<br />
jr start<br />
end<br />
</syntaxhighlight><br />
<br />
===35 bytes version for Plus/4===<br />
The following optimized version for the Commodore Plus/4 was created after the deadline:<br />
<syntaxhighlight lang="6502tasm"><br />
# Plus/4 Christmas Tree by GeirS, 2021-12-29<br />
# Assemble using 64tass (replace hash with semicolon first, except for 'lda #$2a')<br />
<br />
BtmRow = $0c00+$28*$18 # Address of bottom screen row<br />
Screen = BtmRow-$6c # Adjustment for ($100-$28)/2<br />
ScrollUp = $da89 # KERNAL routine to scroll screen upwards<br />
VarTab = $2d # Pointer: Start of BASIC variables<br />
<br />
* = $1001 # Load address<br />
<br />
# BASIC stub<br />
.word (NextLine),0<br />
.null $9e,format("%4d", Start)<br />
NextLine<br />
.word 0<br />
<br />
# Code and data (35 bytes total)<br />
RowLoop<br />
lsr # Calculate screen offset<br />
tay<br />
lda #$2a # Asterisk character<br />
CharLoop<br />
sta Screen,y # Put char in bottom screen row<br />
iny<br />
inx<br />
bne CharLoop # Loop for all chars<br />
Start<br />
jsr ScrollUp # Scroll the screen upwards (x=0 after)<br />
dec VarTab # Adjust address of char count to use next<br />
lax (VarTab,x) # Load char count into both a and x<br />
bmi RowLoop # Loop while not done<br />
rts<br />
<br />
# Asterisk counts (negative values to optimize the code)<br />
.char -3,-3,-23,-17,-11,-5,-15,-11,-7,-3,-7,-5,-3,-1<br />
</syntaxhighlight></div>Wilhttp://www.sizecoding.org/index.php?title=Christmas_Star&diff=1219Christmas Star2023-01-07T16:37:27Z<p>Wil: /* Shortest BASIC entry for C64 */ fixed language</p>
<hr />
<div>[[Category:Case Study]]<br />
==The challenge==<br />
During the [https://demozoo.org/parties/4578/ Vintage Computing Christmas Challenge 2022], the goal was to create the shape of a given Christmas star with as few bytes as possible. All platforms and languages were allowed. The star should look exactly like the one shown below.<br />
<code><br />
* *<br />
** **<br />
*** ***<br />
**** ****<br />
*****************<br />
***************<br />
*************<br />
***********<br />
*********<br />
***********<br />
*************<br />
***************<br />
*****************<br />
**** ****<br />
*** ***<br />
** **<br />
* *<br />
</code><br />
There were mainly two kinds of approaches:<br />
* draw character by character<br />
* mirror triangles<br />
<br />
Program length was measured as the shortest of source, file, or "real" code (excluding basic stub and file load address). For assembler programs started with SYS or call, typically filesize minus load address (=file header) is the relevant number. A BASIC stub to start the program would also not count, but it is not allowed to use the stub#s side effects to initialize zeropage addresses.<br />
<br />
==Remarkable Entries==<br />
=== Shortest entry for C64 ===<br />
The shortest entry for the C64 was submitted by Serato with 34 bytes (filesize 36 bytes):<br />
<syntaxhighlight lang="6502"><br />
chrout = $FFD2 ; Kernal routine outputs char in A<br />
plot = $E50C ; Kernal routine moves cursor to (y,x)<br />
pnt = $d1 ; Pointer to the start of the current screen line<br />
row = $b3 ; zp var that always starts at 3<br />
* = $1000<br />
do_2nd ldx row ; render "upside down" triangles<br />
do_line ldy #9 ; render one row of triangle, and its x-mirror image<br />
jsr plot ; move cursor to column 9 on row x<br />
ldy #17 ; start x-mirrored image in column 17<br />
lda #'*' ; the star of the show<br />
do_asks jsr chrout ; print star, advancing kernal cursor to right<br />
sta (pnt),y ; write x-mirrored star with mirrored cursor<br />
dey ; advance mirrored cursor to left<br />
cpy row ; test against line y=x to form diagonal<br />
bne do_asks <br />
cpx row ; check if these weere "upside down" triangles<br />
bne do_2nd ; if not, draw the upside down ones<br />
sys lda #$10 ; entry point of routine, start with y mirrored<br />
sec ; wish this could be avoided, feels like a wasted byte<br />
isc row ; increment bottom row counter and put (16 - row) in A<br />
tax ; we need in x register<br />
bpl do_line ; repeat until row < 0, then fall through<br />
rts<br />
</syntaxhighlight><br />
Serato's entry was provided with the following comments:<br />
<nowiki>The required octogram may be constructed as the union of four right triangles reflected four ways in x and y axes. The central loop renders one row of the triangle, plus its horizontal mirror image. The outer loop iterates over normal and mirror image screen rows. The result is all four triangles being rendered on top of each other. Saved a byte with unintended 6502 opcode ISC which combines INC and SBC to both increment a counter and load (16 minus) its value into A.</nowiki><br />
<br />
=== Shortest BASIC entry for C64 ===<br />
<br />
While BASIC programs seem to have a structural disadvantage for this kind of challenge, some entries in the spirit of oneliners are remarkably compact.<br />
The shortest BASIC entry for the C64 was submitted by Serato with 68 bytes of tokenized code.<br />
<br />
<syntaxhighlight lang="basic"><br />
0fOy=-8to8:fOx=-8to31:?cH(33+(9oraB(aB(y)-aB(x))>4oraB(x)>4aNaB(y)>4));:nE:nE<br />
</syntaxhighlight><br />
<br />
Expanded source code as produced by LIST:<br />
<br />
<syntaxhighlight lang="basic"><br />
0 fory=-8to8:forx=-8to31:printchr$(33+(9orabs(abs(y)-abs(x))>4orabs(x)>4andabs(y)>4));:next:next<br />
</syntaxhighlight><br />
<br />
==Optimized post-deadline versions==<br />
===32 bytes version for C64===<br />
This shorter C64 version by Serato renders the union of four triangles rotated 90 degrees. To save space it iterates 256 times. It also uses a trick where the carry flag state is set by the loop comparison causing the active row to advance automatically at the end of each column. The executable code size is 32 bytes (filesize 34 bytes).<br />
<syntaxhighlight lang="6502"><br />
plot = $E50C ; Kernal routine moves cursor to (y,x)<br />
sys_h = $15<br />
pnt = $d1<br />
tblx = $d6<br />
* = $c00<br />
lda #22<br />
loop2 tay<br />
loop1 sbc #3<br />
tax<br />
jsr plot<br />
lda #'*'<br />
sta (pnt),y<br />
tya<br />
eor #$1f<br />
ldy tblx<br />
dec $2<br />
bne loop1<br />
dey<br />
cpy #10<br />
bcs loop1<br />
dec sys_h<br />
bpl loop2<br />
rts<br />
</syntaxhighlight></div>Wilhttp://www.sizecoding.org/index.php?title=Commodore_64&diff=1218Commodore 642023-01-02T00:12:13Z<p>Wil: updated link to illegal opcaode manual to newest version</p>
<hr />
<div>== Commodore 64 ==<br />
The Commodore system consists of a 6502-compatible MOS 6510 processor with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Commodore systems is quite easy, first get the following tools:<br />
<br />
* Assembler: To be added<br />
* Emulator(s): VICE is the way to go<br />
<br />
=== Memory map ===<br />
<br />
<syntaxhighlight lang="6502"><br />
0-1 $0-$1 PROCESSOR PORT REGISTERS, not usable as RAM<br />
0-255 $0-$FF ZEROPAGE, mostly used by BASIC interpreter and Kernal<br />
256-511 $100-$1FF SYSTEM STACK<br />
512-600 $200-$258 INPUT BUFFER<br />
601-630 $259-$276 FILE SYSTEM DATA<br />
631-640 $277-$280 KEYBOARD BUFFER, filled by Kernal ISR upon key presses <br />
641-678 $281-$2A6 VARIOUS KERNAL VARIABLES<br />
679-767 $2A7-$2FF Unused (89 byte)<br />
768-779 $300-$30B KERNAL VECTORS<br />
780-783 $30C-$30F REGISTER VALUES A,X,Y,SR for SYS<br />
784-819 $310-$333 KERNAL VECTORS<br />
820-827 $334-$33B Unused (8 byte)<br />
828-1019 $33C-$3FB DATASETTE BUFFER<br />
1020-1023 $3FC-$3FF Unused (4 byte)<br />
1024-2023 $400-$7E7 SCREEN MEMORY (25 lines times 40 columns)<br />
2024-2039 $7E8-$7F7 Unused (16 byte)<br />
2040-2047 $7F8-$7FF SPRITE COSTUME POINTERS<br />
2048 $800 must contain a value of 0 so that the BASIC program can be RUN<br />
2049-40959 $801-$9FFF BASIC AREA (code, variables, arrays, strings)<br />
40960-49151 $A000-$BFFF BASIC ROM (unused RAM underneath)<br />
49152-53247 $C000-$CFFF UPPER RAM AREA (unused)<br />
53248-53294 $D000-$D02E VIC-II, memory-mapped graphics chip registers)<br />
54272-54300 $D400-$D41C SID, memory-mapped sound chip registers)<br />
55296-56295 $D800-$DBE7 Color RAM, only lower 4 bits are stored, higher nibble undefined<br />
56296-56319 $DBE8-$DBFF Unused (24 half-bytes)<br />
56320-56335 $DC00-$DC0F CIA#1, memory-mapped I/O chip registers for keyboard, joystick, mouse, datasette, IRQ control<br />
56576-56591 $DD00-$DD0F CIA#1, memory-mapped I/O chip registers for serial bus, RS232, NMI control<br />
57344-65535 $E000-$FFFF KERNAL ROM<br />
65534-65535 $FFFE-$FFFF Execution address of interrupt service routine, can only be set if KERNAL is turned off<br />
</syntaxhighlight><br />
<br />
For a detailed explanation of the C64 memory map check out [https://sta.c64.org/cbm64mem.html Commodore 64 memory map] on Joe Forster/STA homepage.<br />
<br />
=== Program file overhead ===<br />
<br />
A standard CBM file consists of a 2 byte loading address followed by the data that is placed into memory starting at this address. In addition, if your machine program should be able to be started with "RUN", you need a BASIC stub that is loaded into memory from $0801 to $080c, typically followed by your machine program:<br />
<br />
<syntaxhighlight lang="6502"><br />
*=$0801<br />
.word $080b ;address of next BASIC line<br />
.word LINENO ;line number, can be chosen between 0 and 63999<br />
.byte $9e ;token for SYS command<br />
.byte $32,$30,$35,$39 ;address to jump to in ASCII code: "2059" <br />
.byte $00 ;end of BASIC line<br />
start lax #0 ;actually address of next BASIC line, $xx00 means end of BASIC program, use $xx for an opcode<br />
; your code here<br />
</syntaxhighlight><br />
<br />
Together with the 2 byte load address, this makes an overhead of 14 bytes for your program, coming with A and X initialised to 0. To reduce this, you can<br />
* omit the BASIC line and tell users to start your program by directly entering "SYS ''address''"<br />
* save your program from $0802 on, the byte at $0801 is recovered automatically after loading by the relink function. This reduces your program file size by 1 byte<br />
* accept the loss and use the 2 byte establishing LINENO for something good, they are copied to zeropage addresses $39/$3a automatically, saving you the effort of initializing the addresses<br />
* use an autostart method (see below)<br />
<br />
Some compos also specify that the BASIC loader does not count towards the overall filesize, check the rules before you worry.<br />
<br />
=== Autostart ===<br />
<br />
Unlike the Commodore 128, the Commodore 64 has no dedicated built-in auto-boot feature, but it is possible to autorun a program after loading by specifying the load address so that it overwrites a vector or address that is called by the operating system. There are multiple possibilities:<br />
<br />
==== Overwriting CHROUT vector at $326-$327 ====<br />
<br />
The vector at address $326-$327 points at the CHROUT routine, normally at address $F1CA.<br />
If you put the entry address of your program into $326/27, your code will be called when the operating system wants to print "READY." after loading.<br />
Note that the vector at address $328-$329 points at the STOP routine that checks the status of Stop key indicator. Since this routine is called multiple times before your code is done loading, its default value $F6ED needs to be preserved. <br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$0326<br />
.word start <br />
.byte $ed,$f6<br />
start<br />
; rest of code<br />
</syntaxhighlight><br />
<br />
Together with the two byte load address, the overwritten CHROUT vector and the preserved STOP vector, your program file will have a deadweight of 6 byte: $26 $03 $0a $03 $ed $f6, less than half of the standard version with a BASIC stub with SYS<br />
<br />
Caveat:<br />
* If your program after $32a is longer than 214 byte, part of your program will load into the screen at $400. Thus, issuing a clear screen will overwrite your program. It is possible to move the screen memory somewhere else, but that requires storing a new value into address $D018, which when done with an LDA # / STA pair will cost you 5 byte<br />
* Since you changed the CHROUT pointer, standard KERNAL functions for printing won't work. For output of single characters, you can still use the direct address $F1CA. Alternatively, you can restore the vectors by calling $FD15, which will overwrite the memory $314 to $333 with the default values.<br />
* The memory area $33C-$3FB is the datasette buffer, thus loading a program into this area won't work when loading from a cassette.<br />
<br />
==== Overwriting BASIC idle loop vector at $302-$303 ====<br />
<br />
After loading the program, the BASIC idle loop will be called. By overwriting the vector at $302/$303 it is possible to autostart your program. Since the memory before $302 can be safely overwritten, the program would be arranged so that $303 is the '''last''' address of your program. If your program requires a loop back to the start, the vector can be used as part of a JMP where the following two bytes are already there, saving one byte in comparison to a loop done with a branch command.<br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$304 - (end - start)<br />
start:<br />
;your code here<br />
; ...<br />
jmp start ;the address for start lies in $302/$303, thus will be called by the Kernal after loading<br />
end:<br />
</syntaxhighlight><br />
<br />
In cases where the vector has a practical use, the overhead in filesize is only the 2 byte loading address. For programs larger than 93 byte keep in mind that addresses before $2A7 are in use by the Kernal.<br />
<br />
==== Overwriting return address on stack at $1F8 ====<br />
<br />
When the load routine is called, the stack pointer is always at $FA at a stock C64. Thus the return address from the loading process is stored in memory address $1F8 (low byte) and $1F9 (high byte). During the loading routine, stack usage will clobber the stack below $1F8, but a program loaded to $1F8 and above will be fine and the overwritten address stored at $1F8/$1F9 will be called after loading.<br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$1F8<br />
.word start-1 ;adjust for the RTS command pulling the address from stack and increasing it by 1<br />
start:<br />
;your code here<br />
</syntaxhighlight><br />
<br />
For programs larger than 95 byte keep in mind that addresses after $259 are in use by the Kernal, you might overwrite some values here if you don't have disk operations, but better check the memory map beforehand.<br />
<br />
Together with the two byte load address and the overwritten address at $1F8/$1F9, your program file will have a deadweight of 4 byte when using this method.<br />
<br />
==== Putting your program into zeropage overwriting part of CHRGET ====<br />
<br />
CHRGET is a machine code routine for the BASIC interpreter that is placed in the zero page at $73-$8A. By putting your program at $7C and following, the CHRGET routine runs directly into your code.<br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$7C<br />
start:<br />
;your code here<br />
</syntaxhighlight><br />
<br />
With this method, there is no need for a start address vector. The only deadweight in your program is the loading address. However, the zero page is a busy place, if your program extends beyond address $8f (that is it has more than 22 bytes on disk) you have to deal with some parts of your program being overwritten, for example, the status byte in $90 is set after loading.<br />
<br />
Loading data into address $A9 has an interesting side effect - the vector of $AE/$AF defines the address where the loaded bytes are written to. If $AE gets overwritten with, for example, $40, the next byte will be written to $41 (because the vector is incremented after the write). This can be used to split your program into different parts of memory.<br />
<br />
=== Video display ===<br />
Video display on the Commodore has the following native video modes:<br />
* Standard text mode, 40x25 characters, 1 individual foreground color per character, 1 common background color<br />
* Multicolor text mode, 40x25 characters, only 8 foreground colors, can be mixed with hires chars, foreground < 8 denotes a hires char, with foreground >= 8 a pair of two bits (brick pixel) define color: background, foreground & %111, common color 1+2<br />
* Extended background color text mode, 40x25 characters, 1 individual foreground color per character, 1 out of 4 background colors, only 64 chars<br />
* Hires bitmap, 320x200 pixels, an 8x8 field can have an individual foreground and an individual background color<br />
* Multicolor bitmap, 160x200 pixels, a pair of two bits (brick pixel) define color: background, screen color lower nibble, screen color higher nibble, color from color RAM<br />
<br />
==== Sync with frame ====<br />
<br />
Depending on the VIC type, there are 262/263 raster lines (NTSC) or 312 raster lines (PAL-B). Therefore, the VIC uses register at $D012 and the highest bit of register $D011 to represent the current raster line. Checking only the lower 8 bits and waiting for them to be 0 would therefore not work because this happens two times per frame. However, any number greater than 64 will only trigger once. Using a value of 255, we would sync to a rasterline at the end of the screen, well below the part where graphics are normally displayed:<br />
<br />
<syntaxhighlight lang="6502"><br />
waitsync:<br />
ldx $D012<br />
inx<br />
bne waitsync<br />
</syntaxhighlight><br />
<br />
As long as there have more than 63 cycles passed since the snyc, the next sync will happen at the next frame.<br />
This works fine as long as we don't miss the line 255 due to an interrupt. If your program has interrupts that are not synced to a rasterline, you can change the condition as follows<br />
<syntaxhighlight lang="6502"><br />
lda #$E3<br />
waitsync:<br />
cmp $D012<br />
bcs waitsync<br />
</syntaxhighlight><br />
<br />
Now we have a window between raster line $E4 and $FF to trigger our sync, which we will meet even if a standard Kernal interrupt comes in-between. Of course, our main program now has to burn around 1700 cycles to avoid a retriggering in the same frame.<br />
<br />
==== Getting something on screen ====<br />
<br />
Output a character:<br />
<syntaxhighlight lang="6502"><br />
lda #C ;C must be the char code according to the PETSCII code table<br />
jsr $FFD2 ;you can also use the direct address $FC1A, function preserves A,X,Y and enables interrupt<br />
</syntaxhighlight><br />
<br />
Since the [https://en.wikipedia.org/wiki/PETSCII#Character_set PETSCII code table] contains also control characters, this method can be also used to clear the screen, move the cursor or set the text color. However, some functions are shorter (and faster) by directly calling the respective KERNAL function:<br />
<br />
<syntaxhighlight lang="6502"><br />
Clear screen JSR $E544<br />
Cursor home position JSR $E566<br />
Output newline character JSR $AAD7<br />
Set text color LDA #COLOR, STA $286<br />
Set border color LDA #COLOR, STA $D020 ;not possible with a PETSCII control code<br />
Set background color LDA #COLOR, STA $D021 ;not possible with a PETSCII control code<br />
</syntaxhighlight><br />
<br />
Copy characters directly to screen memory:<br />
<br />
<syntaxhighlight lang="6502"><br />
.macpack cbm ;scrcode macro<br />
SCREEN_BASE=$400<br />
LINE=5 ;for example<br />
COLUMN=10 ;for example<br />
<br />
ldx #endtext-text-1<br />
@loop: lda text,x<br />
sta SCREEN_BASE+LINE*40+COLUMN,x<br />
dex<br />
bpl @loop<br />
text: scrcode "hello world!"<br />
endtext:<br />
</syntaxhighlight><br />
<br />
Note that the text needs to be stored in '''screen code''' format, not in PETSCII (see [https://sta.c64.org/cbm64pettoscr.html Commodore 64 PETSCII code to screen code conversion] for the differences). Furthermore, the example above only writes to the screen memory, not the color RAM, assuming that the color RAM already contains the intended text color. This is the case after issuing a clear screen on most C64 machines, except for some old ROM revisions. To be on the save side you would have to write to color RAM as well, which costs another 5 byte:<br />
<br />
<syntaxhighlight lang="6502"><br />
.macpack cbm ;scrcode macro<br />
SCREEN_BASE=$400<br />
COLOR_RAM =$D800<br />
LINE =5 ;for example<br />
COLUMN =10 ;for example<br />
COLOR =1 ;white<br />
<br />
ldx #endtext-text-1<br />
@loop: lda text,x<br />
sta SCREEN_BASE+LINE*40+COLUMN,x<br />
lda #COLOR<br />
sta COLOR_RAM +LINE*40+COLUMN,x<br />
dex<br />
bpl @loop<br />
text: scrcode "hello world!"<br />
endtext:<br />
</syntaxhighlight><br />
<br />
=== Sound ===<br />
The Commodore 64 uses the famous SID chip to generate sound.<br />
To be added soon.<br />
<br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Useful Kernal functions ===<br />
<br />
==== Get a pseudo random number ====<br />
<br />
<syntaxhighlight lang="6502"><br />
lda #1 <br />
jsr $E09A<br />
lda $63<br />
</syntaxhighlight><br />
<br />
The sequence of random numbers is always the same after a cold start or reset, the first 20 numbers are:<br />
<syntaxhighlight lang="6502"><br />
4,24,231,4,177,170,193,101,231,18,196,1,75,48,149,36,124,53,65,154<br />
</syntaxhighlight><br />
<br />
==== Delay 1 Millisecond ====<br />
<br />
<syntaxhighlight lang="6502"><br />
jsr $EEB3<br />
</syntaxhighlight><br />
<br />
==== Delay ~ 2 Seconds ====<br />
<br />
This is actually Commodore's memory testing routine that is run every time the computer is turned on. Execution takes about 2 seconds to execute.<br />
<br />
<syntaxhighlight lang="6502"><br />
jsr $FD68<br />
</syntaxhighlight><br />
<br />
==== Increment a zero page counter, return in X register, clear Y register ====<br />
<br />
This is part of the string handling function in the BASIC ROM, but the code could be useful for some loop stuff.<br />
<br />
<syntaxhighlight lang="6502"><br />
jsr $B5FF ;does inc $23, ldx $23, ldy #$00, rts<br />
</syntaxhighlight><br />
<br />
=== Additional Resources ===<br />
* Codebase 64 https://codebase64.org/doku.php?id=base:start<br />
* Commodore 64 Memory map https://sta.c64.org/cbm64mem.html<br />
* C64 BASIC & KERNAL ROM Disassembly https://www.pagetable.com/c64ref/c64disasm/<br />
* No More Secrets https://csdb.dk/release/?id=226987 Everything about illegal opcodes and their use in a C64 system</div>Wilhttp://www.sizecoding.org/index.php?title=Christmas_Star&diff=1217Christmas Star2023-01-01T23:06:57Z<p>Wil: /* Shortest entry for C64 */ -> Shortest BASIC entry for C64</p>
<hr />
<div>[[Category:Case Study]]<br />
==The challenge==<br />
During the [https://demozoo.org/parties/4578/ Vintage Computing Christmas Challenge 2022], the goal was to create the shape of a given Christmas star with as few bytes as possible. All platforms and languages were allowed. The star should look exactly like the one shown below.<br />
<code><br />
* *<br />
** **<br />
*** ***<br />
**** ****<br />
*****************<br />
***************<br />
*************<br />
***********<br />
*********<br />
***********<br />
*************<br />
***************<br />
*****************<br />
**** ****<br />
*** ***<br />
** **<br />
* *<br />
</code><br />
There were mainly two kinds of approaches:<br />
* draw character by character<br />
* mirror triangles<br />
<br />
Program length was measured as the shortest of source, file, or "real" code (excluding basic stub and file load address). For assembler programs started with SYS or call, typically filesize minus load address (=file header) is the relevant number. A BASIC stub to start the program would also not count, but it is not allowed to use the stub#s side effects to initialize zeropage addresses.<br />
<br />
==Remarkable Entries==<br />
=== Shortest entry for C64 ===<br />
The shortest entry for the C64 was submitted by Serato with 34 bytes (filesize 36 bytes):<br />
<syntaxhighlight lang="6502"><br />
chrout = $FFD2 ; Kernal routine outputs char in A<br />
plot = $E50C ; Kernal routine moves cursor to (y,x)<br />
pnt = $d1 ; Pointer to the start of the current screen line<br />
row = $b3 ; zp var that always starts at 3<br />
* = $1000<br />
do_2nd ldx row ; render "upside down" triangles<br />
do_line ldy #9 ; render one row of triangle, and its x-mirror image<br />
jsr plot ; move cursor to column 9 on row x<br />
ldy #17 ; start x-mirrored image in column 17<br />
lda #'*' ; the star of the show<br />
do_asks jsr chrout ; print star, advancing kernal cursor to right<br />
sta (pnt),y ; write x-mirrored star with mirrored cursor<br />
dey ; advance mirrored cursor to left<br />
cpy row ; test against line y=x to form diagonal<br />
bne do_asks <br />
cpx row ; check if these weere "upside down" triangles<br />
bne do_2nd ; if not, draw the upside down ones<br />
sys lda #$10 ; entry point of routine, start with y mirrored<br />
sec ; wish this could be avoided, feels like a wasted byte<br />
isc row ; increment bottom row counter and put (16 - row) in A<br />
tax ; we need in x register<br />
bpl do_line ; repeat until row < 0, then fall through<br />
rts<br />
</syntaxhighlight><br />
Serato's entry was provided with the following comments:<br />
<nowiki>The required octogram may be constructed as the union of four right triangles reflected four ways in x and y axes. The central loop renders one row of the triangle, plus its horizontal mirror image. The outer loop iterates over normal and mirror image screen rows. The result is all four triangles being rendered on top of each other. Saved a byte with unintended 6502 opcode ISC which combines INC and SBC to both increment a counter and load (16 minus) its value into A.</nowiki><br />
<br />
=== Shortest BASIC entry for C64 ===<br />
<br />
While BASIC programmes sees to have a structural disadvantage for this kind of challenge, some entries in the spirit of oneliners are remarably compact.<br />
The shortest BASIC entry for the C64 was submitted by Serato with 68 bytes tokenized code.<br />
<br />
<syntaxhighlight lang="basic"><br />
0fOy=-8to8:fOx=-8to31:?cH(33+(9oraB(aB(y)-aB(x))>4oraB(x)>4aNaB(y)>4));:nE:nE<br />
</syntaxhighlight><br />
<br />
Expanded source code as produced by LIST:<br />
<br />
<syntaxhighlight lang="basic"><br />
0 fory=-8to8:forx=-8to31:printchr$(33+(9orabs(abs(y)-abs(x))>4orabs(x)>4andabs(y)>4));:next:next<br />
</syntaxhighlight><br />
<br />
==Optimized post-deadline versions==<br />
===32 bytes version for C64===<br />
This shorter C64 version by Serato renders the union of four triangles rotated 90 degrees. To save space it iterates 256 times. It also uses a trick where the carry flag state is set by the loop comparison causing the active row to advance automatically at the end of each column. The executable code size is 32 bytes (filesize 34 bytes).<br />
<syntaxhighlight lang="6502"><br />
plot = $E50C ; Kernal routine moves cursor to (y,x)<br />
sys_h = $15<br />
pnt = $d1<br />
tblx = $d6<br />
* = $c00<br />
lda #22<br />
loop2 tay<br />
loop1 sbc #3<br />
tax<br />
jsr plot<br />
lda #'*'<br />
sta (pnt),y<br />
tya<br />
eor #$1f<br />
ldy tblx<br />
dec $2<br />
bne loop1<br />
dey<br />
cpy #10<br />
bcs loop1<br />
dec sys_h<br />
bpl loop2<br />
rts<br />
</syntaxhighlight></div>Wilhttp://www.sizecoding.org/index.php?title=Christmas_Star&diff=1216Christmas Star2023-01-01T22:49:53Z<p>Wil: /* Winning Entries */ rephrased to avoid overuse of winning - there was only one main contest</p>
<hr />
<div>[[Category:Case Study]]<br />
==The challenge==<br />
During the [https://demozoo.org/parties/4578/ Vintage Computing Christmas Challenge 2022], the goal was to create the shape of a given Christmas star with as few bytes as possible. All platforms and languages were allowed. The star should look exactly like the one shown below.<br />
<code><br />
* *<br />
** **<br />
*** ***<br />
**** ****<br />
*****************<br />
***************<br />
*************<br />
***********<br />
*********<br />
***********<br />
*************<br />
***************<br />
*****************<br />
**** ****<br />
*** ***<br />
** **<br />
* *<br />
</code><br />
There were mainly two kinds of approaches:<br />
* draw character by character<br />
* mirror triangles<br />
<br />
Program length was measured as the shortest of source, file, or "real" code (excluding basic stub and file load address). For assembler programs started with SYS or call, typically filesize minus load address (=file header) is the relevant number. A BASIC stub to start the program would also not count, but it is not allowed to use the stub#s side effects to initialize zeropage addresses.<br />
<br />
==Remarkable Entries==<br />
=== Shortest entry for C64 ===<br />
The shortest entry for the C64 was submitted by Serato with 34 bytes (filesize 36 bytes):<br />
<syntaxhighlight lang="6502"><br />
chrout = $FFD2 ; Kernal routine outputs char in A<br />
plot = $E50C ; Kernal routine moves cursor to (y,x)<br />
pnt = $d1 ; Pointer to the start of the current screen line<br />
row = $b3 ; zp var that always starts at 3<br />
* = $1000<br />
do_2nd ldx row ; render "upside down" triangles<br />
do_line ldy #9 ; render one row of triangle, and its x-mirror image<br />
jsr plot ; move cursor to column 9 on row x<br />
ldy #17 ; start x-mirrored image in column 17<br />
lda #'*' ; the star of the show<br />
do_asks jsr chrout ; print star, advancing kernal cursor to right<br />
sta (pnt),y ; write x-mirrored star with mirrored cursor<br />
dey ; advance mirrored cursor to left<br />
cpy row ; test against line y=x to form diagonal<br />
bne do_asks <br />
cpx row ; check if these weere "upside down" triangles<br />
bne do_2nd ; if not, draw the upside down ones<br />
sys lda #$10 ; entry point of routine, start with y mirrored<br />
sec ; wish this could be avoided, feels like a wasted byte<br />
isc row ; increment bottom row counter and put (16 - row) in A<br />
tax ; we need in x register<br />
bpl do_line ; repeat until row < 0, then fall through<br />
rts<br />
</syntaxhighlight><br />
Serato's entry was provided with the following comments:<br />
<nowiki>The required octogram may be constructed as the union of four right triangles reflected four ways in x and y axes. The central loop renders one row of the triangle, plus its horizontal mirror image. The outer loop iterates over normal and mirror image screen rows. The result is all four triangles being rendered on top of each other. Saved a byte with unintended 6502 opcode ISC which combines INC and SBC to both increment a counter and load (16 minus) its value into A.</nowiki><br />
<br />
==Optimized post-deadline versions==<br />
===32 bytes version for C64===<br />
This shorter C64 version by Serato renders the union of four triangles rotated 90 degrees. To save space it iterates 256 times. It also uses a trick where the carry flag state is set by the loop comparison causing the active row to advance automatically at the end of each column. The executable code size is 32 bytes (filesize 34 bytes).<br />
<syntaxhighlight lang="6502"><br />
plot = $E50C ; Kernal routine moves cursor to (y,x)<br />
sys_h = $15<br />
pnt = $d1<br />
tblx = $d6<br />
* = $c00<br />
lda #22<br />
loop2 tay<br />
loop1 sbc #3<br />
tax<br />
jsr plot<br />
lda #'*'<br />
sta (pnt),y<br />
tya<br />
eor #$1f<br />
ldy tblx<br />
dec $2<br />
bne loop1<br />
dey<br />
cpy #10<br />
bcs loop1<br />
dec sys_h<br />
bpl loop2<br />
rts<br />
</syntaxhighlight></div>Wilhttp://www.sizecoding.org/index.php?title=Christmas_Tree&diff=1215Christmas Tree2023-01-01T22:48:15Z<p>Wil: /* The challenge */</p>
<hr />
<div>[[Category:Case Study]]<br />
==The challenge==<br />
During the [https://demozoo.org/parties/4398/ Vintage Computing Christmas Challenge 2021] the goal was to create the shape of a given Christmas tree with as few bytes as possible. All platforms and languages were allowed.<br />
The tree should be centered and look exactly like shown bellow.<br />
<code><br />
*<br />
***<br />
*****<br />
*******<br />
***<br />
*******<br />
***********<br />
***************<br />
***** <br />
*********** <br />
***************** <br />
*********************** <br />
***<br />
***<br />
</code><br />
There were mainly two kinds of approaches:<br />
* calculate stars using a formula<br />
* save amount of stars within data<br />
Do to the trunk of the tree, the second type was more efficient.<br />
<br />
The length measurement for the contest was defined as the shortest file size or source code. For Assembler, typically the filesize was relevant.<br />
<br />
==Remarkable Entries==<br />
=== Shortest DOS version ===<br />
The shortest DOS version with 44 bytes came from Hellmood:<br />
<syntaxhighlight lang=nasm><br />
org 100h ; define start of code for data access<br />
db 80 ; screen width, located at [SI], also "push ax"<br />
mov bx,d ; pointer to data for XLAT<br />
mov cx,1120 ; 14 lines with 80 chars each<br />
X: mov ax,cx ; get current sequence position<br />
div byte [si] ; transform to [X,Y] in AL, AH<br />
xlat ; get tree width for current line number<br />
sub ah,40 ; center tree in the middle<br />
jnc F ; - <br />
neg ah ; -<br />
F: sub ah,al ; inside or outside tree?<br />
salc ; set AL depending on carry flag<br />
imul ax,byte -42 ; transform into STAR or nothing<br />
int 29h ; write current char to screen<br />
loop X ; repeat unil all chars are plotter<br />
ret ; return to prompt (JMP to former AX=0x0000)<br />
d:db 2,2,12,9,6,3,8,6,4,2,4,3,2,1<br />
</syntaxhighlight><br />
=== Overall winning entry (C64) ===<br />
The shortest entry overall was for the C64 and was submitted by Serato with only 37 bytes:<br />
<syntaxhighlight lang="6502"><br />
!cpu 6510 ; enable unintended opcodes in ACME assembler<br />
<br />
chrout = $FFD2<br />
crlf = $AAD7<br />
pntr = $D3<br />
width = 40<br />
<br />
;; BASIC header<br />
*= $0801<br />
!word +, 10<br />
!byte $9e<br />
!text "2092"<br />
!byte 0<br />
+ !word 0<br />
table<br />
!byte -1 <br />
!byte -3 <br />
!byte -5 <br />
!byte -7 <br />
!byte -3 <br />
!byte -7 <br />
!byte -11 <br />
!byte -15 <br />
!byte -5 <br />
!byte -11 <br />
!byte -17 <br />
!byte -23 <br />
!byte -3 <br />
!byte -3 <br />
code<br />
-- lsr<br />
sbc #(128-width/2)<br />
sta pntr<br />
lda #'*'<br />
- jsr chrout<br />
inx<br />
bne -<br />
jsr crlf<br />
iny<br />
entry<br />
lax table,y<br />
bmi --<br />
rts<br />
end<br />
</syntaxhighlight><br />
Serato's entry was provided with the following comments:<br />
<nowiki>This entry to the Christmas Tree challenge saves space in six ways:<br />
<br />
1. Using the c64 kernal routines to output individual characters and carriage return/linefeed. These routines save/restore X/Y allowing the registers to be used as loop counters.<br />
<br />
2. Writing to the PNTR kernal variable to indent each row.<br />
<br />
3. Using the unintended LAX opcode to simultaneously load A and X with the table values.<br />
<br />
4. Storing the row widths as 2's complement negative values, to simplify the indent calculation to divide by two (LSR) and subtract (SBC). The inner loop simply counts back up to zero for rendering the correct width.<br />
<br />
5. BASIC loads the Y register from address $30d. This defaults to 0 on startup, so Y does not need to be initialised.<br />
<br />
6. Placing the table before the code in memory, the MSB of the table entries do not match the MSB of the first opcode (LSR), allowing the outer loop exit condition to be set implicitly in the Negative flag as the table values are read.<br />
<br />
These optimisations result in 37 bytes of machine code and data. Two further optimisations are possible each of which save 1 byte, but break the rules of this challenge:<br />
<br />
a - LSR and SBC can be replaced with the unintended opcode ARR, if you are willing to "centre" the tree on a virtual screen width of 32 chars.<br />
<br />
b - The BASIC interpreter leaves the line number in the zero page word at $39, so by setting the line number in the basic header to the address of the table, "LAX ($39),y" can be used for the table access.</nowiki><br />
<br />
==Optimized post-deadline versions==<br />
===36 bytes version for C64===<br />
The C64 version was shortened by altering the calculation so the default register values on start cause the first line to be drawn, shortening the table by one entry.<br />
<syntaxhighlight lang="6502"><br />
!cpu 6510 ; enable unintended opcodes in ACME assembler<br />
<br />
chrout = $FFD2<br />
crlf = $AAD7<br />
pntr = $D3<br />
width = 40<br />
<br />
;; BASIC header<br />
*= $0801<br />
!word +, 10<br />
!byte $9e<br />
!text "2074"<br />
!byte 0<br />
+ !word 0<br />
table<br />
; !byte -1 <br />
!byte -3 <br />
!byte -5 <br />
!byte -7 <br />
!byte -3 <br />
!byte -7 <br />
!byte -11 <br />
!byte -15 <br />
!byte -5 <br />
!byte -11 <br />
!byte -17 <br />
!byte -23 <br />
!byte -3 <br />
!byte -3 <br />
code<br />
-- adc #width-1<br />
lsr<br />
sta pntr<br />
lda #'*'<br />
- jsr chrout<br />
inx<br />
bmi -<br />
jsr crlf<br />
iny<br />
lax table-1,y<br />
bmi --<br />
rts<br />
end<br />
</syntaxhighlight><br />
===35 bytes version for C64===<br />
The C64 version was shortened by writing directly to the screen, saving one byte. This change prevents the Y register being used as a loop index, so a different approach is used to iterate over the table entries.<br />
<syntaxhighlight lang="6502"><br />
!cpu 6510 ; enable unintended opcodes in ACME assembler<br />
<br />
crlf = $AAD7<br />
pnt = $D1<br />
lnmx = $D5<br />
eal = $AE<br />
<br />
<br />
;; BASIC header<br />
*= $0801<br />
!word +, 10<br />
!byte $9e<br />
!text "2061"<br />
!byte 0<br />
+ !word 0<br />
<br />
code <br />
-- adc lnmx<br />
lsr<br />
tay<br />
lda #'*'<br />
- sta (pnt),y<br />
iny<br />
inx<br />
bmi -<br />
jsr crlf-8<br />
dec eal<br />
lax (eal+1,x)<br />
bmi --<br />
rts<br />
table<br />
!byte -3 <br />
!byte -3 <br />
!byte -23 <br />
!byte -17 <br />
!byte -11 <br />
!byte -5 <br />
!byte -15 <br />
!byte -11 <br />
!byte -7 <br />
!byte -3 <br />
!byte -7 <br />
!byte -5 <br />
!byte -3 <br />
; !byte -1 <br />
</syntaxhighlight><br />
===34 bytes version for C64===<br />
The C64 version was shortened by removing the ADC that indents the tree. Instead the offset to centre the tree is provided "for free" by suitably locating the EAL/EAH zp vector. This is possible because the C64 tape buffer is located immediately below the default screen location, and writing to the top line of the screen can be combined with the kernal routine to scroll the screen downward. This routine always leaves the Y register as $84, which added to the tape buffer zp vector TAPE1 points to the table ending at $3c0. The table values have their MSB clear so the centre of the tree has value $7f. When right shifted this gives an indent of $3f. The structure of the code is arranged so that the end of the binary ($3d4) plus the $3f offset give $413, ie 19 chars indented from the start of the screen matrix, centring the tree on screen. Although removing the ADC saves two bytes, one byte is lost adding the first row back into the table.<br />
<syntaxhighlight lang="6502"><br />
!cpu 6510 ; enable unintended opcodes in ACME assembler<br />
<br />
scroll_down = $E981<br />
eal = $AE<br />
tape1 = $b2<br />
<br />
*=$3c0-14<br />
; SYS 970 to draw tree<br />
; SYS 960 to draw with added "ground"<br />
<br />
table<br />
!byte 128-1<br />
!byte 128-3<br />
!byte 128-5<br />
!byte 128-7<br />
!byte 128-3<br />
!byte 128-7<br />
!byte 128-11<br />
!byte 128-15<br />
!byte 128-5<br />
!byte 128-11<br />
!byte 128-17<br />
!byte 128-23<br />
!byte 128-3<br />
!byte 128-3<br />
code <br />
-- lsr<br />
tay<br />
lda #'*'<br />
- sta (eal),y<br />
iny<br />
inx<br />
bpl -<br />
entry<br />
jsr scroll_down<br />
dec tape1<br />
lax (tape1),y<br />
bne --<br />
rts<br />
end<br />
</syntaxhighlight><br />
===33 bytes version for C64===<br />
This C64 version is most similar to the 35-byte version above. It saves 2 bytes over that version by omitting the table vector decrement, instead using the zp screen editor row variable which is incremented by the kernal with each linefeed. Fortuitously the high-byte of this vector is the "ASCII Value of Last Character Printed" which will always be $d. By locating the binary at $0dxx the table can be accessed with this vector.<br />
<syntaxhighlight lang="6502"><br />
!cpu 6510 ; enable unintended opcodes in ACME assembler<br />
<br />
crlf = $AAD7<br />
pnt = $D1<br />
lnmx = $D5<br />
tblx = $D6<br />
<br />
*=$d0b<br />
; SYS 3352 to draw tree, SYS should be typed with the cursor on row 10.<br />
<br />
table<br />
; !byte -1<br />
!byte -3<br />
!byte -5<br />
!byte -7<br />
!byte -3<br />
!byte -7<br />
!byte -11<br />
!byte -15<br />
!byte -5<br />
!byte -11<br />
!byte -17<br />
!byte -23<br />
!byte -3<br />
!byte -3<br />
code <br />
-- adc lnmx<br />
lsr<br />
tay<br />
lda #'*'<br />
- sta (pnt),y<br />
iny<br />
inx<br />
bmi -<br />
jsr crlf-8<br />
lax (tblx+1,x)<br />
bmi --<br />
rts<br />
end<br />
</syntaxhighlight><br />
===32 bytes version for ZX Spectrum===<br />
After the deadline following entry for the ZX Spectrum with only 35 bytes was submitted by reddie and optimized by char to 32 bytes:<br />
<syntaxhighlight lang="z80"><br />
# Christmas Tree post-event build, ZX Spectrum version<br />
# tnx to Manwe for info about event, better late than never =)<br />
# first version - 35 bytes - (c) reddie, 2021.12.25<br />
# optimized to 32 bytes by char, 2021.12.26 - huge thanks from me!<br />
# full final object len = 32 bytes (from label "data" to label "end")<br />
# data array len = 14 bytes; code len = 18 bytes, 13 Z80 instructions<br />
# execute from Basic only! entry point = 61455, or just run TRD image<br />
# and then run "ctree32b" Basic-program, it will load & start the code<br />
# TRD file also contains source text in ALASM format<br />
<br />
data org -16*256+1<br />
defb -5,-5,-25,-19,-13,-7,-17,-13,-9,-5,-9,-7,-5,-3<br />
<br />
start dec c<br />
jr z,$ ;stop when finished<br />
ld a,23 ;set coords via ROM procedure<br />
rst 16<br />
ld a,(bc) ;line len in negative format<br />
ld e,a<br />
rra<br />
sub b ;centering<br />
print rst 16<br />
ld a,"*"<br />
inc e<br />
jr nz,print<br />
jr start<br />
end<br />
</syntaxhighlight><br />
<br />
===35 bytes version for Plus/4===<br />
The following optimized version for the Commodore Plus/4 was created after the deadline:<br />
<syntaxhighlight lang="6502tasm"><br />
# Plus/4 Christmas Tree by GeirS, 2021-12-29<br />
# Assemble using 64tass (replace hash with semicolon first, except for 'lda #$2a')<br />
<br />
BtmRow = $0c00+$28*$18 # Address of bottom screen row<br />
Screen = BtmRow-$6c # Adjustment for ($100-$28)/2<br />
ScrollUp = $da89 # KERNAL routine to scroll screen upwards<br />
VarTab = $2d # Pointer: Start of BASIC variables<br />
<br />
* = $1001 # Load address<br />
<br />
# BASIC stub<br />
.word (NextLine),0<br />
.null $9e,format("%4d", Start)<br />
NextLine<br />
.word 0<br />
<br />
# Code and data (35 bytes total)<br />
RowLoop<br />
lsr # Calculate screen offset<br />
tay<br />
lda #$2a # Asterisk character<br />
CharLoop<br />
sta Screen,y # Put char in bottom screen row<br />
iny<br />
inx<br />
bne CharLoop # Loop for all chars<br />
Start<br />
jsr ScrollUp # Scroll the screen upwards (x=0 after)<br />
dec VarTab # Adjust address of char count to use next<br />
lax (VarTab,x) # Load char count into both a and x<br />
bmi RowLoop # Loop while not done<br />
rts<br />
<br />
# Asterisk counts (negative values to optimize the code)<br />
.char -3,-3,-23,-17,-11,-5,-15,-11,-7,-3,-7,-5,-3,-1<br />
</syntaxhighlight></div>Wilhttp://www.sizecoding.org/index.php?title=Christmas_Tree&diff=1214Christmas Tree2023-01-01T22:44:47Z<p>Wil: /* Winning Entries */</p>
<hr />
<div>[[Category:Case Study]]<br />
==The challenge==<br />
During the [https://demozoo.org/parties/4398/ Vintage Computing Christmas Challenge 2021] the goal was to create the shape of a given Christmas tree with as few bytes as possible. All platforms and languages were allowed.<br />
The tree should be centered and look exactly like shown bellow.<br />
<code><br />
*<br />
***<br />
*****<br />
*******<br />
***<br />
*******<br />
***********<br />
***************<br />
***** <br />
*********** <br />
***************** <br />
*********************** <br />
***<br />
***<br />
</code><br />
There were mainly two kinds of approaches:<br />
* calculate stars using a formula<br />
* save amount of stars within data<br />
Do to the trunk of the tree, the second type was more efficient. <br />
==Remarkable Entries==<br />
=== Shortest DOS version ===<br />
The shortest DOS version with 44 bytes came from Hellmood:<br />
<syntaxhighlight lang=nasm><br />
org 100h ; define start of code for data access<br />
db 80 ; screen width, located at [SI], also "push ax"<br />
mov bx,d ; pointer to data for XLAT<br />
mov cx,1120 ; 14 lines with 80 chars each<br />
X: mov ax,cx ; get current sequence position<br />
div byte [si] ; transform to [X,Y] in AL, AH<br />
xlat ; get tree width for current line number<br />
sub ah,40 ; center tree in the middle<br />
jnc F ; - <br />
neg ah ; -<br />
F: sub ah,al ; inside or outside tree?<br />
salc ; set AL depending on carry flag<br />
imul ax,byte -42 ; transform into STAR or nothing<br />
int 29h ; write current char to screen<br />
loop X ; repeat unil all chars are plotter<br />
ret ; return to prompt (JMP to former AX=0x0000)<br />
d:db 2,2,12,9,6,3,8,6,4,2,4,3,2,1<br />
</syntaxhighlight><br />
=== Overall winning entry (C64) ===<br />
The shortest entry overall was for the C64 and was submitted by Serato with only 37 bytes:<br />
<syntaxhighlight lang="6502"><br />
!cpu 6510 ; enable unintended opcodes in ACME assembler<br />
<br />
chrout = $FFD2<br />
crlf = $AAD7<br />
pntr = $D3<br />
width = 40<br />
<br />
;; BASIC header<br />
*= $0801<br />
!word +, 10<br />
!byte $9e<br />
!text "2092"<br />
!byte 0<br />
+ !word 0<br />
table<br />
!byte -1 <br />
!byte -3 <br />
!byte -5 <br />
!byte -7 <br />
!byte -3 <br />
!byte -7 <br />
!byte -11 <br />
!byte -15 <br />
!byte -5 <br />
!byte -11 <br />
!byte -17 <br />
!byte -23 <br />
!byte -3 <br />
!byte -3 <br />
code<br />
-- lsr<br />
sbc #(128-width/2)<br />
sta pntr<br />
lda #'*'<br />
- jsr chrout<br />
inx<br />
bne -<br />
jsr crlf<br />
iny<br />
entry<br />
lax table,y<br />
bmi --<br />
rts<br />
end<br />
</syntaxhighlight><br />
Serato's entry was provided with the following comments:<br />
<nowiki>This entry to the Christmas Tree challenge saves space in six ways:<br />
<br />
1. Using the c64 kernal routines to output individual characters and carriage return/linefeed. These routines save/restore X/Y allowing the registers to be used as loop counters.<br />
<br />
2. Writing to the PNTR kernal variable to indent each row.<br />
<br />
3. Using the unintended LAX opcode to simultaneously load A and X with the table values.<br />
<br />
4. Storing the row widths as 2's complement negative values, to simplify the indent calculation to divide by two (LSR) and subtract (SBC). The inner loop simply counts back up to zero for rendering the correct width.<br />
<br />
5. BASIC loads the Y register from address $30d. This defaults to 0 on startup, so Y does not need to be initialised.<br />
<br />
6. Placing the table before the code in memory, the MSB of the table entries do not match the MSB of the first opcode (LSR), allowing the outer loop exit condition to be set implicitly in the Negative flag as the table values are read.<br />
<br />
These optimisations result in 37 bytes of machine code and data. Two further optimisations are possible each of which save 1 byte, but break the rules of this challenge:<br />
<br />
a - LSR and SBC can be replaced with the unintended opcode ARR, if you are willing to "centre" the tree on a virtual screen width of 32 chars.<br />
<br />
b - The BASIC interpreter leaves the line number in the zero page word at $39, so by setting the line number in the basic header to the address of the table, "LAX ($39),y" can be used for the table access.</nowiki><br />
<br />
==Optimized post-deadline versions==<br />
===36 bytes version for C64===<br />
The C64 version was shortened by altering the calculation so the default register values on start cause the first line to be drawn, shortening the table by one entry.<br />
<syntaxhighlight lang="6502"><br />
!cpu 6510 ; enable unintended opcodes in ACME assembler<br />
<br />
chrout = $FFD2<br />
crlf = $AAD7<br />
pntr = $D3<br />
width = 40<br />
<br />
;; BASIC header<br />
*= $0801<br />
!word +, 10<br />
!byte $9e<br />
!text "2074"<br />
!byte 0<br />
+ !word 0<br />
table<br />
; !byte -1 <br />
!byte -3 <br />
!byte -5 <br />
!byte -7 <br />
!byte -3 <br />
!byte -7 <br />
!byte -11 <br />
!byte -15 <br />
!byte -5 <br />
!byte -11 <br />
!byte -17 <br />
!byte -23 <br />
!byte -3 <br />
!byte -3 <br />
code<br />
-- adc #width-1<br />
lsr<br />
sta pntr<br />
lda #'*'<br />
- jsr chrout<br />
inx<br />
bmi -<br />
jsr crlf<br />
iny<br />
lax table-1,y<br />
bmi --<br />
rts<br />
end<br />
</syntaxhighlight><br />
===35 bytes version for C64===<br />
The C64 version was shortened by writing directly to the screen, saving one byte. This change prevents the Y register being used as a loop index, so a different approach is used to iterate over the table entries.<br />
<syntaxhighlight lang="6502"><br />
!cpu 6510 ; enable unintended opcodes in ACME assembler<br />
<br />
crlf = $AAD7<br />
pnt = $D1<br />
lnmx = $D5<br />
eal = $AE<br />
<br />
<br />
;; BASIC header<br />
*= $0801<br />
!word +, 10<br />
!byte $9e<br />
!text "2061"<br />
!byte 0<br />
+ !word 0<br />
<br />
code <br />
-- adc lnmx<br />
lsr<br />
tay<br />
lda #'*'<br />
- sta (pnt),y<br />
iny<br />
inx<br />
bmi -<br />
jsr crlf-8<br />
dec eal<br />
lax (eal+1,x)<br />
bmi --<br />
rts<br />
table<br />
!byte -3 <br />
!byte -3 <br />
!byte -23 <br />
!byte -17 <br />
!byte -11 <br />
!byte -5 <br />
!byte -15 <br />
!byte -11 <br />
!byte -7 <br />
!byte -3 <br />
!byte -7 <br />
!byte -5 <br />
!byte -3 <br />
; !byte -1 <br />
</syntaxhighlight><br />
===34 bytes version for C64===<br />
The C64 version was shortened by removing the ADC that indents the tree. Instead the offset to centre the tree is provided "for free" by suitably locating the EAL/EAH zp vector. This is possible because the C64 tape buffer is located immediately below the default screen location, and writing to the top line of the screen can be combined with the kernal routine to scroll the screen downward. This routine always leaves the Y register as $84, which added to the tape buffer zp vector TAPE1 points to the table ending at $3c0. The table values have their MSB clear so the centre of the tree has value $7f. When right shifted this gives an indent of $3f. The structure of the code is arranged so that the end of the binary ($3d4) plus the $3f offset give $413, ie 19 chars indented from the start of the screen matrix, centring the tree on screen. Although removing the ADC saves two bytes, one byte is lost adding the first row back into the table.<br />
<syntaxhighlight lang="6502"><br />
!cpu 6510 ; enable unintended opcodes in ACME assembler<br />
<br />
scroll_down = $E981<br />
eal = $AE<br />
tape1 = $b2<br />
<br />
*=$3c0-14<br />
; SYS 970 to draw tree<br />
; SYS 960 to draw with added "ground"<br />
<br />
table<br />
!byte 128-1<br />
!byte 128-3<br />
!byte 128-5<br />
!byte 128-7<br />
!byte 128-3<br />
!byte 128-7<br />
!byte 128-11<br />
!byte 128-15<br />
!byte 128-5<br />
!byte 128-11<br />
!byte 128-17<br />
!byte 128-23<br />
!byte 128-3<br />
!byte 128-3<br />
code <br />
-- lsr<br />
tay<br />
lda #'*'<br />
- sta (eal),y<br />
iny<br />
inx<br />
bpl -<br />
entry<br />
jsr scroll_down<br />
dec tape1<br />
lax (tape1),y<br />
bne --<br />
rts<br />
end<br />
</syntaxhighlight><br />
===33 bytes version for C64===<br />
This C64 version is most similar to the 35-byte version above. It saves 2 bytes over that version by omitting the table vector decrement, instead using the zp screen editor row variable which is incremented by the kernal with each linefeed. Fortuitously the high-byte of this vector is the "ASCII Value of Last Character Printed" which will always be $d. By locating the binary at $0dxx the table can be accessed with this vector.<br />
<syntaxhighlight lang="6502"><br />
!cpu 6510 ; enable unintended opcodes in ACME assembler<br />
<br />
crlf = $AAD7<br />
pnt = $D1<br />
lnmx = $D5<br />
tblx = $D6<br />
<br />
*=$d0b<br />
; SYS 3352 to draw tree, SYS should be typed with the cursor on row 10.<br />
<br />
table<br />
; !byte -1<br />
!byte -3<br />
!byte -5<br />
!byte -7<br />
!byte -3<br />
!byte -7<br />
!byte -11<br />
!byte -15<br />
!byte -5<br />
!byte -11<br />
!byte -17<br />
!byte -23<br />
!byte -3<br />
!byte -3<br />
code <br />
-- adc lnmx<br />
lsr<br />
tay<br />
lda #'*'<br />
- sta (pnt),y<br />
iny<br />
inx<br />
bmi -<br />
jsr crlf-8<br />
lax (tblx+1,x)<br />
bmi --<br />
rts<br />
end<br />
</syntaxhighlight><br />
===32 bytes version for ZX Spectrum===<br />
After the deadline following entry for the ZX Spectrum with only 35 bytes was submitted by reddie and optimized by char to 32 bytes:<br />
<syntaxhighlight lang="z80"><br />
# Christmas Tree post-event build, ZX Spectrum version<br />
# tnx to Manwe for info about event, better late than never =)<br />
# first version - 35 bytes - (c) reddie, 2021.12.25<br />
# optimized to 32 bytes by char, 2021.12.26 - huge thanks from me!<br />
# full final object len = 32 bytes (from label "data" to label "end")<br />
# data array len = 14 bytes; code len = 18 bytes, 13 Z80 instructions<br />
# execute from Basic only! entry point = 61455, or just run TRD image<br />
# and then run "ctree32b" Basic-program, it will load & start the code<br />
# TRD file also contains source text in ALASM format<br />
<br />
data org -16*256+1<br />
defb -5,-5,-25,-19,-13,-7,-17,-13,-9,-5,-9,-7,-5,-3<br />
<br />
start dec c<br />
jr z,$ ;stop when finished<br />
ld a,23 ;set coords via ROM procedure<br />
rst 16<br />
ld a,(bc) ;line len in negative format<br />
ld e,a<br />
rra<br />
sub b ;centering<br />
print rst 16<br />
ld a,"*"<br />
inc e<br />
jr nz,print<br />
jr start<br />
end<br />
</syntaxhighlight><br />
<br />
===35 bytes version for Plus/4===<br />
The following optimized version for the Commodore Plus/4 was created after the deadline:<br />
<syntaxhighlight lang="6502tasm"><br />
# Plus/4 Christmas Tree by GeirS, 2021-12-29<br />
# Assemble using 64tass (replace hash with semicolon first, except for 'lda #$2a')<br />
<br />
BtmRow = $0c00+$28*$18 # Address of bottom screen row<br />
Screen = BtmRow-$6c # Adjustment for ($100-$28)/2<br />
ScrollUp = $da89 # KERNAL routine to scroll screen upwards<br />
VarTab = $2d # Pointer: Start of BASIC variables<br />
<br />
* = $1001 # Load address<br />
<br />
# BASIC stub<br />
.word (NextLine),0<br />
.null $9e,format("%4d", Start)<br />
NextLine<br />
.word 0<br />
<br />
# Code and data (35 bytes total)<br />
RowLoop<br />
lsr # Calculate screen offset<br />
tay<br />
lda #$2a # Asterisk character<br />
CharLoop<br />
sta Screen,y # Put char in bottom screen row<br />
iny<br />
inx<br />
bne CharLoop # Loop for all chars<br />
Start<br />
jsr ScrollUp # Scroll the screen upwards (x=0 after)<br />
dec VarTab # Adjust address of char count to use next<br />
lax (VarTab,x) # Load char count into both a and x<br />
bmi RowLoop # Loop while not done<br />
rts<br />
<br />
# Asterisk counts (negative values to optimize the code)<br />
.char -3,-3,-23,-17,-11,-5,-15,-11,-7,-3,-7,-5,-3,-1<br />
</syntaxhighlight></div>Wilhttp://www.sizecoding.org/index.php?title=Christmas_Tree&diff=1213Christmas Tree2023-01-01T22:44:34Z<p>Wil: /* Winning entry for C64 */</p>
<hr />
<div>[[Category:Case Study]]<br />
==The challenge==<br />
During the [https://demozoo.org/parties/4398/ Vintage Computing Christmas Challenge 2021] the goal was to create the shape of a given Christmas tree with as few bytes as possible. All platforms and languages were allowed.<br />
The tree should be centered and look exactly like shown bellow.<br />
<code><br />
*<br />
***<br />
*****<br />
*******<br />
***<br />
*******<br />
***********<br />
***************<br />
***** <br />
*********** <br />
***************** <br />
*********************** <br />
***<br />
***<br />
</code><br />
There were mainly two kinds of approaches:<br />
* calculate stars using a formula<br />
* save amount of stars within data<br />
Do to the trunk of the tree, the second type was more efficient. <br />
==Winning Entries==<br />
=== Shortest DOS version ===<br />
The shortest DOS version with 44 bytes came from Hellmood:<br />
<syntaxhighlight lang=nasm><br />
org 100h ; define start of code for data access<br />
db 80 ; screen width, located at [SI], also "push ax"<br />
mov bx,d ; pointer to data for XLAT<br />
mov cx,1120 ; 14 lines with 80 chars each<br />
X: mov ax,cx ; get current sequence position<br />
div byte [si] ; transform to [X,Y] in AL, AH<br />
xlat ; get tree width for current line number<br />
sub ah,40 ; center tree in the middle<br />
jnc F ; - <br />
neg ah ; -<br />
F: sub ah,al ; inside or outside tree?<br />
salc ; set AL depending on carry flag<br />
imul ax,byte -42 ; transform into STAR or nothing<br />
int 29h ; write current char to screen<br />
loop X ; repeat unil all chars are plotter<br />
ret ; return to prompt (JMP to former AX=0x0000)<br />
d:db 2,2,12,9,6,3,8,6,4,2,4,3,2,1<br />
</syntaxhighlight><br />
=== Overall winning entry (C64) ===<br />
The shortest entry overall was for the C64 and was submitted by Serato with only 37 bytes:<br />
<syntaxhighlight lang="6502"><br />
!cpu 6510 ; enable unintended opcodes in ACME assembler<br />
<br />
chrout = $FFD2<br />
crlf = $AAD7<br />
pntr = $D3<br />
width = 40<br />
<br />
;; BASIC header<br />
*= $0801<br />
!word +, 10<br />
!byte $9e<br />
!text "2092"<br />
!byte 0<br />
+ !word 0<br />
table<br />
!byte -1 <br />
!byte -3 <br />
!byte -5 <br />
!byte -7 <br />
!byte -3 <br />
!byte -7 <br />
!byte -11 <br />
!byte -15 <br />
!byte -5 <br />
!byte -11 <br />
!byte -17 <br />
!byte -23 <br />
!byte -3 <br />
!byte -3 <br />
code<br />
-- lsr<br />
sbc #(128-width/2)<br />
sta pntr<br />
lda #'*'<br />
- jsr chrout<br />
inx<br />
bne -<br />
jsr crlf<br />
iny<br />
entry<br />
lax table,y<br />
bmi --<br />
rts<br />
end<br />
</syntaxhighlight><br />
Serato's entry was provided with the following comments:<br />
<nowiki>This entry to the Christmas Tree challenge saves space in six ways:<br />
<br />
1. Using the c64 kernal routines to output individual characters and carriage return/linefeed. These routines save/restore X/Y allowing the registers to be used as loop counters.<br />
<br />
2. Writing to the PNTR kernal variable to indent each row.<br />
<br />
3. Using the unintended LAX opcode to simultaneously load A and X with the table values.<br />
<br />
4. Storing the row widths as 2's complement negative values, to simplify the indent calculation to divide by two (LSR) and subtract (SBC). The inner loop simply counts back up to zero for rendering the correct width.<br />
<br />
5. BASIC loads the Y register from address $30d. This defaults to 0 on startup, so Y does not need to be initialised.<br />
<br />
6. Placing the table before the code in memory, the MSB of the table entries do not match the MSB of the first opcode (LSR), allowing the outer loop exit condition to be set implicitly in the Negative flag as the table values are read.<br />
<br />
These optimisations result in 37 bytes of machine code and data. Two further optimisations are possible each of which save 1 byte, but break the rules of this challenge:<br />
<br />
a - LSR and SBC can be replaced with the unintended opcode ARR, if you are willing to "centre" the tree on a virtual screen width of 32 chars.<br />
<br />
b - The BASIC interpreter leaves the line number in the zero page word at $39, so by setting the line number in the basic header to the address of the table, "LAX ($39),y" can be used for the table access.</nowiki><br />
<br />
==Optimized post-deadline versions==<br />
===36 bytes version for C64===<br />
The C64 version was shortened by altering the calculation so the default register values on start cause the first line to be drawn, shortening the table by one entry.<br />
<syntaxhighlight lang="6502"><br />
!cpu 6510 ; enable unintended opcodes in ACME assembler<br />
<br />
chrout = $FFD2<br />
crlf = $AAD7<br />
pntr = $D3<br />
width = 40<br />
<br />
;; BASIC header<br />
*= $0801<br />
!word +, 10<br />
!byte $9e<br />
!text "2074"<br />
!byte 0<br />
+ !word 0<br />
table<br />
; !byte -1 <br />
!byte -3 <br />
!byte -5 <br />
!byte -7 <br />
!byte -3 <br />
!byte -7 <br />
!byte -11 <br />
!byte -15 <br />
!byte -5 <br />
!byte -11 <br />
!byte -17 <br />
!byte -23 <br />
!byte -3 <br />
!byte -3 <br />
code<br />
-- adc #width-1<br />
lsr<br />
sta pntr<br />
lda #'*'<br />
- jsr chrout<br />
inx<br />
bmi -<br />
jsr crlf<br />
iny<br />
lax table-1,y<br />
bmi --<br />
rts<br />
end<br />
</syntaxhighlight><br />
===35 bytes version for C64===<br />
The C64 version was shortened by writing directly to the screen, saving one byte. This change prevents the Y register being used as a loop index, so a different approach is used to iterate over the table entries.<br />
<syntaxhighlight lang="6502"><br />
!cpu 6510 ; enable unintended opcodes in ACME assembler<br />
<br />
crlf = $AAD7<br />
pnt = $D1<br />
lnmx = $D5<br />
eal = $AE<br />
<br />
<br />
;; BASIC header<br />
*= $0801<br />
!word +, 10<br />
!byte $9e<br />
!text "2061"<br />
!byte 0<br />
+ !word 0<br />
<br />
code <br />
-- adc lnmx<br />
lsr<br />
tay<br />
lda #'*'<br />
- sta (pnt),y<br />
iny<br />
inx<br />
bmi -<br />
jsr crlf-8<br />
dec eal<br />
lax (eal+1,x)<br />
bmi --<br />
rts<br />
table<br />
!byte -3 <br />
!byte -3 <br />
!byte -23 <br />
!byte -17 <br />
!byte -11 <br />
!byte -5 <br />
!byte -15 <br />
!byte -11 <br />
!byte -7 <br />
!byte -3 <br />
!byte -7 <br />
!byte -5 <br />
!byte -3 <br />
; !byte -1 <br />
</syntaxhighlight><br />
===34 bytes version for C64===<br />
The C64 version was shortened by removing the ADC that indents the tree. Instead the offset to centre the tree is provided "for free" by suitably locating the EAL/EAH zp vector. This is possible because the C64 tape buffer is located immediately below the default screen location, and writing to the top line of the screen can be combined with the kernal routine to scroll the screen downward. This routine always leaves the Y register as $84, which added to the tape buffer zp vector TAPE1 points to the table ending at $3c0. The table values have their MSB clear so the centre of the tree has value $7f. When right shifted this gives an indent of $3f. The structure of the code is arranged so that the end of the binary ($3d4) plus the $3f offset give $413, ie 19 chars indented from the start of the screen matrix, centring the tree on screen. Although removing the ADC saves two bytes, one byte is lost adding the first row back into the table.<br />
<syntaxhighlight lang="6502"><br />
!cpu 6510 ; enable unintended opcodes in ACME assembler<br />
<br />
scroll_down = $E981<br />
eal = $AE<br />
tape1 = $b2<br />
<br />
*=$3c0-14<br />
; SYS 970 to draw tree<br />
; SYS 960 to draw with added "ground"<br />
<br />
table<br />
!byte 128-1<br />
!byte 128-3<br />
!byte 128-5<br />
!byte 128-7<br />
!byte 128-3<br />
!byte 128-7<br />
!byte 128-11<br />
!byte 128-15<br />
!byte 128-5<br />
!byte 128-11<br />
!byte 128-17<br />
!byte 128-23<br />
!byte 128-3<br />
!byte 128-3<br />
code <br />
-- lsr<br />
tay<br />
lda #'*'<br />
- sta (eal),y<br />
iny<br />
inx<br />
bpl -<br />
entry<br />
jsr scroll_down<br />
dec tape1<br />
lax (tape1),y<br />
bne --<br />
rts<br />
end<br />
</syntaxhighlight><br />
===33 bytes version for C64===<br />
This C64 version is most similar to the 35-byte version above. It saves 2 bytes over that version by omitting the table vector decrement, instead using the zp screen editor row variable which is incremented by the kernal with each linefeed. Fortuitously the high-byte of this vector is the "ASCII Value of Last Character Printed" which will always be $d. By locating the binary at $0dxx the table can be accessed with this vector.<br />
<syntaxhighlight lang="6502"><br />
!cpu 6510 ; enable unintended opcodes in ACME assembler<br />
<br />
crlf = $AAD7<br />
pnt = $D1<br />
lnmx = $D5<br />
tblx = $D6<br />
<br />
*=$d0b<br />
; SYS 3352 to draw tree, SYS should be typed with the cursor on row 10.<br />
<br />
table<br />
; !byte -1<br />
!byte -3<br />
!byte -5<br />
!byte -7<br />
!byte -3<br />
!byte -7<br />
!byte -11<br />
!byte -15<br />
!byte -5<br />
!byte -11<br />
!byte -17<br />
!byte -23<br />
!byte -3<br />
!byte -3<br />
code <br />
-- adc lnmx<br />
lsr<br />
tay<br />
lda #'*'<br />
- sta (pnt),y<br />
iny<br />
inx<br />
bmi -<br />
jsr crlf-8<br />
lax (tblx+1,x)<br />
bmi --<br />
rts<br />
end<br />
</syntaxhighlight><br />
===32 bytes version for ZX Spectrum===<br />
After the deadline following entry for the ZX Spectrum with only 35 bytes was submitted by reddie and optimized by char to 32 bytes:<br />
<syntaxhighlight lang="z80"><br />
# Christmas Tree post-event build, ZX Spectrum version<br />
# tnx to Manwe for info about event, better late than never =)<br />
# first version - 35 bytes - (c) reddie, 2021.12.25<br />
# optimized to 32 bytes by char, 2021.12.26 - huge thanks from me!<br />
# full final object len = 32 bytes (from label "data" to label "end")<br />
# data array len = 14 bytes; code len = 18 bytes, 13 Z80 instructions<br />
# execute from Basic only! entry point = 61455, or just run TRD image<br />
# and then run "ctree32b" Basic-program, it will load & start the code<br />
# TRD file also contains source text in ALASM format<br />
<br />
data org -16*256+1<br />
defb -5,-5,-25,-19,-13,-7,-17,-13,-9,-5,-9,-7,-5,-3<br />
<br />
start dec c<br />
jr z,$ ;stop when finished<br />
ld a,23 ;set coords via ROM procedure<br />
rst 16<br />
ld a,(bc) ;line len in negative format<br />
ld e,a<br />
rra<br />
sub b ;centering<br />
print rst 16<br />
ld a,"*"<br />
inc e<br />
jr nz,print<br />
jr start<br />
end<br />
</syntaxhighlight><br />
<br />
===35 bytes version for Plus/4===<br />
The following optimized version for the Commodore Plus/4 was created after the deadline:<br />
<syntaxhighlight lang="6502tasm"><br />
# Plus/4 Christmas Tree by GeirS, 2021-12-29<br />
# Assemble using 64tass (replace hash with semicolon first, except for 'lda #$2a')<br />
<br />
BtmRow = $0c00+$28*$18 # Address of bottom screen row<br />
Screen = BtmRow-$6c # Adjustment for ($100-$28)/2<br />
ScrollUp = $da89 # KERNAL routine to scroll screen upwards<br />
VarTab = $2d # Pointer: Start of BASIC variables<br />
<br />
* = $1001 # Load address<br />
<br />
# BASIC stub<br />
.word (NextLine),0<br />
.null $9e,format("%4d", Start)<br />
NextLine<br />
.word 0<br />
<br />
# Code and data (35 bytes total)<br />
RowLoop<br />
lsr # Calculate screen offset<br />
tay<br />
lda #$2a # Asterisk character<br />
CharLoop<br />
sta Screen,y # Put char in bottom screen row<br />
iny<br />
inx<br />
bne CharLoop # Loop for all chars<br />
Start<br />
jsr ScrollUp # Scroll the screen upwards (x=0 after)<br />
dec VarTab # Adjust address of char count to use next<br />
lax (VarTab,x) # Load char count into both a and x<br />
bmi RowLoop # Loop while not done<br />
rts<br />
<br />
# Asterisk counts (negative values to optimize the code)<br />
.char -3,-3,-23,-17,-11,-5,-15,-11,-7,-3,-7,-5,-3,-1<br />
</syntaxhighlight></div>Wilhttp://www.sizecoding.org/index.php?title=Christmas_Star&diff=1212Christmas Star2023-01-01T22:39:17Z<p>Wil: /* The challenge */</p>
<hr />
<div>[[Category:Case Study]]<br />
==The challenge==<br />
During the [https://demozoo.org/parties/4578/ Vintage Computing Christmas Challenge 2022], the goal was to create the shape of a given Christmas star with as few bytes as possible. All platforms and languages were allowed. The star should look exactly like the one shown below.<br />
<code><br />
* *<br />
** **<br />
*** ***<br />
**** ****<br />
*****************<br />
***************<br />
*************<br />
***********<br />
*********<br />
***********<br />
*************<br />
***************<br />
*****************<br />
**** ****<br />
*** ***<br />
** **<br />
* *<br />
</code><br />
There were mainly two kinds of approaches:<br />
* draw character by character<br />
* mirror triangles<br />
<br />
Program length was measured as the shortest of source, file, or "real" code (excluding basic stub and file load address). For assembler programs started with SYS or call, typically filesize minus load address (=file header) is the relevant number. A BASIC stub to start the program would also not count, but it is not allowed to use the stub#s side effects to initialize zeropage addresses.<br />
<br />
==Winning Entries==<br />
=== Winning entry for C64 ===<br />
The shortest entry for the C64 was submitted by Serato with 34 bytes (filesize 36 bytes):<br />
<syntaxhighlight lang="6502"><br />
chrout = $FFD2 ; Kernal routine outputs char in A<br />
plot = $E50C ; Kernal routine moves cursor to (y,x)<br />
pnt = $d1 ; Pointer to the start of the current screen line<br />
row = $b3 ; zp var that always starts at 3<br />
* = $1000<br />
do_2nd ldx row ; render "upside down" triangles<br />
do_line ldy #9 ; render one row of triangle, and its x-mirror image<br />
jsr plot ; move cursor to column 9 on row x<br />
ldy #17 ; start x-mirrored image in column 17<br />
lda #'*' ; the star of the show<br />
do_asks jsr chrout ; print star, advancing kernal cursor to right<br />
sta (pnt),y ; write x-mirrored star with mirrored cursor<br />
dey ; advance mirrored cursor to left<br />
cpy row ; test against line y=x to form diagonal<br />
bne do_asks <br />
cpx row ; check if these weere "upside down" triangles<br />
bne do_2nd ; if not, draw the upside down ones<br />
sys lda #$10 ; entry point of routine, start with y mirrored<br />
sec ; wish this could be avoided, feels like a wasted byte<br />
isc row ; increment bottom row counter and put (16 - row) in A<br />
tax ; we need in x register<br />
bpl do_line ; repeat until row < 0, then fall through<br />
rts<br />
</syntaxhighlight><br />
Serato's entry was provided with the following comments:<br />
<nowiki>The required octogram may be constructed as the union of four right triangles reflected four ways in x and y axes. The central loop renders one row of the triangle, plus its horizontal mirror image. The outer loop iterates over normal and mirror image screen rows. The result is all four triangles being rendered on top of each other. Saved a byte with unintended 6502 opcode ISC which combines INC and SBC to both increment a counter and load (16 minus) its value into A.</nowiki><br />
<br />
==Optimized post-deadline versions==<br />
===32 bytes version for C64===<br />
This shorter C64 version by Serato renders the union of four triangles rotated 90 degrees. To save space it iterates 256 times. It also uses a trick where the carry flag state is set by the loop comparison causing the active row to advance automatically at the end of each column. The executable code size is 32 bytes (filesize 34 bytes).<br />
<syntaxhighlight lang="6502"><br />
plot = $E50C ; Kernal routine moves cursor to (y,x)<br />
sys_h = $15<br />
pnt = $d1<br />
tblx = $d6<br />
* = $c00<br />
lda #22<br />
loop2 tay<br />
loop1 sbc #3<br />
tax<br />
jsr plot<br />
lda #'*'<br />
sta (pnt),y<br />
tya<br />
eor #$1f<br />
ldy tblx<br />
dec $2<br />
bne loop1<br />
dey<br />
cpy #10<br />
bcs loop1<br />
dec sys_h<br />
bpl loop2<br />
rts<br />
</syntaxhighlight></div>Wilhttp://www.sizecoding.org/index.php?title=Christmas_Star&diff=1211Christmas Star2023-01-01T21:46:18Z<p>Wil: /* 34 bytes version for C64 */ -> should be called 32 bytes version</p>
<hr />
<div>[[Category:Case Study]]<br />
==The challenge==<br />
During the [https://demozoo.org/parties/4578/ Vintage Computing Christmas Challenge 2022], the goal was to create the shape of a given Christmas star with as few bytes as possible. All platforms and languages were allowed. The star should look exactly like the one shown below.<br />
<code><br />
* *<br />
** **<br />
*** ***<br />
**** ****<br />
*****************<br />
***************<br />
*************<br />
***********<br />
*********<br />
***********<br />
*************<br />
***************<br />
*****************<br />
**** ****<br />
*** ***<br />
** **<br />
* *<br />
</code><br />
There were mainly two kinds of approaches:<br />
* draw character by character<br />
* mirror triangles<br />
<br />
Program length was measured as the minimum of (executable code minus file header, sourcecode). For assembler, the sourcecode version is always larger than the program, so the filesize minus load address (=file header) is the relevant number. A BASIC stub to start the program would also not count, but it is not allowed to use the stub#s side effects to initialize zeropage addresses.<br />
<br />
==Winning Entries==<br />
=== Winning entry for C64 ===<br />
The shortest entry for the C64 was submitted by Serato with 34 bytes (filesize 36 bytes):<br />
<syntaxhighlight lang="6502"><br />
chrout = $FFD2 ; Kernal routine outputs char in A<br />
plot = $E50C ; Kernal routine moves cursor to (y,x)<br />
pnt = $d1 ; Pointer to the start of the current screen line<br />
row = $b3 ; zp var that always starts at 3<br />
* = $1000<br />
do_2nd ldx row ; render "upside down" triangles<br />
do_line ldy #9 ; render one row of triangle, and its x-mirror image<br />
jsr plot ; move cursor to column 9 on row x<br />
ldy #17 ; start x-mirrored image in column 17<br />
lda #'*' ; the star of the show<br />
do_asks jsr chrout ; print star, advancing kernal cursor to right<br />
sta (pnt),y ; write x-mirrored star with mirrored cursor<br />
dey ; advance mirrored cursor to left<br />
cpy row ; test against line y=x to form diagonal<br />
bne do_asks <br />
cpx row ; check if these weere "upside down" triangles<br />
bne do_2nd ; if not, draw the upside down ones<br />
sys lda #$10 ; entry point of routine, start with y mirrored<br />
sec ; wish this could be avoided, feels like a wasted byte<br />
isc row ; increment bottom row counter and put (16 - row) in A<br />
tax ; we need in x register<br />
bpl do_line ; repeat until row < 0, then fall through<br />
rts<br />
</syntaxhighlight><br />
Serato's entry was provided with the following comments:<br />
<nowiki>The required octogram may be constructed as the union of four right triangles reflected four ways in x and y axes. The central loop renders one row of the triangle, plus its horizontal mirror image. The outer loop iterates over normal and mirror image screen rows. The result is all four triangles being rendered on top of each other. Saved a byte with unintended 6502 opcode ISC which combines INC and SBC to both increment a counter and load (16 minus) its value into A.</nowiki><br />
<br />
==Optimized post-deadline versions==<br />
===32 bytes version for C64===<br />
This shorter C64 version by Serato renders the union of four triangles rotated 90 degrees. To save space it iterates 256 times. It also uses a trick where the carry flag state is set by the loop comparison causing the active row to advance automatically at the end of each column. The executable code size is 32 bytes (filesize 34 bytes).<br />
<syntaxhighlight lang="6502"><br />
plot = $E50C ; Kernal routine moves cursor to (y,x)<br />
sys_h = $15<br />
pnt = $d1<br />
tblx = $d6<br />
* = $c00<br />
lda #22<br />
loop2 tay<br />
loop1 sbc #3<br />
tax<br />
jsr plot<br />
lda #'*'<br />
sta (pnt),y<br />
tya<br />
eor #$1f<br />
ldy tblx<br />
dec $2<br />
bne loop1<br />
dey<br />
cpy #10<br />
bcs loop1<br />
dec sys_h<br />
bpl loop2<br />
rts<br />
</syntaxhighlight></div>Wilhttp://www.sizecoding.org/index.php?title=Christmas_Star&diff=1210Christmas Star2023-01-01T21:44:51Z<p>Wil: /* Winning entry for C64 */</p>
<hr />
<div>[[Category:Case Study]]<br />
==The challenge==<br />
During the [https://demozoo.org/parties/4578/ Vintage Computing Christmas Challenge 2022], the goal was to create the shape of a given Christmas star with as few bytes as possible. All platforms and languages were allowed. The star should look exactly like the one shown below.<br />
<code><br />
* *<br />
** **<br />
*** ***<br />
**** ****<br />
*****************<br />
***************<br />
*************<br />
***********<br />
*********<br />
***********<br />
*************<br />
***************<br />
*****************<br />
**** ****<br />
*** ***<br />
** **<br />
* *<br />
</code><br />
There were mainly two kinds of approaches:<br />
* draw character by character<br />
* mirror triangles<br />
<br />
Program length was measured as the minimum of (executable code minus file header, sourcecode). For assembler, the sourcecode version is always larger than the program, so the filesize minus load address (=file header) is the relevant number. A BASIC stub to start the program would also not count, but it is not allowed to use the stub#s side effects to initialize zeropage addresses.<br />
<br />
==Winning Entries==<br />
=== Winning entry for C64 ===<br />
The shortest entry for the C64 was submitted by Serato with 34 bytes (filesize 36 bytes):<br />
<syntaxhighlight lang="6502"><br />
chrout = $FFD2 ; Kernal routine outputs char in A<br />
plot = $E50C ; Kernal routine moves cursor to (y,x)<br />
pnt = $d1 ; Pointer to the start of the current screen line<br />
row = $b3 ; zp var that always starts at 3<br />
* = $1000<br />
do_2nd ldx row ; render "upside down" triangles<br />
do_line ldy #9 ; render one row of triangle, and its x-mirror image<br />
jsr plot ; move cursor to column 9 on row x<br />
ldy #17 ; start x-mirrored image in column 17<br />
lda #'*' ; the star of the show<br />
do_asks jsr chrout ; print star, advancing kernal cursor to right<br />
sta (pnt),y ; write x-mirrored star with mirrored cursor<br />
dey ; advance mirrored cursor to left<br />
cpy row ; test against line y=x to form diagonal<br />
bne do_asks <br />
cpx row ; check if these weere "upside down" triangles<br />
bne do_2nd ; if not, draw the upside down ones<br />
sys lda #$10 ; entry point of routine, start with y mirrored<br />
sec ; wish this could be avoided, feels like a wasted byte<br />
isc row ; increment bottom row counter and put (16 - row) in A<br />
tax ; we need in x register<br />
bpl do_line ; repeat until row < 0, then fall through<br />
rts<br />
</syntaxhighlight><br />
Serato's entry was provided with the following comments:<br />
<nowiki>The required octogram may be constructed as the union of four right triangles reflected four ways in x and y axes. The central loop renders one row of the triangle, plus its horizontal mirror image. The outer loop iterates over normal and mirror image screen rows. The result is all four triangles being rendered on top of each other. Saved a byte with unintended 6502 opcode ISC which combines INC and SBC to both increment a counter and load (16 minus) its value into A.</nowiki><br />
<br />
==Optimized post-deadline versions==<br />
===34 bytes version for C64===<br />
This shorter C64 version by Serato renders the union of four triangles rotated 90 degrees. To save space it iterates 256 times. It also uses a trick where the carry flag state is set by the loop comparison causing the active row to advance automatically at the end of each column.<br />
<syntaxhighlight lang="6502"><br />
plot = $E50C ; Kernal routine moves cursor to (y,x)<br />
sys_h = $15<br />
pnt = $d1<br />
tblx = $d6<br />
* = $c00<br />
lda #22<br />
loop2 tay<br />
loop1 sbc #3<br />
tax<br />
jsr plot<br />
lda #'*'<br />
sta (pnt),y<br />
tya<br />
eor #$1f<br />
ldy tblx<br />
dec $2<br />
bne loop1<br />
dey<br />
cpy #10<br />
bcs loop1<br />
dec sys_h<br />
bpl loop2<br />
rts<br />
</syntaxhighlight></div>Wilhttp://www.sizecoding.org/index.php?title=Christmas_Star&diff=1209Christmas Star2023-01-01T21:44:18Z<p>Wil: /* The challenge */ Program length measurement explanation.</p>
<hr />
<div>[[Category:Case Study]]<br />
==The challenge==<br />
During the [https://demozoo.org/parties/4578/ Vintage Computing Christmas Challenge 2022], the goal was to create the shape of a given Christmas star with as few bytes as possible. All platforms and languages were allowed. The star should look exactly like the one shown below.<br />
<code><br />
* *<br />
** **<br />
*** ***<br />
**** ****<br />
*****************<br />
***************<br />
*************<br />
***********<br />
*********<br />
***********<br />
*************<br />
***************<br />
*****************<br />
**** ****<br />
*** ***<br />
** **<br />
* *<br />
</code><br />
There were mainly two kinds of approaches:<br />
* draw character by character<br />
* mirror triangles<br />
<br />
Program length was measured as the minimum of (executable code minus file header, sourcecode). For assembler, the sourcecode version is always larger than the program, so the filesize minus load address (=file header) is the relevant number. A BASIC stub to start the program would also not count, but it is not allowed to use the stub#s side effects to initialize zeropage addresses.<br />
<br />
==Winning Entries==<br />
=== Winning entry for C64 ===<br />
The shortest entry for the C64 was submitted by Serato with 34 bytes:<br />
<syntaxhighlight lang="6502"><br />
chrout = $FFD2 ; Kernal routine outputs char in A<br />
plot = $E50C ; Kernal routine moves cursor to (y,x)<br />
pnt = $d1 ; Pointer to the start of the current screen line<br />
row = $b3 ; zp var that always starts at 3<br />
* = $1000<br />
do_2nd ldx row ; render "upside down" triangles<br />
do_line ldy #9 ; render one row of triangle, and its x-mirror image<br />
jsr plot ; move cursor to column 9 on row x<br />
ldy #17 ; start x-mirrored image in column 17<br />
lda #'*' ; the star of the show<br />
do_asks jsr chrout ; print star, advancing kernal cursor to right<br />
sta (pnt),y ; write x-mirrored star with mirrored cursor<br />
dey ; advance mirrored cursor to left<br />
cpy row ; test against line y=x to form diagonal<br />
bne do_asks <br />
cpx row ; check if these weere "upside down" triangles<br />
bne do_2nd ; if not, draw the upside down ones<br />
sys lda #$10 ; entry point of routine, start with y mirrored<br />
sec ; wish this could be avoided, feels like a wasted byte<br />
isc row ; increment bottom row counter and put (16 - row) in A<br />
tax ; we need in x register<br />
bpl do_line ; repeat until row < 0, then fall through<br />
rts<br />
</syntaxhighlight><br />
Serato's entry was provided with the following comments:<br />
<nowiki>The required octogram may be constructed as the union of four right triangles reflected four ways in x and y axes. The central loop renders one row of the triangle, plus its horizontal mirror image. The outer loop iterates over normal and mirror image screen rows. The result is all four triangles being rendered on top of each other. Saved a byte with unintended 6502 opcode ISC which combines INC and SBC to both increment a counter and load (16 minus) its value into A.</nowiki><br />
==Optimized post-deadline versions==<br />
===34 bytes version for C64===<br />
This shorter C64 version by Serato renders the union of four triangles rotated 90 degrees. To save space it iterates 256 times. It also uses a trick where the carry flag state is set by the loop comparison causing the active row to advance automatically at the end of each column.<br />
<syntaxhighlight lang="6502"><br />
plot = $E50C ; Kernal routine moves cursor to (y,x)<br />
sys_h = $15<br />
pnt = $d1<br />
tblx = $d6<br />
* = $c00<br />
lda #22<br />
loop2 tay<br />
loop1 sbc #3<br />
tax<br />
jsr plot<br />
lda #'*'<br />
sta (pnt),y<br />
tya<br />
eor #$1f<br />
ldy tblx<br />
dec $2<br />
bne loop1<br />
dey<br />
cpy #10<br />
bcs loop1<br />
dec sys_h<br />
bpl loop2<br />
rts<br />
</syntaxhighlight></div>Wilhttp://www.sizecoding.org/index.php?title=Christmas_Star&diff=1207Christmas Star2022-12-28T21:46:33Z<p>Wil: /* The challenge */ minor language edit</p>
<hr />
<div>[[Category:Case Study]]<br />
==The challenge==<br />
During the [https://demozoo.org/parties/4578/ Vintage Computing Christmas Challenge 2022], the goal was to create the shape of a given Christmas star with as few bytes as possible. All platforms and languages were allowed. The star should look exactly like the one shown below.<br />
<code><br />
* *<br />
** **<br />
*** ***<br />
**** ****<br />
*****************<br />
***************<br />
*************<br />
***********<br />
*********<br />
***********<br />
*************<br />
***************<br />
*****************<br />
**** ****<br />
*** ***<br />
** **<br />
* *<br />
</code><br />
There were mainly two kinds of approaches:<br />
* draw character by character<br />
* mirror triangles<br />
<br />
==Winning Entries==<br />
=== Winning entry for C64 ===<br />
The shortest entry for the C64 was submitted by Serato with 34 bytes:<br />
<syntaxhighlight lang="6502"><br />
chrout = $FFD2 ; Kernal routine outputs char in A<br />
plot = $E50C ; Kernal routine moves cursor to (y,x)<br />
pnt = $d1 ; Pointer to the start of the current screen line<br />
row = $b3 ; zp var that always starts at 3<br />
* = $1000<br />
do_2nd ldx row ; render "upside down" triangles<br />
do_line ldy #9 ; render one row of triangle, and its x-mirror image<br />
jsr plot ; move cursor to column 9 on row x<br />
ldy #17 ; start x-mirrored image in column 17<br />
lda #'*' ; the star of the show<br />
do_asks jsr chrout ; print star, advancing kernal cursor to right<br />
sta (pnt),y ; write x-mirrored star with mirrored cursor<br />
dey ; advance mirrored cursor to left<br />
cpy row ; test against line y=x to form diagonal<br />
bne do_asks <br />
cpx row ; check if these weere "upside down" triangles<br />
bne do_2nd ; if not, draw the upside down ones<br />
sys lda #$10 ; entry point of routine, start with y mirrored<br />
sec ; wish this could be avoided, feels like a wasted byte<br />
isc row ; increment bottom row counter and put (16 - row) in A<br />
tax ; we need in x register<br />
bpl do_line ; repeat until row < 0, then fall through<br />
rts<br />
</syntaxhighlight><br />
Serato's entry was provided with the following comments:<br />
<nowiki>The required octogram may be constructed as the union of four right triangles reflected four ways in x and y axes. The central loop renders one row of the triangle, plus its horizontal mirror image. The outer loop iterates over normal and mirror image screen rows. The result is all four triangles being rendered on top of each other. Saved a byte with unintended 6502 opcode ISC which combines INC and SBC to both increment a counter and load (16 minus) its value into A.</nowiki></div>Wilhttp://www.sizecoding.org/index.php?title=6502&diff=108465022022-02-25T22:10:02Z<p>Wil: /* Useful Kernal functions */ Delay routines</p>
<hr />
<div>== Introduction ==<br />
Wanting to start sizecoding on a 6502 platform in this day and age can be tough. <br />
<br />
[[File:6502.jpg|thumb]]<br />
<br />
So here is a bit of help to get you started:<br />
<br />
=== The 6502 processor ===<br />
The 6502 processor can be seen as the 8-bit micro ARM chip. <br />
It has only has 3 registers (Accumulator, X and Y registers) and a handful of instructions to work with.<br />
<br />
=== Adressing modes ===<br />
To be added.<br />
<br />
=== Zero page ===<br />
When using the 6502 for sizecoding, you'll mostly be working from zeropage<br />
<br />
=== General 6502 Resources ===<br />
* 6502.org http://www.6502.org/<br />
* 6502 instruction reference http://www.6502.org/tutorials/6502opcodes.html<br />
* 6502 books http://retro.hansotten.nl/6502-sbc/<br />
* 6502 Assembler tutorial https://dwheeler.com/6502/oneelkruns/asm1step.html<br />
* Easy 6502 code tester https://skilldrick.github.io/easy6502/<br />
* Synthetic instructions https://wiki.nesdev.com/w/index.php/Synthetic_instructions#8-bit_rotate<br />
<br />
== Atari 8-bit family ==<br />
The systems in this family are: Atari 400, 800, 5200, 1200XL, 600XL, 800XL, 130XE, 65XE, 800XE and XEGS.<br /><br />
<br />
The Atari 8-bit systems consists of the 6502 with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Atari 8bit systems is quite easy, first get the following tools:<br />
<br />
* Assembler: MADS Assembler - This assembler has nice macros for creating Binaries and SNA snapshot files out of the box. You can download it at https://mads.atari8.info/<br />
* Emulator(s): I Found Altirra to work best for my usecase. Make sure to use the original Rev2 rom for best compatibility.<br />
<br />
==== Special Memory Adresses ====<br />
* FRAMECOUNTER_HIGH = 19<br />
* FRAMECOUNTER_LOW = 20<br />
<br />
=== Video display ===<br />
Video display on the Atari 8bit systems use the ANTIC and GTIA chips. Information can be found here:<br />
* https://en.wikipedia.org/wiki/ANTIC<br />
* https://www.atariarchives.org/agagd/chapter1.php<br />
<br />
==== Sync with frame ====<br />
<syntaxhighlight lang="6502"><br />
RTCLOK equ $0012<br />
lda RTCLOK+2<br />
waits<br />
cmp RTCLOK+2<br />
beq waits<br />
</syntaxhighlight><br />
<br />
Or if you don't mind trashing RTCLOK<br />
<br />
<syntaxhighlight lang="6502"><br />
RTCLOK equ $0012<br />
waits<br />
lsr RTCLOK+2<br />
bcc waits<br />
</syntaxhighlight><br />
<br />
Which is two bytes shorter.<br />
<br />
==== Getting something on screen ====<br />
<syntaxhighlight lang="6502"><br />
;fill screen with charset,(88,89)=an address<br />
org $600; free 6th page:600-6ff<br />
ldy #0<br />
fl: tya<br />
sta(88),y<br />
iny<br />
bne fl<br />
jmp *<br />
</syntaxhighlight><br />
<br />
To be added soon.<br />
<br />
<syntaxhighlight lang="6502"><br />
SDMCTL = $022f<br />
HPOSP0 = $d000<br />
SIZEP0 = $d008<br />
GRAFP0 = $d00d<br />
COLPM0 = $d012<br />
<br />
FRAMECOUNTER_HIGH = 19<br />
FRAMECOUNTER = 20<br />
WSYNC = $d40a<br />
VCOUNT = $d40b<br />
<br />
sinewave = $0600 ; to $06ff<br />
<br />
org $80<br />
<br />
main <br />
; disable all graphics/colors<br />
ldx #0<br />
stx SDMCTL <br />
<br />
ldy #$7f<br />
sty SIZEP0 ; size p0=127<br />
<br />
ldx #0<br />
ldy #$3f<br />
make_sine:<br />
value_lo<br />
lda #0<br />
clc<br />
delta_lo<br />
adc #0<br />
sta value_lo+1<br />
value_hi<br />
lda #0<br />
delta_hi<br />
adc #0<br />
sta value_hi+1<br />
<br />
sta sinewave+$c0,x<br />
sta sinewave+$80,y<br />
eor #$7f<br />
sta sinewave+$40,x<br />
sta sinewave+$00,y<br />
<br />
lda delta_lo+1<br />
adc #8<br />
sta delta_lo+1<br />
bcc nothing<br />
inc delta_hi+1<br />
nothing<br />
inx<br />
dey<br />
bpl make_sine<br />
<br />
updateloop:<br />
; vblank<br />
lda VCOUNT<br />
bne updateloop<br />
<br />
; clear graphics<br />
sta HPOSP0<br />
sta GRAFP0<br />
<br />
ldy #0<br />
lda #47<br />
sta COLPM0<br />
yloop:<br />
tya ; graphics shape = y<br />
sta WSYNC<br />
sta GRAFP0<br />
<br />
; a = sin(frame+y)+48<br />
tya <br />
adc FRAMECOUNTER<br />
tax<br />
lda sinewave,x<br />
adc #48<br />
sta HPOSP0<br />
<br />
iny<br />
bne yloop<br />
jmp updateloop<br />
<br />
run main<br />
</syntaxhighlight><br />
<br />
=== Sound ===<br />
The Atari 8-bit use the POKEY chip to generate sound.<br />
* https://en.wikipedia.org/wiki/POKEY<br />
<br />
==== BASIC ====<br />
<syntaxhighlight lang="6502"><br />
; from Analog, 1985-09,pp.25-32<br />
*=$2000<br />
AUDF1=$D200<br />
AUDC1=$D201<br />
AUDCTL=$D208<br />
SKCTL=$D20F<br />
<br />
.MACRO SOUND ; voice,pitch,dist,vol;,dur<br />
lda #%2<br />
sta AUDF1+2*%1<br />
lda #[[%3 * 16] | %4] ;lda #[[%3 shl 4] or %4]<br />
sta AUDC1+2*%1<br />
.ENDM<br />
<br />
lda #0<br />
sta AUDCTL<br />
lda #3<br />
sta SKCTL<br />
<br />
SOUND 0,121,10,8<br />
<br />
jmp *<br />
</syntaxhighlight><br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Additional Resources ===<br />
Sizecoding resource for the Atari 8bit are:<br />
* Mapping the Atari https://www.atariarchives.org/mapping/<br />
* Atari 8bit Memory map https://www.atariarchives.org/mapping/memorymap.php<br />
* Fready's undocumented 6502 opcodes https://github.com/FreddyOffenga/6502<br />
* Atari OS Rev2 disassembly for MADS assembler https://github.com/ilmenit/A800-OS-XL-Rev2<br />
* Fready's github https://github.com/FreddyOffenga/<br />
<br />
== Commodore 64 ==<br />
The Commodore system consists of a 6502-compatible MOS 6510 processor with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Commodore systems is quite easy, first get the following tools:<br />
<br />
* Assembler: To be added<br />
* Emulator(s): VICE is the way to go<br />
<br />
=== Memory map ===<br />
<br />
<syntaxhighlight lang="6502"><br />
0-1 $0-$1 PROCESSOR PORT REGISTERS, not usable as RAM<br />
0-255 $0-$FF ZEROPAGE, mostly used by BASIC interpreter and Kernal<br />
256-511 $100-$1FF SYSTEM STACK<br />
512-600 $200-$258 INPUT BUFFER<br />
601-630 $259-$276 FILE SYSTEM DATA<br />
631-640 $277-$280 KEYBOARD BUFFER, filled by Kernal ISR upon key presses <br />
641-678 $281-$2A6 VARIOUS KERNAL VARIABLES<br />
679-767 $2A7-$2FF Unused (89 byte)<br />
768-779 $300-$30B KERNAL VECTORS<br />
780-783 $30C-$30F REGISTER VALUES A,X,Y,SR for SYS<br />
784-819 $310-$333 KERNAL VECTORS<br />
820-827 $334-$33B Unused (8 byte)<br />
828-1019 $33C-$3FB DATASETTE BUFFER<br />
1020-1023 $3FC-$3FF Unused (4 byte)<br />
1024-2023 $400-$7E7 SCREEN MEMORY (25 lines times 40 columns)<br />
2024-2039 $7E8-$7F7 Unused (16 byte)<br />
2040-2047 $7F8-$7FF SPRITE COSTUME POINTERS<br />
2048 $800 must contain a value of 0 so that the BASIC program can be RUN<br />
2049-40959 $801-$9FFF BASIC AREA (code, variables, arrays, strings)<br />
40960-49151 $A000-$BFFF BASIC ROM (unused RAM underneath)<br />
49152-53247 $C000-$CFFF UPPER RAM AREA (unused)<br />
53248-53294 $D000-$D02E VIC-II, memory-mapped graphics chip registers)<br />
54272-54300 $D400-$D41C SID, memory-mapped sound chip registers)<br />
55296-56295 $D800-$DBE7 Color RAM, only lower 4 bits are stored, higher nibble undefined<br />
56296-56319 $DBE8-$DBFF Unused (24 half-bytes)<br />
56320-56335 $DC00-$DC0F CIA#1, memory-mapped I/O chip registers for keyboard, joystick, mouse, datasette, IRQ control<br />
56576-56591 $DD00-$DD0F CIA#1, memory-mapped I/O chip registers for serial bus, RS232, NMI control<br />
57344-65535 $E000-$FFFF KERNAL ROM<br />
65534-65535 $FFFE-$FFFF Execution address of interrupt service routine, can only be set if KERNAL is turned off<br />
</syntaxhighlight><br />
<br />
For a detailed explanation of the C64 memory map check out [https://sta.c64.org/cbm64mem.html Commodore 64 memory map] on Joe Forster/STA homepage.<br />
<br />
=== Program file overhead ===<br />
<br />
A standard CBM file consists of a 2 byte loading address followed by the data that is placed into memory starting at this address. In addition, if your machine program should be able to be started with "RUN", you need a BASIC stub that is loaded into memory from $0801 to $080c, typically followed by your machine program:<br />
<br />
<syntaxhighlight lang="6502"><br />
*=$0801<br />
.word $080b ;address of next BASIC line<br />
.word LINENO ;line number, can be chosen between 0 and 63999<br />
.byte $9e ;token for SYS command<br />
.byte $32,$30,$35,$39 ;address to jump to in ASCII code: "2059" <br />
.byte $00 ;end of BASIC line<br />
start lax #0 ;actually address of next BASIC line, $xx00 means end of BASIC program, use $xx for an opcode<br />
; your code here<br />
</syntaxhighlight><br />
<br />
Together with the 2 byte load address, this makes an overhead of 14 bytes for your program, coming with A and X initialised to 0. To reduce this, you can<br />
* omit the BASIC line and tell users to start your program by directly entering "SYS ''address''"<br />
* save your program from $0802 on, the byte at $0801 is recovered automatically after loading by the relink function. This reduces your program file size by 1 byte<br />
* accept the loss and use the 2 byte establishing LINENO for something good, they are copied to zeropage addresses $39/$3a automatically, saving you the effort of initializing the addresses<br />
* use an autostart method (see below)<br />
<br />
Some compos also specify that the BASIC loader does not count towards the overall filesize, check the rules before you worry.<br />
<br />
=== Autostart ===<br />
<br />
Unlike the Commodore 128, the Commodore 64 has no dedicated built-in auto-boot feature, but it is possible to autorun a program after loading by specifying the load address so that it overwrites a vector or address that is called by the operating system. There are multiple possibilities:<br />
<br />
==== Overwriting CHROUT vector at $326-$327 ====<br />
<br />
The vector at address $326-$327 points at the CHROUT routine, normally at address $F1CA.<br />
If you put the entry address of your program into $326/27, your code will be called when the operating system wants to print "READY." after loading.<br />
Note that the vector at address $328-$329 points at the STOP routine that checks the status of Stop key indicator. Since this routine is called multiple times before your code is done loading, its default value $F6ED needs to be preserved. <br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$0326<br />
.word start <br />
.byte $ed,$f6<br />
start<br />
; rest of code<br />
</syntaxhighlight><br />
<br />
Together with the two byte load address, the overwritten CHROUT vector and the preserved STOP vector, your program file will have a deadweight of 6 byte: $26 $03 $0a $03 $ed $f6, less than half of the standard version with a BASIC stub with SYS<br />
<br />
Caveat:<br />
* If your program after $32a is longer than 214 byte, part of your program will load into the screen at $400. Thus, issuing a clear screen will overwrite your program. It is possible to move the screen memory somewhere else, but that requires storing a new value into address $D018, which when done with an LDA # / STA pair will cost you 5 byte<br />
* Since you changed the CHROUT pointer, standard KERNAL functions for printing won't work. For output of single characters, you can still use the direct address $F1CA. Alternatively, you can restore the vectors by calling $FD15, which will overwrite the memory $314 to $333 with the default values.<br />
* The memory area $33C-$3FB is the datasette buffer, thus loading a program into this area won't work when loading from a cassette.<br />
<br />
==== Overwriting BASIC idle loop vector at $302-$303 ====<br />
<br />
After loading the program, the BASIC idle loop will be called. By overwriting the vector at $302/$303 it is possible to autostart your program. Since the memory before $302 can be safely overwritten, the program would be arranged so that $303 is the '''last''' address of your program. If your program requires a loop back to the start, the vector can be used as part of a JMP where the following two bytes are already there, saving one byte in comparison to a loop done with a branch command.<br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$304 - (end - start)<br />
start:<br />
;your code here<br />
; ...<br />
jmp start ;the address for start lies in $302/$303, thus will be called by the Kernal after loading<br />
end:<br />
</syntaxhighlight><br />
<br />
In cases where the vector has a practical use, the overhead in filesize is only the 2 byte loading address. For programs larger than 93 byte keep in mind that addresses before $2A7 are in use by the Kernal.<br />
<br />
==== Overwriting return address on stack at $1F8 ====<br />
<br />
When the load routine is called, the stack pointer is always at $FA at a stock C64. Thus the return address from the loading process is stored in memory address $1F8 (low byte) and $1F9 (high byte). During the loading routine, stack usage will clobber the stack below $1F8, but a program loaded to $1F8 and above will be fine and the overwritten address stored at $1F8/$1F9 will be called after loading.<br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$1F8<br />
.word start-1 ;adjust for the RTS command pulling the address from stack and increasing it by 1<br />
start:<br />
;your code here<br />
</syntaxhighlight><br />
<br />
For programs larger than 95 byte keep in mind that addresses after $259 are in use by the Kernal, you might overwrite some values here if you don't have disk operations, but better check the memory map beforehand.<br />
<br />
Together with the two byte load address and the overwritten address at $1F8/$1F9, your program file will have a deadweight of 4 byte when using this method.<br />
<br />
==== Putting your program into zeropage overwriting part of CHRGET ====<br />
<br />
CHRGET is a machine code routine for the BASIC interpreter that is placed in the zero page at $73-$8A. By putting your program at $7C and following, the CHRGET routine runs directly into your code.<br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$7C<br />
start:<br />
;your code here<br />
</syntaxhighlight><br />
<br />
With this method, there is no need for a start address vector. The only deadweight in your program is the loading address. However, the zero page is a busy place, if your program extends beyond address $8f (that is it has more than 22 bytes on disk) you have to deal with some parts of your program being overwritten, for example, the status byte in $90 is set after loading.<br />
<br />
Loading data into address $A9 has an interesting side effect - the vector of $AE/$AF defines the address where the loaded bytes are written to. If $AE gets overwritten with, for example, $40, the next byte will be written to $41 (because the vector is incremented after the write). This can be used to split your program into different parts of memory.<br />
<br />
=== Video display ===<br />
Video display on the Commodore has the following native video modes:<br />
* Standard text mode, 40x25 characters, 1 individual foreground color per character, 1 common background color<br />
* Multicolor text mode, 40x25 characters, only 8 foreground colors, can be mixed with hires chars, foreground < 8 denotes a hires char, with foreground >= 8 a pair of two bits (brick pixel) define color: background, foreground & %111, common color 1+2<br />
* Extended background color text mode, 40x25 characters, 1 individual foreground color per character, 1 out of 4 background colors, only 64 chars<br />
* Hires bitmap, 320x200 pixels, an 8x8 field can have an individual foreground and an individual background color<br />
* Multicolor bitmap, 160x200 pixels, a pair of two bits (brick pixel) define color: background, screen color lower nibble, screen color higher nibble, color from color RAM<br />
<br />
==== Sync with frame ====<br />
<br />
Depending on the VIC type, there are 262/263 raster lines (NTSC) or 312 raster lines (PAL-B). Therefore, the VIC uses register at $D012 and the highest bit of register $D011 to represent the current raster line. Checking only the lower 8 bits and waiting for them to be 0 would therefore not work because this happens two times per frame. However, any number greater than 64 will only trigger once. Using a value of 255, we would sync to a rasterline at the end of the screen, well below the part where graphics are normally displayed:<br />
<br />
<syntaxhighlight lang="6502"><br />
waitsync:<br />
ldx $D012<br />
inx<br />
bne waitsync<br />
</syntaxhighlight><br />
<br />
As long as there have more than 63 cycles passed since the snyc, the next sync will happen at the next frame.<br />
This works fine as long as we don't miss the line 255 due to an interrupt. If your program has interrupts that are not synced to a rasterline, you can change the condition as follows<br />
<syntaxhighlight lang="6502"><br />
lda #$E3<br />
waitsync:<br />
cmp $D012<br />
bcs waitsync<br />
</syntaxhighlight><br />
<br />
Now we have a window between raster line $E4 and $FF to trigger our sync, which we will meet even if a standard Kernal interrupt comes in-between. Of course, our main program now has to burn around 1700 cycles to avoid a retriggering in the same frame.<br />
<br />
==== Getting something on screen ====<br />
<br />
Output a character:<br />
<syntaxhighlight lang="6502"><br />
lda #C ;C must be the char code according to the PETSCII code table<br />
jsr $FFD2 ;you can also use the direct address $FC1A, function preserves A,X,Y and enables interrupt<br />
</syntaxhighlight><br />
<br />
Since the [https://en.wikipedia.org/wiki/PETSCII#Character_set PETSCII code table] contains also control characters, this method can be also used to clear the screen, move the cursor or set the text color. However, some functions are shorter (and faster) by directly calling the respective KERNAL function:<br />
<br />
<syntaxhighlight lang="6502"><br />
Clear screen JSR $E544<br />
Cursor home position JSR $E566<br />
Output newline character JSR $AAD7<br />
Set text color LDA #COLOR, STA $286<br />
Set border color LDA #COLOR, STA $D020 ;not possible with a PETSCII control code<br />
Set background color LDA #COLOR, STA $D021 ;not possible with a PETSCII control code<br />
</syntaxhighlight><br />
<br />
Copy characters directly to screen memory:<br />
<br />
<syntaxhighlight lang="6502"><br />
.macpack cbm ;scrcode macro<br />
SCREEN_BASE=$400<br />
LINE=5 ;for example<br />
COLUMN=10 ;for example<br />
<br />
ldx #endtext-text-1<br />
@loop: lda text,x<br />
sta SCREEN_BASE+LINE*40+COLUMN,x<br />
dex<br />
bpl @loop<br />
text: scrcode "hello world!"<br />
endtext:<br />
</syntaxhighlight><br />
<br />
Note that the text needs to be stored in '''screen code''' format, not in PETSCII (see [https://sta.c64.org/cbm64pettoscr.html Commodore 64 PETSCII code to screen code conversion] for the differences). Furthermore, the example above only writes to the screen memory, not the color RAM, assuming that the color RAM already contains the intended text color. This is the case after issuing a clear screen on most C64 machines, except for some old ROM revisions. To be on the save side you would have to write to color RAM as well, which costs another 5 byte:<br />
<br />
<syntaxhighlight lang="6502"><br />
.macpack cbm ;scrcode macro<br />
SCREEN_BASE=$400<br />
COLOR_RAM =$D800<br />
LINE =5 ;for example<br />
COLUMN =10 ;for example<br />
COLOR =1 ;white<br />
<br />
ldx #endtext-text-1<br />
@loop: lda text,x<br />
sta SCREEN_BASE+LINE*40+COLUMN,x<br />
lda #COLOR<br />
sta COLOR_RAM +LINE*40+COLUMN,x<br />
dex<br />
bpl @loop<br />
text: scrcode "hello world!"<br />
endtext:<br />
</syntaxhighlight><br />
<br />
=== Sound ===<br />
The Commodore 64 uses the famous SID chip to generate sound.<br />
To be added soon.<br />
<br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Useful Kernal functions ===<br />
<br />
==== Get a pseudo random number ====<br />
<br />
<syntaxhighlight lang="6502"><br />
lda #1 <br />
jsr $E09A<br />
lda $63<br />
</syntaxhighlight><br />
<br />
The sequence of random numbers is always the same after a cold start or reset, the first 20 numbers are:<br />
<syntaxhighlight lang="6502"><br />
4,24,231,4,177,170,193,101,231,18,196,1,75,48,149,36,124,53,65,154<br />
</syntaxhighlight><br />
<br />
==== Delay 1 Millisecond ====<br />
<br />
<syntaxhighlight lang="6502"><br />
jsr $EEB3<br />
</syntaxhighlight><br />
<br />
==== Delay ~ 2 Seconds ====<br />
<br />
This is actually Commodore's memory testing routine that is run every time the computer is turned on. Execution takes about 2 seconds to execute.<br />
<br />
<syntaxhighlight lang="6502"><br />
jsr $FD68<br />
</syntaxhighlight><br />
<br />
==== Increment a zero page counter, return in X register, clear Y register ====<br />
<br />
This is part of the string handling function in the BASIC ROM, but the code could be useful for some loop stuff.<br />
<br />
<syntaxhighlight lang="6502"><br />
jsr $B5FF ;does inc $23, ldx $23, ldy #$00, rts<br />
</syntaxhighlight><br />
<br />
=== Additional Resources ===<br />
* Codebase 64 https://codebase64.org/doku.php?id=base:start<br />
* Commodore 64 Memory map https://sta.c64.org/cbm64mem.html<br />
* C64 BASIC & KERNAL ROM Disassembly https://www.pagetable.com/c64ref/c64disasm/<br />
* No More Secrets https://csdb.dk/release/?id=198357 Everything about illegal opcodes and their use in a C64 system<br />
<br />
== Apple II ==<br />
The Apple II is an 8-bit home computer and one of the world's first highly successful mass-produced microcomputer products. It was designed primarily by Steve Wozniak.<br />
<br />
=== Setting up ===<br />
* ACME 6502 cross-assembler(https://sourceforge.net/projects/acme-crossass/)<br />
* Apple Commander (http://applecommander.sourceforge.net) for batch compilation<br />
* AppleWin emulator (https://github.com/AppleWin/AppleWin/releases). Supports Mockingboard card(AY-8910+speech synthesier), HDD, Z80 card(for CP/M), mouse etc.<br />
* CiderPress(https://a2ciderpress.com)<br />
<br />
Compilation can be done as follows (master.dsk can be found with applewin) <br />
<syntaxhighlight><br />
acme hl.asm<br />
java -jar AppleCommander-1.3.5.jar -d master.dsk hl<br />
java -jar AppleCommander-1.3.5.jar -p master.dsk hl B 24576 < hl.bin<br />
</syntaxhighlight><br />
<br />
=== Memory Map ===<br />
<syntaxhighlight lang="6502"><br />
0-255 $0-$FF ZERO-PAGE SYSTEM STORAGE<br />
256-511 $100-$1FF SYSTEM STACK<br />
512-767 $200-$2FF KEYBOARD CHARACTER BUFFER<br />
768-975 $300-$3CF OFTEN AVAILABLE AS FREE SPACE FOR USER PROGRAMS<br />
976-1023 $3D0-3FF SYSTEM VECTORS<br />
1024-2047 $400-$7FF TEXT AND LO-RES GRAPHICS PAGE 1 <--- !!!<br />
2048-LOMEM $800-LOMEM PROGRAM STORAGE<br />
2048-3071 $800-$BFF TEXT AND LO-RES GRAPHICS PAGE 2 OR FREE SPACE<br />
3072-8191 $C00-$1FFF FREE SPACE UNLESS RAM APPLESOFT IS IN USE<br />
8192-16383 $2000-$3FFF HI-RES PAGE 1 OR FREE SPACE <--- !!!<br />
16384-24575 $4000-$5FFF HI-RES PAGE 2 OR FREE SPACE<br />
24576-38999 $6000-$95FF FREE SPACE AND STRING STORAGE<br />
38400-49151 $9600-$BFFF DOS<br />
49152-53247 $C000-$CFFF I/O HARDWARE (RESERVED)<br />
53248-57343 $D000-$DFFF APPLESOFT IN LANGUAGE CARD OR ROM<br />
57344-63487 $E000-$F7FF APPLESOFT OR INTEGER BASIC IN LANGUAGE CARD OR ROM<br />
63488-65535 $F800-$FFFF SYSTEM MONITOR<br />
</syntaxhighlight><br />
<br />
=== Display ===<br />
<br />
=== Graphics Modes ===<br />
: Text Mode 40x24, for Apple IIe available 80x25 - use PR#3 for switch mode, or hardware switch<br />
: LowRes 40x48, 16 colors: https://en.wikipedia.org/wiki/Apple_II_graphics <br />
: Hires mode 280x192,6 colors: https://www.xtof.info/blog/?p=768<br />
https://mrob.com/pub/xapple2/colors.html<br />
https://archive.org/details/HiRes_Color_Graphics_on_the_Apple_II_Computer_by_Wozniak<br />
<br />
However for sizecoding, you almost never want to do direct-access to graphics for Apple II in size-coding because the Apple II graphics modes are horrible. The only fast way to do things is with large lookup tables. To do hires you need to divide by 7 which as you can imagine is a bit difficult to do compactly on 6502. Double-hires is even crazier on top of that. Deater did manage a color-bar style effect in double-hires in 128B but that was doing some crazy tricks with the firmware BASIC routines, definitely not direct-access.<br />
<br />
Lores and Hires can be mixed modes and full-graphics<br />
The screen structure is called memory holes(https://retrocomputing.stackexchange.com/questions/2534/what-are-the-screen-holes-in-apple-ii-graphics). The GBASCALC($F847) procedure is used to calculate the address of the horizontal line : IN:reg.A=Y, out : GBASL/GBASH($26/$27)=address. See also https://www.callapple.org/uncategorized/use-of-apple-ii-color-graphics-in-assembly-language/<br />
<br />
==== Getting something on screen ====<br />
Here is an example of a XOR texture, created by g0blinish<br />
<syntaxhighlight lang="6502"><br />
*=$6000<br />
!to "HL.bin", plain ; set output file and format<br />
!cpu 6502 ; set processor type<br />
<br />
GBASL = $26<br />
GBASH = $27<br />
SETGR = $FB40 ; setup LoRes<br />
GBASCALC = $F847 ; calc Address<br />
<br />
CLRTEXT = $C050 ;display graphics <br />
SETTEXT = $C051 ;display text <br />
<br />
CLRMIXED = $C052 ;clear mixed mode- enable full graphics <br />
SETMIXED = $C053 ;enable graphics/text mixed mode <br />
<br />
PAGE1 = $C054 ;select text/graphics page1 <br />
PAGE2 = $C055 ;select text/graphics page2 <br />
<br />
CLRHIRES = $C056 ;select Lo-res <br />
SETHIRES = $C057 ;select Hi-res <br />
<br />
TMP= $FA<br />
<br />
JSR SETGR ;GR<br />
BIT CLRMIXED ; full screen<br />
<br />
LDA #0 ; A=0<br />
STA TMP ; POKE $FA,A<br />
<br />
YLP ;<br />
LDA TMP ; A=PEEK($FA)<br />
; LSR ; A=A/2<br />
JSR GBASCALC<br />
LDY #0;Y=0<br />
<br />
XLP TYA ; A=Y<br />
EOR TMP ; A=A xor PEEK($FA)<br />
and #$0F ; A=A and 15<br />
TAX ; X=A<br />
LDA COLORS,X ;A=PEEK(COLORS+X)<br />
STA(GBASL),Y ; POKE PEEK($26)+256*PEEK($27)+Y,A<br />
INY ; Y=Y+1<br />
CPY #40 ; Y=40?<br />
BNE XLP<br />
INC TMP ; POKE $FA,PEEK($FA)+1<br />
LDA TMP ; A=PEEK($FA)<br />
CMP #24 ; A=24?<br />
BNE YLP<br />
<br />
M1 JMP M1 ; replace to RTS<br />
<br />
COLORS ;N*17, pixel format is AAAABBBB, AAAA - upper dot, BBBB - lower dot<br />
!byte $00,$11,$22,$33,$44,$55,$66,$77<br />
!byte $88,$99,$AA,$BB,$CC,$DD,$EE,$FF<br />
</syntaxhighlight><br />
<br />
==== Sound ====<br />
Here is an example for using the speaker, based onthe following basic program:<br />
<br />
<syntaxhighlight lang="basic"><br />
; 50 POKE 768,V: POKE 769,P - 255 * INT (P / 256): POKE 800,1 + P / 256<br />
; 60 CALL 770: RETURN <br />
; 95 FOR K = 1 TO N: READ V(K),P(K): NEXT K<br />
; 100 FOR K = 1 TO N:V = V(K):P = P(K)<br />
; 110 GOSUB 50<br />
;!byte 173,48,192,136,208,5,206,1,3,240,9,202,208,245,174,0,3,76,2,3,206,32,3,208,240,96<br />
</syntaxhighlight><br />
<br />
<syntaxhighlight lang="6502"><br />
*=$6000<br />
!to "HL.bin", plain ; set output file and format<br />
!cpu 6502 ; set processor type<br />
<br />
;start<br />
; 95 FOR K = 1 TO N: READ V(K),P(K): NEXT K<br />
; 100 FOR K = 1 TO N:V = V(K):P = P(K)<br />
ini:<br />
lda #70<br />
sta cnt+1<br />
lda #music&255<br />
sta gotbyte+1<br />
lda #music/256<br />
sta gotbyte+2<br />
<br />
lop:<br />
;V<br />
jsr gotbyte<br />
sta L300<br />
jsr gotbyte<br />
;P<br />
jsr gotbyte<br />
sta L301<br />
jsr gotbyte<br />
clc<br />
adc #1<br />
sta L320<br />
jsr beep<br />
<br />
dec cnt+1<br />
cnt lda #70<br />
bne lop<br />
; 110 GOSUB 50<br />
; 50 POKE 768,V: POKE 769,P - 255 * INT (P / 256): POKE 800,1 + P / 256<br />
; 60 CALL 770: RETURN <br />
jmp ini<br />
gotbyte<br />
lda music<br />
inc gotbyte+1<br />
bne noinch<br />
inc gotbyte+2<br />
noinch<br />
rts<br />
;!byte 173,48,192,136,208,5,206,1,3,240,9,202,208,245,174,0,3,76,2,3,206,32,3,208,240,96<br />
beep:<br />
ldy #1<br />
ldx #1<br />
loc_302:<br />
LDA $C030<br />
<br />
loc_305:<br />
DEY<br />
BNE loc_30D<br />
DEC L301<br />
loc_30B:<br />
BEQ loc_316<br />
<br />
loc_30D:<br />
DEX<br />
BNE loc_305<br />
LDX L300<br />
JMP loc_302<br />
loc_316:<br />
DEC L320<br />
BNE loc_30B<br />
RTS<br />
L301 !byte 0<br />
L300 !byte 0<br />
L320 !byte 0<br />
music<br />
!word 76,192,85,64,96,64,102,64,114,128,114,64,96,64,102,64,114,64,128,64<br />
!word 114,64,152,64,171,64,152,512,76,192,85,64,96,64,102,64,114,128,114,64<br />
!word 96,64,102,64,114,64,128,64,114,64,152,64,171,64,152,512,85,64,85,64<br />
!word 85,64,96,64,144,128,144,64,128,64,76,128,85,64,96,64,144,128,114,64<br />
!word 96,64,102,128,114,64,128,64,128,128,114,64,128,64,114,512,85,64,85,64<br />
!word 85,64,96,64,144,128,144,64,128,64,76,128,85,64,96,64,144,128,114,64<br />
!word 96,64,102,128,114,64,128,64,128,64,128,128,96,64,85,64,96,64,102,64,114,64,114,64<br />
</syntaxhighlight><br />
<br />
=== Additional Resources ===<br />
* Deater's page on Apple II sizecoding http://www.deater.net/weave/vmwprod/demos/sizecoding.html (with an additional presentation at https://www.youtube.com/watch?v=kJ-EXbnw0kQ )<br />
* Article on double hi-res http://www.battlestations.zone/2017/04/apple-ii-double-hi-res-from-ground-up.html<br />
* Applesoft Hi-Res Subroutines : http://hackzapple.org/scripts_php/index.php?menu=5&mod=ASM&sub=AAL&sub2=8112&PHPSESSID=f65fabfd0cdbf56b6bdc0ddac25117c6#a2<br />
<br />
== Atari Lynx ==<br />
The Atari Lynx consists of the 65C02 with custom hardware for graphics and sound.<br><br />
If you come from Atari 8bit or Apple, there are no illegal opcodes anymore like <b>lax</b>, but a lot new nice opcodes like <b>stz</b>. :-)<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Atari Lynx:<br />
<br />
* Assembler:<br />
Below size coding examples use [https://github.com/42Bastian/lyxass Lyxass] as assembler and are using the in-official DevKit [https://github.com/42Bastian/new_bll new_bll].<br><br />
But any other 6502 assembler is suitable. Best if it can assemble the extra opcodes of the 65C02 (like <b>BBRx</b> or <b>RMBx</b>).<br />
<br />
* Encryption<br />
The Lynx boot ROM will decrypt the "boot sector" of a Lynx card image. It is done in chunks of 50bytes. Maximum are 5 chunks, hence the limit of a "boot sector" is 250 bytes, but the last byte <b>must</b> be zero.<br />
<br />
* Emulator(s): <br />
Currently Felix is the most accurate Emulator, though only running yet on Windows platform.<br><br />
It is currently available via [https://github.com/laoo/Felix GitHub].<br />
<br />
* Hardware:<br />
If you want to run the code on a real Lynx, you should have a SD card for the Lynx (AgaCard, LynxGD) and also a USB<->Serial adapter.<br />
<br />
=== Initial values ===<br />
After the boot-rom has decrypted the boot-sector, some things are pre-defined:<br />
* CPU Registers:<br />
A = 0<br />
X = 0<br />
Y = 2<br />
P = undefined<br />
S = undefined<br />
<br />
* Zero page<br />
<br />
$00 - 0<br />
$01 - 0<br />
$02 - 0<br />
<br />
* Main<br />
<br />
Main memory is cleared to zero despite a $5000..%$50aa where decryption code is placed.<br />
<br />
* Bank switching<br />
<br />
ROM, Mikey and Suzy are mapped, Vector table is ROM.<br />
<br />
* Suzy<br />
The sprite engine is <b>not</b> setup.<br />
<br />
<br />
<br />
=== Video display ===<br />
The Lynx display is 160x102 pixels which are linear organized as 4 bit per pixel. Hence the screen is little less than 8K.<br />
The pixel value is a pointer to the color look up table.<br />
The Lynx can display black and 4095 colors. The color table is split up into a green and an blue-red part (so not RGB but GBR).<br />
<br />
==== Getting something on screen ====<br />
After the ROM has deciphered the boot sector the display memory is at $2000, background color (that is pen 0) is black, all other entries are $f despite entry 14 which is also 0.<br />
<br />
So to fill the screen simply do:<br />
<pre><br />
lda #$ff<br />
ldx #0<br />
ldy #$20 ; round(160*102/2/256)<br />
loop:<br />
sta $2000,x<br />
inx<br />
bne loop<br />
inc loop+2 ; Self modify<br />
dey<br />
bne loop<br />
</pre><br />
<br />
=== Tips 'n' tricks ===<br />
A nice trick with the new opcodes to limit a counter:<br />
* 6502<br />
lda counter ; 2<br />
inc ; 1<br />
and #3 ; 2<br />
sta counter ; 2 = 7 bytes<br />
<br />
* 65C02<br />
inc counter ; 2<br />
rmb2 counter ; 2 => 4 bytes<br />
<br />
Set a counter (previously 0) to a power-of-two (here 32)<br />
<br />
* 6502<br />
lda #32 ; 2<br />
sta counter ; 2 => 4<br />
<br />
* 65C02<br />
smb5 counter ; 2<br />
<br />
<br />
=== Sound ===<br />
To be added soon.<br />
<br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Additional Resources ===<br />
*[https://www.monlynx.de/lynx/lynxdoc.html Hardware documentation]<br />
*[https://github.com/42Bastian/lynx_hacking/tree/master/248b Size coding examples.]<br />
*[https://github.com/42Bastian/lynx-encryption-tools Lynx encryption-tools]</div>Wilhttp://www.sizecoding.org/index.php?title=6502&diff=99865022022-01-10T21:32:31Z<p>Wil: /* Overwriting return address on stack at $1F8 */ missed high byte for address</p>
<hr />
<div>== Introduction ==<br />
Wanting to start sizecoding on a 6502 platform in this day and age can be tough. <br />
<br />
[[File:6502.jpg|thumb]]<br />
<br />
So here is a bit of help to get you started:<br />
<br />
=== The 6502 processor ===<br />
The 6502 processor can be seen as the 8-bit micro ARM chip. <br />
It has only has 3 registers (Accumulator, X and Y registers) and a handful of instructions to work with.<br />
<br />
=== Adressing modes ===<br />
To be added.<br />
<br />
=== Zero page ===<br />
When using the 6502 for sizecoding, you'll mostly be working from zeropage<br />
<br />
=== General 6502 Resources ===<br />
* 6502.org http://www.6502.org/<br />
* 6502 instruction reference http://www.6502.org/tutorials/6502opcodes.html<br />
* 6502 books http://retro.hansotten.nl/6502-sbc/<br />
* 6502 Assembler tutorial https://dwheeler.com/6502/oneelkruns/asm1step.html<br />
* Easy 6502 code tester https://skilldrick.github.io/easy6502/<br />
* Synthetic instructions https://wiki.nesdev.com/w/index.php/Synthetic_instructions#8-bit_rotate<br />
<br />
== Atari 8-bit family ==<br />
The systems in this family are: Atari 400, 800, 5200, 1200XL, 600XL, 800XL, 130XE, 65XE, 800XE and XEGS.<br /><br />
<br />
The Atari 8-bit systems consists of the 6502 with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Atari 8bit systems is quite easy, first get the following tools:<br />
<br />
* Assembler: MADS Assembler - This assembler has nice macros for creating Binaries and SNA snapshot files out of the box. You can download it at https://mads.atari8.info/<br />
* Emulator(s): I Found Altirra to work best for my usecase. Make sure to use the original Rev2 rom for best compatibility.<br />
<br />
==== Special Memory Adresses ====<br />
* FRAMECOUNTER_HIGH = 19<br />
* FRAMECOUNTER_LOW = 20<br />
<br />
=== Video display ===<br />
Video display on the Atari 8bit systems use the ANTIC and GTIA chips. Information can be found here:<br />
* https://en.wikipedia.org/wiki/ANTIC<br />
* https://www.atariarchives.org/agagd/chapter1.php<br />
<br />
==== Sync with frame ====<br />
<syntaxhighlight lang="6502"><br />
RTCLOK equ $0012<br />
lda RTCLOK+2<br />
waits<br />
cmp RTCLOK+2<br />
beq waits<br />
</syntaxhighlight><br />
<br />
Or if you don't mind trashing RTCLOK<br />
<br />
<syntaxhighlight lang="6502"><br />
RTCLOK equ $0012<br />
waits<br />
lsr RTCLOK+2<br />
bcc waits<br />
</syntaxhighlight><br />
<br />
Which is two bytes shorter.<br />
<br />
==== Getting something on screen ====<br />
<syntaxhighlight lang="6502"><br />
;fill screen with charset,(88,89)=an address<br />
org $600; free 6th page:600-6ff<br />
ldy #0<br />
fl: tya<br />
sta(88),y<br />
iny<br />
bne fl<br />
jmp *<br />
</syntaxhighlight><br />
<br />
To be added soon.<br />
<br />
<syntaxhighlight lang="6502"><br />
SDMCTL = $022f<br />
HPOSP0 = $d000<br />
SIZEP0 = $d008<br />
GRAFP0 = $d00d<br />
COLPM0 = $d012<br />
<br />
FRAMECOUNTER_HIGH = 19<br />
FRAMECOUNTER = 20<br />
WSYNC = $d40a<br />
VCOUNT = $d40b<br />
<br />
sinewave = $0600 ; to $06ff<br />
<br />
org $80<br />
<br />
main <br />
; disable all graphics/colors<br />
ldx #0<br />
stx SDMCTL <br />
<br />
ldy #$7f<br />
sty SIZEP0 ; size p0=127<br />
<br />
ldx #0<br />
ldy #$3f<br />
make_sine:<br />
value_lo<br />
lda #0<br />
clc<br />
delta_lo<br />
adc #0<br />
sta value_lo+1<br />
value_hi<br />
lda #0<br />
delta_hi<br />
adc #0<br />
sta value_hi+1<br />
<br />
sta sinewave+$c0,x<br />
sta sinewave+$80,y<br />
eor #$7f<br />
sta sinewave+$40,x<br />
sta sinewave+$00,y<br />
<br />
lda delta_lo+1<br />
adc #8<br />
sta delta_lo+1<br />
bcc nothing<br />
inc delta_hi+1<br />
nothing<br />
inx<br />
dey<br />
bpl make_sine<br />
<br />
updateloop:<br />
; vblank<br />
lda VCOUNT<br />
bne updateloop<br />
<br />
; clear graphics<br />
sta HPOSP0<br />
sta GRAFP0<br />
<br />
ldy #0<br />
lda #47<br />
sta COLPM0<br />
yloop:<br />
tya ; graphics shape = y<br />
sta WSYNC<br />
sta GRAFP0<br />
<br />
; a = sin(frame+y)+48<br />
tya <br />
adc FRAMECOUNTER<br />
tax<br />
lda sinewave,x<br />
adc #48<br />
sta HPOSP0<br />
<br />
iny<br />
bne yloop<br />
jmp updateloop<br />
<br />
run main<br />
</syntaxhighlight><br />
<br />
=== Sound ===<br />
The Atari 8-bit use the POKEY chip to generate sound.<br />
* https://en.wikipedia.org/wiki/POKEY<br />
<br />
==== BASIC ====<br />
<syntaxhighlight lang="6502"><br />
; from Analog, 1985-09,pp.25-32<br />
*=$2000<br />
AUDF1=$D200<br />
AUDC1=$D201<br />
AUDCTL=$D208<br />
SKCTL=$D20F<br />
<br />
.MACRO SOUND ; voice,pitch,dist,vol;,dur<br />
lda #%2<br />
sta AUDF1+2*%1<br />
lda #[[%3 * 16] | %4] ;lda #[[%3 shl 4] or %4]<br />
sta AUDC1+2*%1<br />
.ENDM<br />
<br />
lda #0<br />
sta AUDCTL<br />
lda #3<br />
sta SKCTL<br />
<br />
SOUND 0,121,10,8<br />
<br />
jmp *<br />
</syntaxhighlight><br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Additional Resources ===<br />
Sizecoding resource for the Atari 8bit are:<br />
* Mapping the Atari https://www.atariarchives.org/mapping/<br />
* Atari 8bit Memory map https://www.atariarchives.org/mapping/memorymap.php<br />
* Fready's undocumented 6502 opcodes https://github.com/FreddyOffenga/6502<br />
* Atari OS Rev2 disassembly for MADS assembler https://github.com/ilmenit/A800-OS-XL-Rev2<br />
* Fready's github https://github.com/FreddyOffenga/<br />
<br />
== Commodore 64 ==<br />
The Commodore system consists of a 6502-compatible MOS 6510 processor with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Commodore systems is quite easy, first get the following tools:<br />
<br />
* Assembler: To be added<br />
* Emulator(s): VICE is the way to go<br />
<br />
=== Memory map ===<br />
<br />
<syntaxhighlight lang="6502"><br />
0-1 $0-$1 PROCESSOR PORT REGISTERS, not usable as RAM<br />
0-255 $0-$FF ZEROPAGE, mostly used by BASIC interpreter and Kernal<br />
256-511 $100-$1FF SYSTEM STACK<br />
512-600 $200-$258 INPUT BUFFER<br />
601-630 $259-$276 FILE SYSTEM DATA<br />
631-640 $277-$280 KEYBOARD BUFFER, filled by Kernal ISR upon key presses <br />
641-678 $281-$2A6 VARIOUS KERNAL VARIABLES<br />
679-767 $2A7-$2FF Unused (89 byte)<br />
768-779 $300-$30B KERNAL VECTORS<br />
780-783 $30C-$30F REGISTER VALUES A,X,Y,SR for SYS<br />
784-819 $310-$333 KERNAL VECTORS<br />
820-827 $334-$33B Unused (8 byte)<br />
828-1019 $33C-$3FB DATASETTE BUFFER<br />
1020-1023 $3FC-$3FF Unused (4 byte)<br />
1024-2023 $400-$7E7 SCREEN MEMORY (25 lines times 40 columns)<br />
2024-2039 $7E8-$7F7 Unused (16 byte)<br />
2040-2047 $7F8-$7FF SPRITE COSTUME POINTERS<br />
2048 $800 must contain a value of 0 so that the BASIC program can be RUN<br />
2049-40959 $801-$9FFF BASIC AREA (code, variables, arrays, strings)<br />
40960-49151 $A000-$BFFF BASIC ROM (unused RAM underneath)<br />
49152-53247 $C000-$CFFF UPPER RAM AREA (unused)<br />
53248-53294 $D000-$D02E VIC-II, memory-mapped graphics chip registers)<br />
54272-54300 $D400-$D41C SID, memory-mapped sound chip registers)<br />
55296-56295 $D800-$DBE7 Color RAM, only lower 4 bits are stored, higher nibble undefined<br />
56296-56319 $DBE8-$DBFF Unused (24 half-bytes)<br />
56320-56335 $DC00-$DC0F CIA#1, memory-mapped I/O chip registers for keyboard, joystick, mouse, datasette, IRQ control<br />
56576-56591 $DD00-$DD0F CIA#1, memory-mapped I/O chip registers for serial bus, RS232, NMI control<br />
57344-65535 $E000-$FFFF KERNAL ROM<br />
65534-65535 $FFFE-$FFFF Execution address of interrupt service routine, can only be set if KERNAL is turned off<br />
</syntaxhighlight><br />
<br />
For a detailed explanation of the C64 memory map check out [https://sta.c64.org/cbm64mem.html Commodore 64 memory map] on Joe Forster/STA homepage.<br />
<br />
=== Program file overhead ===<br />
<br />
A standard CBM file consists of a 2 byte loading address followed by the data that is placed into memory starting at this address. In addition, if your machine program should be able to be started with "RUN", you need a BASIC stub that is loaded into memory from $0801 to $080c, typically followed by your machine program:<br />
<br />
<syntaxhighlight lang="6502"><br />
*=$0801<br />
.word $080b ;address of next BASIC line<br />
.word LINENO ;line number, can be chosen between 0 and 63999<br />
.byte $9e ;token for SYS command<br />
.byte $32,$30,$35,$39 ;address to jump to in ASCII code: "2059" <br />
.byte $00 ;end of BASIC line<br />
start lax #0 ;actually address of next BASIC line, $xx00 means end of BASIC program, use $xx for an opcode<br />
; your code here<br />
</syntaxhighlight><br />
<br />
Together with the 2 byte load address, this makes an overhead of 14 bytes for your program, coming with A and X initialised to 0. To reduce this, you can<br />
* omit the BASIC line and tell users to start your program by directly entering "SYS ''address''"<br />
* save your program from $0802 on, the byte at $0801 is recovered automatically after loading by the relink function. This reduces your program file size by 1 byte<br />
* accept the loss and use the 2 byte establishing LINENO for something good, they are copied to zeropage addresses $39/$3a automatically, saving you the effort of initializing the addresses<br />
* use an autostart method (see below)<br />
<br />
Some compos also specify that the BASIC loader does not count towards the overall filesize, check the rules before you worry.<br />
<br />
=== Autostart ===<br />
<br />
Unlike the Commodore 128, the Commodore 64 has no dedicated built-in auto-boot feature, but it is possible to autorun a program after loading by specifying the load address so that it overwrites a vector or address that is called by the operating system. There are multiple possibilities:<br />
<br />
==== Overwriting CHROUT vector at $326-$327 ====<br />
<br />
The vector at address $326-$327 points at the CHROUT routine, normally at address $F1CA.<br />
If you put the entry address of your program into $326/27, your code will be called when the operating system wants to print "READY." after loading.<br />
Note that the vector at address $328-$329 points at the STOP routine that checks the status of Stop key indicator. Since this routine is called multiple times before your code is done loading, its default value $F6ED needs to be preserved. <br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$0326<br />
.word start <br />
.byte $ed,$f6<br />
start<br />
; rest of code<br />
</syntaxhighlight><br />
<br />
Together with the two byte load address, the overwritten CHROUT vector and the preserved STOP vector, your program file will have a deadweight of 6 byte: $26 $03 $0a $03 $ed $f6, less than half of the standard version with a BASIC stub with SYS<br />
<br />
Caveat:<br />
* If your program after $32a is longer than 214 byte, part of your program will load into the screen at $400. Thus, issuing a clear screen will overwrite your program. It is possible to move the screen memory somewhere else, but that requires storing a new value into address $D018, which when done with an LDA # / STA pair will cost you 5 byte<br />
* Since you changed the CHROUT pointer, standard KERNAL functions for printing won't work. For output of single characters, you can still use the direct address $F1CA. Alternatively, you can restore the vectors by calling $FD15, which will overwrite the memory $314 to $333 with the default values.<br />
* The memory area $33C-$3FB is the datasette buffer, thus loading a program into this area won't work when loading from a cassette.<br />
<br />
==== Overwriting BASIC idle loop vector at $302-$303 ====<br />
<br />
After loading the program, the BASIC idle loop will be called. By overwriting the vector at $302/$303 it is possible to autostart your program. Since the memory before $302 can be safely overwritten, the program would be arranged so that $303 is the '''last''' address of your program. If your program requires a loop back to the start, the vector can be used as part of a JMP where the following two bytes are already there, saving one byte in comparison to a loop done with a branch command.<br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$304 - (end - start)<br />
start:<br />
;your code here<br />
; ...<br />
jmp start ;the address for start lies in $302/$303, thus will be called by the Kernal after loading<br />
end:<br />
</syntaxhighlight><br />
<br />
In cases where the vector has a practical use, the overhead in filesize is only the 2 byte loading address. For programs larger than 93 byte keep in mind that addresses before $2A7 are in use by the Kernal.<br />
<br />
==== Overwriting return address on stack at $1F8 ====<br />
<br />
When the load routine is called, the stack pointer is always at $FA at a stock C64. Thus the return address from the loading process is stored in memory address $1F8 (low byte) and $1F9 (high byte). During the loading routine, stack usage will clobber the stack below $1F8, but a program loaded to $1F8 and above will be fine and the overwritten address stored at $1F8/$1F9 will be called after loading.<br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$1F8<br />
.word start-1 ;adjust for the RTS command pulling the address from stack and increasing it by 1<br />
start:<br />
;your code here<br />
</syntaxhighlight><br />
<br />
For programs larger than 95 byte keep in mind that addresses after $259 are in use by the Kernal, you might overwrite some values here if you don't have disk operations, but better check the memory map beforehand.<br />
<br />
Together with the two byte load address and the overwritten address at $1F8/$1F9, your program file will have a deadweight of 4 byte when using this method.<br />
<br />
==== Putting your program into zeropage overwriting part of CHRGET ====<br />
<br />
CHRGET is a machine code routine for the BASIC interpreter that is placed in the zero page at $73-$8A. By putting your program at $7C and following, the CHRGET routine runs directly into your code.<br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$7C<br />
start:<br />
;your code here<br />
</syntaxhighlight><br />
<br />
With this method, there is no need for a start address vector. The only deadweight in your program is the loading address. However, the zero page is a busy place, if your program extends beyond address $8f (that is it has more than 22 bytes on disk) you have to deal with some parts of your program being overwritten, for example, the status byte in $90 is set after loading.<br />
<br />
Loading data into address $A9 has an interesting side effect - the vector of $AE/$AF defines the address where the loaded bytes are written to. If $AE gets overwritten with, for example, $40, the next byte will be written to $41 (because the vector is incremented after the write). This can be used to split your program into different parts of memory.<br />
<br />
=== Video display ===<br />
Video display on the Commodore has the following native video modes:<br />
* Standard text mode, 40x25 characters, 1 individual foreground color per character, 1 common background color<br />
* Multicolor text mode, 40x25 characters, only 8 foreground colors, can be mixed with hires chars, foreground < 8 denotes a hires char, with foreground >= 8 a pair of two bits (brick pixel) define color: background, foreground & %111, common color 1+2<br />
* Extended background color text mode, 40x25 characters, 1 individual foreground color per character, 1 out of 4 background colors, only 64 chars<br />
* Hires bitmap, 320x200 pixels, an 8x8 field can have an individual foreground and an individual background color<br />
* Multicolor bitmap, 160x200 pixels, a pair of two bits (brick pixel) define color: background, screen color lower nibble, screen color higher nibble, color from color RAM<br />
<br />
==== Sync with frame ====<br />
<br />
Depending on the VIC type, there are 262/263 raster lines (NTSC) or 312 raster lines (PAL-B). Therefore, the VIC uses register at $D012 and the highest bit of register $D011 to represent the current raster line. Checking only the lower 8 bits and waiting for them to be 0 would therefore not work because this happens two times per frame. However, any number greater than 64 will only trigger once. Using a value of 255, we would sync to a rasterline at the end of the screen, well below the part where graphics are normally displayed:<br />
<br />
<syntaxhighlight lang="6502"><br />
waitsync:<br />
ldx $D012<br />
inx<br />
bne waitsync<br />
</syntaxhighlight><br />
<br />
As long as there have more than 63 cycles passed since the snyc, the next sync will happen at the next frame.<br />
This works fine as long as we don't miss the line 255 due to an interrupt. If your program has interrupts that are not synced to a rasterline, you can change the condition as follows<br />
<syntaxhighlight lang="6502"><br />
lda #$E3<br />
waitsync:<br />
cmp $D012<br />
bcs waitsync<br />
</syntaxhighlight><br />
<br />
Now we have a window between raster line $E4 and $FF to trigger our sync, which we will meet even if a standard Kernal interrupt comes in-between. Of course, our main program now has to burn around 1700 cycles to avoid a retriggering in the same frame.<br />
<br />
==== Getting something on screen ====<br />
<br />
Output a character:<br />
<syntaxhighlight lang="6502"><br />
lda #C ;C must be the char code according to the PETSCII code table<br />
jsr $FFD2 ;you can also use the direct address $FC1A, function preserves A,X,Y and enables interrupt<br />
</syntaxhighlight><br />
<br />
Since the [https://en.wikipedia.org/wiki/PETSCII#Character_set PETSCII code table] contains also control characters, this method can be also used to clear the screen, move the cursor or set the text color. However, some functions are shorter (and faster) by directly calling the respective KERNAL function:<br />
<br />
<syntaxhighlight lang="6502"><br />
Clear screen JSR $E544<br />
Cursor home position JSR $E566<br />
Output newline character JSR $AAD7<br />
Set text color LDA #COLOR, STA $286<br />
Set border color LDA #COLOR, STA $D020 ;not possible with a PETSCII control code<br />
Set background color LDA #COLOR, STA $D021 ;not possible with a PETSCII control code<br />
</syntaxhighlight><br />
<br />
Copy characters directly to screen memory:<br />
<br />
<syntaxhighlight lang="6502"><br />
.macpack cbm ;scrcode macro<br />
SCREEN_BASE=$400<br />
LINE=5 ;for example<br />
COLUMN=10 ;for example<br />
<br />
ldx #endtext-text-1<br />
@loop: lda text,x<br />
sta SCREEN_BASE+LINE*40+COLUMN,x<br />
dex<br />
bpl @loop<br />
text: scrcode "hello world!"<br />
endtext:<br />
</syntaxhighlight><br />
<br />
Note that the text needs to be stored in '''screen code''' format, not in PETSCII (see [https://sta.c64.org/cbm64pettoscr.html Commodore 64 PETSCII code to screen code conversion] for the differences). Furthermore, the example above only writes to the screen memory, not the color RAM, assuming that the color RAM already contains the intended text color. This is the case after issuing a clear screen on most C64 machines, except for some old ROM revisions. To be on the save side you would have to write to color RAM as well, which costs another 5 byte:<br />
<br />
<syntaxhighlight lang="6502"><br />
.macpack cbm ;scrcode macro<br />
SCREEN_BASE=$400<br />
COLOR_RAM =$D800<br />
LINE =5 ;for example<br />
COLUMN =10 ;for example<br />
COLOR =1 ;white<br />
<br />
ldx #endtext-text-1<br />
@loop: lda text,x<br />
sta SCREEN_BASE+LINE*40+COLUMN,x<br />
lda #COLOR<br />
sta COLOR_RAM +LINE*40+COLUMN,x<br />
dex<br />
bpl @loop<br />
text: scrcode "hello world!"<br />
endtext:<br />
</syntaxhighlight><br />
<br />
=== Sound ===<br />
The Commodore 64 uses the famous SID chip to generate sound.<br />
To be added soon.<br />
<br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Useful Kernal functions ===<br />
<br />
==== Get a pseudo random number ====<br />
<br />
<syntaxhighlight lang="6502"><br />
lda #1 <br />
jsr $E09A<br />
lda $63<br />
</syntaxhighlight><br />
<br />
The sequence of random numbers is always the same after a cold start or reset, the first 20 numbers are:<br />
<syntaxhighlight lang="6502"><br />
4,24,231,4,177,170,193,101,231,18,196,1,75,48,149,36,124,53,65,154<br />
</syntaxhighlight><br />
<br />
==== Increment a zero page counter, return in X register, clear Y register ====<br />
<br />
This is part of the string handling function in the BASIC ROM, but the code could be useful for some loop stuff.<br />
<br />
<syntaxhighlight lang="6502"><br />
jsr $B5FF ;does inc $23, ldx $23, ldy #$00, rts<br />
</syntaxhighlight><br />
<br />
=== Additional Resources ===<br />
* Codebase 64 https://codebase64.org/doku.php?id=base:start<br />
* Commodore 64 Memory map https://sta.c64.org/cbm64mem.html<br />
* C64 BASIC & KERNAL ROM Disassembly https://www.pagetable.com/c64ref/c64disasm/<br />
* No More Secrets https://csdb.dk/release/?id=198357 Everything about illegal opcodes and their use in a C64 system<br />
<br />
== Apple II ==<br />
The Apple II is an 8-bit home computer and one of the world's first highly successful mass-produced microcomputer products. It was designed primarily by Steve Wozniak.<br />
<br />
=== Setting up ===<br />
* ACME 6502 cross-assembler(https://sourceforge.net/projects/acme-crossass/)<br />
* Apple Commander (http://applecommander.sourceforge.net) for batch compilation<br />
* AppleWin emulator (https://github.com/AppleWin/AppleWin/releases). Supports Mockingboard card(AY-8910+speech synthesier), HDD, Z80 card(for CP/M), mouse etc.<br />
* CiderPress(https://a2ciderpress.com)<br />
<br />
Compilation can be done as follows (master.dsk can be found with applewin) <br />
<syntaxhighlight><br />
acme hl.asm<br />
java -jar AppleCommander-1.3.5.jar -d master.dsk hl<br />
java -jar AppleCommander-1.3.5.jar -p master.dsk hl B 24576 < hl.bin<br />
</syntaxhighlight><br />
<br />
=== Memory Map ===<br />
<syntaxhighlight lang="6502"><br />
0-255 $0-$FF ZERO-PAGE SYSTEM STORAGE<br />
256-511 $100-$1FF SYSTEM STACK<br />
512-767 $200-$2FF KEYBOARD CHARACTER BUFFER<br />
768-975 $300-$3CF OFTEN AVAILABLE AS FREE SPACE FOR USER PROGRAMS<br />
976-1023 $3D0-3FF SYSTEM VECTORS<br />
1024-2047 $400-$7FF TEXT AND LO-RES GRAPHICS PAGE 1 <--- !!!<br />
2048-LOMEM $800-LOMEM PROGRAM STORAGE<br />
2048-3071 $800-$BFF TEXT AND LO-RES GRAPHICS PAGE 2 OR FREE SPACE<br />
3072-8191 $C00-$1FFF FREE SPACE UNLESS RAM APPLESOFT IS IN USE<br />
8192-16383 $2000-$3FFF HI-RES PAGE 1 OR FREE SPACE <--- !!!<br />
16384-24575 $4000-$5FFF HI-RES PAGE 2 OR FREE SPACE<br />
24576-38999 $6000-$95FF FREE SPACE AND STRING STORAGE<br />
38400-49151 $9600-$BFFF DOS<br />
49152-53247 $C000-$CFFF I/O HARDWARE (RESERVED)<br />
53248-57343 $D000-$DFFF APPLESOFT IN LANGUAGE CARD OR ROM<br />
57344-63487 $E000-$F7FF APPLESOFT OR INTEGER BASIC IN LANGUAGE CARD OR ROM<br />
63488-65535 $F800-$FFFF SYSTEM MONITOR<br />
</syntaxhighlight><br />
<br />
=== Display ===<br />
<br />
=== Graphics Modes ===<br />
: Text Mode 40x24, for Apple IIe available 80x25 - use PR#3 for switch mode, or hardware switch<br />
: LowRes 40x48, 16 colors: https://en.wikipedia.org/wiki/Apple_II_graphics <br />
: Hires mode 280x192,6 colors: https://www.xtof.info/blog/?p=768<br />
https://mrob.com/pub/xapple2/colors.html<br />
https://archive.org/details/HiRes_Color_Graphics_on_the_Apple_II_Computer_by_Wozniak<br />
<br />
However for sizecoding, you almost never want to do direct-access to graphics for Apple II in size-coding because the Apple II graphics modes are horrible. The only fast way to do things is with large lookup tables. To do hires you need to divide by 7 which as you can imagine is a bit difficult to do compactly on 6502. Double-hires is even crazier on top of that. Deater did manage a color-bar style effect in double-hires in 128B but that was doing some crazy tricks with the firmware BASIC routines, definitely not direct-access.<br />
<br />
Lores and Hires can be mixed modes and full-graphics<br />
The screen structure is called memory holes(https://retrocomputing.stackexchange.com/questions/2534/what-are-the-screen-holes-in-apple-ii-graphics). The GBASCALC($F847) procedure is used to calculate the address of the horizontal line : IN:reg.A=Y, out : GBASL/GBASH($26/$27)=address. See also https://www.callapple.org/uncategorized/use-of-apple-ii-color-graphics-in-assembly-language/<br />
<br />
==== Getting something on screen ====<br />
Here is an example of a XOR texture, created by g0blinish<br />
<syntaxhighlight lang="6502"><br />
*=$6000<br />
!to "HL.bin", plain ; set output file and format<br />
!cpu 6502 ; set processor type<br />
<br />
GBASL = $26<br />
GBASH = $27<br />
SETGR = $FB40 ; setup LoRes<br />
GBASCALC = $F847 ; calc Address<br />
<br />
CLRTEXT = $C050 ;display graphics <br />
SETTEXT = $C051 ;display text <br />
<br />
CLRMIXED = $C052 ;clear mixed mode- enable full graphics <br />
SETMIXED = $C053 ;enable graphics/text mixed mode <br />
<br />
PAGE1 = $C054 ;select text/graphics page1 <br />
PAGE2 = $C055 ;select text/graphics page2 <br />
<br />
CLRHIRES = $C056 ;select Lo-res <br />
SETHIRES = $C057 ;select Hi-res <br />
<br />
TMP= $FA<br />
<br />
JSR SETGR ;GR<br />
BIT CLRMIXED ; full screen<br />
<br />
LDA #0 ; A=0<br />
STA TMP ; POKE $FA,A<br />
<br />
YLP ;<br />
LDA TMP ; A=PEEK($FA)<br />
; LSR ; A=A/2<br />
JSR GBASCALC<br />
LDY #0;Y=0<br />
<br />
XLP TYA ; A=Y<br />
EOR TMP ; A=A xor PEEK($FA)<br />
and #$0F ; A=A and 15<br />
TAX ; X=A<br />
LDA COLORS,X ;A=PEEK(COLORS+X)<br />
STA(GBASL),Y ; POKE PEEK($26)+256*PEEK($27)+Y,A<br />
INY ; Y=Y+1<br />
CPY #40 ; Y=40?<br />
BNE XLP<br />
INC TMP ; POKE $FA,PEEK($FA)+1<br />
LDA TMP ; A=PEEK($FA)<br />
CMP #24 ; A=24?<br />
BNE YLP<br />
<br />
M1 JMP M1 ; replace to RTS<br />
<br />
COLORS ;N*17, pixel format is AAAABBBB, AAAA - upper dot, BBBB - lower dot<br />
!byte $00,$11,$22,$33,$44,$55,$66,$77<br />
!byte $88,$99,$AA,$BB,$CC,$DD,$EE,$FF<br />
</syntaxhighlight><br />
<br />
==== Sound ====<br />
Here is an example for using the speaker, based onthe following basic program:<br />
<br />
<syntaxhighlight lang="basic"><br />
; 50 POKE 768,V: POKE 769,P - 255 * INT (P / 256): POKE 800,1 + P / 256<br />
; 60 CALL 770: RETURN <br />
; 95 FOR K = 1 TO N: READ V(K),P(K): NEXT K<br />
; 100 FOR K = 1 TO N:V = V(K):P = P(K)<br />
; 110 GOSUB 50<br />
;!byte 173,48,192,136,208,5,206,1,3,240,9,202,208,245,174,0,3,76,2,3,206,32,3,208,240,96<br />
</syntaxhighlight><br />
<br />
<syntaxhighlight lang="6502"><br />
*=$6000<br />
!to "HL.bin", plain ; set output file and format<br />
!cpu 6502 ; set processor type<br />
<br />
;start<br />
; 95 FOR K = 1 TO N: READ V(K),P(K): NEXT K<br />
; 100 FOR K = 1 TO N:V = V(K):P = P(K)<br />
ini:<br />
lda #70<br />
sta cnt+1<br />
lda #music&255<br />
sta gotbyte+1<br />
lda #music/256<br />
sta gotbyte+2<br />
<br />
lop:<br />
;V<br />
jsr gotbyte<br />
sta L300<br />
jsr gotbyte<br />
;P<br />
jsr gotbyte<br />
sta L301<br />
jsr gotbyte<br />
clc<br />
adc #1<br />
sta L320<br />
jsr beep<br />
<br />
dec cnt+1<br />
cnt lda #70<br />
bne lop<br />
; 110 GOSUB 50<br />
; 50 POKE 768,V: POKE 769,P - 255 * INT (P / 256): POKE 800,1 + P / 256<br />
; 60 CALL 770: RETURN <br />
jmp ini<br />
gotbyte<br />
lda music<br />
inc gotbyte+1<br />
bne noinch<br />
inc gotbyte+2<br />
noinch<br />
rts<br />
;!byte 173,48,192,136,208,5,206,1,3,240,9,202,208,245,174,0,3,76,2,3,206,32,3,208,240,96<br />
beep:<br />
ldy #1<br />
ldx #1<br />
loc_302:<br />
LDA $C030<br />
<br />
loc_305:<br />
DEY<br />
BNE loc_30D<br />
DEC L301<br />
loc_30B:<br />
BEQ loc_316<br />
<br />
loc_30D:<br />
DEX<br />
BNE loc_305<br />
LDX L300<br />
JMP loc_302<br />
loc_316:<br />
DEC L320<br />
BNE loc_30B<br />
RTS<br />
L301 !byte 0<br />
L300 !byte 0<br />
L320 !byte 0<br />
music<br />
!word 76,192,85,64,96,64,102,64,114,128,114,64,96,64,102,64,114,64,128,64<br />
!word 114,64,152,64,171,64,152,512,76,192,85,64,96,64,102,64,114,128,114,64<br />
!word 96,64,102,64,114,64,128,64,114,64,152,64,171,64,152,512,85,64,85,64<br />
!word 85,64,96,64,144,128,144,64,128,64,76,128,85,64,96,64,144,128,114,64<br />
!word 96,64,102,128,114,64,128,64,128,128,114,64,128,64,114,512,85,64,85,64<br />
!word 85,64,96,64,144,128,144,64,128,64,76,128,85,64,96,64,144,128,114,64<br />
!word 96,64,102,128,114,64,128,64,128,64,128,128,96,64,85,64,96,64,102,64,114,64,114,64<br />
</syntaxhighlight><br />
<br />
=== Additional Resources ===<br />
* Deater's page on Apple II sizecoding http://www.deater.net/weave/vmwprod/demos/sizecoding.html (with an additional presentation at https://www.youtube.com/watch?v=kJ-EXbnw0kQ )<br />
* Article on double hi-res http://www.battlestations.zone/2017/04/apple-ii-double-hi-res-from-ground-up.html<br />
* Applesoft Hi-Res Subroutines : http://hackzapple.org/scripts_php/index.php?menu=5&mod=ASM&sub=AAL&sub2=8112&PHPSESSID=f65fabfd0cdbf56b6bdc0ddac25117c6#a2<br />
<br />
== Atari Lynx ==<br />
The Atari Lynx consists of the 6502 with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Atari Lynx:<br />
<br />
* Assembler: -<br />
* Emulator(s): -<br />
<br />
=== Video display ===<br />
To be added soon.<br />
<br />
==== Getting something on screen ====<br />
To be added soon.<br />
<br />
<br />
=== Sound ===<br />
To be added soon.<br />
<br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Additional Resources ===<br />
Sizecoding resource for the Atari Lynx are sparse<br />
* 42Bastian's website (link to be added)</div>Wilhttp://www.sizecoding.org/index.php?title=6502&diff=84065022021-02-19T18:35:20Z<p>Wil: /* Sync with frame */ $d011 and $d012 was mixed up</p>
<hr />
<div>== Introduction ==<br />
Wanting to start sizecoding on a 6502 platform in this day and age can be tough. <br />
<br />
[[File:6502.jpg|thumb]]<br />
<br />
So here is a bit of help to get you started:<br />
<br />
=== The 6502 processor ===<br />
The 6502 processor can be seen as the 8-bit micro ARM chip. <br />
It has only has 3 registers (Accumulator, X and Y registers) and a handful of instructions to work with.<br />
<br />
=== Adressing modes ===<br />
To be added.<br />
<br />
=== Zero page ===<br />
When using the 6502 for sizecoding, you'll mostly be working from zeropage<br />
<br />
=== General 6502 Resources ===<br />
* 6502.org http://www.6502.org/<br />
* 6502 instruction reference http://www.6502.org/tutorials/6502opcodes.html<br />
* 6502 books http://retro.hansotten.nl/6502-sbc/<br />
* 6502 Assembler tutorial https://dwheeler.com/6502/oneelkruns/asm1step.html<br />
* Easy 6502 code tester https://skilldrick.github.io/easy6502/<br />
* Synthetic instructions https://wiki.nesdev.com/w/index.php/Synthetic_instructions#8-bit_rotate<br />
<br />
== Atari 8-bit family ==<br />
The systems in this family are: Atari 400, 800, 5200, 1200XL, 600XL, 800XL, 130XE, 65XE, 800XE and XEGS.<br /><br />
<br />
The Atari 8-bit systems consists of the 6502 with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Atari 8bit systems is quite easy, first get the following tools:<br />
<br />
* Assembler: MADS Assembler - This assembler has nice macros for creating Binaries and SNA snapshot files out of the box. You can download it at https://mads.atari8.info/<br />
* Emulator(s): I Found Altirra to work best for my usecase. Make sure to use the original Rev2 rom for best compatibility.<br />
<br />
==== Special Memory Adresses ====<br />
* FRAMECOUNTER_HIGH = 19<br />
* FRAMECOUNTER_LOW = 20<br />
<br />
=== Video display ===<br />
Video display on the Atari 8bit systems use the ANTIC and GTIA chips. Information can be found here:<br />
* https://en.wikipedia.org/wiki/ANTIC<br />
* https://www.atariarchives.org/agagd/chapter1.php<br />
<br />
==== Sync with frame ====<br />
<syntaxhighlight lang="6502"><br />
RTCLOK equ $0012<br />
lda RTCLOK+2<br />
waits<br />
cmp RTCLOK+2<br />
beq waits<br />
</syntaxhighlight><br />
<br />
Or if you don't mind trashing RTCLOK<br />
<br />
<syntaxhighlight lang="6502"><br />
RTCLOK equ $0012<br />
waits<br />
lsr RTCLOK+2<br />
bcc waits<br />
</syntaxhighlight><br />
<br />
Which is two bytes shorter.<br />
<br />
==== Getting something on screen ====<br />
<syntaxhighlight lang="6502"><br />
;fill screen with charset,(88,89)=an address<br />
org $600; free 6th page:600-6ff<br />
ldy #0<br />
fl: tya<br />
sta(88),y<br />
iny<br />
bne fl<br />
jmp *<br />
</syntaxhighlight><br />
<br />
To be added soon.<br />
<br />
<syntaxhighlight lang="6502"><br />
SDMCTL = $022f<br />
HPOSP0 = $d000<br />
SIZEP0 = $d008<br />
GRAFP0 = $d00d<br />
COLPM0 = $d012<br />
<br />
FRAMECOUNTER_HIGH = 19<br />
FRAMECOUNTER = 20<br />
WSYNC = $d40a<br />
VCOUNT = $d40b<br />
<br />
sinewave = $0600 ; to $06ff<br />
<br />
org $80<br />
<br />
main <br />
; disable all graphics/colors<br />
ldx #0<br />
stx SDMCTL <br />
<br />
ldy #$7f<br />
sty SIZEP0 ; size p0=127<br />
<br />
ldx #0<br />
ldy #$3f<br />
make_sine:<br />
value_lo<br />
lda #0<br />
clc<br />
delta_lo<br />
adc #0<br />
sta value_lo+1<br />
value_hi<br />
lda #0<br />
delta_hi<br />
adc #0<br />
sta value_hi+1<br />
<br />
sta sinewave+$c0,x<br />
sta sinewave+$80,y<br />
eor #$7f<br />
sta sinewave+$40,x<br />
sta sinewave+$00,y<br />
<br />
lda delta_lo+1<br />
adc #8<br />
sta delta_lo+1<br />
bcc nothing<br />
inc delta_hi+1<br />
nothing<br />
inx<br />
dey<br />
bpl make_sine<br />
<br />
updateloop:<br />
; vblank<br />
lda VCOUNT<br />
bne updateloop<br />
<br />
; clear graphics<br />
sta HPOSP0<br />
sta GRAFP0<br />
<br />
ldy #0<br />
lda #47<br />
sta COLPM0<br />
yloop:<br />
tya ; graphics shape = y<br />
sta WSYNC<br />
sta GRAFP0<br />
<br />
; a = sin(frame+y)+48<br />
tya <br />
adc FRAMECOUNTER<br />
tax<br />
lda sinewave,x<br />
adc #48<br />
sta HPOSP0<br />
<br />
iny<br />
bne yloop<br />
jmp updateloop<br />
<br />
run main<br />
</syntaxhighlight><br />
<br />
=== Sound ===<br />
The Atari 8-bit use the POKEY chip to generate sound.<br />
* https://en.wikipedia.org/wiki/POKEY<br />
<br />
==== BASIC ====<br />
<syntaxhighlight lang="6502"><br />
; from Analog, 1985-09,pp.25-32<br />
*=$2000<br />
AUDF1=$D200<br />
AUDC1=$D201<br />
AUDCTL=$D208<br />
SKCTL=$D20F<br />
<br />
.MACRO SOUND ; voice,pitch,dist,vol;,dur<br />
lda #%2<br />
sta AUDF1+2*%1<br />
lda #[[%3 * 16] | %4] ;lda #[[%3 shl 4] or %4]<br />
sta AUDC1+2*%1<br />
.ENDM<br />
<br />
lda #0<br />
sta AUDCTL<br />
lda #3<br />
sta SKCTL<br />
<br />
SOUND 0,121,10,8<br />
<br />
jmp *<br />
</syntaxhighlight><br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Additional Resources ===<br />
Sizecoding resource for the Atari 8bit are:<br />
* Mapping the Atari https://www.atariarchives.org/mapping/<br />
* Atari 8bit Memory map https://www.atariarchives.org/mapping/memorymap.php<br />
* Fready's undocumented 6502 opcodes https://github.com/FreddyOffenga/6502<br />
* Atari OS Rev2 disassembly for MADS assembler https://github.com/ilmenit/A800-OS-XL-Rev2<br />
* Fready's github https://github.com/FreddyOffenga/<br />
<br />
== Commodore 64 ==<br />
The Commodore system consists of a 6502-compatible MOS 6510 processor with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Commodore systems is quite easy, first get the following tools:<br />
<br />
* Assembler: To be added<br />
* Emulator(s): VICE is the way to go<br />
<br />
=== Memory map ===<br />
<br />
<syntaxhighlight lang="6502"><br />
0-1 $0-$1 PROCESSOR PORT REGISTERS, not usable as RAM<br />
0-255 $0-$FF ZEROPAGE, mostly used by BASIC interpreter and Kernal<br />
256-511 $100-$1FF SYSTEM STACK<br />
512-600 $200-$258 INPUT BUFFER<br />
601-630 $259-$276 FILE SYSTEM DATA<br />
631-640 $277-$280 KEYBOARD BUFFER, filled by Kernal ISR upon key presses <br />
641-678 $281-$2A6 VARIOUS KERNAL VARIABLES<br />
679-767 $2A7-$2FF Unused (89 byte)<br />
768-779 $300-$30B KERNAL VECTORS<br />
780-783 $30C-$30F REGISTER VALUES A,X,Y,SR for SYS<br />
784-819 $310-$333 KERNAL VECTORS<br />
820-827 $334-$33B Unused (8 byte)<br />
828-1019 $33C-$3FB DATASETTE BUFFER<br />
1020-1023 $3FC-$3FF Unused (4 byte)<br />
1024-2023 $400-$7E7 SCREEN MEMORY (25 lines times 40 columns)<br />
2024-2039 $7E8-$7F7 Unused (16 byte)<br />
2040-2047 $7F8-$7FF SPRITE COSTUME POINTERS<br />
2048 $800 must contain a value of 0 so that the BASIC program can be RUN<br />
2049-40959 $801-$9FFF BASIC AREA (code, variables, arrays, strings)<br />
40960-49151 $A000-$BFFF BASIC ROM (unused RAM underneath)<br />
49152-53247 $C000-$CFFF UPPER RAM AREA (unused)<br />
53248-53294 $D000-$D02E VIC-II, memory-mapped graphics chip registers)<br />
54272-54300 $D400-$D41C SID, memory-mapped sound chip registers)<br />
55296-56295 $D800-$DBE7 Color RAM, only lower 4 bits are stored, higher nibble undefined<br />
56296-56319 $DBE8-$DBFF Unused (24 half-bytes)<br />
56320-56335 $DC00-$DC0F CIA#1, memory-mapped I/O chip registers for keyboard, joystick, mouse, datasette, IRQ control<br />
56576-56591 $DD00-$DD0F CIA#1, memory-mapped I/O chip registers for serial bus, RS232, NMI control<br />
57344-65535 $E000-$FFFF KERNAL ROM<br />
65534-65535 $FFFE-$FFFF Execution address of interrupt service routine, can only be set if KERNAL is turned off<br />
</syntaxhighlight><br />
<br />
For a detailed explanation of the C64 memory map check out [https://sta.c64.org/cbm64mem.html Commodore 64 memory map] on Joe Forster/STA homepage.<br />
<br />
=== Program file overhead ===<br />
<br />
A standard CBM file consists of a 2 byte loading address followed by the data that is placed into memory starting at this address. In addition, if your machine program should be able to be started with "RUN", you need a BASIC stub that is loaded into memory from $0801 to $080c, typically followed by your machine program:<br />
<br />
<syntaxhighlight lang="6502"><br />
*=$0801<br />
.word $080b ;address of next BASIC line<br />
.word LINENO ;line number, can be chosen between 0 and 63999<br />
.byte $9e ;token for SYS command<br />
.byte $32,$30,$35,$39 ;address to jump to in ASCII code: "2059" <br />
.byte $00 ;end of BASIC line<br />
start lax #0 ;actually address of next BASIC line, $xx00 means end of BASIC program, use $xx for an opcode<br />
; your code here<br />
</syntaxhighlight><br />
<br />
Together with the 2 byte load address, this makes an overhead of 14 bytes for your program, coming with A and X initialised to 0. To reduce this, you can<br />
* omit the BASIC line and tell users to start your program by directly entering "SYS ''address''"<br />
* save your program from $0802 on, the byte at $0801 is recovered automatically after loading by the relink function. This reduces your program file size by 1 byte<br />
* accept the loss and use the 2 byte establishing LINENO for something good, they are copied to zeropage addresses $39/$3a automatically, saving you the effort of initializing the addresses<br />
* use an autostart method (see below)<br />
<br />
Some compos also specify that the BASIC loader does not count towards the overall filesize, check the rules before you worry.<br />
<br />
=== Autostart ===<br />
<br />
Unlike the Commodore 128, the Commodore 64 has no dedicated built-in auto-boot feature, but it is possible to autorun a program after loading by specifying the load address so that it overwrites a vector or address that is called by the operating system. There are multiple possibilities:<br />
<br />
==== Overwriting CHROUT vector at $326-$327 ====<br />
<br />
The vector at address $326-$327 points at the CHROUT routine, normally at address $F1CA.<br />
If you put the entry address of your program into $326/27, your code will be called when the operating system wants to print "READY." after loading.<br />
Note that the vector at address $328-$329 points at the STOP routine that checks the status of Stop key indicator. Since this routine is called multiple times before your code is done loading, its default value $F6ED needs to be preserved. <br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$0326<br />
.word start <br />
.byte $ed,$f6<br />
start<br />
; rest of code<br />
</syntaxhighlight><br />
<br />
Together with the two byte load address, the overwritten CHROUT vector and the preserved STOP vector, your program file will have a deadweight of 6 byte: $26 $03 $0a $03 $ed $f6, less than half of the standard version with a BASIC stub with SYS<br />
<br />
Caveat:<br />
* If your program after $32a is longer than 214 byte, part of your program will load into the screen at $400. Thus, issuing a clear screen will overwrite your program. It is possible to move the screen memory somewhere else, but that requires storing a new value into address $D018, which when done with an LDA # / STA pair will cost you 5 byte<br />
* Since you changed the CHROUT pointer, standard KERNAL functions for printing won't work. For output of single characters, you can still use the direct address $F1CA. Alternatively, you can restore the vectors by calling $FD15, which will overwrite the memory $314 to $333 with the default values.<br />
* The memory area $33C-$3FB is the datasette buffer, thus loading a program into this area won't work when loading from a cassette.<br />
<br />
==== Overwriting BASIC idle loop vector at $302-$303 ====<br />
<br />
After loading the program, the BASIC idle loop will be called. By overwriting the vector at $302/$303 it is possible to autostart your program. Since the memory before $302 can be safely overwritten, the program would be arranged so that $303 is the '''last''' address of your program. If your program requires a loop back to the start, the vector can be used as part of a JMP where the following two bytes are already there, saving one byte in comparison to a loop done with a branch command.<br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$304 - (end - start)<br />
start:<br />
;your code here<br />
; ...<br />
jmp start ;the address for start lies in $302/$303, thus will be called by the Kernal after loading<br />
end:<br />
</syntaxhighlight><br />
<br />
In cases where the vector has a practical use, the overhead in filesize is only the 2 byte loading address. For programs larger than 93 byte keep in mind that addresses before $2A7 are in use by the Kernal.<br />
<br />
==== Overwriting return address on stack at $1F8 ====<br />
<br />
When the load routine is called, the stack pointer is always at $FA at a stock C64. Thus the return address from the loading process is stored in memory address $F8 (low byte) and $F9 (high byte). During the loading routine, stack usage will clobber the stack below $1F8, but a program loaded to $1F8 and above will be fine and the overwritten address stored at $1F8/$1F9 will be called after loading.<br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$1F8<br />
.word start-1 ;adjust for the RTS command pulling the address from stack and increasing it by 1<br />
start:<br />
;your code here<br />
</syntaxhighlight><br />
<br />
For programs larger than 95 byte keep in mind that addresses after $259 are in use by the Kernal, you might overwrite some values here if you don't have disk operations, but better check the memory map beforehand.<br />
<br />
Together with the two byte load address and the overwritten address at $1F8/$1F9, your program file will have a deadweight of 4 byte when using this method.<br />
<br />
==== Putting your program into zeropage overwriting part of CHRGET ====<br />
<br />
CHRGET is a machine code routine for the BASIC interpreter that is placed in the zero page at $73-$8A. By putting your program at $7C and following, the CHRGET routine runs directly into your code.<br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$7C<br />
start:<br />
;your code here<br />
</syntaxhighlight><br />
<br />
With this method, there is no need for a start address vector. The only deadweight in your program is the loading address. However, the zero page is a busy place, if your program extends beyond address $8f (that is it has more than 22 bytes on disk) you have to deal with some parts of your program being overwritten, for example, the status byte in $90 is set after loading.<br />
<br />
Loading data into address $A9 has an interesting side effect - the vector of $AE/$AF defines the address where the loaded bytes are written to. If $AE gets overwritten with, for example, $40, the next byte will be written to $41 (because the vector is incremented after the write). This can be used to split your program into different parts of memory.<br />
<br />
=== Video display ===<br />
Video display on the Commodore has the following native video modes:<br />
* Standard text mode, 40x25 characters, 1 individual foreground color per character, 1 common background color<br />
* Multicolor text mode, 40x25 characters, only 8 foreground colors, can be mixed with hires chars, foreground < 8 denotes a hires char, with foreground >= 8 a pair of two bits (brick pixel) define color: background, foreground & %111, common color 1+2<br />
* Extended background color text mode, 40x25 characters, 1 individual foreground color per character, 1 out of 4 background colors, only 64 chars<br />
* Hires bitmap, 320x200 pixels, an 8x8 field can have an individual foreground and an individual background color<br />
* Multicolor bitmap, 160x200 pixels, a pair of two bits (brick pixel) define color: background, screen color lower nibble, screen color higher nibble, color from color RAM<br />
<br />
==== Sync with frame ====<br />
<br />
Depending on the VIC type, there are 262/263 raster lines (NTSC) or 312 raster lines (PAL-B). Therefore, the VIC uses register at $D012 and the highest bit of register $D011 to represent the current raster line. Checking only the lower 8 bits and waiting for them to be 0 would therefore not work because this happens two times per frame. However, any number greater than 64 will only trigger once. Using a value of 255, we would sync to a rasterline at the end of the screen, well below the part where graphics are normally displayed:<br />
<br />
<syntaxhighlight lang="6502"><br />
waitsync:<br />
ldx $D012<br />
inx<br />
bne waitsync<br />
</syntaxhighlight><br />
<br />
As long as there have more than 63 cycles passed since the snyc, the next sync will happen at the next frame.<br />
This works fine as long as we don't miss the line 255 due to an interrupt. If your program has interrupts that are not synced to a rasterline, you can change the condition as follows<br />
<syntaxhighlight lang="6502"><br />
lda #$E3<br />
waitsync:<br />
cmp $D012<br />
bcs waitsync<br />
</syntaxhighlight><br />
<br />
Now we have a window between raster line $E4 and $FF to trigger our sync, which we will meet even if a standard Kernal interrupt comes in-between. Of course, our main program now has to burn around 1700 cycles to avoid a retriggering in the same frame.<br />
<br />
==== Getting something on screen ====<br />
<br />
Output a character:<br />
<syntaxhighlight lang="6502"><br />
lda #C ;C must be the char code according to the PETSCII code table<br />
jsr $FFD2 ;you can also use the direct address $FC1A, function preserves A,X,Y and enables interrupt<br />
</syntaxhighlight><br />
<br />
Since the [https://en.wikipedia.org/wiki/PETSCII#Character_set PETSCII code table] contains also control characters, this method can be also used to clear the screen, move the cursor or set the text color. However, some functions are shorter (and faster) by directly calling the respective KERNAL function:<br />
<br />
<syntaxhighlight lang="6502"><br />
Clear screen JSR $E544<br />
Cursor home position JSR $E566<br />
Output newline character JSR $AAD7<br />
Set text color LDA #COLOR, STA $286<br />
Set border color LDA #COLOR, STA $D020 ;not possible with a PETSCII control code<br />
Set background color LDA #COLOR, STA $D021 ;not possible with a PETSCII control code<br />
</syntaxhighlight><br />
<br />
Copy characters directly to screen memory:<br />
<br />
<syntaxhighlight lang="6502"><br />
.macpack cbm ;scrcode macro<br />
SCREEN_BASE=$400<br />
LINE=5 ;for example<br />
COLUMN=10 ;for example<br />
<br />
ldx #endtext-text-1<br />
@loop: lda text,x<br />
sta SCREEN_BASE+LINE*40+COLUMN,x<br />
dex<br />
bpl @loop<br />
text: scrcode "hello world!"<br />
endtext:<br />
</syntaxhighlight><br />
<br />
Note that the text needs to be stored in '''screen code''' format, not in PETSCII (see [https://sta.c64.org/cbm64pettoscr.html Commodore 64 PETSCII code to screen code conversion] for the differences). Furthermore, the example above only writes to the screen memory, not the color RAM, assuming that the color RAM already contains the intended text color. This is the case after issuing a clear screen on most C64 machines, except for some old ROM revisions. To be on the save side you would have to write to color RAM as well, which costs another 5 byte:<br />
<br />
<syntaxhighlight lang="6502"><br />
.macpack cbm ;scrcode macro<br />
SCREEN_BASE=$400<br />
COLOR_RAM =$D800<br />
LINE =5 ;for example<br />
COLUMN =10 ;for example<br />
COLOR =1 ;white<br />
<br />
ldx #endtext-text-1<br />
@loop: lda text,x<br />
sta SCREEN_BASE+LINE*40+COLUMN,x<br />
lda #COLOR<br />
sta COLOR_RAM +LINE*40+COLUMN,x<br />
dex<br />
bpl @loop<br />
text: scrcode "hello world!"<br />
endtext:<br />
</syntaxhighlight><br />
<br />
=== Sound ===<br />
The Commodore 64 uses the famous SID chip to generate sound.<br />
To be added soon.<br />
<br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Useful Kernal functions ===<br />
<br />
==== Get a pseudo random number ====<br />
<br />
<syntaxhighlight lang="6502"><br />
lda #1 <br />
jsr $E09A<br />
lda $63<br />
</syntaxhighlight><br />
<br />
The sequence of random numbers is always the same after a cold start or reset, the first 20 numbers are:<br />
<syntaxhighlight lang="6502"><br />
4,24,231,4,177,170,193,101,231,18,196,1,75,48,149,36,124,53,65,154<br />
</syntaxhighlight><br />
<br />
==== Increment a zero page counter, return in X register, clear Y register ====<br />
<br />
This is part of the string handling function in the BASIC ROM, but the code could be useful for some loop stuff.<br />
<br />
<syntaxhighlight lang="6502"><br />
jsr $B5FF ;does inc $23, ldx $23, ldy #$00, rts<br />
</syntaxhighlight><br />
<br />
=== Additional Resources ===<br />
* Codebase 64 https://codebase64.org/doku.php?id=base:start<br />
* Commodore 64 Memory map https://sta.c64.org/cbm64mem.html<br />
* C64 BASIC & KERNAL ROM Disassembly https://www.pagetable.com/c64ref/c64disasm/<br />
* No More Secrets https://csdb.dk/release/?id=198357 Everything about illegal opcodes and their use in a C64 system<br />
<br />
== Apple II ==<br />
The Apple II is an 8-bit home computer and one of the world's first highly successful mass-produced microcomputer products. It was designed primarily by Steve Wozniak.<br />
<br />
=== Setting up ===<br />
* ACME 6502 cross-assembler(https://sourceforge.net/projects/acme-crossass/)<br />
* Apple Commander (http://applecommander.sourceforge.net) for batch compilation<br />
* AppleWin emulator (https://github.com/AppleWin/AppleWin/releases). Supports Mockingboard card(AY-8910+speech synthesier), HDD, Z80 card(for CP/M), mouse etc.<br />
* CiderPress(https://a2ciderpress.com)<br />
<br />
Compilation can be done as follows (master.dsk can be found with applewin) <br />
<syntaxhighlight><br />
acme hl.asm<br />
java -jar AppleCommander-1.3.5.jar -d master.dsk hl<br />
java -jar AppleCommander-1.3.5.jar -p master.dsk hl B 24576 < hl.bin<br />
</syntaxhighlight><br />
<br />
=== Memory Map ===<br />
<syntaxhighlight lang="6502"><br />
0-255 $0-$FF ZERO-PAGE SYSTEM STORAGE<br />
256-511 $100-$1FF SYSTEM STACK<br />
512-767 $200-$2FF KEYBOARD CHARACTER BUFFER<br />
768-975 $300-$3CF OFTEN AVAILABLE AS FREE SPACE FOR USER PROGRAMS<br />
976-1023 $3D0-3FF SYSTEM VECTORS<br />
1024-2047 $400-$7FF TEXT AND LO-RES GRAPHICS PAGE 1 <--- !!!<br />
2048-LOMEM $800-LOMEM PROGRAM STORAGE<br />
2048-3071 $800-$BFF TEXT AND LO-RES GRAPHICS PAGE 2 OR FREE SPACE<br />
3072-8191 $C00-$1FFF FREE SPACE UNLESS RAM APPLESOFT IS IN USE<br />
8192-16383 $2000-$3FFF HI-RES PAGE 1 OR FREE SPACE <--- !!!<br />
16384-24575 $4000-$5FFF HI-RES PAGE 2 OR FREE SPACE<br />
24576-38999 $6000-$95FF FREE SPACE AND STRING STORAGE<br />
38400-49151 $9600-$BFFF DOS<br />
49152-53247 $C000-$CFFF I/O HARDWARE (RESERVED)<br />
53248-57343 $D000-$DFFF APPLESOFT IN LANGUAGE CARD OR ROM<br />
57344-63487 $E000-$F7FF APPLESOFT OR INTEGER BASIC IN LANGUAGE CARD OR ROM<br />
63488-65535 $F800-$FFFF SYSTEM MONITOR<br />
</syntaxhighlight><br />
<br />
=== Display ===<br />
<br />
=== Graphics Modes ===<br />
: Text Mode 40x24, for Apple IIe available 80x25 - use PR#3 for switch mode, or hardware switch<br />
: LowRes 40x48, 16 colors: https://en.wikipedia.org/wiki/Apple_II_graphics <br />
: Hires mode 280x192,6 colors: https://www.xtof.info/blog/?p=768<br />
https://mrob.com/pub/xapple2/colors.html<br />
https://archive.org/details/HiRes_Color_Graphics_on_the_Apple_II_Computer_by_Wozniak<br />
<br />
However for sizecoding, you almost never want to do direct-access to graphics for Apple II in size-coding because the Apple II graphics modes are horrible. The only fast way to do things is with large lookup tables. To do hires you need to divide by 7 which as you can imagine is a bit difficult to do compactly on 6502. Double-hires is even crazier on top of that. Deater did manage a color-bar style effect in double-hires in 128B but that was doing some crazy tricks with the firmware BASIC routines, definitely not direct-access.<br />
<br />
Lores and Hires can be mixed modes and full-graphics<br />
The screen structure is called memory holes(https://retrocomputing.stackexchange.com/questions/2534/what-are-the-screen-holes-in-apple-ii-graphics). The GBASCALC($F847) procedure is used to calculate the address of the horizontal line : IN:reg.A=Y, out : GBASL/GBASH($26/$27)=address. See also https://www.callapple.org/uncategorized/use-of-apple-ii-color-graphics-in-assembly-language/<br />
<br />
==== Getting something on screen ====<br />
Here is an example of a XOR texture, created by g0blinish<br />
<syntaxhighlight lang="6502"><br />
*=$6000<br />
!to "HL.bin", plain ; set output file and format<br />
!cpu 6502 ; set processor type<br />
<br />
GBASL = $26<br />
GBASH = $27<br />
SETGR = $FB40 ; setup LoRes<br />
GBASCALC = $F847 ; calc Address<br />
<br />
CLRTEXT = $C050 ;display graphics <br />
SETTEXT = $C051 ;display text <br />
<br />
CLRMIXED = $C052 ;clear mixed mode- enable full graphics <br />
SETMIXED = $C053 ;enable graphics/text mixed mode <br />
<br />
PAGE1 = $C054 ;select text/graphics page1 <br />
PAGE2 = $C055 ;select text/graphics page2 <br />
<br />
CLRHIRES = $C056 ;select Lo-res <br />
SETHIRES = $C057 ;select Hi-res <br />
<br />
TMP= $FA<br />
<br />
JSR SETGR ;GR<br />
BIT CLRMIXED ; full screen<br />
<br />
LDA #0 ; A=0<br />
STA TMP ; POKE $FA,A<br />
<br />
YLP ;<br />
LDA TMP ; A=PEEK($FA)<br />
; LSR ; A=A/2<br />
JSR GBASCALC<br />
LDY #0;Y=0<br />
<br />
XLP TYA ; A=Y<br />
EOR TMP ; A=A xor PEEK($FA)<br />
and #$0F ; A=A and 15<br />
TAX ; X=A<br />
LDA COLORS,X ;A=PEEK(COLORS+X)<br />
STA(GBASL),Y ; POKE PEEK($26)+256*PEEK($27)+Y,A<br />
INY ; Y=Y+1<br />
CPY #40 ; Y=40?<br />
BNE XLP<br />
INC TMP ; POKE $FA,PEEK($FA)+1<br />
LDA TMP ; A=PEEK($FA)<br />
CMP #24 ; A=24?<br />
BNE YLP<br />
<br />
M1 JMP M1 ; replace to RTS<br />
<br />
COLORS ;N*17, pixel format is AAAABBBB, AAAA - upper dot, BBBB - lower dot<br />
!byte $00,$11,$22,$33,$44,$55,$66,$77<br />
!byte $88,$99,$AA,$BB,$CC,$DD,$EE,$FF<br />
</syntaxhighlight><br />
<br />
==== Sound ====<br />
Here is an example for using the speaker, based onthe following basic program:<br />
<br />
<syntaxhighlight lang="basic"><br />
; 50 POKE 768,V: POKE 769,P - 255 * INT (P / 256): POKE 800,1 + P / 256<br />
; 60 CALL 770: RETURN <br />
; 95 FOR K = 1 TO N: READ V(K),P(K): NEXT K<br />
; 100 FOR K = 1 TO N:V = V(K):P = P(K)<br />
; 110 GOSUB 50<br />
;!byte 173,48,192,136,208,5,206,1,3,240,9,202,208,245,174,0,3,76,2,3,206,32,3,208,240,96<br />
</syntaxhighlight><br />
<br />
<syntaxhighlight lang="6502"><br />
*=$6000<br />
!to "HL.bin", plain ; set output file and format<br />
!cpu 6502 ; set processor type<br />
<br />
;start<br />
; 95 FOR K = 1 TO N: READ V(K),P(K): NEXT K<br />
; 100 FOR K = 1 TO N:V = V(K):P = P(K)<br />
ini:<br />
lda #70<br />
sta cnt+1<br />
lda #music&255<br />
sta gotbyte+1<br />
lda #music/256<br />
sta gotbyte+2<br />
<br />
lop:<br />
;V<br />
jsr gotbyte<br />
sta L300<br />
jsr gotbyte<br />
;P<br />
jsr gotbyte<br />
sta L301<br />
jsr gotbyte<br />
clc<br />
adc #1<br />
sta L320<br />
jsr beep<br />
<br />
dec cnt+1<br />
cnt lda #70<br />
bne lop<br />
; 110 GOSUB 50<br />
; 50 POKE 768,V: POKE 769,P - 255 * INT (P / 256): POKE 800,1 + P / 256<br />
; 60 CALL 770: RETURN <br />
jmp ini<br />
gotbyte<br />
lda music<br />
inc gotbyte+1<br />
bne noinch<br />
inc gotbyte+2<br />
noinch<br />
rts<br />
;!byte 173,48,192,136,208,5,206,1,3,240,9,202,208,245,174,0,3,76,2,3,206,32,3,208,240,96<br />
beep:<br />
ldy #1<br />
ldx #1<br />
loc_302:<br />
LDA $C030<br />
<br />
loc_305:<br />
DEY<br />
BNE loc_30D<br />
DEC L301<br />
loc_30B:<br />
BEQ loc_316<br />
<br />
loc_30D:<br />
DEX<br />
BNE loc_305<br />
LDX L300<br />
JMP loc_302<br />
loc_316:<br />
DEC L320<br />
BNE loc_30B<br />
RTS<br />
L301 !byte 0<br />
L300 !byte 0<br />
L320 !byte 0<br />
music<br />
!word 76,192,85,64,96,64,102,64,114,128,114,64,96,64,102,64,114,64,128,64<br />
!word 114,64,152,64,171,64,152,512,76,192,85,64,96,64,102,64,114,128,114,64<br />
!word 96,64,102,64,114,64,128,64,114,64,152,64,171,64,152,512,85,64,85,64<br />
!word 85,64,96,64,144,128,144,64,128,64,76,128,85,64,96,64,144,128,114,64<br />
!word 96,64,102,128,114,64,128,64,128,128,114,64,128,64,114,512,85,64,85,64<br />
!word 85,64,96,64,144,128,144,64,128,64,76,128,85,64,96,64,144,128,114,64<br />
!word 96,64,102,128,114,64,128,64,128,64,128,128,96,64,85,64,96,64,102,64,114,64,114,64<br />
</syntaxhighlight><br />
<br />
=== Additional Resources ===<br />
* Deater's page on Apple II sizecoding http://www.deater.net/weave/vmwprod/demos/sizecoding.html<br />
* Article on double hi-res http://www.battlestations.zone/2017/04/apple-ii-double-hi-res-from-ground-up.html<br />
* Applesoft Hi-Res Subroutines : http://hackzapple.org/scripts_php/index.php?menu=5&mod=ASM&sub=AAL&sub2=8112&PHPSESSID=f65fabfd0cdbf56b6bdc0ddac25117c6#a2<br />
<br />
== Atari Lynx ==<br />
The Atari Lynx consists of the 6502 with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Atari Lynx:<br />
<br />
* Assembler: -<br />
* Emulator(s): -<br />
<br />
=== Video display ===<br />
To be added soon.<br />
<br />
==== Getting something on screen ====<br />
To be added soon.<br />
<br />
<br />
=== Sound ===<br />
To be added soon.<br />
<br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Additional Resources ===<br />
Sizecoding resource for the Atari Lynx are sparse<br />
* 42Bastian's website (link to be added)</div>Wilhttp://www.sizecoding.org/index.php?title=6502&diff=83465022021-02-16T21:07:10Z<p>Wil: /* Putting your program into zeropage overwriting part of CHRGET */ $AE trick</p>
<hr />
<div>== Introduction ==<br />
Wanting to start sizecoding on a 6502 platform in this day and age can be tough. <br />
<br />
[[File:6502.jpg|thumb]]<br />
<br />
So here is a bit of help to get you started:<br />
<br />
=== The 6502 processor ===<br />
The 6502 processor can be seen as the 8-bit micro ARM chip. <br />
It has only has 3 registers (Accumulator, X and Y registers) and a handful of instructions to work with.<br />
<br />
=== Adressing modes ===<br />
To be added.<br />
<br />
=== Zero page ===<br />
When using the 6502 for sizecoding, you'll mostly be working from zeropage<br />
<br />
=== General 6502 Resources ===<br />
* 6502.org http://www.6502.org/<br />
* 6502 instruction reference http://www.6502.org/tutorials/6502opcodes.html<br />
* 6502 books http://retro.hansotten.nl/6502-sbc/<br />
* 6502 Assembler tutorial https://dwheeler.com/6502/oneelkruns/asm1step.html<br />
* Easy 6502 code tester https://skilldrick.github.io/easy6502/<br />
* Synthetic instructions https://wiki.nesdev.com/w/index.php/Synthetic_instructions#8-bit_rotate<br />
<br />
== Atari 8-bit family ==<br />
The systems in this family are: Atari 400, 800, 5200, 1200XL, 600XL, 800XL, 130XE, 65XE, 800XE and XEGS.<br /><br />
<br />
The Atari 8-bit systems consists of the 6502 with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Atari 8bit systems is quite easy, first get the following tools:<br />
<br />
* Assembler: MADS Assembler - This assembler has nice macros for creating Binaries and SNA snapshot files out of the box. You can download it at https://mads.atari8.info/<br />
* Emulator(s): I Found Altirra to work best for my usecase. Make sure to use the original Rev2 rom for best compatibility.<br />
<br />
==== Special Memory Adresses ====<br />
* FRAMECOUNTER_HIGH = 19<br />
* FRAMECOUNTER_LOW = 20<br />
<br />
=== Video display ===<br />
Video display on the Atari 8bit systems use the ANTIC and GTIA chips. Information can be found here:<br />
* https://en.wikipedia.org/wiki/ANTIC<br />
* https://www.atariarchives.org/agagd/chapter1.php<br />
<br />
==== Sync with frame ====<br />
<syntaxhighlight lang="6502"><br />
RTCLOK equ $0012<br />
lda RTCLOK+2<br />
waits<br />
cmp RTCLOK+2<br />
beq waits<br />
</syntaxhighlight><br />
<br />
Or if you don't mind trashing RTCLOK<br />
<br />
<syntaxhighlight lang="6502"><br />
RTCLOK equ $0012<br />
waits<br />
lsr RTCLOK+2<br />
bcc waits<br />
</syntaxhighlight><br />
<br />
Which is two bytes shorter.<br />
<br />
==== Getting something on screen ====<br />
<syntaxhighlight lang="6502"><br />
;fill screen with charset,(88,89)=an address<br />
org $600; free 6th page:600-6ff<br />
ldy #0<br />
fl: tya<br />
sta(88),y<br />
iny<br />
bne fl<br />
jmp *<br />
</syntaxhighlight><br />
<br />
To be added soon.<br />
<br />
<syntaxhighlight lang="6502"><br />
SDMCTL = $022f<br />
HPOSP0 = $d000<br />
SIZEP0 = $d008<br />
GRAFP0 = $d00d<br />
COLPM0 = $d012<br />
<br />
FRAMECOUNTER_HIGH = 19<br />
FRAMECOUNTER = 20<br />
WSYNC = $d40a<br />
VCOUNT = $d40b<br />
<br />
sinewave = $0600 ; to $06ff<br />
<br />
org $80<br />
<br />
main <br />
; disable all graphics/colors<br />
ldx #0<br />
stx SDMCTL <br />
<br />
ldy #$7f<br />
sty SIZEP0 ; size p0=127<br />
<br />
ldx #0<br />
ldy #$3f<br />
make_sine:<br />
value_lo<br />
lda #0<br />
clc<br />
delta_lo<br />
adc #0<br />
sta value_lo+1<br />
value_hi<br />
lda #0<br />
delta_hi<br />
adc #0<br />
sta value_hi+1<br />
<br />
sta sinewave+$c0,x<br />
sta sinewave+$80,y<br />
eor #$7f<br />
sta sinewave+$40,x<br />
sta sinewave+$00,y<br />
<br />
lda delta_lo+1<br />
adc #8<br />
sta delta_lo+1<br />
bcc nothing<br />
inc delta_hi+1<br />
nothing<br />
inx<br />
dey<br />
bpl make_sine<br />
<br />
updateloop:<br />
; vblank<br />
lda VCOUNT<br />
bne updateloop<br />
<br />
; clear graphics<br />
sta HPOSP0<br />
sta GRAFP0<br />
<br />
ldy #0<br />
lda #47<br />
sta COLPM0<br />
yloop:<br />
tya ; graphics shape = y<br />
sta WSYNC<br />
sta GRAFP0<br />
<br />
; a = sin(frame+y)+48<br />
tya <br />
adc FRAMECOUNTER<br />
tax<br />
lda sinewave,x<br />
adc #48<br />
sta HPOSP0<br />
<br />
iny<br />
bne yloop<br />
jmp updateloop<br />
<br />
run main<br />
</syntaxhighlight><br />
<br />
=== Sound ===<br />
The Atari 8-bit use the POKEY chip to generate sound.<br />
* https://en.wikipedia.org/wiki/POKEY<br />
<br />
==== BASIC ====<br />
<syntaxhighlight lang="6502"><br />
; from Analog, 1985-09,pp.25-32<br />
*=$2000<br />
AUDF1=$D200<br />
AUDC1=$D201<br />
AUDCTL=$D208<br />
SKCTL=$D20F<br />
<br />
.MACRO SOUND ; voice,pitch,dist,vol;,dur<br />
lda #%2<br />
sta AUDF1+2*%1<br />
lda #[[%3 * 16] | %4] ;lda #[[%3 shl 4] or %4]<br />
sta AUDC1+2*%1<br />
.ENDM<br />
<br />
lda #0<br />
sta AUDCTL<br />
lda #3<br />
sta SKCTL<br />
<br />
SOUND 0,121,10,8<br />
<br />
jmp *<br />
</syntaxhighlight><br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Additional Resources ===<br />
Sizecoding resource for the Atari 8bit are:<br />
* Mapping the Atari https://www.atariarchives.org/mapping/<br />
* Atari 8bit Memory map https://www.atariarchives.org/mapping/memorymap.php<br />
* Fready's undocumented 6502 opcodes https://github.com/FreddyOffenga/6502<br />
* Atari OS Rev2 disassembly for MADS assembler https://github.com/ilmenit/A800-OS-XL-Rev2<br />
* Fready's github https://github.com/FreddyOffenga/<br />
<br />
== Commodore 64 ==<br />
The Commodore system consists of a 6502-compatible MOS 6510 processor with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Commodore systems is quite easy, first get the following tools:<br />
<br />
* Assembler: To be added<br />
* Emulator(s): VICE is the way to go<br />
<br />
=== Memory map ===<br />
<br />
<syntaxhighlight lang="6502"><br />
0-1 $0-$1 PROCESSOR PORT REGISTERS, not usable as RAM<br />
0-255 $0-$FF ZEROPAGE, mostly used by BASIC interpreter and Kernal<br />
256-511 $100-$1FF SYSTEM STACK<br />
512-600 $200-$258 INPUT BUFFER<br />
601-630 $259-$276 FILE SYSTEM DATA<br />
631-640 $277-$280 KEYBOARD BUFFER, filled by Kernal ISR upon key presses <br />
641-678 $281-$2A6 VARIOUS KERNAL VARIABLES<br />
679-767 $2A7-$2FF Unused (89 byte)<br />
768-779 $300-$30B KERNAL VECTORS<br />
780-783 $30C-$30F REGISTER VALUES A,X,Y,SR for SYS<br />
784-819 $310-$333 KERNAL VECTORS<br />
820-827 $334-$33B Unused (8 byte)<br />
828-1019 $33C-$3FB DATASETTE BUFFER<br />
1020-1023 $3FC-$3FF Unused (4 byte)<br />
1024-2023 $400-$7E7 SCREEN MEMORY (25 lines times 40 columns)<br />
2024-2039 $7E8-$7F7 Unused (16 byte)<br />
2040-2047 $7F8-$7FF SPRITE COSTUME POINTERS<br />
2048 $800 must contain a value of 0 so that the BASIC program can be RUN<br />
2049-40959 $801-$9FFF BASIC AREA (code, variables, arrays, strings)<br />
40960-49151 $A000-$BFFF BASIC ROM (unused RAM underneath)<br />
49152-53247 $C000-$CFFF UPPER RAM AREA (unused)<br />
53248-53294 $D000-$D02E VIC-II, memory-mapped graphics chip registers)<br />
54272-54300 $D400-$D41C SID, memory-mapped sound chip registers)<br />
55296-56295 $D800-$DBE7 Color RAM, only lower 4 bits are stored, higher nibble undefined<br />
56296-56319 $DBE8-$DBFF Unused (24 half-bytes)<br />
56320-56335 $DC00-$DC0F CIA#1, memory-mapped I/O chip registers for keyboard, joystick, mouse, datasette, IRQ control<br />
56576-56591 $DD00-$DD0F CIA#1, memory-mapped I/O chip registers for serial bus, RS232, NMI control<br />
57344-65535 $E000-$FFFF KERNAL ROM<br />
65534-65535 $FFFE-$FFFF Execution address of interrupt service routine, can only be set if KERNAL is turned off<br />
</syntaxhighlight><br />
<br />
For a detailed explanation of the C64 memory map check out [https://sta.c64.org/cbm64mem.html Commodore 64 memory map] on Joe Forster/STA homepage.<br />
<br />
=== Program file overhead ===<br />
<br />
A standard CBM file consists of a 2 byte loading address followed by the data that is placed into memory starting at this address. In addition, if your machine program should be able to be started with "RUN", you need a BASIC stub that is loaded into memory from $0801 to $080c, typically followed by your machine program:<br />
<br />
<syntaxhighlight lang="6502"><br />
*=$0801<br />
.word $080b ;address of next BASIC line<br />
.word LINENR ;line number, can be chosen between 0 and 63999<br />
.byte $9e ;token for SYS command<br />
.byte $32,$30,$36,$31 ;address to jump to in ASCII code: "2061" <br />
.byte $00 ;end of BASIC line<br />
.word $0000 ;address of next BASIC line, $0000 means end of BASIC program <br />
start<br />
; your code here<br />
</syntaxhighlight><br />
<br />
Together with the 2 byte load address, this makes an overhead of 14 byte for your program. To reduce this, you can<br />
* omit the BASIC line and tell users to start your program by directly entering "SYS ''address''"<br />
* save your program from $0802 on, the byte at $0801 is recovered automatically after loading by the relink function. This reduces your program file size by 1 byte<br />
* accept the loss and use the 2 byte establishing LINENR for something good, they are copied to zeropage addresses $39/$3a automatically, saving you the effort of initializing the addresses<br />
* use an autostart method (see below)<br />
<br />
Some compos also specify that the BASIC loader does not count towards the overall filesize, check the rules before you worry.<br />
<br />
=== Autostart ===<br />
<br />
Unlike the Commodore 128, the Commodore 64 has no dedicated built-in auto-boot feature, but it is possible to autorun a program after loading by specifying the load address so that it overwrites a vector or address that is called by the operating system. There are multiple possibilities:<br />
<br />
==== Overwriting CHROUT vector at $326-$327 ====<br />
<br />
The vector at address $326-$327 points at the CHROUT routine, normally at address $F1CA.<br />
If you put the entry address of your program into $326/27, your code will be called when the operating system wants to print "READY." after loading.<br />
Note that the vector at address $328-$329 points at the STOP routine that checks the status of Stop key indicator. Since this routine is called multiple times before your code is done loading, its default value $F6ED needs to be preserved. <br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$0326<br />
.word start <br />
.byte $ed,$f6<br />
start<br />
; rest of code<br />
</syntaxhighlight><br />
<br />
Together with the two byte load address, the overwritten CHROUT vector and the preserved STOP vector, your program file will have a deadweight of 6 byte: $26 $03 $0a $03 $ed $f6, less than half of the standard version with a BASIC stub with SYS<br />
<br />
Caveat:<br />
* If your program after $32a is longer than 214 byte, part of your program will load into the screen at $400. Thus, issuing a clear screen will overwrite your program. It is possible to move the screen memory somewhere else, but that requires storing a new value into address $D018, which when done with an LDA # / STA pair will cost you 5 byte<br />
* Since you changed the CHROUT pointer, standard KERNAL functions for printing won't work. For output of single characters, you can still use the direct address $F1CA. Alternatively, you can restore the vectors by calling $FD15, which will overwrite the memory $314 to $333 with the default values.<br />
* The memory area $33C-$3FB is the datasette buffer, thus loading a program into this area won't work when loading from a cassette.<br />
<br />
==== Overwriting BASIC idle loop vector at $302-$303 ====<br />
<br />
After loading the program, the BASIC idle loop will be called. By overwriting the vector at $302/$303 it is possible to autostart your program. Since the memory before $302 can be safely overwritten, the program would be arranged so that $303 is the '''last''' address of your program. If your program requires a loop back to the start, the vector can be used as part of a JMP where the following two bytes are already there, saving one byte in comparison to a loop done with a branch command.<br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$304 - (end - start)<br />
start:<br />
;your code here<br />
; ...<br />
jmp start ;the address for start lies in $302/$303, thus will be called by the Kernal after loading<br />
end:<br />
</syntaxhighlight><br />
<br />
In cases where the vector has a practical use, the overhead in filesize is only the 2 byte loading address. For programs larger than 93 byte keep in mind that addresses before $2A7 are in use by the Kernal.<br />
<br />
==== Overwriting return address on stack at $1F8 ====<br />
<br />
When the load routine is called, the stack pointer is always at $FA at a stock C64. Thus the return address from the loading process is stored in memory address $F8 (low byte) and $F9 (high byte). During the loading routine, stack usage will clobber the stack below $1F8, but a program loaded to $1F8 and above will be fine and the overwritten address stored at $1F8/$1F9 will be called after loading.<br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$1F8<br />
.word start-1 ;adjust for the RTS command pulling the address from stack and increasing it by 1<br />
start:<br />
;your code here<br />
</syntaxhighlight><br />
<br />
For programs larger than 95 byte keep in mind that addresses after $259 are in use by the Kernal, you might overwrite some values here if you don't have disk operations, but better check the memory map beforehand.<br />
<br />
Together with the two byte load address and the overwritten address at $1F8/$1F9, your program file will have a deadweight of 4 byte when using this method.<br />
<br />
==== Putting your program into zeropage overwriting part of CHRGET ====<br />
<br />
CHRGET is a machine code routine for the BASIC interpreter that is placed in the zero page at $73-$8A. By putting your program at $7C and following, the CHRGET routine runs directly into your code.<br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$7C<br />
start:<br />
;your code here<br />
</syntaxhighlight><br />
<br />
With this method, there is no need for a start address vector. The only deadweight in your program is the loading address. However, the zero page is a busy place, if your program extends beyond address $8f (that is it has more than 22 bytes on disk) you have to deal with some parts of your program being overwritten, for example, the status byte in $90 is set after loading.<br />
<br />
Loading data into address $A9 has an interesting side effect - the vector of $AE/$AF defines the address where the loaded bytes are written to. If $AE gets overwritten with, for example, $40, the next byte will be written to $41 (because the vector is incremented after the write). This can be used to split your program into different parts of memory.<br />
<br />
=== Video display ===<br />
Video display on the Commodore has the following video modes:<br />
* Standard text mode, 40x25 characters, 1 individual color per character, 1 common background color<br />
* Multicolor text mode, 40x25 characters, every two bits (fat pixel) define color: background, char, common color 1+2<br />
* Extended color text mode, 40x25 characters, 1 individual foreground color per character, 1 out of 4 background colors, only 64 chars<br />
* Hires bitmap, 320x200 pixels, an 8x8 field can have an individual foreground and an individual background color<br />
* Multicolor bitmap, 160x200 pixels, every two bits (fat pixel) define color: background, screen color lower nibble, screen color higher nibble, color from color RAM<br />
<br />
==== Sync with frame ====<br />
<br />
Depending on the VIC type, there are 262/263 raster lines (NTSC) or 312 raster lines (PAL-B). Therefore, the VIC uses register at $D011 and the highest bit of register $D012 to represent the current raster line. Checking only the lower 8 bits and waiting for them to be 0 would therefore not work because this happens two times per frame. However, any number greater than 64 will only trigger once. Using a value of 255, we would sync to a rasterline at the end of the screen, well below the part where graphics are normally displayed:<br />
<br />
<syntaxhighlight lang="6502"><br />
lda #$FF<br />
waitsync:<br />
cmp $D012<br />
bne waitsync<br />
</syntaxhighlight><br />
<br />
As long as there have more than 63 cycles passed since the snyc, the next sync will happen at the next frame.<br />
This works fine as long as we don't miss the line 255 due to an interrupt. If your program has interrupts that are not synced to a rasterline, you can change the condition as follows<br />
<syntaxhighlight lang="6502"><br />
lda #$E3<br />
waitsync:<br />
cmp $D012<br />
bcs waitsync<br />
</syntaxhighlight><br />
<br />
Now we have a window between raster line $E4 and $FF to trigger our sync, which we will meet even if a standard Kernal interrupt comes in-between. Of course, our main program now has to burn around 1700 cycles to avoid a retriggering in the same frame.<br />
<br />
==== Getting something on screen ====<br />
<br />
Output a character:<br />
<syntaxhighlight lang="6502"><br />
lda #C ;C must be the char code according to the PETSCII code table<br />
jsr $FFD2 ;you can also use the direct address $FC1A, function preserves A,X,Y and enables interrupt<br />
</syntaxhighlight><br />
<br />
Since the [https://en.wikipedia.org/wiki/PETSCII#Character_set PETSCII code table] contains also control characters, this method can be also used to clear the screen, move the cursor or set the text color. However, some functions are shorter (and faster) by directly calling the respective KERNAL function:<br />
<br />
<syntaxhighlight lang="6502"><br />
Clear screen JSR $E544<br />
Cursor home position JSR $E566<br />
Output newline character JSR $AAD7<br />
Set text color LDA #COLOR, STA $286<br />
Set border color LDA #COLOR, STA $D020 ;not possible with a PETSCII control code<br />
Set background color LDA #COLOR, STA $D021 ;not possible with a PETSCII control code<br />
</syntaxhighlight><br />
<br />
Copy characters directly to screen memory:<br />
<br />
<syntaxhighlight lang="6502"><br />
.macpack cbm ;scrcode macro<br />
SCREEN_BASE=$400<br />
LINE=5 ;for example<br />
COLUMN=10 ;for example<br />
<br />
ldx #endtext-text-1<br />
@loop: lda text,x<br />
sta SCREEN_BASE+LINE*40+COLUMN,x<br />
dex<br />
bpl @loop<br />
text: scrcode "hello world!"<br />
endtext:<br />
</syntaxhighlight><br />
<br />
Note that the text needs to be stored in '''screen code''' format, not in PETSCII (see [https://sta.c64.org/cbm64pettoscr.html Commodore 64 PETSCII code to screen code conversion] for the differences). Furthermore, the example above only writes to the screen memory, not the color RAM, assuming that the color RAM already contains the intended text color. This is the case after issuing a clear screen on most C64 machines, except for some old ROM revisions. To be on the save side you would have to write to color RAM as well, which costs another 5 byte:<br />
<br />
<syntaxhighlight lang="6502"><br />
.macpack cbm ;scrcode macro<br />
SCREEN_BASE=$400<br />
COLOR_RAM =$D800<br />
LINE =5 ;for example<br />
COLUMN =10 ;for example<br />
COLOR =1 ;white<br />
<br />
ldx #endtext-text-1<br />
@loop: lda text,x<br />
sta SCREEN_BASE+LINE*40+COLUMN,x<br />
lda #COLOR<br />
sta COLOR_RAM +LINE*40+COLUMN,x<br />
dex<br />
bpl @loop<br />
text: scrcode "hello world!"<br />
endtext:<br />
</syntaxhighlight><br />
<br />
=== Sound ===<br />
The Commodore 64 uses the famous SID chip to generate sound.<br />
To be added soon.<br />
<br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Useful Kernal functions ===<br />
<br />
==== Get a pseudo random number ====<br />
<br />
<syntaxhighlight lang="6502"><br />
lda #1 <br />
jsr $E09A<br />
lda $63<br />
</syntaxhighlight><br />
<br />
The sequence of random numbers is always the same after a cold start or reset, the first 20 numbers are:<br />
<syntaxhighlight lang="6502"><br />
4,24,231,4,177,170,193,101,231,18,196,1,75,48,149,36,124,53,65,154<br />
</syntaxhighlight><br />
<br />
==== Increment a zero page counter, return in X register, clear Y register ====<br />
<br />
This is part of the string handling function in the BASIC ROM, but the code could be useful for some loop stuff.<br />
<br />
<syntaxhighlight lang="6502"><br />
jsr $B5FF ;does inc $23, ldx $23, ldy #$00, rts<br />
</syntaxhighlight><br />
<br />
=== Additional Resources ===<br />
* Codebase 64 https://codebase64.org/doku.php?id=base:start<br />
* Commodore 64 Memory map https://sta.c64.org/cbm64mem.html<br />
* C64 BASIC & KERNAL ROM Disassembly https://www.pagetable.com/c64ref/c64disasm/<br />
* No More Secrets https://csdb.dk/release/?id=198357 Everything about illegal opcodes and their use in a C64 system<br />
<br />
== Apple II ==<br />
The Apple II is an 8-bit home computer and one of the world's first highly successful mass-produced microcomputer products. It was designed primarily by Steve Wozniak.<br />
<br />
=== Setting up ===<br />
* ACME 6502 cross-assembler(https://sourceforge.net/projects/acme-crossass/)<br />
* Apple Commander (http://applecommander.sourceforge.net) for batch compilation<br />
* AppleWin emulator (https://github.com/AppleWin/AppleWin/releases). Supports Mockingboard card(AY-8910+speech synthesier), HDD, Z80 card(for CP/M), mouse etc.<br />
* CiderPress(https://a2ciderpress.com)<br />
<br />
Compilation can be done as follows (master.dsk can be found with applewin) <br />
<syntaxhighlight><br />
acme hl.asm<br />
java -jar AppleCommander-1.3.5.jar -d master.dsk hl<br />
java -jar AppleCommander-1.3.5.jar -p master.dsk hl B 24576 < hl.bin<br />
</syntaxhighlight><br />
<br />
=== Memory Map ===<br />
<syntaxhighlight lang="6502"><br />
0-255 $0-$FF ZERO-PAGE SYSTEM STORAGE<br />
256-511 $100-$1FF SYSTEM STACK<br />
512-767 $200-$2FF KEYBOARD CHARACTER BUFFER<br />
768-975 $300-$3CF OFTEN AVAILABLE AS FREE SPACE FOR USER PROGRAMS<br />
976-1023 $3D0-3FF SYSTEM VECTORS<br />
1024-2047 $400-$7FF TEXT AND LO-RES GRAPHICS PAGE 1 <--- !!!<br />
2048-LOMEM $800-LOMEM PROGRAM STORAGE<br />
2048-3071 $800-$BFF TEXT AND LO-RES GRAPHICS PAGE 2 OR FREE SPACE<br />
3072-8191 $C00-$1FFF FREE SPACE UNLESS RAM APPLESOFT IS IN USE<br />
8192-16383 $2000-$3FFF HI-RES PAGE 1 OR FREE SPACE <--- !!!<br />
16384-24575 $4000-$5FFF HI-RES PAGE 2 OR FREE SPACE<br />
24576-38999 $6000-$95FF FREE SPACE AND STRING STORAGE<br />
38400-49151 $9600-$BFFF DOS<br />
49152-53247 $C000-$CFFF I/O HARDWARE (RESERVED)<br />
53248-57343 $D000-$DFFF APPLESOFT IN LANGUAGE CARD OR ROM<br />
57344-63487 $E000-$F7FF APPLESOFT OR INTEGER BASIC IN LANGUAGE CARD OR ROM<br />
63488-65535 $F800-$FFFF SYSTEM MONITOR<br />
</syntaxhighlight><br />
<br />
=== Display ===<br />
<br />
=== Graphics Modes ===<br />
: Text Mode 40x24, for Apple IIe available 80x25 - use PR#3 for switch mode, or hardware switch<br />
: LowRes 40x48, 16 colors: https://en.wikipedia.org/wiki/Apple_II_graphics <br />
: Hires mode 280x192,6 colors: https://www.xtof.info/blog/?p=768<br />
https://mrob.com/pub/xapple2/colors.html<br />
https://archive.org/details/HiRes_Color_Graphics_on_the_Apple_II_Computer_by_Wozniak<br />
<br />
However for sizecoding, you almost never want to do direct-access to graphics for Apple II in size-coding because the Apple II graphics modes are horrible. The only fast way to do things is with large lookup tables. To do hires you need to divide by 7 which as you can imagine is a bit difficult to do compactly on 6502. Double-hires is even crazier on top of that. Deater did manage a color-bar style effect in double-hires in 128B but that was doing some crazy tricks with the firmware BASIC routines, definitely not direct-access.<br />
<br />
Lores and Hires can be mixed modes and full-graphics<br />
The screen structure is called memory holes(https://retrocomputing.stackexchange.com/questions/2534/what-are-the-screen-holes-in-apple-ii-graphics). The GBASCALC($F847) procedure is used to calculate the address of the horizontal line : IN:reg.A=Y, out : GBASL/GBASH($26/$27)=address. See also https://www.callapple.org/uncategorized/use-of-apple-ii-color-graphics-in-assembly-language/<br />
<br />
==== Getting something on screen ====<br />
Here is an example of a XOR texture, created by g0blinish<br />
<syntaxhighlight lang="6502"><br />
*=$6000<br />
!to "HL.bin", plain ; set output file and format<br />
!cpu 6502 ; set processor type<br />
<br />
GBASL = $26<br />
GBASH = $27<br />
SETGR = $FB40 ; setup LoRes<br />
GBASCALC = $F847 ; calc Address<br />
<br />
CLRTEXT = $C050 ;display graphics <br />
SETTEXT = $C051 ;display text <br />
<br />
CLRMIXED = $C052 ;clear mixed mode- enable full graphics <br />
SETMIXED = $C053 ;enable graphics/text mixed mode <br />
<br />
PAGE1 = $C054 ;select text/graphics page1 <br />
PAGE2 = $C055 ;select text/graphics page2 <br />
<br />
CLRHIRES = $C056 ;select Lo-res <br />
SETHIRES = $C057 ;select Hi-res <br />
<br />
TMP= $FA<br />
<br />
JSR SETGR ;GR<br />
BIT CLRMIXED ; full screen<br />
<br />
LDA #0 ; A=0<br />
STA TMP ; POKE $FA,A<br />
<br />
YLP ;<br />
LDA TMP ; A=PEEK($FA)<br />
; LSR ; A=A/2<br />
JSR GBASCALC<br />
LDY #0;Y=0<br />
<br />
XLP TYA ; A=Y<br />
EOR TMP ; A=A xor PEEK($FA)<br />
and #$0F ; A=A and 15<br />
TAX ; X=A<br />
LDA COLORS,X ;A=PEEK(COLORS+X)<br />
STA(GBASL),Y ; POKE PEEK($26)+256*PEEK($27)+Y,A<br />
INY ; Y=Y+1<br />
CPY #40 ; Y=40?<br />
BNE XLP<br />
INC TMP ; POKE $FA,PEEK($FA)+1<br />
LDA TMP ; A=PEEK($FA)<br />
CMP #24 ; A=24?<br />
BNE YLP<br />
<br />
M1 JMP M1 ; replace to RTS<br />
<br />
COLORS ;N*17, pixel format is AAAABBBB, AAAA - upper dot, BBBB - lower dot<br />
!byte $00,$11,$22,$33,$44,$55,$66,$77<br />
!byte $88,$99,$AA,$BB,$CC,$DD,$EE,$FF<br />
</syntaxhighlight><br />
<br />
==== Sound ====<br />
Here is an example for using the speaker, based onthe following basic program:<br />
<br />
<syntaxhighlight lang="basic"><br />
; 50 POKE 768,V: POKE 769,P - 255 * INT (P / 256): POKE 800,1 + P / 256<br />
; 60 CALL 770: RETURN <br />
; 95 FOR K = 1 TO N: READ V(K),P(K): NEXT K<br />
; 100 FOR K = 1 TO N:V = V(K):P = P(K)<br />
; 110 GOSUB 50<br />
;!byte 173,48,192,136,208,5,206,1,3,240,9,202,208,245,174,0,3,76,2,3,206,32,3,208,240,96<br />
</syntaxhighlight><br />
<br />
<syntaxhighlight lang="6502"><br />
*=$6000<br />
!to "HL.bin", plain ; set output file and format<br />
!cpu 6502 ; set processor type<br />
<br />
;start<br />
; 95 FOR K = 1 TO N: READ V(K),P(K): NEXT K<br />
; 100 FOR K = 1 TO N:V = V(K):P = P(K)<br />
ini:<br />
lda #70<br />
sta cnt+1<br />
lda #music&255<br />
sta gotbyte+1<br />
lda #music/256<br />
sta gotbyte+2<br />
<br />
lop:<br />
;V<br />
jsr gotbyte<br />
sta L300<br />
jsr gotbyte<br />
;P<br />
jsr gotbyte<br />
sta L301<br />
jsr gotbyte<br />
clc<br />
adc #1<br />
sta L320<br />
jsr beep<br />
<br />
dec cnt+1<br />
cnt lda #70<br />
bne lop<br />
; 110 GOSUB 50<br />
; 50 POKE 768,V: POKE 769,P - 255 * INT (P / 256): POKE 800,1 + P / 256<br />
; 60 CALL 770: RETURN <br />
jmp ini<br />
gotbyte<br />
lda music<br />
inc gotbyte+1<br />
bne noinch<br />
inc gotbyte+2<br />
noinch<br />
rts<br />
;!byte 173,48,192,136,208,5,206,1,3,240,9,202,208,245,174,0,3,76,2,3,206,32,3,208,240,96<br />
beep:<br />
ldy #1<br />
ldx #1<br />
loc_302:<br />
LDA $C030<br />
<br />
loc_305:<br />
DEY<br />
BNE loc_30D<br />
DEC L301<br />
loc_30B:<br />
BEQ loc_316<br />
<br />
loc_30D:<br />
DEX<br />
BNE loc_305<br />
LDX L300<br />
JMP loc_302<br />
loc_316:<br />
DEC L320<br />
BNE loc_30B<br />
RTS<br />
L301 !byte 0<br />
L300 !byte 0<br />
L320 !byte 0<br />
music<br />
!word 76,192,85,64,96,64,102,64,114,128,114,64,96,64,102,64,114,64,128,64<br />
!word 114,64,152,64,171,64,152,512,76,192,85,64,96,64,102,64,114,128,114,64<br />
!word 96,64,102,64,114,64,128,64,114,64,152,64,171,64,152,512,85,64,85,64<br />
!word 85,64,96,64,144,128,144,64,128,64,76,128,85,64,96,64,144,128,114,64<br />
!word 96,64,102,128,114,64,128,64,128,128,114,64,128,64,114,512,85,64,85,64<br />
!word 85,64,96,64,144,128,144,64,128,64,76,128,85,64,96,64,144,128,114,64<br />
!word 96,64,102,128,114,64,128,64,128,64,128,128,96,64,85,64,96,64,102,64,114,64,114,64<br />
</syntaxhighlight><br />
<br />
=== Additional Resources ===<br />
* Deater's page on Apple II sizecoding http://www.deater.net/weave/vmwprod/demos/sizecoding.html<br />
* Article on double hi-res http://www.battlestations.zone/2017/04/apple-ii-double-hi-res-from-ground-up.html<br />
* Applesoft Hi-Res Subroutines : http://hackzapple.org/scripts_php/index.php?menu=5&mod=ASM&sub=AAL&sub2=8112&PHPSESSID=f65fabfd0cdbf56b6bdc0ddac25117c6#a2<br />
<br />
== Atari Lynx ==<br />
The Atari Lynx consists of the 6502 with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Atari Lynx:<br />
<br />
* Assembler: -<br />
* Emulator(s): -<br />
<br />
=== Video display ===<br />
To be added soon.<br />
<br />
==== Getting something on screen ====<br />
To be added soon.<br />
<br />
<br />
=== Sound ===<br />
To be added soon.<br />
<br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Additional Resources ===<br />
Sizecoding resource for the Atari Lynx are sparse<br />
* 42Bastian's website (link to be added)</div>Wilhttp://www.sizecoding.org/index.php?title=6502&diff=83365022021-02-16T20:57:54Z<p>Wil: added link to No More Secrets document (use of illegal 6502 opcodes in C64)</p>
<hr />
<div>== Introduction ==<br />
Wanting to start sizecoding on a 6502 platform in this day and age can be tough. <br />
<br />
[[File:6502.jpg|thumb]]<br />
<br />
So here is a bit of help to get you started:<br />
<br />
=== The 6502 processor ===<br />
The 6502 processor can be seen as the 8-bit micro ARM chip. <br />
It has only has 3 registers (Accumulator, X and Y registers) and a handful of instructions to work with.<br />
<br />
=== Adressing modes ===<br />
To be added.<br />
<br />
=== Zero page ===<br />
When using the 6502 for sizecoding, you'll mostly be working from zeropage<br />
<br />
=== General 6502 Resources ===<br />
* 6502.org http://www.6502.org/<br />
* 6502 instruction reference http://www.6502.org/tutorials/6502opcodes.html<br />
* 6502 books http://retro.hansotten.nl/6502-sbc/<br />
* 6502 Assembler tutorial https://dwheeler.com/6502/oneelkruns/asm1step.html<br />
* Easy 6502 code tester https://skilldrick.github.io/easy6502/<br />
* Synthetic instructions https://wiki.nesdev.com/w/index.php/Synthetic_instructions#8-bit_rotate<br />
<br />
== Atari 8-bit family ==<br />
The systems in this family are: Atari 400, 800, 5200, 1200XL, 600XL, 800XL, 130XE, 65XE, 800XE and XEGS.<br /><br />
<br />
The Atari 8-bit systems consists of the 6502 with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Atari 8bit systems is quite easy, first get the following tools:<br />
<br />
* Assembler: MADS Assembler - This assembler has nice macros for creating Binaries and SNA snapshot files out of the box. You can download it at https://mads.atari8.info/<br />
* Emulator(s): I Found Altirra to work best for my usecase. Make sure to use the original Rev2 rom for best compatibility.<br />
<br />
==== Special Memory Adresses ====<br />
* FRAMECOUNTER_HIGH = 19<br />
* FRAMECOUNTER_LOW = 20<br />
<br />
=== Video display ===<br />
Video display on the Atari 8bit systems use the ANTIC and GTIA chips. Information can be found here:<br />
* https://en.wikipedia.org/wiki/ANTIC<br />
* https://www.atariarchives.org/agagd/chapter1.php<br />
<br />
==== Sync with frame ====<br />
<syntaxhighlight lang="6502"><br />
RTCLOK equ $0012<br />
lda RTCLOK+2<br />
waits<br />
cmp RTCLOK+2<br />
beq waits<br />
</syntaxhighlight><br />
<br />
Or if you don't mind trashing RTCLOK<br />
<br />
<syntaxhighlight lang="6502"><br />
RTCLOK equ $0012<br />
waits<br />
lsr RTCLOK+2<br />
bcc waits<br />
</syntaxhighlight><br />
<br />
Which is two bytes shorter.<br />
<br />
==== Getting something on screen ====<br />
<syntaxhighlight lang="6502"><br />
;fill screen with charset,(88,89)=an address<br />
org $600; free 6th page:600-6ff<br />
ldy #0<br />
fl: tya<br />
sta(88),y<br />
iny<br />
bne fl<br />
jmp *<br />
</syntaxhighlight><br />
<br />
To be added soon.<br />
<br />
<syntaxhighlight lang="6502"><br />
SDMCTL = $022f<br />
HPOSP0 = $d000<br />
SIZEP0 = $d008<br />
GRAFP0 = $d00d<br />
COLPM0 = $d012<br />
<br />
FRAMECOUNTER_HIGH = 19<br />
FRAMECOUNTER = 20<br />
WSYNC = $d40a<br />
VCOUNT = $d40b<br />
<br />
sinewave = $0600 ; to $06ff<br />
<br />
org $80<br />
<br />
main <br />
; disable all graphics/colors<br />
ldx #0<br />
stx SDMCTL <br />
<br />
ldy #$7f<br />
sty SIZEP0 ; size p0=127<br />
<br />
ldx #0<br />
ldy #$3f<br />
make_sine:<br />
value_lo<br />
lda #0<br />
clc<br />
delta_lo<br />
adc #0<br />
sta value_lo+1<br />
value_hi<br />
lda #0<br />
delta_hi<br />
adc #0<br />
sta value_hi+1<br />
<br />
sta sinewave+$c0,x<br />
sta sinewave+$80,y<br />
eor #$7f<br />
sta sinewave+$40,x<br />
sta sinewave+$00,y<br />
<br />
lda delta_lo+1<br />
adc #8<br />
sta delta_lo+1<br />
bcc nothing<br />
inc delta_hi+1<br />
nothing<br />
inx<br />
dey<br />
bpl make_sine<br />
<br />
updateloop:<br />
; vblank<br />
lda VCOUNT<br />
bne updateloop<br />
<br />
; clear graphics<br />
sta HPOSP0<br />
sta GRAFP0<br />
<br />
ldy #0<br />
lda #47<br />
sta COLPM0<br />
yloop:<br />
tya ; graphics shape = y<br />
sta WSYNC<br />
sta GRAFP0<br />
<br />
; a = sin(frame+y)+48<br />
tya <br />
adc FRAMECOUNTER<br />
tax<br />
lda sinewave,x<br />
adc #48<br />
sta HPOSP0<br />
<br />
iny<br />
bne yloop<br />
jmp updateloop<br />
<br />
run main<br />
</syntaxhighlight><br />
<br />
=== Sound ===<br />
The Atari 8-bit use the POKEY chip to generate sound.<br />
* https://en.wikipedia.org/wiki/POKEY<br />
<br />
==== BASIC ====<br />
<syntaxhighlight lang="6502"><br />
; from Analog, 1985-09,pp.25-32<br />
*=$2000<br />
AUDF1=$D200<br />
AUDC1=$D201<br />
AUDCTL=$D208<br />
SKCTL=$D20F<br />
<br />
.MACRO SOUND ; voice,pitch,dist,vol;,dur<br />
lda #%2<br />
sta AUDF1+2*%1<br />
lda #[[%3 * 16] | %4] ;lda #[[%3 shl 4] or %4]<br />
sta AUDC1+2*%1<br />
.ENDM<br />
<br />
lda #0<br />
sta AUDCTL<br />
lda #3<br />
sta SKCTL<br />
<br />
SOUND 0,121,10,8<br />
<br />
jmp *<br />
</syntaxhighlight><br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Additional Resources ===<br />
Sizecoding resource for the Atari 8bit are:<br />
* Mapping the Atari https://www.atariarchives.org/mapping/<br />
* Atari 8bit Memory map https://www.atariarchives.org/mapping/memorymap.php<br />
* Fready's undocumented 6502 opcodes https://github.com/FreddyOffenga/6502<br />
* Atari OS Rev2 disassembly for MADS assembler https://github.com/ilmenit/A800-OS-XL-Rev2<br />
* Fready's github https://github.com/FreddyOffenga/<br />
<br />
== Commodore 64 ==<br />
The Commodore system consists of a 6502-compatible MOS 6510 processor with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Commodore systems is quite easy, first get the following tools:<br />
<br />
* Assembler: To be added<br />
* Emulator(s): VICE is the way to go<br />
<br />
=== Memory map ===<br />
<br />
<syntaxhighlight lang="6502"><br />
0-1 $0-$1 PROCESSOR PORT REGISTERS, not usable as RAM<br />
0-255 $0-$FF ZEROPAGE, mostly used by BASIC interpreter and Kernal<br />
256-511 $100-$1FF SYSTEM STACK<br />
512-600 $200-$258 INPUT BUFFER<br />
601-630 $259-$276 FILE SYSTEM DATA<br />
631-640 $277-$280 KEYBOARD BUFFER, filled by Kernal ISR upon key presses <br />
641-678 $281-$2A6 VARIOUS KERNAL VARIABLES<br />
679-767 $2A7-$2FF Unused (89 byte)<br />
768-779 $300-$30B KERNAL VECTORS<br />
780-783 $30C-$30F REGISTER VALUES A,X,Y,SR for SYS<br />
784-819 $310-$333 KERNAL VECTORS<br />
820-827 $334-$33B Unused (8 byte)<br />
828-1019 $33C-$3FB DATASETTE BUFFER<br />
1020-1023 $3FC-$3FF Unused (4 byte)<br />
1024-2023 $400-$7E7 SCREEN MEMORY (25 lines times 40 columns)<br />
2024-2039 $7E8-$7F7 Unused (16 byte)<br />
2040-2047 $7F8-$7FF SPRITE COSTUME POINTERS<br />
2048 $800 must contain a value of 0 so that the BASIC program can be RUN<br />
2049-40959 $801-$9FFF BASIC AREA (code, variables, arrays, strings)<br />
40960-49151 $A000-$BFFF BASIC ROM (unused RAM underneath)<br />
49152-53247 $C000-$CFFF UPPER RAM AREA (unused)<br />
53248-53294 $D000-$D02E VIC-II, memory-mapped graphics chip registers)<br />
54272-54300 $D400-$D41C SID, memory-mapped sound chip registers)<br />
55296-56295 $D800-$DBE7 Color RAM, only lower 4 bits are stored, higher nibble undefined<br />
56296-56319 $DBE8-$DBFF Unused (24 half-bytes)<br />
56320-56335 $DC00-$DC0F CIA#1, memory-mapped I/O chip registers for keyboard, joystick, mouse, datasette, IRQ control<br />
56576-56591 $DD00-$DD0F CIA#1, memory-mapped I/O chip registers for serial bus, RS232, NMI control<br />
57344-65535 $E000-$FFFF KERNAL ROM<br />
65534-65535 $FFFE-$FFFF Execution address of interrupt service routine, can only be set if KERNAL is turned off<br />
</syntaxhighlight><br />
<br />
For a detailed explanation of the C64 memory map check out [https://sta.c64.org/cbm64mem.html Commodore 64 memory map] on Joe Forster/STA homepage.<br />
<br />
=== Program file overhead ===<br />
<br />
A standard CBM file consists of a 2 byte loading address followed by the data that is placed into memory starting at this address. In addition, if your machine program should be able to be started with "RUN", you need a BASIC stub that is loaded into memory from $0801 to $080c, typically followed by your machine program:<br />
<br />
<syntaxhighlight lang="6502"><br />
*=$0801<br />
.word $080b ;address of next BASIC line<br />
.word LINENR ;line number, can be chosen between 0 and 63999<br />
.byte $9e ;token for SYS command<br />
.byte $32,$30,$36,$31 ;address to jump to in ASCII code: "2061" <br />
.byte $00 ;end of BASIC line<br />
.word $0000 ;address of next BASIC line, $0000 means end of BASIC program <br />
start<br />
; your code here<br />
</syntaxhighlight><br />
<br />
Together with the 2 byte load address, this makes an overhead of 14 byte for your program. To reduce this, you can<br />
* omit the BASIC line and tell users to start your program by directly entering "SYS ''address''"<br />
* save your program from $0802 on, the byte at $0801 is recovered automatically after loading by the relink function. This reduces your program file size by 1 byte<br />
* accept the loss and use the 2 byte establishing LINENR for something good, they are copied to zeropage addresses $39/$3a automatically, saving you the effort of initializing the addresses<br />
* use an autostart method (see below)<br />
<br />
Some compos also specify that the BASIC loader does not count towards the overall filesize, check the rules before you worry.<br />
<br />
=== Autostart ===<br />
<br />
Unlike the Commodore 128, the Commodore 64 has no dedicated built-in auto-boot feature, but it is possible to autorun a program after loading by specifying the load address so that it overwrites a vector or address that is called by the operating system. There are multiple possibilities:<br />
<br />
==== Overwriting CHROUT vector at $326-$327 ====<br />
<br />
The vector at address $326-$327 points at the CHROUT routine, normally at address $F1CA.<br />
If you put the entry address of your program into $326/27, your code will be called when the operating system wants to print "READY." after loading.<br />
Note that the vector at address $328-$329 points at the STOP routine that checks the status of Stop key indicator. Since this routine is called multiple times before your code is done loading, its default value $F6ED needs to be preserved. <br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$0326<br />
.word start <br />
.byte $ed,$f6<br />
start<br />
; rest of code<br />
</syntaxhighlight><br />
<br />
Together with the two byte load address, the overwritten CHROUT vector and the preserved STOP vector, your program file will have a deadweight of 6 byte: $26 $03 $0a $03 $ed $f6, less than half of the standard version with a BASIC stub with SYS<br />
<br />
Caveat:<br />
* If your program after $32a is longer than 214 byte, part of your program will load into the screen at $400. Thus, issuing a clear screen will overwrite your program. It is possible to move the screen memory somewhere else, but that requires storing a new value into address $D018, which when done with an LDA # / STA pair will cost you 5 byte<br />
* Since you changed the CHROUT pointer, standard KERNAL functions for printing won't work. For output of single characters, you can still use the direct address $F1CA. Alternatively, you can restore the vectors by calling $FD15, which will overwrite the memory $314 to $333 with the default values.<br />
* The memory area $33C-$3FB is the datasette buffer, thus loading a program into this area won't work when loading from a cassette.<br />
<br />
==== Overwriting BASIC idle loop vector at $302-$303 ====<br />
<br />
After loading the program, the BASIC idle loop will be called. By overwriting the vector at $302/$303 it is possible to autostart your program. Since the memory before $302 can be safely overwritten, the program would be arranged so that $303 is the '''last''' address of your program. If your program requires a loop back to the start, the vector can be used as part of a JMP where the following two bytes are already there, saving one byte in comparison to a loop done with a branch command.<br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$304 - (end - start)<br />
start:<br />
;your code here<br />
; ...<br />
jmp start ;the address for start lies in $302/$303, thus will be called by the Kernal after loading<br />
end:<br />
</syntaxhighlight><br />
<br />
In cases where the vector has a practical use, the overhead in filesize is only the 2 byte loading address. For programs larger than 93 byte keep in mind that addresses before $2A7 are in use by the Kernal.<br />
<br />
==== Overwriting return address on stack at $1F8 ====<br />
<br />
When the load routine is called, the stack pointer is always at $FA at a stock C64. Thus the return address from the loading process is stored in memory address $F8 (low byte) and $F9 (high byte). During the loading routine, stack usage will clobber the stack below $1F8, but a program loaded to $1F8 and above will be fine and the overwritten address stored at $1F8/$1F9 will be called after loading.<br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$1F8<br />
.word start-1 ;adjust for the RTS command pulling the address from stack and increasing it by 1<br />
start:<br />
;your code here<br />
</syntaxhighlight><br />
<br />
For programs larger than 95 byte keep in mind that addresses after $259 are in use by the Kernal, you might overwrite some values here if you don't have disk operations, but better check the memory map beforehand.<br />
<br />
Together with the two byte load address and the overwritten address at $1F8/$1F9, your program file will have a deadweight of 4 byte when using this method.<br />
<br />
==== Putting your program into zeropage overwriting part of CHRGET ====<br />
<br />
CHRGET is a machine code routine for the BASIC interpreter that is placed in the zero page at $73-$8A. By putting your program at $7C and following, the CHRGET routine runs directly into your code.<br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$7C<br />
start:<br />
;your code here<br />
</syntaxhighlight><br />
<br />
With this method, there is no need for a start address vector. The only deadweight in your program is the loading address. However, the zero page is a busy place, if your program extends beyond address $8f (that is it has more than 22 bytes on disk) you have to deal with some parts of your program being overwritten, for example, the status byte in $90 is set after loading.<br />
<br />
=== Video display ===<br />
Video display on the Commodore has the following video modes:<br />
* Standard text mode, 40x25 characters, 1 individual color per character, 1 common background color<br />
* Multicolor text mode, 40x25 characters, every two bits (fat pixel) define color: background, char, common color 1+2<br />
* Extended color text mode, 40x25 characters, 1 individual foreground color per character, 1 out of 4 background colors, only 64 chars<br />
* Hires bitmap, 320x200 pixels, an 8x8 field can have an individual foreground and an individual background color<br />
* Multicolor bitmap, 160x200 pixels, every two bits (fat pixel) define color: background, screen color lower nibble, screen color higher nibble, color from color RAM<br />
<br />
==== Sync with frame ====<br />
<br />
Depending on the VIC type, there are 262/263 raster lines (NTSC) or 312 raster lines (PAL-B). Therefore, the VIC uses register at $D011 and the highest bit of register $D012 to represent the current raster line. Checking only the lower 8 bits and waiting for them to be 0 would therefore not work because this happens two times per frame. However, any number greater than 64 will only trigger once. Using a value of 255, we would sync to a rasterline at the end of the screen, well below the part where graphics are normally displayed:<br />
<br />
<syntaxhighlight lang="6502"><br />
lda #$FF<br />
waitsync:<br />
cmp $D012<br />
bne waitsync<br />
</syntaxhighlight><br />
<br />
As long as there have more than 63 cycles passed since the snyc, the next sync will happen at the next frame.<br />
This works fine as long as we don't miss the line 255 due to an interrupt. If your program has interrupts that are not synced to a rasterline, you can change the condition as follows<br />
<syntaxhighlight lang="6502"><br />
lda #$E3<br />
waitsync:<br />
cmp $D012<br />
bcs waitsync<br />
</syntaxhighlight><br />
<br />
Now we have a window between raster line $E4 and $FF to trigger our sync, which we will meet even if a standard Kernal interrupt comes in-between. Of course, our main program now has to burn around 1700 cycles to avoid a retriggering in the same frame.<br />
<br />
==== Getting something on screen ====<br />
<br />
Output a character:<br />
<syntaxhighlight lang="6502"><br />
lda #C ;C must be the char code according to the PETSCII code table<br />
jsr $FFD2 ;you can also use the direct address $FC1A, function preserves A,X,Y and enables interrupt<br />
</syntaxhighlight><br />
<br />
Since the [https://en.wikipedia.org/wiki/PETSCII#Character_set PETSCII code table] contains also control characters, this method can be also used to clear the screen, move the cursor or set the text color. However, some functions are shorter (and faster) by directly calling the respective KERNAL function:<br />
<br />
<syntaxhighlight lang="6502"><br />
Clear screen JSR $E544<br />
Cursor home position JSR $E566<br />
Output newline character JSR $AAD7<br />
Set text color LDA #COLOR, STA $286<br />
Set border color LDA #COLOR, STA $D020 ;not possible with a PETSCII control code<br />
Set background color LDA #COLOR, STA $D021 ;not possible with a PETSCII control code<br />
</syntaxhighlight><br />
<br />
Copy characters directly to screen memory:<br />
<br />
<syntaxhighlight lang="6502"><br />
.macpack cbm ;scrcode macro<br />
SCREEN_BASE=$400<br />
LINE=5 ;for example<br />
COLUMN=10 ;for example<br />
<br />
ldx #endtext-text-1<br />
@loop: lda text,x<br />
sta SCREEN_BASE+LINE*40+COLUMN,x<br />
dex<br />
bpl @loop<br />
text: scrcode "hello world!"<br />
endtext:<br />
</syntaxhighlight><br />
<br />
Note that the text needs to be stored in '''screen code''' format, not in PETSCII (see [https://sta.c64.org/cbm64pettoscr.html Commodore 64 PETSCII code to screen code conversion] for the differences). Furthermore, the example above only writes to the screen memory, not the color RAM, assuming that the color RAM already contains the intended text color. This is the case after issuing a clear screen on most C64 machines, except for some old ROM revisions. To be on the save side you would have to write to color RAM as well, which costs another 5 byte:<br />
<br />
<syntaxhighlight lang="6502"><br />
.macpack cbm ;scrcode macro<br />
SCREEN_BASE=$400<br />
COLOR_RAM =$D800<br />
LINE =5 ;for example<br />
COLUMN =10 ;for example<br />
COLOR =1 ;white<br />
<br />
ldx #endtext-text-1<br />
@loop: lda text,x<br />
sta SCREEN_BASE+LINE*40+COLUMN,x<br />
lda #COLOR<br />
sta COLOR_RAM +LINE*40+COLUMN,x<br />
dex<br />
bpl @loop<br />
text: scrcode "hello world!"<br />
endtext:<br />
</syntaxhighlight><br />
<br />
=== Sound ===<br />
The Commodore 64 uses the famous SID chip to generate sound.<br />
To be added soon.<br />
<br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Useful Kernal functions ===<br />
<br />
==== Get a pseudo random number ====<br />
<br />
<syntaxhighlight lang="6502"><br />
lda #1 <br />
jsr $E09A<br />
lda $63<br />
</syntaxhighlight><br />
<br />
The sequence of random numbers is always the same after a cold start or reset, the first 20 numbers are:<br />
<syntaxhighlight lang="6502"><br />
4,24,231,4,177,170,193,101,231,18,196,1,75,48,149,36,124,53,65,154<br />
</syntaxhighlight><br />
<br />
==== Increment a zero page counter, return in X register, clear Y register ====<br />
<br />
This is part of the string handling function in the BASIC ROM, but the code could be useful for some loop stuff.<br />
<br />
<syntaxhighlight lang="6502"><br />
jsr $B5FF ;does inc $23, ldx $23, ldy #$00, rts<br />
</syntaxhighlight><br />
<br />
=== Additional Resources ===<br />
* Codebase 64 https://codebase64.org/doku.php?id=base:start<br />
* Commodore 64 Memory map https://sta.c64.org/cbm64mem.html<br />
* C64 BASIC & KERNAL ROM Disassembly https://www.pagetable.com/c64ref/c64disasm/<br />
* No More Secrets https://csdb.dk/release/?id=198357 Everything about illegal opcodes and their use in a C64 system<br />
<br />
== Apple II ==<br />
The Apple II is an 8-bit home computer and one of the world's first highly successful mass-produced microcomputer products. It was designed primarily by Steve Wozniak.<br />
<br />
=== Setting up ===<br />
* ACME 6502 cross-assembler(https://sourceforge.net/projects/acme-crossass/)<br />
* Apple Commander (http://applecommander.sourceforge.net) for batch compilation<br />
* AppleWin emulator (https://github.com/AppleWin/AppleWin/releases). Supports Mockingboard card(AY-8910+speech synthesier), HDD, Z80 card(for CP/M), mouse etc.<br />
* CiderPress(https://a2ciderpress.com)<br />
<br />
Compilation can be done as follows (master.dsk can be found with applewin) <br />
<syntaxhighlight><br />
acme hl.asm<br />
java -jar AppleCommander-1.3.5.jar -d master.dsk hl<br />
java -jar AppleCommander-1.3.5.jar -p master.dsk hl B 24576 < hl.bin<br />
</syntaxhighlight><br />
<br />
=== Memory Map ===<br />
<syntaxhighlight lang="6502"><br />
0-255 $0-$FF ZERO-PAGE SYSTEM STORAGE<br />
256-511 $100-$1FF SYSTEM STACK<br />
512-767 $200-$2FF KEYBOARD CHARACTER BUFFER<br />
768-975 $300-$3CF OFTEN AVAILABLE AS FREE SPACE FOR USER PROGRAMS<br />
976-1023 $3D0-3FF SYSTEM VECTORS<br />
1024-2047 $400-$7FF TEXT AND LO-RES GRAPHICS PAGE 1 <--- !!!<br />
2048-LOMEM $800-LOMEM PROGRAM STORAGE<br />
2048-3071 $800-$BFF TEXT AND LO-RES GRAPHICS PAGE 2 OR FREE SPACE<br />
3072-8191 $C00-$1FFF FREE SPACE UNLESS RAM APPLESOFT IS IN USE<br />
8192-16383 $2000-$3FFF HI-RES PAGE 1 OR FREE SPACE <--- !!!<br />
16384-24575 $4000-$5FFF HI-RES PAGE 2 OR FREE SPACE<br />
24576-38999 $6000-$95FF FREE SPACE AND STRING STORAGE<br />
38400-49151 $9600-$BFFF DOS<br />
49152-53247 $C000-$CFFF I/O HARDWARE (RESERVED)<br />
53248-57343 $D000-$DFFF APPLESOFT IN LANGUAGE CARD OR ROM<br />
57344-63487 $E000-$F7FF APPLESOFT OR INTEGER BASIC IN LANGUAGE CARD OR ROM<br />
63488-65535 $F800-$FFFF SYSTEM MONITOR<br />
</syntaxhighlight><br />
<br />
=== Display ===<br />
<br />
=== Graphics Modes ===<br />
: Text Mode 40x24, for Apple IIe available 80x25 - use PR#3 for switch mode, or hardware switch<br />
: LowRes 40x48, 16 colors: https://en.wikipedia.org/wiki/Apple_II_graphics <br />
: Hires mode 280x192,6 colors: https://www.xtof.info/blog/?p=768<br />
https://mrob.com/pub/xapple2/colors.html<br />
https://archive.org/details/HiRes_Color_Graphics_on_the_Apple_II_Computer_by_Wozniak<br />
<br />
However for sizecoding, you almost never want to do direct-access to graphics for Apple II in size-coding because the Apple II graphics modes are horrible. The only fast way to do things is with large lookup tables. To do hires you need to divide by 7 which as you can imagine is a bit difficult to do compactly on 6502. Double-hires is even crazier on top of that. Deater did manage a color-bar style effect in double-hires in 128B but that was doing some crazy tricks with the firmware BASIC routines, definitely not direct-access.<br />
<br />
Lores and Hires can be mixed modes and full-graphics<br />
The screen structure is called memory holes(https://retrocomputing.stackexchange.com/questions/2534/what-are-the-screen-holes-in-apple-ii-graphics). The GBASCALC($F847) procedure is used to calculate the address of the horizontal line : IN:reg.A=Y, out : GBASL/GBASH($26/$27)=address. See also https://www.callapple.org/uncategorized/use-of-apple-ii-color-graphics-in-assembly-language/<br />
<br />
==== Getting something on screen ====<br />
Here is an example of a XOR texture, created by g0blinish<br />
<syntaxhighlight lang="6502"><br />
*=$6000<br />
!to "HL.bin", plain ; set output file and format<br />
!cpu 6502 ; set processor type<br />
<br />
GBASL = $26<br />
GBASH = $27<br />
SETGR = $FB40 ; setup LoRes<br />
GBASCALC = $F847 ; calc Address<br />
<br />
CLRTEXT = $C050 ;display graphics <br />
SETTEXT = $C051 ;display text <br />
<br />
CLRMIXED = $C052 ;clear mixed mode- enable full graphics <br />
SETMIXED = $C053 ;enable graphics/text mixed mode <br />
<br />
PAGE1 = $C054 ;select text/graphics page1 <br />
PAGE2 = $C055 ;select text/graphics page2 <br />
<br />
CLRHIRES = $C056 ;select Lo-res <br />
SETHIRES = $C057 ;select Hi-res <br />
<br />
TMP= $FA<br />
<br />
JSR SETGR ;GR<br />
BIT CLRMIXED ; full screen<br />
<br />
LDA #0 ; A=0<br />
STA TMP ; POKE $FA,A<br />
<br />
YLP ;<br />
LDA TMP ; A=PEEK($FA)<br />
; LSR ; A=A/2<br />
JSR GBASCALC<br />
LDY #0;Y=0<br />
<br />
XLP TYA ; A=Y<br />
EOR TMP ; A=A xor PEEK($FA)<br />
and #$0F ; A=A and 15<br />
TAX ; X=A<br />
LDA COLORS,X ;A=PEEK(COLORS+X)<br />
STA(GBASL),Y ; POKE PEEK($26)+256*PEEK($27)+Y,A<br />
INY ; Y=Y+1<br />
CPY #40 ; Y=40?<br />
BNE XLP<br />
INC TMP ; POKE $FA,PEEK($FA)+1<br />
LDA TMP ; A=PEEK($FA)<br />
CMP #24 ; A=24?<br />
BNE YLP<br />
<br />
M1 JMP M1 ; replace to RTS<br />
<br />
COLORS ;N*17, pixel format is AAAABBBB, AAAA - upper dot, BBBB - lower dot<br />
!byte $00,$11,$22,$33,$44,$55,$66,$77<br />
!byte $88,$99,$AA,$BB,$CC,$DD,$EE,$FF<br />
</syntaxhighlight><br />
<br />
==== Sound ====<br />
Here is an example for using the speaker, based onthe following basic program:<br />
<br />
<syntaxhighlight lang="basic"><br />
; 50 POKE 768,V: POKE 769,P - 255 * INT (P / 256): POKE 800,1 + P / 256<br />
; 60 CALL 770: RETURN <br />
; 95 FOR K = 1 TO N: READ V(K),P(K): NEXT K<br />
; 100 FOR K = 1 TO N:V = V(K):P = P(K)<br />
; 110 GOSUB 50<br />
;!byte 173,48,192,136,208,5,206,1,3,240,9,202,208,245,174,0,3,76,2,3,206,32,3,208,240,96<br />
</syntaxhighlight><br />
<br />
<syntaxhighlight lang="6502"><br />
*=$6000<br />
!to "HL.bin", plain ; set output file and format<br />
!cpu 6502 ; set processor type<br />
<br />
;start<br />
; 95 FOR K = 1 TO N: READ V(K),P(K): NEXT K<br />
; 100 FOR K = 1 TO N:V = V(K):P = P(K)<br />
ini:<br />
lda #70<br />
sta cnt+1<br />
lda #music&255<br />
sta gotbyte+1<br />
lda #music/256<br />
sta gotbyte+2<br />
<br />
lop:<br />
;V<br />
jsr gotbyte<br />
sta L300<br />
jsr gotbyte<br />
;P<br />
jsr gotbyte<br />
sta L301<br />
jsr gotbyte<br />
clc<br />
adc #1<br />
sta L320<br />
jsr beep<br />
<br />
dec cnt+1<br />
cnt lda #70<br />
bne lop<br />
; 110 GOSUB 50<br />
; 50 POKE 768,V: POKE 769,P - 255 * INT (P / 256): POKE 800,1 + P / 256<br />
; 60 CALL 770: RETURN <br />
jmp ini<br />
gotbyte<br />
lda music<br />
inc gotbyte+1<br />
bne noinch<br />
inc gotbyte+2<br />
noinch<br />
rts<br />
;!byte 173,48,192,136,208,5,206,1,3,240,9,202,208,245,174,0,3,76,2,3,206,32,3,208,240,96<br />
beep:<br />
ldy #1<br />
ldx #1<br />
loc_302:<br />
LDA $C030<br />
<br />
loc_305:<br />
DEY<br />
BNE loc_30D<br />
DEC L301<br />
loc_30B:<br />
BEQ loc_316<br />
<br />
loc_30D:<br />
DEX<br />
BNE loc_305<br />
LDX L300<br />
JMP loc_302<br />
loc_316:<br />
DEC L320<br />
BNE loc_30B<br />
RTS<br />
L301 !byte 0<br />
L300 !byte 0<br />
L320 !byte 0<br />
music<br />
!word 76,192,85,64,96,64,102,64,114,128,114,64,96,64,102,64,114,64,128,64<br />
!word 114,64,152,64,171,64,152,512,76,192,85,64,96,64,102,64,114,128,114,64<br />
!word 96,64,102,64,114,64,128,64,114,64,152,64,171,64,152,512,85,64,85,64<br />
!word 85,64,96,64,144,128,144,64,128,64,76,128,85,64,96,64,144,128,114,64<br />
!word 96,64,102,128,114,64,128,64,128,128,114,64,128,64,114,512,85,64,85,64<br />
!word 85,64,96,64,144,128,144,64,128,64,76,128,85,64,96,64,144,128,114,64<br />
!word 96,64,102,128,114,64,128,64,128,64,128,128,96,64,85,64,96,64,102,64,114,64,114,64<br />
</syntaxhighlight><br />
<br />
=== Additional Resources ===<br />
* Deater's page on Apple II sizecoding http://www.deater.net/weave/vmwprod/demos/sizecoding.html<br />
* Article on double hi-res http://www.battlestations.zone/2017/04/apple-ii-double-hi-res-from-ground-up.html<br />
* Applesoft Hi-Res Subroutines : http://hackzapple.org/scripts_php/index.php?menu=5&mod=ASM&sub=AAL&sub2=8112&PHPSESSID=f65fabfd0cdbf56b6bdc0ddac25117c6#a2<br />
<br />
== Atari Lynx ==<br />
The Atari Lynx consists of the 6502 with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Atari Lynx:<br />
<br />
* Assembler: -<br />
* Emulator(s): -<br />
<br />
=== Video display ===<br />
To be added soon.<br />
<br />
==== Getting something on screen ====<br />
To be added soon.<br />
<br />
<br />
=== Sound ===<br />
To be added soon.<br />
<br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Additional Resources ===<br />
Sizecoding resource for the Atari Lynx are sparse<br />
* 42Bastian's website (link to be added)</div>Wilhttp://www.sizecoding.org/index.php?title=6502&diff=83265022021-02-16T20:55:22Z<p>Wil: /* Overwriting CHROUT vector at $326-$327 */ warning regarding datasette buffer</p>
<hr />
<div>== Introduction ==<br />
Wanting to start sizecoding on a 6502 platform in this day and age can be tough. <br />
<br />
[[File:6502.jpg|thumb]]<br />
<br />
So here is a bit of help to get you started:<br />
<br />
=== The 6502 processor ===<br />
The 6502 processor can be seen as the 8-bit micro ARM chip. <br />
It has only has 3 registers (Accumulator, X and Y registers) and a handful of instructions to work with.<br />
<br />
=== Adressing modes ===<br />
To be added.<br />
<br />
=== Zero page ===<br />
When using the 6502 for sizecoding, you'll mostly be working from zeropage<br />
<br />
=== General 6502 Resources ===<br />
* 6502.org http://www.6502.org/<br />
* 6502 instruction reference http://www.6502.org/tutorials/6502opcodes.html<br />
* 6502 books http://retro.hansotten.nl/6502-sbc/<br />
* 6502 Assembler tutorial https://dwheeler.com/6502/oneelkruns/asm1step.html<br />
* Easy 6502 code tester https://skilldrick.github.io/easy6502/<br />
* Synthetic instructions https://wiki.nesdev.com/w/index.php/Synthetic_instructions#8-bit_rotate<br />
<br />
== Atari 8-bit family ==<br />
The systems in this family are: Atari 400, 800, 5200, 1200XL, 600XL, 800XL, 130XE, 65XE, 800XE and XEGS.<br /><br />
<br />
The Atari 8-bit systems consists of the 6502 with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Atari 8bit systems is quite easy, first get the following tools:<br />
<br />
* Assembler: MADS Assembler - This assembler has nice macros for creating Binaries and SNA snapshot files out of the box. You can download it at https://mads.atari8.info/<br />
* Emulator(s): I Found Altirra to work best for my usecase. Make sure to use the original Rev2 rom for best compatibility.<br />
<br />
==== Special Memory Adresses ====<br />
* FRAMECOUNTER_HIGH = 19<br />
* FRAMECOUNTER_LOW = 20<br />
<br />
=== Video display ===<br />
Video display on the Atari 8bit systems use the ANTIC and GTIA chips. Information can be found here:<br />
* https://en.wikipedia.org/wiki/ANTIC<br />
* https://www.atariarchives.org/agagd/chapter1.php<br />
<br />
==== Sync with frame ====<br />
<syntaxhighlight lang="6502"><br />
RTCLOK equ $0012<br />
lda RTCLOK+2<br />
waits<br />
cmp RTCLOK+2<br />
beq waits<br />
</syntaxhighlight><br />
<br />
Or if you don't mind trashing RTCLOK<br />
<br />
<syntaxhighlight lang="6502"><br />
RTCLOK equ $0012<br />
waits<br />
lsr RTCLOK+2<br />
bcc waits<br />
</syntaxhighlight><br />
<br />
Which is two bytes shorter.<br />
<br />
==== Getting something on screen ====<br />
<syntaxhighlight lang="6502"><br />
;fill screen with charset,(88,89)=an address<br />
org $600; free 6th page:600-6ff<br />
ldy #0<br />
fl: tya<br />
sta(88),y<br />
iny<br />
bne fl<br />
jmp *<br />
</syntaxhighlight><br />
<br />
To be added soon.<br />
<br />
<syntaxhighlight lang="6502"><br />
SDMCTL = $022f<br />
HPOSP0 = $d000<br />
SIZEP0 = $d008<br />
GRAFP0 = $d00d<br />
COLPM0 = $d012<br />
<br />
FRAMECOUNTER_HIGH = 19<br />
FRAMECOUNTER = 20<br />
WSYNC = $d40a<br />
VCOUNT = $d40b<br />
<br />
sinewave = $0600 ; to $06ff<br />
<br />
org $80<br />
<br />
main <br />
; disable all graphics/colors<br />
ldx #0<br />
stx SDMCTL <br />
<br />
ldy #$7f<br />
sty SIZEP0 ; size p0=127<br />
<br />
ldx #0<br />
ldy #$3f<br />
make_sine:<br />
value_lo<br />
lda #0<br />
clc<br />
delta_lo<br />
adc #0<br />
sta value_lo+1<br />
value_hi<br />
lda #0<br />
delta_hi<br />
adc #0<br />
sta value_hi+1<br />
<br />
sta sinewave+$c0,x<br />
sta sinewave+$80,y<br />
eor #$7f<br />
sta sinewave+$40,x<br />
sta sinewave+$00,y<br />
<br />
lda delta_lo+1<br />
adc #8<br />
sta delta_lo+1<br />
bcc nothing<br />
inc delta_hi+1<br />
nothing<br />
inx<br />
dey<br />
bpl make_sine<br />
<br />
updateloop:<br />
; vblank<br />
lda VCOUNT<br />
bne updateloop<br />
<br />
; clear graphics<br />
sta HPOSP0<br />
sta GRAFP0<br />
<br />
ldy #0<br />
lda #47<br />
sta COLPM0<br />
yloop:<br />
tya ; graphics shape = y<br />
sta WSYNC<br />
sta GRAFP0<br />
<br />
; a = sin(frame+y)+48<br />
tya <br />
adc FRAMECOUNTER<br />
tax<br />
lda sinewave,x<br />
adc #48<br />
sta HPOSP0<br />
<br />
iny<br />
bne yloop<br />
jmp updateloop<br />
<br />
run main<br />
</syntaxhighlight><br />
<br />
=== Sound ===<br />
The Atari 8-bit use the POKEY chip to generate sound.<br />
* https://en.wikipedia.org/wiki/POKEY<br />
<br />
==== BASIC ====<br />
<syntaxhighlight lang="6502"><br />
; from Analog, 1985-09,pp.25-32<br />
*=$2000<br />
AUDF1=$D200<br />
AUDC1=$D201<br />
AUDCTL=$D208<br />
SKCTL=$D20F<br />
<br />
.MACRO SOUND ; voice,pitch,dist,vol;,dur<br />
lda #%2<br />
sta AUDF1+2*%1<br />
lda #[[%3 * 16] | %4] ;lda #[[%3 shl 4] or %4]<br />
sta AUDC1+2*%1<br />
.ENDM<br />
<br />
lda #0<br />
sta AUDCTL<br />
lda #3<br />
sta SKCTL<br />
<br />
SOUND 0,121,10,8<br />
<br />
jmp *<br />
</syntaxhighlight><br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Additional Resources ===<br />
Sizecoding resource for the Atari 8bit are:<br />
* Mapping the Atari https://www.atariarchives.org/mapping/<br />
* Atari 8bit Memory map https://www.atariarchives.org/mapping/memorymap.php<br />
* Fready's undocumented 6502 opcodes https://github.com/FreddyOffenga/6502<br />
* Atari OS Rev2 disassembly for MADS assembler https://github.com/ilmenit/A800-OS-XL-Rev2<br />
* Fready's github https://github.com/FreddyOffenga/<br />
<br />
== Commodore 64 ==<br />
The Commodore system consists of a 6502-compatible MOS 6510 processor with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Commodore systems is quite easy, first get the following tools:<br />
<br />
* Assembler: To be added<br />
* Emulator(s): VICE is the way to go<br />
<br />
=== Memory map ===<br />
<br />
<syntaxhighlight lang="6502"><br />
0-1 $0-$1 PROCESSOR PORT REGISTERS, not usable as RAM<br />
0-255 $0-$FF ZEROPAGE, mostly used by BASIC interpreter and Kernal<br />
256-511 $100-$1FF SYSTEM STACK<br />
512-600 $200-$258 INPUT BUFFER<br />
601-630 $259-$276 FILE SYSTEM DATA<br />
631-640 $277-$280 KEYBOARD BUFFER, filled by Kernal ISR upon key presses <br />
641-678 $281-$2A6 VARIOUS KERNAL VARIABLES<br />
679-767 $2A7-$2FF Unused (89 byte)<br />
768-779 $300-$30B KERNAL VECTORS<br />
780-783 $30C-$30F REGISTER VALUES A,X,Y,SR for SYS<br />
784-819 $310-$333 KERNAL VECTORS<br />
820-827 $334-$33B Unused (8 byte)<br />
828-1019 $33C-$3FB DATASETTE BUFFER<br />
1020-1023 $3FC-$3FF Unused (4 byte)<br />
1024-2023 $400-$7E7 SCREEN MEMORY (25 lines times 40 columns)<br />
2024-2039 $7E8-$7F7 Unused (16 byte)<br />
2040-2047 $7F8-$7FF SPRITE COSTUME POINTERS<br />
2048 $800 must contain a value of 0 so that the BASIC program can be RUN<br />
2049-40959 $801-$9FFF BASIC AREA (code, variables, arrays, strings)<br />
40960-49151 $A000-$BFFF BASIC ROM (unused RAM underneath)<br />
49152-53247 $C000-$CFFF UPPER RAM AREA (unused)<br />
53248-53294 $D000-$D02E VIC-II, memory-mapped graphics chip registers)<br />
54272-54300 $D400-$D41C SID, memory-mapped sound chip registers)<br />
55296-56295 $D800-$DBE7 Color RAM, only lower 4 bits are stored, higher nibble undefined<br />
56296-56319 $DBE8-$DBFF Unused (24 half-bytes)<br />
56320-56335 $DC00-$DC0F CIA#1, memory-mapped I/O chip registers for keyboard, joystick, mouse, datasette, IRQ control<br />
56576-56591 $DD00-$DD0F CIA#1, memory-mapped I/O chip registers for serial bus, RS232, NMI control<br />
57344-65535 $E000-$FFFF KERNAL ROM<br />
65534-65535 $FFFE-$FFFF Execution address of interrupt service routine, can only be set if KERNAL is turned off<br />
</syntaxhighlight><br />
<br />
For a detailed explanation of the C64 memory map check out [https://sta.c64.org/cbm64mem.html Commodore 64 memory map] on Joe Forster/STA homepage.<br />
<br />
=== Program file overhead ===<br />
<br />
A standard CBM file consists of a 2 byte loading address followed by the data that is placed into memory starting at this address. In addition, if your machine program should be able to be started with "RUN", you need a BASIC stub that is loaded into memory from $0801 to $080c, typically followed by your machine program:<br />
<br />
<syntaxhighlight lang="6502"><br />
*=$0801<br />
.word $080b ;address of next BASIC line<br />
.word LINENR ;line number, can be chosen between 0 and 63999<br />
.byte $9e ;token for SYS command<br />
.byte $32,$30,$36,$31 ;address to jump to in ASCII code: "2061" <br />
.byte $00 ;end of BASIC line<br />
.word $0000 ;address of next BASIC line, $0000 means end of BASIC program <br />
start<br />
; your code here<br />
</syntaxhighlight><br />
<br />
Together with the 2 byte load address, this makes an overhead of 14 byte for your program. To reduce this, you can<br />
* omit the BASIC line and tell users to start your program by directly entering "SYS ''address''"<br />
* save your program from $0802 on, the byte at $0801 is recovered automatically after loading by the relink function. This reduces your program file size by 1 byte<br />
* accept the loss and use the 2 byte establishing LINENR for something good, they are copied to zeropage addresses $39/$3a automatically, saving you the effort of initializing the addresses<br />
* use an autostart method (see below)<br />
<br />
Some compos also specify that the BASIC loader does not count towards the overall filesize, check the rules before you worry.<br />
<br />
=== Autostart ===<br />
<br />
Unlike the Commodore 128, the Commodore 64 has no dedicated built-in auto-boot feature, but it is possible to autorun a program after loading by specifying the load address so that it overwrites a vector or address that is called by the operating system. There are multiple possibilities:<br />
<br />
==== Overwriting CHROUT vector at $326-$327 ====<br />
<br />
The vector at address $326-$327 points at the CHROUT routine, normally at address $F1CA.<br />
If you put the entry address of your program into $326/27, your code will be called when the operating system wants to print "READY." after loading.<br />
Note that the vector at address $328-$329 points at the STOP routine that checks the status of Stop key indicator. Since this routine is called multiple times before your code is done loading, its default value $F6ED needs to be preserved. <br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$0326<br />
.word start <br />
.byte $ed,$f6<br />
start<br />
; rest of code<br />
</syntaxhighlight><br />
<br />
Together with the two byte load address, the overwritten CHROUT vector and the preserved STOP vector, your program file will have a deadweight of 6 byte: $26 $03 $0a $03 $ed $f6, less than half of the standard version with a BASIC stub with SYS<br />
<br />
Caveat:<br />
* If your program after $32a is longer than 214 byte, part of your program will load into the screen at $400. Thus, issuing a clear screen will overwrite your program. It is possible to move the screen memory somewhere else, but that requires storing a new value into address $D018, which when done with an LDA # / STA pair will cost you 5 byte<br />
* Since you changed the CHROUT pointer, standard KERNAL functions for printing won't work. For output of single characters, you can still use the direct address $F1CA. Alternatively, you can restore the vectors by calling $FD15, which will overwrite the memory $314 to $333 with the default values.<br />
* The memory area $33C-$3FB is the datasette buffer, thus loading a program into this area won't work when loading from a cassette.<br />
<br />
==== Overwriting BASIC idle loop vector at $302-$303 ====<br />
<br />
After loading the program, the BASIC idle loop will be called. By overwriting the vector at $302/$303 it is possible to autostart your program. Since the memory before $302 can be safely overwritten, the program would be arranged so that $303 is the '''last''' address of your program. If your program requires a loop back to the start, the vector can be used as part of a JMP where the following two bytes are already there, saving one byte in comparison to a loop done with a branch command.<br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$304 - (end - start)<br />
start:<br />
;your code here<br />
; ...<br />
jmp start ;the address for start lies in $302/$303, thus will be called by the Kernal after loading<br />
end:<br />
</syntaxhighlight><br />
<br />
In cases where the vector has a practical use, the overhead in filesize is only the 2 byte loading address. For programs larger than 93 byte keep in mind that addresses before $2A7 are in use by the Kernal.<br />
<br />
==== Overwriting return address on stack at $1F8 ====<br />
<br />
When the load routine is called, the stack pointer is always at $FA at a stock C64. Thus the return address from the loading process is stored in memory address $F8 (low byte) and $F9 (high byte). During the loading routine, stack usage will clobber the stack below $1F8, but a program loaded to $1F8 and above will be fine and the overwritten address stored at $1F8/$1F9 will be called after loading.<br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$1F8<br />
.word start-1 ;adjust for the RTS command pulling the address from stack and increasing it by 1<br />
start:<br />
;your code here<br />
</syntaxhighlight><br />
<br />
For programs larger than 95 byte keep in mind that addresses after $259 are in use by the Kernal, you might overwrite some values here if you don't have disk operations, but better check the memory map beforehand.<br />
<br />
Together with the two byte load address and the overwritten address at $1F8/$1F9, your program file will have a deadweight of 4 byte when using this method.<br />
<br />
==== Putting your program into zeropage overwriting part of CHRGET ====<br />
<br />
CHRGET is a machine code routine for the BASIC interpreter that is placed in the zero page at $73-$8A. By putting your program at $7C and following, the CHRGET routine runs directly into your code.<br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$7C<br />
start:<br />
;your code here<br />
</syntaxhighlight><br />
<br />
With this method, there is no need for a start address vector. The only deadweight in your program is the loading address. However, the zero page is a busy place, if your program extends beyond address $8f (that is it has more than 22 bytes on disk) you have to deal with some parts of your program being overwritten, for example, the status byte in $90 is set after loading.<br />
<br />
=== Video display ===<br />
Video display on the Commodore has the following video modes:<br />
* Standard text mode, 40x25 characters, 1 individual color per character, 1 common background color<br />
* Multicolor text mode, 40x25 characters, every two bits (fat pixel) define color: background, char, common color 1+2<br />
* Extended color text mode, 40x25 characters, 1 individual foreground color per character, 1 out of 4 background colors, only 64 chars<br />
* Hires bitmap, 320x200 pixels, an 8x8 field can have an individual foreground and an individual background color<br />
* Multicolor bitmap, 160x200 pixels, every two bits (fat pixel) define color: background, screen color lower nibble, screen color higher nibble, color from color RAM<br />
<br />
==== Sync with frame ====<br />
<br />
Depending on the VIC type, there are 262/263 raster lines (NTSC) or 312 raster lines (PAL-B). Therefore, the VIC uses register at $D011 and the highest bit of register $D012 to represent the current raster line. Checking only the lower 8 bits and waiting for them to be 0 would therefore not work because this happens two times per frame. However, any number greater than 64 will only trigger once. Using a value of 255, we would sync to a rasterline at the end of the screen, well below the part where graphics are normally displayed:<br />
<br />
<syntaxhighlight lang="6502"><br />
lda #$FF<br />
waitsync:<br />
cmp $D012<br />
bne waitsync<br />
</syntaxhighlight><br />
<br />
As long as there have more than 63 cycles passed since the snyc, the next sync will happen at the next frame.<br />
This works fine as long as we don't miss the line 255 due to an interrupt. If your program has interrupts that are not synced to a rasterline, you can change the condition as follows<br />
<syntaxhighlight lang="6502"><br />
lda #$E3<br />
waitsync:<br />
cmp $D012<br />
bcs waitsync<br />
</syntaxhighlight><br />
<br />
Now we have a window between raster line $E4 and $FF to trigger our sync, which we will meet even if a standard Kernal interrupt comes in-between. Of course, our main program now has to burn around 1700 cycles to avoid a retriggering in the same frame.<br />
<br />
==== Getting something on screen ====<br />
<br />
Output a character:<br />
<syntaxhighlight lang="6502"><br />
lda #C ;C must be the char code according to the PETSCII code table<br />
jsr $FFD2 ;you can also use the direct address $FC1A, function preserves A,X,Y and enables interrupt<br />
</syntaxhighlight><br />
<br />
Since the [https://en.wikipedia.org/wiki/PETSCII#Character_set PETSCII code table] contains also control characters, this method can be also used to clear the screen, move the cursor or set the text color. However, some functions are shorter (and faster) by directly calling the respective KERNAL function:<br />
<br />
<syntaxhighlight lang="6502"><br />
Clear screen JSR $E544<br />
Cursor home position JSR $E566<br />
Output newline character JSR $AAD7<br />
Set text color LDA #COLOR, STA $286<br />
Set border color LDA #COLOR, STA $D020 ;not possible with a PETSCII control code<br />
Set background color LDA #COLOR, STA $D021 ;not possible with a PETSCII control code<br />
</syntaxhighlight><br />
<br />
Copy characters directly to screen memory:<br />
<br />
<syntaxhighlight lang="6502"><br />
.macpack cbm ;scrcode macro<br />
SCREEN_BASE=$400<br />
LINE=5 ;for example<br />
COLUMN=10 ;for example<br />
<br />
ldx #endtext-text-1<br />
@loop: lda text,x<br />
sta SCREEN_BASE+LINE*40+COLUMN,x<br />
dex<br />
bpl @loop<br />
text: scrcode "hello world!"<br />
endtext:<br />
</syntaxhighlight><br />
<br />
Note that the text needs to be stored in '''screen code''' format, not in PETSCII (see [https://sta.c64.org/cbm64pettoscr.html Commodore 64 PETSCII code to screen code conversion] for the differences). Furthermore, the example above only writes to the screen memory, not the color RAM, assuming that the color RAM already contains the intended text color. This is the case after issuing a clear screen on most C64 machines, except for some old ROM revisions. To be on the save side you would have to write to color RAM as well, which costs another 5 byte:<br />
<br />
<syntaxhighlight lang="6502"><br />
.macpack cbm ;scrcode macro<br />
SCREEN_BASE=$400<br />
COLOR_RAM =$D800<br />
LINE =5 ;for example<br />
COLUMN =10 ;for example<br />
COLOR =1 ;white<br />
<br />
ldx #endtext-text-1<br />
@loop: lda text,x<br />
sta SCREEN_BASE+LINE*40+COLUMN,x<br />
lda #COLOR<br />
sta COLOR_RAM +LINE*40+COLUMN,x<br />
dex<br />
bpl @loop<br />
text: scrcode "hello world!"<br />
endtext:<br />
</syntaxhighlight><br />
<br />
=== Sound ===<br />
The Commodore 64 uses the famous SID chip to generate sound.<br />
To be added soon.<br />
<br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Useful Kernal functions ===<br />
<br />
==== Get a pseudo random number ====<br />
<br />
<syntaxhighlight lang="6502"><br />
lda #1 <br />
jsr $E09A<br />
lda $63<br />
</syntaxhighlight><br />
<br />
The sequence of random numbers is always the same after a cold start or reset, the first 20 numbers are:<br />
<syntaxhighlight lang="6502"><br />
4,24,231,4,177,170,193,101,231,18,196,1,75,48,149,36,124,53,65,154<br />
</syntaxhighlight><br />
<br />
==== Increment a zero page counter, return in X register, clear Y register ====<br />
<br />
This is part of the string handling function in the BASIC ROM, but the code could be useful for some loop stuff.<br />
<br />
<syntaxhighlight lang="6502"><br />
jsr $B5FF ;does inc $23, ldx $23, ldy #$00, rts<br />
</syntaxhighlight><br />
<br />
=== Additional Resources ===<br />
* Codebase 64 https://codebase64.org/doku.php?id=base:start<br />
* Commodore 64 Memory map https://sta.c64.org/cbm64mem.html<br />
* C64 BASIC & KERNAL ROM Disassembly https://www.pagetable.com/c64ref/c64disasm/<br />
<br />
== Apple II ==<br />
The Apple II is an 8-bit home computer and one of the world's first highly successful mass-produced microcomputer products. It was designed primarily by Steve Wozniak.<br />
<br />
=== Setting up ===<br />
* ACME 6502 cross-assembler(https://sourceforge.net/projects/acme-crossass/)<br />
* Apple Commander (http://applecommander.sourceforge.net) for batch compilation<br />
* AppleWin emulator (https://github.com/AppleWin/AppleWin/releases). Supports Mockingboard card(AY-8910+speech synthesier), HDD, Z80 card(for CP/M), mouse etc.<br />
* CiderPress(https://a2ciderpress.com)<br />
<br />
Compilation can be done as follows (master.dsk can be found with applewin) <br />
<syntaxhighlight><br />
acme hl.asm<br />
java -jar AppleCommander-1.3.5.jar -d master.dsk hl<br />
java -jar AppleCommander-1.3.5.jar -p master.dsk hl B 24576 < hl.bin<br />
</syntaxhighlight><br />
<br />
=== Memory Map ===<br />
<syntaxhighlight lang="6502"><br />
0-255 $0-$FF ZERO-PAGE SYSTEM STORAGE<br />
256-511 $100-$1FF SYSTEM STACK<br />
512-767 $200-$2FF KEYBOARD CHARACTER BUFFER<br />
768-975 $300-$3CF OFTEN AVAILABLE AS FREE SPACE FOR USER PROGRAMS<br />
976-1023 $3D0-3FF SYSTEM VECTORS<br />
1024-2047 $400-$7FF TEXT AND LO-RES GRAPHICS PAGE 1 <--- !!!<br />
2048-LOMEM $800-LOMEM PROGRAM STORAGE<br />
2048-3071 $800-$BFF TEXT AND LO-RES GRAPHICS PAGE 2 OR FREE SPACE<br />
3072-8191 $C00-$1FFF FREE SPACE UNLESS RAM APPLESOFT IS IN USE<br />
8192-16383 $2000-$3FFF HI-RES PAGE 1 OR FREE SPACE <--- !!!<br />
16384-24575 $4000-$5FFF HI-RES PAGE 2 OR FREE SPACE<br />
24576-38999 $6000-$95FF FREE SPACE AND STRING STORAGE<br />
38400-49151 $9600-$BFFF DOS<br />
49152-53247 $C000-$CFFF I/O HARDWARE (RESERVED)<br />
53248-57343 $D000-$DFFF APPLESOFT IN LANGUAGE CARD OR ROM<br />
57344-63487 $E000-$F7FF APPLESOFT OR INTEGER BASIC IN LANGUAGE CARD OR ROM<br />
63488-65535 $F800-$FFFF SYSTEM MONITOR<br />
</syntaxhighlight><br />
<br />
=== Display ===<br />
<br />
=== Graphics Modes ===<br />
: Text Mode 40x24, for Apple IIe available 80x25 - use PR#3 for switch mode, or hardware switch<br />
: LowRes 40x48, 16 colors: https://en.wikipedia.org/wiki/Apple_II_graphics <br />
: Hires mode 280x192,6 colors: https://www.xtof.info/blog/?p=768<br />
https://mrob.com/pub/xapple2/colors.html<br />
https://archive.org/details/HiRes_Color_Graphics_on_the_Apple_II_Computer_by_Wozniak<br />
<br />
However for sizecoding, you almost never want to do direct-access to graphics for Apple II in size-coding because the Apple II graphics modes are horrible. The only fast way to do things is with large lookup tables. To do hires you need to divide by 7 which as you can imagine is a bit difficult to do compactly on 6502. Double-hires is even crazier on top of that. Deater did manage a color-bar style effect in double-hires in 128B but that was doing some crazy tricks with the firmware BASIC routines, definitely not direct-access.<br />
<br />
Lores and Hires can be mixed modes and full-graphics<br />
The screen structure is called memory holes(https://retrocomputing.stackexchange.com/questions/2534/what-are-the-screen-holes-in-apple-ii-graphics). The GBASCALC($F847) procedure is used to calculate the address of the horizontal line : IN:reg.A=Y, out : GBASL/GBASH($26/$27)=address. See also https://www.callapple.org/uncategorized/use-of-apple-ii-color-graphics-in-assembly-language/<br />
<br />
==== Getting something on screen ====<br />
Here is an example of a XOR texture, created by g0blinish<br />
<syntaxhighlight lang="6502"><br />
*=$6000<br />
!to "HL.bin", plain ; set output file and format<br />
!cpu 6502 ; set processor type<br />
<br />
GBASL = $26<br />
GBASH = $27<br />
SETGR = $FB40 ; setup LoRes<br />
GBASCALC = $F847 ; calc Address<br />
<br />
CLRTEXT = $C050 ;display graphics <br />
SETTEXT = $C051 ;display text <br />
<br />
CLRMIXED = $C052 ;clear mixed mode- enable full graphics <br />
SETMIXED = $C053 ;enable graphics/text mixed mode <br />
<br />
PAGE1 = $C054 ;select text/graphics page1 <br />
PAGE2 = $C055 ;select text/graphics page2 <br />
<br />
CLRHIRES = $C056 ;select Lo-res <br />
SETHIRES = $C057 ;select Hi-res <br />
<br />
TMP= $FA<br />
<br />
JSR SETGR ;GR<br />
BIT CLRMIXED ; full screen<br />
<br />
LDA #0 ; A=0<br />
STA TMP ; POKE $FA,A<br />
<br />
YLP ;<br />
LDA TMP ; A=PEEK($FA)<br />
; LSR ; A=A/2<br />
JSR GBASCALC<br />
LDY #0;Y=0<br />
<br />
XLP TYA ; A=Y<br />
EOR TMP ; A=A xor PEEK($FA)<br />
and #$0F ; A=A and 15<br />
TAX ; X=A<br />
LDA COLORS,X ;A=PEEK(COLORS+X)<br />
STA(GBASL),Y ; POKE PEEK($26)+256*PEEK($27)+Y,A<br />
INY ; Y=Y+1<br />
CPY #40 ; Y=40?<br />
BNE XLP<br />
INC TMP ; POKE $FA,PEEK($FA)+1<br />
LDA TMP ; A=PEEK($FA)<br />
CMP #24 ; A=24?<br />
BNE YLP<br />
<br />
M1 JMP M1 ; replace to RTS<br />
<br />
COLORS ;N*17, pixel format is AAAABBBB, AAAA - upper dot, BBBB - lower dot<br />
!byte $00,$11,$22,$33,$44,$55,$66,$77<br />
!byte $88,$99,$AA,$BB,$CC,$DD,$EE,$FF<br />
</syntaxhighlight><br />
<br />
==== Sound ====<br />
Here is an example for using the speaker, based onthe following basic program:<br />
<br />
<syntaxhighlight lang="basic"><br />
; 50 POKE 768,V: POKE 769,P - 255 * INT (P / 256): POKE 800,1 + P / 256<br />
; 60 CALL 770: RETURN <br />
; 95 FOR K = 1 TO N: READ V(K),P(K): NEXT K<br />
; 100 FOR K = 1 TO N:V = V(K):P = P(K)<br />
; 110 GOSUB 50<br />
;!byte 173,48,192,136,208,5,206,1,3,240,9,202,208,245,174,0,3,76,2,3,206,32,3,208,240,96<br />
</syntaxhighlight><br />
<br />
<syntaxhighlight lang="6502"><br />
*=$6000<br />
!to "HL.bin", plain ; set output file and format<br />
!cpu 6502 ; set processor type<br />
<br />
;start<br />
; 95 FOR K = 1 TO N: READ V(K),P(K): NEXT K<br />
; 100 FOR K = 1 TO N:V = V(K):P = P(K)<br />
ini:<br />
lda #70<br />
sta cnt+1<br />
lda #music&255<br />
sta gotbyte+1<br />
lda #music/256<br />
sta gotbyte+2<br />
<br />
lop:<br />
;V<br />
jsr gotbyte<br />
sta L300<br />
jsr gotbyte<br />
;P<br />
jsr gotbyte<br />
sta L301<br />
jsr gotbyte<br />
clc<br />
adc #1<br />
sta L320<br />
jsr beep<br />
<br />
dec cnt+1<br />
cnt lda #70<br />
bne lop<br />
; 110 GOSUB 50<br />
; 50 POKE 768,V: POKE 769,P - 255 * INT (P / 256): POKE 800,1 + P / 256<br />
; 60 CALL 770: RETURN <br />
jmp ini<br />
gotbyte<br />
lda music<br />
inc gotbyte+1<br />
bne noinch<br />
inc gotbyte+2<br />
noinch<br />
rts<br />
;!byte 173,48,192,136,208,5,206,1,3,240,9,202,208,245,174,0,3,76,2,3,206,32,3,208,240,96<br />
beep:<br />
ldy #1<br />
ldx #1<br />
loc_302:<br />
LDA $C030<br />
<br />
loc_305:<br />
DEY<br />
BNE loc_30D<br />
DEC L301<br />
loc_30B:<br />
BEQ loc_316<br />
<br />
loc_30D:<br />
DEX<br />
BNE loc_305<br />
LDX L300<br />
JMP loc_302<br />
loc_316:<br />
DEC L320<br />
BNE loc_30B<br />
RTS<br />
L301 !byte 0<br />
L300 !byte 0<br />
L320 !byte 0<br />
music<br />
!word 76,192,85,64,96,64,102,64,114,128,114,64,96,64,102,64,114,64,128,64<br />
!word 114,64,152,64,171,64,152,512,76,192,85,64,96,64,102,64,114,128,114,64<br />
!word 96,64,102,64,114,64,128,64,114,64,152,64,171,64,152,512,85,64,85,64<br />
!word 85,64,96,64,144,128,144,64,128,64,76,128,85,64,96,64,144,128,114,64<br />
!word 96,64,102,128,114,64,128,64,128,128,114,64,128,64,114,512,85,64,85,64<br />
!word 85,64,96,64,144,128,144,64,128,64,76,128,85,64,96,64,144,128,114,64<br />
!word 96,64,102,128,114,64,128,64,128,64,128,128,96,64,85,64,96,64,102,64,114,64,114,64<br />
</syntaxhighlight><br />
<br />
=== Additional Resources ===<br />
* Deater's page on Apple II sizecoding http://www.deater.net/weave/vmwprod/demos/sizecoding.html<br />
* Article on double hi-res http://www.battlestations.zone/2017/04/apple-ii-double-hi-res-from-ground-up.html<br />
* Applesoft Hi-Res Subroutines : http://hackzapple.org/scripts_php/index.php?menu=5&mod=ASM&sub=AAL&sub2=8112&PHPSESSID=f65fabfd0cdbf56b6bdc0ddac25117c6#a2<br />
<br />
== Atari Lynx ==<br />
The Atari Lynx consists of the 6502 with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Atari Lynx:<br />
<br />
* Assembler: -<br />
* Emulator(s): -<br />
<br />
=== Video display ===<br />
To be added soon.<br />
<br />
==== Getting something on screen ====<br />
To be added soon.<br />
<br />
<br />
=== Sound ===<br />
To be added soon.<br />
<br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Additional Resources ===<br />
Sizecoding resource for the Atari Lynx are sparse<br />
* 42Bastian's website (link to be added)</div>Wilhttp://www.sizecoding.org/index.php?title=6502&diff=83165022021-02-16T00:24:36Z<p>Wil: /* Autostart */ zeropage overwriting part of CHRGET method</p>
<hr />
<div>== Introduction ==<br />
Wanting to start sizecoding on a 6502 platform in this day and age can be tough. <br />
<br />
[[File:6502.jpg|thumb]]<br />
<br />
So here is a bit of help to get you started:<br />
<br />
=== The 6502 processor ===<br />
The 6502 processor can be seen as the 8-bit micro ARM chip. <br />
It has only has 3 registers (Accumulator, X and Y registers) and a handful of instructions to work with.<br />
<br />
=== Adressing modes ===<br />
To be added.<br />
<br />
=== Zero page ===<br />
When using the 6502 for sizecoding, you'll mostly be working from zeropage<br />
<br />
=== General 6502 Resources ===<br />
* 6502.org http://www.6502.org/<br />
* 6502 instruction reference http://www.6502.org/tutorials/6502opcodes.html<br />
* 6502 books http://retro.hansotten.nl/6502-sbc/<br />
* 6502 Assembler tutorial https://dwheeler.com/6502/oneelkruns/asm1step.html<br />
* Easy 6502 code tester https://skilldrick.github.io/easy6502/<br />
* Synthetic instructions https://wiki.nesdev.com/w/index.php/Synthetic_instructions#8-bit_rotate<br />
<br />
== Atari 8-bit family ==<br />
The systems in this family are: Atari 400, 800, 5200, 1200XL, 600XL, 800XL, 130XE, 65XE, 800XE and XEGS.<br /><br />
<br />
The Atari 8-bit systems consists of the 6502 with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Atari 8bit systems is quite easy, first get the following tools:<br />
<br />
* Assembler: MADS Assembler - This assembler has nice macros for creating Binaries and SNA snapshot files out of the box. You can download it at https://mads.atari8.info/<br />
* Emulator(s): I Found Altirra to work best for my usecase. Make sure to use the original Rev2 rom for best compatibility.<br />
<br />
==== Special Memory Adresses ====<br />
* FRAMECOUNTER_HIGH = 19<br />
* FRAMECOUNTER_LOW = 20<br />
<br />
=== Video display ===<br />
Video display on the Atari 8bit systems use the ANTIC and GTIA chips. Information can be found here:<br />
* https://en.wikipedia.org/wiki/ANTIC<br />
* https://www.atariarchives.org/agagd/chapter1.php<br />
<br />
==== Sync with frame ====<br />
<syntaxhighlight lang="6502"><br />
RTCLOK equ $0012<br />
lda RTCLOK+2<br />
waits<br />
cmp RTCLOK+2<br />
beq waits<br />
</syntaxhighlight><br />
<br />
Or if you don't mind trashing RTCLOK<br />
<br />
<syntaxhighlight lang="6502"><br />
RTCLOK equ $0012<br />
waits<br />
lsr RTCLOK+2<br />
bcc waits<br />
</syntaxhighlight><br />
<br />
Which is two bytes shorter.<br />
<br />
==== Getting something on screen ====<br />
<syntaxhighlight lang="6502"><br />
;fill screen with charset,(88,89)=an address<br />
org $600; free 6th page:600-6ff<br />
ldy #0<br />
fl: tya<br />
sta(88),y<br />
iny<br />
bne fl<br />
jmp *<br />
</syntaxhighlight><br />
<br />
To be added soon.<br />
<br />
<syntaxhighlight lang="6502"><br />
SDMCTL = $022f<br />
HPOSP0 = $d000<br />
SIZEP0 = $d008<br />
GRAFP0 = $d00d<br />
COLPM0 = $d012<br />
<br />
FRAMECOUNTER_HIGH = 19<br />
FRAMECOUNTER = 20<br />
WSYNC = $d40a<br />
VCOUNT = $d40b<br />
<br />
sinewave = $0600 ; to $06ff<br />
<br />
org $80<br />
<br />
main <br />
; disable all graphics/colors<br />
ldx #0<br />
stx SDMCTL <br />
<br />
ldy #$7f<br />
sty SIZEP0 ; size p0=127<br />
<br />
ldx #0<br />
ldy #$3f<br />
make_sine:<br />
value_lo<br />
lda #0<br />
clc<br />
delta_lo<br />
adc #0<br />
sta value_lo+1<br />
value_hi<br />
lda #0<br />
delta_hi<br />
adc #0<br />
sta value_hi+1<br />
<br />
sta sinewave+$c0,x<br />
sta sinewave+$80,y<br />
eor #$7f<br />
sta sinewave+$40,x<br />
sta sinewave+$00,y<br />
<br />
lda delta_lo+1<br />
adc #8<br />
sta delta_lo+1<br />
bcc nothing<br />
inc delta_hi+1<br />
nothing<br />
inx<br />
dey<br />
bpl make_sine<br />
<br />
updateloop:<br />
; vblank<br />
lda VCOUNT<br />
bne updateloop<br />
<br />
; clear graphics<br />
sta HPOSP0<br />
sta GRAFP0<br />
<br />
ldy #0<br />
lda #47<br />
sta COLPM0<br />
yloop:<br />
tya ; graphics shape = y<br />
sta WSYNC<br />
sta GRAFP0<br />
<br />
; a = sin(frame+y)+48<br />
tya <br />
adc FRAMECOUNTER<br />
tax<br />
lda sinewave,x<br />
adc #48<br />
sta HPOSP0<br />
<br />
iny<br />
bne yloop<br />
jmp updateloop<br />
<br />
run main<br />
</syntaxhighlight><br />
<br />
=== Sound ===<br />
The Atari 8-bit use the POKEY chip to generate sound.<br />
* https://en.wikipedia.org/wiki/POKEY<br />
<br />
==== BASIC ====<br />
<syntaxhighlight lang="6502"><br />
; from Analog, 1985-09,pp.25-32<br />
*=$2000<br />
AUDF1=$D200<br />
AUDC1=$D201<br />
AUDCTL=$D208<br />
SKCTL=$D20F<br />
<br />
.MACRO SOUND ; voice,pitch,dist,vol;,dur<br />
lda #%2<br />
sta AUDF1+2*%1<br />
lda #[[%3 * 16] | %4] ;lda #[[%3 shl 4] or %4]<br />
sta AUDC1+2*%1<br />
.ENDM<br />
<br />
lda #0<br />
sta AUDCTL<br />
lda #3<br />
sta SKCTL<br />
<br />
SOUND 0,121,10,8<br />
<br />
jmp *<br />
</syntaxhighlight><br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Additional Resources ===<br />
Sizecoding resource for the Atari 8bit are:<br />
* Mapping the Atari https://www.atariarchives.org/mapping/<br />
* Atari 8bit Memory map https://www.atariarchives.org/mapping/memorymap.php<br />
* Fready's undocumented 6502 opcodes https://github.com/FreddyOffenga/6502<br />
* Atari OS Rev2 disassembly for MADS assembler https://github.com/ilmenit/A800-OS-XL-Rev2<br />
* Fready's github https://github.com/FreddyOffenga/<br />
<br />
== Commodore 64 ==<br />
The Commodore system consists of a 6502-compatible MOS 6510 processor with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Commodore systems is quite easy, first get the following tools:<br />
<br />
* Assembler: To be added<br />
* Emulator(s): VICE is the way to go<br />
<br />
=== Memory map ===<br />
<br />
<syntaxhighlight lang="6502"><br />
0-1 $0-$1 PROCESSOR PORT REGISTERS, not usable as RAM<br />
0-255 $0-$FF ZEROPAGE, mostly used by BASIC interpreter and Kernal<br />
256-511 $100-$1FF SYSTEM STACK<br />
512-600 $200-$258 INPUT BUFFER<br />
601-630 $259-$276 FILE SYSTEM DATA<br />
631-640 $277-$280 KEYBOARD BUFFER, filled by Kernal ISR upon key presses <br />
641-678 $281-$2A6 VARIOUS KERNAL VARIABLES<br />
679-767 $2A7-$2FF Unused (89 byte)<br />
768-779 $300-$30B KERNAL VECTORS<br />
780-783 $30C-$30F REGISTER VALUES A,X,Y,SR for SYS<br />
784-819 $310-$333 KERNAL VECTORS<br />
820-827 $334-$33B Unused (8 byte)<br />
828-1019 $33C-$3FB DATASETTE BUFFER<br />
1020-1023 $3FC-$3FF Unused (4 byte)<br />
1024-2023 $400-$7E7 SCREEN MEMORY (25 lines times 40 columns)<br />
2024-2039 $7E8-$7F7 Unused (16 byte)<br />
2040-2047 $7F8-$7FF SPRITE COSTUME POINTERS<br />
2048 $800 must contain a value of 0 so that the BASIC program can be RUN<br />
2049-40959 $801-$9FFF BASIC AREA (code, variables, arrays, strings)<br />
40960-49151 $A000-$BFFF BASIC ROM (unused RAM underneath)<br />
49152-53247 $C000-$CFFF UPPER RAM AREA (unused)<br />
53248-53294 $D000-$D02E VIC-II, memory-mapped graphics chip registers)<br />
54272-54300 $D400-$D41C SID, memory-mapped sound chip registers)<br />
55296-56295 $D800-$DBE7 Color RAM, only lower 4 bits are stored, higher nibble undefined<br />
56296-56319 $DBE8-$DBFF Unused (24 half-bytes)<br />
56320-56335 $DC00-$DC0F CIA#1, memory-mapped I/O chip registers for keyboard, joystick, mouse, datasette, IRQ control<br />
56576-56591 $DD00-$DD0F CIA#1, memory-mapped I/O chip registers for serial bus, RS232, NMI control<br />
57344-65535 $E000-$FFFF KERNAL ROM<br />
65534-65535 $FFFE-$FFFF Execution address of interrupt service routine, can only be set if KERNAL is turned off<br />
</syntaxhighlight><br />
<br />
For a detailed explanation of the C64 memory map check out [https://sta.c64.org/cbm64mem.html Commodore 64 memory map] on Joe Forster/STA homepage.<br />
<br />
=== Program file overhead ===<br />
<br />
A standard CBM file consists of a 2 byte loading address followed by the data that is placed into memory starting at this address. In addition, if your machine program should be able to be started with "RUN", you need a BASIC stub that is loaded into memory from $0801 to $080c, typically followed by your machine program:<br />
<br />
<syntaxhighlight lang="6502"><br />
*=$0801<br />
.word $080b ;address of next BASIC line<br />
.word LINENR ;line number, can be chosen between 0 and 63999<br />
.byte $9e ;token for SYS command<br />
.byte $32,$30,$36,$31 ;address to jump to in ASCII code: "2061" <br />
.byte $00 ;end of BASIC line<br />
.word $0000 ;address of next BASIC line, $0000 means end of BASIC program <br />
start<br />
; your code here<br />
</syntaxhighlight><br />
<br />
Together with the 2 byte load address, this makes an overhead of 14 byte for your program. To reduce this, you can<br />
* omit the BASIC line and tell users to start your program by directly entering "SYS ''address''"<br />
* save your program from $0802 on, the byte at $0801 is recovered automatically after loading by the relink function. This reduces your program file size by 1 byte<br />
* accept the loss and use the 2 byte establishing LINENR for something good, they are copied to zeropage addresses $39/$3a automatically, saving you the effort of initializing the addresses<br />
* use an autostart method (see below)<br />
<br />
Some compos also specify that the BASIC loader does not count towards the overall filesize, check the rules before you worry.<br />
<br />
=== Autostart ===<br />
<br />
Unlike the Commodore 128, the Commodore 64 has no dedicated built-in auto-boot feature, but it is possible to autorun a program after loading by specifying the load address so that it overwrites a vector or address that is called by the operating system. There are multiple possibilities:<br />
<br />
==== Overwriting CHROUT vector at $326-$327 ====<br />
<br />
The vector at address $326-$327 points at the CHROUT routine, normally at address $F1CA.<br />
If you put the entry address of your program into $326/27, your code will be called when the operating system wants to print "READY." after loading.<br />
Note that the vector at address $328-$329 points at the STOP routine that checks the status of Stop key indicator. Since this routine is called multiple times before your code is done loading, its default value $F6ED needs to be preserved. <br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$0326<br />
.word start <br />
.byte $ed,$f6<br />
start<br />
; rest of code<br />
</syntaxhighlight><br />
<br />
Together with the two byte load address, the overwritten CHROUT vector and the preserved STOP vector, your program file will have a deadweight of 6 byte: $26 $03 $0a $03 $ed $f6, less than half of the standard version with a BASIC stub with SYS<br />
<br />
Caveat:<br />
* If your program after $32a is longer than 214 byte, part of your program will load into the screen at $400. Thus, issuing a clear screen will overwrite your program. It is possible to move the screen memory somewhere else, but that requires storing a new value into address $D018, which when done with an LDA # / STA pair will cost you 5 byte<br />
* Since you changed the CHROUT pointer, standard KERNAL functions for printing won't work. For output of single characters, you can still use the direct address $F1CA. Alternatively, you can restore the vectors by calling $FD15, which will overwrite the memory $314 to $333 with the default values.<br />
<br />
==== Overwriting BASIC idle loop vector at $302-$303 ====<br />
<br />
After loading the program, the BASIC idle loop will be called. By overwriting the vector at $302/$303 it is possible to autostart your program. Since the memory before $302 can be safely overwritten, the program would be arranged so that $303 is the '''last''' address of your program. If your program requires a loop back to the start, the vector can be used as part of a JMP where the following two bytes are already there, saving one byte in comparison to a loop done with a branch command.<br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$304 - (end - start)<br />
start:<br />
;your code here<br />
; ...<br />
jmp start ;the address for start lies in $302/$303, thus will be called by the Kernal after loading<br />
end:<br />
</syntaxhighlight><br />
<br />
In cases where the vector has a practical use, the overhead in filesize is only the 2 byte loading address. For programs larger than 93 byte keep in mind that addresses before $2A7 are in use by the Kernal.<br />
<br />
==== Overwriting return address on stack at $1F8 ====<br />
<br />
When the load routine is called, the stack pointer is always at $FA at a stock C64. Thus the return address from the loading process is stored in memory address $F8 (low byte) and $F9 (high byte). During the loading routine, stack usage will clobber the stack below $1F8, but a program loaded to $1F8 and above will be fine and the overwritten address stored at $1F8/$1F9 will be called after loading.<br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$1F8<br />
.word start-1 ;adjust for the RTS command pulling the address from stack and increasing it by 1<br />
start:<br />
;your code here<br />
</syntaxhighlight><br />
<br />
For programs larger than 95 byte keep in mind that addresses after $259 are in use by the Kernal, you might overwrite some values here if you don't have disk operations, but better check the memory map beforehand.<br />
<br />
Together with the two byte load address and the overwritten address at $1F8/$1F9, your program file will have a deadweight of 4 byte when using this method.<br />
<br />
==== Putting your program into zeropage overwriting part of CHRGET ====<br />
<br />
CHRGET is a machine code routine for the BASIC interpreter that is placed in the zero page at $73-$8A. By putting your program at $7C and following, the CHRGET routine runs directly into your code.<br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$7C<br />
start:<br />
;your code here<br />
</syntaxhighlight><br />
<br />
With this method, there is no need for a start address vector. The only deadweight in your program is the loading address. However, the zero page is a busy place, if your program extends beyond address $8f (that is it has more than 22 bytes on disk) you have to deal with some parts of your program being overwritten, for example, the status byte in $90 is set after loading.<br />
<br />
=== Video display ===<br />
Video display on the Commodore has the following video modes:<br />
* Standard text mode, 40x25 characters, 1 individual color per character, 1 common background color<br />
* Multicolor text mode, 40x25 characters, every two bits (fat pixel) define color: background, char, common color 1+2<br />
* Extended color text mode, 40x25 characters, 1 individual foreground color per character, 1 out of 4 background colors, only 64 chars<br />
* Hires bitmap, 320x200 pixels, an 8x8 field can have an individual foreground and an individual background color<br />
* Multicolor bitmap, 160x200 pixels, every two bits (fat pixel) define color: background, screen color lower nibble, screen color higher nibble, color from color RAM<br />
<br />
==== Sync with frame ====<br />
<br />
Depending on the VIC type, there are 262/263 raster lines (NTSC) or 312 raster lines (PAL-B). Therefore, the VIC uses register at $D011 and the highest bit of register $D012 to represent the current raster line. Checking only the lower 8 bits and waiting for them to be 0 would therefore not work because this happens two times per frame. However, any number greater than 64 will only trigger once. Using a value of 255, we would sync to a rasterline at the end of the screen, well below the part where graphics are normally displayed:<br />
<br />
<syntaxhighlight lang="6502"><br />
lda #$FF<br />
waitsync:<br />
cmp $D012<br />
bne waitsync<br />
</syntaxhighlight><br />
<br />
As long as there have more than 63 cycles passed since the snyc, the next sync will happen at the next frame.<br />
This works fine as long as we don't miss the line 255 due to an interrupt. If your program has interrupts that are not synced to a rasterline, you can change the condition as follows<br />
<syntaxhighlight lang="6502"><br />
lda #$E3<br />
waitsync:<br />
cmp $D012<br />
bcs waitsync<br />
</syntaxhighlight><br />
<br />
Now we have a window between raster line $E4 and $FF to trigger our sync, which we will meet even if a standard Kernal interrupt comes in-between. Of course, our main program now has to burn around 1700 cycles to avoid a retriggering in the same frame.<br />
<br />
==== Getting something on screen ====<br />
<br />
Output a character:<br />
<syntaxhighlight lang="6502"><br />
lda #C ;C must be the char code according to the PETSCII code table<br />
jsr $FFD2 ;you can also use the direct address $FC1A, function preserves A,X,Y and enables interrupt<br />
</syntaxhighlight><br />
<br />
Since the [https://en.wikipedia.org/wiki/PETSCII#Character_set PETSCII code table] contains also control characters, this method can be also used to clear the screen, move the cursor or set the text color. However, some functions are shorter (and faster) by directly calling the respective KERNAL function:<br />
<br />
<syntaxhighlight lang="6502"><br />
Clear screen JSR $E544<br />
Cursor home position JSR $E566<br />
Output newline character JSR $AAD7<br />
Set text color LDA #COLOR, STA $286<br />
Set border color LDA #COLOR, STA $D020 ;not possible with a PETSCII control code<br />
Set background color LDA #COLOR, STA $D021 ;not possible with a PETSCII control code<br />
</syntaxhighlight><br />
<br />
Copy characters directly to screen memory:<br />
<br />
<syntaxhighlight lang="6502"><br />
.macpack cbm ;scrcode macro<br />
SCREEN_BASE=$400<br />
LINE=5 ;for example<br />
COLUMN=10 ;for example<br />
<br />
ldx #endtext-text-1<br />
@loop: lda text,x<br />
sta SCREEN_BASE+LINE*40+COLUMN,x<br />
dex<br />
bpl @loop<br />
text: scrcode "hello world!"<br />
endtext:<br />
</syntaxhighlight><br />
<br />
Note that the text needs to be stored in '''screen code''' format, not in PETSCII (see [https://sta.c64.org/cbm64pettoscr.html Commodore 64 PETSCII code to screen code conversion] for the differences). Furthermore, the example above only writes to the screen memory, not the color RAM, assuming that the color RAM already contains the intended text color. This is the case after issuing a clear screen on most C64 machines, except for some old ROM revisions. To be on the save side you would have to write to color RAM as well, which costs another 5 byte:<br />
<br />
<syntaxhighlight lang="6502"><br />
.macpack cbm ;scrcode macro<br />
SCREEN_BASE=$400<br />
COLOR_RAM =$D800<br />
LINE =5 ;for example<br />
COLUMN =10 ;for example<br />
COLOR =1 ;white<br />
<br />
ldx #endtext-text-1<br />
@loop: lda text,x<br />
sta SCREEN_BASE+LINE*40+COLUMN,x<br />
lda #COLOR<br />
sta COLOR_RAM +LINE*40+COLUMN,x<br />
dex<br />
bpl @loop<br />
text: scrcode "hello world!"<br />
endtext:<br />
</syntaxhighlight><br />
<br />
=== Sound ===<br />
The Commodore 64 uses the famous SID chip to generate sound.<br />
To be added soon.<br />
<br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Useful Kernal functions ===<br />
<br />
==== Get a pseudo random number ====<br />
<br />
<syntaxhighlight lang="6502"><br />
lda #1 <br />
jsr $E09A<br />
lda $63<br />
</syntaxhighlight><br />
<br />
The sequence of random numbers is always the same after a cold start or reset, the first 20 numbers are:<br />
<syntaxhighlight lang="6502"><br />
4,24,231,4,177,170,193,101,231,18,196,1,75,48,149,36,124,53,65,154<br />
</syntaxhighlight><br />
<br />
==== Increment a zero page counter, return in X register, clear Y register ====<br />
<br />
This is part of the string handling function in the BASIC ROM, but the code could be useful for some loop stuff.<br />
<br />
<syntaxhighlight lang="6502"><br />
jsr $B5FF ;does inc $23, ldx $23, ldy #$00, rts<br />
</syntaxhighlight><br />
<br />
=== Additional Resources ===<br />
* Codebase 64 https://codebase64.org/doku.php?id=base:start<br />
* Commodore 64 Memory map https://sta.c64.org/cbm64mem.html<br />
* C64 BASIC & KERNAL ROM Disassembly https://www.pagetable.com/c64ref/c64disasm/<br />
<br />
== Apple II ==<br />
The Apple II is an 8-bit home computer and one of the world's first highly successful mass-produced microcomputer products. It was designed primarily by Steve Wozniak.<br />
<br />
=== Setting up ===<br />
* ACME 6502 cross-assembler(https://sourceforge.net/projects/acme-crossass/)<br />
* Apple Commander (http://applecommander.sourceforge.net) for batch compilation<br />
* AppleWin emulator (https://github.com/AppleWin/AppleWin/releases). Supports Mockingboard card(AY-8910+speech synthesier), HDD, Z80 card(for CP/M), mouse etc.<br />
* CiderPress(https://a2ciderpress.com)<br />
<br />
Compilation can be done as follows (master.dsk can be found with applewin) <br />
<syntaxhighlight><br />
acme hl.asm<br />
java -jar AppleCommander-1.3.5.jar -d master.dsk hl<br />
java -jar AppleCommander-1.3.5.jar -p master.dsk hl B 24576 < hl.bin<br />
</syntaxhighlight><br />
<br />
=== Memory Map ===<br />
<syntaxhighlight lang="6502"><br />
0-255 $0-$FF ZERO-PAGE SYSTEM STORAGE<br />
256-511 $100-$1FF SYSTEM STACK<br />
512-767 $200-$2FF KEYBOARD CHARACTER BUFFER<br />
768-975 $300-$3CF OFTEN AVAILABLE AS FREE SPACE FOR USER PROGRAMS<br />
976-1023 $3D0-3FF SYSTEM VECTORS<br />
1024-2047 $400-$7FF TEXT AND LO-RES GRAPHICS PAGE 1 <--- !!!<br />
2048-LOMEM $800-LOMEM PROGRAM STORAGE<br />
2048-3071 $800-$BFF TEXT AND LO-RES GRAPHICS PAGE 2 OR FREE SPACE<br />
3072-8191 $C00-$1FFF FREE SPACE UNLESS RAM APPLESOFT IS IN USE<br />
8192-16383 $2000-$3FFF HI-RES PAGE 1 OR FREE SPACE <--- !!!<br />
16384-24575 $4000-$5FFF HI-RES PAGE 2 OR FREE SPACE<br />
24576-38999 $6000-$95FF FREE SPACE AND STRING STORAGE<br />
38400-49151 $9600-$BFFF DOS<br />
49152-53247 $C000-$CFFF I/O HARDWARE (RESERVED)<br />
53248-57343 $D000-$DFFF APPLESOFT IN LANGUAGE CARD OR ROM<br />
57344-63487 $E000-$F7FF APPLESOFT OR INTEGER BASIC IN LANGUAGE CARD OR ROM<br />
63488-65535 $F800-$FFFF SYSTEM MONITOR<br />
</syntaxhighlight><br />
<br />
=== Display ===<br />
<br />
=== Graphics Modes ===<br />
: Text Mode 40x24, for Apple IIe available 80x25 - use PR#3 for switch mode, or hardware switch<br />
: LowRes 40x48, 16 colors: https://en.wikipedia.org/wiki/Apple_II_graphics <br />
: Hires mode 280x192,6 colors: https://www.xtof.info/blog/?p=768<br />
https://mrob.com/pub/xapple2/colors.html<br />
https://archive.org/details/HiRes_Color_Graphics_on_the_Apple_II_Computer_by_Wozniak<br />
<br />
However for sizecoding, you almost never want to do direct-access to graphics for Apple II in size-coding because the Apple II graphics modes are horrible. The only fast way to do things is with large lookup tables. To do hires you need to divide by 7 which as you can imagine is a bit difficult to do compactly on 6502. Double-hires is even crazier on top of that. Deater did manage a color-bar style effect in double-hires in 128B but that was doing some crazy tricks with the firmware BASIC routines, definitely not direct-access.<br />
<br />
Lores and Hires can be mixed modes and full-graphics<br />
The screen structure is called memory holes(https://retrocomputing.stackexchange.com/questions/2534/what-are-the-screen-holes-in-apple-ii-graphics). The GBASCALC($F847) procedure is used to calculate the address of the horizontal line : IN:reg.A=Y, out : GBASL/GBASH($26/$27)=address. See also https://www.callapple.org/uncategorized/use-of-apple-ii-color-graphics-in-assembly-language/<br />
<br />
==== Getting something on screen ====<br />
Here is an example of a XOR texture, created by g0blinish<br />
<syntaxhighlight lang="6502"><br />
*=$6000<br />
!to "HL.bin", plain ; set output file and format<br />
!cpu 6502 ; set processor type<br />
<br />
GBASL = $26<br />
GBASH = $27<br />
SETGR = $FB40 ; setup LoRes<br />
GBASCALC = $F847 ; calc Address<br />
<br />
CLRTEXT = $C050 ;display graphics <br />
SETTEXT = $C051 ;display text <br />
<br />
CLRMIXED = $C052 ;clear mixed mode- enable full graphics <br />
SETMIXED = $C053 ;enable graphics/text mixed mode <br />
<br />
PAGE1 = $C054 ;select text/graphics page1 <br />
PAGE2 = $C055 ;select text/graphics page2 <br />
<br />
CLRHIRES = $C056 ;select Lo-res <br />
SETHIRES = $C057 ;select Hi-res <br />
<br />
TMP= $FA<br />
<br />
JSR SETGR ;GR<br />
BIT CLRMIXED ; full screen<br />
<br />
LDA #0 ; A=0<br />
STA TMP ; POKE $FA,A<br />
<br />
YLP ;<br />
LDA TMP ; A=PEEK($FA)<br />
; LSR ; A=A/2<br />
JSR GBASCALC<br />
LDY #0;Y=0<br />
<br />
XLP TYA ; A=Y<br />
EOR TMP ; A=A xor PEEK($FA)<br />
and #$0F ; A=A and 15<br />
TAX ; X=A<br />
LDA COLORS,X ;A=PEEK(COLORS+X)<br />
STA(GBASL),Y ; POKE PEEK($26)+256*PEEK($27)+Y,A<br />
INY ; Y=Y+1<br />
CPY #40 ; Y=40?<br />
BNE XLP<br />
INC TMP ; POKE $FA,PEEK($FA)+1<br />
LDA TMP ; A=PEEK($FA)<br />
CMP #24 ; A=24?<br />
BNE YLP<br />
<br />
M1 JMP M1 ; replace to RTS<br />
<br />
COLORS ;N*17, pixel format is AAAABBBB, AAAA - upper dot, BBBB - lower dot<br />
!byte $00,$11,$22,$33,$44,$55,$66,$77<br />
!byte $88,$99,$AA,$BB,$CC,$DD,$EE,$FF<br />
</syntaxhighlight><br />
<br />
==== Sound ====<br />
Here is an example for using the speaker, based onthe following basic program:<br />
<br />
<syntaxhighlight lang="basic"><br />
; 50 POKE 768,V: POKE 769,P - 255 * INT (P / 256): POKE 800,1 + P / 256<br />
; 60 CALL 770: RETURN <br />
; 95 FOR K = 1 TO N: READ V(K),P(K): NEXT K<br />
; 100 FOR K = 1 TO N:V = V(K):P = P(K)<br />
; 110 GOSUB 50<br />
;!byte 173,48,192,136,208,5,206,1,3,240,9,202,208,245,174,0,3,76,2,3,206,32,3,208,240,96<br />
</syntaxhighlight><br />
<br />
<syntaxhighlight lang="6502"><br />
*=$6000<br />
!to "HL.bin", plain ; set output file and format<br />
!cpu 6502 ; set processor type<br />
<br />
;start<br />
; 95 FOR K = 1 TO N: READ V(K),P(K): NEXT K<br />
; 100 FOR K = 1 TO N:V = V(K):P = P(K)<br />
ini:<br />
lda #70<br />
sta cnt+1<br />
lda #music&255<br />
sta gotbyte+1<br />
lda #music/256<br />
sta gotbyte+2<br />
<br />
lop:<br />
;V<br />
jsr gotbyte<br />
sta L300<br />
jsr gotbyte<br />
;P<br />
jsr gotbyte<br />
sta L301<br />
jsr gotbyte<br />
clc<br />
adc #1<br />
sta L320<br />
jsr beep<br />
<br />
dec cnt+1<br />
cnt lda #70<br />
bne lop<br />
; 110 GOSUB 50<br />
; 50 POKE 768,V: POKE 769,P - 255 * INT (P / 256): POKE 800,1 + P / 256<br />
; 60 CALL 770: RETURN <br />
jmp ini<br />
gotbyte<br />
lda music<br />
inc gotbyte+1<br />
bne noinch<br />
inc gotbyte+2<br />
noinch<br />
rts<br />
;!byte 173,48,192,136,208,5,206,1,3,240,9,202,208,245,174,0,3,76,2,3,206,32,3,208,240,96<br />
beep:<br />
ldy #1<br />
ldx #1<br />
loc_302:<br />
LDA $C030<br />
<br />
loc_305:<br />
DEY<br />
BNE loc_30D<br />
DEC L301<br />
loc_30B:<br />
BEQ loc_316<br />
<br />
loc_30D:<br />
DEX<br />
BNE loc_305<br />
LDX L300<br />
JMP loc_302<br />
loc_316:<br />
DEC L320<br />
BNE loc_30B<br />
RTS<br />
L301 !byte 0<br />
L300 !byte 0<br />
L320 !byte 0<br />
music<br />
!word 76,192,85,64,96,64,102,64,114,128,114,64,96,64,102,64,114,64,128,64<br />
!word 114,64,152,64,171,64,152,512,76,192,85,64,96,64,102,64,114,128,114,64<br />
!word 96,64,102,64,114,64,128,64,114,64,152,64,171,64,152,512,85,64,85,64<br />
!word 85,64,96,64,144,128,144,64,128,64,76,128,85,64,96,64,144,128,114,64<br />
!word 96,64,102,128,114,64,128,64,128,128,114,64,128,64,114,512,85,64,85,64<br />
!word 85,64,96,64,144,128,144,64,128,64,76,128,85,64,96,64,144,128,114,64<br />
!word 96,64,102,128,114,64,128,64,128,64,128,128,96,64,85,64,96,64,102,64,114,64,114,64<br />
</syntaxhighlight><br />
<br />
=== Additional Resources ===<br />
* Deater's page on Apple II sizecoding http://www.deater.net/weave/vmwprod/demos/sizecoding.html<br />
* Article on double hi-res http://www.battlestations.zone/2017/04/apple-ii-double-hi-res-from-ground-up.html<br />
* Applesoft Hi-Res Subroutines : http://hackzapple.org/scripts_php/index.php?menu=5&mod=ASM&sub=AAL&sub2=8112&PHPSESSID=f65fabfd0cdbf56b6bdc0ddac25117c6#a2<br />
<br />
== Atari Lynx ==<br />
The Atari Lynx consists of the 6502 with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Atari Lynx:<br />
<br />
* Assembler: -<br />
* Emulator(s): -<br />
<br />
=== Video display ===<br />
To be added soon.<br />
<br />
==== Getting something on screen ====<br />
To be added soon.<br />
<br />
<br />
=== Sound ===<br />
To be added soon.<br />
<br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Additional Resources ===<br />
Sizecoding resource for the Atari Lynx are sparse<br />
* 42Bastian's website (link to be added)</div>Wilhttp://www.sizecoding.org/index.php?title=6502&diff=83065022021-02-16T00:06:13Z<p>Wil: /* Sync with frame */ added IRQ-tolerant version</p>
<hr />
<div>== Introduction ==<br />
Wanting to start sizecoding on a 6502 platform in this day and age can be tough. <br />
<br />
[[File:6502.jpg|thumb]]<br />
<br />
So here is a bit of help to get you started:<br />
<br />
=== The 6502 processor ===<br />
The 6502 processor can be seen as the 8-bit micro ARM chip. <br />
It has only has 3 registers (Accumulator, X and Y registers) and a handful of instructions to work with.<br />
<br />
=== Adressing modes ===<br />
To be added.<br />
<br />
=== Zero page ===<br />
When using the 6502 for sizecoding, you'll mostly be working from zeropage<br />
<br />
=== General 6502 Resources ===<br />
* 6502.org http://www.6502.org/<br />
* 6502 instruction reference http://www.6502.org/tutorials/6502opcodes.html<br />
* 6502 books http://retro.hansotten.nl/6502-sbc/<br />
* 6502 Assembler tutorial https://dwheeler.com/6502/oneelkruns/asm1step.html<br />
* Easy 6502 code tester https://skilldrick.github.io/easy6502/<br />
* Synthetic instructions https://wiki.nesdev.com/w/index.php/Synthetic_instructions#8-bit_rotate<br />
<br />
== Atari 8-bit family ==<br />
The systems in this family are: Atari 400, 800, 5200, 1200XL, 600XL, 800XL, 130XE, 65XE, 800XE and XEGS.<br /><br />
<br />
The Atari 8-bit systems consists of the 6502 with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Atari 8bit systems is quite easy, first get the following tools:<br />
<br />
* Assembler: MADS Assembler - This assembler has nice macros for creating Binaries and SNA snapshot files out of the box. You can download it at https://mads.atari8.info/<br />
* Emulator(s): I Found Altirra to work best for my usecase. Make sure to use the original Rev2 rom for best compatibility.<br />
<br />
==== Special Memory Adresses ====<br />
* FRAMECOUNTER_HIGH = 19<br />
* FRAMECOUNTER_LOW = 20<br />
<br />
=== Video display ===<br />
Video display on the Atari 8bit systems use the ANTIC and GTIA chips. Information can be found here:<br />
* https://en.wikipedia.org/wiki/ANTIC<br />
* https://www.atariarchives.org/agagd/chapter1.php<br />
<br />
==== Sync with frame ====<br />
<syntaxhighlight lang="6502"><br />
RTCLOK equ $0012<br />
lda RTCLOK+2<br />
waits<br />
cmp RTCLOK+2<br />
beq waits<br />
</syntaxhighlight><br />
<br />
Or if you don't mind trashing RTCLOK<br />
<br />
<syntaxhighlight lang="6502"><br />
RTCLOK equ $0012<br />
waits<br />
lsr RTCLOK+2<br />
bcc waits<br />
</syntaxhighlight><br />
<br />
Which is two bytes shorter.<br />
<br />
==== Getting something on screen ====<br />
<syntaxhighlight lang="6502"><br />
;fill screen with charset,(88,89)=an address<br />
org $600; free 6th page:600-6ff<br />
ldy #0<br />
fl: tya<br />
sta(88),y<br />
iny<br />
bne fl<br />
jmp *<br />
</syntaxhighlight><br />
<br />
To be added soon.<br />
<br />
<syntaxhighlight lang="6502"><br />
SDMCTL = $022f<br />
HPOSP0 = $d000<br />
SIZEP0 = $d008<br />
GRAFP0 = $d00d<br />
COLPM0 = $d012<br />
<br />
FRAMECOUNTER_HIGH = 19<br />
FRAMECOUNTER = 20<br />
WSYNC = $d40a<br />
VCOUNT = $d40b<br />
<br />
sinewave = $0600 ; to $06ff<br />
<br />
org $80<br />
<br />
main <br />
; disable all graphics/colors<br />
ldx #0<br />
stx SDMCTL <br />
<br />
ldy #$7f<br />
sty SIZEP0 ; size p0=127<br />
<br />
ldx #0<br />
ldy #$3f<br />
make_sine:<br />
value_lo<br />
lda #0<br />
clc<br />
delta_lo<br />
adc #0<br />
sta value_lo+1<br />
value_hi<br />
lda #0<br />
delta_hi<br />
adc #0<br />
sta value_hi+1<br />
<br />
sta sinewave+$c0,x<br />
sta sinewave+$80,y<br />
eor #$7f<br />
sta sinewave+$40,x<br />
sta sinewave+$00,y<br />
<br />
lda delta_lo+1<br />
adc #8<br />
sta delta_lo+1<br />
bcc nothing<br />
inc delta_hi+1<br />
nothing<br />
inx<br />
dey<br />
bpl make_sine<br />
<br />
updateloop:<br />
; vblank<br />
lda VCOUNT<br />
bne updateloop<br />
<br />
; clear graphics<br />
sta HPOSP0<br />
sta GRAFP0<br />
<br />
ldy #0<br />
lda #47<br />
sta COLPM0<br />
yloop:<br />
tya ; graphics shape = y<br />
sta WSYNC<br />
sta GRAFP0<br />
<br />
; a = sin(frame+y)+48<br />
tya <br />
adc FRAMECOUNTER<br />
tax<br />
lda sinewave,x<br />
adc #48<br />
sta HPOSP0<br />
<br />
iny<br />
bne yloop<br />
jmp updateloop<br />
<br />
run main<br />
</syntaxhighlight><br />
<br />
=== Sound ===<br />
The Atari 8-bit use the POKEY chip to generate sound.<br />
* https://en.wikipedia.org/wiki/POKEY<br />
<br />
==== BASIC ====<br />
<syntaxhighlight lang="6502"><br />
; from Analog, 1985-09,pp.25-32<br />
*=$2000<br />
AUDF1=$D200<br />
AUDC1=$D201<br />
AUDCTL=$D208<br />
SKCTL=$D20F<br />
<br />
.MACRO SOUND ; voice,pitch,dist,vol;,dur<br />
lda #%2<br />
sta AUDF1+2*%1<br />
lda #[[%3 * 16] | %4] ;lda #[[%3 shl 4] or %4]<br />
sta AUDC1+2*%1<br />
.ENDM<br />
<br />
lda #0<br />
sta AUDCTL<br />
lda #3<br />
sta SKCTL<br />
<br />
SOUND 0,121,10,8<br />
<br />
jmp *<br />
</syntaxhighlight><br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Additional Resources ===<br />
Sizecoding resource for the Atari 8bit are:<br />
* Mapping the Atari https://www.atariarchives.org/mapping/<br />
* Atari 8bit Memory map https://www.atariarchives.org/mapping/memorymap.php<br />
* Fready's undocumented 6502 opcodes https://github.com/FreddyOffenga/6502<br />
* Atari OS Rev2 disassembly for MADS assembler https://github.com/ilmenit/A800-OS-XL-Rev2<br />
* Fready's github https://github.com/FreddyOffenga/<br />
<br />
== Commodore 64 ==<br />
The Commodore system consists of a 6502-compatible MOS 6510 processor with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Commodore systems is quite easy, first get the following tools:<br />
<br />
* Assembler: To be added<br />
* Emulator(s): VICE is the way to go<br />
<br />
=== Memory map ===<br />
<br />
<syntaxhighlight lang="6502"><br />
0-1 $0-$1 PROCESSOR PORT REGISTERS, not usable as RAM<br />
0-255 $0-$FF ZEROPAGE, mostly used by BASIC interpreter and Kernal<br />
256-511 $100-$1FF SYSTEM STACK<br />
512-600 $200-$258 INPUT BUFFER<br />
601-630 $259-$276 FILE SYSTEM DATA<br />
631-640 $277-$280 KEYBOARD BUFFER, filled by Kernal ISR upon key presses <br />
641-678 $281-$2A6 VARIOUS KERNAL VARIABLES<br />
679-767 $2A7-$2FF Unused (89 byte)<br />
768-779 $300-$30B KERNAL VECTORS<br />
780-783 $30C-$30F REGISTER VALUES A,X,Y,SR for SYS<br />
784-819 $310-$333 KERNAL VECTORS<br />
820-827 $334-$33B Unused (8 byte)<br />
828-1019 $33C-$3FB DATASETTE BUFFER<br />
1020-1023 $3FC-$3FF Unused (4 byte)<br />
1024-2023 $400-$7E7 SCREEN MEMORY (25 lines times 40 columns)<br />
2024-2039 $7E8-$7F7 Unused (16 byte)<br />
2040-2047 $7F8-$7FF SPRITE COSTUME POINTERS<br />
2048 $800 must contain a value of 0 so that the BASIC program can be RUN<br />
2049-40959 $801-$9FFF BASIC AREA (code, variables, arrays, strings)<br />
40960-49151 $A000-$BFFF BASIC ROM (unused RAM underneath)<br />
49152-53247 $C000-$CFFF UPPER RAM AREA (unused)<br />
53248-53294 $D000-$D02E VIC-II, memory-mapped graphics chip registers)<br />
54272-54300 $D400-$D41C SID, memory-mapped sound chip registers)<br />
55296-56295 $D800-$DBE7 Color RAM, only lower 4 bits are stored, higher nibble undefined<br />
56296-56319 $DBE8-$DBFF Unused (24 half-bytes)<br />
56320-56335 $DC00-$DC0F CIA#1, memory-mapped I/O chip registers for keyboard, joystick, mouse, datasette, IRQ control<br />
56576-56591 $DD00-$DD0F CIA#1, memory-mapped I/O chip registers for serial bus, RS232, NMI control<br />
57344-65535 $E000-$FFFF KERNAL ROM<br />
65534-65535 $FFFE-$FFFF Execution address of interrupt service routine, can only be set if KERNAL is turned off<br />
</syntaxhighlight><br />
<br />
For a detailed explanation of the C64 memory map check out [https://sta.c64.org/cbm64mem.html Commodore 64 memory map] on Joe Forster/STA homepage.<br />
<br />
=== Program file overhead ===<br />
<br />
A standard CBM file consists of a 2 byte loading address followed by the data that is placed into memory starting at this address. In addition, if your machine program should be able to be started with "RUN", you need a BASIC stub that is loaded into memory from $0801 to $080c, typically followed by your machine program:<br />
<br />
<syntaxhighlight lang="6502"><br />
*=$0801<br />
.word $080b ;address of next BASIC line<br />
.word LINENR ;line number, can be chosen between 0 and 63999<br />
.byte $9e ;token for SYS command<br />
.byte $32,$30,$36,$31 ;address to jump to in ASCII code: "2061" <br />
.byte $00 ;end of BASIC line<br />
.word $0000 ;address of next BASIC line, $0000 means end of BASIC program <br />
start<br />
; your code here<br />
</syntaxhighlight><br />
<br />
Together with the 2 byte load address, this makes an overhead of 14 byte for your program. To reduce this, you can<br />
* omit the BASIC line and tell users to start your program by directly entering "SYS ''address''"<br />
* save your program from $0802 on, the byte at $0801 is recovered automatically after loading by the relink function. This reduces your program file size by 1 byte<br />
* accept the loss and use the 2 byte establishing LINENR for something good, they are copied to zeropage addresses $39/$3a automatically, saving you the effort of initializing the addresses<br />
* use an autostart method (see below)<br />
<br />
Some compos also specify that the BASIC loader does not count towards the overall filesize, check the rules before you worry.<br />
<br />
=== Autostart ===<br />
<br />
Unlike the Commodore 128, the Commodore 64 has no dedicated built-in auto-boot feature, but it is possible to autorun a program after loading by specifying the load address so that it overwrites a vector or address that is called by the operating system. There are multiple possibilities:<br />
<br />
==== Overwriting CHROUT vector at $326-$327 ====<br />
<br />
The vector at address $326-$327 points at the CHROUT routine, normally at address $F1CA.<br />
If you put the entry address of your program into $326/27, your code will be called when the operating system wants to print "READY." after loading.<br />
Note that the vector at address $328-$329 points at the STOP routine that checks the status of Stop key indicator. Since this routine is called multiple times before your code is done loading, its default value $F6ED needs to be preserved. <br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$0326<br />
.word start <br />
.byte $ed,$f6<br />
start<br />
; rest of code<br />
</syntaxhighlight><br />
<br />
Together with the two byte load address, the overwritten CHROUT vector and the preserved STOP vector, your program file will have a deadweight of 6 byte: $26 $03 $0a $03 $ed $f6, less than half of the standard version with a BASIC stub with SYS<br />
<br />
Caveat:<br />
* If your program after $32a is longer than 214 byte, part of your program will load into the screen at $400. Thus, issuing a clear screen will overwrite your program. It is possible to move the screen memory somewhere else, but that requires storing a new value into address $D018, which when done with an LDA # / STA pair will cost you 5 byte<br />
* Since you changed the CHROUT pointer, standard KERNAL functions for printing won't work. For output of single characters, you can still use the direct address $F1CA. Alternatively, you can restore the vectors by calling $FD15, which will overwrite the memory $314 to $333 with the default values.<br />
<br />
==== Overwriting BASIC idle loop vector at $302-$303 ====<br />
<br />
After loading the program, the BASIC idle loop will be called. By overwriting the vector at $302/$303 it is possible to autostart your program. Since the memory before $302 can be safely overwritten, the program would be arranged so that $303 is the '''last''' address of your program. If your program requires a loop back to the start, the vector can be used as part of a JMP where the following two bytes are already there, saving one byte in comparison to a loop done with a branch command.<br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$304 - (end - start)<br />
start:<br />
;your code here<br />
; ...<br />
jmp start ;the address for start lies in $302/$303, thus will be called by the Kernal after loading<br />
end:<br />
</syntaxhighlight><br />
<br />
In cases where the vector has a practical use, the overhead in filesize is only the 2 byte loading address. For programs larger than 93 byte keep in mind that addresses before $2A7 are in use by the Kernal.<br />
<br />
==== Overwriting return address on stack at $1F8 ====<br />
<br />
When the load routine is called, the stack pointer is always at $FA at a stock C64. Thus the return address from the loading process is stored in memory address $F8 (low byte) and $F9 (high byte). During the loading routine, stack usage will clobber the stack below $1F8, but a program loaded to $1F8 and above will be fine and the overwritten address stored at $1F8/$1F9 will be called after loading.<br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$1F8<br />
.word start-1 ;adjust for the RTS command pulling the address from stack and increasing it by 1<br />
start:<br />
;your code here<br />
</syntaxhighlight><br />
<br />
For programs larger than 95 byte keep in mind that addresses after $259 are in use by the Kernal, you might overwrite some values here if you don't have disk operations, but better check the memory map beforehand.<br />
<br />
Together with the two byte load address and the overwritten address at $1F8/$1F9, your program file will have a deadweight of 4 byte when using this method.<br />
<br />
=== Video display ===<br />
Video display on the Commodore has the following video modes:<br />
* Standard text mode, 40x25 characters, 1 individual color per character, 1 common background color<br />
* Multicolor text mode, 40x25 characters, every two bits (fat pixel) define color: background, char, common color 1+2<br />
* Extended color text mode, 40x25 characters, 1 individual foreground color per character, 1 out of 4 background colors, only 64 chars<br />
* Hires bitmap, 320x200 pixels, an 8x8 field can have an individual foreground and an individual background color<br />
* Multicolor bitmap, 160x200 pixels, every two bits (fat pixel) define color: background, screen color lower nibble, screen color higher nibble, color from color RAM<br />
<br />
==== Sync with frame ====<br />
<br />
Depending on the VIC type, there are 262/263 raster lines (NTSC) or 312 raster lines (PAL-B). Therefore, the VIC uses register at $D011 and the highest bit of register $D012 to represent the current raster line. Checking only the lower 8 bits and waiting for them to be 0 would therefore not work because this happens two times per frame. However, any number greater than 64 will only trigger once. Using a value of 255, we would sync to a rasterline at the end of the screen, well below the part where graphics are normally displayed:<br />
<br />
<syntaxhighlight lang="6502"><br />
lda #$FF<br />
waitsync:<br />
cmp $D012<br />
bne waitsync<br />
</syntaxhighlight><br />
<br />
As long as there have more than 63 cycles passed since the snyc, the next sync will happen at the next frame.<br />
This works fine as long as we don't miss the line 255 due to an interrupt. If your program has interrupts that are not synced to a rasterline, you can change the condition as follows<br />
<syntaxhighlight lang="6502"><br />
lda #$E3<br />
waitsync:<br />
cmp $D012<br />
bcs waitsync<br />
</syntaxhighlight><br />
<br />
Now we have a window between raster line $E4 and $FF to trigger our sync, which we will meet even if a standard Kernal interrupt comes in-between. Of course, our main program now has to burn around 1700 cycles to avoid a retriggering in the same frame.<br />
<br />
==== Getting something on screen ====<br />
<br />
Output a character:<br />
<syntaxhighlight lang="6502"><br />
lda #C ;C must be the char code according to the PETSCII code table<br />
jsr $FFD2 ;you can also use the direct address $FC1A, function preserves A,X,Y and enables interrupt<br />
</syntaxhighlight><br />
<br />
Since the [https://en.wikipedia.org/wiki/PETSCII#Character_set PETSCII code table] contains also control characters, this method can be also used to clear the screen, move the cursor or set the text color. However, some functions are shorter (and faster) by directly calling the respective KERNAL function:<br />
<br />
<syntaxhighlight lang="6502"><br />
Clear screen JSR $E544<br />
Cursor home position JSR $E566<br />
Output newline character JSR $AAD7<br />
Set text color LDA #COLOR, STA $286<br />
Set border color LDA #COLOR, STA $D020 ;not possible with a PETSCII control code<br />
Set background color LDA #COLOR, STA $D021 ;not possible with a PETSCII control code<br />
</syntaxhighlight><br />
<br />
Copy characters directly to screen memory:<br />
<br />
<syntaxhighlight lang="6502"><br />
.macpack cbm ;scrcode macro<br />
SCREEN_BASE=$400<br />
LINE=5 ;for example<br />
COLUMN=10 ;for example<br />
<br />
ldx #endtext-text-1<br />
@loop: lda text,x<br />
sta SCREEN_BASE+LINE*40+COLUMN,x<br />
dex<br />
bpl @loop<br />
text: scrcode "hello world!"<br />
endtext:<br />
</syntaxhighlight><br />
<br />
Note that the text needs to be stored in '''screen code''' format, not in PETSCII (see [https://sta.c64.org/cbm64pettoscr.html Commodore 64 PETSCII code to screen code conversion] for the differences). Furthermore, the example above only writes to the screen memory, not the color RAM, assuming that the color RAM already contains the intended text color. This is the case after issuing a clear screen on most C64 machines, except for some old ROM revisions. To be on the save side you would have to write to color RAM as well, which costs another 5 byte:<br />
<br />
<syntaxhighlight lang="6502"><br />
.macpack cbm ;scrcode macro<br />
SCREEN_BASE=$400<br />
COLOR_RAM =$D800<br />
LINE =5 ;for example<br />
COLUMN =10 ;for example<br />
COLOR =1 ;white<br />
<br />
ldx #endtext-text-1<br />
@loop: lda text,x<br />
sta SCREEN_BASE+LINE*40+COLUMN,x<br />
lda #COLOR<br />
sta COLOR_RAM +LINE*40+COLUMN,x<br />
dex<br />
bpl @loop<br />
text: scrcode "hello world!"<br />
endtext:<br />
</syntaxhighlight><br />
<br />
=== Sound ===<br />
The Commodore 64 uses the famous SID chip to generate sound.<br />
To be added soon.<br />
<br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Useful Kernal functions ===<br />
<br />
==== Get a pseudo random number ====<br />
<br />
<syntaxhighlight lang="6502"><br />
lda #1 <br />
jsr $E09A<br />
lda $63<br />
</syntaxhighlight><br />
<br />
The sequence of random numbers is always the same after a cold start or reset, the first 20 numbers are:<br />
<syntaxhighlight lang="6502"><br />
4,24,231,4,177,170,193,101,231,18,196,1,75,48,149,36,124,53,65,154<br />
</syntaxhighlight><br />
<br />
==== Increment a zero page counter, return in X register, clear Y register ====<br />
<br />
This is part of the string handling function in the BASIC ROM, but the code could be useful for some loop stuff.<br />
<br />
<syntaxhighlight lang="6502"><br />
jsr $B5FF ;does inc $23, ldx $23, ldy #$00, rts<br />
</syntaxhighlight><br />
<br />
=== Additional Resources ===<br />
* Codebase 64 https://codebase64.org/doku.php?id=base:start<br />
* Commodore 64 Memory map https://sta.c64.org/cbm64mem.html<br />
* C64 BASIC & KERNAL ROM Disassembly https://www.pagetable.com/c64ref/c64disasm/<br />
<br />
== Apple II ==<br />
The Apple II is an 8-bit home computer and one of the world's first highly successful mass-produced microcomputer products. It was designed primarily by Steve Wozniak.<br />
<br />
=== Setting up ===<br />
* ACME 6502 cross-assembler(https://sourceforge.net/projects/acme-crossass/)<br />
* Apple Commander (http://applecommander.sourceforge.net) for batch compilation<br />
* AppleWin emulator (https://github.com/AppleWin/AppleWin/releases). Supports Mockingboard card(AY-8910+speech synthesier), HDD, Z80 card(for CP/M), mouse etc.<br />
* CiderPress(https://a2ciderpress.com)<br />
<br />
Compilation can be done as follows (master.dsk can be found with applewin) <br />
<syntaxhighlight><br />
acme hl.asm<br />
java -jar AppleCommander-1.3.5.jar -d master.dsk hl<br />
java -jar AppleCommander-1.3.5.jar -p master.dsk hl B 24576 < hl.bin<br />
</syntaxhighlight><br />
<br />
=== Memory Map ===<br />
<syntaxhighlight lang="6502"><br />
0-255 $0-$FF ZERO-PAGE SYSTEM STORAGE<br />
256-511 $100-$1FF SYSTEM STACK<br />
512-767 $200-$2FF KEYBOARD CHARACTER BUFFER<br />
768-975 $300-$3CF OFTEN AVAILABLE AS FREE SPACE FOR USER PROGRAMS<br />
976-1023 $3D0-3FF SYSTEM VECTORS<br />
1024-2047 $400-$7FF TEXT AND LO-RES GRAPHICS PAGE 1 <--- !!!<br />
2048-LOMEM $800-LOMEM PROGRAM STORAGE<br />
2048-3071 $800-$BFF TEXT AND LO-RES GRAPHICS PAGE 2 OR FREE SPACE<br />
3072-8191 $C00-$1FFF FREE SPACE UNLESS RAM APPLESOFT IS IN USE<br />
8192-16383 $2000-$3FFF HI-RES PAGE 1 OR FREE SPACE <--- !!!<br />
16384-24575 $4000-$5FFF HI-RES PAGE 2 OR FREE SPACE<br />
24576-38999 $6000-$95FF FREE SPACE AND STRING STORAGE<br />
38400-49151 $9600-$BFFF DOS<br />
49152-53247 $C000-$CFFF I/O HARDWARE (RESERVED)<br />
53248-57343 $D000-$DFFF APPLESOFT IN LANGUAGE CARD OR ROM<br />
57344-63487 $E000-$F7FF APPLESOFT OR INTEGER BASIC IN LANGUAGE CARD OR ROM<br />
63488-65535 $F800-$FFFF SYSTEM MONITOR<br />
</syntaxhighlight><br />
<br />
=== Display ===<br />
<br />
=== Graphics Modes ===<br />
: Text Mode 40x24, for Apple IIe available 80x25 - use PR#3 for switch mode, or hardware switch<br />
: LowRes 40x48, 16 colors: https://en.wikipedia.org/wiki/Apple_II_graphics <br />
: Hires mode 280x192,6 colors: https://www.xtof.info/blog/?p=768<br />
https://mrob.com/pub/xapple2/colors.html<br />
https://archive.org/details/HiRes_Color_Graphics_on_the_Apple_II_Computer_by_Wozniak<br />
<br />
However for sizecoding, you almost never want to do direct-access to graphics for Apple II in size-coding because the Apple II graphics modes are horrible. The only fast way to do things is with large lookup tables. To do hires you need to divide by 7 which as you can imagine is a bit difficult to do compactly on 6502. Double-hires is even crazier on top of that. Deater did manage a color-bar style effect in double-hires in 128B but that was doing some crazy tricks with the firmware BASIC routines, definitely not direct-access.<br />
<br />
Lores and Hires can be mixed modes and full-graphics<br />
The screen structure is called memory holes(https://retrocomputing.stackexchange.com/questions/2534/what-are-the-screen-holes-in-apple-ii-graphics). The GBASCALC($F847) procedure is used to calculate the address of the horizontal line : IN:reg.A=Y, out : GBASL/GBASH($26/$27)=address. See also https://www.callapple.org/uncategorized/use-of-apple-ii-color-graphics-in-assembly-language/<br />
<br />
==== Getting something on screen ====<br />
Here is an example of a XOR texture, created by g0blinish<br />
<syntaxhighlight lang="6502"><br />
*=$6000<br />
!to "HL.bin", plain ; set output file and format<br />
!cpu 6502 ; set processor type<br />
<br />
GBASL = $26<br />
GBASH = $27<br />
SETGR = $FB40 ; setup LoRes<br />
GBASCALC = $F847 ; calc Address<br />
<br />
CLRTEXT = $C050 ;display graphics <br />
SETTEXT = $C051 ;display text <br />
<br />
CLRMIXED = $C052 ;clear mixed mode- enable full graphics <br />
SETMIXED = $C053 ;enable graphics/text mixed mode <br />
<br />
PAGE1 = $C054 ;select text/graphics page1 <br />
PAGE2 = $C055 ;select text/graphics page2 <br />
<br />
CLRHIRES = $C056 ;select Lo-res <br />
SETHIRES = $C057 ;select Hi-res <br />
<br />
TMP= $FA<br />
<br />
JSR SETGR ;GR<br />
BIT CLRMIXED ; full screen<br />
<br />
LDA #0 ; A=0<br />
STA TMP ; POKE $FA,A<br />
<br />
YLP ;<br />
LDA TMP ; A=PEEK($FA)<br />
; LSR ; A=A/2<br />
JSR GBASCALC<br />
LDY #0;Y=0<br />
<br />
XLP TYA ; A=Y<br />
EOR TMP ; A=A xor PEEK($FA)<br />
and #$0F ; A=A and 15<br />
TAX ; X=A<br />
LDA COLORS,X ;A=PEEK(COLORS+X)<br />
STA(GBASL),Y ; POKE PEEK($26)+256*PEEK($27)+Y,A<br />
INY ; Y=Y+1<br />
CPY #40 ; Y=40?<br />
BNE XLP<br />
INC TMP ; POKE $FA,PEEK($FA)+1<br />
LDA TMP ; A=PEEK($FA)<br />
CMP #24 ; A=24?<br />
BNE YLP<br />
<br />
M1 JMP M1 ; replace to RTS<br />
<br />
COLORS ;N*17, pixel format is AAAABBBB, AAAA - upper dot, BBBB - lower dot<br />
!byte $00,$11,$22,$33,$44,$55,$66,$77<br />
!byte $88,$99,$AA,$BB,$CC,$DD,$EE,$FF<br />
</syntaxhighlight><br />
<br />
==== Sound ====<br />
Here is an example for using the speaker, based onthe following basic program:<br />
<br />
<syntaxhighlight lang="basic"><br />
; 50 POKE 768,V: POKE 769,P - 255 * INT (P / 256): POKE 800,1 + P / 256<br />
; 60 CALL 770: RETURN <br />
; 95 FOR K = 1 TO N: READ V(K),P(K): NEXT K<br />
; 100 FOR K = 1 TO N:V = V(K):P = P(K)<br />
; 110 GOSUB 50<br />
;!byte 173,48,192,136,208,5,206,1,3,240,9,202,208,245,174,0,3,76,2,3,206,32,3,208,240,96<br />
</syntaxhighlight><br />
<br />
<syntaxhighlight lang="6502"><br />
*=$6000<br />
!to "HL.bin", plain ; set output file and format<br />
!cpu 6502 ; set processor type<br />
<br />
;start<br />
; 95 FOR K = 1 TO N: READ V(K),P(K): NEXT K<br />
; 100 FOR K = 1 TO N:V = V(K):P = P(K)<br />
ini:<br />
lda #70<br />
sta cnt+1<br />
lda #music&255<br />
sta gotbyte+1<br />
lda #music/256<br />
sta gotbyte+2<br />
<br />
lop:<br />
;V<br />
jsr gotbyte<br />
sta L300<br />
jsr gotbyte<br />
;P<br />
jsr gotbyte<br />
sta L301<br />
jsr gotbyte<br />
clc<br />
adc #1<br />
sta L320<br />
jsr beep<br />
<br />
dec cnt+1<br />
cnt lda #70<br />
bne lop<br />
; 110 GOSUB 50<br />
; 50 POKE 768,V: POKE 769,P - 255 * INT (P / 256): POKE 800,1 + P / 256<br />
; 60 CALL 770: RETURN <br />
jmp ini<br />
gotbyte<br />
lda music<br />
inc gotbyte+1<br />
bne noinch<br />
inc gotbyte+2<br />
noinch<br />
rts<br />
;!byte 173,48,192,136,208,5,206,1,3,240,9,202,208,245,174,0,3,76,2,3,206,32,3,208,240,96<br />
beep:<br />
ldy #1<br />
ldx #1<br />
loc_302:<br />
LDA $C030<br />
<br />
loc_305:<br />
DEY<br />
BNE loc_30D<br />
DEC L301<br />
loc_30B:<br />
BEQ loc_316<br />
<br />
loc_30D:<br />
DEX<br />
BNE loc_305<br />
LDX L300<br />
JMP loc_302<br />
loc_316:<br />
DEC L320<br />
BNE loc_30B<br />
RTS<br />
L301 !byte 0<br />
L300 !byte 0<br />
L320 !byte 0<br />
music<br />
!word 76,192,85,64,96,64,102,64,114,128,114,64,96,64,102,64,114,64,128,64<br />
!word 114,64,152,64,171,64,152,512,76,192,85,64,96,64,102,64,114,128,114,64<br />
!word 96,64,102,64,114,64,128,64,114,64,152,64,171,64,152,512,85,64,85,64<br />
!word 85,64,96,64,144,128,144,64,128,64,76,128,85,64,96,64,144,128,114,64<br />
!word 96,64,102,128,114,64,128,64,128,128,114,64,128,64,114,512,85,64,85,64<br />
!word 85,64,96,64,144,128,144,64,128,64,76,128,85,64,96,64,144,128,114,64<br />
!word 96,64,102,128,114,64,128,64,128,64,128,128,96,64,85,64,96,64,102,64,114,64,114,64<br />
</syntaxhighlight><br />
<br />
=== Additional Resources ===<br />
* Deater's page on Apple II sizecoding http://www.deater.net/weave/vmwprod/demos/sizecoding.html<br />
* Article on double hi-res http://www.battlestations.zone/2017/04/apple-ii-double-hi-res-from-ground-up.html<br />
* Applesoft Hi-Res Subroutines : http://hackzapple.org/scripts_php/index.php?menu=5&mod=ASM&sub=AAL&sub2=8112&PHPSESSID=f65fabfd0cdbf56b6bdc0ddac25117c6#a2<br />
<br />
== Atari Lynx ==<br />
The Atari Lynx consists of the 6502 with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Atari Lynx:<br />
<br />
* Assembler: -<br />
* Emulator(s): -<br />
<br />
=== Video display ===<br />
To be added soon.<br />
<br />
==== Getting something on screen ====<br />
To be added soon.<br />
<br />
<br />
=== Sound ===<br />
To be added soon.<br />
<br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Additional Resources ===<br />
Sizecoding resource for the Atari Lynx are sparse<br />
* 42Bastian's website (link to be added)</div>Wilhttp://www.sizecoding.org/index.php?title=6502&diff=82965022021-02-15T23:26:44Z<p>Wil: /* Video display */ Sync with frame</p>
<hr />
<div>== Introduction ==<br />
Wanting to start sizecoding on a 6502 platform in this day and age can be tough. <br />
<br />
[[File:6502.jpg|thumb]]<br />
<br />
So here is a bit of help to get you started:<br />
<br />
=== The 6502 processor ===<br />
The 6502 processor can be seen as the 8-bit micro ARM chip. <br />
It has only has 3 registers (Accumulator, X and Y registers) and a handful of instructions to work with.<br />
<br />
=== Adressing modes ===<br />
To be added.<br />
<br />
=== Zero page ===<br />
When using the 6502 for sizecoding, you'll mostly be working from zeropage<br />
<br />
=== General 6502 Resources ===<br />
* 6502.org http://www.6502.org/<br />
* 6502 instruction reference http://www.6502.org/tutorials/6502opcodes.html<br />
* 6502 books http://retro.hansotten.nl/6502-sbc/<br />
* 6502 Assembler tutorial https://dwheeler.com/6502/oneelkruns/asm1step.html<br />
* Easy 6502 code tester https://skilldrick.github.io/easy6502/<br />
* Synthetic instructions https://wiki.nesdev.com/w/index.php/Synthetic_instructions#8-bit_rotate<br />
<br />
== Atari 8-bit family ==<br />
The systems in this family are: Atari 400, 800, 5200, 1200XL, 600XL, 800XL, 130XE, 65XE, 800XE and XEGS.<br /><br />
<br />
The Atari 8-bit systems consists of the 6502 with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Atari 8bit systems is quite easy, first get the following tools:<br />
<br />
* Assembler: MADS Assembler - This assembler has nice macros for creating Binaries and SNA snapshot files out of the box. You can download it at https://mads.atari8.info/<br />
* Emulator(s): I Found Altirra to work best for my usecase. Make sure to use the original Rev2 rom for best compatibility.<br />
<br />
==== Special Memory Adresses ====<br />
* FRAMECOUNTER_HIGH = 19<br />
* FRAMECOUNTER_LOW = 20<br />
<br />
=== Video display ===<br />
Video display on the Atari 8bit systems use the ANTIC and GTIA chips. Information can be found here:<br />
* https://en.wikipedia.org/wiki/ANTIC<br />
* https://www.atariarchives.org/agagd/chapter1.php<br />
<br />
==== Sync with frame ====<br />
<syntaxhighlight lang="6502"><br />
RTCLOK equ $0012<br />
lda RTCLOK+2<br />
waits<br />
cmp RTCLOK+2<br />
beq waits<br />
</syntaxhighlight><br />
<br />
Or if you don't mind trashing RTCLOK<br />
<br />
<syntaxhighlight lang="6502"><br />
RTCLOK equ $0012<br />
waits<br />
lsr RTCLOK+2<br />
bcc waits<br />
</syntaxhighlight><br />
<br />
Which is two bytes shorter.<br />
<br />
==== Getting something on screen ====<br />
<syntaxhighlight lang="6502"><br />
;fill screen with charset,(88,89)=an address<br />
org $600; free 6th page:600-6ff<br />
ldy #0<br />
fl: tya<br />
sta(88),y<br />
iny<br />
bne fl<br />
jmp *<br />
</syntaxhighlight><br />
<br />
To be added soon.<br />
<br />
<syntaxhighlight lang="6502"><br />
SDMCTL = $022f<br />
HPOSP0 = $d000<br />
SIZEP0 = $d008<br />
GRAFP0 = $d00d<br />
COLPM0 = $d012<br />
<br />
FRAMECOUNTER_HIGH = 19<br />
FRAMECOUNTER = 20<br />
WSYNC = $d40a<br />
VCOUNT = $d40b<br />
<br />
sinewave = $0600 ; to $06ff<br />
<br />
org $80<br />
<br />
main <br />
; disable all graphics/colors<br />
ldx #0<br />
stx SDMCTL <br />
<br />
ldy #$7f<br />
sty SIZEP0 ; size p0=127<br />
<br />
ldx #0<br />
ldy #$3f<br />
make_sine:<br />
value_lo<br />
lda #0<br />
clc<br />
delta_lo<br />
adc #0<br />
sta value_lo+1<br />
value_hi<br />
lda #0<br />
delta_hi<br />
adc #0<br />
sta value_hi+1<br />
<br />
sta sinewave+$c0,x<br />
sta sinewave+$80,y<br />
eor #$7f<br />
sta sinewave+$40,x<br />
sta sinewave+$00,y<br />
<br />
lda delta_lo+1<br />
adc #8<br />
sta delta_lo+1<br />
bcc nothing<br />
inc delta_hi+1<br />
nothing<br />
inx<br />
dey<br />
bpl make_sine<br />
<br />
updateloop:<br />
; vblank<br />
lda VCOUNT<br />
bne updateloop<br />
<br />
; clear graphics<br />
sta HPOSP0<br />
sta GRAFP0<br />
<br />
ldy #0<br />
lda #47<br />
sta COLPM0<br />
yloop:<br />
tya ; graphics shape = y<br />
sta WSYNC<br />
sta GRAFP0<br />
<br />
; a = sin(frame+y)+48<br />
tya <br />
adc FRAMECOUNTER<br />
tax<br />
lda sinewave,x<br />
adc #48<br />
sta HPOSP0<br />
<br />
iny<br />
bne yloop<br />
jmp updateloop<br />
<br />
run main<br />
</syntaxhighlight><br />
<br />
=== Sound ===<br />
The Atari 8-bit use the POKEY chip to generate sound.<br />
* https://en.wikipedia.org/wiki/POKEY<br />
<br />
==== BASIC ====<br />
<syntaxhighlight lang="6502"><br />
; from Analog, 1985-09,pp.25-32<br />
*=$2000<br />
AUDF1=$D200<br />
AUDC1=$D201<br />
AUDCTL=$D208<br />
SKCTL=$D20F<br />
<br />
.MACRO SOUND ; voice,pitch,dist,vol;,dur<br />
lda #%2<br />
sta AUDF1+2*%1<br />
lda #[[%3 * 16] | %4] ;lda #[[%3 shl 4] or %4]<br />
sta AUDC1+2*%1<br />
.ENDM<br />
<br />
lda #0<br />
sta AUDCTL<br />
lda #3<br />
sta SKCTL<br />
<br />
SOUND 0,121,10,8<br />
<br />
jmp *<br />
</syntaxhighlight><br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Additional Resources ===<br />
Sizecoding resource for the Atari 8bit are:<br />
* Mapping the Atari https://www.atariarchives.org/mapping/<br />
* Atari 8bit Memory map https://www.atariarchives.org/mapping/memorymap.php<br />
* Fready's undocumented 6502 opcodes https://github.com/FreddyOffenga/6502<br />
* Atari OS Rev2 disassembly for MADS assembler https://github.com/ilmenit/A800-OS-XL-Rev2<br />
* Fready's github https://github.com/FreddyOffenga/<br />
<br />
== Commodore 64 ==<br />
The Commodore system consists of a 6502-compatible MOS 6510 processor with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Commodore systems is quite easy, first get the following tools:<br />
<br />
* Assembler: To be added<br />
* Emulator(s): VICE is the way to go<br />
<br />
=== Memory map ===<br />
<br />
<syntaxhighlight lang="6502"><br />
0-1 $0-$1 PROCESSOR PORT REGISTERS, not usable as RAM<br />
0-255 $0-$FF ZEROPAGE, mostly used by BASIC interpreter and Kernal<br />
256-511 $100-$1FF SYSTEM STACK<br />
512-600 $200-$258 INPUT BUFFER<br />
601-630 $259-$276 FILE SYSTEM DATA<br />
631-640 $277-$280 KEYBOARD BUFFER, filled by Kernal ISR upon key presses <br />
641-678 $281-$2A6 VARIOUS KERNAL VARIABLES<br />
679-767 $2A7-$2FF Unused (89 byte)<br />
768-779 $300-$30B KERNAL VECTORS<br />
780-783 $30C-$30F REGISTER VALUES A,X,Y,SR for SYS<br />
784-819 $310-$333 KERNAL VECTORS<br />
820-827 $334-$33B Unused (8 byte)<br />
828-1019 $33C-$3FB DATASETTE BUFFER<br />
1020-1023 $3FC-$3FF Unused (4 byte)<br />
1024-2023 $400-$7E7 SCREEN MEMORY (25 lines times 40 columns)<br />
2024-2039 $7E8-$7F7 Unused (16 byte)<br />
2040-2047 $7F8-$7FF SPRITE COSTUME POINTERS<br />
2048 $800 must contain a value of 0 so that the BASIC program can be RUN<br />
2049-40959 $801-$9FFF BASIC AREA (code, variables, arrays, strings)<br />
40960-49151 $A000-$BFFF BASIC ROM (unused RAM underneath)<br />
49152-53247 $C000-$CFFF UPPER RAM AREA (unused)<br />
53248-53294 $D000-$D02E VIC-II, memory-mapped graphics chip registers)<br />
54272-54300 $D400-$D41C SID, memory-mapped sound chip registers)<br />
55296-56295 $D800-$DBE7 Color RAM, only lower 4 bits are stored, higher nibble undefined<br />
56296-56319 $DBE8-$DBFF Unused (24 half-bytes)<br />
56320-56335 $DC00-$DC0F CIA#1, memory-mapped I/O chip registers for keyboard, joystick, mouse, datasette, IRQ control<br />
56576-56591 $DD00-$DD0F CIA#1, memory-mapped I/O chip registers for serial bus, RS232, NMI control<br />
57344-65535 $E000-$FFFF KERNAL ROM<br />
65534-65535 $FFFE-$FFFF Execution address of interrupt service routine, can only be set if KERNAL is turned off<br />
</syntaxhighlight><br />
<br />
For a detailed explanation of the C64 memory map check out [https://sta.c64.org/cbm64mem.html Commodore 64 memory map] on Joe Forster/STA homepage.<br />
<br />
=== Program file overhead ===<br />
<br />
A standard CBM file consists of a 2 byte loading address followed by the data that is placed into memory starting at this address. In addition, if your machine program should be able to be started with "RUN", you need a BASIC stub that is loaded into memory from $0801 to $080c, typically followed by your machine program:<br />
<br />
<syntaxhighlight lang="6502"><br />
*=$0801<br />
.word $080b ;address of next BASIC line<br />
.word LINENR ;line number, can be chosen between 0 and 63999<br />
.byte $9e ;token for SYS command<br />
.byte $32,$30,$36,$31 ;address to jump to in ASCII code: "2061" <br />
.byte $00 ;end of BASIC line<br />
.word $0000 ;address of next BASIC line, $0000 means end of BASIC program <br />
start<br />
; your code here<br />
</syntaxhighlight><br />
<br />
Together with the 2 byte load address, this makes an overhead of 14 byte for your program. To reduce this, you can<br />
* omit the BASIC line and tell users to start your program by directly entering "SYS ''address''"<br />
* save your program from $0802 on, the byte at $0801 is recovered automatically after loading by the relink function. This reduces your program file size by 1 byte<br />
* accept the loss and use the 2 byte establishing LINENR for something good, they are copied to zeropage addresses $39/$3a automatically, saving you the effort of initializing the addresses<br />
* use an autostart method (see below)<br />
<br />
Some compos also specify that the BASIC loader does not count towards the overall filesize, check the rules before you worry.<br />
<br />
=== Autostart ===<br />
<br />
Unlike the Commodore 128, the Commodore 64 has no dedicated built-in auto-boot feature, but it is possible to autorun a program after loading by specifying the load address so that it overwrites a vector or address that is called by the operating system. There are multiple possibilities:<br />
<br />
==== Overwriting CHROUT vector at $326-$327 ====<br />
<br />
The vector at address $326-$327 points at the CHROUT routine, normally at address $F1CA.<br />
If you put the entry address of your program into $326/27, your code will be called when the operating system wants to print "READY." after loading.<br />
Note that the vector at address $328-$329 points at the STOP routine that checks the status of Stop key indicator. Since this routine is called multiple times before your code is done loading, its default value $F6ED needs to be preserved. <br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$0326<br />
.word start <br />
.byte $ed,$f6<br />
start<br />
; rest of code<br />
</syntaxhighlight><br />
<br />
Together with the two byte load address, the overwritten CHROUT vector and the preserved STOP vector, your program file will have a deadweight of 6 byte: $26 $03 $0a $03 $ed $f6, less than half of the standard version with a BASIC stub with SYS<br />
<br />
Caveat:<br />
* If your program after $32a is longer than 214 byte, part of your program will load into the screen at $400. Thus, issuing a clear screen will overwrite your program. It is possible to move the screen memory somewhere else, but that requires storing a new value into address $D018, which when done with an LDA # / STA pair will cost you 5 byte<br />
* Since you changed the CHROUT pointer, standard KERNAL functions for printing won't work. For output of single characters, you can still use the direct address $F1CA. Alternatively, you can restore the vectors by calling $FD15, which will overwrite the memory $314 to $333 with the default values.<br />
<br />
==== Overwriting BASIC idle loop vector at $302-$303 ====<br />
<br />
After loading the program, the BASIC idle loop will be called. By overwriting the vector at $302/$303 it is possible to autostart your program. Since the memory before $302 can be safely overwritten, the program would be arranged so that $303 is the '''last''' address of your program. If your program requires a loop back to the start, the vector can be used as part of a JMP where the following two bytes are already there, saving one byte in comparison to a loop done with a branch command.<br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$304 - (end - start)<br />
start:<br />
;your code here<br />
; ...<br />
jmp start ;the address for start lies in $302/$303, thus will be called by the Kernal after loading<br />
end:<br />
</syntaxhighlight><br />
<br />
In cases where the vector has a practical use, the overhead in filesize is only the 2 byte loading address. For programs larger than 93 byte keep in mind that addresses before $2A7 are in use by the Kernal.<br />
<br />
==== Overwriting return address on stack at $1F8 ====<br />
<br />
When the load routine is called, the stack pointer is always at $FA at a stock C64. Thus the return address from the loading process is stored in memory address $F8 (low byte) and $F9 (high byte). During the loading routine, stack usage will clobber the stack below $1F8, but a program loaded to $1F8 and above will be fine and the overwritten address stored at $1F8/$1F9 will be called after loading.<br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$1F8<br />
.word start-1 ;adjust for the RTS command pulling the address from stack and increasing it by 1<br />
start:<br />
;your code here<br />
</syntaxhighlight><br />
<br />
For programs larger than 95 byte keep in mind that addresses after $259 are in use by the Kernal, you might overwrite some values here if you don't have disk operations, but better check the memory map beforehand.<br />
<br />
Together with the two byte load address and the overwritten address at $1F8/$1F9, your program file will have a deadweight of 4 byte when using this method.<br />
<br />
=== Video display ===<br />
Video display on the Commodore has the following video modes:<br />
* Standard text mode, 40x25 characters, 1 individual color per character, 1 common background color<br />
* Multicolor text mode, 40x25 characters, every two bits (fat pixel) define color: background, char, common color 1+2<br />
* Extended color text mode, 40x25 characters, 1 individual foreground color per character, 1 out of 4 background colors, only 64 chars<br />
* Hires bitmap, 320x200 pixels, an 8x8 field can have an individual foreground and an individual background color<br />
* Multicolor bitmap, 160x200 pixels, every two bits (fat pixel) define color: background, screen color lower nibble, screen color higher nibble, color from color RAM<br />
<br />
==== Sync with frame ====<br />
<br />
Depending on the VIC type, there are 262/263 raster lines (NTSC) or 312 raster lines (PAL-B). Therefore, the VIC uses register at $D011 and the highest bit of register $D012 to represent the current raster line. Checking only the lower 8 bits and waiting for them to be 0 would therefore not work because this happens two times per frame. However, any number greater than 64 will only trigger once. Using a value of 255, we would sync to a rasterline at the end of the screen, well below the part where graphics are normally displayed:<br />
<br />
<syntaxhighlight lang="6502"><br />
lda #$FF<br />
waitsync:<br />
cmp $D012<br />
bne waitsync<br />
</syntaxhighlight><br />
<br />
As long as there have more than 63 cycles passed since the snyc, the next sync will happen at the next frame.<br />
<br />
==== Getting something on screen ====<br />
<br />
Output a character:<br />
<syntaxhighlight lang="6502"><br />
lda #C ;C must be the char code according to the PETSCII code table<br />
jsr $FFD2 ;you can also use the direct address $FC1A, function preserves A,X,Y and enables interrupt<br />
</syntaxhighlight><br />
<br />
Since the [https://en.wikipedia.org/wiki/PETSCII#Character_set PETSCII code table] contains also control characters, this method can be also used to clear the screen, move the cursor or set the text color. However, some functions are shorter (and faster) by directly calling the respective KERNAL function:<br />
<br />
<syntaxhighlight lang="6502"><br />
Clear screen JSR $E544<br />
Cursor home position JSR $E566<br />
Output newline character JSR $AAD7<br />
Set text color LDA #COLOR, STA $286<br />
Set border color LDA #COLOR, STA $D020 ;not possible with a PETSCII control code<br />
Set background color LDA #COLOR, STA $D021 ;not possible with a PETSCII control code<br />
</syntaxhighlight><br />
<br />
Copy characters directly to screen memory:<br />
<br />
<syntaxhighlight lang="6502"><br />
.macpack cbm ;scrcode macro<br />
SCREEN_BASE=$400<br />
LINE=5 ;for example<br />
COLUMN=10 ;for example<br />
<br />
ldx #endtext-text-1<br />
@loop: lda text,x<br />
sta SCREEN_BASE+LINE*40+COLUMN,x<br />
dex<br />
bpl @loop<br />
text: scrcode "hello world!"<br />
endtext:<br />
</syntaxhighlight><br />
<br />
Note that the text needs to be stored in '''screen code''' format, not in PETSCII (see [https://sta.c64.org/cbm64pettoscr.html Commodore 64 PETSCII code to screen code conversion] for the differences). Furthermore, the example above only writes to the screen memory, not the color RAM, assuming that the color RAM already contains the intended text color. This is the case after issuing a clear screen on most C64 machines, except for some old ROM revisions. To be on the save side you would have to write to color RAM as well, which costs another 5 byte:<br />
<br />
<syntaxhighlight lang="6502"><br />
.macpack cbm ;scrcode macro<br />
SCREEN_BASE=$400<br />
COLOR_RAM =$D800<br />
LINE =5 ;for example<br />
COLUMN =10 ;for example<br />
COLOR =1 ;white<br />
<br />
ldx #endtext-text-1<br />
@loop: lda text,x<br />
sta SCREEN_BASE+LINE*40+COLUMN,x<br />
lda #COLOR<br />
sta COLOR_RAM +LINE*40+COLUMN,x<br />
dex<br />
bpl @loop<br />
text: scrcode "hello world!"<br />
endtext:<br />
</syntaxhighlight><br />
<br />
=== Sound ===<br />
The Commodore 64 uses the famous SID chip to generate sound.<br />
To be added soon.<br />
<br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Useful Kernal functions ===<br />
<br />
==== Get a pseudo random number ====<br />
<br />
<syntaxhighlight lang="6502"><br />
lda #1 <br />
jsr $E09A<br />
lda $63<br />
</syntaxhighlight><br />
<br />
The sequence of random numbers is always the same after a cold start or reset, the first 20 numbers are:<br />
<syntaxhighlight lang="6502"><br />
4,24,231,4,177,170,193,101,231,18,196,1,75,48,149,36,124,53,65,154<br />
</syntaxhighlight><br />
<br />
==== Increment a zero page counter, return in X register, clear Y register ====<br />
<br />
This is part of the string handling function in the BASIC ROM, but the code could be useful for some loop stuff.<br />
<br />
<syntaxhighlight lang="6502"><br />
jsr $B5FF ;does inc $23, ldx $23, ldy #$00, rts<br />
</syntaxhighlight><br />
<br />
=== Additional Resources ===<br />
* Codebase 64 https://codebase64.org/doku.php?id=base:start<br />
* Commodore 64 Memory map https://sta.c64.org/cbm64mem.html<br />
* C64 BASIC & KERNAL ROM Disassembly https://www.pagetable.com/c64ref/c64disasm/<br />
<br />
== Apple II ==<br />
The Apple II is an 8-bit home computer and one of the world's first highly successful mass-produced microcomputer products. It was designed primarily by Steve Wozniak.<br />
<br />
=== Setting up ===<br />
* ACME 6502 cross-assembler(https://sourceforge.net/projects/acme-crossass/)<br />
* Apple Commander (http://applecommander.sourceforge.net) for batch compilation<br />
* AppleWin emulator (https://github.com/AppleWin/AppleWin/releases). Supports Mockingboard card(AY-8910+speech synthesier), HDD, Z80 card(for CP/M), mouse etc.<br />
* CiderPress(https://a2ciderpress.com)<br />
<br />
Compilation can be done as follows (master.dsk can be found with applewin) <br />
<syntaxhighlight><br />
acme hl.asm<br />
java -jar AppleCommander-1.3.5.jar -d master.dsk hl<br />
java -jar AppleCommander-1.3.5.jar -p master.dsk hl B 24576 < hl.bin<br />
</syntaxhighlight><br />
<br />
=== Memory Map ===<br />
<syntaxhighlight lang="6502"><br />
0-255 $0-$FF ZERO-PAGE SYSTEM STORAGE<br />
256-511 $100-$1FF SYSTEM STACK<br />
512-767 $200-$2FF KEYBOARD CHARACTER BUFFER<br />
768-975 $300-$3CF OFTEN AVAILABLE AS FREE SPACE FOR USER PROGRAMS<br />
976-1023 $3D0-3FF SYSTEM VECTORS<br />
1024-2047 $400-$7FF TEXT AND LO-RES GRAPHICS PAGE 1 <--- !!!<br />
2048-LOMEM $800-LOMEM PROGRAM STORAGE<br />
2048-3071 $800-$BFF TEXT AND LO-RES GRAPHICS PAGE 2 OR FREE SPACE<br />
3072-8191 $C00-$1FFF FREE SPACE UNLESS RAM APPLESOFT IS IN USE<br />
8192-16383 $2000-$3FFF HI-RES PAGE 1 OR FREE SPACE <--- !!!<br />
16384-24575 $4000-$5FFF HI-RES PAGE 2 OR FREE SPACE<br />
24576-38999 $6000-$95FF FREE SPACE AND STRING STORAGE<br />
38400-49151 $9600-$BFFF DOS<br />
49152-53247 $C000-$CFFF I/O HARDWARE (RESERVED)<br />
53248-57343 $D000-$DFFF APPLESOFT IN LANGUAGE CARD OR ROM<br />
57344-63487 $E000-$F7FF APPLESOFT OR INTEGER BASIC IN LANGUAGE CARD OR ROM<br />
63488-65535 $F800-$FFFF SYSTEM MONITOR<br />
</syntaxhighlight><br />
<br />
=== Display ===<br />
<br />
=== Graphics Modes ===<br />
: Text Mode 40x24, for Apple IIe available 80x25 - use PR#3 for switch mode, or hardware switch<br />
: LowRes 40x48, 16 colors: https://en.wikipedia.org/wiki/Apple_II_graphics <br />
: Hires mode 280x192,6 colors: https://www.xtof.info/blog/?p=768<br />
https://mrob.com/pub/xapple2/colors.html<br />
https://archive.org/details/HiRes_Color_Graphics_on_the_Apple_II_Computer_by_Wozniak<br />
<br />
However for sizecoding, you almost never want to do direct-access to graphics for Apple II in size-coding because the Apple II graphics modes are horrible. The only fast way to do things is with large lookup tables. To do hires you need to divide by 7 which as you can imagine is a bit difficult to do compactly on 6502. Double-hires is even crazier on top of that. Deater did manage a color-bar style effect in double-hires in 128B but that was doing some crazy tricks with the firmware BASIC routines, definitely not direct-access.<br />
<br />
Lores and Hires can be mixed modes and full-graphics<br />
The screen structure is called memory holes(https://retrocomputing.stackexchange.com/questions/2534/what-are-the-screen-holes-in-apple-ii-graphics). The GBASCALC($F847) procedure is used to calculate the address of the horizontal line : IN:reg.A=Y, out : GBASL/GBASH($26/$27)=address. See also https://www.callapple.org/uncategorized/use-of-apple-ii-color-graphics-in-assembly-language/<br />
<br />
==== Getting something on screen ====<br />
Here is an example of a XOR texture, created by g0blinish<br />
<syntaxhighlight lang="6502"><br />
*=$6000<br />
!to "HL.bin", plain ; set output file and format<br />
!cpu 6502 ; set processor type<br />
<br />
GBASL = $26<br />
GBASH = $27<br />
SETGR = $FB40 ; setup LoRes<br />
GBASCALC = $F847 ; calc Address<br />
<br />
CLRTEXT = $C050 ;display graphics <br />
SETTEXT = $C051 ;display text <br />
<br />
CLRMIXED = $C052 ;clear mixed mode- enable full graphics <br />
SETMIXED = $C053 ;enable graphics/text mixed mode <br />
<br />
PAGE1 = $C054 ;select text/graphics page1 <br />
PAGE2 = $C055 ;select text/graphics page2 <br />
<br />
CLRHIRES = $C056 ;select Lo-res <br />
SETHIRES = $C057 ;select Hi-res <br />
<br />
TMP= $FA<br />
<br />
JSR SETGR ;GR<br />
BIT CLRMIXED ; full screen<br />
<br />
LDA #0 ; A=0<br />
STA TMP ; POKE $FA,A<br />
<br />
YLP ;<br />
LDA TMP ; A=PEEK($FA)<br />
; LSR ; A=A/2<br />
JSR GBASCALC<br />
LDY #0;Y=0<br />
<br />
XLP TYA ; A=Y<br />
EOR TMP ; A=A xor PEEK($FA)<br />
and #$0F ; A=A and 15<br />
TAX ; X=A<br />
LDA COLORS,X ;A=PEEK(COLORS+X)<br />
STA(GBASL),Y ; POKE PEEK($26)+256*PEEK($27)+Y,A<br />
INY ; Y=Y+1<br />
CPY #40 ; Y=40?<br />
BNE XLP<br />
INC TMP ; POKE $FA,PEEK($FA)+1<br />
LDA TMP ; A=PEEK($FA)<br />
CMP #24 ; A=24?<br />
BNE YLP<br />
<br />
M1 JMP M1 ; replace to RTS<br />
<br />
COLORS ;N*17, pixel format is AAAABBBB, AAAA - upper dot, BBBB - lower dot<br />
!byte $00,$11,$22,$33,$44,$55,$66,$77<br />
!byte $88,$99,$AA,$BB,$CC,$DD,$EE,$FF<br />
</syntaxhighlight><br />
<br />
==== Sound ====<br />
Here is an example for using the speaker, based onthe following basic program:<br />
<br />
<syntaxhighlight lang="basic"><br />
; 50 POKE 768,V: POKE 769,P - 255 * INT (P / 256): POKE 800,1 + P / 256<br />
; 60 CALL 770: RETURN <br />
; 95 FOR K = 1 TO N: READ V(K),P(K): NEXT K<br />
; 100 FOR K = 1 TO N:V = V(K):P = P(K)<br />
; 110 GOSUB 50<br />
;!byte 173,48,192,136,208,5,206,1,3,240,9,202,208,245,174,0,3,76,2,3,206,32,3,208,240,96<br />
</syntaxhighlight><br />
<br />
<syntaxhighlight lang="6502"><br />
*=$6000<br />
!to "HL.bin", plain ; set output file and format<br />
!cpu 6502 ; set processor type<br />
<br />
;start<br />
; 95 FOR K = 1 TO N: READ V(K),P(K): NEXT K<br />
; 100 FOR K = 1 TO N:V = V(K):P = P(K)<br />
ini:<br />
lda #70<br />
sta cnt+1<br />
lda #music&255<br />
sta gotbyte+1<br />
lda #music/256<br />
sta gotbyte+2<br />
<br />
lop:<br />
;V<br />
jsr gotbyte<br />
sta L300<br />
jsr gotbyte<br />
;P<br />
jsr gotbyte<br />
sta L301<br />
jsr gotbyte<br />
clc<br />
adc #1<br />
sta L320<br />
jsr beep<br />
<br />
dec cnt+1<br />
cnt lda #70<br />
bne lop<br />
; 110 GOSUB 50<br />
; 50 POKE 768,V: POKE 769,P - 255 * INT (P / 256): POKE 800,1 + P / 256<br />
; 60 CALL 770: RETURN <br />
jmp ini<br />
gotbyte<br />
lda music<br />
inc gotbyte+1<br />
bne noinch<br />
inc gotbyte+2<br />
noinch<br />
rts<br />
;!byte 173,48,192,136,208,5,206,1,3,240,9,202,208,245,174,0,3,76,2,3,206,32,3,208,240,96<br />
beep:<br />
ldy #1<br />
ldx #1<br />
loc_302:<br />
LDA $C030<br />
<br />
loc_305:<br />
DEY<br />
BNE loc_30D<br />
DEC L301<br />
loc_30B:<br />
BEQ loc_316<br />
<br />
loc_30D:<br />
DEX<br />
BNE loc_305<br />
LDX L300<br />
JMP loc_302<br />
loc_316:<br />
DEC L320<br />
BNE loc_30B<br />
RTS<br />
L301 !byte 0<br />
L300 !byte 0<br />
L320 !byte 0<br />
music<br />
!word 76,192,85,64,96,64,102,64,114,128,114,64,96,64,102,64,114,64,128,64<br />
!word 114,64,152,64,171,64,152,512,76,192,85,64,96,64,102,64,114,128,114,64<br />
!word 96,64,102,64,114,64,128,64,114,64,152,64,171,64,152,512,85,64,85,64<br />
!word 85,64,96,64,144,128,144,64,128,64,76,128,85,64,96,64,144,128,114,64<br />
!word 96,64,102,128,114,64,128,64,128,128,114,64,128,64,114,512,85,64,85,64<br />
!word 85,64,96,64,144,128,144,64,128,64,76,128,85,64,96,64,144,128,114,64<br />
!word 96,64,102,128,114,64,128,64,128,64,128,128,96,64,85,64,96,64,102,64,114,64,114,64<br />
</syntaxhighlight><br />
<br />
=== Additional Resources ===<br />
* Deater's page on Apple II sizecoding http://www.deater.net/weave/vmwprod/demos/sizecoding.html<br />
* Article on double hi-res http://www.battlestations.zone/2017/04/apple-ii-double-hi-res-from-ground-up.html<br />
* Applesoft Hi-Res Subroutines : http://hackzapple.org/scripts_php/index.php?menu=5&mod=ASM&sub=AAL&sub2=8112&PHPSESSID=f65fabfd0cdbf56b6bdc0ddac25117c6#a2<br />
<br />
== Atari Lynx ==<br />
The Atari Lynx consists of the 6502 with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Atari Lynx:<br />
<br />
* Assembler: -<br />
* Emulator(s): -<br />
<br />
=== Video display ===<br />
To be added soon.<br />
<br />
==== Getting something on screen ====<br />
To be added soon.<br />
<br />
<br />
=== Sound ===<br />
To be added soon.<br />
<br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Additional Resources ===<br />
Sizecoding resource for the Atari Lynx are sparse<br />
* 42Bastian's website (link to be added)</div>Wilhttp://www.sizecoding.org/index.php?title=6502&diff=82865022021-02-15T22:59:16Z<p>Wil: /* Useful Kernal functions */ typo</p>
<hr />
<div>== Introduction ==<br />
Wanting to start sizecoding on a 6502 platform in this day and age can be tough. <br />
<br />
[[File:6502.jpg|thumb]]<br />
<br />
So here is a bit of help to get you started:<br />
<br />
=== The 6502 processor ===<br />
The 6502 processor can be seen as the 8-bit micro ARM chip. <br />
It has only has 3 registers (Accumulator, X and Y registers) and a handful of instructions to work with.<br />
<br />
=== Adressing modes ===<br />
To be added.<br />
<br />
=== Zero page ===<br />
When using the 6502 for sizecoding, you'll mostly be working from zeropage<br />
<br />
=== General 6502 Resources ===<br />
* 6502.org http://www.6502.org/<br />
* 6502 instruction reference http://www.6502.org/tutorials/6502opcodes.html<br />
* 6502 books http://retro.hansotten.nl/6502-sbc/<br />
* 6502 Assembler tutorial https://dwheeler.com/6502/oneelkruns/asm1step.html<br />
* Easy 6502 code tester https://skilldrick.github.io/easy6502/<br />
* Synthetic instructions https://wiki.nesdev.com/w/index.php/Synthetic_instructions#8-bit_rotate<br />
<br />
== Atari 8-bit family ==<br />
The systems in this family are: Atari 400, 800, 5200, 1200XL, 600XL, 800XL, 130XE, 65XE, 800XE and XEGS.<br /><br />
<br />
The Atari 8-bit systems consists of the 6502 with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Atari 8bit systems is quite easy, first get the following tools:<br />
<br />
* Assembler: MADS Assembler - This assembler has nice macros for creating Binaries and SNA snapshot files out of the box. You can download it at https://mads.atari8.info/<br />
* Emulator(s): I Found Altirra to work best for my usecase. Make sure to use the original Rev2 rom for best compatibility.<br />
<br />
==== Special Memory Adresses ====<br />
* FRAMECOUNTER_HIGH = 19<br />
* FRAMECOUNTER_LOW = 20<br />
<br />
=== Video display ===<br />
Video display on the Atari 8bit systems use the ANTIC and GTIA chips. Information can be found here:<br />
* https://en.wikipedia.org/wiki/ANTIC<br />
* https://www.atariarchives.org/agagd/chapter1.php<br />
<br />
==== Sync with frame ====<br />
<syntaxhighlight lang="6502"><br />
RTCLOK equ $0012<br />
lda RTCLOK+2<br />
waits<br />
cmp RTCLOK+2<br />
beq waits<br />
</syntaxhighlight><br />
<br />
Or if you don't mind trashing RTCLOK<br />
<br />
<syntaxhighlight lang="6502"><br />
RTCLOK equ $0012<br />
waits<br />
lsr RTCLOK+2<br />
bcc waits<br />
</syntaxhighlight><br />
<br />
Which is two bytes shorter.<br />
<br />
==== Getting something on screen ====<br />
<syntaxhighlight lang="6502"><br />
;fill screen with charset,(88,89)=an address<br />
org $600; free 6th page:600-6ff<br />
ldy #0<br />
fl: tya<br />
sta(88),y<br />
iny<br />
bne fl<br />
jmp *<br />
</syntaxhighlight><br />
<br />
To be added soon.<br />
<br />
<syntaxhighlight lang="6502"><br />
SDMCTL = $022f<br />
HPOSP0 = $d000<br />
SIZEP0 = $d008<br />
GRAFP0 = $d00d<br />
COLPM0 = $d012<br />
<br />
FRAMECOUNTER_HIGH = 19<br />
FRAMECOUNTER = 20<br />
WSYNC = $d40a<br />
VCOUNT = $d40b<br />
<br />
sinewave = $0600 ; to $06ff<br />
<br />
org $80<br />
<br />
main <br />
; disable all graphics/colors<br />
ldx #0<br />
stx SDMCTL <br />
<br />
ldy #$7f<br />
sty SIZEP0 ; size p0=127<br />
<br />
ldx #0<br />
ldy #$3f<br />
make_sine:<br />
value_lo<br />
lda #0<br />
clc<br />
delta_lo<br />
adc #0<br />
sta value_lo+1<br />
value_hi<br />
lda #0<br />
delta_hi<br />
adc #0<br />
sta value_hi+1<br />
<br />
sta sinewave+$c0,x<br />
sta sinewave+$80,y<br />
eor #$7f<br />
sta sinewave+$40,x<br />
sta sinewave+$00,y<br />
<br />
lda delta_lo+1<br />
adc #8<br />
sta delta_lo+1<br />
bcc nothing<br />
inc delta_hi+1<br />
nothing<br />
inx<br />
dey<br />
bpl make_sine<br />
<br />
updateloop:<br />
; vblank<br />
lda VCOUNT<br />
bne updateloop<br />
<br />
; clear graphics<br />
sta HPOSP0<br />
sta GRAFP0<br />
<br />
ldy #0<br />
lda #47<br />
sta COLPM0<br />
yloop:<br />
tya ; graphics shape = y<br />
sta WSYNC<br />
sta GRAFP0<br />
<br />
; a = sin(frame+y)+48<br />
tya <br />
adc FRAMECOUNTER<br />
tax<br />
lda sinewave,x<br />
adc #48<br />
sta HPOSP0<br />
<br />
iny<br />
bne yloop<br />
jmp updateloop<br />
<br />
run main<br />
</syntaxhighlight><br />
<br />
=== Sound ===<br />
The Atari 8-bit use the POKEY chip to generate sound.<br />
* https://en.wikipedia.org/wiki/POKEY<br />
<br />
==== BASIC ====<br />
<syntaxhighlight lang="6502"><br />
; from Analog, 1985-09,pp.25-32<br />
*=$2000<br />
AUDF1=$D200<br />
AUDC1=$D201<br />
AUDCTL=$D208<br />
SKCTL=$D20F<br />
<br />
.MACRO SOUND ; voice,pitch,dist,vol;,dur<br />
lda #%2<br />
sta AUDF1+2*%1<br />
lda #[[%3 * 16] | %4] ;lda #[[%3 shl 4] or %4]<br />
sta AUDC1+2*%1<br />
.ENDM<br />
<br />
lda #0<br />
sta AUDCTL<br />
lda #3<br />
sta SKCTL<br />
<br />
SOUND 0,121,10,8<br />
<br />
jmp *<br />
</syntaxhighlight><br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Additional Resources ===<br />
Sizecoding resource for the Atari 8bit are:<br />
* Mapping the Atari https://www.atariarchives.org/mapping/<br />
* Atari 8bit Memory map https://www.atariarchives.org/mapping/memorymap.php<br />
* Fready's undocumented 6502 opcodes https://github.com/FreddyOffenga/6502<br />
* Atari OS Rev2 disassembly for MADS assembler https://github.com/ilmenit/A800-OS-XL-Rev2<br />
* Fready's github https://github.com/FreddyOffenga/<br />
<br />
== Commodore 64 ==<br />
The Commodore system consists of a 6502-compatible MOS 6510 processor with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Commodore systems is quite easy, first get the following tools:<br />
<br />
* Assembler: To be added<br />
* Emulator(s): VICE is the way to go<br />
<br />
=== Memory map ===<br />
<br />
<syntaxhighlight lang="6502"><br />
0-1 $0-$1 PROCESSOR PORT REGISTERS, not usable as RAM<br />
0-255 $0-$FF ZEROPAGE, mostly used by BASIC interpreter and Kernal<br />
256-511 $100-$1FF SYSTEM STACK<br />
512-600 $200-$258 INPUT BUFFER<br />
601-630 $259-$276 FILE SYSTEM DATA<br />
631-640 $277-$280 KEYBOARD BUFFER, filled by Kernal ISR upon key presses <br />
641-678 $281-$2A6 VARIOUS KERNAL VARIABLES<br />
679-767 $2A7-$2FF Unused (89 byte)<br />
768-779 $300-$30B KERNAL VECTORS<br />
780-783 $30C-$30F REGISTER VALUES A,X,Y,SR for SYS<br />
784-819 $310-$333 KERNAL VECTORS<br />
820-827 $334-$33B Unused (8 byte)<br />
828-1019 $33C-$3FB DATASETTE BUFFER<br />
1020-1023 $3FC-$3FF Unused (4 byte)<br />
1024-2023 $400-$7E7 SCREEN MEMORY (25 lines times 40 columns)<br />
2024-2039 $7E8-$7F7 Unused (16 byte)<br />
2040-2047 $7F8-$7FF SPRITE COSTUME POINTERS<br />
2048 $800 must contain a value of 0 so that the BASIC program can be RUN<br />
2049-40959 $801-$9FFF BASIC AREA (code, variables, arrays, strings)<br />
40960-49151 $A000-$BFFF BASIC ROM (unused RAM underneath)<br />
49152-53247 $C000-$CFFF UPPER RAM AREA (unused)<br />
53248-53294 $D000-$D02E VIC-II, memory-mapped graphics chip registers)<br />
54272-54300 $D400-$D41C SID, memory-mapped sound chip registers)<br />
55296-56295 $D800-$DBE7 Color RAM, only lower 4 bits are stored, higher nibble undefined<br />
56296-56319 $DBE8-$DBFF Unused (24 half-bytes)<br />
56320-56335 $DC00-$DC0F CIA#1, memory-mapped I/O chip registers for keyboard, joystick, mouse, datasette, IRQ control<br />
56576-56591 $DD00-$DD0F CIA#1, memory-mapped I/O chip registers for serial bus, RS232, NMI control<br />
57344-65535 $E000-$FFFF KERNAL ROM<br />
65534-65535 $FFFE-$FFFF Execution address of interrupt service routine, can only be set if KERNAL is turned off<br />
</syntaxhighlight><br />
<br />
For a detailed explanation of the C64 memory map check out [https://sta.c64.org/cbm64mem.html Commodore 64 memory map] on Joe Forster/STA homepage.<br />
<br />
=== Program file overhead ===<br />
<br />
A standard CBM file consists of a 2 byte loading address followed by the data that is placed into memory starting at this address. In addition, if your machine program should be able to be started with "RUN", you need a BASIC stub that is loaded into memory from $0801 to $080c, typically followed by your machine program:<br />
<br />
<syntaxhighlight lang="6502"><br />
*=$0801<br />
.word $080b ;address of next BASIC line<br />
.word LINENR ;line number, can be chosen between 0 and 63999<br />
.byte $9e ;token for SYS command<br />
.byte $32,$30,$36,$31 ;address to jump to in ASCII code: "2061" <br />
.byte $00 ;end of BASIC line<br />
.word $0000 ;address of next BASIC line, $0000 means end of BASIC program <br />
start<br />
; your code here<br />
</syntaxhighlight><br />
<br />
Together with the 2 byte load address, this makes an overhead of 14 byte for your program. To reduce this, you can<br />
* omit the BASIC line and tell users to start your program by directly entering "SYS ''address''"<br />
* save your program from $0802 on, the byte at $0801 is recovered automatically after loading by the relink function. This reduces your program file size by 1 byte<br />
* accept the loss and use the 2 byte establishing LINENR for something good, they are copied to zeropage addresses $39/$3a automatically, saving you the effort of initializing the addresses<br />
* use an autostart method (see below)<br />
<br />
Some compos also specify that the BASIC loader does not count towards the overall filesize, check the rules before you worry.<br />
<br />
=== Autostart ===<br />
<br />
Unlike the Commodore 128, the Commodore 64 has no dedicated built-in auto-boot feature, but it is possible to autorun a program after loading by specifying the load address so that it overwrites a vector or address that is called by the operating system. There are multiple possibilities:<br />
<br />
==== Overwriting CHROUT vector at $326-$327 ====<br />
<br />
The vector at address $326-$327 points at the CHROUT routine, normally at address $F1CA.<br />
If you put the entry address of your program into $326/27, your code will be called when the operating system wants to print "READY." after loading.<br />
Note that the vector at address $328-$329 points at the STOP routine that checks the status of Stop key indicator. Since this routine is called multiple times before your code is done loading, its default value $F6ED needs to be preserved. <br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$0326<br />
.word start <br />
.byte $ed,$f6<br />
start<br />
; rest of code<br />
</syntaxhighlight><br />
<br />
Together with the two byte load address, the overwritten CHROUT vector and the preserved STOP vector, your program file will have a deadweight of 6 byte: $26 $03 $0a $03 $ed $f6, less than half of the standard version with a BASIC stub with SYS<br />
<br />
Caveat:<br />
* If your program after $32a is longer than 214 byte, part of your program will load into the screen at $400. Thus, issuing a clear screen will overwrite your program. It is possible to move the screen memory somewhere else, but that requires storing a new value into address $D018, which when done with an LDA # / STA pair will cost you 5 byte<br />
* Since you changed the CHROUT pointer, standard KERNAL functions for printing won't work. For output of single characters, you can still use the direct address $F1CA. Alternatively, you can restore the vectors by calling $FD15, which will overwrite the memory $314 to $333 with the default values.<br />
<br />
==== Overwriting BASIC idle loop vector at $302-$303 ====<br />
<br />
After loading the program, the BASIC idle loop will be called. By overwriting the vector at $302/$303 it is possible to autostart your program. Since the memory before $302 can be safely overwritten, the program would be arranged so that $303 is the '''last''' address of your program. If your program requires a loop back to the start, the vector can be used as part of a JMP where the following two bytes are already there, saving one byte in comparison to a loop done with a branch command.<br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$304 - (end - start)<br />
start:<br />
;your code here<br />
; ...<br />
jmp start ;the address for start lies in $302/$303, thus will be called by the Kernal after loading<br />
end:<br />
</syntaxhighlight><br />
<br />
In cases where the vector has a practical use, the overhead in filesize is only the 2 byte loading address. For programs larger than 93 byte keep in mind that addresses before $2A7 are in use by the Kernal.<br />
<br />
==== Overwriting return address on stack at $1F8 ====<br />
<br />
When the load routine is called, the stack pointer is always at $FA at a stock C64. Thus the return address from the loading process is stored in memory address $F8 (low byte) and $F9 (high byte). During the loading routine, stack usage will clobber the stack below $1F8, but a program loaded to $1F8 and above will be fine and the overwritten address stored at $1F8/$1F9 will be called after loading.<br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$1F8<br />
.word start-1 ;adjust for the RTS command pulling the address from stack and increasing it by 1<br />
start:<br />
;your code here<br />
</syntaxhighlight><br />
<br />
For programs larger than 95 byte keep in mind that addresses after $259 are in use by the Kernal, you might overwrite some values here if you don't have disk operations, but better check the memory map beforehand.<br />
<br />
Together with the two byte load address and the overwritten address at $1F8/$1F9, your program file will have a deadweight of 4 byte when using this method.<br />
<br />
=== Video display ===<br />
Video display on the Commodore has the following video modes:<br />
* Standard text mode, 40x25 characters, 1 individual color per character, 1 common background color<br />
* Multicolor text mode, 40x25 characters, every two bits (fat pixel) define color: background, char, common color 1+2<br />
* Extended color text mode, 40x25 characters, 1 individual foreground color per character, 1 out of 4 background colors, only 64 chars<br />
* Hires bitmap, 320x200 pixels, an 8x8 field can have an individual foreground and an individual background color<br />
* Multicolor bitmap, 160x200 pixels, every two bits (fat pixel) define color: background, screen color lower nibble, screen color higher nibble, color from color RAM<br />
<br />
==== Getting something on screen ====<br />
<br />
Output a character:<br />
<syntaxhighlight lang="6502"><br />
lda #C ;C must be the char code according to the PETSCII code table<br />
jsr $FFD2 ;you can also use the direct address $FC1A, function preserves A,X,Y and enables interrupt<br />
</syntaxhighlight><br />
<br />
Since the [https://en.wikipedia.org/wiki/PETSCII#Character_set PETSCII code table] contains also control characters, this method can be also used to clear the screen, move the cursor or set the text color. However, some functions are shorter (and faster) by directly calling the respective KERNAL function:<br />
<br />
<syntaxhighlight lang="6502"><br />
Clear screen JSR $E544<br />
Cursor home position JSR $E566<br />
Output newline character JSR $AAD7<br />
Set text color LDA #COLOR, STA $286<br />
Set border color LDA #COLOR, STA $D020 ;not possible with a PETSCII control code<br />
Set background color LDA #COLOR, STA $D021 ;not possible with a PETSCII control code<br />
</syntaxhighlight><br />
<br />
Copy characters directly to screen memory:<br />
<br />
<syntaxhighlight lang="6502"><br />
.macpack cbm ;scrcode macro<br />
SCREEN_BASE=$400<br />
LINE=5 ;for example<br />
COLUMN=10 ;for example<br />
<br />
ldx #endtext-text-1<br />
@loop: lda text,x<br />
sta SCREEN_BASE+LINE*40+COLUMN,x<br />
dex<br />
bpl @loop<br />
text: scrcode "hello world!"<br />
endtext:<br />
</syntaxhighlight><br />
<br />
Note that the text needs to be stored in '''screen code''' format, not in PETSCII (see [https://sta.c64.org/cbm64pettoscr.html Commodore 64 PETSCII code to screen code conversion] for the differences). Furthermore, the example above only writes to the screen memory, not the color RAM, assuming that the color RAM already contains the intended text color. This is the case after issuing a clear screen on most C64 machines, except for some old ROM revisions. To be on the save side you would have to write to color RAM as well, which costs another 5 byte:<br />
<br />
<syntaxhighlight lang="6502"><br />
.macpack cbm ;scrcode macro<br />
SCREEN_BASE=$400<br />
COLOR_RAM =$D800<br />
LINE =5 ;for example<br />
COLUMN =10 ;for example<br />
COLOR =1 ;white<br />
<br />
ldx #endtext-text-1<br />
@loop: lda text,x<br />
sta SCREEN_BASE+LINE*40+COLUMN,x<br />
lda #COLOR<br />
sta COLOR_RAM +LINE*40+COLUMN,x<br />
dex<br />
bpl @loop<br />
text: scrcode "hello world!"<br />
endtext:<br />
</syntaxhighlight><br />
<br />
=== Sound ===<br />
The Commodore 64 uses the famous SID chip to generate sound.<br />
To be added soon.<br />
<br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Useful Kernal functions ===<br />
<br />
==== Get a pseudo random number ====<br />
<br />
<syntaxhighlight lang="6502"><br />
lda #1 <br />
jsr $E09A<br />
lda $63<br />
</syntaxhighlight><br />
<br />
The sequence of random numbers is always the same after a cold start or reset, the first 20 numbers are:<br />
<syntaxhighlight lang="6502"><br />
4,24,231,4,177,170,193,101,231,18,196,1,75,48,149,36,124,53,65,154<br />
</syntaxhighlight><br />
<br />
==== Increment a zero page counter, return in X register, clear Y register ====<br />
<br />
This is part of the string handling function in the BASIC ROM, but the code could be useful for some loop stuff.<br />
<br />
<syntaxhighlight lang="6502"><br />
jsr $B5FF ;does inc $23, ldx $23, ldy #$00, rts<br />
</syntaxhighlight><br />
<br />
=== Additional Resources ===<br />
* Codebase 64 https://codebase64.org/doku.php?id=base:start<br />
* Commodore 64 Memory map https://sta.c64.org/cbm64mem.html<br />
* C64 BASIC & KERNAL ROM Disassembly https://www.pagetable.com/c64ref/c64disasm/<br />
<br />
== Apple II ==<br />
The Apple II is an 8-bit home computer and one of the world's first highly successful mass-produced microcomputer products. It was designed primarily by Steve Wozniak.<br />
<br />
=== Setting up ===<br />
* ACME 6502 cross-assembler(https://sourceforge.net/projects/acme-crossass/)<br />
* Apple Commander (http://applecommander.sourceforge.net) for batch compilation<br />
* AppleWin emulator (https://github.com/AppleWin/AppleWin/releases). Supports Mockingboard card(AY-8910+speech synthesier), HDD, Z80 card(for CP/M), mouse etc.<br />
* CiderPress(https://a2ciderpress.com)<br />
<br />
Compilation can be done as follows (master.dsk can be found with applewin) <br />
<syntaxhighlight><br />
acme hl.asm<br />
java -jar AppleCommander-1.3.5.jar -d master.dsk hl<br />
java -jar AppleCommander-1.3.5.jar -p master.dsk hl B 24576 < hl.bin<br />
</syntaxhighlight><br />
<br />
=== Memory Map ===<br />
<syntaxhighlight lang="6502"><br />
0-255 $0-$FF ZERO-PAGE SYSTEM STORAGE<br />
256-511 $100-$1FF SYSTEM STACK<br />
512-767 $200-$2FF KEYBOARD CHARACTER BUFFER<br />
768-975 $300-$3CF OFTEN AVAILABLE AS FREE SPACE FOR USER PROGRAMS<br />
976-1023 $3D0-3FF SYSTEM VECTORS<br />
1024-2047 $400-$7FF TEXT AND LO-RES GRAPHICS PAGE 1 <--- !!!<br />
2048-LOMEM $800-LOMEM PROGRAM STORAGE<br />
2048-3071 $800-$BFF TEXT AND LO-RES GRAPHICS PAGE 2 OR FREE SPACE<br />
3072-8191 $C00-$1FFF FREE SPACE UNLESS RAM APPLESOFT IS IN USE<br />
8192-16383 $2000-$3FFF HI-RES PAGE 1 OR FREE SPACE <--- !!!<br />
16384-24575 $4000-$5FFF HI-RES PAGE 2 OR FREE SPACE<br />
24576-38999 $6000-$95FF FREE SPACE AND STRING STORAGE<br />
38400-49151 $9600-$BFFF DOS<br />
49152-53247 $C000-$CFFF I/O HARDWARE (RESERVED)<br />
53248-57343 $D000-$DFFF APPLESOFT IN LANGUAGE CARD OR ROM<br />
57344-63487 $E000-$F7FF APPLESOFT OR INTEGER BASIC IN LANGUAGE CARD OR ROM<br />
63488-65535 $F800-$FFFF SYSTEM MONITOR<br />
</syntaxhighlight><br />
<br />
=== Display ===<br />
<br />
=== Graphics Modes ===<br />
: Text Mode 40x24, for Apple IIe available 80x25 - use PR#3 for switch mode, or hardware switch<br />
: LowRes 40x48, 16 colors: https://en.wikipedia.org/wiki/Apple_II_graphics <br />
: Hires mode 280x192,6 colors: https://www.xtof.info/blog/?p=768<br />
https://mrob.com/pub/xapple2/colors.html<br />
https://archive.org/details/HiRes_Color_Graphics_on_the_Apple_II_Computer_by_Wozniak<br />
<br />
However for sizecoding, you almost never want to do direct-access to graphics for Apple II in size-coding because the Apple II graphics modes are horrible. The only fast way to do things is with large lookup tables. To do hires you need to divide by 7 which as you can imagine is a bit difficult to do compactly on 6502. Double-hires is even crazier on top of that. Deater did manage a color-bar style effect in double-hires in 128B but that was doing some crazy tricks with the firmware BASIC routines, definitely not direct-access.<br />
<br />
Lores and Hires can be mixed modes and full-graphics<br />
The screen structure is called memory holes(https://retrocomputing.stackexchange.com/questions/2534/what-are-the-screen-holes-in-apple-ii-graphics). The GBASCALC($F847) procedure is used to calculate the address of the horizontal line : IN:reg.A=Y, out : GBASL/GBASH($26/$27)=address. See also https://www.callapple.org/uncategorized/use-of-apple-ii-color-graphics-in-assembly-language/<br />
<br />
==== Getting something on screen ====<br />
Here is an example of a XOR texture, created by g0blinish<br />
<syntaxhighlight lang="6502"><br />
*=$6000<br />
!to "HL.bin", plain ; set output file and format<br />
!cpu 6502 ; set processor type<br />
<br />
GBASL = $26<br />
GBASH = $27<br />
SETGR = $FB40 ; setup LoRes<br />
GBASCALC = $F847 ; calc Address<br />
<br />
CLRTEXT = $C050 ;display graphics <br />
SETTEXT = $C051 ;display text <br />
<br />
CLRMIXED = $C052 ;clear mixed mode- enable full graphics <br />
SETMIXED = $C053 ;enable graphics/text mixed mode <br />
<br />
PAGE1 = $C054 ;select text/graphics page1 <br />
PAGE2 = $C055 ;select text/graphics page2 <br />
<br />
CLRHIRES = $C056 ;select Lo-res <br />
SETHIRES = $C057 ;select Hi-res <br />
<br />
TMP= $FA<br />
<br />
JSR SETGR ;GR<br />
BIT CLRMIXED ; full screen<br />
<br />
LDA #0 ; A=0<br />
STA TMP ; POKE $FA,A<br />
<br />
YLP ;<br />
LDA TMP ; A=PEEK($FA)<br />
; LSR ; A=A/2<br />
JSR GBASCALC<br />
LDY #0;Y=0<br />
<br />
XLP TYA ; A=Y<br />
EOR TMP ; A=A xor PEEK($FA)<br />
and #$0F ; A=A and 15<br />
TAX ; X=A<br />
LDA COLORS,X ;A=PEEK(COLORS+X)<br />
STA(GBASL),Y ; POKE PEEK($26)+256*PEEK($27)+Y,A<br />
INY ; Y=Y+1<br />
CPY #40 ; Y=40?<br />
BNE XLP<br />
INC TMP ; POKE $FA,PEEK($FA)+1<br />
LDA TMP ; A=PEEK($FA)<br />
CMP #24 ; A=24?<br />
BNE YLP<br />
<br />
M1 JMP M1 ; replace to RTS<br />
<br />
COLORS ;N*17, pixel format is AAAABBBB, AAAA - upper dot, BBBB - lower dot<br />
!byte $00,$11,$22,$33,$44,$55,$66,$77<br />
!byte $88,$99,$AA,$BB,$CC,$DD,$EE,$FF<br />
</syntaxhighlight><br />
<br />
==== Sound ====<br />
Here is an example for using the speaker, based onthe following basic program:<br />
<br />
<syntaxhighlight lang="basic"><br />
; 50 POKE 768,V: POKE 769,P - 255 * INT (P / 256): POKE 800,1 + P / 256<br />
; 60 CALL 770: RETURN <br />
; 95 FOR K = 1 TO N: READ V(K),P(K): NEXT K<br />
; 100 FOR K = 1 TO N:V = V(K):P = P(K)<br />
; 110 GOSUB 50<br />
;!byte 173,48,192,136,208,5,206,1,3,240,9,202,208,245,174,0,3,76,2,3,206,32,3,208,240,96<br />
</syntaxhighlight><br />
<br />
<syntaxhighlight lang="6502"><br />
*=$6000<br />
!to "HL.bin", plain ; set output file and format<br />
!cpu 6502 ; set processor type<br />
<br />
;start<br />
; 95 FOR K = 1 TO N: READ V(K),P(K): NEXT K<br />
; 100 FOR K = 1 TO N:V = V(K):P = P(K)<br />
ini:<br />
lda #70<br />
sta cnt+1<br />
lda #music&255<br />
sta gotbyte+1<br />
lda #music/256<br />
sta gotbyte+2<br />
<br />
lop:<br />
;V<br />
jsr gotbyte<br />
sta L300<br />
jsr gotbyte<br />
;P<br />
jsr gotbyte<br />
sta L301<br />
jsr gotbyte<br />
clc<br />
adc #1<br />
sta L320<br />
jsr beep<br />
<br />
dec cnt+1<br />
cnt lda #70<br />
bne lop<br />
; 110 GOSUB 50<br />
; 50 POKE 768,V: POKE 769,P - 255 * INT (P / 256): POKE 800,1 + P / 256<br />
; 60 CALL 770: RETURN <br />
jmp ini<br />
gotbyte<br />
lda music<br />
inc gotbyte+1<br />
bne noinch<br />
inc gotbyte+2<br />
noinch<br />
rts<br />
;!byte 173,48,192,136,208,5,206,1,3,240,9,202,208,245,174,0,3,76,2,3,206,32,3,208,240,96<br />
beep:<br />
ldy #1<br />
ldx #1<br />
loc_302:<br />
LDA $C030<br />
<br />
loc_305:<br />
DEY<br />
BNE loc_30D<br />
DEC L301<br />
loc_30B:<br />
BEQ loc_316<br />
<br />
loc_30D:<br />
DEX<br />
BNE loc_305<br />
LDX L300<br />
JMP loc_302<br />
loc_316:<br />
DEC L320<br />
BNE loc_30B<br />
RTS<br />
L301 !byte 0<br />
L300 !byte 0<br />
L320 !byte 0<br />
music<br />
!word 76,192,85,64,96,64,102,64,114,128,114,64,96,64,102,64,114,64,128,64<br />
!word 114,64,152,64,171,64,152,512,76,192,85,64,96,64,102,64,114,128,114,64<br />
!word 96,64,102,64,114,64,128,64,114,64,152,64,171,64,152,512,85,64,85,64<br />
!word 85,64,96,64,144,128,144,64,128,64,76,128,85,64,96,64,144,128,114,64<br />
!word 96,64,102,128,114,64,128,64,128,128,114,64,128,64,114,512,85,64,85,64<br />
!word 85,64,96,64,144,128,144,64,128,64,76,128,85,64,96,64,144,128,114,64<br />
!word 96,64,102,128,114,64,128,64,128,64,128,128,96,64,85,64,96,64,102,64,114,64,114,64<br />
</syntaxhighlight><br />
<br />
=== Additional Resources ===<br />
* Deater's page on Apple II sizecoding http://www.deater.net/weave/vmwprod/demos/sizecoding.html<br />
* Article on double hi-res http://www.battlestations.zone/2017/04/apple-ii-double-hi-res-from-ground-up.html<br />
* Applesoft Hi-Res Subroutines : http://hackzapple.org/scripts_php/index.php?menu=5&mod=ASM&sub=AAL&sub2=8112&PHPSESSID=f65fabfd0cdbf56b6bdc0ddac25117c6#a2<br />
<br />
== Atari Lynx ==<br />
The Atari Lynx consists of the 6502 with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Atari Lynx:<br />
<br />
* Assembler: -<br />
* Emulator(s): -<br />
<br />
=== Video display ===<br />
To be added soon.<br />
<br />
==== Getting something on screen ====<br />
To be added soon.<br />
<br />
<br />
=== Sound ===<br />
To be added soon.<br />
<br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Additional Resources ===<br />
Sizecoding resource for the Atari Lynx are sparse<br />
* 42Bastian's website (link to be added)</div>Wilhttp://www.sizecoding.org/index.php?title=6502&diff=82765022021-02-15T22:17:48Z<p>Wil: /* Autostart */ stack return address method</p>
<hr />
<div>== Introduction ==<br />
Wanting to start sizecoding on a 6502 platform in this day and age can be tough. <br />
<br />
[[File:6502.jpg|thumb]]<br />
<br />
So here is a bit of help to get you started:<br />
<br />
=== The 6502 processor ===<br />
The 6502 processor can be seen as the 8-bit micro ARM chip. <br />
It has only has 3 registers (Accumulator, X and Y registers) and a handful of instructions to work with.<br />
<br />
=== Adressing modes ===<br />
To be added.<br />
<br />
=== Zero page ===<br />
When using the 6502 for sizecoding, you'll mostly be working from zeropage<br />
<br />
=== General 6502 Resources ===<br />
* 6502.org http://www.6502.org/<br />
* 6502 instruction reference http://www.6502.org/tutorials/6502opcodes.html<br />
* 6502 books http://retro.hansotten.nl/6502-sbc/<br />
* 6502 Assembler tutorial https://dwheeler.com/6502/oneelkruns/asm1step.html<br />
* Easy 6502 code tester https://skilldrick.github.io/easy6502/<br />
* Synthetic instructions https://wiki.nesdev.com/w/index.php/Synthetic_instructions#8-bit_rotate<br />
<br />
== Atari 8-bit family ==<br />
The systems in this family are: Atari 400, 800, 5200, 1200XL, 600XL, 800XL, 130XE, 65XE, 800XE and XEGS.<br /><br />
<br />
The Atari 8-bit systems consists of the 6502 with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Atari 8bit systems is quite easy, first get the following tools:<br />
<br />
* Assembler: MADS Assembler - This assembler has nice macros for creating Binaries and SNA snapshot files out of the box. You can download it at https://mads.atari8.info/<br />
* Emulator(s): I Found Altirra to work best for my usecase. Make sure to use the original Rev2 rom for best compatibility.<br />
<br />
==== Special Memory Adresses ====<br />
* FRAMECOUNTER_HIGH = 19<br />
* FRAMECOUNTER_LOW = 20<br />
<br />
=== Video display ===<br />
Video display on the Atari 8bit systems use the ANTIC and GTIA chips. Information can be found here:<br />
* https://en.wikipedia.org/wiki/ANTIC<br />
* https://www.atariarchives.org/agagd/chapter1.php<br />
<br />
==== Sync with frame ====<br />
<syntaxhighlight lang="6502"><br />
RTCLOK equ $0012<br />
lda RTCLOK+2<br />
waits<br />
cmp RTCLOK+2<br />
beq waits<br />
</syntaxhighlight><br />
<br />
Or if you don't mind trashing RTCLOK<br />
<br />
<syntaxhighlight lang="6502"><br />
RTCLOK equ $0012<br />
waits<br />
lsr RTCLOK+2<br />
bcc waits<br />
</syntaxhighlight><br />
<br />
Which is two bytes shorter.<br />
<br />
==== Getting something on screen ====<br />
<syntaxhighlight lang="6502"><br />
;fill screen with charset,(88,89)=an address<br />
org $600; free 6th page:600-6ff<br />
ldy #0<br />
fl: tya<br />
sta(88),y<br />
iny<br />
bne fl<br />
jmp *<br />
</syntaxhighlight><br />
<br />
To be added soon.<br />
<br />
<syntaxhighlight lang="6502"><br />
SDMCTL = $022f<br />
HPOSP0 = $d000<br />
SIZEP0 = $d008<br />
GRAFP0 = $d00d<br />
COLPM0 = $d012<br />
<br />
FRAMECOUNTER_HIGH = 19<br />
FRAMECOUNTER = 20<br />
WSYNC = $d40a<br />
VCOUNT = $d40b<br />
<br />
sinewave = $0600 ; to $06ff<br />
<br />
org $80<br />
<br />
main <br />
; disable all graphics/colors<br />
ldx #0<br />
stx SDMCTL <br />
<br />
ldy #$7f<br />
sty SIZEP0 ; size p0=127<br />
<br />
ldx #0<br />
ldy #$3f<br />
make_sine:<br />
value_lo<br />
lda #0<br />
clc<br />
delta_lo<br />
adc #0<br />
sta value_lo+1<br />
value_hi<br />
lda #0<br />
delta_hi<br />
adc #0<br />
sta value_hi+1<br />
<br />
sta sinewave+$c0,x<br />
sta sinewave+$80,y<br />
eor #$7f<br />
sta sinewave+$40,x<br />
sta sinewave+$00,y<br />
<br />
lda delta_lo+1<br />
adc #8<br />
sta delta_lo+1<br />
bcc nothing<br />
inc delta_hi+1<br />
nothing<br />
inx<br />
dey<br />
bpl make_sine<br />
<br />
updateloop:<br />
; vblank<br />
lda VCOUNT<br />
bne updateloop<br />
<br />
; clear graphics<br />
sta HPOSP0<br />
sta GRAFP0<br />
<br />
ldy #0<br />
lda #47<br />
sta COLPM0<br />
yloop:<br />
tya ; graphics shape = y<br />
sta WSYNC<br />
sta GRAFP0<br />
<br />
; a = sin(frame+y)+48<br />
tya <br />
adc FRAMECOUNTER<br />
tax<br />
lda sinewave,x<br />
adc #48<br />
sta HPOSP0<br />
<br />
iny<br />
bne yloop<br />
jmp updateloop<br />
<br />
run main<br />
</syntaxhighlight><br />
<br />
=== Sound ===<br />
The Atari 8-bit use the POKEY chip to generate sound.<br />
* https://en.wikipedia.org/wiki/POKEY<br />
<br />
==== BASIC ====<br />
<syntaxhighlight lang="6502"><br />
; from Analog, 1985-09,pp.25-32<br />
*=$2000<br />
AUDF1=$D200<br />
AUDC1=$D201<br />
AUDCTL=$D208<br />
SKCTL=$D20F<br />
<br />
.MACRO SOUND ; voice,pitch,dist,vol;,dur<br />
lda #%2<br />
sta AUDF1+2*%1<br />
lda #[[%3 * 16] | %4] ;lda #[[%3 shl 4] or %4]<br />
sta AUDC1+2*%1<br />
.ENDM<br />
<br />
lda #0<br />
sta AUDCTL<br />
lda #3<br />
sta SKCTL<br />
<br />
SOUND 0,121,10,8<br />
<br />
jmp *<br />
</syntaxhighlight><br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Additional Resources ===<br />
Sizecoding resource for the Atari 8bit are:<br />
* Mapping the Atari https://www.atariarchives.org/mapping/<br />
* Atari 8bit Memory map https://www.atariarchives.org/mapping/memorymap.php<br />
* Fready's undocumented 6502 opcodes https://github.com/FreddyOffenga/6502<br />
* Atari OS Rev2 disassembly for MADS assembler https://github.com/ilmenit/A800-OS-XL-Rev2<br />
* Fready's github https://github.com/FreddyOffenga/<br />
<br />
== Commodore 64 ==<br />
The Commodore system consists of a 6502-compatible MOS 6510 processor with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Commodore systems is quite easy, first get the following tools:<br />
<br />
* Assembler: To be added<br />
* Emulator(s): VICE is the way to go<br />
<br />
=== Memory map ===<br />
<br />
<syntaxhighlight lang="6502"><br />
0-1 $0-$1 PROCESSOR PORT REGISTERS, not usable as RAM<br />
0-255 $0-$FF ZEROPAGE, mostly used by BASIC interpreter and Kernal<br />
256-511 $100-$1FF SYSTEM STACK<br />
512-600 $200-$258 INPUT BUFFER<br />
601-630 $259-$276 FILE SYSTEM DATA<br />
631-640 $277-$280 KEYBOARD BUFFER, filled by Kernal ISR upon key presses <br />
641-678 $281-$2A6 VARIOUS KERNAL VARIABLES<br />
679-767 $2A7-$2FF Unused (89 byte)<br />
768-779 $300-$30B KERNAL VECTORS<br />
780-783 $30C-$30F REGISTER VALUES A,X,Y,SR for SYS<br />
784-819 $310-$333 KERNAL VECTORS<br />
820-827 $334-$33B Unused (8 byte)<br />
828-1019 $33C-$3FB DATASETTE BUFFER<br />
1020-1023 $3FC-$3FF Unused (4 byte)<br />
1024-2023 $400-$7E7 SCREEN MEMORY (25 lines times 40 columns)<br />
2024-2039 $7E8-$7F7 Unused (16 byte)<br />
2040-2047 $7F8-$7FF SPRITE COSTUME POINTERS<br />
2048 $800 must contain a value of 0 so that the BASIC program can be RUN<br />
2049-40959 $801-$9FFF BASIC AREA (code, variables, arrays, strings)<br />
40960-49151 $A000-$BFFF BASIC ROM (unused RAM underneath)<br />
49152-53247 $C000-$CFFF UPPER RAM AREA (unused)<br />
53248-53294 $D000-$D02E VIC-II, memory-mapped graphics chip registers)<br />
54272-54300 $D400-$D41C SID, memory-mapped sound chip registers)<br />
55296-56295 $D800-$DBE7 Color RAM, only lower 4 bits are stored, higher nibble undefined<br />
56296-56319 $DBE8-$DBFF Unused (24 half-bytes)<br />
56320-56335 $DC00-$DC0F CIA#1, memory-mapped I/O chip registers for keyboard, joystick, mouse, datasette, IRQ control<br />
56576-56591 $DD00-$DD0F CIA#1, memory-mapped I/O chip registers for serial bus, RS232, NMI control<br />
57344-65535 $E000-$FFFF KERNAL ROM<br />
65534-65535 $FFFE-$FFFF Execution address of interrupt service routine, can only be set if KERNAL is turned off<br />
</syntaxhighlight><br />
<br />
For a detailed explanation of the C64 memory map check out [https://sta.c64.org/cbm64mem.html Commodore 64 memory map] on Joe Forster/STA homepage.<br />
<br />
=== Program file overhead ===<br />
<br />
A standard CBM file consists of a 2 byte loading address followed by the data that is placed into memory starting at this address. In addition, if your machine program should be able to be started with "RUN", you need a BASIC stub that is loaded into memory from $0801 to $080c, typically followed by your machine program:<br />
<br />
<syntaxhighlight lang="6502"><br />
*=$0801<br />
.word $080b ;address of next BASIC line<br />
.word LINENR ;line number, can be chosen between 0 and 63999<br />
.byte $9e ;token for SYS command<br />
.byte $32,$30,$36,$31 ;address to jump to in ASCII code: "2061" <br />
.byte $00 ;end of BASIC line<br />
.word $0000 ;address of next BASIC line, $0000 means end of BASIC program <br />
start<br />
; your code here<br />
</syntaxhighlight><br />
<br />
Together with the 2 byte load address, this makes an overhead of 14 byte for your program. To reduce this, you can<br />
* omit the BASIC line and tell users to start your program by directly entering "SYS ''address''"<br />
* save your program from $0802 on, the byte at $0801 is recovered automatically after loading by the relink function. This reduces your program file size by 1 byte<br />
* accept the loss and use the 2 byte establishing LINENR for something good, they are copied to zeropage addresses $39/$3a automatically, saving you the effort of initializing the addresses<br />
* use an autostart method (see below)<br />
<br />
Some compos also specify that the BASIC loader does not count towards the overall filesize, check the rules before you worry.<br />
<br />
=== Autostart ===<br />
<br />
Unlike the Commodore 128, the Commodore 64 has no dedicated built-in auto-boot feature, but it is possible to autorun a program after loading by specifying the load address so that it overwrites a vector or address that is called by the operating system. There are multiple possibilities:<br />
<br />
==== Overwriting CHROUT vector at $326-$327 ====<br />
<br />
The vector at address $326-$327 points at the CHROUT routine, normally at address $F1CA.<br />
If you put the entry address of your program into $326/27, your code will be called when the operating system wants to print "READY." after loading.<br />
Note that the vector at address $328-$329 points at the STOP routine that checks the status of Stop key indicator. Since this routine is called multiple times before your code is done loading, its default value $F6ED needs to be preserved. <br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$0326<br />
.word start <br />
.byte $ed,$f6<br />
start<br />
; rest of code<br />
</syntaxhighlight><br />
<br />
Together with the two byte load address, the overwritten CHROUT vector and the preserved STOP vector, your program file will have a deadweight of 6 byte: $26 $03 $0a $03 $ed $f6, less than half of the standard version with a BASIC stub with SYS<br />
<br />
Caveat:<br />
* If your program after $32a is longer than 214 byte, part of your program will load into the screen at $400. Thus, issuing a clear screen will overwrite your program. It is possible to move the screen memory somewhere else, but that requires storing a new value into address $D018, which when done with an LDA # / STA pair will cost you 5 byte<br />
* Since you changed the CHROUT pointer, standard KERNAL functions for printing won't work. For output of single characters, you can still use the direct address $F1CA. Alternatively, you can restore the vectors by calling $FD15, which will overwrite the memory $314 to $333 with the default values.<br />
<br />
==== Overwriting BASIC idle loop vector at $302-$303 ====<br />
<br />
After loading the program, the BASIC idle loop will be called. By overwriting the vector at $302/$303 it is possible to autostart your program. Since the memory before $302 can be safely overwritten, the program would be arranged so that $303 is the '''last''' address of your program. If your program requires a loop back to the start, the vector can be used as part of a JMP where the following two bytes are already there, saving one byte in comparison to a loop done with a branch command.<br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$304 - (end - start)<br />
start:<br />
;your code here<br />
; ...<br />
jmp start ;the address for start lies in $302/$303, thus will be called by the Kernal after loading<br />
end:<br />
</syntaxhighlight><br />
<br />
In cases where the vector has a practical use, the overhead in filesize is only the 2 byte loading address. For programs larger than 93 byte keep in mind that addresses before $2A7 are in use by the Kernal.<br />
<br />
==== Overwriting return address on stack at $1F8 ====<br />
<br />
When the load routine is called, the stack pointer is always at $FA at a stock C64. Thus the return address from the loading process is stored in memory address $F8 (low byte) and $F9 (high byte). During the loading routine, stack usage will clobber the stack below $1F8, but a program loaded to $1F8 and above will be fine and the overwritten address stored at $1F8/$1F9 will be called after loading.<br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$1F8<br />
.word start-1 ;adjust for the RTS command pulling the address from stack and increasing it by 1<br />
start:<br />
;your code here<br />
</syntaxhighlight><br />
<br />
For programs larger than 95 byte keep in mind that addresses after $259 are in use by the Kernal, you might overwrite some values here if you don't have disk operations, but better check the memory map beforehand.<br />
<br />
Together with the two byte load address and the overwritten address at $1F8/$1F9, your program file will have a deadweight of 4 byte when using this method.<br />
<br />
=== Video display ===<br />
Video display on the Commodore has the following video modes:<br />
* Standard text mode, 40x25 characters, 1 individual color per character, 1 common background color<br />
* Multicolor text mode, 40x25 characters, every two bits (fat pixel) define color: background, char, common color 1+2<br />
* Extended color text mode, 40x25 characters, 1 individual foreground color per character, 1 out of 4 background colors, only 64 chars<br />
* Hires bitmap, 320x200 pixels, an 8x8 field can have an individual foreground and an individual background color<br />
* Multicolor bitmap, 160x200 pixels, every two bits (fat pixel) define color: background, screen color lower nibble, screen color higher nibble, color from color RAM<br />
<br />
==== Getting something on screen ====<br />
<br />
Output a character:<br />
<syntaxhighlight lang="6502"><br />
lda #C ;C must be the char code according to the PETSCII code table<br />
jsr $FFD2 ;you can also use the direct address $FC1A, function preserves A,X,Y and enables interrupt<br />
</syntaxhighlight><br />
<br />
Since the [https://en.wikipedia.org/wiki/PETSCII#Character_set PETSCII code table] contains also control characters, this method can be also used to clear the screen, move the cursor or set the text color. However, some functions are shorter (and faster) by directly calling the respective KERNAL function:<br />
<br />
<syntaxhighlight lang="6502"><br />
Clear screen JSR $E544<br />
Cursor home position JSR $E566<br />
Output newline character JSR $AAD7<br />
Set text color LDA #COLOR, STA $286<br />
Set border color LDA #COLOR, STA $D020 ;not possible with a PETSCII control code<br />
Set background color LDA #COLOR, STA $D021 ;not possible with a PETSCII control code<br />
</syntaxhighlight><br />
<br />
Copy characters directly to screen memory:<br />
<br />
<syntaxhighlight lang="6502"><br />
.macpack cbm ;scrcode macro<br />
SCREEN_BASE=$400<br />
LINE=5 ;for example<br />
COLUMN=10 ;for example<br />
<br />
ldx #endtext-text-1<br />
@loop: lda text,x<br />
sta SCREEN_BASE+LINE*40+COLUMN,x<br />
dex<br />
bpl @loop<br />
text: scrcode "hello world!"<br />
endtext:<br />
</syntaxhighlight><br />
<br />
Note that the text needs to be stored in '''screen code''' format, not in PETSCII (see [https://sta.c64.org/cbm64pettoscr.html Commodore 64 PETSCII code to screen code conversion] for the differences). Furthermore, the example above only writes to the screen memory, not the color RAM, assuming that the color RAM already contains the intended text color. This is the case after issuing a clear screen on most C64 machines, except for some old ROM revisions. To be on the save side you would have to write to color RAM as well, which costs another 5 byte:<br />
<br />
<syntaxhighlight lang="6502"><br />
.macpack cbm ;scrcode macro<br />
SCREEN_BASE=$400<br />
COLOR_RAM =$D800<br />
LINE =5 ;for example<br />
COLUMN =10 ;for example<br />
COLOR =1 ;white<br />
<br />
ldx #endtext-text-1<br />
@loop: lda text,x<br />
sta SCREEN_BASE+LINE*40+COLUMN,x<br />
lda #COLOR<br />
sta COLOR_RAM +LINE*40+COLUMN,x<br />
dex<br />
bpl @loop<br />
text: scrcode "hello world!"<br />
endtext:<br />
</syntaxhighlight><br />
<br />
=== Sound ===<br />
The Commodore 64 uses the famous SID chip to generate sound.<br />
To be added soon.<br />
<br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Useful Kernal functions ===<br />
<br />
==== Get a pseudo random number ====<br />
<br />
<syntaxhighlight lang="6502"><br />
lda #1 <br />
jsr $E09A<br />
lda $63<br />
</syntaxhighlight><br />
<br />
The sequence of random numbers is always the same after a cold start or reset, the first 20 numbers are:<br />
<syntaxhighlight lang="6502"><br />
4,24,231,4,177,170,193,101,231,18,196,1,75,48,149,36,124,53,65,154<br />
</syntaxhighlight><br />
<br />
==== Increment a zero page counter, return in X register, clear Y register ====<br />
<br />
This is part of the string handling function in the BASIC ROM, but the code could be useful for some loop stuff.<br />
<br />
<syntaxhighlight lang="6502"><br />
jsr $B5FF ;does a inc $23, ldx $23, ldy #$00, rts<br />
</syntaxhighlight><br />
<br />
=== Additional Resources ===<br />
* Codebase 64 https://codebase64.org/doku.php?id=base:start<br />
* Commodore 64 Memory map https://sta.c64.org/cbm64mem.html<br />
* C64 BASIC & KERNAL ROM Disassembly https://www.pagetable.com/c64ref/c64disasm/<br />
<br />
== Apple II ==<br />
The Apple II is an 8-bit home computer and one of the world's first highly successful mass-produced microcomputer products. It was designed primarily by Steve Wozniak.<br />
<br />
=== Setting up ===<br />
* ACME 6502 cross-assembler(https://sourceforge.net/projects/acme-crossass/)<br />
* Apple Commander (http://applecommander.sourceforge.net) for batch compilation<br />
* AppleWin emulator (https://github.com/AppleWin/AppleWin/releases). Supports Mockingboard card(AY-8910+speech synthesier), HDD, Z80 card(for CP/M), mouse etc.<br />
* CiderPress(https://a2ciderpress.com)<br />
<br />
Compilation can be done as follows (master.dsk can be found with applewin) <br />
<syntaxhighlight><br />
acme hl.asm<br />
java -jar AppleCommander-1.3.5.jar -d master.dsk hl<br />
java -jar AppleCommander-1.3.5.jar -p master.dsk hl B 24576 < hl.bin<br />
</syntaxhighlight><br />
<br />
=== Memory Map ===<br />
<syntaxhighlight lang="6502"><br />
0-255 $0-$FF ZERO-PAGE SYSTEM STORAGE<br />
256-511 $100-$1FF SYSTEM STACK<br />
512-767 $200-$2FF KEYBOARD CHARACTER BUFFER<br />
768-975 $300-$3CF OFTEN AVAILABLE AS FREE SPACE FOR USER PROGRAMS<br />
976-1023 $3D0-3FF SYSTEM VECTORS<br />
1024-2047 $400-$7FF TEXT AND LO-RES GRAPHICS PAGE 1 <--- !!!<br />
2048-LOMEM $800-LOMEM PROGRAM STORAGE<br />
2048-3071 $800-$BFF TEXT AND LO-RES GRAPHICS PAGE 2 OR FREE SPACE<br />
3072-8191 $C00-$1FFF FREE SPACE UNLESS RAM APPLESOFT IS IN USE<br />
8192-16383 $2000-$3FFF HI-RES PAGE 1 OR FREE SPACE <--- !!!<br />
16384-24575 $4000-$5FFF HI-RES PAGE 2 OR FREE SPACE<br />
24576-38999 $6000-$95FF FREE SPACE AND STRING STORAGE<br />
38400-49151 $9600-$BFFF DOS<br />
49152-53247 $C000-$CFFF I/O HARDWARE (RESERVED)<br />
53248-57343 $D000-$DFFF APPLESOFT IN LANGUAGE CARD OR ROM<br />
57344-63487 $E000-$F7FF APPLESOFT OR INTEGER BASIC IN LANGUAGE CARD OR ROM<br />
63488-65535 $F800-$FFFF SYSTEM MONITOR<br />
</syntaxhighlight><br />
<br />
=== Display ===<br />
<br />
=== Graphics Modes ===<br />
: Text Mode 40x24, for Apple IIe available 80x25 - use PR#3 for switch mode, or hardware switch<br />
: LowRes 40x48, 16 colors: https://en.wikipedia.org/wiki/Apple_II_graphics <br />
: Hires mode 280x192,6 colors: https://www.xtof.info/blog/?p=768<br />
https://mrob.com/pub/xapple2/colors.html<br />
https://archive.org/details/HiRes_Color_Graphics_on_the_Apple_II_Computer_by_Wozniak<br />
<br />
However for sizecoding, you almost never want to do direct-access to graphics for Apple II in size-coding because the Apple II graphics modes are horrible. The only fast way to do things is with large lookup tables. To do hires you need to divide by 7 which as you can imagine is a bit difficult to do compactly on 6502. Double-hires is even crazier on top of that. Deater did manage a color-bar style effect in double-hires in 128B but that was doing some crazy tricks with the firmware BASIC routines, definitely not direct-access.<br />
<br />
Lores and Hires can be mixed modes and full-graphics<br />
The screen structure is called memory holes(https://retrocomputing.stackexchange.com/questions/2534/what-are-the-screen-holes-in-apple-ii-graphics). The GBASCALC($F847) procedure is used to calculate the address of the horizontal line : IN:reg.A=Y, out : GBASL/GBASH($26/$27)=address. See also https://www.callapple.org/uncategorized/use-of-apple-ii-color-graphics-in-assembly-language/<br />
<br />
==== Getting something on screen ====<br />
Here is an example of a XOR texture, created by g0blinish<br />
<syntaxhighlight lang="6502"><br />
*=$6000<br />
!to "HL.bin", plain ; set output file and format<br />
!cpu 6502 ; set processor type<br />
<br />
GBASL = $26<br />
GBASH = $27<br />
SETGR = $FB40 ; setup LoRes<br />
GBASCALC = $F847 ; calc Address<br />
<br />
CLRTEXT = $C050 ;display graphics <br />
SETTEXT = $C051 ;display text <br />
<br />
CLRMIXED = $C052 ;clear mixed mode- enable full graphics <br />
SETMIXED = $C053 ;enable graphics/text mixed mode <br />
<br />
PAGE1 = $C054 ;select text/graphics page1 <br />
PAGE2 = $C055 ;select text/graphics page2 <br />
<br />
CLRHIRES = $C056 ;select Lo-res <br />
SETHIRES = $C057 ;select Hi-res <br />
<br />
TMP= $FA<br />
<br />
JSR SETGR ;GR<br />
BIT CLRMIXED ; full screen<br />
<br />
LDA #0 ; A=0<br />
STA TMP ; POKE $FA,A<br />
<br />
YLP ;<br />
LDA TMP ; A=PEEK($FA)<br />
; LSR ; A=A/2<br />
JSR GBASCALC<br />
LDY #0;Y=0<br />
<br />
XLP TYA ; A=Y<br />
EOR TMP ; A=A xor PEEK($FA)<br />
and #$0F ; A=A and 15<br />
TAX ; X=A<br />
LDA COLORS,X ;A=PEEK(COLORS+X)<br />
STA(GBASL),Y ; POKE PEEK($26)+256*PEEK($27)+Y,A<br />
INY ; Y=Y+1<br />
CPY #40 ; Y=40?<br />
BNE XLP<br />
INC TMP ; POKE $FA,PEEK($FA)+1<br />
LDA TMP ; A=PEEK($FA)<br />
CMP #24 ; A=24?<br />
BNE YLP<br />
<br />
M1 JMP M1 ; replace to RTS<br />
<br />
COLORS ;N*17, pixel format is AAAABBBB, AAAA - upper dot, BBBB - lower dot<br />
!byte $00,$11,$22,$33,$44,$55,$66,$77<br />
!byte $88,$99,$AA,$BB,$CC,$DD,$EE,$FF<br />
</syntaxhighlight><br />
<br />
==== Sound ====<br />
Here is an example for using the speaker, based onthe following basic program:<br />
<br />
<syntaxhighlight lang="basic"><br />
; 50 POKE 768,V: POKE 769,P - 255 * INT (P / 256): POKE 800,1 + P / 256<br />
; 60 CALL 770: RETURN <br />
; 95 FOR K = 1 TO N: READ V(K),P(K): NEXT K<br />
; 100 FOR K = 1 TO N:V = V(K):P = P(K)<br />
; 110 GOSUB 50<br />
;!byte 173,48,192,136,208,5,206,1,3,240,9,202,208,245,174,0,3,76,2,3,206,32,3,208,240,96<br />
</syntaxhighlight><br />
<br />
<syntaxhighlight lang="6502"><br />
*=$6000<br />
!to "HL.bin", plain ; set output file and format<br />
!cpu 6502 ; set processor type<br />
<br />
;start<br />
; 95 FOR K = 1 TO N: READ V(K),P(K): NEXT K<br />
; 100 FOR K = 1 TO N:V = V(K):P = P(K)<br />
ini:<br />
lda #70<br />
sta cnt+1<br />
lda #music&255<br />
sta gotbyte+1<br />
lda #music/256<br />
sta gotbyte+2<br />
<br />
lop:<br />
;V<br />
jsr gotbyte<br />
sta L300<br />
jsr gotbyte<br />
;P<br />
jsr gotbyte<br />
sta L301<br />
jsr gotbyte<br />
clc<br />
adc #1<br />
sta L320<br />
jsr beep<br />
<br />
dec cnt+1<br />
cnt lda #70<br />
bne lop<br />
; 110 GOSUB 50<br />
; 50 POKE 768,V: POKE 769,P - 255 * INT (P / 256): POKE 800,1 + P / 256<br />
; 60 CALL 770: RETURN <br />
jmp ini<br />
gotbyte<br />
lda music<br />
inc gotbyte+1<br />
bne noinch<br />
inc gotbyte+2<br />
noinch<br />
rts<br />
;!byte 173,48,192,136,208,5,206,1,3,240,9,202,208,245,174,0,3,76,2,3,206,32,3,208,240,96<br />
beep:<br />
ldy #1<br />
ldx #1<br />
loc_302:<br />
LDA $C030<br />
<br />
loc_305:<br />
DEY<br />
BNE loc_30D<br />
DEC L301<br />
loc_30B:<br />
BEQ loc_316<br />
<br />
loc_30D:<br />
DEX<br />
BNE loc_305<br />
LDX L300<br />
JMP loc_302<br />
loc_316:<br />
DEC L320<br />
BNE loc_30B<br />
RTS<br />
L301 !byte 0<br />
L300 !byte 0<br />
L320 !byte 0<br />
music<br />
!word 76,192,85,64,96,64,102,64,114,128,114,64,96,64,102,64,114,64,128,64<br />
!word 114,64,152,64,171,64,152,512,76,192,85,64,96,64,102,64,114,128,114,64<br />
!word 96,64,102,64,114,64,128,64,114,64,152,64,171,64,152,512,85,64,85,64<br />
!word 85,64,96,64,144,128,144,64,128,64,76,128,85,64,96,64,144,128,114,64<br />
!word 96,64,102,128,114,64,128,64,128,128,114,64,128,64,114,512,85,64,85,64<br />
!word 85,64,96,64,144,128,144,64,128,64,76,128,85,64,96,64,144,128,114,64<br />
!word 96,64,102,128,114,64,128,64,128,64,128,128,96,64,85,64,96,64,102,64,114,64,114,64<br />
</syntaxhighlight><br />
<br />
=== Additional Resources ===<br />
* Deater's page on Apple II sizecoding http://www.deater.net/weave/vmwprod/demos/sizecoding.html<br />
* Article on double hi-res http://www.battlestations.zone/2017/04/apple-ii-double-hi-res-from-ground-up.html<br />
* Applesoft Hi-Res Subroutines : http://hackzapple.org/scripts_php/index.php?menu=5&mod=ASM&sub=AAL&sub2=8112&PHPSESSID=f65fabfd0cdbf56b6bdc0ddac25117c6#a2<br />
<br />
== Atari Lynx ==<br />
The Atari Lynx consists of the 6502 with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Atari Lynx:<br />
<br />
* Assembler: -<br />
* Emulator(s): -<br />
<br />
=== Video display ===<br />
To be added soon.<br />
<br />
==== Getting something on screen ====<br />
To be added soon.<br />
<br />
<br />
=== Sound ===<br />
To be added soon.<br />
<br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Additional Resources ===<br />
Sizecoding resource for the Atari Lynx are sparse<br />
* 42Bastian's website (link to be added)</div>Wilhttp://www.sizecoding.org/index.php?title=6502&diff=82665022021-02-15T21:36:16Z<p>Wil: /* Video display */ added video modes</p>
<hr />
<div>== Introduction ==<br />
Wanting to start sizecoding on a 6502 platform in this day and age can be tough. <br />
<br />
[[File:6502.jpg|thumb]]<br />
<br />
So here is a bit of help to get you started:<br />
<br />
=== The 6502 processor ===<br />
The 6502 processor can be seen as the 8-bit micro ARM chip. <br />
It has only has 3 registers (Accumulator, X and Y registers) and a handful of instructions to work with.<br />
<br />
=== Adressing modes ===<br />
To be added.<br />
<br />
=== Zero page ===<br />
When using the 6502 for sizecoding, you'll mostly be working from zeropage<br />
<br />
=== General 6502 Resources ===<br />
* 6502.org http://www.6502.org/<br />
* 6502 instruction reference http://www.6502.org/tutorials/6502opcodes.html<br />
* 6502 books http://retro.hansotten.nl/6502-sbc/<br />
* 6502 Assembler tutorial https://dwheeler.com/6502/oneelkruns/asm1step.html<br />
* Easy 6502 code tester https://skilldrick.github.io/easy6502/<br />
* Synthetic instructions https://wiki.nesdev.com/w/index.php/Synthetic_instructions#8-bit_rotate<br />
<br />
== Atari 8-bit family ==<br />
The systems in this family are: Atari 400, 800, 5200, 1200XL, 600XL, 800XL, 130XE, 65XE, 800XE and XEGS.<br /><br />
<br />
The Atari 8-bit systems consists of the 6502 with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Atari 8bit systems is quite easy, first get the following tools:<br />
<br />
* Assembler: MADS Assembler - This assembler has nice macros for creating Binaries and SNA snapshot files out of the box. You can download it at https://mads.atari8.info/<br />
* Emulator(s): I Found Altirra to work best for my usecase. Make sure to use the original Rev2 rom for best compatibility.<br />
<br />
==== Special Memory Adresses ====<br />
* FRAMECOUNTER_HIGH = 19<br />
* FRAMECOUNTER_LOW = 20<br />
<br />
=== Video display ===<br />
Video display on the Atari 8bit systems use the ANTIC and GTIA chips. Information can be found here:<br />
* https://en.wikipedia.org/wiki/ANTIC<br />
* https://www.atariarchives.org/agagd/chapter1.php<br />
<br />
==== Sync with frame ====<br />
<syntaxhighlight lang="6502"><br />
RTCLOK equ $0012<br />
lda RTCLOK+2<br />
waits<br />
cmp RTCLOK+2<br />
beq waits<br />
</syntaxhighlight><br />
<br />
Or if you don't mind trashing RTCLOK<br />
<br />
<syntaxhighlight lang="6502"><br />
RTCLOK equ $0012<br />
waits<br />
lsr RTCLOK+2<br />
bcc waits<br />
</syntaxhighlight><br />
<br />
Which is two bytes shorter.<br />
<br />
==== Getting something on screen ====<br />
<syntaxhighlight lang="6502"><br />
;fill screen with charset,(88,89)=an address<br />
org $600; free 6th page:600-6ff<br />
ldy #0<br />
fl: tya<br />
sta(88),y<br />
iny<br />
bne fl<br />
jmp *<br />
</syntaxhighlight><br />
<br />
To be added soon.<br />
<br />
<syntaxhighlight lang="6502"><br />
SDMCTL = $022f<br />
HPOSP0 = $d000<br />
SIZEP0 = $d008<br />
GRAFP0 = $d00d<br />
COLPM0 = $d012<br />
<br />
FRAMECOUNTER_HIGH = 19<br />
FRAMECOUNTER = 20<br />
WSYNC = $d40a<br />
VCOUNT = $d40b<br />
<br />
sinewave = $0600 ; to $06ff<br />
<br />
org $80<br />
<br />
main <br />
; disable all graphics/colors<br />
ldx #0<br />
stx SDMCTL <br />
<br />
ldy #$7f<br />
sty SIZEP0 ; size p0=127<br />
<br />
ldx #0<br />
ldy #$3f<br />
make_sine:<br />
value_lo<br />
lda #0<br />
clc<br />
delta_lo<br />
adc #0<br />
sta value_lo+1<br />
value_hi<br />
lda #0<br />
delta_hi<br />
adc #0<br />
sta value_hi+1<br />
<br />
sta sinewave+$c0,x<br />
sta sinewave+$80,y<br />
eor #$7f<br />
sta sinewave+$40,x<br />
sta sinewave+$00,y<br />
<br />
lda delta_lo+1<br />
adc #8<br />
sta delta_lo+1<br />
bcc nothing<br />
inc delta_hi+1<br />
nothing<br />
inx<br />
dey<br />
bpl make_sine<br />
<br />
updateloop:<br />
; vblank<br />
lda VCOUNT<br />
bne updateloop<br />
<br />
; clear graphics<br />
sta HPOSP0<br />
sta GRAFP0<br />
<br />
ldy #0<br />
lda #47<br />
sta COLPM0<br />
yloop:<br />
tya ; graphics shape = y<br />
sta WSYNC<br />
sta GRAFP0<br />
<br />
; a = sin(frame+y)+48<br />
tya <br />
adc FRAMECOUNTER<br />
tax<br />
lda sinewave,x<br />
adc #48<br />
sta HPOSP0<br />
<br />
iny<br />
bne yloop<br />
jmp updateloop<br />
<br />
run main<br />
</syntaxhighlight><br />
<br />
=== Sound ===<br />
The Atari 8-bit use the POKEY chip to generate sound.<br />
* https://en.wikipedia.org/wiki/POKEY<br />
<br />
==== BASIC ====<br />
<syntaxhighlight lang="6502"><br />
; from Analog, 1985-09,pp.25-32<br />
*=$2000<br />
AUDF1=$D200<br />
AUDC1=$D201<br />
AUDCTL=$D208<br />
SKCTL=$D20F<br />
<br />
.MACRO SOUND ; voice,pitch,dist,vol;,dur<br />
lda #%2<br />
sta AUDF1+2*%1<br />
lda #[[%3 * 16] | %4] ;lda #[[%3 shl 4] or %4]<br />
sta AUDC1+2*%1<br />
.ENDM<br />
<br />
lda #0<br />
sta AUDCTL<br />
lda #3<br />
sta SKCTL<br />
<br />
SOUND 0,121,10,8<br />
<br />
jmp *<br />
</syntaxhighlight><br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Additional Resources ===<br />
Sizecoding resource for the Atari 8bit are:<br />
* Mapping the Atari https://www.atariarchives.org/mapping/<br />
* Atari 8bit Memory map https://www.atariarchives.org/mapping/memorymap.php<br />
* Fready's undocumented 6502 opcodes https://github.com/FreddyOffenga/6502<br />
* Atari OS Rev2 disassembly for MADS assembler https://github.com/ilmenit/A800-OS-XL-Rev2<br />
* Fready's github https://github.com/FreddyOffenga/<br />
<br />
== Commodore 64 ==<br />
The Commodore system consists of a 6502-compatible MOS 6510 processor with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Commodore systems is quite easy, first get the following tools:<br />
<br />
* Assembler: To be added<br />
* Emulator(s): VICE is the way to go<br />
<br />
=== Memory map ===<br />
<br />
<syntaxhighlight lang="6502"><br />
0-1 $0-$1 PROCESSOR PORT REGISTERS, not usable as RAM<br />
0-255 $0-$FF ZEROPAGE, mostly used by BASIC interpreter and Kernal<br />
256-511 $100-$1FF SYSTEM STACK<br />
512-600 $200-$258 INPUT BUFFER<br />
601-630 $259-$276 FILE SYSTEM DATA<br />
631-640 $277-$280 KEYBOARD BUFFER, filled by Kernal ISR upon key presses <br />
641-678 $281-$2A6 VARIOUS KERNAL VARIABLES<br />
679-767 $2A7-$2FF Unused (89 byte)<br />
768-779 $300-$30B KERNAL VECTORS<br />
780-783 $30C-$30F REGISTER VALUES A,X,Y,SR for SYS<br />
784-819 $310-$333 KERNAL VECTORS<br />
820-827 $334-$33B Unused (8 byte)<br />
828-1019 $33C-$3FB DATASETTE BUFFER<br />
1020-1023 $3FC-$3FF Unused (4 byte)<br />
1024-2023 $400-$7E7 SCREEN MEMORY (25 lines times 40 columns)<br />
2024-2039 $7E8-$7F7 Unused (16 byte)<br />
2040-2047 $7F8-$7FF SPRITE COSTUME POINTERS<br />
2048 $800 must contain a value of 0 so that the BASIC program can be RUN<br />
2049-40959 $801-$9FFF BASIC AREA (code, variables, arrays, strings)<br />
40960-49151 $A000-$BFFF BASIC ROM (unused RAM underneath)<br />
49152-53247 $C000-$CFFF UPPER RAM AREA (unused)<br />
53248-53294 $D000-$D02E VIC-II, memory-mapped graphics chip registers)<br />
54272-54300 $D400-$D41C SID, memory-mapped sound chip registers)<br />
55296-56295 $D800-$DBE7 Color RAM, only lower 4 bits are stored, higher nibble undefined<br />
56296-56319 $DBE8-$DBFF Unused (24 half-bytes)<br />
56320-56335 $DC00-$DC0F CIA#1, memory-mapped I/O chip registers for keyboard, joystick, mouse, datasette, IRQ control<br />
56576-56591 $DD00-$DD0F CIA#1, memory-mapped I/O chip registers for serial bus, RS232, NMI control<br />
57344-65535 $E000-$FFFF KERNAL ROM<br />
65534-65535 $FFFE-$FFFF Execution address of interrupt service routine, can only be set if KERNAL is turned off<br />
</syntaxhighlight><br />
<br />
For a detailed explanation of the C64 memory map check out [https://sta.c64.org/cbm64mem.html Commodore 64 memory map] on Joe Forster/STA homepage.<br />
<br />
=== Program file overhead ===<br />
<br />
A standard CBM file consists of a 2 byte loading address followed by the data that is placed into memory starting at this address. In addition, if your machine program should be able to be started with "RUN", you need a BASIC stub that is loaded into memory from $0801 to $080c, typically followed by your machine program:<br />
<br />
<syntaxhighlight lang="6502"><br />
*=$0801<br />
.word $080b ;address of next BASIC line<br />
.word LINENR ;line number, can be chosen between 0 and 63999<br />
.byte $9e ;token for SYS command<br />
.byte $32,$30,$36,$31 ;address to jump to in ASCII code: "2061" <br />
.byte $00 ;end of BASIC line<br />
.word $0000 ;address of next BASIC line, $0000 means end of BASIC program <br />
start<br />
; your code here<br />
</syntaxhighlight><br />
<br />
Together with the 2 byte load address, this makes an overhead of 14 byte for your program. To reduce this, you can<br />
* omit the BASIC line and tell users to start your program by directly entering "SYS ''address''"<br />
* save your program from $0802 on, the byte at $0801 is recovered automatically after loading by the relink function. This reduces your program file size by 1 byte<br />
* accept the loss and use the 2 byte establishing LINENR for something good, they are copied to zeropage addresses $39/$3a automatically, saving you the effort of initializing the addresses<br />
* use an autostart method (see below)<br />
<br />
Some compos also specify that the BASIC loader does not count towards the overall filesize, check the rules before you worry.<br />
<br />
=== Autostart ===<br />
<br />
Unlike the Commodore 128, the Commodore 64 has no dedicated built-in auto-boot feature, but it is possible to autorun a program after loading by specifying the load address so that it overwrites a vector or address that is called by the operating system. There are multiple possibilities:<br />
<br />
==== Overwriting CHROUT vector at $326-$327 ====<br />
<br />
The vector at address $326-$327 points at the CHROUT routine, normally at address $F1CA.<br />
If you put the entry address of your program into $326/27, your code will be called when the operating system wants to print "READY." after loading.<br />
Note that the vector at address $328-$329 points at the STOP routine that checks the status of Stop key indicator. Since this routine is called multiple times before your code is done loading, its default value $F6ED needs to be preserved. <br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$0326<br />
.word start <br />
.byte $ed,$f6<br />
start<br />
; rest of code<br />
</syntaxhighlight><br />
<br />
Together with the two byte load address, the overwritten CHROUT vector and the preserved STOP vector, your program file will have a deadweight of 6 byte: $26 $03 $0a $03 $ed $f6, less than half of the standard version with a BASIC stub with SYS<br />
<br />
Caveat:<br />
* If your program after $32a is longer than 214 byte, part of your program will load into the screen at $400. Thus, issuing a clear screen will overwrite your program. It is possible to move the screen memory somewhere else, but that requires storing a new value into address $D018, which when done with an LDA # / STA pair will cost you 5 byte<br />
* Since you changed the CHROUT pointer, standard KERNAL functions for printing won't work. For output of single characters, you can still use the direct address $F1CA. Alternatively, you can restore the vectors by calling $FD15, which will overwrite the memory $314 to $333 with the default values.<br />
<br />
=== Video display ===<br />
Video display on the Commodore has the following video modes:<br />
* Standard text mode, 40x25 characters, 1 individual color per character, 1 common background color<br />
* Multicolor text mode, 40x25 characters, every two bits (fat pixel) define color: background, char, common color 1+2<br />
* Extended color text mode, 40x25 characters, 1 individual foreground color per character, 1 out of 4 background colors, only 64 chars<br />
* Hires bitmap, 320x200 pixels, an 8x8 field can have an individual foreground and an individual background color<br />
* Multicolor bitmap, 160x200 pixels, every two bits (fat pixel) define color: background, screen color lower nibble, screen color higher nibble, color from color RAM<br />
<br />
==== Getting something on screen ====<br />
<br />
Output a character:<br />
<syntaxhighlight lang="6502"><br />
lda #C ;C must be the char code according to the PETSCII code table<br />
jsr $FFD2 ;you can also use the direct address $FC1A, function preserves A,X,Y and enables interrupt<br />
</syntaxhighlight><br />
<br />
Since the [https://en.wikipedia.org/wiki/PETSCII#Character_set PETSCII code table] contains also control characters, this method can be also used to clear the screen, move the cursor or set the text color. However, some functions are shorter (and faster) by directly calling the respective KERNAL function:<br />
<br />
<syntaxhighlight lang="6502"><br />
Clear screen JSR $E544<br />
Cursor home position JSR $E566<br />
Output newline character JSR $AAD7<br />
Set text color LDA #COLOR, STA $286<br />
Set border color LDA #COLOR, STA $D020 ;not possible with a PETSCII control code<br />
Set background color LDA #COLOR, STA $D021 ;not possible with a PETSCII control code<br />
</syntaxhighlight><br />
<br />
Copy characters directly to screen memory:<br />
<br />
<syntaxhighlight lang="6502"><br />
.macpack cbm ;scrcode macro<br />
SCREEN_BASE=$400<br />
LINE=5 ;for example<br />
COLUMN=10 ;for example<br />
<br />
ldx #endtext-text-1<br />
@loop: lda text,x<br />
sta SCREEN_BASE+LINE*40+COLUMN,x<br />
dex<br />
bpl @loop<br />
text: scrcode "hello world!"<br />
endtext:<br />
</syntaxhighlight><br />
<br />
Note that the text needs to be stored in '''screen code''' format, not in PETSCII (see [https://sta.c64.org/cbm64pettoscr.html Commodore 64 PETSCII code to screen code conversion] for the differences). Furthermore, the example above only writes to the screen memory, not the color RAM, assuming that the color RAM already contains the intended text color. This is the case after issuing a clear screen on most C64 machines, except for some old ROM revisions. To be on the save side you would have to write to color RAM as well, which costs another 5 byte:<br />
<br />
<syntaxhighlight lang="6502"><br />
.macpack cbm ;scrcode macro<br />
SCREEN_BASE=$400<br />
COLOR_RAM =$D800<br />
LINE =5 ;for example<br />
COLUMN =10 ;for example<br />
COLOR =1 ;white<br />
<br />
ldx #endtext-text-1<br />
@loop: lda text,x<br />
sta SCREEN_BASE+LINE*40+COLUMN,x<br />
lda #COLOR<br />
sta COLOR_RAM +LINE*40+COLUMN,x<br />
dex<br />
bpl @loop<br />
text: scrcode "hello world!"<br />
endtext:<br />
</syntaxhighlight><br />
<br />
=== Sound ===<br />
The Commodore 64 uses the famous SID chip to generate sound.<br />
To be added soon.<br />
<br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Useful Kernal functions ===<br />
<br />
==== Get a pseudo random number ====<br />
<br />
<syntaxhighlight lang="6502"><br />
lda #1 <br />
jsr $E09A<br />
lda $63<br />
</syntaxhighlight><br />
<br />
The sequence of random numbers is always the same after a cold start or reset, the first 20 numbers are:<br />
<syntaxhighlight lang="6502"><br />
4,24,231,4,177,170,193,101,231,18,196,1,75,48,149,36,124,53,65,154<br />
</syntaxhighlight><br />
<br />
==== Increment a zero page counter, return in X register, clear Y register ====<br />
<br />
This is part of the string handling function in the BASIC ROM, but the code could be useful for some loop stuff.<br />
<br />
<syntaxhighlight lang="6502"><br />
jsr $B5FF ;does a inc $23, ldx $23, ldy #$00, rts<br />
</syntaxhighlight><br />
<br />
=== Additional Resources ===<br />
* Codebase 64 https://codebase64.org/doku.php?id=base:start<br />
* Commodore 64 Memory map https://sta.c64.org/cbm64mem.html<br />
* C64 BASIC & KERNAL ROM Disassembly https://www.pagetable.com/c64ref/c64disasm/<br />
<br />
== Apple II ==<br />
The Apple II is an 8-bit home computer and one of the world's first highly successful mass-produced microcomputer products. It was designed primarily by Steve Wozniak.<br />
<br />
=== Setting up ===<br />
* ACME 6502 cross-assembler(https://sourceforge.net/projects/acme-crossass/)<br />
* Apple Commander (http://applecommander.sourceforge.net) for batch compilation<br />
* AppleWin emulator (https://github.com/AppleWin/AppleWin/releases). Supports Mockingboard card(AY-8910+speech synthesier), HDD, Z80 card(for CP/M), mouse etc.<br />
* CiderPress(https://a2ciderpress.com)<br />
<br />
Compilation can be done as follows (master.dsk can be found with applewin) <br />
<syntaxhighlight><br />
acme hl.asm<br />
java -jar AppleCommander-1.3.5.jar -d master.dsk hl<br />
java -jar AppleCommander-1.3.5.jar -p master.dsk hl B 24576 < hl.bin<br />
</syntaxhighlight><br />
<br />
=== Memory Map ===<br />
<syntaxhighlight lang="6502"><br />
0-255 $0-$FF ZERO-PAGE SYSTEM STORAGE<br />
256-511 $100-$1FF SYSTEM STACK<br />
512-767 $200-$2FF KEYBOARD CHARACTER BUFFER<br />
768-975 $300-$3CF OFTEN AVAILABLE AS FREE SPACE FOR USER PROGRAMS<br />
976-1023 $3D0-3FF SYSTEM VECTORS<br />
1024-2047 $400-$7FF TEXT AND LO-RES GRAPHICS PAGE 1 <--- !!!<br />
2048-LOMEM $800-LOMEM PROGRAM STORAGE<br />
2048-3071 $800-$BFF TEXT AND LO-RES GRAPHICS PAGE 2 OR FREE SPACE<br />
3072-8191 $C00-$1FFF FREE SPACE UNLESS RAM APPLESOFT IS IN USE<br />
8192-16383 $2000-$3FFF HI-RES PAGE 1 OR FREE SPACE <--- !!!<br />
16384-24575 $4000-$5FFF HI-RES PAGE 2 OR FREE SPACE<br />
24576-38999 $6000-$95FF FREE SPACE AND STRING STORAGE<br />
38400-49151 $9600-$BFFF DOS<br />
49152-53247 $C000-$CFFF I/O HARDWARE (RESERVED)<br />
53248-57343 $D000-$DFFF APPLESOFT IN LANGUAGE CARD OR ROM<br />
57344-63487 $E000-$F7FF APPLESOFT OR INTEGER BASIC IN LANGUAGE CARD OR ROM<br />
63488-65535 $F800-$FFFF SYSTEM MONITOR<br />
</syntaxhighlight><br />
<br />
=== Display ===<br />
<br />
=== Graphics Modes ===<br />
: Text Mode 40x24, for Apple IIe available 80x25 - use PR#3 for switch mode, or hardware switch<br />
: LowRes 40x48, 16 colors: https://en.wikipedia.org/wiki/Apple_II_graphics <br />
: Hires mode 280x192,6 colors: https://www.xtof.info/blog/?p=768<br />
https://mrob.com/pub/xapple2/colors.html<br />
https://archive.org/details/HiRes_Color_Graphics_on_the_Apple_II_Computer_by_Wozniak<br />
<br />
However for sizecoding, you almost never want to do direct-access to graphics for Apple II in size-coding because the Apple II graphics modes are horrible. The only fast way to do things is with large lookup tables. To do hires you need to divide by 7 which as you can imagine is a bit difficult to do compactly on 6502. Double-hires is even crazier on top of that. Deater did manage a color-bar style effect in double-hires in 128B but that was doing some crazy tricks with the firmware BASIC routines, definitely not direct-access.<br />
<br />
Lores and Hires can be mixed modes and full-graphics<br />
The screen structure is called memory holes(https://retrocomputing.stackexchange.com/questions/2534/what-are-the-screen-holes-in-apple-ii-graphics). The GBASCALC($F847) procedure is used to calculate the address of the horizontal line : IN:reg.A=Y, out : GBASL/GBASH($26/$27)=address. See also https://www.callapple.org/uncategorized/use-of-apple-ii-color-graphics-in-assembly-language/<br />
<br />
==== Getting something on screen ====<br />
Here is an example of a XOR texture, created by g0blinish<br />
<syntaxhighlight lang="6502"><br />
*=$6000<br />
!to "HL.bin", plain ; set output file and format<br />
!cpu 6502 ; set processor type<br />
<br />
GBASL = $26<br />
GBASH = $27<br />
SETGR = $FB40 ; setup LoRes<br />
GBASCALC = $F847 ; calc Address<br />
<br />
CLRTEXT = $C050 ;display graphics <br />
SETTEXT = $C051 ;display text <br />
<br />
CLRMIXED = $C052 ;clear mixed mode- enable full graphics <br />
SETMIXED = $C053 ;enable graphics/text mixed mode <br />
<br />
PAGE1 = $C054 ;select text/graphics page1 <br />
PAGE2 = $C055 ;select text/graphics page2 <br />
<br />
CLRHIRES = $C056 ;select Lo-res <br />
SETHIRES = $C057 ;select Hi-res <br />
<br />
TMP= $FA<br />
<br />
JSR SETGR ;GR<br />
BIT CLRMIXED ; full screen<br />
<br />
LDA #0 ; A=0<br />
STA TMP ; POKE $FA,A<br />
<br />
YLP ;<br />
LDA TMP ; A=PEEK($FA)<br />
; LSR ; A=A/2<br />
JSR GBASCALC<br />
LDY #0;Y=0<br />
<br />
XLP TYA ; A=Y<br />
EOR TMP ; A=A xor PEEK($FA)<br />
and #$0F ; A=A and 15<br />
TAX ; X=A<br />
LDA COLORS,X ;A=PEEK(COLORS+X)<br />
STA(GBASL),Y ; POKE PEEK($26)+256*PEEK($27)+Y,A<br />
INY ; Y=Y+1<br />
CPY #40 ; Y=40?<br />
BNE XLP<br />
INC TMP ; POKE $FA,PEEK($FA)+1<br />
LDA TMP ; A=PEEK($FA)<br />
CMP #24 ; A=24?<br />
BNE YLP<br />
<br />
M1 JMP M1 ; replace to RTS<br />
<br />
COLORS ;N*17, pixel format is AAAABBBB, AAAA - upper dot, BBBB - lower dot<br />
!byte $00,$11,$22,$33,$44,$55,$66,$77<br />
!byte $88,$99,$AA,$BB,$CC,$DD,$EE,$FF<br />
</syntaxhighlight><br />
<br />
==== Sound ====<br />
Here is an example for using the speaker, based onthe following basic program:<br />
<br />
<syntaxhighlight lang="basic"><br />
; 50 POKE 768,V: POKE 769,P - 255 * INT (P / 256): POKE 800,1 + P / 256<br />
; 60 CALL 770: RETURN <br />
; 95 FOR K = 1 TO N: READ V(K),P(K): NEXT K<br />
; 100 FOR K = 1 TO N:V = V(K):P = P(K)<br />
; 110 GOSUB 50<br />
;!byte 173,48,192,136,208,5,206,1,3,240,9,202,208,245,174,0,3,76,2,3,206,32,3,208,240,96<br />
</syntaxhighlight><br />
<br />
<syntaxhighlight lang="6502"><br />
*=$6000<br />
!to "HL.bin", plain ; set output file and format<br />
!cpu 6502 ; set processor type<br />
<br />
;start<br />
; 95 FOR K = 1 TO N: READ V(K),P(K): NEXT K<br />
; 100 FOR K = 1 TO N:V = V(K):P = P(K)<br />
ini:<br />
lda #70<br />
sta cnt+1<br />
lda #music&255<br />
sta gotbyte+1<br />
lda #music/256<br />
sta gotbyte+2<br />
<br />
lop:<br />
;V<br />
jsr gotbyte<br />
sta L300<br />
jsr gotbyte<br />
;P<br />
jsr gotbyte<br />
sta L301<br />
jsr gotbyte<br />
clc<br />
adc #1<br />
sta L320<br />
jsr beep<br />
<br />
dec cnt+1<br />
cnt lda #70<br />
bne lop<br />
; 110 GOSUB 50<br />
; 50 POKE 768,V: POKE 769,P - 255 * INT (P / 256): POKE 800,1 + P / 256<br />
; 60 CALL 770: RETURN <br />
jmp ini<br />
gotbyte<br />
lda music<br />
inc gotbyte+1<br />
bne noinch<br />
inc gotbyte+2<br />
noinch<br />
rts<br />
;!byte 173,48,192,136,208,5,206,1,3,240,9,202,208,245,174,0,3,76,2,3,206,32,3,208,240,96<br />
beep:<br />
ldy #1<br />
ldx #1<br />
loc_302:<br />
LDA $C030<br />
<br />
loc_305:<br />
DEY<br />
BNE loc_30D<br />
DEC L301<br />
loc_30B:<br />
BEQ loc_316<br />
<br />
loc_30D:<br />
DEX<br />
BNE loc_305<br />
LDX L300<br />
JMP loc_302<br />
loc_316:<br />
DEC L320<br />
BNE loc_30B<br />
RTS<br />
L301 !byte 0<br />
L300 !byte 0<br />
L320 !byte 0<br />
music<br />
!word 76,192,85,64,96,64,102,64,114,128,114,64,96,64,102,64,114,64,128,64<br />
!word 114,64,152,64,171,64,152,512,76,192,85,64,96,64,102,64,114,128,114,64<br />
!word 96,64,102,64,114,64,128,64,114,64,152,64,171,64,152,512,85,64,85,64<br />
!word 85,64,96,64,144,128,144,64,128,64,76,128,85,64,96,64,144,128,114,64<br />
!word 96,64,102,128,114,64,128,64,128,128,114,64,128,64,114,512,85,64,85,64<br />
!word 85,64,96,64,144,128,144,64,128,64,76,128,85,64,96,64,144,128,114,64<br />
!word 96,64,102,128,114,64,128,64,128,64,128,128,96,64,85,64,96,64,102,64,114,64,114,64<br />
</syntaxhighlight><br />
<br />
=== Additional Resources ===<br />
* Deater's page on Apple II sizecoding http://www.deater.net/weave/vmwprod/demos/sizecoding.html<br />
* Article on double hi-res http://www.battlestations.zone/2017/04/apple-ii-double-hi-res-from-ground-up.html<br />
* Applesoft Hi-Res Subroutines : http://hackzapple.org/scripts_php/index.php?menu=5&mod=ASM&sub=AAL&sub2=8112&PHPSESSID=f65fabfd0cdbf56b6bdc0ddac25117c6#a2<br />
<br />
== Atari Lynx ==<br />
The Atari Lynx consists of the 6502 with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Atari Lynx:<br />
<br />
* Assembler: -<br />
* Emulator(s): -<br />
<br />
=== Video display ===<br />
To be added soon.<br />
<br />
==== Getting something on screen ====<br />
To be added soon.<br />
<br />
<br />
=== Sound ===<br />
To be added soon.<br />
<br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Additional Resources ===<br />
Sizecoding resource for the Atari Lynx are sparse<br />
* 42Bastian's website (link to be added)</div>Wilhttp://www.sizecoding.org/index.php?title=6502&diff=82565022021-02-15T21:26:51Z<p>Wil: added links to memory map and to ROM disassembly</p>
<hr />
<div>== Introduction ==<br />
Wanting to start sizecoding on a 6502 platform in this day and age can be tough. <br />
<br />
[[File:6502.jpg|thumb]]<br />
<br />
So here is a bit of help to get you started:<br />
<br />
=== The 6502 processor ===<br />
The 6502 processor can be seen as the 8-bit micro ARM chip. <br />
It has only has 3 registers (Accumulator, X and Y registers) and a handful of instructions to work with.<br />
<br />
=== Adressing modes ===<br />
To be added.<br />
<br />
=== Zero page ===<br />
When using the 6502 for sizecoding, you'll mostly be working from zeropage<br />
<br />
=== General 6502 Resources ===<br />
* 6502.org http://www.6502.org/<br />
* 6502 instruction reference http://www.6502.org/tutorials/6502opcodes.html<br />
* 6502 books http://retro.hansotten.nl/6502-sbc/<br />
* 6502 Assembler tutorial https://dwheeler.com/6502/oneelkruns/asm1step.html<br />
* Easy 6502 code tester https://skilldrick.github.io/easy6502/<br />
* Synthetic instructions https://wiki.nesdev.com/w/index.php/Synthetic_instructions#8-bit_rotate<br />
<br />
== Atari 8-bit family ==<br />
The systems in this family are: Atari 400, 800, 5200, 1200XL, 600XL, 800XL, 130XE, 65XE, 800XE and XEGS.<br /><br />
<br />
The Atari 8-bit systems consists of the 6502 with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Atari 8bit systems is quite easy, first get the following tools:<br />
<br />
* Assembler: MADS Assembler - This assembler has nice macros for creating Binaries and SNA snapshot files out of the box. You can download it at https://mads.atari8.info/<br />
* Emulator(s): I Found Altirra to work best for my usecase. Make sure to use the original Rev2 rom for best compatibility.<br />
<br />
==== Special Memory Adresses ====<br />
* FRAMECOUNTER_HIGH = 19<br />
* FRAMECOUNTER_LOW = 20<br />
<br />
=== Video display ===<br />
Video display on the Atari 8bit systems use the ANTIC and GTIA chips. Information can be found here:<br />
* https://en.wikipedia.org/wiki/ANTIC<br />
* https://www.atariarchives.org/agagd/chapter1.php<br />
<br />
==== Sync with frame ====<br />
<syntaxhighlight lang="6502"><br />
RTCLOK equ $0012<br />
lda RTCLOK+2<br />
waits<br />
cmp RTCLOK+2<br />
beq waits<br />
</syntaxhighlight><br />
<br />
Or if you don't mind trashing RTCLOK<br />
<br />
<syntaxhighlight lang="6502"><br />
RTCLOK equ $0012<br />
waits<br />
lsr RTCLOK+2<br />
bcc waits<br />
</syntaxhighlight><br />
<br />
Which is two bytes shorter.<br />
<br />
==== Getting something on screen ====<br />
<syntaxhighlight lang="6502"><br />
;fill screen with charset,(88,89)=an address<br />
org $600; free 6th page:600-6ff<br />
ldy #0<br />
fl: tya<br />
sta(88),y<br />
iny<br />
bne fl<br />
jmp *<br />
</syntaxhighlight><br />
<br />
To be added soon.<br />
<br />
<syntaxhighlight lang="6502"><br />
SDMCTL = $022f<br />
HPOSP0 = $d000<br />
SIZEP0 = $d008<br />
GRAFP0 = $d00d<br />
COLPM0 = $d012<br />
<br />
FRAMECOUNTER_HIGH = 19<br />
FRAMECOUNTER = 20<br />
WSYNC = $d40a<br />
VCOUNT = $d40b<br />
<br />
sinewave = $0600 ; to $06ff<br />
<br />
org $80<br />
<br />
main <br />
; disable all graphics/colors<br />
ldx #0<br />
stx SDMCTL <br />
<br />
ldy #$7f<br />
sty SIZEP0 ; size p0=127<br />
<br />
ldx #0<br />
ldy #$3f<br />
make_sine:<br />
value_lo<br />
lda #0<br />
clc<br />
delta_lo<br />
adc #0<br />
sta value_lo+1<br />
value_hi<br />
lda #0<br />
delta_hi<br />
adc #0<br />
sta value_hi+1<br />
<br />
sta sinewave+$c0,x<br />
sta sinewave+$80,y<br />
eor #$7f<br />
sta sinewave+$40,x<br />
sta sinewave+$00,y<br />
<br />
lda delta_lo+1<br />
adc #8<br />
sta delta_lo+1<br />
bcc nothing<br />
inc delta_hi+1<br />
nothing<br />
inx<br />
dey<br />
bpl make_sine<br />
<br />
updateloop:<br />
; vblank<br />
lda VCOUNT<br />
bne updateloop<br />
<br />
; clear graphics<br />
sta HPOSP0<br />
sta GRAFP0<br />
<br />
ldy #0<br />
lda #47<br />
sta COLPM0<br />
yloop:<br />
tya ; graphics shape = y<br />
sta WSYNC<br />
sta GRAFP0<br />
<br />
; a = sin(frame+y)+48<br />
tya <br />
adc FRAMECOUNTER<br />
tax<br />
lda sinewave,x<br />
adc #48<br />
sta HPOSP0<br />
<br />
iny<br />
bne yloop<br />
jmp updateloop<br />
<br />
run main<br />
</syntaxhighlight><br />
<br />
=== Sound ===<br />
The Atari 8-bit use the POKEY chip to generate sound.<br />
* https://en.wikipedia.org/wiki/POKEY<br />
<br />
==== BASIC ====<br />
<syntaxhighlight lang="6502"><br />
; from Analog, 1985-09,pp.25-32<br />
*=$2000<br />
AUDF1=$D200<br />
AUDC1=$D201<br />
AUDCTL=$D208<br />
SKCTL=$D20F<br />
<br />
.MACRO SOUND ; voice,pitch,dist,vol;,dur<br />
lda #%2<br />
sta AUDF1+2*%1<br />
lda #[[%3 * 16] | %4] ;lda #[[%3 shl 4] or %4]<br />
sta AUDC1+2*%1<br />
.ENDM<br />
<br />
lda #0<br />
sta AUDCTL<br />
lda #3<br />
sta SKCTL<br />
<br />
SOUND 0,121,10,8<br />
<br />
jmp *<br />
</syntaxhighlight><br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Additional Resources ===<br />
Sizecoding resource for the Atari 8bit are:<br />
* Mapping the Atari https://www.atariarchives.org/mapping/<br />
* Atari 8bit Memory map https://www.atariarchives.org/mapping/memorymap.php<br />
* Fready's undocumented 6502 opcodes https://github.com/FreddyOffenga/6502<br />
* Atari OS Rev2 disassembly for MADS assembler https://github.com/ilmenit/A800-OS-XL-Rev2<br />
* Fready's github https://github.com/FreddyOffenga/<br />
<br />
== Commodore 64 ==<br />
The Commodore system consists of a 6502-compatible MOS 6510 processor with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Commodore systems is quite easy, first get the following tools:<br />
<br />
* Assembler: To be added<br />
* Emulator(s): VICE is the way to go<br />
<br />
=== Memory map ===<br />
<br />
<syntaxhighlight lang="6502"><br />
0-1 $0-$1 PROCESSOR PORT REGISTERS, not usable as RAM<br />
0-255 $0-$FF ZEROPAGE, mostly used by BASIC interpreter and Kernal<br />
256-511 $100-$1FF SYSTEM STACK<br />
512-600 $200-$258 INPUT BUFFER<br />
601-630 $259-$276 FILE SYSTEM DATA<br />
631-640 $277-$280 KEYBOARD BUFFER, filled by Kernal ISR upon key presses <br />
641-678 $281-$2A6 VARIOUS KERNAL VARIABLES<br />
679-767 $2A7-$2FF Unused (89 byte)<br />
768-779 $300-$30B KERNAL VECTORS<br />
780-783 $30C-$30F REGISTER VALUES A,X,Y,SR for SYS<br />
784-819 $310-$333 KERNAL VECTORS<br />
820-827 $334-$33B Unused (8 byte)<br />
828-1019 $33C-$3FB DATASETTE BUFFER<br />
1020-1023 $3FC-$3FF Unused (4 byte)<br />
1024-2023 $400-$7E7 SCREEN MEMORY (25 lines times 40 columns)<br />
2024-2039 $7E8-$7F7 Unused (16 byte)<br />
2040-2047 $7F8-$7FF SPRITE COSTUME POINTERS<br />
2048 $800 must contain a value of 0 so that the BASIC program can be RUN<br />
2049-40959 $801-$9FFF BASIC AREA (code, variables, arrays, strings)<br />
40960-49151 $A000-$BFFF BASIC ROM (unused RAM underneath)<br />
49152-53247 $C000-$CFFF UPPER RAM AREA (unused)<br />
53248-53294 $D000-$D02E VIC-II, memory-mapped graphics chip registers)<br />
54272-54300 $D400-$D41C SID, memory-mapped sound chip registers)<br />
55296-56295 $D800-$DBE7 Color RAM, only lower 4 bits are stored, higher nibble undefined<br />
56296-56319 $DBE8-$DBFF Unused (24 half-bytes)<br />
56320-56335 $DC00-$DC0F CIA#1, memory-mapped I/O chip registers for keyboard, joystick, mouse, datasette, IRQ control<br />
56576-56591 $DD00-$DD0F CIA#1, memory-mapped I/O chip registers for serial bus, RS232, NMI control<br />
57344-65535 $E000-$FFFF KERNAL ROM<br />
65534-65535 $FFFE-$FFFF Execution address of interrupt service routine, can only be set if KERNAL is turned off<br />
</syntaxhighlight><br />
<br />
For a detailed explanation of the C64 memory map check out [https://sta.c64.org/cbm64mem.html Commodore 64 memory map] on Joe Forster/STA homepage.<br />
<br />
=== Program file overhead ===<br />
<br />
A standard CBM file consists of a 2 byte loading address followed by the data that is placed into memory starting at this address. In addition, if your machine program should be able to be started with "RUN", you need a BASIC stub that is loaded into memory from $0801 to $080c, typically followed by your machine program:<br />
<br />
<syntaxhighlight lang="6502"><br />
*=$0801<br />
.word $080b ;address of next BASIC line<br />
.word LINENR ;line number, can be chosen between 0 and 63999<br />
.byte $9e ;token for SYS command<br />
.byte $32,$30,$36,$31 ;address to jump to in ASCII code: "2061" <br />
.byte $00 ;end of BASIC line<br />
.word $0000 ;address of next BASIC line, $0000 means end of BASIC program <br />
start<br />
; your code here<br />
</syntaxhighlight><br />
<br />
Together with the 2 byte load address, this makes an overhead of 14 byte for your program. To reduce this, you can<br />
* omit the BASIC line and tell users to start your program by directly entering "SYS ''address''"<br />
* save your program from $0802 on, the byte at $0801 is recovered automatically after loading by the relink function. This reduces your program file size by 1 byte<br />
* accept the loss and use the 2 byte establishing LINENR for something good, they are copied to zeropage addresses $39/$3a automatically, saving you the effort of initializing the addresses<br />
* use an autostart method (see below)<br />
<br />
Some compos also specify that the BASIC loader does not count towards the overall filesize, check the rules before you worry.<br />
<br />
=== Autostart ===<br />
<br />
Unlike the Commodore 128, the Commodore 64 has no dedicated built-in auto-boot feature, but it is possible to autorun a program after loading by specifying the load address so that it overwrites a vector or address that is called by the operating system. There are multiple possibilities:<br />
<br />
==== Overwriting CHROUT vector at $326-$327 ====<br />
<br />
The vector at address $326-$327 points at the CHROUT routine, normally at address $F1CA.<br />
If you put the entry address of your program into $326/27, your code will be called when the operating system wants to print "READY." after loading.<br />
Note that the vector at address $328-$329 points at the STOP routine that checks the status of Stop key indicator. Since this routine is called multiple times before your code is done loading, its default value $F6ED needs to be preserved. <br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$0326<br />
.word start <br />
.byte $ed,$f6<br />
start<br />
; rest of code<br />
</syntaxhighlight><br />
<br />
Together with the two byte load address, the overwritten CHROUT vector and the preserved STOP vector, your program file will have a deadweight of 6 byte: $26 $03 $0a $03 $ed $f6, less than half of the standard version with a BASIC stub with SYS<br />
<br />
Caveat:<br />
* If your program after $32a is longer than 214 byte, part of your program will load into the screen at $400. Thus, issuing a clear screen will overwrite your program. It is possible to move the screen memory somewhere else, but that requires storing a new value into address $D018, which when done with an LDA # / STA pair will cost you 5 byte<br />
* Since you changed the CHROUT pointer, standard KERNAL functions for printing won't work. For output of single characters, you can still use the direct address $F1CA. Alternatively, you can restore the vectors by calling $FD15, which will overwrite the memory $314 to $333 with the default values.<br />
<br />
=== Video display ===<br />
Video display on the Commodore, it has the following video modes:<br />
<br />
To be added soon.<br />
<br />
==== Getting something on screen ====<br />
<br />
Output a character:<br />
<syntaxhighlight lang="6502"><br />
lda #C ;C must be the char code according to the PETSCII code table<br />
jsr $FFD2 ;you can also use the direct address $FC1A, function preserves A,X,Y and enables interrupt<br />
</syntaxhighlight><br />
<br />
Since the [https://en.wikipedia.org/wiki/PETSCII#Character_set PETSCII code table] contains also control characters, this method can be also used to clear the screen, move the cursor or set the text color. However, some functions are shorter (and faster) by directly calling the respective KERNAL function:<br />
<br />
<syntaxhighlight lang="6502"><br />
Clear screen JSR $E544<br />
Cursor home position JSR $E566<br />
Output newline character JSR $AAD7<br />
Set text color LDA #COLOR, STA $286<br />
Set border color LDA #COLOR, STA $D020 ;not possible with a PETSCII control code<br />
Set background color LDA #COLOR, STA $D021 ;not possible with a PETSCII control code<br />
</syntaxhighlight><br />
<br />
Copy characters directly to screen memory:<br />
<br />
<syntaxhighlight lang="6502"><br />
.macpack cbm ;scrcode macro<br />
SCREEN_BASE=$400<br />
LINE=5 ;for example<br />
COLUMN=10 ;for example<br />
<br />
ldx #endtext-text-1<br />
@loop: lda text,x<br />
sta SCREEN_BASE+LINE*40+COLUMN,x<br />
dex<br />
bpl @loop<br />
text: scrcode "hello world!"<br />
endtext:<br />
</syntaxhighlight><br />
<br />
Note that the text needs to be stored in '''screen code''' format, not in PETSCII (see [https://sta.c64.org/cbm64pettoscr.html Commodore 64 PETSCII code to screen code conversion] for the differences). Furthermore, the example above only writes to the screen memory, not the color RAM, assuming that the color RAM already contains the intended text color. This is the case after issuing a clear screen on most C64 machines, except for some old ROM revisions. To be on the save side you would have to write to color RAM as well, which costs another 5 byte:<br />
<br />
<syntaxhighlight lang="6502"><br />
.macpack cbm ;scrcode macro<br />
SCREEN_BASE=$400<br />
COLOR_RAM =$D800<br />
LINE =5 ;for example<br />
COLUMN =10 ;for example<br />
COLOR =1 ;white<br />
<br />
ldx #endtext-text-1<br />
@loop: lda text,x<br />
sta SCREEN_BASE+LINE*40+COLUMN,x<br />
lda #COLOR<br />
sta COLOR_RAM +LINE*40+COLUMN,x<br />
dex<br />
bpl @loop<br />
text: scrcode "hello world!"<br />
endtext:<br />
</syntaxhighlight><br />
<br />
=== Sound ===<br />
The Commodore 64 uses the famous SID chip to generate sound.<br />
To be added soon.<br />
<br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Useful Kernal functions ===<br />
<br />
==== Get a pseudo random number ====<br />
<br />
<syntaxhighlight lang="6502"><br />
lda #1 <br />
jsr $E09A<br />
lda $63<br />
</syntaxhighlight><br />
<br />
The sequence of random numbers is always the same after a cold start or reset, the first 20 numbers are:<br />
<syntaxhighlight lang="6502"><br />
4,24,231,4,177,170,193,101,231,18,196,1,75,48,149,36,124,53,65,154<br />
</syntaxhighlight><br />
<br />
==== Increment a zero page counter, return in X register, clear Y register ====<br />
<br />
This is part of the string handling function in the BASIC ROM, but the code could be useful for some loop stuff.<br />
<br />
<syntaxhighlight lang="6502"><br />
jsr $B5FF ;does a inc $23, ldx $23, ldy #$00, rts<br />
</syntaxhighlight><br />
<br />
=== Additional Resources ===<br />
* Codebase 64 https://codebase64.org/doku.php?id=base:start<br />
* Commodore 64 Memory map https://sta.c64.org/cbm64mem.html<br />
* C64 BASIC & KERNAL ROM Disassembly https://www.pagetable.com/c64ref/c64disasm/<br />
<br />
== Apple II ==<br />
The Apple II is an 8-bit home computer and one of the world's first highly successful mass-produced microcomputer products. It was designed primarily by Steve Wozniak.<br />
<br />
=== Setting up ===<br />
* ACME 6502 cross-assembler(https://sourceforge.net/projects/acme-crossass/)<br />
* Apple Commander (http://applecommander.sourceforge.net) for batch compilation<br />
* AppleWin emulator (https://github.com/AppleWin/AppleWin/releases). Supports Mockingboard card(AY-8910+speech synthesier), HDD, Z80 card(for CP/M), mouse etc.<br />
* CiderPress(https://a2ciderpress.com)<br />
<br />
Compilation can be done as follows (master.dsk can be found with applewin) <br />
<syntaxhighlight><br />
acme hl.asm<br />
java -jar AppleCommander-1.3.5.jar -d master.dsk hl<br />
java -jar AppleCommander-1.3.5.jar -p master.dsk hl B 24576 < hl.bin<br />
</syntaxhighlight><br />
<br />
=== Memory Map ===<br />
<syntaxhighlight lang="6502"><br />
0-255 $0-$FF ZERO-PAGE SYSTEM STORAGE<br />
256-511 $100-$1FF SYSTEM STACK<br />
512-767 $200-$2FF KEYBOARD CHARACTER BUFFER<br />
768-975 $300-$3CF OFTEN AVAILABLE AS FREE SPACE FOR USER PROGRAMS<br />
976-1023 $3D0-3FF SYSTEM VECTORS<br />
1024-2047 $400-$7FF TEXT AND LO-RES GRAPHICS PAGE 1 <--- !!!<br />
2048-LOMEM $800-LOMEM PROGRAM STORAGE<br />
2048-3071 $800-$BFF TEXT AND LO-RES GRAPHICS PAGE 2 OR FREE SPACE<br />
3072-8191 $C00-$1FFF FREE SPACE UNLESS RAM APPLESOFT IS IN USE<br />
8192-16383 $2000-$3FFF HI-RES PAGE 1 OR FREE SPACE <--- !!!<br />
16384-24575 $4000-$5FFF HI-RES PAGE 2 OR FREE SPACE<br />
24576-38999 $6000-$95FF FREE SPACE AND STRING STORAGE<br />
38400-49151 $9600-$BFFF DOS<br />
49152-53247 $C000-$CFFF I/O HARDWARE (RESERVED)<br />
53248-57343 $D000-$DFFF APPLESOFT IN LANGUAGE CARD OR ROM<br />
57344-63487 $E000-$F7FF APPLESOFT OR INTEGER BASIC IN LANGUAGE CARD OR ROM<br />
63488-65535 $F800-$FFFF SYSTEM MONITOR<br />
</syntaxhighlight><br />
<br />
=== Display ===<br />
<br />
=== Graphics Modes ===<br />
: Text Mode 40x24, for Apple IIe available 80x25 - use PR#3 for switch mode, or hardware switch<br />
: LowRes 40x48, 16 colors: https://en.wikipedia.org/wiki/Apple_II_graphics <br />
: Hires mode 280x192,6 colors: https://www.xtof.info/blog/?p=768<br />
https://mrob.com/pub/xapple2/colors.html<br />
https://archive.org/details/HiRes_Color_Graphics_on_the_Apple_II_Computer_by_Wozniak<br />
<br />
However for sizecoding, you almost never want to do direct-access to graphics for Apple II in size-coding because the Apple II graphics modes are horrible. The only fast way to do things is with large lookup tables. To do hires you need to divide by 7 which as you can imagine is a bit difficult to do compactly on 6502. Double-hires is even crazier on top of that. Deater did manage a color-bar style effect in double-hires in 128B but that was doing some crazy tricks with the firmware BASIC routines, definitely not direct-access.<br />
<br />
Lores and Hires can be mixed modes and full-graphics<br />
The screen structure is called memory holes(https://retrocomputing.stackexchange.com/questions/2534/what-are-the-screen-holes-in-apple-ii-graphics). The GBASCALC($F847) procedure is used to calculate the address of the horizontal line : IN:reg.A=Y, out : GBASL/GBASH($26/$27)=address. See also https://www.callapple.org/uncategorized/use-of-apple-ii-color-graphics-in-assembly-language/<br />
<br />
==== Getting something on screen ====<br />
Here is an example of a XOR texture, created by g0blinish<br />
<syntaxhighlight lang="6502"><br />
*=$6000<br />
!to "HL.bin", plain ; set output file and format<br />
!cpu 6502 ; set processor type<br />
<br />
GBASL = $26<br />
GBASH = $27<br />
SETGR = $FB40 ; setup LoRes<br />
GBASCALC = $F847 ; calc Address<br />
<br />
CLRTEXT = $C050 ;display graphics <br />
SETTEXT = $C051 ;display text <br />
<br />
CLRMIXED = $C052 ;clear mixed mode- enable full graphics <br />
SETMIXED = $C053 ;enable graphics/text mixed mode <br />
<br />
PAGE1 = $C054 ;select text/graphics page1 <br />
PAGE2 = $C055 ;select text/graphics page2 <br />
<br />
CLRHIRES = $C056 ;select Lo-res <br />
SETHIRES = $C057 ;select Hi-res <br />
<br />
TMP= $FA<br />
<br />
JSR SETGR ;GR<br />
BIT CLRMIXED ; full screen<br />
<br />
LDA #0 ; A=0<br />
STA TMP ; POKE $FA,A<br />
<br />
YLP ;<br />
LDA TMP ; A=PEEK($FA)<br />
; LSR ; A=A/2<br />
JSR GBASCALC<br />
LDY #0;Y=0<br />
<br />
XLP TYA ; A=Y<br />
EOR TMP ; A=A xor PEEK($FA)<br />
and #$0F ; A=A and 15<br />
TAX ; X=A<br />
LDA COLORS,X ;A=PEEK(COLORS+X)<br />
STA(GBASL),Y ; POKE PEEK($26)+256*PEEK($27)+Y,A<br />
INY ; Y=Y+1<br />
CPY #40 ; Y=40?<br />
BNE XLP<br />
INC TMP ; POKE $FA,PEEK($FA)+1<br />
LDA TMP ; A=PEEK($FA)<br />
CMP #24 ; A=24?<br />
BNE YLP<br />
<br />
M1 JMP M1 ; replace to RTS<br />
<br />
COLORS ;N*17, pixel format is AAAABBBB, AAAA - upper dot, BBBB - lower dot<br />
!byte $00,$11,$22,$33,$44,$55,$66,$77<br />
!byte $88,$99,$AA,$BB,$CC,$DD,$EE,$FF<br />
</syntaxhighlight><br />
<br />
==== Sound ====<br />
Here is an example for using the speaker, based onthe following basic program:<br />
<br />
<syntaxhighlight lang="basic"><br />
; 50 POKE 768,V: POKE 769,P - 255 * INT (P / 256): POKE 800,1 + P / 256<br />
; 60 CALL 770: RETURN <br />
; 95 FOR K = 1 TO N: READ V(K),P(K): NEXT K<br />
; 100 FOR K = 1 TO N:V = V(K):P = P(K)<br />
; 110 GOSUB 50<br />
;!byte 173,48,192,136,208,5,206,1,3,240,9,202,208,245,174,0,3,76,2,3,206,32,3,208,240,96<br />
</syntaxhighlight><br />
<br />
<syntaxhighlight lang="6502"><br />
*=$6000<br />
!to "HL.bin", plain ; set output file and format<br />
!cpu 6502 ; set processor type<br />
<br />
;start<br />
; 95 FOR K = 1 TO N: READ V(K),P(K): NEXT K<br />
; 100 FOR K = 1 TO N:V = V(K):P = P(K)<br />
ini:<br />
lda #70<br />
sta cnt+1<br />
lda #music&255<br />
sta gotbyte+1<br />
lda #music/256<br />
sta gotbyte+2<br />
<br />
lop:<br />
;V<br />
jsr gotbyte<br />
sta L300<br />
jsr gotbyte<br />
;P<br />
jsr gotbyte<br />
sta L301<br />
jsr gotbyte<br />
clc<br />
adc #1<br />
sta L320<br />
jsr beep<br />
<br />
dec cnt+1<br />
cnt lda #70<br />
bne lop<br />
; 110 GOSUB 50<br />
; 50 POKE 768,V: POKE 769,P - 255 * INT (P / 256): POKE 800,1 + P / 256<br />
; 60 CALL 770: RETURN <br />
jmp ini<br />
gotbyte<br />
lda music<br />
inc gotbyte+1<br />
bne noinch<br />
inc gotbyte+2<br />
noinch<br />
rts<br />
;!byte 173,48,192,136,208,5,206,1,3,240,9,202,208,245,174,0,3,76,2,3,206,32,3,208,240,96<br />
beep:<br />
ldy #1<br />
ldx #1<br />
loc_302:<br />
LDA $C030<br />
<br />
loc_305:<br />
DEY<br />
BNE loc_30D<br />
DEC L301<br />
loc_30B:<br />
BEQ loc_316<br />
<br />
loc_30D:<br />
DEX<br />
BNE loc_305<br />
LDX L300<br />
JMP loc_302<br />
loc_316:<br />
DEC L320<br />
BNE loc_30B<br />
RTS<br />
L301 !byte 0<br />
L300 !byte 0<br />
L320 !byte 0<br />
music<br />
!word 76,192,85,64,96,64,102,64,114,128,114,64,96,64,102,64,114,64,128,64<br />
!word 114,64,152,64,171,64,152,512,76,192,85,64,96,64,102,64,114,128,114,64<br />
!word 96,64,102,64,114,64,128,64,114,64,152,64,171,64,152,512,85,64,85,64<br />
!word 85,64,96,64,144,128,144,64,128,64,76,128,85,64,96,64,144,128,114,64<br />
!word 96,64,102,128,114,64,128,64,128,128,114,64,128,64,114,512,85,64,85,64<br />
!word 85,64,96,64,144,128,144,64,128,64,76,128,85,64,96,64,144,128,114,64<br />
!word 96,64,102,128,114,64,128,64,128,64,128,128,96,64,85,64,96,64,102,64,114,64,114,64<br />
</syntaxhighlight><br />
<br />
=== Additional Resources ===<br />
* Deater's page on Apple II sizecoding http://www.deater.net/weave/vmwprod/demos/sizecoding.html<br />
* Article on double hi-res http://www.battlestations.zone/2017/04/apple-ii-double-hi-res-from-ground-up.html<br />
* Applesoft Hi-Res Subroutines : http://hackzapple.org/scripts_php/index.php?menu=5&mod=ASM&sub=AAL&sub2=8112&PHPSESSID=f65fabfd0cdbf56b6bdc0ddac25117c6#a2<br />
<br />
== Atari Lynx ==<br />
The Atari Lynx consists of the 6502 with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Atari Lynx:<br />
<br />
* Assembler: -<br />
* Emulator(s): -<br />
<br />
=== Video display ===<br />
To be added soon.<br />
<br />
==== Getting something on screen ====<br />
To be added soon.<br />
<br />
<br />
=== Sound ===<br />
To be added soon.<br />
<br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Additional Resources ===<br />
Sizecoding resource for the Atari Lynx are sparse<br />
* 42Bastian's website (link to be added)</div>Wilhttp://www.sizecoding.org/index.php?title=6502&diff=82465022021-02-15T21:22:41Z<p>Wil: /* Useful Kernal functions */ added two examples</p>
<hr />
<div>== Introduction ==<br />
Wanting to start sizecoding on a 6502 platform in this day and age can be tough. <br />
<br />
[[File:6502.jpg|thumb]]<br />
<br />
So here is a bit of help to get you started:<br />
<br />
=== The 6502 processor ===<br />
The 6502 processor can be seen as the 8-bit micro ARM chip. <br />
It has only has 3 registers (Accumulator, X and Y registers) and a handful of instructions to work with.<br />
<br />
=== Adressing modes ===<br />
To be added.<br />
<br />
=== Zero page ===<br />
When using the 6502 for sizecoding, you'll mostly be working from zeropage<br />
<br />
=== General 6502 Resources ===<br />
* 6502.org http://www.6502.org/<br />
* 6502 instruction reference http://www.6502.org/tutorials/6502opcodes.html<br />
* 6502 books http://retro.hansotten.nl/6502-sbc/<br />
* 6502 Assembler tutorial https://dwheeler.com/6502/oneelkruns/asm1step.html<br />
* Easy 6502 code tester https://skilldrick.github.io/easy6502/<br />
* Synthetic instructions https://wiki.nesdev.com/w/index.php/Synthetic_instructions#8-bit_rotate<br />
<br />
== Atari 8-bit family ==<br />
The systems in this family are: Atari 400, 800, 5200, 1200XL, 600XL, 800XL, 130XE, 65XE, 800XE and XEGS.<br /><br />
<br />
The Atari 8-bit systems consists of the 6502 with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Atari 8bit systems is quite easy, first get the following tools:<br />
<br />
* Assembler: MADS Assembler - This assembler has nice macros for creating Binaries and SNA snapshot files out of the box. You can download it at https://mads.atari8.info/<br />
* Emulator(s): I Found Altirra to work best for my usecase. Make sure to use the original Rev2 rom for best compatibility.<br />
<br />
==== Special Memory Adresses ====<br />
* FRAMECOUNTER_HIGH = 19<br />
* FRAMECOUNTER_LOW = 20<br />
<br />
=== Video display ===<br />
Video display on the Atari 8bit systems use the ANTIC and GTIA chips. Information can be found here:<br />
* https://en.wikipedia.org/wiki/ANTIC<br />
* https://www.atariarchives.org/agagd/chapter1.php<br />
<br />
==== Sync with frame ====<br />
<syntaxhighlight lang="6502"><br />
RTCLOK equ $0012<br />
lda RTCLOK+2<br />
waits<br />
cmp RTCLOK+2<br />
beq waits<br />
</syntaxhighlight><br />
<br />
Or if you don't mind trashing RTCLOK<br />
<br />
<syntaxhighlight lang="6502"><br />
RTCLOK equ $0012<br />
waits<br />
lsr RTCLOK+2<br />
bcc waits<br />
</syntaxhighlight><br />
<br />
Which is two bytes shorter.<br />
<br />
==== Getting something on screen ====<br />
<syntaxhighlight lang="6502"><br />
;fill screen with charset,(88,89)=an address<br />
org $600; free 6th page:600-6ff<br />
ldy #0<br />
fl: tya<br />
sta(88),y<br />
iny<br />
bne fl<br />
jmp *<br />
</syntaxhighlight><br />
<br />
To be added soon.<br />
<br />
<syntaxhighlight lang="6502"><br />
SDMCTL = $022f<br />
HPOSP0 = $d000<br />
SIZEP0 = $d008<br />
GRAFP0 = $d00d<br />
COLPM0 = $d012<br />
<br />
FRAMECOUNTER_HIGH = 19<br />
FRAMECOUNTER = 20<br />
WSYNC = $d40a<br />
VCOUNT = $d40b<br />
<br />
sinewave = $0600 ; to $06ff<br />
<br />
org $80<br />
<br />
main <br />
; disable all graphics/colors<br />
ldx #0<br />
stx SDMCTL <br />
<br />
ldy #$7f<br />
sty SIZEP0 ; size p0=127<br />
<br />
ldx #0<br />
ldy #$3f<br />
make_sine:<br />
value_lo<br />
lda #0<br />
clc<br />
delta_lo<br />
adc #0<br />
sta value_lo+1<br />
value_hi<br />
lda #0<br />
delta_hi<br />
adc #0<br />
sta value_hi+1<br />
<br />
sta sinewave+$c0,x<br />
sta sinewave+$80,y<br />
eor #$7f<br />
sta sinewave+$40,x<br />
sta sinewave+$00,y<br />
<br />
lda delta_lo+1<br />
adc #8<br />
sta delta_lo+1<br />
bcc nothing<br />
inc delta_hi+1<br />
nothing<br />
inx<br />
dey<br />
bpl make_sine<br />
<br />
updateloop:<br />
; vblank<br />
lda VCOUNT<br />
bne updateloop<br />
<br />
; clear graphics<br />
sta HPOSP0<br />
sta GRAFP0<br />
<br />
ldy #0<br />
lda #47<br />
sta COLPM0<br />
yloop:<br />
tya ; graphics shape = y<br />
sta WSYNC<br />
sta GRAFP0<br />
<br />
; a = sin(frame+y)+48<br />
tya <br />
adc FRAMECOUNTER<br />
tax<br />
lda sinewave,x<br />
adc #48<br />
sta HPOSP0<br />
<br />
iny<br />
bne yloop<br />
jmp updateloop<br />
<br />
run main<br />
</syntaxhighlight><br />
<br />
=== Sound ===<br />
The Atari 8-bit use the POKEY chip to generate sound.<br />
* https://en.wikipedia.org/wiki/POKEY<br />
<br />
==== BASIC ====<br />
<syntaxhighlight lang="6502"><br />
; from Analog, 1985-09,pp.25-32<br />
*=$2000<br />
AUDF1=$D200<br />
AUDC1=$D201<br />
AUDCTL=$D208<br />
SKCTL=$D20F<br />
<br />
.MACRO SOUND ; voice,pitch,dist,vol;,dur<br />
lda #%2<br />
sta AUDF1+2*%1<br />
lda #[[%3 * 16] | %4] ;lda #[[%3 shl 4] or %4]<br />
sta AUDC1+2*%1<br />
.ENDM<br />
<br />
lda #0<br />
sta AUDCTL<br />
lda #3<br />
sta SKCTL<br />
<br />
SOUND 0,121,10,8<br />
<br />
jmp *<br />
</syntaxhighlight><br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Additional Resources ===<br />
Sizecoding resource for the Atari 8bit are:<br />
* Mapping the Atari https://www.atariarchives.org/mapping/<br />
* Atari 8bit Memory map https://www.atariarchives.org/mapping/memorymap.php<br />
* Fready's undocumented 6502 opcodes https://github.com/FreddyOffenga/6502<br />
* Atari OS Rev2 disassembly for MADS assembler https://github.com/ilmenit/A800-OS-XL-Rev2<br />
* Fready's github https://github.com/FreddyOffenga/<br />
<br />
== Commodore 64 ==<br />
The Commodore system consists of a 6502-compatible MOS 6510 processor with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Commodore systems is quite easy, first get the following tools:<br />
<br />
* Assembler: To be added<br />
* Emulator(s): VICE is the way to go<br />
<br />
=== Memory map ===<br />
<br />
<syntaxhighlight lang="6502"><br />
0-1 $0-$1 PROCESSOR PORT REGISTERS, not usable as RAM<br />
0-255 $0-$FF ZEROPAGE, mostly used by BASIC interpreter and Kernal<br />
256-511 $100-$1FF SYSTEM STACK<br />
512-600 $200-$258 INPUT BUFFER<br />
601-630 $259-$276 FILE SYSTEM DATA<br />
631-640 $277-$280 KEYBOARD BUFFER, filled by Kernal ISR upon key presses <br />
641-678 $281-$2A6 VARIOUS KERNAL VARIABLES<br />
679-767 $2A7-$2FF Unused (89 byte)<br />
768-779 $300-$30B KERNAL VECTORS<br />
780-783 $30C-$30F REGISTER VALUES A,X,Y,SR for SYS<br />
784-819 $310-$333 KERNAL VECTORS<br />
820-827 $334-$33B Unused (8 byte)<br />
828-1019 $33C-$3FB DATASETTE BUFFER<br />
1020-1023 $3FC-$3FF Unused (4 byte)<br />
1024-2023 $400-$7E7 SCREEN MEMORY (25 lines times 40 columns)<br />
2024-2039 $7E8-$7F7 Unused (16 byte)<br />
2040-2047 $7F8-$7FF SPRITE COSTUME POINTERS<br />
2048 $800 must contain a value of 0 so that the BASIC program can be RUN<br />
2049-40959 $801-$9FFF BASIC AREA (code, variables, arrays, strings)<br />
40960-49151 $A000-$BFFF BASIC ROM (unused RAM underneath)<br />
49152-53247 $C000-$CFFF UPPER RAM AREA (unused)<br />
53248-53294 $D000-$D02E VIC-II, memory-mapped graphics chip registers)<br />
54272-54300 $D400-$D41C SID, memory-mapped sound chip registers)<br />
55296-56295 $D800-$DBE7 Color RAM, only lower 4 bits are stored, higher nibble undefined<br />
56296-56319 $DBE8-$DBFF Unused (24 half-bytes)<br />
56320-56335 $DC00-$DC0F CIA#1, memory-mapped I/O chip registers for keyboard, joystick, mouse, datasette, IRQ control<br />
56576-56591 $DD00-$DD0F CIA#1, memory-mapped I/O chip registers for serial bus, RS232, NMI control<br />
57344-65535 $E000-$FFFF KERNAL ROM<br />
65534-65535 $FFFE-$FFFF Execution address of interrupt service routine, can only be set if KERNAL is turned off<br />
</syntaxhighlight><br />
<br />
For a detailed explanation of the C64 memory map check out [https://sta.c64.org/cbm64mem.html Commodore 64 memory map] on Joe Forster/STA homepage.<br />
<br />
=== Program file overhead ===<br />
<br />
A standard CBM file consists of a 2 byte loading address followed by the data that is placed into memory starting at this address. In addition, if your machine program should be able to be started with "RUN", you need a BASIC stub that is loaded into memory from $0801 to $080c, typically followed by your machine program:<br />
<br />
<syntaxhighlight lang="6502"><br />
*=$0801<br />
.word $080b ;address of next BASIC line<br />
.word LINENR ;line number, can be chosen between 0 and 63999<br />
.byte $9e ;token for SYS command<br />
.byte $32,$30,$36,$31 ;address to jump to in ASCII code: "2061" <br />
.byte $00 ;end of BASIC line<br />
.word $0000 ;address of next BASIC line, $0000 means end of BASIC program <br />
start<br />
; your code here<br />
</syntaxhighlight><br />
<br />
Together with the 2 byte load address, this makes an overhead of 14 byte for your program. To reduce this, you can<br />
* omit the BASIC line and tell users to start your program by directly entering "SYS ''address''"<br />
* save your program from $0802 on, the byte at $0801 is recovered automatically after loading by the relink function. This reduces your program file size by 1 byte<br />
* accept the loss and use the 2 byte establishing LINENR for something good, they are copied to zeropage addresses $39/$3a automatically, saving you the effort of initializing the addresses<br />
* use an autostart method (see below)<br />
<br />
Some compos also specify that the BASIC loader does not count towards the overall filesize, check the rules before you worry.<br />
<br />
=== Autostart ===<br />
<br />
Unlike the Commodore 128, the Commodore 64 has no dedicated built-in auto-boot feature, but it is possible to autorun a program after loading by specifying the load address so that it overwrites a vector or address that is called by the operating system. There are multiple possibilities:<br />
<br />
==== Overwriting CHROUT vector at $326-$327 ====<br />
<br />
The vector at address $326-$327 points at the CHROUT routine, normally at address $F1CA.<br />
If you put the entry address of your program into $326/27, your code will be called when the operating system wants to print "READY." after loading.<br />
Note that the vector at address $328-$329 points at the STOP routine that checks the status of Stop key indicator. Since this routine is called multiple times before your code is done loading, its default value $F6ED needs to be preserved. <br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$0326<br />
.word start <br />
.byte $ed,$f6<br />
start<br />
; rest of code<br />
</syntaxhighlight><br />
<br />
Together with the two byte load address, the overwritten CHROUT vector and the preserved STOP vector, your program file will have a deadweight of 6 byte: $26 $03 $0a $03 $ed $f6, less than half of the standard version with a BASIC stub with SYS<br />
<br />
Caveat:<br />
* If your program after $32a is longer than 214 byte, part of your program will load into the screen at $400. Thus, issuing a clear screen will overwrite your program. It is possible to move the screen memory somewhere else, but that requires storing a new value into address $D018, which when done with an LDA # / STA pair will cost you 5 byte<br />
* Since you changed the CHROUT pointer, standard KERNAL functions for printing won't work. For output of single characters, you can still use the direct address $F1CA. Alternatively, you can restore the vectors by calling $FD15, which will overwrite the memory $314 to $333 with the default values.<br />
<br />
=== Video display ===<br />
Video display on the Commodore, it has the following video modes:<br />
<br />
To be added soon.<br />
<br />
==== Getting something on screen ====<br />
<br />
Output a character:<br />
<syntaxhighlight lang="6502"><br />
lda #C ;C must be the char code according to the PETSCII code table<br />
jsr $FFD2 ;you can also use the direct address $FC1A, function preserves A,X,Y and enables interrupt<br />
</syntaxhighlight><br />
<br />
Since the [https://en.wikipedia.org/wiki/PETSCII#Character_set PETSCII code table] contains also control characters, this method can be also used to clear the screen, move the cursor or set the text color. However, some functions are shorter (and faster) by directly calling the respective KERNAL function:<br />
<br />
<syntaxhighlight lang="6502"><br />
Clear screen JSR $E544<br />
Cursor home position JSR $E566<br />
Output newline character JSR $AAD7<br />
Set text color LDA #COLOR, STA $286<br />
Set border color LDA #COLOR, STA $D020 ;not possible with a PETSCII control code<br />
Set background color LDA #COLOR, STA $D021 ;not possible with a PETSCII control code<br />
</syntaxhighlight><br />
<br />
Copy characters directly to screen memory:<br />
<br />
<syntaxhighlight lang="6502"><br />
.macpack cbm ;scrcode macro<br />
SCREEN_BASE=$400<br />
LINE=5 ;for example<br />
COLUMN=10 ;for example<br />
<br />
ldx #endtext-text-1<br />
@loop: lda text,x<br />
sta SCREEN_BASE+LINE*40+COLUMN,x<br />
dex<br />
bpl @loop<br />
text: scrcode "hello world!"<br />
endtext:<br />
</syntaxhighlight><br />
<br />
Note that the text needs to be stored in '''screen code''' format, not in PETSCII (see [https://sta.c64.org/cbm64pettoscr.html Commodore 64 PETSCII code to screen code conversion] for the differences). Furthermore, the example above only writes to the screen memory, not the color RAM, assuming that the color RAM already contains the intended text color. This is the case after issuing a clear screen on most C64 machines, except for some old ROM revisions. To be on the save side you would have to write to color RAM as well, which costs another 5 byte:<br />
<br />
<syntaxhighlight lang="6502"><br />
.macpack cbm ;scrcode macro<br />
SCREEN_BASE=$400<br />
COLOR_RAM =$D800<br />
LINE =5 ;for example<br />
COLUMN =10 ;for example<br />
COLOR =1 ;white<br />
<br />
ldx #endtext-text-1<br />
@loop: lda text,x<br />
sta SCREEN_BASE+LINE*40+COLUMN,x<br />
lda #COLOR<br />
sta COLOR_RAM +LINE*40+COLUMN,x<br />
dex<br />
bpl @loop<br />
text: scrcode "hello world!"<br />
endtext:<br />
</syntaxhighlight><br />
<br />
=== Sound ===<br />
The Commodore 64 uses the famous SID chip to generate sound.<br />
To be added soon.<br />
<br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Useful Kernal functions ===<br />
<br />
==== Get a pseudo random number ====<br />
<br />
<syntaxhighlight lang="6502"><br />
lda #1 <br />
jsr $E09A<br />
lda $63<br />
</syntaxhighlight><br />
<br />
The sequence of random numbers is always the same after a cold start or reset, the first 20 numbers are:<br />
<syntaxhighlight lang="6502"><br />
4,24,231,4,177,170,193,101,231,18,196,1,75,48,149,36,124,53,65,154<br />
</syntaxhighlight><br />
<br />
==== Increment a zero page counter, return in X register, clear Y register ====<br />
<br />
This is part of the string handling function in the BASIC ROM, but the code could be useful for some loop stuff.<br />
<br />
<syntaxhighlight lang="6502"><br />
jsr $B5FF ;does a inc $23, ldx $23, ldy #$00, rts<br />
</syntaxhighlight><br />
<br />
=== Additional Resources ===<br />
* Codebase 64 https://codebase64.org/doku.php?id=base:start<br />
<br />
== Apple II ==<br />
The Apple II is an 8-bit home computer and one of the world's first highly successful mass-produced microcomputer products. It was designed primarily by Steve Wozniak.<br />
<br />
=== Setting up ===<br />
* ACME 6502 cross-assembler(https://sourceforge.net/projects/acme-crossass/)<br />
* Apple Commander (http://applecommander.sourceforge.net) for batch compilation<br />
* AppleWin emulator (https://github.com/AppleWin/AppleWin/releases). Supports Mockingboard card(AY-8910+speech synthesier), HDD, Z80 card(for CP/M), mouse etc.<br />
* CiderPress(https://a2ciderpress.com)<br />
<br />
Compilation can be done as follows (master.dsk can be found with applewin) <br />
<syntaxhighlight><br />
acme hl.asm<br />
java -jar AppleCommander-1.3.5.jar -d master.dsk hl<br />
java -jar AppleCommander-1.3.5.jar -p master.dsk hl B 24576 < hl.bin<br />
</syntaxhighlight><br />
<br />
=== Memory Map ===<br />
<syntaxhighlight lang="6502"><br />
0-255 $0-$FF ZERO-PAGE SYSTEM STORAGE<br />
256-511 $100-$1FF SYSTEM STACK<br />
512-767 $200-$2FF KEYBOARD CHARACTER BUFFER<br />
768-975 $300-$3CF OFTEN AVAILABLE AS FREE SPACE FOR USER PROGRAMS<br />
976-1023 $3D0-3FF SYSTEM VECTORS<br />
1024-2047 $400-$7FF TEXT AND LO-RES GRAPHICS PAGE 1 <--- !!!<br />
2048-LOMEM $800-LOMEM PROGRAM STORAGE<br />
2048-3071 $800-$BFF TEXT AND LO-RES GRAPHICS PAGE 2 OR FREE SPACE<br />
3072-8191 $C00-$1FFF FREE SPACE UNLESS RAM APPLESOFT IS IN USE<br />
8192-16383 $2000-$3FFF HI-RES PAGE 1 OR FREE SPACE <--- !!!<br />
16384-24575 $4000-$5FFF HI-RES PAGE 2 OR FREE SPACE<br />
24576-38999 $6000-$95FF FREE SPACE AND STRING STORAGE<br />
38400-49151 $9600-$BFFF DOS<br />
49152-53247 $C000-$CFFF I/O HARDWARE (RESERVED)<br />
53248-57343 $D000-$DFFF APPLESOFT IN LANGUAGE CARD OR ROM<br />
57344-63487 $E000-$F7FF APPLESOFT OR INTEGER BASIC IN LANGUAGE CARD OR ROM<br />
63488-65535 $F800-$FFFF SYSTEM MONITOR<br />
</syntaxhighlight><br />
<br />
=== Display ===<br />
<br />
=== Graphics Modes ===<br />
: Text Mode 40x24, for Apple IIe available 80x25 - use PR#3 for switch mode, or hardware switch<br />
: LowRes 40x48, 16 colors: https://en.wikipedia.org/wiki/Apple_II_graphics <br />
: Hires mode 280x192,6 colors: https://www.xtof.info/blog/?p=768<br />
https://mrob.com/pub/xapple2/colors.html<br />
https://archive.org/details/HiRes_Color_Graphics_on_the_Apple_II_Computer_by_Wozniak<br />
<br />
However for sizecoding, you almost never want to do direct-access to graphics for Apple II in size-coding because the Apple II graphics modes are horrible. The only fast way to do things is with large lookup tables. To do hires you need to divide by 7 which as you can imagine is a bit difficult to do compactly on 6502. Double-hires is even crazier on top of that. Deater did manage a color-bar style effect in double-hires in 128B but that was doing some crazy tricks with the firmware BASIC routines, definitely not direct-access.<br />
<br />
Lores and Hires can be mixed modes and full-graphics<br />
The screen structure is called memory holes(https://retrocomputing.stackexchange.com/questions/2534/what-are-the-screen-holes-in-apple-ii-graphics). The GBASCALC($F847) procedure is used to calculate the address of the horizontal line : IN:reg.A=Y, out : GBASL/GBASH($26/$27)=address. See also https://www.callapple.org/uncategorized/use-of-apple-ii-color-graphics-in-assembly-language/<br />
<br />
==== Getting something on screen ====<br />
Here is an example of a XOR texture, created by g0blinish<br />
<syntaxhighlight lang="6502"><br />
*=$6000<br />
!to "HL.bin", plain ; set output file and format<br />
!cpu 6502 ; set processor type<br />
<br />
GBASL = $26<br />
GBASH = $27<br />
SETGR = $FB40 ; setup LoRes<br />
GBASCALC = $F847 ; calc Address<br />
<br />
CLRTEXT = $C050 ;display graphics <br />
SETTEXT = $C051 ;display text <br />
<br />
CLRMIXED = $C052 ;clear mixed mode- enable full graphics <br />
SETMIXED = $C053 ;enable graphics/text mixed mode <br />
<br />
PAGE1 = $C054 ;select text/graphics page1 <br />
PAGE2 = $C055 ;select text/graphics page2 <br />
<br />
CLRHIRES = $C056 ;select Lo-res <br />
SETHIRES = $C057 ;select Hi-res <br />
<br />
TMP= $FA<br />
<br />
JSR SETGR ;GR<br />
BIT CLRMIXED ; full screen<br />
<br />
LDA #0 ; A=0<br />
STA TMP ; POKE $FA,A<br />
<br />
YLP ;<br />
LDA TMP ; A=PEEK($FA)<br />
; LSR ; A=A/2<br />
JSR GBASCALC<br />
LDY #0;Y=0<br />
<br />
XLP TYA ; A=Y<br />
EOR TMP ; A=A xor PEEK($FA)<br />
and #$0F ; A=A and 15<br />
TAX ; X=A<br />
LDA COLORS,X ;A=PEEK(COLORS+X)<br />
STA(GBASL),Y ; POKE PEEK($26)+256*PEEK($27)+Y,A<br />
INY ; Y=Y+1<br />
CPY #40 ; Y=40?<br />
BNE XLP<br />
INC TMP ; POKE $FA,PEEK($FA)+1<br />
LDA TMP ; A=PEEK($FA)<br />
CMP #24 ; A=24?<br />
BNE YLP<br />
<br />
M1 JMP M1 ; replace to RTS<br />
<br />
COLORS ;N*17, pixel format is AAAABBBB, AAAA - upper dot, BBBB - lower dot<br />
!byte $00,$11,$22,$33,$44,$55,$66,$77<br />
!byte $88,$99,$AA,$BB,$CC,$DD,$EE,$FF<br />
</syntaxhighlight><br />
<br />
==== Sound ====<br />
Here is an example for using the speaker, based onthe following basic program:<br />
<br />
<syntaxhighlight lang="basic"><br />
; 50 POKE 768,V: POKE 769,P - 255 * INT (P / 256): POKE 800,1 + P / 256<br />
; 60 CALL 770: RETURN <br />
; 95 FOR K = 1 TO N: READ V(K),P(K): NEXT K<br />
; 100 FOR K = 1 TO N:V = V(K):P = P(K)<br />
; 110 GOSUB 50<br />
;!byte 173,48,192,136,208,5,206,1,3,240,9,202,208,245,174,0,3,76,2,3,206,32,3,208,240,96<br />
</syntaxhighlight><br />
<br />
<syntaxhighlight lang="6502"><br />
*=$6000<br />
!to "HL.bin", plain ; set output file and format<br />
!cpu 6502 ; set processor type<br />
<br />
;start<br />
; 95 FOR K = 1 TO N: READ V(K),P(K): NEXT K<br />
; 100 FOR K = 1 TO N:V = V(K):P = P(K)<br />
ini:<br />
lda #70<br />
sta cnt+1<br />
lda #music&255<br />
sta gotbyte+1<br />
lda #music/256<br />
sta gotbyte+2<br />
<br />
lop:<br />
;V<br />
jsr gotbyte<br />
sta L300<br />
jsr gotbyte<br />
;P<br />
jsr gotbyte<br />
sta L301<br />
jsr gotbyte<br />
clc<br />
adc #1<br />
sta L320<br />
jsr beep<br />
<br />
dec cnt+1<br />
cnt lda #70<br />
bne lop<br />
; 110 GOSUB 50<br />
; 50 POKE 768,V: POKE 769,P - 255 * INT (P / 256): POKE 800,1 + P / 256<br />
; 60 CALL 770: RETURN <br />
jmp ini<br />
gotbyte<br />
lda music<br />
inc gotbyte+1<br />
bne noinch<br />
inc gotbyte+2<br />
noinch<br />
rts<br />
;!byte 173,48,192,136,208,5,206,1,3,240,9,202,208,245,174,0,3,76,2,3,206,32,3,208,240,96<br />
beep:<br />
ldy #1<br />
ldx #1<br />
loc_302:<br />
LDA $C030<br />
<br />
loc_305:<br />
DEY<br />
BNE loc_30D<br />
DEC L301<br />
loc_30B:<br />
BEQ loc_316<br />
<br />
loc_30D:<br />
DEX<br />
BNE loc_305<br />
LDX L300<br />
JMP loc_302<br />
loc_316:<br />
DEC L320<br />
BNE loc_30B<br />
RTS<br />
L301 !byte 0<br />
L300 !byte 0<br />
L320 !byte 0<br />
music<br />
!word 76,192,85,64,96,64,102,64,114,128,114,64,96,64,102,64,114,64,128,64<br />
!word 114,64,152,64,171,64,152,512,76,192,85,64,96,64,102,64,114,128,114,64<br />
!word 96,64,102,64,114,64,128,64,114,64,152,64,171,64,152,512,85,64,85,64<br />
!word 85,64,96,64,144,128,144,64,128,64,76,128,85,64,96,64,144,128,114,64<br />
!word 96,64,102,128,114,64,128,64,128,128,114,64,128,64,114,512,85,64,85,64<br />
!word 85,64,96,64,144,128,144,64,128,64,76,128,85,64,96,64,144,128,114,64<br />
!word 96,64,102,128,114,64,128,64,128,64,128,128,96,64,85,64,96,64,102,64,114,64,114,64<br />
</syntaxhighlight><br />
<br />
=== Additional Resources ===<br />
* Deater's page on Apple II sizecoding http://www.deater.net/weave/vmwprod/demos/sizecoding.html<br />
* Article on double hi-res http://www.battlestations.zone/2017/04/apple-ii-double-hi-res-from-ground-up.html<br />
* Applesoft Hi-Res Subroutines : http://hackzapple.org/scripts_php/index.php?menu=5&mod=ASM&sub=AAL&sub2=8112&PHPSESSID=f65fabfd0cdbf56b6bdc0ddac25117c6#a2<br />
<br />
== Atari Lynx ==<br />
The Atari Lynx consists of the 6502 with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Atari Lynx:<br />
<br />
* Assembler: -<br />
* Emulator(s): -<br />
<br />
=== Video display ===<br />
To be added soon.<br />
<br />
==== Getting something on screen ====<br />
To be added soon.<br />
<br />
<br />
=== Sound ===<br />
To be added soon.<br />
<br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Additional Resources ===<br />
Sizecoding resource for the Atari Lynx are sparse<br />
* 42Bastian's website (link to be added)</div>Wilhttp://www.sizecoding.org/index.php?title=6502&diff=82365022021-02-15T21:01:45Z<p>Wil: /* Getting something on screen */ fixed indentation</p>
<hr />
<div>== Introduction ==<br />
Wanting to start sizecoding on a 6502 platform in this day and age can be tough. <br />
<br />
[[File:6502.jpg|thumb]]<br />
<br />
So here is a bit of help to get you started:<br />
<br />
=== The 6502 processor ===<br />
The 6502 processor can be seen as the 8-bit micro ARM chip. <br />
It has only has 3 registers (Accumulator, X and Y registers) and a handful of instructions to work with.<br />
<br />
=== Adressing modes ===<br />
To be added.<br />
<br />
=== Zero page ===<br />
When using the 6502 for sizecoding, you'll mostly be working from zeropage<br />
<br />
=== General 6502 Resources ===<br />
* 6502.org http://www.6502.org/<br />
* 6502 instruction reference http://www.6502.org/tutorials/6502opcodes.html<br />
* 6502 books http://retro.hansotten.nl/6502-sbc/<br />
* 6502 Assembler tutorial https://dwheeler.com/6502/oneelkruns/asm1step.html<br />
* Easy 6502 code tester https://skilldrick.github.io/easy6502/<br />
* Synthetic instructions https://wiki.nesdev.com/w/index.php/Synthetic_instructions#8-bit_rotate<br />
<br />
== Atari 8-bit family ==<br />
The systems in this family are: Atari 400, 800, 5200, 1200XL, 600XL, 800XL, 130XE, 65XE, 800XE and XEGS.<br /><br />
<br />
The Atari 8-bit systems consists of the 6502 with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Atari 8bit systems is quite easy, first get the following tools:<br />
<br />
* Assembler: MADS Assembler - This assembler has nice macros for creating Binaries and SNA snapshot files out of the box. You can download it at https://mads.atari8.info/<br />
* Emulator(s): I Found Altirra to work best for my usecase. Make sure to use the original Rev2 rom for best compatibility.<br />
<br />
==== Special Memory Adresses ====<br />
* FRAMECOUNTER_HIGH = 19<br />
* FRAMECOUNTER_LOW = 20<br />
<br />
=== Video display ===<br />
Video display on the Atari 8bit systems use the ANTIC and GTIA chips. Information can be found here:<br />
* https://en.wikipedia.org/wiki/ANTIC<br />
* https://www.atariarchives.org/agagd/chapter1.php<br />
<br />
==== Sync with frame ====<br />
<syntaxhighlight lang="6502"><br />
RTCLOK equ $0012<br />
lda RTCLOK+2<br />
waits<br />
cmp RTCLOK+2<br />
beq waits<br />
</syntaxhighlight><br />
<br />
Or if you don't mind trashing RTCLOK<br />
<br />
<syntaxhighlight lang="6502"><br />
RTCLOK equ $0012<br />
waits<br />
lsr RTCLOK+2<br />
bcc waits<br />
</syntaxhighlight><br />
<br />
Which is two bytes shorter.<br />
<br />
==== Getting something on screen ====<br />
<syntaxhighlight lang="6502"><br />
;fill screen with charset,(88,89)=an address<br />
org $600; free 6th page:600-6ff<br />
ldy #0<br />
fl: tya<br />
sta(88),y<br />
iny<br />
bne fl<br />
jmp *<br />
</syntaxhighlight><br />
<br />
To be added soon.<br />
<br />
<syntaxhighlight lang="6502"><br />
SDMCTL = $022f<br />
HPOSP0 = $d000<br />
SIZEP0 = $d008<br />
GRAFP0 = $d00d<br />
COLPM0 = $d012<br />
<br />
FRAMECOUNTER_HIGH = 19<br />
FRAMECOUNTER = 20<br />
WSYNC = $d40a<br />
VCOUNT = $d40b<br />
<br />
sinewave = $0600 ; to $06ff<br />
<br />
org $80<br />
<br />
main <br />
; disable all graphics/colors<br />
ldx #0<br />
stx SDMCTL <br />
<br />
ldy #$7f<br />
sty SIZEP0 ; size p0=127<br />
<br />
ldx #0<br />
ldy #$3f<br />
make_sine:<br />
value_lo<br />
lda #0<br />
clc<br />
delta_lo<br />
adc #0<br />
sta value_lo+1<br />
value_hi<br />
lda #0<br />
delta_hi<br />
adc #0<br />
sta value_hi+1<br />
<br />
sta sinewave+$c0,x<br />
sta sinewave+$80,y<br />
eor #$7f<br />
sta sinewave+$40,x<br />
sta sinewave+$00,y<br />
<br />
lda delta_lo+1<br />
adc #8<br />
sta delta_lo+1<br />
bcc nothing<br />
inc delta_hi+1<br />
nothing<br />
inx<br />
dey<br />
bpl make_sine<br />
<br />
updateloop:<br />
; vblank<br />
lda VCOUNT<br />
bne updateloop<br />
<br />
; clear graphics<br />
sta HPOSP0<br />
sta GRAFP0<br />
<br />
ldy #0<br />
lda #47<br />
sta COLPM0<br />
yloop:<br />
tya ; graphics shape = y<br />
sta WSYNC<br />
sta GRAFP0<br />
<br />
; a = sin(frame+y)+48<br />
tya <br />
adc FRAMECOUNTER<br />
tax<br />
lda sinewave,x<br />
adc #48<br />
sta HPOSP0<br />
<br />
iny<br />
bne yloop<br />
jmp updateloop<br />
<br />
run main<br />
</syntaxhighlight><br />
<br />
=== Sound ===<br />
The Atari 8-bit use the POKEY chip to generate sound.<br />
* https://en.wikipedia.org/wiki/POKEY<br />
<br />
==== BASIC ====<br />
<syntaxhighlight lang="6502"><br />
; from Analog, 1985-09,pp.25-32<br />
*=$2000<br />
AUDF1=$D200<br />
AUDC1=$D201<br />
AUDCTL=$D208<br />
SKCTL=$D20F<br />
<br />
.MACRO SOUND ; voice,pitch,dist,vol;,dur<br />
lda #%2<br />
sta AUDF1+2*%1<br />
lda #[[%3 * 16] | %4] ;lda #[[%3 shl 4] or %4]<br />
sta AUDC1+2*%1<br />
.ENDM<br />
<br />
lda #0<br />
sta AUDCTL<br />
lda #3<br />
sta SKCTL<br />
<br />
SOUND 0,121,10,8<br />
<br />
jmp *<br />
</syntaxhighlight><br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Additional Resources ===<br />
Sizecoding resource for the Atari 8bit are:<br />
* Mapping the Atari https://www.atariarchives.org/mapping/<br />
* Atari 8bit Memory map https://www.atariarchives.org/mapping/memorymap.php<br />
* Fready's undocumented 6502 opcodes https://github.com/FreddyOffenga/6502<br />
* Atari OS Rev2 disassembly for MADS assembler https://github.com/ilmenit/A800-OS-XL-Rev2<br />
* Fready's github https://github.com/FreddyOffenga/<br />
<br />
== Commodore 64 ==<br />
The Commodore system consists of a 6502-compatible MOS 6510 processor with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Commodore systems is quite easy, first get the following tools:<br />
<br />
* Assembler: To be added<br />
* Emulator(s): VICE is the way to go<br />
<br />
=== Memory map ===<br />
<br />
<syntaxhighlight lang="6502"><br />
0-1 $0-$1 PROCESSOR PORT REGISTERS, not usable as RAM<br />
0-255 $0-$FF ZEROPAGE, mostly used by BASIC interpreter and Kernal<br />
256-511 $100-$1FF SYSTEM STACK<br />
512-600 $200-$258 INPUT BUFFER<br />
601-630 $259-$276 FILE SYSTEM DATA<br />
631-640 $277-$280 KEYBOARD BUFFER, filled by Kernal ISR upon key presses <br />
641-678 $281-$2A6 VARIOUS KERNAL VARIABLES<br />
679-767 $2A7-$2FF Unused (89 byte)<br />
768-779 $300-$30B KERNAL VECTORS<br />
780-783 $30C-$30F REGISTER VALUES A,X,Y,SR for SYS<br />
784-819 $310-$333 KERNAL VECTORS<br />
820-827 $334-$33B Unused (8 byte)<br />
828-1019 $33C-$3FB DATASETTE BUFFER<br />
1020-1023 $3FC-$3FF Unused (4 byte)<br />
1024-2023 $400-$7E7 SCREEN MEMORY (25 lines times 40 columns)<br />
2024-2039 $7E8-$7F7 Unused (16 byte)<br />
2040-2047 $7F8-$7FF SPRITE COSTUME POINTERS<br />
2048 $800 must contain a value of 0 so that the BASIC program can be RUN<br />
2049-40959 $801-$9FFF BASIC AREA (code, variables, arrays, strings)<br />
40960-49151 $A000-$BFFF BASIC ROM (unused RAM underneath)<br />
49152-53247 $C000-$CFFF UPPER RAM AREA (unused)<br />
53248-53294 $D000-$D02E VIC-II, memory-mapped graphics chip registers)<br />
54272-54300 $D400-$D41C SID, memory-mapped sound chip registers)<br />
55296-56295 $D800-$DBE7 Color RAM, only lower 4 bits are stored, higher nibble undefined<br />
56296-56319 $DBE8-$DBFF Unused (24 half-bytes)<br />
56320-56335 $DC00-$DC0F CIA#1, memory-mapped I/O chip registers for keyboard, joystick, mouse, datasette, IRQ control<br />
56576-56591 $DD00-$DD0F CIA#1, memory-mapped I/O chip registers for serial bus, RS232, NMI control<br />
57344-65535 $E000-$FFFF KERNAL ROM<br />
65534-65535 $FFFE-$FFFF Execution address of interrupt service routine, can only be set if KERNAL is turned off<br />
</syntaxhighlight><br />
<br />
For a detailed explanation of the C64 memory map check out [https://sta.c64.org/cbm64mem.html Commodore 64 memory map] on Joe Forster/STA homepage.<br />
<br />
=== Program file overhead ===<br />
<br />
A standard CBM file consists of a 2 byte loading address followed by the data that is placed into memory starting at this address. In addition, if your machine program should be able to be started with "RUN", you need a BASIC stub that is loaded into memory from $0801 to $080c, typically followed by your machine program:<br />
<br />
<syntaxhighlight lang="6502"><br />
*=$0801<br />
.word $080b ;address of next BASIC line<br />
.word LINENR ;line number, can be chosen between 0 and 63999<br />
.byte $9e ;token for SYS command<br />
.byte $32,$30,$36,$31 ;address to jump to in ASCII code: "2061" <br />
.byte $00 ;end of BASIC line<br />
.word $0000 ;address of next BASIC line, $0000 means end of BASIC program <br />
start<br />
; your code here<br />
</syntaxhighlight><br />
<br />
Together with the 2 byte load address, this makes an overhead of 14 byte for your program. To reduce this, you can<br />
* omit the BASIC line and tell users to start your program by directly entering "SYS ''address''"<br />
* save your program from $0802 on, the byte at $0801 is recovered automatically after loading by the relink function. This reduces your program file size by 1 byte<br />
* accept the loss and use the 2 byte establishing LINENR for something good, they are copied to zeropage addresses $39/$3a automatically, saving you the effort of initializing the addresses<br />
* use an autostart method (see below)<br />
<br />
Some compos also specify that the BASIC loader does not count towards the overall filesize, check the rules before you worry.<br />
<br />
=== Autostart ===<br />
<br />
Unlike the Commodore 128, the Commodore 64 has no dedicated built-in auto-boot feature, but it is possible to autorun a program after loading by specifying the load address so that it overwrites a vector or address that is called by the operating system. There are multiple possibilities:<br />
<br />
==== Overwriting CHROUT vector at $326-$327 ====<br />
<br />
The vector at address $326-$327 points at the CHROUT routine, normally at address $F1CA.<br />
If you put the entry address of your program into $326/27, your code will be called when the operating system wants to print "READY." after loading.<br />
Note that the vector at address $328-$329 points at the STOP routine that checks the status of Stop key indicator. Since this routine is called multiple times before your code is done loading, its default value $F6ED needs to be preserved. <br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$0326<br />
.word start <br />
.byte $ed,$f6<br />
start<br />
; rest of code<br />
</syntaxhighlight><br />
<br />
Together with the two byte load address, the overwritten CHROUT vector and the preserved STOP vector, your program file will have a deadweight of 6 byte: $26 $03 $0a $03 $ed $f6, less than half of the standard version with a BASIC stub with SYS<br />
<br />
Caveat:<br />
* If your program after $32a is longer than 214 byte, part of your program will load into the screen at $400. Thus, issuing a clear screen will overwrite your program. It is possible to move the screen memory somewhere else, but that requires storing a new value into address $D018, which when done with an LDA # / STA pair will cost you 5 byte<br />
* Since you changed the CHROUT pointer, standard KERNAL functions for printing won't work. For output of single characters, you can still use the direct address $F1CA. Alternatively, you can restore the vectors by calling $FD15, which will overwrite the memory $314 to $333 with the default values.<br />
<br />
=== Video display ===<br />
Video display on the Commodore, it has the following video modes:<br />
<br />
To be added soon.<br />
<br />
==== Getting something on screen ====<br />
<br />
Output a character:<br />
<syntaxhighlight lang="6502"><br />
lda #C ;C must be the char code according to the PETSCII code table<br />
jsr $FFD2 ;you can also use the direct address $FC1A, function preserves A,X,Y and enables interrupt<br />
</syntaxhighlight><br />
<br />
Since the [https://en.wikipedia.org/wiki/PETSCII#Character_set PETSCII code table] contains also control characters, this method can be also used to clear the screen, move the cursor or set the text color. However, some functions are shorter (and faster) by directly calling the respective KERNAL function:<br />
<br />
<syntaxhighlight lang="6502"><br />
Clear screen JSR $E544<br />
Cursor home position JSR $E566<br />
Output newline character JSR $AAD7<br />
Set text color LDA #COLOR, STA $286<br />
Set border color LDA #COLOR, STA $D020 ;not possible with a PETSCII control code<br />
Set background color LDA #COLOR, STA $D021 ;not possible with a PETSCII control code<br />
</syntaxhighlight><br />
<br />
Copy characters directly to screen memory:<br />
<br />
<syntaxhighlight lang="6502"><br />
.macpack cbm ;scrcode macro<br />
SCREEN_BASE=$400<br />
LINE=5 ;for example<br />
COLUMN=10 ;for example<br />
<br />
ldx #endtext-text-1<br />
@loop: lda text,x<br />
sta SCREEN_BASE+LINE*40+COLUMN,x<br />
dex<br />
bpl @loop<br />
text: scrcode "hello world!"<br />
endtext:<br />
</syntaxhighlight><br />
<br />
Note that the text needs to be stored in '''screen code''' format, not in PETSCII (see [https://sta.c64.org/cbm64pettoscr.html Commodore 64 PETSCII code to screen code conversion] for the differences). Furthermore, the example above only writes to the screen memory, not the color RAM, assuming that the color RAM already contains the intended text color. This is the case after issuing a clear screen on most C64 machines, except for some old ROM revisions. To be on the save side you would have to write to color RAM as well, which costs another 5 byte:<br />
<br />
<syntaxhighlight lang="6502"><br />
.macpack cbm ;scrcode macro<br />
SCREEN_BASE=$400<br />
COLOR_RAM =$D800<br />
LINE =5 ;for example<br />
COLUMN =10 ;for example<br />
COLOR =1 ;white<br />
<br />
ldx #endtext-text-1<br />
@loop: lda text,x<br />
sta SCREEN_BASE+LINE*40+COLUMN,x<br />
lda #COLOR<br />
sta COLOR_RAM +LINE*40+COLUMN,x<br />
dex<br />
bpl @loop<br />
text: scrcode "hello world!"<br />
endtext:<br />
</syntaxhighlight><br />
<br />
=== Sound ===<br />
The Commodore 64 uses the famous SID chip to generate sound.<br />
To be added soon.<br />
<br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Additional Resources ===<br />
* Codebase 64 https://codebase64.org/doku.php?id=base:start<br />
<br />
== Apple II ==<br />
The Apple II is an 8-bit home computer and one of the world's first highly successful mass-produced microcomputer products. It was designed primarily by Steve Wozniak.<br />
<br />
=== Setting up ===<br />
* ACME 6502 cross-assembler(https://sourceforge.net/projects/acme-crossass/)<br />
* Apple Commander (http://applecommander.sourceforge.net) for batch compilation<br />
* AppleWin emulator (https://github.com/AppleWin/AppleWin/releases). Supports Mockingboard card(AY-8910+speech synthesier), HDD, Z80 card(for CP/M), mouse etc.<br />
* CiderPress(https://a2ciderpress.com)<br />
<br />
Compilation can be done as follows (master.dsk can be found with applewin) <br />
<syntaxhighlight><br />
acme hl.asm<br />
java -jar AppleCommander-1.3.5.jar -d master.dsk hl<br />
java -jar AppleCommander-1.3.5.jar -p master.dsk hl B 24576 < hl.bin<br />
</syntaxhighlight><br />
<br />
=== Memory Map ===<br />
<syntaxhighlight lang="6502"><br />
0-255 $0-$FF ZERO-PAGE SYSTEM STORAGE<br />
256-511 $100-$1FF SYSTEM STACK<br />
512-767 $200-$2FF KEYBOARD CHARACTER BUFFER<br />
768-975 $300-$3CF OFTEN AVAILABLE AS FREE SPACE FOR USER PROGRAMS<br />
976-1023 $3D0-3FF SYSTEM VECTORS<br />
1024-2047 $400-$7FF TEXT AND LO-RES GRAPHICS PAGE 1 <--- !!!<br />
2048-LOMEM $800-LOMEM PROGRAM STORAGE<br />
2048-3071 $800-$BFF TEXT AND LO-RES GRAPHICS PAGE 2 OR FREE SPACE<br />
3072-8191 $C00-$1FFF FREE SPACE UNLESS RAM APPLESOFT IS IN USE<br />
8192-16383 $2000-$3FFF HI-RES PAGE 1 OR FREE SPACE <--- !!!<br />
16384-24575 $4000-$5FFF HI-RES PAGE 2 OR FREE SPACE<br />
24576-38999 $6000-$95FF FREE SPACE AND STRING STORAGE<br />
38400-49151 $9600-$BFFF DOS<br />
49152-53247 $C000-$CFFF I/O HARDWARE (RESERVED)<br />
53248-57343 $D000-$DFFF APPLESOFT IN LANGUAGE CARD OR ROM<br />
57344-63487 $E000-$F7FF APPLESOFT OR INTEGER BASIC IN LANGUAGE CARD OR ROM<br />
63488-65535 $F800-$FFFF SYSTEM MONITOR<br />
</syntaxhighlight><br />
<br />
=== Display ===<br />
<br />
=== Graphics Modes ===<br />
: Text Mode 40x24, for Apple IIe available 80x25 - use PR#3 for switch mode, or hardware switch<br />
: LowRes 40x48, 16 colors: https://en.wikipedia.org/wiki/Apple_II_graphics <br />
: Hires mode 280x192,6 colors: https://www.xtof.info/blog/?p=768<br />
https://mrob.com/pub/xapple2/colors.html<br />
https://archive.org/details/HiRes_Color_Graphics_on_the_Apple_II_Computer_by_Wozniak<br />
<br />
However for sizecoding, you almost never want to do direct-access to graphics for Apple II in size-coding because the Apple II graphics modes are horrible. The only fast way to do things is with large lookup tables. To do hires you need to divide by 7 which as you can imagine is a bit difficult to do compactly on 6502. Double-hires is even crazier on top of that. Deater did manage a color-bar style effect in double-hires in 128B but that was doing some crazy tricks with the firmware BASIC routines, definitely not direct-access.<br />
<br />
Lores and Hires can be mixed modes and full-graphics<br />
The screen structure is called memory holes(https://retrocomputing.stackexchange.com/questions/2534/what-are-the-screen-holes-in-apple-ii-graphics). The GBASCALC($F847) procedure is used to calculate the address of the horizontal line : IN:reg.A=Y, out : GBASL/GBASH($26/$27)=address. See also https://www.callapple.org/uncategorized/use-of-apple-ii-color-graphics-in-assembly-language/<br />
<br />
==== Getting something on screen ====<br />
Here is an example of a XOR texture, created by g0blinish<br />
<syntaxhighlight lang="6502"><br />
*=$6000<br />
!to "HL.bin", plain ; set output file and format<br />
!cpu 6502 ; set processor type<br />
<br />
GBASL = $26<br />
GBASH = $27<br />
SETGR = $FB40 ; setup LoRes<br />
GBASCALC = $F847 ; calc Address<br />
<br />
CLRTEXT = $C050 ;display graphics <br />
SETTEXT = $C051 ;display text <br />
<br />
CLRMIXED = $C052 ;clear mixed mode- enable full graphics <br />
SETMIXED = $C053 ;enable graphics/text mixed mode <br />
<br />
PAGE1 = $C054 ;select text/graphics page1 <br />
PAGE2 = $C055 ;select text/graphics page2 <br />
<br />
CLRHIRES = $C056 ;select Lo-res <br />
SETHIRES = $C057 ;select Hi-res <br />
<br />
TMP= $FA<br />
<br />
JSR SETGR ;GR<br />
BIT CLRMIXED ; full screen<br />
<br />
LDA #0 ; A=0<br />
STA TMP ; POKE $FA,A<br />
<br />
YLP ;<br />
LDA TMP ; A=PEEK($FA)<br />
; LSR ; A=A/2<br />
JSR GBASCALC<br />
LDY #0;Y=0<br />
<br />
XLP TYA ; A=Y<br />
EOR TMP ; A=A xor PEEK($FA)<br />
and #$0F ; A=A and 15<br />
TAX ; X=A<br />
LDA COLORS,X ;A=PEEK(COLORS+X)<br />
STA(GBASL),Y ; POKE PEEK($26)+256*PEEK($27)+Y,A<br />
INY ; Y=Y+1<br />
CPY #40 ; Y=40?<br />
BNE XLP<br />
INC TMP ; POKE $FA,PEEK($FA)+1<br />
LDA TMP ; A=PEEK($FA)<br />
CMP #24 ; A=24?<br />
BNE YLP<br />
<br />
M1 JMP M1 ; replace to RTS<br />
<br />
COLORS ;N*17, pixel format is AAAABBBB, AAAA - upper dot, BBBB - lower dot<br />
!byte $00,$11,$22,$33,$44,$55,$66,$77<br />
!byte $88,$99,$AA,$BB,$CC,$DD,$EE,$FF<br />
</syntaxhighlight><br />
<br />
==== Sound ====<br />
Here is an example for using the speaker, based onthe following basic program:<br />
<br />
<syntaxhighlight lang="basic"><br />
; 50 POKE 768,V: POKE 769,P - 255 * INT (P / 256): POKE 800,1 + P / 256<br />
; 60 CALL 770: RETURN <br />
; 95 FOR K = 1 TO N: READ V(K),P(K): NEXT K<br />
; 100 FOR K = 1 TO N:V = V(K):P = P(K)<br />
; 110 GOSUB 50<br />
;!byte 173,48,192,136,208,5,206,1,3,240,9,202,208,245,174,0,3,76,2,3,206,32,3,208,240,96<br />
</syntaxhighlight><br />
<br />
<syntaxhighlight lang="6502"><br />
*=$6000<br />
!to "HL.bin", plain ; set output file and format<br />
!cpu 6502 ; set processor type<br />
<br />
;start<br />
; 95 FOR K = 1 TO N: READ V(K),P(K): NEXT K<br />
; 100 FOR K = 1 TO N:V = V(K):P = P(K)<br />
ini:<br />
lda #70<br />
sta cnt+1<br />
lda #music&255<br />
sta gotbyte+1<br />
lda #music/256<br />
sta gotbyte+2<br />
<br />
lop:<br />
;V<br />
jsr gotbyte<br />
sta L300<br />
jsr gotbyte<br />
;P<br />
jsr gotbyte<br />
sta L301<br />
jsr gotbyte<br />
clc<br />
adc #1<br />
sta L320<br />
jsr beep<br />
<br />
dec cnt+1<br />
cnt lda #70<br />
bne lop<br />
; 110 GOSUB 50<br />
; 50 POKE 768,V: POKE 769,P - 255 * INT (P / 256): POKE 800,1 + P / 256<br />
; 60 CALL 770: RETURN <br />
jmp ini<br />
gotbyte<br />
lda music<br />
inc gotbyte+1<br />
bne noinch<br />
inc gotbyte+2<br />
noinch<br />
rts<br />
;!byte 173,48,192,136,208,5,206,1,3,240,9,202,208,245,174,0,3,76,2,3,206,32,3,208,240,96<br />
beep:<br />
ldy #1<br />
ldx #1<br />
loc_302:<br />
LDA $C030<br />
<br />
loc_305:<br />
DEY<br />
BNE loc_30D<br />
DEC L301<br />
loc_30B:<br />
BEQ loc_316<br />
<br />
loc_30D:<br />
DEX<br />
BNE loc_305<br />
LDX L300<br />
JMP loc_302<br />
loc_316:<br />
DEC L320<br />
BNE loc_30B<br />
RTS<br />
L301 !byte 0<br />
L300 !byte 0<br />
L320 !byte 0<br />
music<br />
!word 76,192,85,64,96,64,102,64,114,128,114,64,96,64,102,64,114,64,128,64<br />
!word 114,64,152,64,171,64,152,512,76,192,85,64,96,64,102,64,114,128,114,64<br />
!word 96,64,102,64,114,64,128,64,114,64,152,64,171,64,152,512,85,64,85,64<br />
!word 85,64,96,64,144,128,144,64,128,64,76,128,85,64,96,64,144,128,114,64<br />
!word 96,64,102,128,114,64,128,64,128,128,114,64,128,64,114,512,85,64,85,64<br />
!word 85,64,96,64,144,128,144,64,128,64,76,128,85,64,96,64,144,128,114,64<br />
!word 96,64,102,128,114,64,128,64,128,64,128,128,96,64,85,64,96,64,102,64,114,64,114,64<br />
</syntaxhighlight><br />
<br />
=== Additional Resources ===<br />
* Deater's page on Apple II sizecoding http://www.deater.net/weave/vmwprod/demos/sizecoding.html<br />
* Article on double hi-res http://www.battlestations.zone/2017/04/apple-ii-double-hi-res-from-ground-up.html<br />
* Applesoft Hi-Res Subroutines : http://hackzapple.org/scripts_php/index.php?menu=5&mod=ASM&sub=AAL&sub2=8112&PHPSESSID=f65fabfd0cdbf56b6bdc0ddac25117c6#a2<br />
<br />
== Atari Lynx ==<br />
The Atari Lynx consists of the 6502 with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Atari Lynx:<br />
<br />
* Assembler: -<br />
* Emulator(s): -<br />
<br />
=== Video display ===<br />
To be added soon.<br />
<br />
==== Getting something on screen ====<br />
To be added soon.<br />
<br />
<br />
=== Sound ===<br />
To be added soon.<br />
<br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Additional Resources ===<br />
Sizecoding resource for the Atari Lynx are sparse<br />
* 42Bastian's website (link to be added)</div>Wilhttp://www.sizecoding.org/index.php?title=6502&diff=82265022021-02-15T20:56:34Z<p>Wil: added info for screen output in text mode</p>
<hr />
<div>== Introduction ==<br />
Wanting to start sizecoding on a 6502 platform in this day and age can be tough. <br />
<br />
[[File:6502.jpg|thumb]]<br />
<br />
So here is a bit of help to get you started:<br />
<br />
=== The 6502 processor ===<br />
The 6502 processor can be seen as the 8-bit micro ARM chip. <br />
It has only has 3 registers (Accumulator, X and Y registers) and a handful of instructions to work with.<br />
<br />
=== Adressing modes ===<br />
To be added.<br />
<br />
=== Zero page ===<br />
When using the 6502 for sizecoding, you'll mostly be working from zeropage<br />
<br />
=== General 6502 Resources ===<br />
* 6502.org http://www.6502.org/<br />
* 6502 instruction reference http://www.6502.org/tutorials/6502opcodes.html<br />
* 6502 books http://retro.hansotten.nl/6502-sbc/<br />
* 6502 Assembler tutorial https://dwheeler.com/6502/oneelkruns/asm1step.html<br />
* Easy 6502 code tester https://skilldrick.github.io/easy6502/<br />
* Synthetic instructions https://wiki.nesdev.com/w/index.php/Synthetic_instructions#8-bit_rotate<br />
<br />
== Atari 8-bit family ==<br />
The systems in this family are: Atari 400, 800, 5200, 1200XL, 600XL, 800XL, 130XE, 65XE, 800XE and XEGS.<br /><br />
<br />
The Atari 8-bit systems consists of the 6502 with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Atari 8bit systems is quite easy, first get the following tools:<br />
<br />
* Assembler: MADS Assembler - This assembler has nice macros for creating Binaries and SNA snapshot files out of the box. You can download it at https://mads.atari8.info/<br />
* Emulator(s): I Found Altirra to work best for my usecase. Make sure to use the original Rev2 rom for best compatibility.<br />
<br />
==== Special Memory Adresses ====<br />
* FRAMECOUNTER_HIGH = 19<br />
* FRAMECOUNTER_LOW = 20<br />
<br />
=== Video display ===<br />
Video display on the Atari 8bit systems use the ANTIC and GTIA chips. Information can be found here:<br />
* https://en.wikipedia.org/wiki/ANTIC<br />
* https://www.atariarchives.org/agagd/chapter1.php<br />
<br />
==== Sync with frame ====<br />
<syntaxhighlight lang="6502"><br />
RTCLOK equ $0012<br />
lda RTCLOK+2<br />
waits<br />
cmp RTCLOK+2<br />
beq waits<br />
</syntaxhighlight><br />
<br />
Or if you don't mind trashing RTCLOK<br />
<br />
<syntaxhighlight lang="6502"><br />
RTCLOK equ $0012<br />
waits<br />
lsr RTCLOK+2<br />
bcc waits<br />
</syntaxhighlight><br />
<br />
Which is two bytes shorter.<br />
<br />
==== Getting something on screen ====<br />
<syntaxhighlight lang="6502"><br />
;fill screen with charset,(88,89)=an address<br />
org $600; free 6th page:600-6ff<br />
ldy #0<br />
fl: tya<br />
sta(88),y<br />
iny<br />
bne fl<br />
jmp *<br />
</syntaxhighlight><br />
<br />
To be added soon.<br />
<br />
<syntaxhighlight lang="6502"><br />
SDMCTL = $022f<br />
HPOSP0 = $d000<br />
SIZEP0 = $d008<br />
GRAFP0 = $d00d<br />
COLPM0 = $d012<br />
<br />
FRAMECOUNTER_HIGH = 19<br />
FRAMECOUNTER = 20<br />
WSYNC = $d40a<br />
VCOUNT = $d40b<br />
<br />
sinewave = $0600 ; to $06ff<br />
<br />
org $80<br />
<br />
main <br />
; disable all graphics/colors<br />
ldx #0<br />
stx SDMCTL <br />
<br />
ldy #$7f<br />
sty SIZEP0 ; size p0=127<br />
<br />
ldx #0<br />
ldy #$3f<br />
make_sine:<br />
value_lo<br />
lda #0<br />
clc<br />
delta_lo<br />
adc #0<br />
sta value_lo+1<br />
value_hi<br />
lda #0<br />
delta_hi<br />
adc #0<br />
sta value_hi+1<br />
<br />
sta sinewave+$c0,x<br />
sta sinewave+$80,y<br />
eor #$7f<br />
sta sinewave+$40,x<br />
sta sinewave+$00,y<br />
<br />
lda delta_lo+1<br />
adc #8<br />
sta delta_lo+1<br />
bcc nothing<br />
inc delta_hi+1<br />
nothing<br />
inx<br />
dey<br />
bpl make_sine<br />
<br />
updateloop:<br />
; vblank<br />
lda VCOUNT<br />
bne updateloop<br />
<br />
; clear graphics<br />
sta HPOSP0<br />
sta GRAFP0<br />
<br />
ldy #0<br />
lda #47<br />
sta COLPM0<br />
yloop:<br />
tya ; graphics shape = y<br />
sta WSYNC<br />
sta GRAFP0<br />
<br />
; a = sin(frame+y)+48<br />
tya <br />
adc FRAMECOUNTER<br />
tax<br />
lda sinewave,x<br />
adc #48<br />
sta HPOSP0<br />
<br />
iny<br />
bne yloop<br />
jmp updateloop<br />
<br />
run main<br />
</syntaxhighlight><br />
<br />
=== Sound ===<br />
The Atari 8-bit use the POKEY chip to generate sound.<br />
* https://en.wikipedia.org/wiki/POKEY<br />
<br />
==== BASIC ====<br />
<syntaxhighlight lang="6502"><br />
; from Analog, 1985-09,pp.25-32<br />
*=$2000<br />
AUDF1=$D200<br />
AUDC1=$D201<br />
AUDCTL=$D208<br />
SKCTL=$D20F<br />
<br />
.MACRO SOUND ; voice,pitch,dist,vol;,dur<br />
lda #%2<br />
sta AUDF1+2*%1<br />
lda #[[%3 * 16] | %4] ;lda #[[%3 shl 4] or %4]<br />
sta AUDC1+2*%1<br />
.ENDM<br />
<br />
lda #0<br />
sta AUDCTL<br />
lda #3<br />
sta SKCTL<br />
<br />
SOUND 0,121,10,8<br />
<br />
jmp *<br />
</syntaxhighlight><br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Additional Resources ===<br />
Sizecoding resource for the Atari 8bit are:<br />
* Mapping the Atari https://www.atariarchives.org/mapping/<br />
* Atari 8bit Memory map https://www.atariarchives.org/mapping/memorymap.php<br />
* Fready's undocumented 6502 opcodes https://github.com/FreddyOffenga/6502<br />
* Atari OS Rev2 disassembly for MADS assembler https://github.com/ilmenit/A800-OS-XL-Rev2<br />
* Fready's github https://github.com/FreddyOffenga/<br />
<br />
== Commodore 64 ==<br />
The Commodore system consists of a 6502-compatible MOS 6510 processor with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Commodore systems is quite easy, first get the following tools:<br />
<br />
* Assembler: To be added<br />
* Emulator(s): VICE is the way to go<br />
<br />
=== Memory map ===<br />
<br />
<syntaxhighlight lang="6502"><br />
0-1 $0-$1 PROCESSOR PORT REGISTERS, not usable as RAM<br />
0-255 $0-$FF ZEROPAGE, mostly used by BASIC interpreter and Kernal<br />
256-511 $100-$1FF SYSTEM STACK<br />
512-600 $200-$258 INPUT BUFFER<br />
601-630 $259-$276 FILE SYSTEM DATA<br />
631-640 $277-$280 KEYBOARD BUFFER, filled by Kernal ISR upon key presses <br />
641-678 $281-$2A6 VARIOUS KERNAL VARIABLES<br />
679-767 $2A7-$2FF Unused (89 byte)<br />
768-779 $300-$30B KERNAL VECTORS<br />
780-783 $30C-$30F REGISTER VALUES A,X,Y,SR for SYS<br />
784-819 $310-$333 KERNAL VECTORS<br />
820-827 $334-$33B Unused (8 byte)<br />
828-1019 $33C-$3FB DATASETTE BUFFER<br />
1020-1023 $3FC-$3FF Unused (4 byte)<br />
1024-2023 $400-$7E7 SCREEN MEMORY (25 lines times 40 columns)<br />
2024-2039 $7E8-$7F7 Unused (16 byte)<br />
2040-2047 $7F8-$7FF SPRITE COSTUME POINTERS<br />
2048 $800 must contain a value of 0 so that the BASIC program can be RUN<br />
2049-40959 $801-$9FFF BASIC AREA (code, variables, arrays, strings)<br />
40960-49151 $A000-$BFFF BASIC ROM (unused RAM underneath)<br />
49152-53247 $C000-$CFFF UPPER RAM AREA (unused)<br />
53248-53294 $D000-$D02E VIC-II, memory-mapped graphics chip registers)<br />
54272-54300 $D400-$D41C SID, memory-mapped sound chip registers)<br />
55296-56295 $D800-$DBE7 Color RAM, only lower 4 bits are stored, higher nibble undefined<br />
56296-56319 $DBE8-$DBFF Unused (24 half-bytes)<br />
56320-56335 $DC00-$DC0F CIA#1, memory-mapped I/O chip registers for keyboard, joystick, mouse, datasette, IRQ control<br />
56576-56591 $DD00-$DD0F CIA#1, memory-mapped I/O chip registers for serial bus, RS232, NMI control<br />
57344-65535 $E000-$FFFF KERNAL ROM<br />
65534-65535 $FFFE-$FFFF Execution address of interrupt service routine, can only be set if KERNAL is turned off<br />
</syntaxhighlight><br />
<br />
For a detailed explanation of the C64 memory map check out [https://sta.c64.org/cbm64mem.html Commodore 64 memory map] on Joe Forster/STA homepage.<br />
<br />
=== Program file overhead ===<br />
<br />
A standard CBM file consists of a 2 byte loading address followed by the data that is placed into memory starting at this address. In addition, if your machine program should be able to be started with "RUN", you need a BASIC stub that is loaded into memory from $0801 to $080c, typically followed by your machine program:<br />
<br />
<syntaxhighlight lang="6502"><br />
*=$0801<br />
.word $080b ;address of next BASIC line<br />
.word LINENR ;line number, can be chosen between 0 and 63999<br />
.byte $9e ;token for SYS command<br />
.byte $32,$30,$36,$31 ;address to jump to in ASCII code: "2061" <br />
.byte $00 ;end of BASIC line<br />
.word $0000 ;address of next BASIC line, $0000 means end of BASIC program <br />
start<br />
; your code here<br />
</syntaxhighlight><br />
<br />
Together with the 2 byte load address, this makes an overhead of 14 byte for your program. To reduce this, you can<br />
* omit the BASIC line and tell users to start your program by directly entering "SYS ''address''"<br />
* save your program from $0802 on, the byte at $0801 is recovered automatically after loading by the relink function. This reduces your program file size by 1 byte<br />
* accept the loss and use the 2 byte establishing LINENR for something good, they are copied to zeropage addresses $39/$3a automatically, saving you the effort of initializing the addresses<br />
* use an autostart method (see below)<br />
<br />
Some compos also specify that the BASIC loader does not count towards the overall filesize, check the rules before you worry.<br />
<br />
=== Autostart ===<br />
<br />
Unlike the Commodore 128, the Commodore 64 has no dedicated built-in auto-boot feature, but it is possible to autorun a program after loading by specifying the load address so that it overwrites a vector or address that is called by the operating system. There are multiple possibilities:<br />
<br />
==== Overwriting CHROUT vector at $326-$327 ====<br />
<br />
The vector at address $326-$327 points at the CHROUT routine, normally at address $F1CA.<br />
If you put the entry address of your program into $326/27, your code will be called when the operating system wants to print "READY." after loading.<br />
Note that the vector at address $328-$329 points at the STOP routine that checks the status of Stop key indicator. Since this routine is called multiple times before your code is done loading, its default value $F6ED needs to be preserved. <br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$0326<br />
.word start <br />
.byte $ed,$f6<br />
start<br />
; rest of code<br />
</syntaxhighlight><br />
<br />
Together with the two byte load address, the overwritten CHROUT vector and the preserved STOP vector, your program file will have a deadweight of 6 byte: $26 $03 $0a $03 $ed $f6, less than half of the standard version with a BASIC stub with SYS<br />
<br />
Caveat:<br />
* If your program after $32a is longer than 214 byte, part of your program will load into the screen at $400. Thus, issuing a clear screen will overwrite your program. It is possible to move the screen memory somewhere else, but that requires storing a new value into address $D018, which when done with an LDA # / STA pair will cost you 5 byte<br />
* Since you changed the CHROUT pointer, standard KERNAL functions for printing won't work. For output of single characters, you can still use the direct address $F1CA. Alternatively, you can restore the vectors by calling $FD15, which will overwrite the memory $314 to $333 with the default values.<br />
<br />
=== Video display ===<br />
Video display on the Commodore, it has the following video modes:<br />
<br />
To be added soon.<br />
<br />
==== Getting something on screen ====<br />
<br />
Output a character:<br />
<syntaxhighlight lang="6502"><br />
lda #C ;C must be the char code according to the PETSCII code table<br />
jsr $FFD2 ;you can also use the direct address $FC1A, function preserves A,X,Y and enables interrupt<br />
</syntaxhighlight><br />
<br />
Since the [https://en.wikipedia.org/wiki/PETSCII#Character_set PETSCII code table] contains also control characters, this method can be also used to clear the screen, move the cursor or set the text color. However, some functions are shorter (and faster) by directly calling the respective KERNAL function:<br />
<br />
<syntaxhighlight lang="6502"><br />
Clear screen JSR $E544<br />
Cursor home position JSR $E566<br />
Output newline character JSR $AAD7<br />
Set text color LDA #COLOR, STA $286<br />
Set border color LDA #COLOR, STA $D020 ;not possible with a PETSCII control code<br />
Set background color LDA #COLOR, STA $D021 ;not possible with a PETSCII control code<br />
</syntaxhighlight><br />
<br />
Copy characters directly to screen memory:<br />
<br />
<syntaxhighlight lang="6502"><br />
.macpack cbm ;scrcode macro<br />
SCREEN_BASE=$400<br />
LINE=5 ;for example<br />
COLUMN=10 ;for example<br />
<br />
ldx #endtext-text-1<br />
@loop: lda text,x<br />
sta SCREEN_BASE+LINE*40+COLUMN,x<br />
dex<br />
bpl @loop<br />
text: scrcode "hello world!"<br />
endtext:<br />
</syntaxhighlight><br />
<br />
Note that the text needs to be stored in '''screen code''' format, not in PETSCII (see [https://sta.c64.org/cbm64pettoscr.html Commodore 64 PETSCII code to screen code conversion] for the differences). Furthermore, the example above only writes to the screen memory, not the color RAM, assuming that the color RAM already contains the intended text color. This is the case after issuing a clear screen on most C64 machines, except for some old ROM revisions. To be on the save side you would have to write to color RAM as well, which costs another 5 byte:<br />
<br />
<syntaxhighlight lang="6502"><br />
.macpack cbm ;scrcode macro<br />
SCREEN_BASE=$400<br />
COLOR_RAM =$D800<br />
LINE =5 ;for example<br />
COLUMN =10 ;for example<br />
COLOR =1 ;white<br />
<br />
ldx #endtext-text-1<br />
@loop: lda text,x<br />
sta SCREEN_BASE+LINE*40+COLUMN,x<br />
lda #COLOR<br />
sta COLOR_RAM +LINE*40+COLUMN,x<br />
dex<br />
bpl @loop<br />
text: scrcode "hello world!"<br />
endtext:<br />
</syntaxhighlight><br />
<br />
=== Sound ===<br />
The Commodore 64 uses the famous SID chip to generate sound.<br />
To be added soon.<br />
<br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Additional Resources ===<br />
* Codebase 64 https://codebase64.org/doku.php?id=base:start<br />
<br />
== Apple II ==<br />
The Apple II is an 8-bit home computer and one of the world's first highly successful mass-produced microcomputer products. It was designed primarily by Steve Wozniak.<br />
<br />
=== Setting up ===<br />
* ACME 6502 cross-assembler(https://sourceforge.net/projects/acme-crossass/)<br />
* Apple Commander (http://applecommander.sourceforge.net) for batch compilation<br />
* AppleWin emulator (https://github.com/AppleWin/AppleWin/releases). Supports Mockingboard card(AY-8910+speech synthesier), HDD, Z80 card(for CP/M), mouse etc.<br />
* CiderPress(https://a2ciderpress.com)<br />
<br />
Compilation can be done as follows (master.dsk can be found with applewin) <br />
<syntaxhighlight><br />
acme hl.asm<br />
java -jar AppleCommander-1.3.5.jar -d master.dsk hl<br />
java -jar AppleCommander-1.3.5.jar -p master.dsk hl B 24576 < hl.bin<br />
</syntaxhighlight><br />
<br />
=== Memory Map ===<br />
<syntaxhighlight lang="6502"><br />
0-255 $0-$FF ZERO-PAGE SYSTEM STORAGE<br />
256-511 $100-$1FF SYSTEM STACK<br />
512-767 $200-$2FF KEYBOARD CHARACTER BUFFER<br />
768-975 $300-$3CF OFTEN AVAILABLE AS FREE SPACE FOR USER PROGRAMS<br />
976-1023 $3D0-3FF SYSTEM VECTORS<br />
1024-2047 $400-$7FF TEXT AND LO-RES GRAPHICS PAGE 1 <--- !!!<br />
2048-LOMEM $800-LOMEM PROGRAM STORAGE<br />
2048-3071 $800-$BFF TEXT AND LO-RES GRAPHICS PAGE 2 OR FREE SPACE<br />
3072-8191 $C00-$1FFF FREE SPACE UNLESS RAM APPLESOFT IS IN USE<br />
8192-16383 $2000-$3FFF HI-RES PAGE 1 OR FREE SPACE <--- !!!<br />
16384-24575 $4000-$5FFF HI-RES PAGE 2 OR FREE SPACE<br />
24576-38999 $6000-$95FF FREE SPACE AND STRING STORAGE<br />
38400-49151 $9600-$BFFF DOS<br />
49152-53247 $C000-$CFFF I/O HARDWARE (RESERVED)<br />
53248-57343 $D000-$DFFF APPLESOFT IN LANGUAGE CARD OR ROM<br />
57344-63487 $E000-$F7FF APPLESOFT OR INTEGER BASIC IN LANGUAGE CARD OR ROM<br />
63488-65535 $F800-$FFFF SYSTEM MONITOR<br />
</syntaxhighlight><br />
<br />
=== Display ===<br />
<br />
=== Graphics Modes ===<br />
: Text Mode 40x24, for Apple IIe available 80x25 - use PR#3 for switch mode, or hardware switch<br />
: LowRes 40x48, 16 colors: https://en.wikipedia.org/wiki/Apple_II_graphics <br />
: Hires mode 280x192,6 colors: https://www.xtof.info/blog/?p=768<br />
https://mrob.com/pub/xapple2/colors.html<br />
https://archive.org/details/HiRes_Color_Graphics_on_the_Apple_II_Computer_by_Wozniak<br />
<br />
However for sizecoding, you almost never want to do direct-access to graphics for Apple II in size-coding because the Apple II graphics modes are horrible. The only fast way to do things is with large lookup tables. To do hires you need to divide by 7 which as you can imagine is a bit difficult to do compactly on 6502. Double-hires is even crazier on top of that. Deater did manage a color-bar style effect in double-hires in 128B but that was doing some crazy tricks with the firmware BASIC routines, definitely not direct-access.<br />
<br />
Lores and Hires can be mixed modes and full-graphics<br />
The screen structure is called memory holes(https://retrocomputing.stackexchange.com/questions/2534/what-are-the-screen-holes-in-apple-ii-graphics). The GBASCALC($F847) procedure is used to calculate the address of the horizontal line : IN:reg.A=Y, out : GBASL/GBASH($26/$27)=address. See also https://www.callapple.org/uncategorized/use-of-apple-ii-color-graphics-in-assembly-language/<br />
<br />
==== Getting something on screen ====<br />
Here is an example of a XOR texture, created by g0blinish<br />
<syntaxhighlight lang="6502"><br />
*=$6000<br />
!to "HL.bin", plain ; set output file and format<br />
!cpu 6502 ; set processor type<br />
<br />
GBASL = $26<br />
GBASH = $27<br />
SETGR = $FB40 ; setup LoRes<br />
GBASCALC = $F847 ; calc Address<br />
<br />
CLRTEXT = $C050 ;display graphics <br />
SETTEXT = $C051 ;display text <br />
<br />
CLRMIXED = $C052 ;clear mixed mode- enable full graphics <br />
SETMIXED = $C053 ;enable graphics/text mixed mode <br />
<br />
PAGE1 = $C054 ;select text/graphics page1 <br />
PAGE2 = $C055 ;select text/graphics page2 <br />
<br />
CLRHIRES = $C056 ;select Lo-res <br />
SETHIRES = $C057 ;select Hi-res <br />
<br />
TMP= $FA<br />
<br />
JSR SETGR ;GR<br />
BIT CLRMIXED ; full screen<br />
<br />
LDA #0 ; A=0<br />
STA TMP ; POKE $FA,A<br />
<br />
YLP ;<br />
LDA TMP ; A=PEEK($FA)<br />
; LSR ; A=A/2<br />
JSR GBASCALC<br />
LDY #0;Y=0<br />
<br />
XLP TYA ; A=Y<br />
EOR TMP ; A=A xor PEEK($FA)<br />
and #$0F ; A=A and 15<br />
TAX ; X=A<br />
LDA COLORS,X ;A=PEEK(COLORS+X)<br />
STA(GBASL),Y ; POKE PEEK($26)+256*PEEK($27)+Y,A<br />
INY ; Y=Y+1<br />
CPY #40 ; Y=40?<br />
BNE XLP<br />
INC TMP ; POKE $FA,PEEK($FA)+1<br />
LDA TMP ; A=PEEK($FA)<br />
CMP #24 ; A=24?<br />
BNE YLP<br />
<br />
M1 JMP M1 ; replace to RTS<br />
<br />
COLORS ;N*17, pixel format is AAAABBBB, AAAA - upper dot, BBBB - lower dot<br />
!byte $00,$11,$22,$33,$44,$55,$66,$77<br />
!byte $88,$99,$AA,$BB,$CC,$DD,$EE,$FF<br />
</syntaxhighlight><br />
<br />
==== Sound ====<br />
Here is an example for using the speaker, based onthe following basic program:<br />
<br />
<syntaxhighlight lang="basic"><br />
; 50 POKE 768,V: POKE 769,P - 255 * INT (P / 256): POKE 800,1 + P / 256<br />
; 60 CALL 770: RETURN <br />
; 95 FOR K = 1 TO N: READ V(K),P(K): NEXT K<br />
; 100 FOR K = 1 TO N:V = V(K):P = P(K)<br />
; 110 GOSUB 50<br />
;!byte 173,48,192,136,208,5,206,1,3,240,9,202,208,245,174,0,3,76,2,3,206,32,3,208,240,96<br />
</syntaxhighlight><br />
<br />
<syntaxhighlight lang="6502"><br />
*=$6000<br />
!to "HL.bin", plain ; set output file and format<br />
!cpu 6502 ; set processor type<br />
<br />
;start<br />
; 95 FOR K = 1 TO N: READ V(K),P(K): NEXT K<br />
; 100 FOR K = 1 TO N:V = V(K):P = P(K)<br />
ini:<br />
lda #70<br />
sta cnt+1<br />
lda #music&255<br />
sta gotbyte+1<br />
lda #music/256<br />
sta gotbyte+2<br />
<br />
lop:<br />
;V<br />
jsr gotbyte<br />
sta L300<br />
jsr gotbyte<br />
;P<br />
jsr gotbyte<br />
sta L301<br />
jsr gotbyte<br />
clc<br />
adc #1<br />
sta L320<br />
jsr beep<br />
<br />
dec cnt+1<br />
cnt lda #70<br />
bne lop<br />
; 110 GOSUB 50<br />
; 50 POKE 768,V: POKE 769,P - 255 * INT (P / 256): POKE 800,1 + P / 256<br />
; 60 CALL 770: RETURN <br />
jmp ini<br />
gotbyte<br />
lda music<br />
inc gotbyte+1<br />
bne noinch<br />
inc gotbyte+2<br />
noinch<br />
rts<br />
;!byte 173,48,192,136,208,5,206,1,3,240,9,202,208,245,174,0,3,76,2,3,206,32,3,208,240,96<br />
beep:<br />
ldy #1<br />
ldx #1<br />
loc_302:<br />
LDA $C030<br />
<br />
loc_305:<br />
DEY<br />
BNE loc_30D<br />
DEC L301<br />
loc_30B:<br />
BEQ loc_316<br />
<br />
loc_30D:<br />
DEX<br />
BNE loc_305<br />
LDX L300<br />
JMP loc_302<br />
loc_316:<br />
DEC L320<br />
BNE loc_30B<br />
RTS<br />
L301 !byte 0<br />
L300 !byte 0<br />
L320 !byte 0<br />
music<br />
!word 76,192,85,64,96,64,102,64,114,128,114,64,96,64,102,64,114,64,128,64<br />
!word 114,64,152,64,171,64,152,512,76,192,85,64,96,64,102,64,114,128,114,64<br />
!word 96,64,102,64,114,64,128,64,114,64,152,64,171,64,152,512,85,64,85,64<br />
!word 85,64,96,64,144,128,144,64,128,64,76,128,85,64,96,64,144,128,114,64<br />
!word 96,64,102,128,114,64,128,64,128,128,114,64,128,64,114,512,85,64,85,64<br />
!word 85,64,96,64,144,128,144,64,128,64,76,128,85,64,96,64,144,128,114,64<br />
!word 96,64,102,128,114,64,128,64,128,64,128,128,96,64,85,64,96,64,102,64,114,64,114,64<br />
</syntaxhighlight><br />
<br />
=== Additional Resources ===<br />
* Deater's page on Apple II sizecoding http://www.deater.net/weave/vmwprod/demos/sizecoding.html<br />
* Article on double hi-res http://www.battlestations.zone/2017/04/apple-ii-double-hi-res-from-ground-up.html<br />
* Applesoft Hi-Res Subroutines : http://hackzapple.org/scripts_php/index.php?menu=5&mod=ASM&sub=AAL&sub2=8112&PHPSESSID=f65fabfd0cdbf56b6bdc0ddac25117c6#a2<br />
<br />
== Atari Lynx ==<br />
The Atari Lynx consists of the 6502 with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Atari Lynx:<br />
<br />
* Assembler: -<br />
* Emulator(s): -<br />
<br />
=== Video display ===<br />
To be added soon.<br />
<br />
==== Getting something on screen ====<br />
To be added soon.<br />
<br />
<br />
=== Sound ===<br />
To be added soon.<br />
<br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Additional Resources ===<br />
Sizecoding resource for the Atari Lynx are sparse<br />
* 42Bastian's website (link to be added)</div>Wilhttp://www.sizecoding.org/index.php?title=6502&diff=82165022021-02-15T20:19:40Z<p>Wil: Added a memory map overview for C64 section</p>
<hr />
<div>== Introduction ==<br />
Wanting to start sizecoding on a 6502 platform in this day and age can be tough. <br />
<br />
[[File:6502.jpg|thumb]]<br />
<br />
So here is a bit of help to get you started:<br />
<br />
=== The 6502 processor ===<br />
The 6502 processor can be seen as the 8-bit micro ARM chip. <br />
It has only has 3 registers (Accumulator, X and Y registers) and a handful of instructions to work with.<br />
<br />
=== Adressing modes ===<br />
To be added.<br />
<br />
=== Zero page ===<br />
When using the 6502 for sizecoding, you'll mostly be working from zeropage<br />
<br />
=== General 6502 Resources ===<br />
* 6502.org http://www.6502.org/<br />
* 6502 instruction reference http://www.6502.org/tutorials/6502opcodes.html<br />
* 6502 books http://retro.hansotten.nl/6502-sbc/<br />
* 6502 Assembler tutorial https://dwheeler.com/6502/oneelkruns/asm1step.html<br />
* Easy 6502 code tester https://skilldrick.github.io/easy6502/<br />
* Synthetic instructions https://wiki.nesdev.com/w/index.php/Synthetic_instructions#8-bit_rotate<br />
<br />
== Atari 8-bit family ==<br />
The systems in this family are: Atari 400, 800, 5200, 1200XL, 600XL, 800XL, 130XE, 65XE, 800XE and XEGS.<br /><br />
<br />
The Atari 8-bit systems consists of the 6502 with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Atari 8bit systems is quite easy, first get the following tools:<br />
<br />
* Assembler: MADS Assembler - This assembler has nice macros for creating Binaries and SNA snapshot files out of the box. You can download it at https://mads.atari8.info/<br />
* Emulator(s): I Found Altirra to work best for my usecase. Make sure to use the original Rev2 rom for best compatibility.<br />
<br />
==== Special Memory Adresses ====<br />
* FRAMECOUNTER_HIGH = 19<br />
* FRAMECOUNTER_LOW = 20<br />
<br />
=== Video display ===<br />
Video display on the Atari 8bit systems use the ANTIC and GTIA chips. Information can be found here:<br />
* https://en.wikipedia.org/wiki/ANTIC<br />
* https://www.atariarchives.org/agagd/chapter1.php<br />
<br />
==== Sync with frame ====<br />
<syntaxhighlight lang="6502"><br />
RTCLOK equ $0012<br />
lda RTCLOK+2<br />
waits<br />
cmp RTCLOK+2<br />
beq waits<br />
</syntaxhighlight><br />
<br />
Or if you don't mind trashing RTCLOK<br />
<br />
<syntaxhighlight lang="6502"><br />
RTCLOK equ $0012<br />
waits<br />
lsr RTCLOK+2<br />
bcc waits<br />
</syntaxhighlight><br />
<br />
Which is two bytes shorter.<br />
<br />
==== Getting something on screen ====<br />
<syntaxhighlight lang="6502"><br />
;fill screen with charset,(88,89)=an address<br />
org $600; free 6th page:600-6ff<br />
ldy #0<br />
fl: tya<br />
sta(88),y<br />
iny<br />
bne fl<br />
jmp *<br />
</syntaxhighlight><br />
<br />
To be added soon.<br />
<br />
<syntaxhighlight lang="6502"><br />
SDMCTL = $022f<br />
HPOSP0 = $d000<br />
SIZEP0 = $d008<br />
GRAFP0 = $d00d<br />
COLPM0 = $d012<br />
<br />
FRAMECOUNTER_HIGH = 19<br />
FRAMECOUNTER = 20<br />
WSYNC = $d40a<br />
VCOUNT = $d40b<br />
<br />
sinewave = $0600 ; to $06ff<br />
<br />
org $80<br />
<br />
main <br />
; disable all graphics/colors<br />
ldx #0<br />
stx SDMCTL <br />
<br />
ldy #$7f<br />
sty SIZEP0 ; size p0=127<br />
<br />
ldx #0<br />
ldy #$3f<br />
make_sine:<br />
value_lo<br />
lda #0<br />
clc<br />
delta_lo<br />
adc #0<br />
sta value_lo+1<br />
value_hi<br />
lda #0<br />
delta_hi<br />
adc #0<br />
sta value_hi+1<br />
<br />
sta sinewave+$c0,x<br />
sta sinewave+$80,y<br />
eor #$7f<br />
sta sinewave+$40,x<br />
sta sinewave+$00,y<br />
<br />
lda delta_lo+1<br />
adc #8<br />
sta delta_lo+1<br />
bcc nothing<br />
inc delta_hi+1<br />
nothing<br />
inx<br />
dey<br />
bpl make_sine<br />
<br />
updateloop:<br />
; vblank<br />
lda VCOUNT<br />
bne updateloop<br />
<br />
; clear graphics<br />
sta HPOSP0<br />
sta GRAFP0<br />
<br />
ldy #0<br />
lda #47<br />
sta COLPM0<br />
yloop:<br />
tya ; graphics shape = y<br />
sta WSYNC<br />
sta GRAFP0<br />
<br />
; a = sin(frame+y)+48<br />
tya <br />
adc FRAMECOUNTER<br />
tax<br />
lda sinewave,x<br />
adc #48<br />
sta HPOSP0<br />
<br />
iny<br />
bne yloop<br />
jmp updateloop<br />
<br />
run main<br />
</syntaxhighlight><br />
<br />
=== Sound ===<br />
The Atari 8-bit use the POKEY chip to generate sound.<br />
* https://en.wikipedia.org/wiki/POKEY<br />
<br />
==== BASIC ====<br />
<syntaxhighlight lang="6502"><br />
; from Analog, 1985-09,pp.25-32<br />
*=$2000<br />
AUDF1=$D200<br />
AUDC1=$D201<br />
AUDCTL=$D208<br />
SKCTL=$D20F<br />
<br />
.MACRO SOUND ; voice,pitch,dist,vol;,dur<br />
lda #%2<br />
sta AUDF1+2*%1<br />
lda #[[%3 * 16] | %4] ;lda #[[%3 shl 4] or %4]<br />
sta AUDC1+2*%1<br />
.ENDM<br />
<br />
lda #0<br />
sta AUDCTL<br />
lda #3<br />
sta SKCTL<br />
<br />
SOUND 0,121,10,8<br />
<br />
jmp *<br />
</syntaxhighlight><br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Additional Resources ===<br />
Sizecoding resource for the Atari 8bit are:<br />
* Mapping the Atari https://www.atariarchives.org/mapping/<br />
* Atari 8bit Memory map https://www.atariarchives.org/mapping/memorymap.php<br />
* Fready's undocumented 6502 opcodes https://github.com/FreddyOffenga/6502<br />
* Atari OS Rev2 disassembly for MADS assembler https://github.com/ilmenit/A800-OS-XL-Rev2<br />
* Fready's github https://github.com/FreddyOffenga/<br />
<br />
== Commodore 64 ==<br />
The Commodore system consists of a 6502-compatible MOS 6510 processor with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Commodore systems is quite easy, first get the following tools:<br />
<br />
* Assembler: To be added<br />
* Emulator(s): VICE is the way to go<br />
<br />
=== Memory map ===<br />
<br />
<syntaxhighlight lang="6502"><br />
0-1 $0-$1 PROCESSOR PORT REGISTERS, not usable as RAM<br />
0-255 $0-$FF ZEROPAGE, mostly used by BASIC interpreter and Kernal<br />
256-511 $100-$1FF SYSTEM STACK<br />
512-600 $200-$258 INPUT BUFFER<br />
601-630 $259-$276 FILE SYSTEM DATA<br />
631-640 $277-$280 KEYBOARD BUFFER, filled by Kernal ISR upon key presses <br />
641-678 $281-$2A6 VARIOUS KERNAL VARIABLES<br />
679-767 $2A7-$2FF Unused (89 byte)<br />
768-779 $300-$30B KERNAL VECTORS<br />
780-783 $30C-$30F REGISTER VALUES A,X,Y,SR for SYS<br />
784-819 $310-$333 KERNAL VECTORS<br />
820-827 $334-$33B Unused (8 byte)<br />
828-1019 $33C-$3FB DATASETTE BUFFER<br />
1020-1023 $3FC-$3FF Unused (4 byte)<br />
1024-2023 $400-$7E7 SCREEN MEMORY (25 lines times 40 columns)<br />
2024-2039 $7E8-$7F7 Unused (16 byte)<br />
2040-2047 $7F8-$7FF SPRITE COSTUME POINTERS<br />
2048 $800 must contain a value of 0 so that the BASIC program can be RUN<br />
2049-40959 $801-$9FFF BASIC AREA (code, variables, arrays, strings)<br />
40960-49151 $A000-$BFFF BASIC ROM (unused RAM underneath)<br />
49152-53247 $C000-$CFFF UPPER RAM AREA (unused)<br />
53248-53294 $D000-$D02E VIC-II, memory-mapped graphics chip registers)<br />
54272-54300 $D400-$D41C SID, memory-mapped sound chip registers)<br />
55296-56295 $D800-$DBE7 Color RAM, only lower 4 bits are stored, higher nibble undefined<br />
56296-56319 $DBE8-$DBFF Unused (24 half-bytes)<br />
56320-56335 $DC00-$DC0F CIA#1, memory-mapped I/O chip registers for keyboard, joystick, mouse, datasette, IRQ control<br />
56576-56591 $DD00-$DD0F CIA#1, memory-mapped I/O chip registers for serial bus, RS232, NMI control<br />
57344-65535 $E000-$FFFF KERNAL ROM<br />
65534-65535 $FFFE-$FFFF Execution address of interrupt service routine, can only be set if KERNAL is turned off<br />
</syntaxhighlight><br />
<br />
For a detailed explanation of the C64 memory map check out [https://sta.c64.org/cbm64mem.html Commodore 64 memory map] on Joe Forster/STA homepage.<br />
<br />
=== Program file overhead ===<br />
<br />
A standard CBM file consists of a 2 byte loading address followed by the data that is placed into memory starting at this address. In addition, if your machine program should be able to be started with "RUN", you need a BASIC stub that is loaded into memory from $0801 to $080c, typically followed by your machine program:<br />
<br />
<syntaxhighlight lang="6502"><br />
*=$0801<br />
.word $080b ;address of next BASIC line<br />
.word LINENR ;line number, can be chosen between 0 and 63999<br />
.byte $9e ;token for SYS command<br />
.byte $32,$30,$36,$31 ;address to jump to in ASCII code: "2061" <br />
.byte $00 ;end of BASIC line<br />
.word $0000 ;address of next BASIC line, $0000 means end of BASIC program <br />
start<br />
; your code here<br />
</syntaxhighlight><br />
<br />
Together with the 2 byte load address, this makes an overhead of 14 byte for your program. To reduce this, you can<br />
* omit the BASIC line and tell users to start your program by directly entering "SYS ''address''"<br />
* save your program from $0802 on, the byte at $0801 is recovered automatically after loading by the relink function. This reduces your program file size by 1 byte<br />
* accept the loss and use the 2 byte establishing LINENR for something good, they are copied to zeropage addresses $39/$3a automatically, saving you the effort of initializing the addresses<br />
* use an autostart method (see below)<br />
<br />
Some compos also specify that the BASIC loader does not count towards the overall filesize, check the rules before you worry.<br />
<br />
=== Autostart ===<br />
<br />
Unlike the Commodore 128, the Commodore 64 has no dedicated built-in auto-boot feature, but it is possible to autorun a program after loading by specifying the load address so that it overwrites a vector or address that is called by the operating system. There are multiple possibilities:<br />
<br />
==== Overwriting CHROUT vector at $326-$327 ====<br />
<br />
The vector at address $326-$327 points at the CHROUT routine, normally at address $F1CA.<br />
If you put the entry address of your program into $326/27, your code will be called when the operating system wants to print "READY." after loading.<br />
Note that the vector at address $328-$329 points at the STOP routine that checks the status of Stop key indicator. Since this routine is called multiple times before your code is done loading, its default value $F6ED needs to be preserved. <br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$0326<br />
.word start <br />
.byte $ed,$f6<br />
start<br />
; rest of code<br />
</syntaxhighlight><br />
<br />
Together with the two byte load address, the overwritten CHROUT vector and the preserved STOP vector, your program file will have a deadweight of 6 byte: $26 $03 $0a $03 $ed $f6, less than half of the standard version with a BASIC stub with SYS<br />
<br />
Caveat:<br />
* If your program after $32a is longer than 214 byte, part of your program will load into the screen at $400. Thus, issuing a clear screen will overwrite your program. It is possible to move the screen memory somewhere else, but that requires storing a new value into address $D018, which when done with an LDA # / STA pair will cost you 5 byte<br />
* Since you changed the CHROUT pointer, standard KERNAL functions for printing won't work. For output of single characters, you can still use the direct address $F1CA. Alternatively, you can restore the vectors by calling $FD15, which will overwrite the memory $314 to $333 with the default values.<br />
<br />
=== Video display ===<br />
Video display on the Commodore, it has the following video modes:<br />
<br />
To be added soon.<br />
<br />
==== Getting something on screen ====<br />
To be added soon.<br />
<br />
<br />
=== Sound ===<br />
The Commodore 64 uses the famous SID chip to generate sound.<br />
To be added soon.<br />
<br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Additional Resources ===<br />
* Codebase 64 https://codebase64.org/doku.php?id=base:start<br />
<br />
== Apple II ==<br />
The Apple II is an 8-bit home computer and one of the world's first highly successful mass-produced microcomputer products. It was designed primarily by Steve Wozniak.<br />
<br />
=== Setting up ===<br />
* ACME 6502 cross-assembler(https://sourceforge.net/projects/acme-crossass/)<br />
* Apple Commander (http://applecommander.sourceforge.net) for batch compilation<br />
* AppleWin emulator (https://github.com/AppleWin/AppleWin/releases). Supports Mockingboard card(AY-8910+speech synthesier), HDD, Z80 card(for CP/M), mouse etc.<br />
* CiderPress(https://a2ciderpress.com)<br />
<br />
Compilation can be done as follows (master.dsk can be found with applewin) <br />
<syntaxhighlight><br />
acme hl.asm<br />
java -jar AppleCommander-1.3.5.jar -d master.dsk hl<br />
java -jar AppleCommander-1.3.5.jar -p master.dsk hl B 24576 < hl.bin<br />
</syntaxhighlight><br />
<br />
=== Memory Map ===<br />
<syntaxhighlight lang="6502"><br />
0-255 $0-$FF ZERO-PAGE SYSTEM STORAGE<br />
256-511 $100-$1FF SYSTEM STACK<br />
512-767 $200-$2FF KEYBOARD CHARACTER BUFFER<br />
768-975 $300-$3CF OFTEN AVAILABLE AS FREE SPACE FOR USER PROGRAMS<br />
976-1023 $3D0-3FF SYSTEM VECTORS<br />
1024-2047 $400-$7FF TEXT AND LO-RES GRAPHICS PAGE 1 <--- !!!<br />
2048-LOMEM $800-LOMEM PROGRAM STORAGE<br />
2048-3071 $800-$BFF TEXT AND LO-RES GRAPHICS PAGE 2 OR FREE SPACE<br />
3072-8191 $C00-$1FFF FREE SPACE UNLESS RAM APPLESOFT IS IN USE<br />
8192-16383 $2000-$3FFF HI-RES PAGE 1 OR FREE SPACE <--- !!!<br />
16384-24575 $4000-$5FFF HI-RES PAGE 2 OR FREE SPACE<br />
24576-38999 $6000-$95FF FREE SPACE AND STRING STORAGE<br />
38400-49151 $9600-$BFFF DOS<br />
49152-53247 $C000-$CFFF I/O HARDWARE (RESERVED)<br />
53248-57343 $D000-$DFFF APPLESOFT IN LANGUAGE CARD OR ROM<br />
57344-63487 $E000-$F7FF APPLESOFT OR INTEGER BASIC IN LANGUAGE CARD OR ROM<br />
63488-65535 $F800-$FFFF SYSTEM MONITOR<br />
</syntaxhighlight><br />
<br />
=== Display ===<br />
<br />
=== Graphics Modes ===<br />
: Text Mode 40x24, for Apple IIe available 80x25 - use PR#3 for switch mode, or hardware switch<br />
: LowRes 40x48, 16 colors: https://en.wikipedia.org/wiki/Apple_II_graphics <br />
: Hires mode 280x192,6 colors: https://www.xtof.info/blog/?p=768<br />
https://mrob.com/pub/xapple2/colors.html<br />
https://archive.org/details/HiRes_Color_Graphics_on_the_Apple_II_Computer_by_Wozniak<br />
<br />
However for sizecoding, you almost never want to do direct-access to graphics for Apple II in size-coding because the Apple II graphics modes are horrible. The only fast way to do things is with large lookup tables. To do hires you need to divide by 7 which as you can imagine is a bit difficult to do compactly on 6502. Double-hires is even crazier on top of that. Deater did manage a color-bar style effect in double-hires in 128B but that was doing some crazy tricks with the firmware BASIC routines, definitely not direct-access.<br />
<br />
Lores and Hires can be mixed modes and full-graphics<br />
The screen structure is called memory holes(https://retrocomputing.stackexchange.com/questions/2534/what-are-the-screen-holes-in-apple-ii-graphics). The GBASCALC($F847) procedure is used to calculate the address of the horizontal line : IN:reg.A=Y, out : GBASL/GBASH($26/$27)=address. See also https://www.callapple.org/uncategorized/use-of-apple-ii-color-graphics-in-assembly-language/<br />
<br />
==== Getting something on screen ====<br />
Here is an example of a XOR texture, created by g0blinish<br />
<syntaxhighlight lang="6502"><br />
*=$6000<br />
!to "HL.bin", plain ; set output file and format<br />
!cpu 6502 ; set processor type<br />
<br />
GBASL = $26<br />
GBASH = $27<br />
SETGR = $FB40 ; setup LoRes<br />
GBASCALC = $F847 ; calc Address<br />
<br />
CLRTEXT = $C050 ;display graphics <br />
SETTEXT = $C051 ;display text <br />
<br />
CLRMIXED = $C052 ;clear mixed mode- enable full graphics <br />
SETMIXED = $C053 ;enable graphics/text mixed mode <br />
<br />
PAGE1 = $C054 ;select text/graphics page1 <br />
PAGE2 = $C055 ;select text/graphics page2 <br />
<br />
CLRHIRES = $C056 ;select Lo-res <br />
SETHIRES = $C057 ;select Hi-res <br />
<br />
TMP= $FA<br />
<br />
JSR SETGR ;GR<br />
BIT CLRMIXED ; full screen<br />
<br />
LDA #0 ; A=0<br />
STA TMP ; POKE $FA,A<br />
<br />
YLP ;<br />
LDA TMP ; A=PEEK($FA)<br />
; LSR ; A=A/2<br />
JSR GBASCALC<br />
LDY #0;Y=0<br />
<br />
XLP TYA ; A=Y<br />
EOR TMP ; A=A xor PEEK($FA)<br />
and #$0F ; A=A and 15<br />
TAX ; X=A<br />
LDA COLORS,X ;A=PEEK(COLORS+X)<br />
STA(GBASL),Y ; POKE PEEK($26)+256*PEEK($27)+Y,A<br />
INY ; Y=Y+1<br />
CPY #40 ; Y=40?<br />
BNE XLP<br />
INC TMP ; POKE $FA,PEEK($FA)+1<br />
LDA TMP ; A=PEEK($FA)<br />
CMP #24 ; A=24?<br />
BNE YLP<br />
<br />
M1 JMP M1 ; replace to RTS<br />
<br />
COLORS ;N*17, pixel format is AAAABBBB, AAAA - upper dot, BBBB - lower dot<br />
!byte $00,$11,$22,$33,$44,$55,$66,$77<br />
!byte $88,$99,$AA,$BB,$CC,$DD,$EE,$FF<br />
</syntaxhighlight><br />
<br />
==== Sound ====<br />
Here is an example for using the speaker, based onthe following basic program:<br />
<br />
<syntaxhighlight lang="basic"><br />
; 50 POKE 768,V: POKE 769,P - 255 * INT (P / 256): POKE 800,1 + P / 256<br />
; 60 CALL 770: RETURN <br />
; 95 FOR K = 1 TO N: READ V(K),P(K): NEXT K<br />
; 100 FOR K = 1 TO N:V = V(K):P = P(K)<br />
; 110 GOSUB 50<br />
;!byte 173,48,192,136,208,5,206,1,3,240,9,202,208,245,174,0,3,76,2,3,206,32,3,208,240,96<br />
</syntaxhighlight><br />
<br />
<syntaxhighlight lang="6502"><br />
*=$6000<br />
!to "HL.bin", plain ; set output file and format<br />
!cpu 6502 ; set processor type<br />
<br />
;start<br />
; 95 FOR K = 1 TO N: READ V(K),P(K): NEXT K<br />
; 100 FOR K = 1 TO N:V = V(K):P = P(K)<br />
ini:<br />
lda #70<br />
sta cnt+1<br />
lda #music&255<br />
sta gotbyte+1<br />
lda #music/256<br />
sta gotbyte+2<br />
<br />
lop:<br />
;V<br />
jsr gotbyte<br />
sta L300<br />
jsr gotbyte<br />
;P<br />
jsr gotbyte<br />
sta L301<br />
jsr gotbyte<br />
clc<br />
adc #1<br />
sta L320<br />
jsr beep<br />
<br />
dec cnt+1<br />
cnt lda #70<br />
bne lop<br />
; 110 GOSUB 50<br />
; 50 POKE 768,V: POKE 769,P - 255 * INT (P / 256): POKE 800,1 + P / 256<br />
; 60 CALL 770: RETURN <br />
jmp ini<br />
gotbyte<br />
lda music<br />
inc gotbyte+1<br />
bne noinch<br />
inc gotbyte+2<br />
noinch<br />
rts<br />
;!byte 173,48,192,136,208,5,206,1,3,240,9,202,208,245,174,0,3,76,2,3,206,32,3,208,240,96<br />
beep:<br />
ldy #1<br />
ldx #1<br />
loc_302:<br />
LDA $C030<br />
<br />
loc_305:<br />
DEY<br />
BNE loc_30D<br />
DEC L301<br />
loc_30B:<br />
BEQ loc_316<br />
<br />
loc_30D:<br />
DEX<br />
BNE loc_305<br />
LDX L300<br />
JMP loc_302<br />
loc_316:<br />
DEC L320<br />
BNE loc_30B<br />
RTS<br />
L301 !byte 0<br />
L300 !byte 0<br />
L320 !byte 0<br />
music<br />
!word 76,192,85,64,96,64,102,64,114,128,114,64,96,64,102,64,114,64,128,64<br />
!word 114,64,152,64,171,64,152,512,76,192,85,64,96,64,102,64,114,128,114,64<br />
!word 96,64,102,64,114,64,128,64,114,64,152,64,171,64,152,512,85,64,85,64<br />
!word 85,64,96,64,144,128,144,64,128,64,76,128,85,64,96,64,144,128,114,64<br />
!word 96,64,102,128,114,64,128,64,128,128,114,64,128,64,114,512,85,64,85,64<br />
!word 85,64,96,64,144,128,144,64,128,64,76,128,85,64,96,64,144,128,114,64<br />
!word 96,64,102,128,114,64,128,64,128,64,128,128,96,64,85,64,96,64,102,64,114,64,114,64<br />
</syntaxhighlight><br />
<br />
=== Additional Resources ===<br />
* Deater's page on Apple II sizecoding http://www.deater.net/weave/vmwprod/demos/sizecoding.html<br />
* Article on double hi-res http://www.battlestations.zone/2017/04/apple-ii-double-hi-res-from-ground-up.html<br />
* Applesoft Hi-Res Subroutines : http://hackzapple.org/scripts_php/index.php?menu=5&mod=ASM&sub=AAL&sub2=8112&PHPSESSID=f65fabfd0cdbf56b6bdc0ddac25117c6#a2<br />
<br />
== Atari Lynx ==<br />
The Atari Lynx consists of the 6502 with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Atari Lynx:<br />
<br />
* Assembler: -<br />
* Emulator(s): -<br />
<br />
=== Video display ===<br />
To be added soon.<br />
<br />
==== Getting something on screen ====<br />
To be added soon.<br />
<br />
<br />
=== Sound ===<br />
To be added soon.<br />
<br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Additional Resources ===<br />
Sizecoding resource for the Atari Lynx are sparse<br />
* 42Bastian's website (link to be added)</div>Wilhttp://www.sizecoding.org/index.php?title=6502&diff=82065022021-02-15T19:34:20Z<p>Wil: /* Program file overhead */ wording</p>
<hr />
<div>== Introduction ==<br />
Wanting to start sizecoding on a 6502 platform in this day and age can be tough. <br />
<br />
[[File:6502.jpg|thumb]]<br />
<br />
So here is a bit of help to get you started:<br />
<br />
=== The 6502 processor ===<br />
The 6502 processor can be seen as the 8-bit micro ARM chip. <br />
It has only has 3 registers (Accumulator, X and Y registers) and a handful of instructions to work with.<br />
<br />
=== Adressing modes ===<br />
To be added.<br />
<br />
=== Zero page ===<br />
When using the 6502 for sizecoding, you'll mostly be working from zeropage<br />
<br />
=== General 6502 Resources ===<br />
* 6502.org http://www.6502.org/<br />
* 6502 instruction reference http://www.6502.org/tutorials/6502opcodes.html<br />
* 6502 books http://retro.hansotten.nl/6502-sbc/<br />
* 6502 Assembler tutorial https://dwheeler.com/6502/oneelkruns/asm1step.html<br />
* Easy 6502 code tester https://skilldrick.github.io/easy6502/<br />
* Synthetic instructions https://wiki.nesdev.com/w/index.php/Synthetic_instructions#8-bit_rotate<br />
<br />
== Atari 8-bit family ==<br />
The systems in this family are: Atari 400, 800, 5200, 1200XL, 600XL, 800XL, 130XE, 65XE, 800XE and XEGS.<br /><br />
<br />
The Atari 8-bit systems consists of the 6502 with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Atari 8bit systems is quite easy, first get the following tools:<br />
<br />
* Assembler: MADS Assembler - This assembler has nice macros for creating Binaries and SNA snapshot files out of the box. You can download it at https://mads.atari8.info/<br />
* Emulator(s): I Found Altirra to work best for my usecase. Make sure to use the original Rev2 rom for best compatibility.<br />
<br />
==== Special Memory Adresses ====<br />
* FRAMECOUNTER_HIGH = 19<br />
* FRAMECOUNTER_LOW = 20<br />
<br />
=== Video display ===<br />
Video display on the Atari 8bit systems use the ANTIC and GTIA chips. Information can be found here:<br />
* https://en.wikipedia.org/wiki/ANTIC<br />
* https://www.atariarchives.org/agagd/chapter1.php<br />
<br />
==== Sync with frame ====<br />
<syntaxhighlight lang="6502"><br />
RTCLOK equ $0012<br />
lda RTCLOK+2<br />
waits<br />
cmp RTCLOK+2<br />
beq waits<br />
</syntaxhighlight><br />
<br />
Or if you don't mind trashing RTCLOK<br />
<br />
<syntaxhighlight lang="6502"><br />
RTCLOK equ $0012<br />
waits<br />
lsr RTCLOK+2<br />
bcc waits<br />
</syntaxhighlight><br />
<br />
Which is two bytes shorter.<br />
<br />
==== Getting something on screen ====<br />
<syntaxhighlight lang="6502"><br />
;fill screen with charset,(88,89)=an address<br />
org $600; free 6th page:600-6ff<br />
ldy #0<br />
fl: tya<br />
sta(88),y<br />
iny<br />
bne fl<br />
jmp *<br />
</syntaxhighlight><br />
<br />
To be added soon.<br />
<br />
<syntaxhighlight lang="6502"><br />
SDMCTL = $022f<br />
HPOSP0 = $d000<br />
SIZEP0 = $d008<br />
GRAFP0 = $d00d<br />
COLPM0 = $d012<br />
<br />
FRAMECOUNTER_HIGH = 19<br />
FRAMECOUNTER = 20<br />
WSYNC = $d40a<br />
VCOUNT = $d40b<br />
<br />
sinewave = $0600 ; to $06ff<br />
<br />
org $80<br />
<br />
main <br />
; disable all graphics/colors<br />
ldx #0<br />
stx SDMCTL <br />
<br />
ldy #$7f<br />
sty SIZEP0 ; size p0=127<br />
<br />
ldx #0<br />
ldy #$3f<br />
make_sine:<br />
value_lo<br />
lda #0<br />
clc<br />
delta_lo<br />
adc #0<br />
sta value_lo+1<br />
value_hi<br />
lda #0<br />
delta_hi<br />
adc #0<br />
sta value_hi+1<br />
<br />
sta sinewave+$c0,x<br />
sta sinewave+$80,y<br />
eor #$7f<br />
sta sinewave+$40,x<br />
sta sinewave+$00,y<br />
<br />
lda delta_lo+1<br />
adc #8<br />
sta delta_lo+1<br />
bcc nothing<br />
inc delta_hi+1<br />
nothing<br />
inx<br />
dey<br />
bpl make_sine<br />
<br />
updateloop:<br />
; vblank<br />
lda VCOUNT<br />
bne updateloop<br />
<br />
; clear graphics<br />
sta HPOSP0<br />
sta GRAFP0<br />
<br />
ldy #0<br />
lda #47<br />
sta COLPM0<br />
yloop:<br />
tya ; graphics shape = y<br />
sta WSYNC<br />
sta GRAFP0<br />
<br />
; a = sin(frame+y)+48<br />
tya <br />
adc FRAMECOUNTER<br />
tax<br />
lda sinewave,x<br />
adc #48<br />
sta HPOSP0<br />
<br />
iny<br />
bne yloop<br />
jmp updateloop<br />
<br />
run main<br />
</syntaxhighlight><br />
<br />
=== Sound ===<br />
The Atari 8-bit use the POKEY chip to generate sound.<br />
* https://en.wikipedia.org/wiki/POKEY<br />
<br />
==== BASIC ====<br />
<syntaxhighlight lang="6502"><br />
; from Analog, 1985-09,pp.25-32<br />
*=$2000<br />
AUDF1=$D200<br />
AUDC1=$D201<br />
AUDCTL=$D208<br />
SKCTL=$D20F<br />
<br />
.MACRO SOUND ; voice,pitch,dist,vol;,dur<br />
lda #%2<br />
sta AUDF1+2*%1<br />
lda #[[%3 * 16] | %4] ;lda #[[%3 shl 4] or %4]<br />
sta AUDC1+2*%1<br />
.ENDM<br />
<br />
lda #0<br />
sta AUDCTL<br />
lda #3<br />
sta SKCTL<br />
<br />
SOUND 0,121,10,8<br />
<br />
jmp *<br />
</syntaxhighlight><br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Additional Resources ===<br />
Sizecoding resource for the Atari 8bit are:<br />
* Mapping the Atari https://www.atariarchives.org/mapping/<br />
* Atari 8bit Memory map https://www.atariarchives.org/mapping/memorymap.php<br />
* Fready's undocumented 6502 opcodes https://github.com/FreddyOffenga/6502<br />
* Atari OS Rev2 disassembly for MADS assembler https://github.com/ilmenit/A800-OS-XL-Rev2<br />
* Fready's github https://github.com/FreddyOffenga/<br />
<br />
== Commodore 64 ==<br />
The Commodore systems consists of the 6502 with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Commodore systems is quite easy, first get the following tools:<br />
<br />
* Assembler: To be added<br />
* Emulator(s): VICE is the way to go<br />
<br />
=== Program file overhead ===<br />
<br />
A standard CBM file consists of a 2 byte loading address followed by the data that is placed into memory starting at this address. In addition, if your machine program should be able to be started with "RUN", you need a BASIC stub that is loaded into memory from $0801 to $080c, typically followed by your machine program:<br />
<br />
<syntaxhighlight lang="6502"><br />
*=$0801<br />
.word $080b ;address of next BASIC line<br />
.word LINENR ;line number, can be chosen between 0 and 63999<br />
.byte $9e ;token for SYS command<br />
.byte $32,$30,$36,$31 ;address to jump to in ASCII code: "2061" <br />
.byte $00 ;end of BASIC line<br />
.word $0000 ;address of next BASIC line, $0000 means end of BASIC program <br />
start<br />
; your code here<br />
</syntaxhighlight><br />
<br />
Together with the 2 byte load address, this makes an overhead of 14 byte for your program. To reduce this, you can<br />
* omit the BASIC line and tell users to start your program by directly entering "SYS ''address''"<br />
* save your program from $0802 on, the byte at $0801 is recovered automatically after loading by the relink function. This reduces your program file size by 1 byte<br />
* accept the loss and use the 2 byte establishing LINENR for something good, they are copied to zeropage addresses $39/$3a automatically, saving you the effort of initializing the addresses<br />
* use an autostart method (see below)<br />
<br />
Some compos also specify that the BASIC loader does not count towards the overall filesize, check the rules before you worry.<br />
<br />
=== Autostart ===<br />
<br />
Unlike the Commodore 128, the Commodore 64 has no dedicated built-in auto-boot feature, but it is possible to autorun a program after loading by specifying the load address so that it overwrites a vector or address that is called by the operating system. There are multiple possibilities:<br />
<br />
==== Overwriting CHROUT vector at $326-$327 ====<br />
<br />
The vector at address $326-$327 points at the CHROUT routine, normally at address $F1CA.<br />
If you put the entry address of your program into $326/27, your code will be called when the operating system wants to print "READY." after loading.<br />
Note that the vector at address $328-$329 points at the STOP routine that checks the status of Stop key indicator. Since this routine is called multiple times before your code is done loading, its default value $F6ED needs to be preserved. <br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$0326<br />
.word start <br />
.byte $ed,$f6<br />
start<br />
; rest of code<br />
</syntaxhighlight><br />
<br />
Together with the two byte load address, the overwritten CHROUT vector and the preserved STOP vector, your program file will have a deadweight of 6 byte: $26 $03 $0a $03 $ed $f6, less than half of the standard version with a BASIC stub with SYS<br />
<br />
Caveat:<br />
* If your program after $32a is longer than 214 byte, part of your program will load into the screen at $400. Thus, issuing a clear screen will overwrite your program. It is possible to move the screen memory somewhere else, but that requires storing a new value into address $D018, which when done with an LDA # / STA pair will cost you 5 byte<br />
* Since you changed the CHROUT pointer, standard KERNAL functions for printing won't work. For output of single characters, you can still use the direct address $F1CA. Alternatively, you can restore the vectors by calling $FD15, which will overwrite the memory $314 to $333 with the default values.<br />
<br />
=== Video display ===<br />
Video display on the Commodore, it has the following video modes:<br />
<br />
To be added soon.<br />
<br />
==== Getting something on screen ====<br />
To be added soon.<br />
<br />
<br />
=== Sound ===<br />
The Commodore 64 uses the famous SID chip to generate sound.<br />
To be added soon.<br />
<br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Additional Resources ===<br />
* Codebase 64 https://codebase64.org/doku.php?id=base:start<br />
<br />
== Apple II ==<br />
The Apple II is an 8-bit home computer and one of the world's first highly successful mass-produced microcomputer products. It was designed primarily by Steve Wozniak.<br />
<br />
=== Setting up ===<br />
* ACME 6502 cross-assembler(https://sourceforge.net/projects/acme-crossass/)<br />
* Apple Commander (http://applecommander.sourceforge.net) for batch compilation<br />
* AppleWin emulator (https://github.com/AppleWin/AppleWin/releases). Supports Mockingboard card(AY-8910+speech synthesier), HDD, Z80 card(for CP/M), mouse etc.<br />
* CiderPress(https://a2ciderpress.com)<br />
<br />
Compilation can be done as follows (master.dsk can be found with applewin) <br />
<syntaxhighlight><br />
acme hl.asm<br />
java -jar AppleCommander-1.3.5.jar -d master.dsk hl<br />
java -jar AppleCommander-1.3.5.jar -p master.dsk hl B 24576 < hl.bin<br />
</syntaxhighlight><br />
<br />
=== Memory Map ===<br />
<syntaxhighlight lang="6502"><br />
0-255 $0-$FF ZERO-PAGE SYSTEM STORAGE<br />
256-511 $100-$1FF SYSTEM STACK<br />
512-767 $200-$2FF KEYBOARD CHARACTER BUFFER<br />
768-975 $300-$3CF OFTEN AVAILABLE AS FREE SPACE FOR USER PROGRAMS<br />
976-1023 $3D0-3FF SYSTEM VECTORS<br />
1024-2047 $400-$7FF TEXT AND LO-RES GRAPHICS PAGE 1 <--- !!!<br />
2048-LOMEM $800-LOMEM PROGRAM STORAGE<br />
2048-3071 $800-$BFF TEXT AND LO-RES GRAPHICS PAGE 2 OR FREE SPACE<br />
3072-8191 $C00-$1FFF FREE SPACE UNLESS RAM APPLESOFT IS IN USE<br />
8192-16383 $2000-$3FFF HI-RES PAGE 1 OR FREE SPACE <--- !!!<br />
16384-24575 $4000-$5FFF HI-RES PAGE 2 OR FREE SPACE<br />
24576-38999 $6000-$95FF FREE SPACE AND STRING STORAGE<br />
38400-49151 $9600-$BFFF DOS<br />
49152-53247 $C000-$CFFF I/O HARDWARE (RESERVED)<br />
53248-57343 $D000-$DFFF APPLESOFT IN LANGUAGE CARD OR ROM<br />
57344-63487 $E000-$F7FF APPLESOFT OR INTEGER BASIC IN LANGUAGE CARD OR ROM<br />
63488-65535 $F800-$FFFF SYSTEM MONITOR<br />
</syntaxhighlight><br />
<br />
=== Display ===<br />
<br />
=== Graphics Modes ===<br />
: Text Mode 40x24, for Apple IIe available 80x25 - use PR#3 for switch mode, or hardware switch<br />
: LowRes 40x48, 16 colors: https://en.wikipedia.org/wiki/Apple_II_graphics <br />
: Hires mode 280x192,6 colors: https://www.xtof.info/blog/?p=768<br />
https://mrob.com/pub/xapple2/colors.html<br />
https://archive.org/details/HiRes_Color_Graphics_on_the_Apple_II_Computer_by_Wozniak<br />
<br />
However for sizecoding, you almost never want to do direct-access to graphics for Apple II in size-coding because the Apple II graphics modes are horrible. The only fast way to do things is with large lookup tables. To do hires you need to divide by 7 which as you can imagine is a bit difficult to do compactly on 6502. Double-hires is even crazier on top of that. Deater did manage a color-bar style effect in double-hires in 128B but that was doing some crazy tricks with the firmware BASIC routines, definitely not direct-access.<br />
<br />
Lores and Hires can be mixed modes and full-graphics<br />
The screen structure is called memory holes(https://retrocomputing.stackexchange.com/questions/2534/what-are-the-screen-holes-in-apple-ii-graphics). The GBASCALC($F847) procedure is used to calculate the address of the horizontal line : IN:reg.A=Y, out : GBASL/GBASH($26/$27)=address. See also https://www.callapple.org/uncategorized/use-of-apple-ii-color-graphics-in-assembly-language/<br />
<br />
==== Getting something on screen ====<br />
Here is an example of a XOR texture, created by g0blinish<br />
<syntaxhighlight lang="6502"><br />
*=$6000<br />
!to "HL.bin", plain ; set output file and format<br />
!cpu 6502 ; set processor type<br />
<br />
GBASL = $26<br />
GBASH = $27<br />
SETGR = $FB40 ; setup LoRes<br />
GBASCALC = $F847 ; calc Address<br />
<br />
CLRTEXT = $C050 ;display graphics <br />
SETTEXT = $C051 ;display text <br />
<br />
CLRMIXED = $C052 ;clear mixed mode- enable full graphics <br />
SETMIXED = $C053 ;enable graphics/text mixed mode <br />
<br />
PAGE1 = $C054 ;select text/graphics page1 <br />
PAGE2 = $C055 ;select text/graphics page2 <br />
<br />
CLRHIRES = $C056 ;select Lo-res <br />
SETHIRES = $C057 ;select Hi-res <br />
<br />
TMP= $FA<br />
<br />
JSR SETGR ;GR<br />
BIT CLRMIXED ; full screen<br />
<br />
LDA #0 ; A=0<br />
STA TMP ; POKE $FA,A<br />
<br />
YLP ;<br />
LDA TMP ; A=PEEK($FA)<br />
; LSR ; A=A/2<br />
JSR GBASCALC<br />
LDY #0;Y=0<br />
<br />
XLP TYA ; A=Y<br />
EOR TMP ; A=A xor PEEK($FA)<br />
and #$0F ; A=A and 15<br />
TAX ; X=A<br />
LDA COLORS,X ;A=PEEK(COLORS+X)<br />
STA(GBASL),Y ; POKE PEEK($26)+256*PEEK($27)+Y,A<br />
INY ; Y=Y+1<br />
CPY #40 ; Y=40?<br />
BNE XLP<br />
INC TMP ; POKE $FA,PEEK($FA)+1<br />
LDA TMP ; A=PEEK($FA)<br />
CMP #24 ; A=24?<br />
BNE YLP<br />
<br />
M1 JMP M1 ; replace to RTS<br />
<br />
COLORS ;N*17, pixel format is AAAABBBB, AAAA - upper dot, BBBB - lower dot<br />
!byte $00,$11,$22,$33,$44,$55,$66,$77<br />
!byte $88,$99,$AA,$BB,$CC,$DD,$EE,$FF<br />
</syntaxhighlight><br />
<br />
==== Sound ====<br />
Here is an example for using the speaker, based onthe following basic program:<br />
<br />
<syntaxhighlight lang="basic"><br />
; 50 POKE 768,V: POKE 769,P - 255 * INT (P / 256): POKE 800,1 + P / 256<br />
; 60 CALL 770: RETURN <br />
; 95 FOR K = 1 TO N: READ V(K),P(K): NEXT K<br />
; 100 FOR K = 1 TO N:V = V(K):P = P(K)<br />
; 110 GOSUB 50<br />
;!byte 173,48,192,136,208,5,206,1,3,240,9,202,208,245,174,0,3,76,2,3,206,32,3,208,240,96<br />
</syntaxhighlight><br />
<br />
<syntaxhighlight lang="6502"><br />
*=$6000<br />
!to "HL.bin", plain ; set output file and format<br />
!cpu 6502 ; set processor type<br />
<br />
;start<br />
; 95 FOR K = 1 TO N: READ V(K),P(K): NEXT K<br />
; 100 FOR K = 1 TO N:V = V(K):P = P(K)<br />
ini:<br />
lda #70<br />
sta cnt+1<br />
lda #music&255<br />
sta gotbyte+1<br />
lda #music/256<br />
sta gotbyte+2<br />
<br />
lop:<br />
;V<br />
jsr gotbyte<br />
sta L300<br />
jsr gotbyte<br />
;P<br />
jsr gotbyte<br />
sta L301<br />
jsr gotbyte<br />
clc<br />
adc #1<br />
sta L320<br />
jsr beep<br />
<br />
dec cnt+1<br />
cnt lda #70<br />
bne lop<br />
; 110 GOSUB 50<br />
; 50 POKE 768,V: POKE 769,P - 255 * INT (P / 256): POKE 800,1 + P / 256<br />
; 60 CALL 770: RETURN <br />
jmp ini<br />
gotbyte<br />
lda music<br />
inc gotbyte+1<br />
bne noinch<br />
inc gotbyte+2<br />
noinch<br />
rts<br />
;!byte 173,48,192,136,208,5,206,1,3,240,9,202,208,245,174,0,3,76,2,3,206,32,3,208,240,96<br />
beep:<br />
ldy #1<br />
ldx #1<br />
loc_302:<br />
LDA $C030<br />
<br />
loc_305:<br />
DEY<br />
BNE loc_30D<br />
DEC L301<br />
loc_30B:<br />
BEQ loc_316<br />
<br />
loc_30D:<br />
DEX<br />
BNE loc_305<br />
LDX L300<br />
JMP loc_302<br />
loc_316:<br />
DEC L320<br />
BNE loc_30B<br />
RTS<br />
L301 !byte 0<br />
L300 !byte 0<br />
L320 !byte 0<br />
music<br />
!word 76,192,85,64,96,64,102,64,114,128,114,64,96,64,102,64,114,64,128,64<br />
!word 114,64,152,64,171,64,152,512,76,192,85,64,96,64,102,64,114,128,114,64<br />
!word 96,64,102,64,114,64,128,64,114,64,152,64,171,64,152,512,85,64,85,64<br />
!word 85,64,96,64,144,128,144,64,128,64,76,128,85,64,96,64,144,128,114,64<br />
!word 96,64,102,128,114,64,128,64,128,128,114,64,128,64,114,512,85,64,85,64<br />
!word 85,64,96,64,144,128,144,64,128,64,76,128,85,64,96,64,144,128,114,64<br />
!word 96,64,102,128,114,64,128,64,128,64,128,128,96,64,85,64,96,64,102,64,114,64,114,64<br />
</syntaxhighlight><br />
<br />
=== Additional Resources ===<br />
* Deater's page on Apple II sizecoding http://www.deater.net/weave/vmwprod/demos/sizecoding.html<br />
* Article on double hi-res http://www.battlestations.zone/2017/04/apple-ii-double-hi-res-from-ground-up.html<br />
* Applesoft Hi-Res Subroutines : http://hackzapple.org/scripts_php/index.php?menu=5&mod=ASM&sub=AAL&sub2=8112&PHPSESSID=f65fabfd0cdbf56b6bdc0ddac25117c6#a2<br />
<br />
== Atari Lynx ==<br />
The Atari Lynx consists of the 6502 with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Atari Lynx:<br />
<br />
* Assembler: -<br />
* Emulator(s): -<br />
<br />
=== Video display ===<br />
To be added soon.<br />
<br />
==== Getting something on screen ====<br />
To be added soon.<br />
<br />
<br />
=== Sound ===<br />
To be added soon.<br />
<br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Additional Resources ===<br />
Sizecoding resource for the Atari Lynx are sparse<br />
* 42Bastian's website (link to be added)</div>Wilhttp://www.sizecoding.org/index.php?title=6502&diff=81965022021-02-15T19:31:45Z<p>Wil: /* Autoboot */ added info on program file overhead and on autorun via $326/7</p>
<hr />
<div>== Introduction ==<br />
Wanting to start sizecoding on a 6502 platform in this day and age can be tough. <br />
<br />
[[File:6502.jpg|thumb]]<br />
<br />
So here is a bit of help to get you started:<br />
<br />
=== The 6502 processor ===<br />
The 6502 processor can be seen as the 8-bit micro ARM chip. <br />
It has only has 3 registers (Accumulator, X and Y registers) and a handful of instructions to work with.<br />
<br />
=== Adressing modes ===<br />
To be added.<br />
<br />
=== Zero page ===<br />
When using the 6502 for sizecoding, you'll mostly be working from zeropage<br />
<br />
=== General 6502 Resources ===<br />
* 6502.org http://www.6502.org/<br />
* 6502 instruction reference http://www.6502.org/tutorials/6502opcodes.html<br />
* 6502 books http://retro.hansotten.nl/6502-sbc/<br />
* 6502 Assembler tutorial https://dwheeler.com/6502/oneelkruns/asm1step.html<br />
* Easy 6502 code tester https://skilldrick.github.io/easy6502/<br />
* Synthetic instructions https://wiki.nesdev.com/w/index.php/Synthetic_instructions#8-bit_rotate<br />
<br />
== Atari 8-bit family ==<br />
The systems in this family are: Atari 400, 800, 5200, 1200XL, 600XL, 800XL, 130XE, 65XE, 800XE and XEGS.<br /><br />
<br />
The Atari 8-bit systems consists of the 6502 with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Atari 8bit systems is quite easy, first get the following tools:<br />
<br />
* Assembler: MADS Assembler - This assembler has nice macros for creating Binaries and SNA snapshot files out of the box. You can download it at https://mads.atari8.info/<br />
* Emulator(s): I Found Altirra to work best for my usecase. Make sure to use the original Rev2 rom for best compatibility.<br />
<br />
==== Special Memory Adresses ====<br />
* FRAMECOUNTER_HIGH = 19<br />
* FRAMECOUNTER_LOW = 20<br />
<br />
=== Video display ===<br />
Video display on the Atari 8bit systems use the ANTIC and GTIA chips. Information can be found here:<br />
* https://en.wikipedia.org/wiki/ANTIC<br />
* https://www.atariarchives.org/agagd/chapter1.php<br />
<br />
==== Sync with frame ====<br />
<syntaxhighlight lang="6502"><br />
RTCLOK equ $0012<br />
lda RTCLOK+2<br />
waits<br />
cmp RTCLOK+2<br />
beq waits<br />
</syntaxhighlight><br />
<br />
Or if you don't mind trashing RTCLOK<br />
<br />
<syntaxhighlight lang="6502"><br />
RTCLOK equ $0012<br />
waits<br />
lsr RTCLOK+2<br />
bcc waits<br />
</syntaxhighlight><br />
<br />
Which is two bytes shorter.<br />
<br />
==== Getting something on screen ====<br />
<syntaxhighlight lang="6502"><br />
;fill screen with charset,(88,89)=an address<br />
org $600; free 6th page:600-6ff<br />
ldy #0<br />
fl: tya<br />
sta(88),y<br />
iny<br />
bne fl<br />
jmp *<br />
</syntaxhighlight><br />
<br />
To be added soon.<br />
<br />
<syntaxhighlight lang="6502"><br />
SDMCTL = $022f<br />
HPOSP0 = $d000<br />
SIZEP0 = $d008<br />
GRAFP0 = $d00d<br />
COLPM0 = $d012<br />
<br />
FRAMECOUNTER_HIGH = 19<br />
FRAMECOUNTER = 20<br />
WSYNC = $d40a<br />
VCOUNT = $d40b<br />
<br />
sinewave = $0600 ; to $06ff<br />
<br />
org $80<br />
<br />
main <br />
; disable all graphics/colors<br />
ldx #0<br />
stx SDMCTL <br />
<br />
ldy #$7f<br />
sty SIZEP0 ; size p0=127<br />
<br />
ldx #0<br />
ldy #$3f<br />
make_sine:<br />
value_lo<br />
lda #0<br />
clc<br />
delta_lo<br />
adc #0<br />
sta value_lo+1<br />
value_hi<br />
lda #0<br />
delta_hi<br />
adc #0<br />
sta value_hi+1<br />
<br />
sta sinewave+$c0,x<br />
sta sinewave+$80,y<br />
eor #$7f<br />
sta sinewave+$40,x<br />
sta sinewave+$00,y<br />
<br />
lda delta_lo+1<br />
adc #8<br />
sta delta_lo+1<br />
bcc nothing<br />
inc delta_hi+1<br />
nothing<br />
inx<br />
dey<br />
bpl make_sine<br />
<br />
updateloop:<br />
; vblank<br />
lda VCOUNT<br />
bne updateloop<br />
<br />
; clear graphics<br />
sta HPOSP0<br />
sta GRAFP0<br />
<br />
ldy #0<br />
lda #47<br />
sta COLPM0<br />
yloop:<br />
tya ; graphics shape = y<br />
sta WSYNC<br />
sta GRAFP0<br />
<br />
; a = sin(frame+y)+48<br />
tya <br />
adc FRAMECOUNTER<br />
tax<br />
lda sinewave,x<br />
adc #48<br />
sta HPOSP0<br />
<br />
iny<br />
bne yloop<br />
jmp updateloop<br />
<br />
run main<br />
</syntaxhighlight><br />
<br />
=== Sound ===<br />
The Atari 8-bit use the POKEY chip to generate sound.<br />
* https://en.wikipedia.org/wiki/POKEY<br />
<br />
==== BASIC ====<br />
<syntaxhighlight lang="6502"><br />
; from Analog, 1985-09,pp.25-32<br />
*=$2000<br />
AUDF1=$D200<br />
AUDC1=$D201<br />
AUDCTL=$D208<br />
SKCTL=$D20F<br />
<br />
.MACRO SOUND ; voice,pitch,dist,vol;,dur<br />
lda #%2<br />
sta AUDF1+2*%1<br />
lda #[[%3 * 16] | %4] ;lda #[[%3 shl 4] or %4]<br />
sta AUDC1+2*%1<br />
.ENDM<br />
<br />
lda #0<br />
sta AUDCTL<br />
lda #3<br />
sta SKCTL<br />
<br />
SOUND 0,121,10,8<br />
<br />
jmp *<br />
</syntaxhighlight><br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Additional Resources ===<br />
Sizecoding resource for the Atari 8bit are:<br />
* Mapping the Atari https://www.atariarchives.org/mapping/<br />
* Atari 8bit Memory map https://www.atariarchives.org/mapping/memorymap.php<br />
* Fready's undocumented 6502 opcodes https://github.com/FreddyOffenga/6502<br />
* Atari OS Rev2 disassembly for MADS assembler https://github.com/ilmenit/A800-OS-XL-Rev2<br />
* Fready's github https://github.com/FreddyOffenga/<br />
<br />
== Commodore 64 ==<br />
The Commodore systems consists of the 6502 with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Commodore systems is quite easy, first get the following tools:<br />
<br />
* Assembler: To be added<br />
* Emulator(s): VICE is the way to go<br />
<br />
=== Program file overhead ===<br />
<br />
A standard CBM file consists of a 2 byte loading address followed by the data that is placed into memory starting at this address. In addition, if your machine program should be able to be started with "RUN", you need a BASIC stub that is loaded into memory from $0801 to $080c, typically followed by your machine program:<br />
<br />
<syntaxhighlight lang="6502"><br />
*=$0801<br />
.word $080b ;address of next BASIC line<br />
.word LINENR ;line number, can be set between 0 and 63999<br />
.byte $9e ;token for SYS command<br />
.byte $32,$30,$36,$31 ;address to jump to in ASCII code: "2061" <br />
.byte $00 ;end of BASIC line<br />
.word $0000 ;address of next BASIC line, $0000 means end of BASIC program <br />
start<br />
; your code here<br />
</syntaxhighlight><br />
<br />
Together with the 2 byte load address, this makes an overhead of 14 byte for your program. To reduce this, you can<br />
* omit the BASIC line and tell users to start your program by directly entering "SYS ''address''"<br />
* save your program from $0802 on, the byte at $0801 is recovered automatically after loading by the relink function. This reduces your program file size by 1 byte<br />
* accept the loss and use the 2 byte establishing LINENR for something good, they are copied to zeropage addresses $39/$3a automatically, saving you the effort of initializing the addresses<br />
* use an autostart method (see below)<br />
<br />
Some compos also specify that the BASIC loader does not count towards the overall filesize, check the rules before you worry.<br />
<br />
=== Autostart ===<br />
<br />
Unlike the Commodore 128, the Commodore 64 has no dedicated built-in auto-boot feature, but it is possible to autorun a program after loading by specifying the load address so that it overwrites a vector or address that is called by the operating system. There are multiple possibilities:<br />
<br />
==== Overwriting CHROUT vector at $326-$327 ====<br />
<br />
The vector at address $326-$327 points at the CHROUT routine, normally at address $F1CA.<br />
If you put the entry address of your program into $326/27, your code will be called when the operating system wants to print "READY." after loading.<br />
Note that the vector at address $328-$329 points at the STOP routine that checks the status of Stop key indicator. Since this routine is called multiple times before your code is done loading, its default value $F6ED needs to be preserved. <br />
<br />
Application example:<br />
<syntaxhighlight lang="6502"><br />
*=$0326<br />
.word start <br />
.byte $ed,$f6<br />
start<br />
; rest of code<br />
</syntaxhighlight><br />
<br />
Together with the two byte load address, the overwritten CHROUT vector and the preserved STOP vector, your program file will have a deadweight of 6 byte: $26 $03 $0a $03 $ed $f6, less than half of the standard version with a BASIC stub with SYS<br />
<br />
Caveat:<br />
* If your program after $32a is longer than 214 byte, part of your program will load into the screen at $400. Thus, issuing a clear screen will overwrite your program. It is possible to move the screen memory somewhere else, but that requires storing a new value into address $D018, which when done with an LDA # / STA pair will cost you 5 byte<br />
* Since you changed the CHROUT pointer, standard KERNAL functions for printing won't work. For output of single characters, you can still use the direct address $F1CA. Alternatively, you can restore the vectors by calling $FD15, which will overwrite the memory $314 to $333 with the default values.<br />
<br />
=== Video display ===<br />
Video display on the Commodore, it has the following video modes:<br />
<br />
To be added soon.<br />
<br />
==== Getting something on screen ====<br />
To be added soon.<br />
<br />
<br />
=== Sound ===<br />
The Commodore 64 uses the famous SID chip to generate sound.<br />
To be added soon.<br />
<br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Additional Resources ===<br />
* Codebase 64 https://codebase64.org/doku.php?id=base:start<br />
<br />
== Apple II ==<br />
The Apple II is an 8-bit home computer and one of the world's first highly successful mass-produced microcomputer products. It was designed primarily by Steve Wozniak.<br />
<br />
=== Setting up ===<br />
* ACME 6502 cross-assembler(https://sourceforge.net/projects/acme-crossass/)<br />
* Apple Commander (http://applecommander.sourceforge.net) for batch compilation<br />
* AppleWin emulator (https://github.com/AppleWin/AppleWin/releases). Supports Mockingboard card(AY-8910+speech synthesier), HDD, Z80 card(for CP/M), mouse etc.<br />
* CiderPress(https://a2ciderpress.com)<br />
<br />
Compilation can be done as follows (master.dsk can be found with applewin) <br />
<syntaxhighlight><br />
acme hl.asm<br />
java -jar AppleCommander-1.3.5.jar -d master.dsk hl<br />
java -jar AppleCommander-1.3.5.jar -p master.dsk hl B 24576 < hl.bin<br />
</syntaxhighlight><br />
<br />
=== Memory Map ===<br />
<syntaxhighlight lang="6502"><br />
0-255 $0-$FF ZERO-PAGE SYSTEM STORAGE<br />
256-511 $100-$1FF SYSTEM STACK<br />
512-767 $200-$2FF KEYBOARD CHARACTER BUFFER<br />
768-975 $300-$3CF OFTEN AVAILABLE AS FREE SPACE FOR USER PROGRAMS<br />
976-1023 $3D0-3FF SYSTEM VECTORS<br />
1024-2047 $400-$7FF TEXT AND LO-RES GRAPHICS PAGE 1 <--- !!!<br />
2048-LOMEM $800-LOMEM PROGRAM STORAGE<br />
2048-3071 $800-$BFF TEXT AND LO-RES GRAPHICS PAGE 2 OR FREE SPACE<br />
3072-8191 $C00-$1FFF FREE SPACE UNLESS RAM APPLESOFT IS IN USE<br />
8192-16383 $2000-$3FFF HI-RES PAGE 1 OR FREE SPACE <--- !!!<br />
16384-24575 $4000-$5FFF HI-RES PAGE 2 OR FREE SPACE<br />
24576-38999 $6000-$95FF FREE SPACE AND STRING STORAGE<br />
38400-49151 $9600-$BFFF DOS<br />
49152-53247 $C000-$CFFF I/O HARDWARE (RESERVED)<br />
53248-57343 $D000-$DFFF APPLESOFT IN LANGUAGE CARD OR ROM<br />
57344-63487 $E000-$F7FF APPLESOFT OR INTEGER BASIC IN LANGUAGE CARD OR ROM<br />
63488-65535 $F800-$FFFF SYSTEM MONITOR<br />
</syntaxhighlight><br />
<br />
=== Display ===<br />
<br />
=== Graphics Modes ===<br />
: Text Mode 40x24, for Apple IIe available 80x25 - use PR#3 for switch mode, or hardware switch<br />
: LowRes 40x48, 16 colors: https://en.wikipedia.org/wiki/Apple_II_graphics <br />
: Hires mode 280x192,6 colors: https://www.xtof.info/blog/?p=768<br />
https://mrob.com/pub/xapple2/colors.html<br />
https://archive.org/details/HiRes_Color_Graphics_on_the_Apple_II_Computer_by_Wozniak<br />
<br />
However for sizecoding, you almost never want to do direct-access to graphics for Apple II in size-coding because the Apple II graphics modes are horrible. The only fast way to do things is with large lookup tables. To do hires you need to divide by 7 which as you can imagine is a bit difficult to do compactly on 6502. Double-hires is even crazier on top of that. Deater did manage a color-bar style effect in double-hires in 128B but that was doing some crazy tricks with the firmware BASIC routines, definitely not direct-access.<br />
<br />
Lores and Hires can be mixed modes and full-graphics<br />
The screen structure is called memory holes(https://retrocomputing.stackexchange.com/questions/2534/what-are-the-screen-holes-in-apple-ii-graphics). The GBASCALC($F847) procedure is used to calculate the address of the horizontal line : IN:reg.A=Y, out : GBASL/GBASH($26/$27)=address. See also https://www.callapple.org/uncategorized/use-of-apple-ii-color-graphics-in-assembly-language/<br />
<br />
==== Getting something on screen ====<br />
Here is an example of a XOR texture, created by g0blinish<br />
<syntaxhighlight lang="6502"><br />
*=$6000<br />
!to "HL.bin", plain ; set output file and format<br />
!cpu 6502 ; set processor type<br />
<br />
GBASL = $26<br />
GBASH = $27<br />
SETGR = $FB40 ; setup LoRes<br />
GBASCALC = $F847 ; calc Address<br />
<br />
CLRTEXT = $C050 ;display graphics <br />
SETTEXT = $C051 ;display text <br />
<br />
CLRMIXED = $C052 ;clear mixed mode- enable full graphics <br />
SETMIXED = $C053 ;enable graphics/text mixed mode <br />
<br />
PAGE1 = $C054 ;select text/graphics page1 <br />
PAGE2 = $C055 ;select text/graphics page2 <br />
<br />
CLRHIRES = $C056 ;select Lo-res <br />
SETHIRES = $C057 ;select Hi-res <br />
<br />
TMP= $FA<br />
<br />
JSR SETGR ;GR<br />
BIT CLRMIXED ; full screen<br />
<br />
LDA #0 ; A=0<br />
STA TMP ; POKE $FA,A<br />
<br />
YLP ;<br />
LDA TMP ; A=PEEK($FA)<br />
; LSR ; A=A/2<br />
JSR GBASCALC<br />
LDY #0;Y=0<br />
<br />
XLP TYA ; A=Y<br />
EOR TMP ; A=A xor PEEK($FA)<br />
and #$0F ; A=A and 15<br />
TAX ; X=A<br />
LDA COLORS,X ;A=PEEK(COLORS+X)<br />
STA(GBASL),Y ; POKE PEEK($26)+256*PEEK($27)+Y,A<br />
INY ; Y=Y+1<br />
CPY #40 ; Y=40?<br />
BNE XLP<br />
INC TMP ; POKE $FA,PEEK($FA)+1<br />
LDA TMP ; A=PEEK($FA)<br />
CMP #24 ; A=24?<br />
BNE YLP<br />
<br />
M1 JMP M1 ; replace to RTS<br />
<br />
COLORS ;N*17, pixel format is AAAABBBB, AAAA - upper dot, BBBB - lower dot<br />
!byte $00,$11,$22,$33,$44,$55,$66,$77<br />
!byte $88,$99,$AA,$BB,$CC,$DD,$EE,$FF<br />
</syntaxhighlight><br />
<br />
==== Sound ====<br />
Here is an example for using the speaker, based onthe following basic program:<br />
<br />
<syntaxhighlight lang="basic"><br />
; 50 POKE 768,V: POKE 769,P - 255 * INT (P / 256): POKE 800,1 + P / 256<br />
; 60 CALL 770: RETURN <br />
; 95 FOR K = 1 TO N: READ V(K),P(K): NEXT K<br />
; 100 FOR K = 1 TO N:V = V(K):P = P(K)<br />
; 110 GOSUB 50<br />
;!byte 173,48,192,136,208,5,206,1,3,240,9,202,208,245,174,0,3,76,2,3,206,32,3,208,240,96<br />
</syntaxhighlight><br />
<br />
<syntaxhighlight lang="6502"><br />
*=$6000<br />
!to "HL.bin", plain ; set output file and format<br />
!cpu 6502 ; set processor type<br />
<br />
;start<br />
; 95 FOR K = 1 TO N: READ V(K),P(K): NEXT K<br />
; 100 FOR K = 1 TO N:V = V(K):P = P(K)<br />
ini:<br />
lda #70<br />
sta cnt+1<br />
lda #music&255<br />
sta gotbyte+1<br />
lda #music/256<br />
sta gotbyte+2<br />
<br />
lop:<br />
;V<br />
jsr gotbyte<br />
sta L300<br />
jsr gotbyte<br />
;P<br />
jsr gotbyte<br />
sta L301<br />
jsr gotbyte<br />
clc<br />
adc #1<br />
sta L320<br />
jsr beep<br />
<br />
dec cnt+1<br />
cnt lda #70<br />
bne lop<br />
; 110 GOSUB 50<br />
; 50 POKE 768,V: POKE 769,P - 255 * INT (P / 256): POKE 800,1 + P / 256<br />
; 60 CALL 770: RETURN <br />
jmp ini<br />
gotbyte<br />
lda music<br />
inc gotbyte+1<br />
bne noinch<br />
inc gotbyte+2<br />
noinch<br />
rts<br />
;!byte 173,48,192,136,208,5,206,1,3,240,9,202,208,245,174,0,3,76,2,3,206,32,3,208,240,96<br />
beep:<br />
ldy #1<br />
ldx #1<br />
loc_302:<br />
LDA $C030<br />
<br />
loc_305:<br />
DEY<br />
BNE loc_30D<br />
DEC L301<br />
loc_30B:<br />
BEQ loc_316<br />
<br />
loc_30D:<br />
DEX<br />
BNE loc_305<br />
LDX L300<br />
JMP loc_302<br />
loc_316:<br />
DEC L320<br />
BNE loc_30B<br />
RTS<br />
L301 !byte 0<br />
L300 !byte 0<br />
L320 !byte 0<br />
music<br />
!word 76,192,85,64,96,64,102,64,114,128,114,64,96,64,102,64,114,64,128,64<br />
!word 114,64,152,64,171,64,152,512,76,192,85,64,96,64,102,64,114,128,114,64<br />
!word 96,64,102,64,114,64,128,64,114,64,152,64,171,64,152,512,85,64,85,64<br />
!word 85,64,96,64,144,128,144,64,128,64,76,128,85,64,96,64,144,128,114,64<br />
!word 96,64,102,128,114,64,128,64,128,128,114,64,128,64,114,512,85,64,85,64<br />
!word 85,64,96,64,144,128,144,64,128,64,76,128,85,64,96,64,144,128,114,64<br />
!word 96,64,102,128,114,64,128,64,128,64,128,128,96,64,85,64,96,64,102,64,114,64,114,64<br />
</syntaxhighlight><br />
<br />
=== Additional Resources ===<br />
* Deater's page on Apple II sizecoding http://www.deater.net/weave/vmwprod/demos/sizecoding.html<br />
* Article on double hi-res http://www.battlestations.zone/2017/04/apple-ii-double-hi-res-from-ground-up.html<br />
* Applesoft Hi-Res Subroutines : http://hackzapple.org/scripts_php/index.php?menu=5&mod=ASM&sub=AAL&sub2=8112&PHPSESSID=f65fabfd0cdbf56b6bdc0ddac25117c6#a2<br />
<br />
== Atari Lynx ==<br />
The Atari Lynx consists of the 6502 with custom hardware for graphics and sound.<br />
<br />
=== Setting up ===<br />
Setting up your development platform for the Atari Lynx:<br />
<br />
* Assembler: -<br />
* Emulator(s): -<br />
<br />
=== Video display ===<br />
To be added soon.<br />
<br />
==== Getting something on screen ====<br />
To be added soon.<br />
<br />
<br />
=== Sound ===<br />
To be added soon.<br />
<br />
==== Make some noise ====<br />
To be added soon.<br />
<br />
=== Additional Resources ===<br />
Sizecoding resource for the Atari Lynx are sparse<br />
* 42Bastian's website (link to be added)</div>Wil