Calculatrice - concaténer les caractères

Bonjour,
Je suis sur le projet d’une calculatrice.
Après avoir soudé 18 boutons reliés à une nano sur une carte universelle et relié le tout à un écran LCD, je me lance dans le code.
Pour l’instant, je suis parti sur la base du code posté par azerthuiop dans son sujet [calculatrice moniteur série] (calculatrice moniteur série) :

Son code est simple et compréhensible pour moi qui ne connais pas le C. La seule ligne de code que je ne comprends pas est la suivante :

l’expression nbActuel = ( ( nbActuel * 10 ) + ( key - ‘0’ ) ) ; doit concatèner les chiffres pour mémoriser nbActuel mais je ne comprends pas du tout la formule. Pourquoi multiplié nbActuel par 10 et lui ajouté key -‘0’ ?
Le code de azerthuiop ne prend pas en compte les calculs décimaux, dans un deuxième temps je vais essayer de l’adapter en ce sens.

Merci pour votre aide

Bonjour,

Si tu appuies sur la touche ‘3’ par exemple, alors ‘3’ - ‘0’ = 3 parce que le code ASCII du caractère ‘3’ est 51 et le code ASCII de ‘0’ est 48.

Si nbActuel est 12, alors après avoir appuyé sur ‘3’, ça donne : 12*10 + 3 = 123

Bonjour,

key doit être codé en ASCII. En ASCII le code des chiffres se suit donc key-‘0’ donne le chiffre correspondant.
Le dernier chiffre entré est l’unité, donc pour avoir le nombre total correspondant il faut multiplier le nombre précédent pat 10 et ajouter l’unité.

Le clavier virtuel doit renvoyer le code ascii du chiffre dessiné sur le bouton donc key - ‘0’ Représente ce chiffre (dans la table ASCII, les chiffres sont l’un derrière l’autre, donc on enlève le code ascii du symbole zéro et ça donne le chiffre en numérique)

Ensuite pour concaténer en base 10 il faut multiplier par 10 pour décaler et ensuite on ajoute les unités (qui est ce chiffre que l’on vient de fabriquer)

ÉDIT: avec 3 réponses qui disent la même chose, il devrait s’en sortir :wink:

Merci à tous. J’ai compris.

Je tenais à vous remercier encore.
Grace à vous tous, j’ai une calculatrice qui tient la route !
Pour les chiffres décimaux j’ai créé une fonction NbDecimal () et une variable booléenne décimal :
Quand j’appuie sur un bouton correspondant à un opérateur et que decimal est true (appui sur le bouton “.”), j’appel la fonction NbDecimal () et je réinitialise les valeurs pour prendre en compte le deuxième chiffre de l’opération

#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 16, 2);// défini l'adresse et le type d'écran lcd : 16 x 2

// déclaration des variables
const int bouton0 = 2;
const int bouton1 = 3;
const int bouton2 = 4;
const int bouton3 = 5;
const int bouton4 = 6;
const int bouton5 = 7;
const int bouton6 = 8;
const int bouton7 = 9;
const int bouton8 = 10;
const int bouton9 = 11;
const int bouton10 = 12;
const int bouton11 = A7;
const int bouton12 = A6;

int Statutbouton0 = 0; 
int Statutbouton1 = 0; 
int Statutbouton2 = 0;
int Statutbouton3 = 0;
int Statutbouton4 = 0;
int Statutbouton5 = 0;
int Statutbouton6 = 0;
int Statutbouton7 = 0;
int Statutbouton8 = 0;
int Statutbouton9 = 0;
int Statutbouton10 = 0;

int NbChiApVirgule = 0;

boolean decimal = false;
boolean result = false;

//calculatrice
// variable globale retenant l'opérateur sélectionné
char operateur   ;

// variable globale retenant le précédent nombre
float  nbPrecedent  ;

// variable globale retenant le nombre actuel
float  nbActuel   ;



void setup() {
  lcd.init(); 
  lcd.backlight();
  
  pinMode(bouton0, INPUT);// D2
  pinMode(bouton1, INPUT);// D3
  pinMode(bouton2, INPUT);// D4
  pinMode(bouton3, INPUT);// D5
  pinMode(bouton4, INPUT);// D6
  pinMode(bouton5, INPUT);// D7
  pinMode(bouton6, INPUT);// D8
  pinMode(bouton7, INPUT);// D9
  pinMode(bouton8, INPUT);// D10
  pinMode(bouton9, INPUT);// D11
  pinMode(bouton10, INPUT);//D12
  pinMode(A0, INPUT);
  pinMode(A1, INPUT);
  pinMode(A2, INPUT);
  pinMode(A3, INPUT);
 
}

void loop() {

  
  
  Statutbouton0 = digitalRead(bouton0);
  Statutbouton1 = digitalRead(bouton1);
  Statutbouton2 = digitalRead(bouton2);
  Statutbouton3 = digitalRead(bouton3);
  Statutbouton4 = digitalRead(bouton4);
  Statutbouton5 = digitalRead(bouton5);
  Statutbouton6 = digitalRead(bouton6);
  Statutbouton7 = digitalRead(bouton7);
  Statutbouton8 = digitalRead(bouton8);
  Statutbouton9 = digitalRead(bouton9);
  Statutbouton10 = digitalRead(bouton10);
  //val = analogRead(bouton11);
  //Serial.println(val);
  //delay (500);
  char key;
  

  if (Statutbouton0 == HIGH) {
   decimal = true;
   key = '.';
   lcd.print(key);
   
   delay(200);  

  } 
   if (Statutbouton1 == HIGH) {

  key = '0';
  if (decimal==true) NbChiApVirgule = NbChiApVirgule + 1;
  nbActuel = ( ( nbActuel * 10 ) + ( key - '0' ) ) ;
  lcd.print(key);
       
  delay(200); 

   }
   if (Statutbouton2 == HIGH) {
  
   key = '1';
   if (decimal==true) NbChiApVirgule = NbChiApVirgule + 1;
   nbActuel = ( ( nbActuel * 10 ) + ( key - '0' ) ) ;
   lcd.print(key);
   delay(200);  
   } 
   if (Statutbouton3 == HIGH) {
    
    key = '2';
   if (decimal==true) NbChiApVirgule = NbChiApVirgule + 1;
   nbActuel = ( ( nbActuel * 10 ) + ( key - '0' ) ) ;
   lcd.print(key);
    
  delay(200);  
   } 
    if (Statutbouton4 == HIGH) {
  
   key = '3';
   if (decimal==true) NbChiApVirgule = NbChiApVirgule + 1;
   nbActuel = ( ( nbActuel * 10 ) + ( key - '0' ) ) ;
   lcd.print(key);
    
  delay(200);  
   }
   if (Statutbouton5 == HIGH) {

   key = '4';
   if (decimal==true) NbChiApVirgule = NbChiApVirgule + 1;
   nbActuel = ( ( nbActuel * 10 ) + ( key - '0' ) ) ;
   lcd.print(key);
    
  delay(200);  
   } 
   if (Statutbouton6 == HIGH) {
    
    key = '5';
    if (decimal==true) NbChiApVirgule = NbChiApVirgule + 1;
    nbActuel = ( ( nbActuel * 10 ) + ( key - '0' ) ) ;
   lcd.print(key);
    
  delay(200);  
   } 
   if (Statutbouton7 == HIGH) {
    key = '6';
    if (decimal==true) NbChiApVirgule = NbChiApVirgule + 1;
   nbActuel = ( ( nbActuel * 10 ) + ( key - '0' ) ) ;
   lcd.print(key);
    
  delay(200);  
   }
   if (Statutbouton8 == HIGH) {
    
   key = '7';
    if (decimal==true) NbChiApVirgule = NbChiApVirgule + 1;
   nbActuel = ( ( nbActuel * 10 ) + ( key - '0' ) ) ;
   lcd.print(key);
    
  delay(200);  
   }
   if (Statutbouton9 == HIGH) {

   key = '8';
    if (decimal==true) NbChiApVirgule = NbChiApVirgule + 1;
   nbActuel = ( ( nbActuel * 10 ) + ( key - '0' ) ) ;
   lcd.print(key);
    
  delay(200);  
   } 
  if (Statutbouton10 == HIGH) {
   key = '9';
   if (decimal==true) NbChiApVirgule = NbChiApVirgule + 1;
   nbActuel = ( ( nbActuel * 10 ) + ( key - '0' ) ) ;
   lcd.print(key);
    
  delay(200);  
   } 
  if (digitalRead(A0) == HIGH) {
    key = '=';
    if (decimal==true) NbDecimal(), decimal=false ;
  Calcul(); 
    
  delay(200);  
   } 
   if (digitalRead(A1) == HIGH) {
   key = '+';
   lcd.print(key);
   if (decimal==true) NbDecimal(), decimal=false ;
   NbChiApVirgule = 0 ;
   nbPrecedent = nbActuel ;
   operateur   = key      ;
   nbActuel    = 0        ;
   
    
  delay(200);  
   } 
   if (digitalRead(A2) == HIGH) {
   key = '-';
   lcd.print(key);
   if (decimal==true) NbDecimal(), decimal=false ;
   NbChiApVirgule = 0 ;
   nbPrecedent = nbActuel ;
   operateur   = key      ;
   nbActuel    = 0        ;
   
    
  delay(200);  
   } 
   if (digitalRead(A3) == HIGH) {
   key = '*';
   lcd.print(key);
   if (decimal==true) NbDecimal(), decimal=false ;
   NbChiApVirgule = 0 ;
   nbPrecedent = nbActuel ;
   operateur   = key      ;
   nbActuel    = 0        ;
   
    
  delay(200);  
   } 
 
   
   if (analogRead(bouton11)> 511) {
   key = '/';
   lcd.print(key);
   if (decimal==true) NbDecimal(), decimal=false ;
   NbChiApVirgule = 0 ;
   nbPrecedent = nbActuel ;
   operateur   = key      ;
   nbActuel    = 0        ;
   
    
  delay(200);  
  } 

  if (analogRead(bouton12)<320) {
    
   key = 'C';
   Efface();
   delay(1500);
  } 
  if (analogRead(bouton12)> 320 && analogRead(bouton12)<511){  //(analogRead(bouton12)<500)){ //if (analogRead(bouton12)> 511 && (analogRead(bouton12)<500)){
   
   lcd.print("ok");
   delay(1500);
  } 
}

void Calcul()
{
      

      result = true;
      lcd.setCursor(0,1);
         
      if ( operateur == '+' )nbActuel = nbPrecedent + nbActuel,lcd.print ('='),lcd.print(nbActuel);
      
      if ( operateur == '-' ) nbActuel = nbPrecedent - nbActuel,lcd.print ('='),lcd.print(nbActuel);
      
      if ( operateur == '*' ) nbActuel = nbPrecedent * nbActuel,lcd.print ('='),lcd.print(nbActuel);
     
      if ( operateur == '/' ) nbActuel = nbPrecedent / nbActuel,lcd.print ('='),lcd.print(nbActuel);
      
}

 void Efface()
 {
      NbChiApVirgule = 0;
      decimal=false;
      nbActuel = 0; 
      nbPrecedent = 0;
      lcd.clear();
 }
 
void NbDecimal ()
{
  switch (NbChiApVirgule) {
   
    case 1 :
    nbActuel=nbActuel/10;
    break;
    case 2 :
    nbActuel=nbActuel/100;
    break;
    case 3 :
    nbActuel=nbActuel/1000;
    break;
    case 4 :
    nbActuel=nbActuel/10000;
    break;
       
}
}



 

je vais simplifier encore mon code car je sais, c’est l’usine à gaz :wink:
Si j’en suis là c’est grace à la communauté arduino.

Merci encore à vous.

Mettez les pins dans un tableau dans le même ordre que les nombres, comme ça pas besoin de répéter 10 fois le même code

J’ai pas regardé comment vous gérez les décimaux assurez vous que des 0 après le point soient bien gérés (12.00005 par exemple ne doit pas faire 12.5)

Bonjour J-M-L,

Avec mon code 12.00005+0 = 12.00005 mais j’ai du rajouter une ligne à ma fonction NbDecimal() pour traiter les chiffres à 5 décimales et modifier le code dans la fonction calcul() (lcd.print(nbActuel,5);). 5 chiffres après la virgule, je pense que c’est suffisant pour moi.

Mes compétences en C sont insuffisantes et je ne comprends pas.

Merci.

Que se passe t il si vous tenez appuyé un bouton plus de 200ms ? Ou si vous en appuyez 3 à la fois ?

J-M-L,
Si j’appuie au delà des 200ms, key s’affiche toutes les 200ms sur l’écran lcd. Si key est égal à 3 :
333333333333…
Si j’appuie sur 3 boutons à la fois, 123 par exemple, il s’affiche sur l’écran lcd : 123123123123…

Merci.

Me revoilà,
Pour info, je vous donne les caractéristiques techniques de mon montage :

  • 18 boutons poussoirs sont soudés sur une carte universelle et reliés à une carte nano, ils sont reliés aux entrées numériques et analogiques du microcontrôleur :

1/ les 11 entrées numériques (D2-D12) sont tirées une par une à la masse par une résistance de 10K ;
2/ Les entrées analogiques A0, A1, A2, A3 et A7 sont également tirées une par une à la masse par une résistance de 10KΩ ;
3/ Les entrées analogiques A4 et A5 sont utilisées pour l’I2C de l’écran LCD ;
4/ l’entrée analogique A6 est tirée à +5V par une résistance de 470Ω, un deuxième bouton poussoir est soudé en parallèle et est connecté entre l’A6 et la masse par une résistance de 1KΩ.

Pour les deux boutons poussoirs connectés à A6, je me suis inspiré de ce tuto :
http://modelleisenbahn.triskell.org/spip.php?article59
Mais je ne suis pas allé jusqu’à contrôler les états (ENFONCE - NON_PRESSE), pour deux boutons seulement, je me suis contenté de relevé que analogRead(A6)==0) pour le premier et analogRead(A6)==697) pour le deuxième.

Voilà je vous donne mon code auquel j’ai ajouté une fonction racine carrée :

#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 16, 2);// défini l'adresse et le type d'écran lcd : 16 x 2

// déclaration des variables
const int bouton0 = 2;
const int bouton1 = 3;
const int bouton2 = 4;
const int bouton3 = 5;
const int bouton4 = 6;
const int bouton5 = 7;
const int bouton6 = 8;
const int bouton7 = 9;
const int bouton8 = 10;
const int bouton9 = 11;
const int bouton10 = 12;
const int bouton11 = A7;
const int bouton12 = A6;

int Statutbouton0 = 0; 
int Statutbouton1 = 0; 
int Statutbouton2 = 0;
int Statutbouton3 = 0;
int Statutbouton4 = 0;
int Statutbouton5 = 0;
int Statutbouton6 = 0;
int Statutbouton7 = 0;
int Statutbouton8 = 0;
int Statutbouton9 = 0;
int Statutbouton10 = 0;

int NbChiApVirgule = 0;

boolean decimal = false;
boolean result = false;

//calculatrice
// variable globale retenant l'opérateur sélectionné
char operateur   ;

// variable globale retenant le précédent nombre
float  nbPrecedent  ;

// variable globale retenant le nombre actuel
float  nbActuel   ;



void setup() {
  lcd.init(); 
  lcd.backlight();
  
  pinMode(bouton0, INPUT);// D2
  pinMode(bouton1, INPUT);// D3
  pinMode(bouton2, INPUT);// D4
  pinMode(bouton3, INPUT);// D5
  pinMode(bouton4, INPUT);// D6
  pinMode(bouton5, INPUT);// D7
  pinMode(bouton6, INPUT);// D8
  pinMode(bouton7, INPUT);// D9
  pinMode(bouton8, INPUT);// D10
  pinMode(bouton9, INPUT);// D11
  pinMode(bouton10, INPUT);//D12
  pinMode(A0, INPUT);
  pinMode(A1, INPUT);
  pinMode(A2, INPUT);
  pinMode(A3, INPUT);
 
}

void loop() {

  
  
  Statutbouton0 = digitalRead(bouton0);
  Statutbouton1 = digitalRead(bouton1);
  Statutbouton2 = digitalRead(bouton2);
  Statutbouton3 = digitalRead(bouton3);
  Statutbouton4 = digitalRead(bouton4);
  Statutbouton5 = digitalRead(bouton5);
  Statutbouton6 = digitalRead(bouton6);
  Statutbouton7 = digitalRead(bouton7);
  Statutbouton8 = digitalRead(bouton8);
  Statutbouton9 = digitalRead(bouton9);
  Statutbouton10 = digitalRead(bouton10);
  
  char key;
  

  if (Statutbouton0 == HIGH) {
   decimal = true;
   key = '.';
   lcd.print(key);
   
   delay(200);  

  } 
   if (Statutbouton1 == HIGH) {
  if (result==true) Efface(),result=false;
  key = '0';
  if (decimal==true) NbChiApVirgule = NbChiApVirgule + 1;
  nbActuel = ( ( nbActuel * 10 ) + ( key - '0' ) ) ;
  lcd.print(key);
       
  delay(200); 

   }
   if (Statutbouton2 == HIGH) {
    if (result==true) Efface(),result=false;
   key = '1';
   
   if (decimal==true) NbChiApVirgule = NbChiApVirgule + 1;
   nbActuel = ( ( nbActuel * 10 ) + ( key - '0' ) ) ;
   lcd.print(key);
   delay(200);  
   } 
   if (Statutbouton3 == HIGH) {
    if (result==true) Efface(),result=false;
    key = '2';
   if (decimal==true) NbChiApVirgule = NbChiApVirgule + 1;
   nbActuel = ( ( nbActuel * 10 ) + ( key - '0' ) ) ;
   lcd.print(key);
    
  delay(200);  
   } 
    if (Statutbouton4 == HIGH) {
  if (result==true) Efface(),result=false;
   key = '3';
   if (decimal==true) NbChiApVirgule = NbChiApVirgule + 1;
   nbActuel = ( ( nbActuel * 10 ) + ( key - '0' ) ) ;
   lcd.print(key);
    
  delay(200);  
   }
   if (Statutbouton5 == HIGH) {
if (result==true) Efface(),result=false;
   key = '4';
   if (decimal==true) NbChiApVirgule = NbChiApVirgule + 1;
   nbActuel = ( ( nbActuel * 10 ) + ( key - '0' ) ) ;
   lcd.print(key);
    
  delay(200);  
   } 
   if (Statutbouton6 == HIGH) {
    if (result==true) Efface(),result=false;
    key = '5';
    if (decimal==true) NbChiApVirgule = NbChiApVirgule + 1;
    nbActuel = ( ( nbActuel * 10 ) + ( key - '0' ) ) ;
   lcd.print(key);
    
  delay(200);  
   } 
   if (Statutbouton7 == HIGH) {
    if (result==true) Efface(),result=false;
    key = '6';
    if (decimal==true) NbChiApVirgule = NbChiApVirgule + 1;
   nbActuel = ( ( nbActuel * 10 ) + ( key - '0' ) ) ;
   lcd.print(key);
    
  delay(200);  
   }
   if (Statutbouton8 == HIGH) {
   if (result==true) Efface(),result=false; 
   key = '7';
    if (decimal==true) NbChiApVirgule = NbChiApVirgule + 1;
   nbActuel = ( ( nbActuel * 10 ) + ( key - '0' ) ) ;
   lcd.print(key);
    
  delay(200);  
   }
   if (Statutbouton9 == HIGH) {
    if (result==true) Efface(),result=false;
   key = '8';
    if (decimal==true) NbChiApVirgule = NbChiApVirgule + 1;
   nbActuel = ( ( nbActuel * 10 ) + ( key - '0' ) ) ;
   lcd.print(key);
    
  delay(200);  
   } 
  if (Statutbouton10 == HIGH) {
    if (result==true) Efface(),result=false;
   key = '9';
   if (decimal==true) NbChiApVirgule = NbChiApVirgule + 1;
   nbActuel = ( ( nbActuel * 10 ) + ( key - '0' ) ) ;
   lcd.print(key);
    
  delay(200);  
   } 
  if (digitalRead(A0) == HIGH) {
    key = '=';
    if (decimal==true) NbDecimal(), decimal=false ;
  Calcul(); 
    
  delay(200);  
   } 
   if (digitalRead(A1) == HIGH) {
   
   key = '+';
   lcd.print(key);
   if (decimal==true) NbDecimal(), decimal=false ;
   NbChiApVirgule = 0 ;
   nbPrecedent = nbActuel ;
   operateur   = key      ;
   nbActuel    = 0        ;
   
    
  delay(200);  
   } 
   if (digitalRead(A2) == HIGH) {
   
   key = '-';
   lcd.print(key);
   if (decimal==true) NbDecimal(), decimal=false ;
   NbChiApVirgule = 0 ;
   nbPrecedent = nbActuel ;
   operateur   = key      ;
   nbActuel    = 0        ;
   
    
  delay(200);  
   } 
   if (digitalRead(A3) == HIGH) {
   
   key = '*';
   lcd.print(key);
   if (decimal==true) NbDecimal(), decimal=false ;
   NbChiApVirgule = 0 ;
   nbPrecedent = nbActuel ;
   operateur   = key      ;
   nbActuel    = 0        ;
   
    
  delay(200);  
   } 
 
   
   if (analogRead(bouton11)> 511) {
   
   key = '/';
   lcd.print(key);
   if (decimal==true) NbDecimal(), decimal=false ;
   NbChiApVirgule = 0 ;
   nbPrecedent = nbActuel ;
   operateur   = key      ;
   nbActuel    = 0        ;
   
    
  delay(200);  
  } 

  if (analogRead(bouton12)==0) {
   key = 'C';
   Efface();
   delay(200);
  } 
  if (analogRead(bouton12)==697) {
  operateur = 'R';
  //lcd.print('R');
  Calcul(); 
  delay(200);
  } 
}

void Calcul()
{
      

      result = true;
      lcd.setCursor(0,1);
         
      if ( operateur == '+' )nbActuel = nbPrecedent + nbActuel,lcd.print ('='),lcd.print(nbActuel,5);
      
      if ( operateur == '-' ) nbActuel = nbPrecedent - nbActuel,lcd.print ('='),lcd.print(nbActuel,5);
      
      if ( operateur == '*' ) nbActuel = nbPrecedent * nbActuel,lcd.print ('='),lcd.print(nbActuel,5);
     
      if ( operateur == '/' ) nbActuel = nbPrecedent / nbActuel,lcd.print ('='),lcd.print(nbActuel,5);
      
      if ( operateur == 'R' ) nbActuel = sqrt(nbActuel),lcd.print ('='),lcd.print(nbActuel,5);
}

 void Efface()
 {
      NbChiApVirgule = 0;
      decimal=false;
      nbActuel = 0; 
      nbPrecedent = 0;
      lcd.clear();
 }
 
void NbDecimal ()
{
  switch (NbChiApVirgule) {
   
    case 1 :
    nbActuel=nbActuel/10;
    break;
    case 2 :
    nbActuel=nbActuel/100;
    break;
    case 3 :
    nbActuel=nbActuel/1000;
    break;
    case 4 :
    nbActuel=nbActuel/10000;
    break;
    case 5 :
    nbActuel=nbActuel/100000;
    break;
       
}
}

J’ai travaillé de manière empirique, c’est quand je n’ai plus eu assez de boutons que j’ai cherché à en brancher plusieurs sur une entrée analogique. Pareil pour le code…
Maintenant je vais brancher une pile 9V reliée à VIN et à GND avec un interrupteur (j’espère que ça va le faire).
Telle quelle la calculatrice est certes très basique mais elle fonctionne très bien.

Voilà je suis preneur de toutes critiques, conseils car je suis débutant et j’ai beaucoup à apprendre de vous.

Merci déjà pour tout ce que vous m’avez apporté.
Philippe

Est ce un comportement désirable ?

Maintenant je vais brancher une pile 9V reliée à VIN et à GND avec un interrupteur

Pour un fonctionnement ponctuel ça devrait aller un moment, mais lisez quand même cet article

Non J-M-L ce n’est pas un comportement désirable :sleepy:
Bonne soirée.

C’est une opportunité d’améliorer encore plus la calculatrice :slight_smile:

Votre gestion des boutons est un peu trop directe. Vous évacuez les rebonds par le délai de 200ms mais vous n’attendez pas le relâchement.

Si vous mettiez des else entre les if vous pourriez n’avoir qu’un seul bouton pris en compte

sinon pour simplifier votre gestion des boutons, éventuellement utilisez la librairie de @bricoleau ou alors la librairie OneButton de Matthias Hertel.

Merci J-M-L
Je vais travailler ce point.
Bonne journée.

hello
j’ai joué avec ton code
les BP sont raccordés entre GND et les entrées D0 à A3
nota A0 est D14, A1 est D15, A2 est D16, A3 est D17
les entrées sont déclarées en INPUT_PULLUP
les PINS 0 et 1 sont utilisées car tu n’utilises pas le moniteur
l’adresse de ton LCD est 0x 27, celle de mon lcd est 0x26
A6 et A7 ne sont pas utilisées.

#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x26, 16, 2);// défini l'adresse et le type d'écran lcd : 16 x 2
//LiquidCrystal_I2C lcd(0x27, 16, 2);// défini l'adresse et le type d'écran lcd : 16 x 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','.','='};
int NbChiApVirgule = 0;
long decimal       = 0;
float  nbPrecedent = 0;
float  nbActuel    = 0;
boolean result     = false;
char   operateur;
char   key;

void setup()
{
 lcd.init();
  //lcd.begin();
  lcd.backlight();
  for (byte f = 0; f <= 17; f++)
  {
    pinMode(bouton[f], INPUT_PULLUP);
  } 
}

void loop()
{
  for (byte f = 0; 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é
    }
  }

  if (key == 'C') {Efface();}
  if (key == '.') {decimal = 10;}
  if (key == '=') {calculs();}

  for (byte f = 0; f <= 9; f++)
  {
    if (key == caractere[f])
    {
      if ( key >= '0' && key <= '9' )
      {
        if (decimal != 0)
        { 
          nbActuel = (  nbActuel  + (float( key - '0' ) / (decimal))) ;
          decimal = decimal * 10;
          //lcd.setCursor(0, 0); lcd.print(nbActuel, 5);
        }
        else
        { 
          nbActuel = ( ( nbActuel * 10 ) + ( key - '0' ) ) ;
          //lcd.setCursor(0, 0); lcd.print(nbActuel, 5);
        }
        key = '_';
      }
    }
    if ( key == '+' || key == '-' || key == '*' || key == '/' || key == 'R' )
    {
      //lcd.print (key);
      nbPrecedent = nbActuel ;
      operateur   = key      ;
      key = '_';
      nbActuel    = 0;
      decimal     = 0;
    }
  }
}


void Efface()
{
  decimal = 0;
  nbActuel = 0;
  nbPrecedent = 0;
  lcd.clear();
  key = '_';
}
void calculs()
{
  if ( operateur == '+' ) nbActuel += nbPrecedent   ;
  if ( operateur == '-' ) nbActuel -= nbPrecedent   ;
  if ( operateur == '*' ) nbActuel *= nbPrecedent   ;
  if ( operateur == '/' ) nbActuel /= nbPrecedent   ;
  if ( operateur == 'R' ) nbActuel  = sqrt(nbActuel);
  decimal = 0; lcd.setCursor(0, 1); lcd.print ( nbActuel , 12 ) ;
  key = '_';
  decimal = 0;
  nbActuel = 0;
  nbPrecedent = 0;
}

Merci dfgh,
Maintenant je comprends pourquoi J-M-L voulait que je mette les pins dans un tableau !
L’utilisation d’un tableau et d’une boucle simplifie énormément le code.
Encore fallait-il savoir créer un tableau et utiliser une boucle for.
Bravo et merci pour ce partage qui va me faire évoluer plus vite !
Philippe

Oui c’était l’idée d’utiliser les tableaux pour cela

On peut écrire cela juste

while (digitalRead(bouton[f]) == LOW);  // attente relâchement 

Noter que le délai de 200ms ne se justifie plus, 15ms devraient aller Pour la gestion des rebonds

Les pins TX1 et RX0 sont donc également des broches digitales d’entrée / sorti et j’avais pas vu D13.
Oupssssssssssss :sunglasses:

c’était bien le but :grin: (je pense qu’ étudier le code des autres n’est pas une perte de temps)

@JML :+1: merci