z80 | A csharp emulator for the Zilog Z80 CPU

The Direct Page register D is a 16-bit register specifying which 256-byte page within bank 0 that should be the current Direct Page (what you call Zero Page).

There are a couple of different instructions you can use to write to D. So e.g. something like this should work:

It helps if you read the manual.

The main error: Only labels start in the first column, insert at least a space or tab before any instruction or pseudo instruction.

ejemplo1.asm(1) : Unrecognized instruction: "ejemplo1.

output is interpreted as label, and consequently the filename is tried as an instruction. The interesting detail is that the point "." is taken as a separator. BTW, the filename is not in quotation marks, according to the examples.

ejemplo1.asm(3) : Label not found: fe

db is interpreted as label, and perhaps #fe is interpreted as a structure field entry. # defines the length on a field, and therefore fe is not recognized as a number, but as a label. This interpretation looks like a bug in the assembler to me.

ejemplo1.asm(4) : Unrecognized instruction: start

dw is interpreted as label, and consequently start is tried as an instruction.

ejemplo1.asm(5) : Duplicate labelname: dw

dw is again interpreted as label, as the error message tells us that it is already defined (in the line before).

Note: If you correct your code and get new errors, feel free to post a new question. You might want to add this to this question, but don't remove the current contents, add it and mark it as addition.

The subroutines change the value of the BC register so if one of them is called the subsequent IN A,(C) instructions will read the wrong port.

Put a LD BC,31 before every IN A,(C) to fix this. Or you could save and restore BC in the subroutines with a push and pop like so:

Yes, exactly; using defw will increase the size of the data (2 bytes each) to match the data size specification of the instruction being used in code.

Code and data sizes have to match; each instruction that references data tells the CPU what size the data has, and, data declarations also have a size.  In many assembly languages, consistency is programmer responsibility — assemblers often do not complain about (size) mismatches.

The CPU never sees data declarations, it only sees instructions.  So, each and every time an instruction references data, it has to specify how (i.e. the data size).  The CPU doesn't remember or care about mismatches between code in one place and code in another place, or between code & data; it just takes one instruction at a time and does what that says.

Expanding the data to match what the code does is the easiest fix here because your print subroutine takes the argument to print in the bc 16-bit register pair.

Otherwise, you can change the instruction to use the same size load as the defb, namely byte-sized instead of word-sized.  This would be done using an instruction like LD c,(score1), which loads only the c 8-bit register — and this is appropriate for data declared to 8-bits using defb.

To continue and use the print function, however, since the print expects a value in 16-bit bc, the 8-bit value in c will have to be expanded to a 16-bit value in bc, by clearing b (set b to 0, or by sign extending into b).

_{If I got the endian wrong, then swap references to the 8-bit registers with one letters b and c in what I said above.}

You can select the id's where all the values are 'I10'

Using dplyr :

There's no portable way of waiting for a certain amount of time under CP/M 2.2. CP/M doesn't require or use a real time clock or any kind of timer, and so you can't even assume one is present in the system, let alone that it uses any kind of common interface.

Turbo Pascal's Delay function worked by assuming a certain CPU frequency, one that was configured when Turbo Pascal was installed. The CP/M game Ladder was written in Turbo Pascal and used its Delay function, so it also assumed a certain CPU frequency. If you played on a faster or slower CPU the game would play faster or slower than intended.

The simplest solution would be to implement your own delay function that assumed a certain CPU frequency. I believe 4 MHz was the most common Z80 speed for CP/M. You can make this a configurable option so users can change the assumed CPU speed. You're probably also going to want to give users the option of changing the terminal type, just like Ladder did, as there are many possible terminals that can be used with CP/M.

CP performs a subtraction and sets the flags appropriately. It doesn't store the results of the subtraction.

So to compare for the A greater than the operand, you need to look for a result of that subtraction that was a strictly positive number, i.e. it was 1 or greater.

There's no direct route to that, you'll have to do it as a compound — NC to eliminate all results less than 0, getting you to greater than or equal, followed by NZ to eliminate the possibility of equality. But you might want to flip those for more straightforward code. E.g.

I just want to wrote down what @Jester already explained to me

1. using AND

Golly. LONG time since I used a z80 C compiler, and most were buggy as [unprintable] back then. I would suggest that you dump the assembler if the compiler allows. My GUESS is that internally the char is being promoted to a 16 bit INT with indeterminate upper bits set.

The problem is that %04X expects an integer - not a char.

You might try forcing the compiler to play nice by explicitly casting the char to an int - i.e.

printf("0x%04x | ", (int) i);