So I am trying to learn how to program the Super Nintendo. I am working on a demo and have run into a stumbling block.
I can't seem to successfully load a 16 bit register into the accumulator register. I have read the docs and have learned that I need
to put the accumulator flag into 16 bit mode in the status register.

So I did the following



Basically I have found that if I load "$FF" or 255 into A, I see 255 tiles drawn the screen.
but if I go outside of 1 byte and try $256, my code fails and I see nothing on screen.
I am pretty sure that the problem is because I either misunderstand or am not putting a
correct 16 bit value in the A register because if I load any other number under a byte from
0-255, my code works as expected. Can anyone please shed some light on my misunderstanding?

Thanks!

I figured it would be more helpful if I actually show my code Here is what I am doing



The above code works but if I define OffX to be a number greater than 255, I see nothing on the screen.

In know nothing about Super Nintendo, but for the 65816, for your first part, putting A in 16-bit mode then loading $100 and then putting it back in 8-bit mode means you now have 0 in it. Bits 8 and up are in accumulator B which you just made not to be part of A.

But for your code listing:

why not just increment TileCounter directly without pulling it into a register and then storing it again. But since you do pull it into a register then store it, why recall it again. Just do LDA, INC, STA, then CMP#4. Same thing after MapSwap, for greater efficiency.

_________________
http://WilsonMinesCo.com/ lots of 6502 resources

REP and SEP are awfully cryptic though. For greater clarity with no penalty in memory or runtime speed, you can use macros to show what you're doing. Define them something like:

and then just use ACCUM_16, ACCUM_8, etc. as if they were assembly-languange mnemonics. They result in exactly the same machine code which executes in the same number of cycles, but it's much more clear what you're doing.

_________________
http://WilsonMinesCo.com/ lots of 6502 resources

GARTHWILSON, thanks for the heads up. I will definitely use your 8/16 bit mode macro. Seems like a great idea!

As far as incrementing the TileCounter variable directly, I didn't realize I could do that.
How does one increment a variable directly in 65c816?

Also, while we are on the topic of marcos, what is the syntax for writing a macro that takes an immediate value as an argument and loads it directly into a register?

For example, lets say I have a maco called "SetA"
and I want the code to be called like so




And basically I want the macro to do the following


I still am unsure of how to do something like that.

Your macro listing is nearly perfect, at least for some assemblers. Just put the "#" in front of "value" in the LDA line, in indeed LDA #value is what you want. (It hardly seems very useful to just rename LDA# though, as that's awfully standard and clear 6502/c02/816 assembly language.) Edit: Oh, also, remove the "#" from the line where you invoke the macro. The C32 assembler I use does not put a dot in front of "MACRO" or "ENDM", and the 2500AD assembler I used before didn't either-- but do whatever works in yours.

"INC TileCounter" works in 6502, 65c02, and 65816. They all have the same addressing modes available in INC except the NMOS 6502 which does not let you increment the accumulator. On the '816, if you increment the variable without bringing it into a register, it will treat it as the width that the accumulator is set to; so if 8-bit, it will increment a one-byte variable, and if 16-bit, it will increment the two-byte variable residing at that address and the following one, low byte first of course.

_________________
http://WilsonMinesCo.com/ lots of 6502 resources

_________________
x86? We ain't got no x86. We don't need no stinking x86!

In addition to the SEP/REP instructions most 65816 assemblers will need a directive to tell them whether to generate 8 or 16 bit literal values for the following immediate load instructions.

Look at your listing and if you see a two byte instruction for a load immediate (e.g LDA #$FF => A9 FF) then your assembler is in 6502 mode if its three bytes (e.g. A9 FF 00) then its generated a 16-bit literal.

_________________
Andrew Jacobs
6502 & PIC Stuff - http://www.obelisk.demon.co.uk/
Cross-Platform 6502/65C02/65816 Macro Assembler - http://www.obelisk.demon.co.uk/dev65/

Ah yes, I forgot to mention it. For the C32 assembler however, instead of .LONGA ON/OFF, you do for example LDA #0 for A9 00 00, and LDA #<0 for the single-byte operand.

_________________
http://WilsonMinesCo.com/ lots of 6502 resources

_________________
x86? We ain't got no x86. We don't need no stinking x86!

So I am now doing the following



If I take out the rep/sep, my code draws 10 water tiles on the screen.
But if I put A into 16 bit mode, I see garbage on the screen.
Am I not using 16 bit mode correctly? I know that I need to do 2 writes to A when
in 16 bit mode but I am unsure of how to make my macro play nicely with 16 bit numbers.

You don't need to write code for two writes of A in 16-bit mode, because STA <addr> for example writes the low byte to <addr> and the high byte to <addr+1>, adding an extra cycle to the instruction to fit both byte writes in. IOW, a single instruction handles both bytes. Remember that INC does that too, so make sure that second byte is part of the variable. Make sure your code is consistent with numbers of bits. When you put A in 16-bit mode, the CMP# and LDA# for example need to have two-byte operands. There may be other such things also that you'll have to keep in agreement on the number of bits.

Edit: If your "inc OffX" is a direct-page addressing mode (is that supposed to be $FF?), then the next byte will be 100, and the 1 in the address offset gets lost. The first byte of the two-byte variable will be DP addr base + FF, and the 2nd (ie, high) byte will be DP addr base + 00, which may not be what you wanted.

_________________
http://WilsonMinesCo.com/ lots of 6502 resources

Interesting, I guess not understanding how 16 bit mode works is an issue for me. So you said that I need to use 2 operands when using lda and cmp in 16 bit mode. Does that mean if I want to load 256 into the A register then I should do the following?

lda #$FF, #$01

$FF is the 255 high byte component and the $01 if the low byte component.

It'll just be LDA #$1FF. It's a single 2-byte operand.

Edit: Woops, if your really want FF to be the high byte, make it LDA#FF01, and it will lay down A9 01 FF. Is that really what you meant though, or did you want $1FF, ie, 511 in decimal?

_________________
http://WilsonMinesCo.com/ lots of 6502 resources