clavier, et optimisations.. - Page 1

qqes questions:
-il vaut mieux faire un lea ($4c00).w,a0 ou alors un move.w #$4c00,a0? [vitesse/taille svp]
-Faut-il utiliser movea (en terme general, pas seulement pour au dessus) ou alors as (on-calc) optimise tout seul lorsqu'il le faut?
-Pour la lecture du clavier, je désactive toutes les interruptions en passant le niveau de priorité le plus élevé (move.w #$700,d0 | trap #1) je récupere le code de la touche et je réactive tous les ints..

getkey:
 ints -> off
 écriture dans le port $600018
 lecture et stockage de l'octet $60001A
 ints -> on
 rts 
[...]
keyloop:
 bsr getkey
 test de la touche
 analyse de la touche
 [...]
 bra.s keyloop

la lecture de la touche marche, mais apparament les ints sont tjs actifs, puisque je peux voir l'indicateur 2nd allumé (auto-int 1 je crois..) et le déplacement de mon sprite
est ralenti si une touche est maintenue enfoncée (auto-int 2 il me semble). Comment faire?

Attention, il me semble que movea.w #$4c00,a0 charge le mot contenu à l'adresse $4c00 dans a0, alors que lea ($4C00).w,a0 charge l'adresse $4C00 dans a0.

Je parle d'un move.w #$4c00
J'ai d'autres questions également:
- que fait exactement un move.w #x,d0 (la syntaxe la plus logique serait move.w x,d0), sachant que x est définit comme ça: x dc.w 0 ?
- j'ai un freeze lorsque je fais :

lea lcd(pc),a0
[...] 
lcd dc.w $4c00

alors que lea ($4c00).w,a0 fonctionne.

> Je parle d'un move.w #$4c00
movea.w #$4c00: 12 clocks, lea $4c00,an (8 clocks).

> que fait exactement un move.w #x,d0 (la syntaxe la plus logique serait move.w x,d0), sachant que x est définit comme ça: x dc.w 0 ?
Un move.w #nnn,d0 met la valeur nnn dans d0.w; un move.w nnn,d0 prend le mot à l'adresse nnn et le met dans d0.w.
Ici, x étant défini comme un word en mémoire et pas comme un equate, l'expression correcte est move.w x,d0.

> j'ai un freeze lorsque je fais :
lea lcd(pc),a0
[...]
lcd dc.w $4c00
alors que lea ($4c00).w,a0 fonctionne.
La différence entre lea et movea (& et * en C)...
C'est movea.w lcd(pc),a0 qui est équivalent à lea $4c00.w,a0.

On a déjà répondu à la première question. Pour la deuxième: je ne sais pas, essaye. Mais je pense bien qu'il te mettra movea tout seul. AS on-calc est bête, mais probablement pas si bête que ça. Reste la troisième:

Nerick a écrit :
-Pour la lecture du clavier, je désactive toutes les interruptions en passant le niveau de priorité le plus élevé (move.w #$700,d0 | trap #1) je récupere le code de la touche et je réactive tous les ints..

getkey:
 ints -> off
 écriture dans le port $600018
 lecture et stockage de l'octet $60001A
 ints -> on
 rts 
[...]
keyloop:
 bsr getkey
 test de la touche
 analyse de la touche
 [...]
 bra.s keyloop

la lecture de la touche marche, mais apparament les ints sont tjs actifs, puisque je peux voir l'indicateur 2nd allumé (auto-int 1 je crois..) et le déplacement de mon sprite est ralenti si une touche est maintenue enfoncée (auto-int 2 il me semble).

Normal. Les interruptions s'activent en dehors de ta routine de lecture de touches (getkey). Dans keyloop par exemple.

Comment faire?

Tu rediriges les interruptions pendant tout le programme. Et ne les désactive pas avec le trap 1, redirige-les vers un rte, en faisant bien garde à ne pas rediriger l'auto-interruption n°3! Sinon, tu arrêtes l'horloge! En revanche, il faut absolument rediriger les auto-interruptions 1 et 5 pour faire de la lecture de touches bas niveau.

AS on-calc est bête

n'oublions pas que c un programme... et donc dépourvu d'intelligence...

jackiechan
a écrit : Attention, il me semble que movea.w #$4c00,a0 charge le mot contenu à l'adresse $4c00 dans a0, alors que lea ($4C00).w,a0 charge l'adresse $4C00 dans a0.

Excuse moi, j'ai confondu movea.l $4c00,a0 et movea.w #$4c00,a0.

Oki, tout marche nikel
Kevin> Pour ce qui est du detournement des ints, pour l'instant je fais le bourrin, je desactive toutes les ints au debut du programme, puis je reactive tout a la fin, en repassant la main a AMS. Mais effectivement, je n'avais pas pense a l'int 3...
Donc je redirige les ints 1 et 5 sur un rte au debut du prog. Mais au moment de la lecture des touches, je desactive tout ou non (juste le temps de la lecture) ?
De plus, est-ce aue je redirige aussi l'int 2 (j'avais lu qu'il etait a 660Hz je crois, ce qui fait ralentir le systeme lorsque les touches sont maintenues appuyees) ?

Sinon, pour une eventuelle adaptation de mon programme en niveau de gris (d'ailleurs faut que je trouve comment activer les gris en nostub.. ca va pas etre facile mais je verrai ca plus tard [ca m'embeterai d'avoir a recopier les sources de tigcc...]), les redirections des ints 1 et 5 (eventuellement le 2, ca dependera de ta reponse a la question precedente ) sont suffisante, ou alors il y a d'autres ints a detourner ?

> que fait exactement un move.w #x,d0 (la syntaxe la plus logique serait move.w x,d0), sachant que x est définit comme ça: x dc.w 0 ?
Un move.w #nnn,d0 met la valeur nnn dans d0.w; un move.w nnn,d0 prend le mot à l'adresse nnn et le met dans d0.w. Ici, x étant défini comme un word en mémoire et pas comme un equate, l'expression correcte est move.w x,d0.

D'accord pour move.w x,d0.. mais je ne saisit toujours pas ce que fait move.w #x,d0: que contiendrait alors le reg d0 si x est definit par x dc.w 3 par exemple?

Ah, sinon je viens de decouvrir que AS n'optimisait pas tout seul un move.l vscr,a0 par exemple. Lorsque je remplace ca par movea.l vscr(pc),a0, je gagne 6 octets

Edit> ah ce nest pas a cause du movea mais a l'adressage relatif au pc. Donc c bon c normal

> j'ai un freeze lorsque je fais :
lea lcd(pc),a0
[...]
lcd dc.w $4c00
alors que lea ($4c00).w,a0 fonctionne.
La différence entre lea et movea (& et * en C)... C'est movea.w lcd(pc),a0 qui est équivalent à lea $4c00.w,a0.

Je comprends tout a fait, mais dans ce cas, pourquoi est-ce que:

lea string(pc), a0
[...]
string dc.b "salut",0

marche? string est bien defini comme une suite d'octets en memoire, tout comme lcd au dessus, en fin de compte (2 octets)...

Encore une question , est-ce qu'un label suivi de ':' et un label sans ':' sont equivalents? Si oui, alors:

loop:
[...]
dbf d0,loop

est equivalent a
[pre]loop: [...] dbf d0,loop [pre] ?

Nerick a écrit :
]> j'ai un freeze lorsque je fais :
lea lcd(pc),a0
[...]
lcd dc.w $4c00
alors que lea ($4c00).w,a0 fonctionne.

Je comprends tout a fait, mais dans ce cas, pourquoi est-ce que:

lea string(pc), a0
[...]
string dc.b "salut",0

marche? string est bien defini comme une suite d'octets en memoire, tout comme lcd au dessus, en fin de compte (2 octets)...

Parce que dans le premier cas (celui du freeze), tu as chargé dans a0 l'adresse du mot $4c00 au lieu de charger ce mot lui-même.
Dans le deuxième cas, tu charges également l'adresse de la chaine, donc c'est normal que ça marche .

Dans le premier cas, il aurait fallu faire movea.l lcd(PC),a0 (mais je ne suis pas sûr, je n'ai pas testé).
J'ai l'impression que tu essaies d'utiliser des variables globales comme des constantes.
Définis plutôt des constante comme ça :

LCD EQU $4C00
...
 LEA.L LCD,a0

non non, ct juste un exemple... dans mon prog, je ne fait pas de definition du lcd comme ca.
ce que je voulais dire, c pk est ce aue avec 'string' le lea marche, mais pas avec 'lcd', pourtant defini comme string,cad une suite d'octets...
(c Nerick)

lea lcd(pc),a0
[...]
lcd dc.w $4c0

marche pas

lea atring(pc),a0
[...]
lcd dc.b "salut",0

marche

Oui, je t'ai expliqué pourquoi dans mon post #13.
Quand tu fais lea.l Labal(PC),a0 tu charges l'adresse du Label dans a0, pas son contenu.
Et quand tu fais :
Label dc.w $4C00

Le mot '$4C00' est à une certaine adresse dans le prog, et c'est cette adresse que tu charges.

et puis à mon avis, c'est mieux de faire dc.l $4C00 parce que si tu charges juste le mot $4C00, tu risque d'avoir des couilles après en utilisant ton registre d'adresse, au cas où il y avait des trucs dans le mot de poids fort.

>D'accord pour move.w x,d0.. mais je ne saisit toujours pas ce que fait move.w #x,d0: que contiendrait alors le reg d0 si x est definit par x dc.w 3 par exemple?
Je n'en sais rien, mais je pense que l'assembleur ne va pas être content. Il le sera si x est défini comme x equ 3, mais là, je ne suis pas sûr du tout...
Regarde toi-même ce que le code que tu proposes fait...

jackiechan> ok

Sinon, comment on déprotege l'acces aux vecteurs d'interruption? parsque j'ai un PMV qd j'essaye de lire/ecrire dans cette zone..

jackiechan
a écrit : et puis à mon avis, c'est mieux de faire dc.l $4C00 parce que si tu charges juste le mot $4C00, tu risque d'avoir des couilles après en utilisant ton registre d'adresse, au cas où il y avait des trucs dans le mot de poids fort.

C'est faux, une extension de signe est faite automatiquement lors d'un move.w vers un registre d'adresses. Reste à savoir pourquoi une extension de signe et pas une extension par zéros.

Nerick a écrit :
Oki, tout marche nikel
Kevin> Pour ce qui est du detournement des ints, pour l'instant je fais le bourrin, je desactive toutes les ints au debut du programme, puis je reactive tout a la fin, en repassant la main a AMS. Mais effectivement, je n'avais pas pense a l'int 3... Donc je redirige les ints 1 et 5 sur un rte au debut du prog. Mais au moment de la lecture des touches, je desactive tout ou non (juste le temps de la lecture) ?

Ce n'est pas la peine normalement.

De plus, est-ce aue je redirige aussi l'int 2 (j'avais lu qu'il etait a 660Hz je crois, ce qui fait ralentir le systeme lorsque les touches sont maintenues appuyees) ?

Comme tu veux. Si tu trouves que c'est utile, fais-le, ça ne dérange rien.

Sinon, pour une eventuelle adaptation de mon programme en niveau de gris (d'ailleurs faut que je trouve comment activer les gris en nostub.. ca va pas etre facile mais je verrai ca plus tard [ca m'embeterai d'avoir a recopier les sources de tigcc...]),

Il y a déjà un portage des routines de niveau gris de TIGCC pour AS on-calc. (Regarde du côté de "routines CC".)

les redirections des ints 1 et 5 (eventuellement le 2, ca dependera de ta reponse a la question precedente ) sont suffisante, ou alors il y a d'autres ints a detourner ?

1 et 5 suffisent. Le 2 est optionnel. Les autres ne posent pas problème.

Ok merci
Pour les vecteurs d'ints, j'ai trouvé finalement, dans le zguide.

T'as l'air de trafiquer les ints dans ta fonction de lecture du clavier. C'est inutile et ça ralentit la fonction

Ce n'est pas inutile. Réfléchis.

Je crois deviner. J'ai employé une expression Kevinéenne de manière Kevinéenne. C'est ça ?
Alors je me corrige : T'as l'air de trafiquer les ints dans ta fonction de lecture du clavier. Ca ralentit la fonction.

Est-ce que adda.l d0,a0 et lea (a0,d0),a0 sont équivalents?

Thibaut> ça ralentit rien, puisque je désactive toutes les interruptions (mais c'est provisoire).

>adda.l d0,a0 et lea (a0,d0),a0
Comme tu l'as écrit, on ne peut pas savoir (d0 = d0.w ou d0.l ?).
(a0,d0) n'est pas une écriture standard... Peut-être qu'elle est acceptée, mais elle n'est pas standard.

adda.l d0,a0: prend les 32 bits de d0 et les ajoute aux 32 bits de a0.
adda.w d0,a0: prend les 16 bits du bas de d0, fait le sign-extend en interne, ajoute les 32 bits sign-extended à a0.
lea 0(a0,d0.w),a0: prend les 16 bits du bas de d0, fait le sign-extend en interne, les ajoute à a0, ajoute un déplacement de 0 octets.
lea 0(a0,d0.l),a0: prend les 32 bits de d0, les ajoute à a0, ajoute un déplacement de 0 octets.

mm.. je sais que lea (a0,d0),a0 n'est pas standard, mais as accepte
je me posais la question, parsque dans certains cas, adda.l d0,a0 provoque un plantage, mais lea (a0,d0),a0 passe.
Donc, lorsque l'on ne précise pas la taille du registre dans le lea, qu'est-ce qui est sous-entendu?

la taille par défaut est souvent .w

oki