one more time keytest - Page 1

bonjour tout le monde...
et oui ! encore un problème d'input... mais bon là je galère vraiment...
voilà mon souci, je sais qu'il faut rediriger les interruptions 1 et 5, etc..
bon, pour la une, pas de problème, mais le 5 elle gère les timers non ?

mon problème c'est que je procède à la lecture du clavier dans une boucle se finissant lorsqu'un timer expire... autant dire que je ne peux pas désactiver les timer... pour info, c'est pour un jeu tetris

pour l'instant, je n'ai pas touché à l'AI5 et le programme tourne assez convenablement... mais bon ça ne me semble pas propre du tout...

alors que faire ?

voilà le code qui fait descendre ma pièce.. while (1)     {         OSFreeTimer (USER_TIMER) ;         OSRegisterTimer (USER_TIMER, Timer) ;         while (!OSTimerExpired (USER_TIMER))         {             if (_keytest (RR_ESC)) {running = 0 ; return ;} ;             if (_keytest (RR_RIGHT)) Try2MoveRight () ;             else if (_keytest (RR_LEFT)) Try2MoveLeft () ;             if (_keytest (RR_DIAMOND)) RotateCW () ;             else if (_keytest (RR_2ND)) RotateCCW () ;             OSFreeTimer (BATT_TIMER) ;             OSRegisterTimer (BATT_TIMER, 5) ;             while (!OSTimerExpired (BATT_TIMER)) ;         }         if (Collision ())             break ;                      REDRAW_PIECE ;         ++CurrPiece->pY ;         REDRAW_PIECE ;     }

ah oui, on m'a parlé de redéfinir l'interruption 5, mais bon, je ne vois pas trop en quoi cela pourrait m'aider... (je débute, hein...)

...donc les timers ne marcheront toujours pas :/
Par contre, tu peux récrire un handler (regarde la doc de DEFINE_INT_HANDLER) qui fait office de compteur.

déjà merci les gars pour vos réponses
c'est fait pour le DUMMY_HANDLER, j'ai vu ça et ça marche nickel pour l'AI1

ok pour réécrire un handler, c'est ce qu'on m'avait précédemment conseillé...
je saurais le déclarer et rediriger les AI5 vers lui, ok, mais je ne vois pas QUOI lui faire faire.. ?
je suis désolé, ce n'est pas très clair pour moi toutes ces histoires d'interruptions...

bon alors ça servirait à quoi de définir un nouveau handler ?
il serait censé faire quoi ?

merci de votre patience, hein...

Il y a un exemple dans la doc il me semble, teste le

hmm... à mon avis j'ai du mal à comprendre où se situe le conflit entre rowread et l'AI5...

est-ce que tu es en train de me dire que si je redirige l'AI5 vers un simple handler du type
DEFINE_INT_HANDLER(MyInt5)
{
ExecuteHandler (OldInt5);
}

ou bien entendu, OldInt5 est le précédent handler sauvegardé...

alors, mon problème sera résolu ?


j'ai fait ça et mon programme tourne parfaitement !
mais bon, il tournait également sans problème avant que je redirige l'AI5 vers ce handler...

pas très clair pour moi tout ça...

en règle générale, si tu laisses l'AUTO_INT_5 d'AMS (ce que tu fais au post 6), ton programme fonctionnera
mais de temps en temps, un problème peut se poser ; par exemple, ton programme peut croire qu'une touche a été pressée sans que ça n'ait été le cas en réalité (me semble que c'est le genre de bug que ça peut poser)

ok, c'est bien ce que je pensais... mais si je le vire le timer marche autant que que si je redirigeai l'AI5 vers un DUMMY_HANDLER, ok ? en gros, ça marche pas...

alors ma question c'était, comment on garde un timer en redirigeant l'AI5... ??
et si faut définir un nouveau Handler, on met quoi dedans ?

on garde pas un timer en redirigeant l'AI5
(enfin, tu pourrais, si ton AI5 perso appelait celui d'AMS - mais vu que tu redirige justement pour éviter que celui d'AMS soit appelé, ça perdrait pas mal de son intéret)

l'AI5 (par défaut) est appelé 19 à 20 fois par seconde
il suffit de définir un AI5 perso qui incrémente un compteur
et quand la valeur de ce compteur est à 20 => c'est qu'une seconde est passée

genre : (en gros)

en variable globale :
unsigned long compteur = 0;

puis tu définis ton handler :

DEFINE_INT_HANDLER(mine)
{
    compteur++;
}

et dans ta fonction :

// blah blah installation handler

while (...)
{
    
    // ce que tu veux
    
    if (compteur >= 20)
    {
         // ça fait une seconde (environ)
         // remise à 0 du compteur
         compteur = 0;
    }
}

// blah restauration de l'AI5 d'AMS

ok !
donc on laisse tomber les OSFreeTimer et compagnie c'est bien ça ?
très bien expliqué en tout cas, merci beaucoup !

je test de ce pas et je vous tiens au courant

FunkyMatt :
donc on laisse tomber les OSFreeTimer et compagnie c'est bien ça ?

ils dépendent de l'AI5 d'AMS (le même qui peut interférer avec la lecture clavier bas-niveau) ; donc, oui

et bien cette fois çi j'ai compris !

merci beaucoup pour ces explications..

soit dit en passant, si tu ne fais rien de particulier, n'hésite pas à stopper le processeur dans ta boucle. L'interruption le réveille, et comme de toutes façons ta variable ne vas pas bouger avant l'interruption

par contre, il faut que le compteur soit volatile, sinon il risque de ne pas être relu à chaque test.

Bah c'est pas très compliqué, c'est juste un masque de bits...et puis la touche on n'est pas masquable il me semble, donc au pire il suffit de rallumer.

Ca change rien. Même si tu désactives la prise en compte de l'autoint 6 par le processeur via le sr, tu supprimes pas le signal électrique correspondant, et l'asic le verra. Donc il relancera le processeur (qui sera alors libre d'ignorer royalement l'autoint 6 s'il veut, l'important étant qu'il soit relancé).

C'était un exemple. Ce que je voulais montrer c'est que la gestion de l'autoint 6 est totalement dissociée de l'asic qui bloque et relance le processeur.

ouaip, sauf que pendant mon timer je regarde ce qui se passe au niveau du clavier, donc je pense pas qu'il doit trop dormir l'autre...

mais merci en tout cas pour ces précisions...

si je peux mettre mon grain de sel...

dans le handler que tu as marqué, squall... tu mets

DEFINE_INT_HANDLER(mine)
{
compteur++;
}

je sais pas comment certains vont prendre ça, mais un ++compteur à la place marcherait autant, si ce n'est mieux
en effet l'opérateur de pré incrémentation est "bien mois lourd" que celui de post incr, dans la mesure où il n'a pas à faire de copie de l'objet avant de l'incrémenter, et qu'il peut renvoyer directement le résultat de l'incrémentation, au lieu de renvoyer la copie...
pour une telle fonction appellée une 20aine de fois par seconde, le résultat est exactement le même est est plus "propre"

c'était juste pour pinailler !
je ne veux donner de cours à personne, je partage quelque chose que j'ai appris il y a peu et qui m'a fait ouvrir les yeux sur ce qu'était un programmme "bien foutu", et qui peut être utile quand on ne programme pas sur des architextures à 8GHz, non ?

voilà, et encore merci à tous pour votre aide précieuse

là tu est sur le bon forum si tu veux pinailler, surtout quand il s'agit d'optimisation.
au passage, je crois que tu dis n'imp.

1) le type concerné est un entier, donc en envoyer une copie ne provoque pas d'overhead (y'a pas d'appel de constructeur, etc comme pour une classe en c++)
2) de toutes façons la valeur de retour est inutilisée, et sur un entier, ++ n'étant pas une fonction mais un opérateur trivial (de toutes façons en C la question ne se posait pas), le compilateur a tous les éléments en main pour ne pas calculer un truc qu'il n'utilisera de toutes façons pas.

ouaip, sauf que pendant mon timer je regarde ce qui se passe au niveau du clavier, donc je pense pas qu'il doit trop dormir l'autre...

Et est-il réellement indispensable de vérifier si une touche est appuyée 10000 fois par secondes ? Tu tappes si vite que ça ?
20 vérifications par seconde c'est amplement suffisant.

Si tu veux tu feras une version spéciale pour M.Flash qui permet d'appuyer 10000 touches par seconde, mais je pense que pour le commun des mortels, 20 touches / seconde suffiront amplement, et l'économie en utilisation des piles sera substancielle.

FunkyMatt :
dans le handler que tu as marqué, squall... tu mets

squale, stp ^^

spectras
: 1) le type concerné est un entier, donc en envoyer une copie ne provoque pas d'overhead (y'a pas d'appel de constructeur, etc comme pour une classe en c++)

-classe+"classe sans constructeur inlinable" </troll>

ouaip, sauf que pendant mon timer je regarde ce qui se passe au niveau du clavier, donc je pense pas qu'il doit trop dormir l'autre...

Et est-il réellement indispensable de vérifier si une touche est appuyée 10000 fois par secondes ? Tu tappes si vite que ça ?
20 vérifications par seconde c'est amplement suffisant.
Si tu veux tu feras une version spéciale pour M.Flash qui permet d'appuyer 10000 touches par seconde, mais je pense que pour le commun des mortels, 20 touches / seconde suffiront amplement, et l'économie en utilisation des piles sera substancielle.

10000 c'est un peu exagéré, mais ça peut être utile d'en détecter par exemple 100 / seconde : c'est possible en consommant à peine plus de piles, soit en utilisant l'int 1 (là ça fait 400 interruptions / seconde, mais on peut en ignorer les trois quarts), soit en changeant la fréquence de l'auto-int 5 ^^

-classe+"classe sans constructeur inlinable" </troll>

je sens comme une résurgence de ce sujet ces temps ci

10000 c'est un peu exagéré, mais ça peut être utile d'en détecter par exemple 100 / seconde : c'est possible en consommant à peine plus de piles, soit en utilisant l'int 1 (là ça fait 400 interruptions / seconde, mais on peut en ignorer les trois quarts), soit en changeant la fréquence de l'auto-int 5 ^^

Oui, le nombre n'est pas important, ce que je disais c'est que boucler sur la détection de touches et refuser d'arrêter le processeur entre deux interruptions, (1 ou 5 c'est pas le problème), c'est idiot.

On est d'accord ^^

désolé squale, un vieux reste de ff8 je suppose, héhé

ouaip, bon, je ne connais pas la signification d'overhead, je me doutais bien que le copmilateur gérait tout seul ce genre d'optimisations, mais bon, tant qu'à faire...
et puis c'est vrai que je taquine quand même mieux le c++ que le c...

au temps pour moi, et vive les i++

FunkyMatt :
désolé squale, un vieux reste de ff8 je suppose

je commence à avoir l'habitude, depuis le nombre d'années qu'on me fait régulièrement le coup ^^
pas grave ^^