Anti Rebond instantanné ???

[invite9cfa3f9b]

Tout d'abord bonjour ts le monde.

Voila je suis élève ingé en électronique (première année) et je suis actuellement en stage.

Mon projet et la réalisation d'un accordéon electro acoustique

Problématique :


Je dois lire 32 touches. Pour cela je vais câbler des interrupteurs sous forme "matricielle". Je les regroupe par 8. Comment est constitué le câblage ? Prenons un groupe de 8. Je relie chaque interrupteur entre eux et je branche finalement mon fil sur un port du microP définie en sortie. je me retrouve dc pr l'instant avec un fil. j ai toujours huit pattes en l air. je relie chacune de ses huit pattes à un bit d'un autre port de mon microP définie cette fois en entrée.

Lecture : Je met un 1 en sortie => un interrupteur est fermé alors je récupère un 1 sur un des bits de mon entrée. j'obtiens ainsi un mot de huit bits représentatif de mes huit interrupteurs.

Ensuite j active un autre bit en sortie et je reviens lire l'état de mes inter et ainsi de suite dans une boucle infini.

Le problème des inter c'est les rebonds. je dois donc les traiter et cela doit être fait en soft !

Ok je fais une fonction avec une tempo tous ça fonctionne bien.

Ma démarche était : je lis l état du port d entrée en boucle pdt une durée déterminée à l'aide d'un timer et j effectue deux mesures dans ma boucle. Si la mesure a changé alors peut être s'agit il d'un rebond alors je reset le timer et recommence le processus...

Dans l'idéal si pas de rebond, je reviens lire le même interrupteur toute les 15ms. Si il y a du parasite étant donné que je "reset" mon timer à chaque detection d un changement de mon signal, ca peut prendre 15ms de lire un groupe de 8. donc je reviens lire dans le pire des cas le même inter tous les 45ms. Pas mal non ? bah non c mal !! ca donne donc dans le pire des cas une réactivité de l'instrument de 45ms et mon tuteur dis qu'il faut qu'elle soit de 1ms !!!!

Euh oui d'accord mais un rebond dure dans les 10ms.

1ms suppose que je passe pas plus de 330microS à lire mon groupe de 8 interrupteurs.

Comment puis-je traiter un rebond qui dure dans les 7-8ms en seulement 330microS ??????

votre aide me sera en tous cas certainement très utile.

merci de votre future aide.

Corentin
-----

[invitee05a3fcc]

Bonjour coco86 et bienvenue sur FUTURA

• Tu peux dire qu'un appui sur une touche dure (au moins ) 100mS. Donc dès que tu trouves un contact, tu démarres ta musique
• tu viens relire ta touche 99 mS plus tard,
• et ensuite ton anti-rebond au relachement

[invite9cfa3f9b]

D'accord mais le problème c'est que plusieurs touches en même temps peuvent être appuyée. Donc si je ne reviens faire ma mesure que 100ms plus tard et q'une touche du même groupe est appuyée elle ne sera pas lu. et ma contrainte d'1ms n'est plus respecté

J'avoue que je trouve que se problème soulève trop de paradoxe, je crois trouver une solution mais cela pose à chaque fois de nouveau problème.

Merci pour ta réponse rapide.

Corentin

[invite9cfa3f9b]

un traitement bit à bit pourrait-il être efficace ?

Si oui bonjour le code à taper mais bon...

[A voir en vidéo sur Futura]

[invitee05a3fcc]

Tu peux relire ton clavier 1mS plus tard et ne pas tenir compte de l'état de la touche que tu as trouvé "On" avant et ceci pendant 99 mS

PS: ne pas oublié de mettre une diode en série avec chaque touche.

[invite9cfa3f9b]

oui je n'ai pas parlé des diodes mais elles sont présente.

Donc ca revient un peu à se que je viens de dire dans mon message précédent il faut faire du traitement bit à bit.

Je vois pas très bien comment coder tous ça mais je vais réfléchir...(et moi qui croyais avant de commencer que ça aller être fastoche à réaliser...)

Merci pr ton aide

[invitee05a3fcc]

On récupére 8 touches à la fois, on stocke dans une matrice nouvelle, un XOR avec la matrice précédente, on a toutes les touches qui ont changé d'état

[invite6d608176]

Comment puis-je traiter un rebond qui dure dans les 7-8ms en seulement 330microS ??????

Bonjour,

A mon avis cela doit pouvoir se faire avec un compteur par touche et une boucle de pooling.

-Chaque passage dans la boucle de pooling fait -1 sur chaque compteur non nul.
-Chaque fois qu'une touche appuyée est détectée on met le compteur à MaxValue= 16 par exemple.
-Chaque compteur non nul correspond à une touche qui a été appuyée et le tone souhaité est généré en conséquence.

JP

[invite9cfa3f9b]

salut. J'étais partis sur l'idée de lancer un timer qui tourne en fond de mon programme, puis affecter à chaque détection de changement d'état la valeur du timer. Tant que la différence avec le timer et la valeur enregistrée n'a pas atteint une certaine valeur, on actualise pas la valeur. Mais merci pour vos conseils je vais essayé d'avancer mon programme.

Crdt

[invite9cfa3f9b]

juste pr rebondir (haha) sur ton commentaire, le problème c'est que mon µP est cadencé à 4MHz. Pour atteindre une durée de l'ordre de la 10aine de ms ainsi, va falloir mettre une valeur plutot importante. Alors que je peux cadencé mon Timer a 4Mhz/1024 ce qui permet une tempo correct. Ou alors j ai pas compris ce que tu voulais me dire

[invitee05a3fcc]

Ton timer sert à cadencer la scrutation de ton clavier (toutes les 5 mS par exemple) et tu comptes le nombre de scrutation (avec un compteur par touche) pour savoir si les 99mS sont passés (avec ma méthode)

[invite9cfa3f9b]

rebonjour tous le monde.

bon j'ai avancé mais j'ai toujours quelque petit souci technique :

voila comment j'ai procédé :

je travail avec des tableau. Je dois lire en réalité 6 paquets de 8 interrupteurs.
Je viens donc lire un premier paquet de 8 je stock dans la première ligne de mon tableau (qui comprend 8 cases par ligne). je fait un XOR avec le tableau de la valeur mesurée à la mesure d'avant. Si il y a eut un changement, alors, SI, un certain délai est passé (grâce à une matrice qui relève la valeur du timer au dernier changement mesuré) alors ce changement est pris en compte. sinon on laisse l'ancienne valeur. et ainsi de suite avec les huits paquet. le problème tient de plusieurs choses :

premièrement, un même paquet ne se fait pas scruter toute les millisecondes comme voulu, à cause je pense de la "lourdeur" du programme.

deuxièmement, un rébond étant aléatoire il se peut que deux mesures successive donne une valeur identique et dans ce cas là, on ne détect pas l'appui sur une touche

je vais donner mon code en espérant qu'in ne vous sera pas trop indigèste :

code :

while(1)
{
*TCCR0=0x05;
{
for(p=0;p<6;p++)
{

test_touche(&touche_p[p][0]);
for(j=0;j<8;j++)
{
touche_p[p][j]=new_touche[p][j];
}
ecrit_touche(&touche_p[p][0],p);
if(*PORTC!=0x20)
{
*PORTC=*PORTC*2;
}
else
{
*PORTC=0X01;
}
}

}

}


return 0;
}


void test_touche(unsigned char *touche_prec)
{
int i=0;
int j=0;
unsigned char tempo[6][8];
unsigned char touche[6][8];
gp_tch=*PINB;
switch(*PORTC)
{
case 0x01:do
{
port=0;
touche[port][i]=gp_tch&0x01;
gp_tch=gp_tch/2;
i++;
}while(i<8);
break;
case 0x02:do{
port=1;
touche[port][i]=gp_tch&0x01;
gp_tch=gp_tch/2;
i++;
}while(i<8);break;
case 0x04:do{
port=2;
touche[port][i]=gp_tch&0x01;
gp_tch=gp_tch/2;
i++;
}while(i<8);break;
case 0x08:do{
port=3;
touche[port][i]=gp_tch&0x01;
gp_tch=gp_tch/2;
i++;
}while(i<8);break;
case 0x10:do{
port=4;
touche[port][i]=gp_tch&0x01;
gp_tch=gp_tch/2;
i++;
}while(i<8);
break;
case 0x20:do{
port=5;
touche[port][i]=gp_tch&0x01;
gp_tch=gp_tch/2;
i++;
}while(i<8);
}

for(j=0;j<8;j++)
{
val1=touche[port][j];
val2=touche_prec[j];
change[port][j]=val1^val2;
}

{
for(j=0;j<8;j++)
{
if(change[port][j]&&do_change[port][j]==0x01)
{
new_touche[port][j]=touche[port][j];
tempo[port][j]=*TCNT0;
do_change[port][j]=0;
}
else
{
new_touche[port][j]=touche_prec[j];
}
if((*TCNT0-tempo[port][j])>0x00)
{
do_change[port][j]=1;
}
}
}

/*
if(*PORTC!=0x20)
{
*PORTC=*PORTC*2;
}
else
{
*PORTC=0X01;
}
*/

}

void ecrit_touche(unsigned char *touche_p,int L)
{
int mult,i;
unsigned char data;
mult=1;
data=0x00;
for(i=0;i<8;i++)
{
data=data+touche_p[i]*mult;
mult=mult*2;
}

*PORTD=data;


}

merci par avance.

[invite9cfa3f9b]

Autre question :

Je viens de regarder, avec le debugger, une mesure sur un groupe d'interrupteur dure entre 200 et 300 micro alors qu'avec le simulateur, elle dure 1ms !!


Qui est le plus fiable ?

edit : en réglant l'horloge interne du microP à la bonne fréquence ça marche un peu mieux...désolé

[Qristoff]

Pour info parce que tu sembles parti sur la méthode soft, il y a le MC14490 qui est un anti rebond "hardware" à six entrées..dispo chez Farnell http://fr.farnell.com/jsp/search/bro...equestid=93127