Miscellaneous Asm questions

[simplethinker]

Since I'm still a beginner with Asm most of my issues won't merit a whole new thread, so I figured I could just use this.

I'm working on a program that will take data stored in a string and create a matrix and I've run into a couple problems. The input string (for now) is Str0 and stores into [A]. The data will be two-digit hex numbers (i.e. "FF", "02"). Str0 will start with the number of rows followed by the number of columns followed by the data (so if Str0="02020B01FF22", then [A]=[[11,1][255,34]]). Here's what I have:

[WikiGuru]

Hmm...

dec on 16-bit registers doesn't change the flags, and there are some problems with your byteToFloat/byteToA/nibbleToA (see code for changes). I've also added a few checks at the beginning to see if str0 exists, and if it's in the RAM. Of course, if it's not in RAM you could use UnArchive, but here I just quit.

Here's some code that does what you want:

[calc84maniac]

I think your NibbleToA routine is messed up, too... it would return $10 for "A" instead of 10. ;)

I'll see if I can type up an insanely optimized one. :D

Edit:
Heh heh... I had an extremely optimized one for converting a value to ASCII, but not the other way around... I should think about this more...

[WikiGuru]

Hehe, that's what I get for doing it at 2 in the morning... now that I'm hopefully awake, I have fixed NibbleToA, and am working on fixing byteToFloat.

edit: Well, here's the fixed nibbleToA. I still haven't figured out byteToFloat...

[simplethinker]

Thanks for the replies. This is for a project I'm working on, so I didn't add any error checking since this will (probably) never be used by someone else, thus idiot-proofing it isn't needed (hopefully) :)

I've been working on the ByteToFloat part and I think I'm on the right track. The part after _LessThan100 I just threw together as a starting point (it only works for numbers between 100 and 255), so it's the gist of what I'm doing and will be drastically optimized and generalized for <100. Does this look like an efficient way to convert to a floating-point number (between 0-255) without any b_calls or is there another way?

[WikiGuru]

I can't quite figure out what's wrong with ByteToFloat. Hopefully more debugging will work.

As for your questions:
1.
T-States can be thought of as a single operation the z80 CPU does. The number of T-States an instruction takes is how many operations the CPU actually does. The CPU's frequency is the number of T-States it can do every second (for TI-83+ Series, 6MHz or 11MHz on turbo mode).

2.
From a programming perspective, it's irrelevant. However, if you really want to know, see here: http://www.z80.info/zip/z80pps.zip. Inside is a little diagram of the CPU's workings while performing a few instructions. And yes, the OpCodes are hard-coded, and can not be changed.

3.
I'm not sure what you're talking about...
set imm3,reg8
imm3: a 3-bit immediate (number between 0 and 7)
reg8: Any of the following registers: A,B,C,D,E,H,L,IXH,IXL,IYH,IYL

same thing with res

[simplethinker]

2) Thanks I was just wondering about the inner workings of it.

3) Res also has the syntax "SET imm3,(regindex + ofs8)" and the opcode is "[regindex] : 11001011 : [ofs8] : 11[imm3]110", and I'm not sure how to get [reg_index].

[WikiGuru]

Oh yeah! I forgot about that! You can set an offset of IX/IY! Basically, you can add any 8-bit signed integer as such:


set 3,(IY+3)


This is how system flags works. It's actually changing bits in RAM.


;DonePrgm = 5
;DoneFlags = 0
res DonePrgm,(IY+DoneFlags)

[simplethinker]

Yeah, that's it My question is about the actual opcode though. The first part, which is [reg_index] and is followed by : 11001011 : [ofs8] : 11[imm3]110

[benryves]

Obligatory link to the Z80 User Manual.

[simplethinker]

[FloppusMaximus]

T-states are the internal subdivisions of the Z80 operations. The simplest Z80 instructions have four T-states, roughly:
(1) fetch the opcode from memory;
(2) increment the program counter;
(3) perform the desired operation;
(4) memory refresh.
(I might have the order wrong.) In general, one T-state takes one clock cycle -- sometimes they can take two or more due to memory delays, especially on the 84+, but for most purposes, you can think of one T-state as equal to one six-millionth of a second.

More complicated instructions, such as those that read or write memory or I/O ports, and those that do 16-bit arithmetic, will require more T-states to execute. So if you're writing a piece of code that may need to be called thousands of times per second, it's useful to know how long each instruction will take to execute.

Internally, the Z80 basically does what you describe: first, it reads a byte from memory and stores it in an internal register. Next, the CPU's control unit "examines" the contents of that register and directs the rest of the CPU to perform the operation indicated. This logic is indeed pretty much "hard-coded" into the control unit, although if you consider the structure of the Z80 opcodes, the required circuitry isn't quite as complicated as you might think. For instance, every opcode 10xxxyyy is an 8-bit ALU instruction; the xxx determines which operation to perform, and the yyy determines which register to use as the input.

The bitwise operations on (IX+n) are similar to the corresponding operations on (HL), with the addition of the prefix DD and the displacement n. So the machine code for SET 0,(HL) is CB C6, while the code for SET 0,(IX+42h) is DD CB 42 C6 (the displacement is placed in the "middle" of the instruction for speed, if you can believe it -- if the 42 came after the C6, the instruction would probably require 3-4 additional T-states.)

edit: Duh, I see some other folks have already answered those questions. Hope this is still helpful

[simplethinker]

Thanks FloppusMaximus. So for set n, (IX+m) (or (IY+m)) (or for 'res') it's the same as for (HL) but with $DD (or $FD) in front and 'm' stuck in between. That's easy enough :)

[edit] For converting an integer to FP format, I remember Iambian once mentioned something about a "hack" using DAA, does anyone know what it is? If I understand correctly, DAA adjusts the accumulator already in BCD (binary coded decimal) for BCD arithmetic, so I'm not sure how it could be used to get a number into BCD format.

[FloppusMaximus]

I don't know what trick in particular you're referring to. The fastest way to convert an integer to BCD is, of course, a lookup table, but if you're looking for something more compact, DAA can certainly be helpful. Here's one way to do it:

[calc84maniac]

[WikiGuru]

Yay, hopefully this will work. It's extremely un-optimized.

[simplethinker]

It's alive! I finally got a byteToFloat routine working:

[simplethinker]

I finally have a decent String->Float routine working, but I'm still running into the problem of certain values not being stored into the matrix properly.

The String->Matrix program:

[FloppusMaximus]

You presumably want OR C, not ADD A,C; the latter will give a result of zero if BC equals (for instance) 01FFh.

[simplethinker]