Discussion :

[lcoulon]

Bonjour,

J'utilise un C embarqué et pour une application je cherche à faire fonctionner, j'aurai besoin que lorsque qu'un bouton poussoir est appuyé, celui ci réalise différentes actions en fonction du temps sur lequel l'utilisateur va l'appuyer :

Le bouton poussoir est déclaré comme une variable

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

unsigned char BP_1;

L'état de BP_1 est donc soit 0 ou 1 si il est appuyé ou non.

Je cherche à faire ceci :

BP_1 appui bref < 0.5s - considéré comme accidentel --> Action : ne fait rien - pas d'action
BP_1 appui supérieur à 0.5s puis l'utilisateur fait des impulsions successives sur le bouton : incrémente de +1 la valeur d'une variable appelé VAR1 à chaque nouvelle impulsion ou si le bouton est maintenu appuyé moins de 1 seconde
BP_1 est maintenu appuyé par l'utilisateur plus de 2 secondes : incrémente par pas de +5 la valeur de la variable VAR1.
BP_1 est appuyé 2 fois rapidement puis relaché ( plus d'impulsion dans la seconde qui suit ) : incrémente de +1 la variable VAR2

On rencontre souvent ce type de bouton poussoir intelligent sur les appareils électronique du moment, je pense qu'il deja exister des codes fonctionnels pour faire cela mais je n'ai pas trouvé.


Pour faire des essais, j'ai tenté ceci mais essayer de reproduire l'incrémentation de +1 de la variable VAR1 mais ça n'est pas concluant du tout :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
unsigned char n = 0;
unsigned char VAR1 = 0;

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
            while (BP_1 == 0)                    // Quand le BP + est appuyé, BP_1 passe à 0, au repos BP_1 est '1'
            {
            n++;
                if (n>200)                          // en fonction de la vitesse du micro n permet de faire la tempo de 0.5s
                    {
                    VAR1 += 1;
                    __delay_ms(1000);             // ré-incrémentera VAR1 que 1 seconde plus tard
                    }
           }
           n=0;

Est ce que le code ci-dessous est une bonne façon de procéder pour réaliser ce type de fonctionnalité ?
Je ne sais pas trop comment faire.

Merci à vous,

[skeud]

Il faut regrouper tes 4 cas en seulement 3:
Appuie < 0,5 -> on fait rien
0,5 < Appuie < 2 -> on incrémente de un par appuie
Appuie > 2 -> on incrémente par 5 par appuie.

Donc:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
int ChoixFonction()
{
  int timer = 0;
  while (BP_1 == 0)
  {
    __delay_ms(100); // On évite de surcharger le proc
    timer += 100;
  }
  // On a relacher le bouton
  if (timer < 500)
    return (0);
  if (timer < 2)
    return (1);
  return (2);
}
 
void incremente(int pas)
{
    int timer = 0;
    int enfoncer = 0;
    while (timer < 1000) // Tant que le temps que le bouton reste pas enfoncer est inférieur à 1 seconde
    {
        if (BP_1 == 0 && enfoncer == 0) // Si le bouton est enfoncer et que c'est la première passe
        {
           // On incrémente le compteur
           VAR1 += pas;
           // On précise qu'on a déjà fait l'incrémentation
           enfoncer = 1;
           // On remet le compteur à 0
           timer = 0;
        }
        if (BP_1 == 1) // Si le bouton n'est pas enfoncer
        {
           // On précise qu'a la prochaine activation du bouton, on incrémente la valeur
           enfoncer = 0;
        }
        __delay_ms(100); // On évite de surcharger le proc
        if (enfoncer == 0) // Si le bouton n'est pas enfoncer, on incrémente le compteur
          timer += 100;
    }
}
 
int principal()
{
    int res = ChoixFonction();
    if (res == 1)
      incremente(1);
    if (res == 2)
      incremente(5);
}

Il te suffit donc d'appeler la fonction principal régulièrement pour savoir quelles actions tu dois faire .

[lcoulon]

Merci pour l'idée.
Du coup cela ferait 2 fonctions, est ce possible de rassembler les 'cas' dans des switch cases ?

Pour le 4eme cas, comment pourrais je faire pour l'intégrer lui aussi :
BP_1 est appuyé 2 fois rapidement puis relaché ( plus d'impulsion dans la seconde qui suit ) : incrémente de +1 la variable VAR2

Cordialement,

[skeud]

Deux fois rapidement c'est à dire? Le premier clique est-il supérieur à 0.5 seconde?

[lcoulon]

oui, une sorte de double clic comme sur une souris, ce sera incrémenter la variable VAR2 qui aura pour effet de quitter un menu sur un afficheur LCD.

Les delais d'appui sur les boutons pourront etre ajouté à l'usage , c'est surtout pour comprendre la démarche qui permet de coder cette fonctionnalité.

Est ce qu'il est possible de faire des switches cases ?

[skeud]

Le soucis, c'est que tu ne pourras pas distinguer le cas 1 (appuie bref puis plusieurs appuie) du cas 4 (appuie bref puis un seul appuie). Je serais toi, je passerais par un deuxième bouton. Ce qui semble plus logique, un bouton par variable à incrémenter, en général c'est comme ça que l'on fait .

[lcoulon]

ChoixFonction() permet de déterminer le tout 1er appui sur le bouton poussoir, n'est ce pas ?
Je voudrai, pour me simplifier réunir la fonction principal(); et choixFonction();

J'ai compris que ces 2 fonctions permettent, une fois réunies d'indiquer les actions à effectuer par la suite.

Par contre, je n'ai pas très bien compris pourquoi, incremente(int pas) teste à son tour le timer,
Le timer à été testé avant dans la fonction choixFonction();

Je pense que si on pouvait tout combiner en 1 seule fonction cela devrait plus clair pour moi.

Info utile que je n'avais pas précisé auparavant :
Mon projet utilise une interruption qui intervient lorsque le bouton poussoir passe de l'état '1' à l'état '0'
En fait la détection du 1er appui sur le bouton se fait donc automatiquement et permet alors d’exécuter une fois ce changement d'état détecté une ou plusieurs fonctions : c'est à dire celles que nous écrivons actuellement.

[skeud]

J'utilise le timer dans la deuxième fonction pour savoir quand est-ce que le bouton est relâche plus de 1 seconde, de cette manière on sort de la fonction de traitement. J'ai volontairement séparé les deux fonctions afin d'en avoir une première qui acquiert le signal et une seconde qui effectue le traitement, c'est une bonne pratique à avoir plutôt que de tout réunir dans une seule fonction.

D'un point de vue global, plus tu auras des petites fonctions qui font une seul chose, mieux ça sera, ton code sera maintenable plus facilement et les impacts en modifiant une fonction seront beaucoup plus minimes et prévisibles .