Eine weitere Schleife mit Z80 anhängen ?

Es gibt viele Möglichkeiten, dies wäre eine:

1

  ld hl,$c000

2

  ld c,0

3

  ld a,3

4

5

loop1:

6

  ld b,16

7

8

loop:

9

  ld (hl),a

10

  inc l

11

  djnz loop

12

  ld l,0

13

  inc h

14

  dec c

15

  jrnz loop1

DAS meinte ich mit "viele Möglichkeiten".

hex-fan schrieb:
> MaWin schrieb:
>
>> Man kann auch B vor der inneren Schleife pushen
>
> Push/Pop ist immer 16 bit. Also BC.

Der Assembler könnte das anders sehen, wenngleich "push b" eher 
8080-Syntax ist.

----------------------------------
Willst Du wirklich über 64k verteilt immer die ersten 16 Byte jeder
256-Byte-Page mit $03 überschreiben ?
----------------------------------

Nein die Werte werden sich später ändern , die dann von einem Speicher 
ausgelesen werden.

Ich möchte erstmal einen Grund in meine Frage reinbekommen.
Der Z80 hat sehr viele Befehle.

Danke.

Peter B. schrieb:
> Ich möchte erstmal einen Grund in meine Frage reinbekommen.
> Der Z80 hat sehr viele Befehle.

Dann beschränke Dich zunächst auf den Befehlssatz des 8080.

Es ist für den N-GO für den layer2.

Ich möchte in einer SChleife dieses $c000 in hl immer um 256 erhöhen.
Dieses Grundprinzip suche ich für den Z80.
Kann auch nur 10x sein , aber wie?

Danke.

Moin,

michael_ schrieb:
> Peter B. schrieb:
>> Der Z80 hat sehr viele Befehle.
>
> Nö.

Doch!
Ohhh!
Gegenueber einem 6502 hat der Z80 doch deutlich mehr...
Aber's gibt sicher auch Prozessoren mit noch mehr Befehlen als der Z80 
hat.

Zur aeusseren Schleife kann ich auch nur sagen:
"Erlaubt ist, was gefaellt" und "Viele Wege fuehren nach Rom".

Gruss
WK

Vielleicht kann man mir bitte helfen ,wie ich einen zähler bei loop3 
setze?
Diese hl erhöhen um 256 habe ich jetzt gefunden. Nun fehlt mir eine 
Zählschleife für loop3 dazu.

Danke.


loop3:
  ...............................
  ld bc,256
  ld hl,$c000
  add hl,bc
  ld b,16
loop1:
  ld a,252
  ld (hl),a
  inc hl
  djnz loop1
  ..........................
  djnz loop3

Peter B. schrieb:
> Diese hl erhöhen um 256 habe ich jetzt gefunden

"inc h" hätte für diesen Fall gereicht, aber das Laden von HL muss aus 
der Schleife raus, sonst schreibt er immer ab $C100.

FOp schrieb:
> Percy N. schrieb:
>
>> Dann beschränke Dich zunächst auf den Befehlssatz des 8080.
>
> Würde ich so nicht sagen. Die Mnemomics von Intel sind grausam, da hat
> Zilog echte Verbesserungen gebracht.

Das mag sein, nur besteht der Befehlssatz des Prozessors nicht aus 
irgendwelchen Mbemonics.

FOp schrieb:
> Hatte ich erwähnt, dass ich die Mnemonics von Intel Murks finde ?

Nein, Du hast nur erkennen lassen, dass Du sie für einen Befehlssatz 
hältst.

Experte schrieb:
> Mario M. schrieb:
>>   push bc
>>   push hl
>
> Meine Güte! Der Z80 hat Register und Befehle, da muss doch nicht so
> gedankenlos programmieren:

Die registerbasierte Schreibweise hatte ich in meinem ersten Post schon 
gezeigt, aber der TO hat es entweder nicht gelesen oder nicht verstanden 
bzw. nicht kommentiert. Solange er nicht genau sagt, was er will, kann 
man keine optimale Version erstellen. Es kann ja z.B. auch sein, dass er 
das Füllbyte an die Routine übergeben möchte.

Danke für eure Hilfe.

jetzt funktioniert mein Beispiel.

Experte schrieb:
> Vielleicht weiß er auch nur nicht, wie man 16-Bit-Arithmetik mit dem Z80
> macht.

Ja, das weiß nicht jeder, dabei konnte schon der 8080 16- bit-Adfitionen 
mit HL als Zielregister ...

Schwer ist es mit dem Zahlen nicht , die zu bearbeiten.

Ich finde die verschiedenen Lösungen für die Schleifen nicht so richtig.
Welches der Verantwortliche Zähler ist von den Registern usw.

Wie kann man dann bitte buffer nutzen? :

buffb:
     db 0
buffw
     dw 0

Kann man die auch als Ersatz nehmen statt : push / pop ?
Wäre für mich übersichtlicher und sauberer.
Bei push und pop weiss ich dann nicht woran das liegt wenn das Programm 
andere Daten schickt die nicht stimmen oder abstürzt.

Wie geht das mit dem buffer und welches Register nimmt man bitte dafür?

Ich glaube, jetzt ist der Punkt gekommen, an dem Du mal ein Buch über 
Z80-Programmierung zur Hand nehmen solltest.
https://www.mathematik.uni-ulm.de/users/ag/yaze-ag/devel/Programmierung_des_Z80.pdf

Danke, habe ich mir mal runter geladen.

Den Grundsatz der Register mit befüllen und schieben , ldir , addieren , 
subtrahieren ist kein Problem.

Ich suche eben das arbeiten mit den verschiedenen Schleifen formen und 
das arbeiten mit buffer statt dieses push pop.
Das steht nicht so drin im Buch.
Die vielen Seiten dort drin wie ein Byte aufgebaut ist , das ist 
Verschwendung im Buch. Bei speziellen Fragen weicht der Autor auch aus.

So etwas geht nicht mit dem Debugger.
So sehen meine Programme aus für den N-GO/NEXT
-----------------------
program Layer2;
@use "screen"
@use "text/txt"
@use "memory"
@use "Next"
@use "compression"

var
  y,z,p : Byte;
  zp:pointer;
  x,ac,ad,af : integer;

procedure Delay(del: Byte);
begin
  while (del > 0) do
  begin
    Memory_VSync();
    del := del - 1;
  end;
end;

procedure plotlayer();
begin
  asm("
  L2_BANK equ 32

  ld bc,#243b
  ld a,$56
  out (c),a
  ld bc,#253b
  ld a,L2_BANK*2
  out (c),a

  ld hl,$c000+16
  ld b,10
loop2:
  push bc
  push hl
  ld b,16
loop1:
  ld a,252
  ld (hl),a
  inc hl
  djnz loop1
  pop hl
  ld bc,256
  add hl,bc
  pop bc
  djnz loop2

  ld bc,#243b
  ld a,$12
  out (c),a
  ld bc,#253b
  ld a,L2_BANK
  out (c),a

  ld bc,#243b
  ld a,$69
  out (c),a
  ld bc,#253b
  ld a,$80
  out (c),a
  ");
 end;

begin
  plotlayer();

  Loop();
end.
------------------------------
procedure UpdateSprite();
begin
  asm("
  ld a,0      ; get ID spriteid
  ld bc, $303b  ; selct sprite slot
  out (c), a

  ld bc, $57    ; sprite control port
  ld a,100      ; attr 0 = x  (msb in byte 3)
  out (c), a

  ld a,50      ; attr 1 = y  (msb in optional byte 5)
  out (c), a

  ld d,0      ; attr 2 = now palette offset and no rotate and mirrors 
flags send  byte 3 and the MSB of X
  ld a,0      ; msb of x
  and 1
  or d
  out (c), a     ; attr 3

  ld a,128+5    ; attr 4 = Sprite visible and show pattern
  or 192       ; bit 7 for visibility bit 6 for 4 bit
  out (c), a

  ld a,10      ; attr 5 the sub-pattern displayed is selected by N6 bit 
in 5th sprite-attribute byte.
  out (c), a    ; att
  ");
end;
-----------------------------

....sich gute Z80 Quellcodes zu
besorgen.

Dieses ist Relativ zu meinem Programm , es geht nicht mit ähnlichen 
Programmen. Ich finde keine ASM für meine Fragen mit dem Layer2 usw. und 
den Bänken.


---------------------
So ein Buch hätte ich mir früher für den Atari ST gewünscht,
---------------------
Davon gab es zwei verschiedene Bücher , jetzt auch noch mit PDF.
Ich habe die beiden als PDF und den ATARI ST als CORE auf meinem MISTER.

Welchen Debugger meinst Du, was für ein Pascal-Compiler ist das? Solche 
Details hätten in den Eröffnungspost gehört.

Das ist Turbo Rascal.

rbx schrieb:
> Z80 Assembly Language Subroutines (1983)(Osborne)(pdf)
> (in die Suchmaschine eingeben)

https://archive.org/details/bitsavers_osborneboogeSubroutines1983_24203802

Ich habe jetzt mal Module gemacht.
Wieviel Byte kann man eigentlich mit dem Call nach vorne gehen?
Und wieviel Byte wieder zurück springen mit dem JP?
Es sollten mehr Byte wie 128 sein beim Rücksprung.

----------------------
procedure plotlayer();
begin
  asm("
  L2_BANK equ 32

  call banki
weiter:
  call plot
weiter1:
  call fertig

banki:
  ld bc,#243b
  ld a,$56
  out (c),a
  ld bc,#253b
  ld a,L2_BANK*2
  out (c),a
jp weiter

plot:
  ld hl,$c000+16
  ld b,10
loop2:
  push bc
  push hl
  ld b,16
loop1:
  ld a,252
  ld (hl),a
  inc hl
  djnz loop1
  pop hl
  ld bc,256
  add hl,bc
  pop bc
  djnz loop2
jp weiter1

fertig:
  ld bc,#243b
  ld a,$12
  out (c),a
  ld bc,#253b
  ld a,L2_BANK
  out (c),a

  ld bc,#243b
  ld a,$69
  out (c),a
  ld bc,#253b
  ld a,$80
  out (c),a

  ");
 end;
-------------------------

Peter B. schrieb:
> Wieviel Byte kann man eigentlich mit dem Call nach vorne gehen?
> Und wieviel Byte wieder zurück springen mit dem JP?

Unbegrenzt in beide Richtungen. Die 8080 Befehle adressieren absolut 
alle 64 KB. Erst Z80 JR ist PC-relativ.

Danke, klappt ganz gut mit dem call.

rbx schrieb:
> Ich hatte mehrere Treffer, mit ziemlich ähnlichem Inhalt. Ich würde den
> Link vom cpcwiki empfehlen.

Warum tust Du es dann nicht? Verlässt Du Dich darauf, dass auch diesen 
link ein anderer für Dich heraussucht, wie es oben schon geklappt hat?

------------------------
Sei froh, wenn dir paar alte Säcke darauf überhaupt antworten können.
------------------------

Ich habe auch erst mit 72 jahren damit angefangen.
In 6 Monaten werde ich 74.

Dein Satz geht daneben.

Nimm du alter Sackmal ein billiges Bandmas , die meisten sind glaube ich 
2 Meter.
Schneide davon die Lebenserwartung von einem Man ab. Die Beträgt ca. 87 
jahre
Schau dir diese Länge an von 87 cm.
Davon schneidest du dein Lebensalter ab , den Rest davon hälst du in die 
Hand....Manche können die wenigen Jahre nicht genießen.
Sei froh wenn du es noch kannst.

Prost

Peter B. schrieb:
> Das ist Turbo Rascal.

Wenn Du schon einen Compiler hast, warum willst Du Dich dann mit 
Assembler quälen?

Der Compiler macht für Dich die ganze Variablenverwaltung, d.h. Du 
kannst soviele Zählschleifen basteln, wie Du RAM hast.