touche 2nd - Page 1

'lu

comment on fait pour detecter qquand l'utilisateur appuie sur la touche 2nd ?
le manuel de tigcc precise rien sur les codes des touches genre mode, alpha et tout ca resultat j'utilise

int key=ngetchx();
switch(key)
{
   case 268://instruction apres F1
   case.............
}

les touches alpha, maj, 2nd, et HAND sont des "modificateurs"
leur but est de modifier l'action correspondant à une autre touche (et donc, la valeur renvoyée par ngetchx quand on les utilise en combinaison avec une autre touche)
De ce fait, le fait d'appuyer uniquement sur une de ces touches modificateur ne peut pas être détecté par ngetchx.

Si tu veux lire ces touches sans avoir à ce qu'elles soient utilisées en combinaison avec une touche "normale", il faudra passer par les touches de la famille de _rowread...
Cela dit, si tu utilises ce genre de fonction de lecture du clavier, il te faudra détourner/désactiver les AUTO_INT 1 et 5... ce qui empéchera la lecture des autres touches avec ngetchx...
Il y a dans TIGCC pas mal de fonctions basées sur _rowread, parfois plus simples à utiliser ; cf la doc, si tu veux te lancer là-dedans

En somme :
- soit tu veux vraiment lire les touches modificateurs => famille de _rowread pour lire le clavier
- soit tu te passes des modificateurs => famille de ngetchx

(note: _rowread et assimilés sont généralement plus rapides que ngetchx (vu que les AUTO_INT 1 et 5 sont désactivés) et sont généralement utilisées pour les jeux)
(note 2 : _rowread n'attend pas une pression sur une touche : ça permet juste de savoir si une touche est enfoncée à l'instant où tu appelles cette fonction)

_keytest est bien plus pratique que _rowread même si c'est un peu la même chose.

heu... peut-être
jamais utilisé (me souvenais même plus le nom )
mais c'est effectivement à ça que je pensais en disant "famille de _rowread" ^^

merci squale92

c bien toi l'auteur des tutos c ?
je les utilise ils sont pas mal

ben en fait je voudrais absolument utiliser la touche 2nd
donc faut que j'utilise rowread
mais
"il te faudra détourner/désactiver les AUTO_INT 1 et 5... ce qui empéchera la lecture des autres touches avec ngetchx... "
c quoi les auto_int 1-5 ?

xantares :
merci squale92

de rien

xantares :
c bien toi l'auteur des tutos c ?

oui, en majeure partie

xantares :
je les utilise ils sont pas mal

merci

xantares :
"il te faudra détourner/désactiver les AUTO_INT 1 et 5... ce qui empéchera la lecture des autres touches avec ngetchx... " c quoi les auto_int 1-5 ?

ce sont des interruptions (des sortes de fonctions spéciales) appelées de manière régulière (plus ou moins ^^) automatiquement par AMS (le système d'exploitation de la TI)
l'AUTO_INT_1 est appelé entre 350 et 350 fois par seconde, me semble, selon qu'on est sur HW1 ou 2 ; le 5 est appelé entre 19 et 20 fois par seconde.
Pour les détourner/désactiver, regarde les docs de [tiwiki]SetIntVec[/tiwiki], [tiwiki]GetIntVec[/tiwiki], et [tiwiki]DUMMY_HANDLER[/tiwiki]
(et, de manière générale, ce qui est dans intr.h dans la doc de tigcc)

euh.............

he y'a plein de trucs compliqués là dedans !

moi j'veux juste detecter la touche 2nd
s'il faut utiliser keytest / rowread pas de prob
mais pour les interruptions là ca paraît achement complexe

tu peux me donner un bout de code pour voir ?

Suffit de faire un _keytest (RR_2ND).
Mais avant il faut désactiver les auto ints.

INT_HANDLER OldInt1 = NULL;
INT_HANDLER OldInt5 = NULL;

void _main (void)
{
  OldInt1 = GetIntVec (AUTO_INT_1);
  OldInt2 = GetIntVec (AUTO_INT_5);
  SetIntVec (AUTO_INT_1, DUMMY_HANDLER);
  SetIntVec (AUTO_INT_5, DUMMY_HANDLER);

  while (!_keytest(RR_2ND));

  SetIntVec (AUTO_INT_1, OldInt1);
  SetIntVec (AUTO_INT_5, OldInt5);
}

merci geogeo

jcomprends pas tout ton code mais vais essayer ca.

avant que tu commences à chercher a détecter les appuies de touches, tu met:
OldInt1 = GetIntVec (AUTO_INT_1);
OldInt2 = GetIntVec (AUTO_INT_5);
SetIntVec (AUTO_INT_1, DUMMY_HANDLER);
SetIntVec (AUTO_INT_5, DUMMY_HANDLER);


Tu détectes l'appuie de la touche [2nd] avec:
_keytest(RR_2ND)
(_keytest(RR_2ND) a une valeur différente de zéro que quand la touche 2nd est appuyée


Une fois que tu as fini d'utiliser le clavier avec _keytest, tu met:
SetIntVec (AUTO_INT_1, OldInt1);
SetIntVec (AUTO_INT_5, OldInt5);


Tu sais tout là; pour le reste il faut que tu réfléchisses...

là c plus clair.....

merci jfg

ca ne sert a rien
et sinon j'ai vu une faute de frappe OldInt5 pas OldInt2

Martial Demolins :
tiens, pourquoi initialiser les variables à NULL geogeo? Pour spécifier qu'il faut 4 octets?

pour mettre à 4 octets, non, même sans les initialiser, elles prendraient 4 octets
typedef void (*INT_HANDLER)(void);
c'est un pointeur déjà (void *) => ça prend nécessairement 4 octets

Martial Demolins :
quel avantage à ne pas utiliser un type (long en C il me semble)?

INT_HANDLER est défini comme un type
(un alias de void *, plus précisément ; cf juste au dessus)
utiliser INT_HANDLER au lieu d'un type plus "général" permet d'être plus clair : on comprend tout de suite, en voyant INT_HANDLER comme type, à quoi la variable servira.
(de plus, c'est plus clair au niveau du compilateur, qui se base sur les types pour les passages d'arguments de fonctions, les affectations, et tout ça)

Juste une précision, INT_HANDLER n'est pas un alias de void *, mais plutôt de void (*)(void) (malheureusement je ne suis pas sûr de la syntaxe), c'est-à-dire un pointeur vers une fonction ne prenant aucun paramètre et ne renvoyant rien.

void (*foo)(void)
est bien un pointeur sur une fonction que tu decris

ah oué ; pas fait gaffe à ce que je copiais-collais comme code pplus haut ^^
(et j'utilise pas souvent les pointeurs de fonction, faut avouer )

squale92 :
typedef void (*INT_HANDLER)(void);

c'est vrai ce mensonge-là ? en principe un INT_HANDLER n'est pas du tout une fonction, puisqu'il termine par rte... perso je dirais que c'est un pointeur vers un truc inconnu, point (donc pas "void *", mais le "contraire" : "struct Marmotte{} *")

bah... c'est ce qui est mis dans la doc
http://tigcc.ticalc.org/doc/intr.html#INT_HANDLER
après, vrai ou pas, j'en sais que dalle ^^

enfin, si on lit autour, ils disent que ça serait logique de le définir un peu comme ça, mais que en fait ça doit pas être ça, ou dans le genre
(et ils donnent l'explication détaillée ; RTFM quoi)

It might be logical that INT_HANDLER is defined as a pointer to a void function, i.e.

typedef void (*INT_HANDLER)(void);

But this is not true.

Donc non c'est pas défini comme ça ^^

Mais cela dit, quand on définit un INT_HANDLER avec TIGCC, on définit bien une fonction void handler(void) qui sera appelée par le vrai handler d'interruption. Donc la fonction qu'on définit se termine bien par un rts.

En parlant de ça au lieu d'utiliser INT_HANDLER pour spécifier une interruption on ne peut pas utiliser #pragma ... ?

Comment ça ?

Genre un truc de ce style? Car je connais certaines plateformes embarquées surtout pour les microcontrolleurs pour un robot où la déclaration d'une interruption se fait de cette façon:
#pragma interrupt_handler fonction_name:5

Genre on déclare la fonction 'fonction_name' qui correspond à l'interruption numéro 5.

DEFINE_INT_HANDLER, et surtout __attribute__((__interrupt_handler__)) ?
Voir http://gcc.gnu.org/onlinedocs/gcc-4.0.0/gcc/Function-Attributes.html#Function-Attributes pour plus d'infos.

Sasume :
Mais cela dit, quand on définit un INT_HANDLER avec TIGCC, on définit bien une fonction void handler(void) qui sera appelée par le vrai handler d'interruption. Donc la fonction qu'on définit se termine bien par un rts.

justement, cette fonction n'est pas le INT_HANDLER lui-même, d'où l'intérêt de faire la distinction entre les deux ^^ (enfin je me doute que toi tu le sais, mais je précise pour d'autres)

Il me semble qu'__attribute__((__interrupt_handler__)) est censé éviter l'encapsulation par un movem d0-d7/a0-a6 vers et de la pile + la séquence d'appel et de retour de la sous-fonction.
Gain pour les handlers simples ({counter++;}): plus de 300 clocks par exécution du handler. A 256 ou ~350-395 Hz, faites le calcul...

euh d0-d7/a0-a6, c'est pas *du tout* nécessaire... d0-d2/a0-a1 suffit

et 300 clocks à 300 Hz, ça fait même pas 1% du processeur : sachant que tes 300 clocks tiennent compte du fait que y a 15 registres sauvegardés alors que y a besoin d'en sauvegarder que 5, ça doit en fait faire plutôt dans les 0.3-0.4% du processeur ça vaut vraiment la peine

?? Un handler d'interruption ne doit modifier aucun registre, y compris SR.

J'ai fait le calcul et je sais que c'est négligeable, même en inlinant les sous-fonctions éventuelles du handler d'INT1.