Return to Question

I'm building my own Z80 computer but I'm having a very strange problem. Consider this code:

ld a,0xaa
out (00),a
jp a

That works as expected, outputting 0xaa on port 0x00. Now consider this code:

 ld a,0xaa
hello:
 out (00),a
 inc a
 jp hello

This outputs exactly 87 times to port 0x00, then it crashes. I took a look at the buses to see what's happening and it seems that it accesses incrementally addresses on memory when it's not needed. I read a year ago that this was a thing due to Z80's architecture, but the problem happens when this incremental access reaches 10000000(bin). This is what I see in the logic analyser:

The increment is happening on address 3 4 5 6 7 and 8, and when the 8th modulates, iorq stops and the CPU does weird stuff. Can any one please help?

###EDIT:

I found the answer but if you have the same or similar issue, you should definitely read Spektre's and tofro's answers because they list a lot of very possible problems that could cause this.

I'm building my own Z80 computer but I'm having a very strange problem. Consider this code:

ld a,0xaa
out (00),a
jp a

That works as expected, outputting 0xaa on port 0x00. Now consider this code:

 ld a,0xaa
hello:
 out (00),a
 inc a
 jp hello

This outputs exactly 87 times to port 0x00, then it crashes. I took a look at the buses to see what's happening and it seems that it accesses incrementally addresses on memory when it's not needed. I read a year ago that this was a thing due to Z80's architecture, but the problem happens when this incremental access reaches 10000000(bin). This is what I see in the logic analyser:

The increment is happening on address 3 4 5 6 7 and 8, and when the 8th modulates, iorq stops and the CPU does weird stuff. Can any one please help?

EDIT:

I found the answer but if you have the same or similar issue, you should definitely read Spektre's and tofro's answers because they list a lot of very possible problems that could cause this.

So i'm building my own z80 computer but i'm having a very strange problem. this code

ld a,0xaa
out (00),a
jp a

works as expected, outputting 0xaa on port 0x00 but this code:

 ld a,0xaa
hello:
 out (00),a
 inc a
 jp hello

outputs exactly 87 times in 0x00, then it crashes. i took a look in the buses to see what's happening and it seems that it accesses incrementally addresses on memory when it's not needed. i read a year ago that this was a thing due to z80's architecture but the problem happens when this incremental access reaches 10000000(bin).this is the what i see in the logic analizer

the increment is happening on address 3 4 5 6 7 and 8.and when the 8th modulates, iorq stops and the cpu does weird stuff. can any one please help?

EDIT:

i found the answer but if you have the same or similar issue, you should definitely read Spektre's and tofro's answers because they lists a lot of very possible problems that could cause this

I'm building my own Z80 computer but I'm having a very strange problem. Consider this code:

ld a,0xaa
out (00),a
jp a

That works as expected, outputting 0xaa on port 0x00. Now consider this code:

 ld a,0xaa
hello:
 out (00),a
 inc a
 jp hello

This outputs exactly 87 times to port 0x00, then it crashes. I took a look at the buses to see what's happening and it seems that it accesses incrementally addresses on memory when it's not needed. I read a year ago that this was a thing due to Z80's architecture, but the problem happens when this incremental access reaches 10000000(bin). This is what I see in the logic analyser:

The increment is happening on address 3 4 5 6 7 and 8, and when the 8th modulates, iorq stops and the CPU does weird stuff. Can any one please help?

###EDIT:

I found the answer but if you have the same or similar issue, you should definitely read Spektre's and tofro's answers because they list a lot of very possible problems that could cause this.

So i'm building my own z80 computer but i'm having a very strange problem. this code

ld a,0xaa
out (00),a
jp a

works as expected, outputting 0xaa on port 0x00 but this code:

 ld a,0xaa
hello:
 out (00),a
 inc a
 jp hello

outputs exactly 87 times in 0x00, then it crashes. i took a look in the buses to see what's happening and it seems that it accesses incrementally addresses on memory when it's not needed. i read a year ago that this was a thing due to z80's architecture but the problem happens when this incremental access reaches 10000000(bin).this is the what i see in the logic analizer

the increment is happening on address 3 4 5 6 7 and 8.and when the 8th modulates, iorq stops and the cpu does weird stuff. can any one please help?

EDIT: i accepted tofro's answer because it was closer to the solution but if you have the same or similar issue, you should definitely read Spektre's awesome answer because it lists a lot of very possible problems that could cause this

So i'm building my own z80 computer but i'm having a very strange problem. this code

ld a,0xaa
out (00),a
jp a

works as expected, outputting 0xaa on port 0x00 but this code:

 ld a,0xaa
hello:
 out (00),a
 inc a
 jp hello

outputs exactly 87 times in 0x00, then it crashes. i took a look in the buses to see what's happening and it seems that it accesses incrementally addresses on memory when it's not needed. i read a year ago that this was a thing due to z80's architecture but the problem happens when this incremental access reaches 10000000(bin).this is the what i see in the logic analizer

the increment is happening on address 3 4 5 6 7 and 8.and when the 8th modulates, iorq stops and the cpu does weird stuff. can any one please help?

EDIT: 

i found the answer but if you have the same or similar issue, you should definitely read Spektre's and tofro's answers because they lists a lot of very possible problems that could cause this