dfgh,
J'ai une dernière question :
C'est quoi le moniteur ?
Merci encore.
Philippe
c'est ton écran PC, cette possibilité est utilisée pour faire du debugage
les instructions Serial.print ( ma variable ) ; //ecrivent la valeur de la variable sur ton écran
idempour du texte : Serial.print ( "ma variable est égale a "); // ecrit ma variable est égale a sur ton écran PC
dans un cas comme dans l'autre, si tu rajoutes "ln" au print ( Serial.println(ma variable); il y aura un retour à la ligne a la fin de l'écriture sur le moniteur.
il y a aussi la possibilité de faire des tabulation avec \t ( je crois que c'est t )
ces instructions utilisent la liaison usb de ta carte arduino avec le PC.
il faut initialiser cette liaison serie dans le setup : Serial.begin(vitesse en bauds); exemple : Serial.begin(115200);
le moniteur paux aussi etre utilisé comme traceur, il faut aller dans outil et cliquer sur "moniteur" ou sur "traceur"
le moniteur peut aussi etre ouvert en cliquant sur la petite loupe en haut à droite de la fenetre principale de l'IDE
le traceur ne peut pas etre ouvert de cette façon
pour que le traceur fasse des courbes, il faut utiliser Serial.println(ma variable); cest le "ln" qu'il ne faut pas oublier
et enfin, après avoir ouvert le moniteur ou le traceur, il faut regler la vitesse de com avec le choix multiple en bas à droite du moniteur. bien sur la meme que celle que tu as initialisée dans le setup
dans ton cas, pour pouvoir utiliser les pins 0 et 1 dans ton prg et aussi pour l liaison serie, la seule solution est de ne pas traiter les pins0 et dans tes declarations, setup,loop, et fonctions. ainsi tu peux voir tes Serial.print et debuger ton prg
sans utiliser les chiffres correspondant aux pins 0 et 1.
puis une fois ton prg au point, tu revalides les pins 0 et 1 comme touches. ( et adieu la liaison serie.
tu as du utiliser le lcd pour ton debugage, le moniteur pouvait le faire
Merci beaucoup dfgh pour toutes ces nombreuses informations.
Merci d'avoir consacré ton temps pour m'aider et me donner des explications qui me sont très utiles !
Très sincèrement.
Philippe
Bonsoir,
Afin d'améliorer ma calculatrice en y ajoutant des fonctions, j'ai testé le code de dfgh, en soudant une carte universelle avec une nano et 17 boutons poussoir .
dans un premier temps j'ai souhaité tester mes connexions avec ce code :
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 16, 2);
byte bouton[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17 };//nano
char caractere[] = = { '0','1','2','3','4','5','6','7','8','9','+','-','*','/','R','C','=','.'};
char key;
void setup() {
//Serial.begin(9600);
lcd.init();
lcd.backlight();
for (byte f = 0; f <= 17; f++)
{
pinMode(bouton[f], INPUT_PULLUP);
}
}
//pinMode(bouton[2], INPUT_PULLUP);
void loop() {
//for (byte f = 0; f <= 2; f++)
for (byte f = 14; f <= 17; f++)
{
if (digitalRead(bouton[f]) == LOW)
{
key = caractere[f];
lcd.print(key);
delay(200);
while (digitalRead(bouton[f]) == LOW){;} //si le BP à été appuyé
}
}
}
Mon entrée D13 ne fonctionne pas et je crois que c'est du à la LED témoin sur 13 ?
Je ne trouve pas comment résoudre ce PB.
Dommage, c'était bien sympa de gérer 17 boutons en même temps...
Quelqu'un a t-il déjà rencontré ce PB ?
Merci.
Bonjour,
Essaye de mettre une résistance de pullup externe assez faible (4.7k voire moins) sur D13.
Merci Kamill,
Je vais essayer demain matin.
Bonjour,
J'ai essayé avec une résistance de pullup externe de 4.7k et une de 220k.
Cela n'a rien donné, du coup j'ai laissé tombé D13 et j'utilise A6 et A7.
Par contre je pense qu'A6 et A7 ont des pullups internes que j'utilise mais je n'ai accès à l'état de ces pins qu'avec digitalRead.
Voici mon nouveau code :
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 16, 2);
byte bouton[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21 };//nano
char caractere[] = { '0','1','2','3','4','5','6','7','8','9','+','-','*','D13','R','C','=','.','A4','A5','/','E'};
char key;
void setup() {
//Serial.begin(9600);
lcd.init();
lcd.backlight();
for (byte f = 0; f <= 21; f++)
{
if ((f !=13) && (f !=18) && (f !=19))
{
pinMode(bouton[f], INPUT_PULLUP);
}
}
}
void loop() {
for (byte f = 0; f <= 21; f++)
{
if ((f !=13) && (f !=18) && (f !=19) && (digitalRead(bouton[f]) == LOW))
{
key = caractere[f];
lcd.print(key);
delay(200);
while (digitalRead(bouton[f]) == LOW){;} //si le BP à été appuyé
}
if (((f==20) || (f==21)) && (analogRead(bouton[f]) == LOW))
{
key = caractere[f];
lcd.print(key);
delay(200);
while (analogRead(bouton[f]) == LOW){;} //si le BP à été appuyé
}
}
}
Je vais structurer ma calculatrice sur cette base qui fonctionne parfaitement.
Par contre il me reste des questions sans réponses :
1/ Pourquoi le pullup interne ou externe ne fonctionne t'il pas ? à cause de la LED 13 ?
2/ Il y a des résistances pullups internes pour A6 et A7 mais pourquoi digitalRead ne fonctionne pas ?
Merci par avance.
C'est pas un peu contradictoire?
Ça ne fonctionne pas parce que
Extrait de la datasheet de ATmega328 : Note that ADC pins ADC7 and ADC6 do not have digital input buffers
Les entrées ADC6 et ADC7 ne possèdent pas de buffer d'entrée digitale.
Il y a une raison pour laquelle tu ne veux pas utiliser une librairie de gestion de clavier matriciel?
Ce qui te laisserait quelques I/Os disponibles.
Merci fdufnews,
Effectivement c'est contradictoire mais c'est parce que je ne comprends pas bien.
Donc si je dis :
A6 et A7 ont des résistances de pullup internes mais ne possédent pas de buffer d'entrée digitale, c'est bon ?
Merci.
A6 et A7 sont des uniquement des entrées analogiques. Elles ne peuvent pas fonctionner en entrées-sorties digitales.
Ou as tu vu qu'elles avait des résistances de pullup interne?
Bonsoir Kamill,
Ce code fonctionne pour A6 et A7 du coup je me suis posé la question.
L'IDE compile pinMode(A6 ou A7, INPUT_PULLUP).
J'ai branché les boutons 20 et 21 (A6 et A7) comme si il s'agissait d'entrées numériques (D2 par exemple) et ça fonctionne avec analogRead.
Merci pour ta réponse du coup je sais qu'il n'y en a pas pour A6 et A7.
Il y a quelques mois encore je n'y connaissais rien en électronique, Arduino, C...
Ceci explique peut-être cela.
Je viens de trouver ça pour mon problème avec la D13 :
D13 INPUT_PULLUP
Merci et désolé de vous faire perdre du temps.
Très sincèrement.
J'ai passé des heures entières à souder et à coder du coup je dois être bien fatigué car je ne suis plus sûr de rien. Je me permets une dernière question bête :
J'ai branché deux boutons poussoirs l'un est relié à GND et A6 et l'autre à GND et A7 (pas de 5V ni de résistance). Lorsque j'appuie sur les boutons "/" et "E" sont bien affichés sur l'écran LCD.
Ce code fonctionne.
Ce branchement ne doit pas être bon ?
Merci.
Ca fonctionne... jusqu'au moment ou ça ne fonctionnera plus parce que lorsque le bouton sera enfoncé tu ne liras pas 0, mais 1 ou 2 ou lorsque le bouton sera relâché au lieu de lire une valeur entre 1 et 1023 tu liras 0.
Non il n'est absolument pas fiable.
avoir le pull up sur une entrée analogique va en plus fausser la lecture de analogRead()
si vous ne pouvez pas faire autrement, essayez un truc du genre
if (((f==20) || (f==21)) && (analogRead(bouton[f]) < 80)) {
key = caractere[f];
lcd.print(key);
delay(200); // c'est bcp pour un anti-rebond
while (analogRead(bouton[f]) < 80); // on attend que le bouton soit relâché
}
faudra peut-être affiner le 80 pour bien détecter le relâchement
Je ne comprend pas ce que tu veux dire. Pour que le programme que tu proposes fonctionne à coup sur, il faut justement qu'il y ait des pullups.
Kamill,
Sur A6 et A7 pas de pullup interne cars ce sont des entrées analogiques uniquement.
Mes deux boutons sont l'un et l'autre branchés uniquement sur A6 et GND et A7 et GND, du coup il n'y a pas de pull up externe non plus.
Donc si je comprends bien J-M-L, je laisse le branchement tel quel et j'essaye d'affiner le résultat de la lecture analogique ?
Merci
Comme je l'ai déjà dit: IL FAUT DES PULLUPS!!
Oui mais le pull-up va modifier la valeur retournée par analogRead() donc adapter 80 si nécessaire
Le 80 n'est pas du tout critique.
Quand le bouton est relaché, la pin est relée au 5V par ce pullup donc on lit environ 1023, quand le bouton est enfoncé la pin est au GND et ont lit environ 0.
C'est le fonctionnement "classique" d'un pullup
