Aide Coleco et assembleur

[bfg]

Bonjour, j'ai besoin d'une formation des pros de l'assembleur. Je voudrais coder une fonction qui affiche un bloc de 2*2 caractères sur Coleco en assembleur

put_square(void *bloc_data,unsigned vram_offset);

En gros

my_bloc_data={'A','B','C','D'};
put_square(my_bloc_data,vram+5};
--> Affiche sur l'écran à la position x=5,y=0

    AB
    CD

Je sais comment intégrer de l'assembleur en fonction dans le C, c'est l'algo qui coince. Voilà ce que je brouillonne :

Code:

put_square(void *bloc_data,unsigned vram_offset);

    pop     bc            depile l'adresse de retour de la fonction => bc
    pop     hl            depile l'adresse bloc_data=> hl
    pop     de            depile vram_offset (adresse de destination dans la vram )=> de
    push    de            ensuite on remet tout en place.  c'est necessaire puisque les "pop" l'ont retirer de la pile
    push    hl            sinon le RET a la fin de la routine , ne pourrait plus retrouver l'adresse de retour
    push    bc

 ld c,#0x00        c=0
debut$:
 ld a,c                 a = c = 0 au premier tour
 sub a,#0x02        a = a - 2 au premier tour
 jr NC,end$        Si le résultat n'est pas négatif alors c'est finit
 push bc                Je sauvegarde C
 
    di
    ld a,e          Charge la partie poid faible de l'adresse de destination
    out (0xbf),a    Balance sur le control port
    ld a,d          Charge la partie poid fort de l'adresse de destination
    or 0x60h        Agit directement sur A pour ajouter le flag d'écriture
    out (0xbf),a Balance sur le control port
    ld  bc,#0x02be  On va écrire Les données HL 2 fois sur le port be (paramétrage OTIR)

 otir Balance toutes les datas dans la destination et avance source et dest
 ei
 
 --> Je veux incrémenter DE de 32 pour pointer la ligne suivante dans la VRAM. Comment je fait ?
 
 pop bc  Je restaure C pour la boucle
 inc c j'incrémente C
 jr debut$ Je boule
end$:
 

La question est dans le code ... Comment je fais avancer l'adressage de destination de la VRAM de 32 pour passer à la ligne suivante dans la VRAM ??
Je ne trouve pas de commande pour le faire ... J'ai beau fouiller Z80 heaven des docs de C, je trouve pas les opérandes qui vont bien

HELP!!!

[vingazole]

--> Je veux incrémenter DE de 32 pour pointer la ligne suivante dans la VRAM. Comment je fait ?

Code:

push hl        ; sauve hl sur la pile
ld   hl,#32    ; hl = 32
add  hl,de     ; hl = hl + de ( = 32 + de, donc)
ex   de,hl     ; échange les contenus de de et de hl
pop  hl        ; restaure l'ancienne valeur de hl

Par contre ta fonction est très loin d'être optimisée : as-tu besoin de quelque chose de rapide ou pas spécialement ?

[bfg]

--> Je veux incrémenter DE de 32 pour pointer la ligne suivante dans la VRAM. Comment je fait ?

Code:

push hl        ; sauve hl sur la pile (facultatif)
ld   hl,#32    ; hl = 32
add  hl,de     ; hl = hl + de ( = 32 + de, donc)
ex   de,hl     ; échange les contenus de de et de hl
pop  hl        ; restaure l'ancienne valeur de hl (éventuellement)

Par contre ta fonction est très loin d'être optimisée : as-tu besoin de quelque chose de rapide ou pas spécialement ?

Purée, il faut réfléchir à l'envers !!!! hl prend 32 et on lui bourre de !!
Je connaissais pas ex :)

Déjà, je fait ce petit exercice pour comprendre, et oui, ensuite je voudrais faire de manière rapide, un remplissage d'écran par des tiles de 2*2 caractères ...

En tout cas merci, c'est vraiment une autre logique ...

[vingazole]

Oui, c'est ça qu'est marrant !

Par contre j'ai édité : la sauvegarde/restauration de hl n'est pas facultative dans ton cas puisque hl doit continuer de pointer sur tes données.

[vingazole]

A tester mais ça devrait être plus rapide :

Code:

ld   a,e       ; a = e
add  a,#32     ; a = a +32
ld   e,a       ; e = a
ld   a,d       ; a = d
adc  a,#0      ; a = a + 0 + CF (la retenue obtenue en faisant e+32)
ld   d,a       ; d = a

[bfg]

Rooo punaise ...

Bon, la version sans t'on opti fonctionne ! (A un bug prêt c'etait un or 0x40 au lieu de 0x60).

Je vais pas dire que je me sens pousser des ailes mais bon ... Je devrais pourvoir transférer de plus grand bloc aussi maintenant ...

Merci !!

[vingazole]

De rien :)

J'en profite pour te féliciter : j'adore ta chaîne, même si je ne commente ni ne like pas forcément à chaque fois !

[Spirale]

Un petit commentaire qui ne fait rien avancer du tout. C'est juste pour dire que je suis toujours admiratif devant ceux qui utilise l'assembleur et encore plus devant ceux qui le maitrise.

[bfg]

Bon, ben sur ces bonnes paroles j'aimerais comprendre un truc ...
Voici la routine :

Code:

   .module psquare
   .globl _put_square
   
   .AREA _CODE
   ;void put_square(void *bloc_data,unsigned chrtab);
_put_square:
   pop    bc            ;depile l'adresse de retour de la fonction => bc
    pop    hl            ;depile l'adresse bloc_data=> hl
    pop    de            ;depile vram_offset (adresse de destination dans la vram )=> de
    push    de            ;ensuite on remet tout en place. 
                    ;c'est necessaire puisque les "pop" l'ont retirer de la pile
    push    hl            ;sinon le RET a la fin de la routine
    push    bc           ;ne pourrait plus retrouver l'adresse de retour
   
   ld c,#0

0$:
   ld a,c
   sub   a,#0x02
   jr   NC,1$
   push bc
   
    di
    ld a,e          ;Charge la partie poid faible de l'adresse de destination
    out (0xbf),a    ;Balance sur le control port
    ld a,d          ;Charge la partie poid fort de l'adresse de destination
    or #0x40        ;Agit directement sur A pour ajouter le flag d'écriture
    out (0xbf),a   ;Balance sur le control port
    ld  bc,#0x02be  ;On va écrire Les données HL 2 fois sur le port be (paramétrage OTIR)

   otir         ;Balance toutes les datas dans la destination et avance source et dest
   ei
   
   push hl        ; sauve hl sur la pile
   ld  hl,#32    ; hl = 32
   add  hl,de    ; hl = hl + de ( = 32 + de, donc)
   ex  de,hl    ; échange les contenus de de et de hl
   pop  hl        ; restaure l'ancienne valeur de hl
   
   pop bc
   inc   c
   jr   0$
1$:   


Je récupère les paramètres balancé par l'appel du C par les 1er pop.

Maintenant, j'ai fait une fonction en C toute bête

Code:

int offset(byte x,byte y)
{
   return (y<<5)+x;
}

C'est compilé ainsi en assembleur :

Code:

_offset_start::
_offset:
   push   ix
   ld   ix,#0
   add   ix,sp
;functions.c:9: return (y<<5)+x;
   ld   l,5 (ix)
   ld   h,#0x00
   add   hl, hl
   add   hl, hl
   add   hl, hl
   add   hl, hl
   add   hl, hl
   ld   e,4 (ix)
   ld   d,#0x00
   add   hl,de
   pop   ix
   ret

Quel est la meilleure méthode pour récupérer les paramètres ?
Je comprends la seconde méthode, mais d'après la doc z80 ix c'est plus lent que les autres registres 16 bits...

Ce que je pige pas, c'est comment avec la 1ère méthode je peux récupérer les valeurs d'une procédiure à 10 paramètres ...

J'avoue que je navigue à l'aveugle car j'ai pas trouvé d'explication sur le net...

[Hpman]

Bah tu peux pas? 

Je suis pas expert z80 mais la 1ere méthode ressemble plus à de la bidouille pour gagner quelques cycles quand on n'a pas besoin de beaucoup de paramètre.
La 2eme est beaucoup plus orthodoxe, en tout cas pour quelqu'un qui viens du 68k.

[Invité]

Par contre ta fonction est très loin d'être optimisée : as-tu besoin de quelque chose de rapide ou pas spécialement ?

Non mais regardez comme il se la pète celui là 
Rapide ?? sans BCD, impossible .. 

Je connaissais pas ex :)

Quoi t'as jamais eu de copines avant d'être marié ?? 

[drfloyd]

a quand un vrai cours d'assembleur Z80 pour les nuls sur Gamopat ?

[bfg]

Bah tu peux pas? 

Je suis pas expert z80 mais la 1ere méthode ressemble plus à de la bidouille pour gagner quelques cycles quand on n'a pas besoin de beaucoup de paramètre.
La 2eme est beaucoup plus orthodoxe, en tout cas pour quelqu'un qui viens du 68k.

Ben a priori on peut mais c'est encore moins clair dans le genre une proc qui récupère les params pour faire un appel d'un proc bios. Avec du exx et des shadow register. Après si c'est la seconde méthode la plus propre, ça me va je la comprends :)

Code:

   ; get_bkgrnd (void *table, byte x, byte y, byte width, byte height)
   
   .area _CODE

_get_bkgrnd:
      exx
      pop   hl
      exx
      pop   hl
      pop   de
      pop   bc
      push   bc
      push   de
      push   hl
      exx
      push   hl
      exx
      push   ix
      push   iy
      call   0x0898
      pop   iy
      pop   ix
      ret

[vingazole]

Je te conseillerais, à l'instar d'Emmanuel Macron de Bouddha, la voie du milieu !

Sous réserve que je me plante (ce qui est très fréquent, j'avoue), une fois que ta fonction offset est appelée, le pointeur de pile (SP) pointe sur l'adresse de retour du CALL, donc x est pointé par SP+2 et y par SP+3.

Tu peux donc faire :

Code:

ld  hl,#2
add hl,sp
ld  b,(hl)  ; b = x  [hl = SP+2]
inc hl
ld c,(hl)  ; c = y  [hl = SP+3]

nb. dans ton exemple avec ix les paramètres sont en SP+4 et SP+5 car le push ix les décale de deux octets par rapport à la base de la pile; en effet il faut éviter au maximum d'utiliser les adressages indexés sur le z80 (que ce soit avec ix ou iy) car ils sont très coûteux en cycles

[vingazole]

a quand un vrai cours d'assembleur Z80 pour les nuls sur Gamopat ?

ça n'aurait d'intérêt qu'en choisissant une machine-cible (la coleco, au hasard), à mon humble avis

[bfg]

Je te conseillerais, à l'instar d'Emmanuel Macron de Bouddha, la voie du milieu !

Sous réserve que je me plante (ce qui est très fréquent, j'avoue), une fois que ta fonction offset est appelée, le pointeur de pile (SP) pointe sur l'adresse de retour du CALL, donc x est pointé par SP+2 et y par SP+3.

Tu peux donc faire :

Code:

ld  hl,#2
add hl,sp
ld  b,(hl)  ; b = x  [hl = SP+2]
inc hl
ld c,(hl)  ; c = y  [hl = SP+3]

nb. dans ton exemple avec ix les paramètres sont en SP+4 et SP+5 car le push ix les décale de deux octets par rapport à la base de la pile; en effet il faut éviter au maximum d'utiliser les adressages indexés sur le z80 (que ce soit avec ix ou iy) car ils sont très coûteux en cycles

Pourquoi je comprends ton code, et pas celui de la lib Colecovision 
Ok, mais alors comment dans mon exemple généré par le compilo, les résultat est renvoyé ?
Comment tu ferais toi ?

(Promis après je pose plus de question je fais des tests :) ) (Si j'avais un débugger pas à pas aussi ...)

[nemokantio]

Pour la récupération des paramètres, entièrement d'accord avec la méthode de vingazole.
Ensuite, pour le résultat d'une fonction, sdcc le récupère dans l ou hl.

[drfloyd]

a quand un vrai cours d'assembleur Z80 pour les nuls sur Gamopat ?

ça n'aurait d'intérêt qu'en choisissant une machine-cible (la coleco, au hasard), à mon humble avis

Oui je pensais à la Coleco.... d'autant que les jeux sont courts, souvent 8ko, et que c'est facile à sortir ensuite son jeu en cartouche.

un cours pour vrai débutant, qui a limite n'a jamais touché au C et au basic.

[bfg]

Pour la récupération des paramètres, entièrement d'accord avec la méthode de vingazole.
Ensuite, pour le résultat d'une fonction, sdcc le récupère dans l ou hl.

Ok, messieurs, j'irais grâce à vous me coucher moins con ce soir !!

Je vais faire des fonctions basiques pour tester ça !

MERCI BEAUCOUP !!

[vingazole]

Pour la récupération des paramètres, entièrement d'accord avec la méthode de vingazole.
Ensuite, pour le résultat d'une fonction, sdcc le récupère dans l ou hl.

Oui, de mémoire tu mets le résultat dans hl pour un int et seulement dans l pour un char (signé ou pas).

[vingazole]

a quand un vrai cours d'assembleur Z80 pour les nuls sur Gamopat ?

ça n'aurait d'intérêt qu'en choisissant une machine-cible (la coleco, au hasard), à mon humble avis

Oui je pensais à la Coleco.... d'autant que les jeux sont courts, souvent 8ko, et que c'est facile à sortir ensuite son jeu en cartouche.

un cours pour vrai débutant, qui a limite n'a jamais touché au C et au basic.

Ca me paraît difficile de partir vraiment de zéro : il faudrait réexpliquer -encore- les bases de la programmation : la numération, le complément à deux, la virgule fixe, etc...

Et puis perso je n'ai jamais programmé la Coleco, j'aurais "un peu" du mal à l'expliquer...

[drfloyd]

Il faut bien partir de zéro pour apprendre l'assembleur

je ne pense que de savoir ecrire 10 PRINT "HELLO WORLD" puisse aider

[Hpman]

Il faut aussi savoir quels sont les registres considérés comme scrath pour ton compilateur, ça permet d’éviter de s'emmerder à les préserver pour rien.

[Invité]

Ca me paraît difficile de partir vraiment de zéro : il faudrait réexpliquer -encore- les bases de la programmation : la numération, le complément à deux, la virgule fixe, etc... 

Faudrait pas partir de ci-bas, mais du principe quand même que les gens connaissent un minimum(sinon ça va prendre trois plombes à expliquer les bases) .
Je pense qu'il faut partir du principe que ça s'adresse aux gens ayant déjà codé(peu importe le langage)
Expliquer brièvement le hardware, comment compiler, les outils à utiliser,etc .

[vingazole]

je ne pense que de savoir ecrire 10 PRINT "HELLO WORLD" puisse aider

Non, mais rien que de connaître déjà les concepts de mémoire, de variables, etc... ça permet de sauter des chapitres.

[Invité]

Oui c'est pour ça qu'il faut partir du principe que les personnes ont déjà codé 

[vingazole]

(Si j'avais un débugger pas à pas aussi ...)

Je vais peut-être dire une ânerie, mais Meka (le fameux émulateur pour SMS) ne permet-il pas de débugger la Coleco ?

[vingazole]

Oui c'est pour ça qu'il faut partir du principe que les personnes ont déjà codé 

Oui, tu as eu le temps de poster la même chose avant moi.

Sinon on peut aller plus loin et supposer que les gens ne savent pas compter, voire même ne savent pas lire.

[drfloyd]

Cours en assembleur Z80 Coleco pour les gens ayant des notions informatiques et de programmation alors.... Ca aurait du succès franchement.... l'assembleur reste un mystère pour une grande partie de la population (et meme de beaucoup de développeurs !)

[vingazole]

L'idéal c'est peut-être "la méthode TOUKO" : apprivoiser la machine en codant en C - ou autre, sous réserve qu'il y ait d'autres possibilités - puis petit à petit introduire de l'ASM en inline pour optimiser certaines fonctions...