API tools faq
paste
Ollivier

DFR0075 Modifié Clic long clic court double clic _ commentaires

Ollivier
Aug 18th, 2020 (edited)
71
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 13.25 KB | None | 0 0
raw download clone embed print report
  1. // DFR0075 ======================================================================
  2. // Code fabricant modifié du module 5 boutons DFR0075
  3. // https://wiki.dfrobot.com/ADKeyboard_Module__SKU__DFR0075_
  4. // Permet le simple clic (clic court), le clic long, et le double-clic
  5. // une version sans commentaire de ce code se trouve ici :
  6. // https://pastebin.com/uWBVLtGx
  7. // une version du code fabricant hyper commentée aussi se trouve ici :
  8. // https://pastebin.com/JXRjZ4G3
  9. // ===============================================================================
  10. // Ollivier JULLIEN || aout 2020
  11. // 100% libre de droit
  12. // (en cas de copie, merci de citer l'auteur...
  13. // il a travaillé dur pour vous le donner ;) )
  14. // ===============================================================================
  15.  
  16. // Fonctionnement du module DFR 0075
  17. /* Si on appuie sur le bouton 0 (S1), la valeur analogique reçue est inférieure à 600
  18. * Si on appuie sur le bouton 1 (S2), la valeur analogique reçue est supérieure à 600 et inférieure à 650
  19. * Si on appuie sur le bouton 2 (S3), la valeur analogique reçue est supérieure à 650 et inférieure à 700
  20. * Si on appuie sur le bouton 3 (S4), la valeur analogique reçue est supérieure à 700 et inférieure à 800
  21. * Si on appuie sur le bouton 4 (S5), la valeur analogique reçue est supérieure à 800 et inférieure à 900
  22. * Si on appuie pas la valeur analogique reçue est supérieure à 900 (1023, normalement)
  23. * Ces valeurs sont celles fixée par le tableau
  24. * Si un bouton ne fonctionne pas ou active le suivant (ou précédent), faire un Serial.print(valeurLue); ,
  25. * juste en dessous de valeurLue = analogRead(0); pour connaitre sa valeur, et modifier la valeur correspondante
  26. * dans le tableau valLimiteHauteModule[] de manière à ce que la limite correspondant à ce bouton dans le tableau
  27. * soit supérieure à la valeur du bouton (perso j'ai eu à le faire
  28. */
  29.  
  30. // VARIABLES
  31.  
  32.  
  33. int valLimiteHauteModule[5] = {600, 700, 760, 850, 900}; // on crée un tableau qui contient les valeurs limites
  34. // qui permettent de déterminer quel bouton est enfoncé (ou pas)
  35.  
  36. const int nombreBoutons = 5; // on donne le nombre de bouton du module (sert pour attribuer un numéro
  37. // à un bouton à partir de la valeur lue)
  38.  
  39. const int pinModule5BP = 0; // numero de la borche analogique sur laquelle est branchée
  40. // le module 5 boutons
  41.  
  42. int valeurLue; // Valeur qui sera lue sur le pin analogique sur lequel est branché
  43. // le module (0 < valeurLue < 1023)
  44. int valeurLueDebug;
  45.  
  46. int numBouton = -1; // numero du bouton correspondant à la valeur reçue
  47. // (-1 pas de bouton enfoncé)
  48. int derniereLue = -1; // dernière valeur reçue du module (-1 pas de bouton enfoncé)
  49. int memoireNumBouton = -1; // numero du dernier bouton à avoir été enfoncé
  50. // (-1 pas de bouton enfoncé avant)
  51.  
  52. unsigned long debutPression; // repère temporel : valeur du chrono au moment où on presse le bouton
  53. // sert à faire la différence qui détermine la durée de la pression
  54. unsigned long debutEntreDeux;
  55.  
  56. unsigned long dureePression; // durée de la pression (différence entre "maintenant" et le moment
  57. // où on a commencé à appuyer pour avoir la durée de la pression)
  58. // sera utilisée au moment du relachement
  59. // (numBouton passe de X(dernierLu!=-1) à -1)
  60. unsigned long dureeEntreDeux;
  61.  
  62. // FONCTIONS
  63.  
  64. // Fonction servant à transformer la valeur reçu (comprise entre 0 et 1023) en valeur de bouton (comprise entre -1 et 4)
  65. int recupNumBouton (unsigned int lecture) {
  66.  
  67. int boucleLecture; // Rang de comptage
  68. for (boucleLecture = 0; boucleLecture < nombreBoutons; boucleLecture ++) { // on part de 0 (boucleLecture = 0),
  69. // et on ajout 1 (boucleLecture ++) à chaque tour (for)
  70. // jusqu'à la valeur (boucleLecture)
  71. // juste avant le nombre de bouton :
  72. // (boucleLecture < nombreBoutons)
  73. // (boucleLecture < 5)
  74. // donc jusquà ce que boucleLecture = 4
  75. // 4 est la derniere valeur à laquelle on ajoute 1
  76. // donc le maximum possible pour boucleLecture est 5 ("4 ++")
  77. //
  78. if (lecture < valLimiteHauteModule[boucleLecture]) { // Si la valeur lue (lecture) est inférieure à la valeur du tableau
  79. // du rang de lecture auquel on se trouve.
  80. // Si lecture (valeur reçue) inférieure à 600 (valLimiteHauteModule[0])
  81. // Si lecture (valeur reçue) inférieure à 650 (valLimiteHauteModule[1])
  82. // Si lecture (valeur reçue) inférieure à 700 (valLimiteHauteModule[2])
  83. // Si lecture (valeur reçue) inférieure à 800 (valLimiteHauteModule[3])
  84. // Si lecture (valeur reçue) inférieure à 900 (valLimiteHauteModule[4])
  85.  
  86. return boucleLecture; // on retourne la valeur de boucleLecture
  87. }
  88. }
  89. if (boucleLecture >= nombreBoutons) { // si la valeur lue (lecture) n'est pas inférieur à une valeur du tableau
  90. boucleLecture = -1; // valLimiteHauteModule[] alors on impose la valeur -1 à boucleLecture
  91. }
  92. return boucleLecture; // on retourne la valeur de boucle lecture
  93.  
  94. // seul un cas peut se présenter soit inférieur à toutes les valeurs
  95. // du tableau soit supérieur à toutes ("pas inférieur" à toutes les
  96. // valeurs du tableau)
  97. }
  98.  
  99. /*
  100. Remarque sur la fonction : je pensais qu'on ne pouvait pas le faire tourner sur une valeur de tableau qui n'existe pas :
  101. on arrive à un moment où on lui demande de vérifier que lecture est inférieure à valLimiteHauteModule[boucleLecture]
  102. avec boucleLecture = 5, mais valLimiteHauteModule[5] n'existe pas. Je ne savais pas qu'on pouvait demander une lecture
  103. (ici pour uine comparaison) d'un rang de tableau qui n'existe pas
  104. */
  105.  
  106. // SET UP
  107.  
  108. void setup() {
  109. Serial.begin(9600); // on ouvre la communication avec l'ordinateur (port série) à 9600 baud
  110. }
  111.  
  112. void loop() {
  113. valeurLue = analogRead(pinModule5BP); // on lit la valeur sur le port analogique
  114. // c'est pa obligatoire vu qu'on la refait dessous, mais bon je laisse
  115. delay(20); // on laisse un peut de temps au cas pour être sur du résultat
  116. valeurLue = analogRead(pinModule5BP); // on lit la valeur sur le port analogique
  117. numBouton = recupNumBouton(valeurLue); // on transforme cette valeur de tension en numero de bouton
  118. // avec la fonction ci-dessus
  119.  
  120. if (numBouton != derniereLue && numBouton != -1) { // si on vient d'enfoncer le bouton
  121. // c'est à dire qu'il n'a pas -1 comme valeur (enfoncé)
  122. // et que sa valeur est différente de celle de la précédente lecture
  123. // (on vient de...)
  124.  
  125. dureeEntreDeux = (millis() - debutEntreDeux); // on mesure le temps qui s'est écoulé depuis le dernier clic (enfoncé)
  126. // la période entre le moment ou on relache et le moment ou on appuie
  127. debutPression = millis(); // on "démarre le chrono" qui sert à mesurer le temps de pression
  128. // en fait on repere le moment debutPression pour faire une
  129. // sourstraction plus tard, avec le moment où on relache
  130. derniereLue = numBouton; // on enregistre que c'est la dernière valeur de bouton lue "connue"
  131. memoireNumBouton = numBouton; // on enregistre que c'est la dernière valeur de bouton enfoncé "connue"
  132.  
  133. } else if (numBouton != derniereLue && numBouton == -1) { // si on vient de relacher le bouton
  134. // c'est à dire qu'il n'a pas -1 comme valeur (enfoncé)
  135. // et que sa valeur est différente de celle de la précédente lecture
  136. // (on vient de...)
  137. debutEntreDeux = millis(); // on "démarre le chrono" qui sert à mesurer le temps entre deux clics
  138. // en fait on repere le moment debutEntreDeux pour faire une
  139. // sourstraction plus tard, avec le moment où on rappuie
  140. dureePression = millis() - debutPression; // on lit la valeur du "chrono"
  141. // en fait on fait la fameuse soustraction pour avoir le temps écoulé
  142. // depuis qu'on a appuyé sur le bouton
  143. derniereLue = numBouton; // on enregistre que c'est la dernière valeur de bouton lue "connue"
  144. if (dureeEntreDeux > 350) { // si il s'est passé assez de temps entre les deux pressions
  145. // de boutons pour que ce ne soit pas un double clic
  146. // alors on mesure la durée du dernier clic
  147. if (dureePression < 250 ) { // si cette durée est comprise entre 0 et 0.5s
  148. Serial.print("clic court sur le bouton "); // => Action du clic long : ici on affiche simplement sur le moniteur série
  149. // "clic court sur le bouton "
  150. Serial.println(memoireNumBouton); // et on rajoute la valeur du bouton qu'on a en mémoire
  151. // avant de retourner à la ligne
  152. } else if (dureePression >= 250) { // si cette durée est comprise entre 0.5s et 1s
  153. Serial.print("clic long sur le bouton "); // => Action du clic long : ici on affiche simplement sur le moniteur série
  154. // "clic long sur le bouton "
  155. Serial.println(memoireNumBouton); // et on rajoute la valeur du bouton qu'on a en mémoire
  156. // avant de retourner à la ligne
  157. }
  158. } else {
  159. if (dureePression < 250 ) {
  160. if (memoireNumBouton == ancienneMemoireNumBouton){// on vérifie que le dernier bouton enfoncé soit le même que
  161. // l'avant dernier bouton enfoncé (double clic sur le même bouton)
  162. Serial.print("double clic sur le bouton "); // => Action du clic long : ici on affiche simplement sur le moniteur série
  163. // "double clic sur le bouton "
  164. Serial.println(memoireNumBouton); // et on rajoute la valeur du bouton qu'on a en mémoire
  165. // avant de retourner à la ligne
  166. }
  167. }
  168. }
  169. }
  170. }
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!