Calculatrice commandée par la carte Arduino UNO

Arduino 14-02-26

17 0

Plan de tutoriel

1- Présentation du projet

2- Matériel nécessaire

3- Schéma de câblage de la calculatrice

4- Programmation de la carte Arduino UNO

Présentation du projet

Ce projet consiste à réaliser une calculatrice électronique basée sur la carte Arduino UNO, utilisant un afficheur LCD I2C pour afficher les données et un clavier matriciel 4×4 pour la saisie des nombres et des opérations.

Cette calculatrice permet à l’utilisateur d’entrer deux nombres, de choisir une opération mathématique (addition, soustraction, multiplication ou division), puis d’afficher le résultat directement sur l’écran LCD.

La carte Arduino UNO joue le rôle d’unité centrale : elle lit les touches pressées sur le clavier matriciel, traite les données et effectue les calculs nécessaires.

L’afficheur LCD I2C facilite l’affichage des informations tout en réduisant le nombre de connexions grâce à la communication I2C.

Le clavier matriciel 4×4 sert d’interface utilisateur, permettant la saisie des chiffres et la sélection des opérateurs.

Ce projet est idéal pour les débutants et les élèves souhaitant apprendre les bases de la programmation Arduino, la gestion des entrées/sorties, l’utilisation du protocole I2C et l’interfaçage de périphériques électroniques.

Il constitue également une excellente application pratique combinant électronique et programmation pour créer un système interactif réel.

Matériel nécessaire

1- Carte ESP32

Arduino Uno

La carte Arduino UNO est le composant principal de la calculatrice. Elle agit comme le cerveau du système.

2. Clavier matriciel 4×4

Le clavier matriciel 4×4 est utilisé pour la saisie des données.

3. Afficheur LCD I2C

L’afficheur LCD I2C sert à afficher les nombres saisis, les opérations choisies et le résultat final.

4. Câbles de Connexion (Jumper Wires)

Fils de connexion

Les fils de connexion assurent la liaison entre la carte Arduino UNO, le clavier et l’afficheur LCD. Ils permettent de relier les broches d’entrée/sortie et d’alimentation.

6- Breadboard (Plaque d'essai) :

plaque d'essai

Une breadboard est utile pour créer un circuit temporaire et connecter facilement les composants entre eux.

Schéma de câblage de la calculatrice

1- Connexion du clavier matriciel 4×4 à la carte Arduino UNO

Clavier 4×4	Carte Arduino UNO
Ligne 1	pin 2
Ligne 2	pin 3
Ligne 3	pin 4
Ligne 4	pin 5
Colonne 1	pin 6
Colonne 2	pin 7
Colonne 3	pin 8
Colonne 4	pin 9

2- Connexion de l’afficheur LCD I2C à la carte Arduino UNO

Afficheur LCD I2C	Carte Arduino UNO
VCC	5V
GND	GND
SDA	pin A4
SCL	pin A4

Programmation de la carte Arduino UNO

Ce programme Arduino permet à la carte Arduin UNO de piloter l’ensemble du système de la calculatrice. Il assure la lecture des touches du clavier matriciel, le traitement des opérations mathématiques et l’affichage des résultats sur l’écran LCD I2C.

On commence par l’importation de la bibliothèque LiquidCrystal_I2C dédiées à l'afficheur LCD I2C et la bibliothèque Keypad pour le clavier matriciel 4x4.

#include <Wire.h>                 // Bibliothèque pour la communication I2C
#include <LiquidCrystal_I2C.h>   // Bibliothèque pour contrôler l'afficheur LCD I2C
#include <Keypad.h>              // Bibliothèque pour gérer le clavier matriciel

// ---------------- LCD ----------------
// Création d'un objet lcd avec adresse I2C 0x27, 20 colonnes et 4 lignes
LiquidCrystal_I2C lcd(0x27, 20, 4);

// ---------------- Clavier ----------------
// Définition du nombre de lignes et colonnes du clavier
const byte ROWS = 4;
const byte COLS = 4;

// Tableau contenant les caractères de chaque touche du clavier
char keys[ROWS][COLS] = {
  {'1','2','3','+'},
  {'4','5','6','-'},
  {'7','8','9','*'},
  {'C','0','=','/'}
};

// Définition des broches Arduino connectées aux lignes du clavier
byte rowPins[ROWS] = {9, 8, 7, 6};

// Définition des broches Arduino connectées aux colonnes du clavier
byte colPins[COLS] = {5, 4, 3, 2};

// Création de l'objet clavier
Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);

// ---------------- Variables ----------------
// Variable pour stocker l'expression mathématique saisie par l'utilisateur
String expression = "";

// ---------------- SETUP ----------------
void setup() {

  lcd.init();        // Initialisation de l'afficheur LCD
  lcd.backlight();   // Activation du rétroéclairage
  lcd.clear();       // Effacement de l'écran

  // Affichage du message de démarrage
  lcd.setCursor(0,0);
  lcd.print("Calculatrice Arduino");

  delay(10000);      // Attendre 10 secondes

  lcd.clear();       // Effacer l'écran
}

// ---------------- Fonction de calcul ----------------
float calculer(String exp) {

  // Tableaux pour stocker les nombres et les opérateurs
  float nombres[10];
  char ops[10];

  int nCount = 0;   // Compteur de nombres
  int oCount = 0;   // Compteur d'opérateurs

  // ---- Découpage de l'expression ----
  // Exemple : "12+3*4"
  // nombres = {12,3,4}
  // ops = {'+','*'}

  String temp = "";

  for (int i = 0; i < exp.length(); i++) {

    char c = exp[i];

    // Si le caractère est un chiffre, on l'ajoute au nombre temporaire
    if (isdigit(c)) {
      temp += c;
    }

    // Sinon c'est un opérateur
    else {
      nombres[nCount++] = temp.toFloat(); // Stocker le nombre
      ops[oCount++] = c;                  // Stocker l'opérateur
      temp = "";                          // Réinitialiser
    }
  }

  // Ajouter le dernier nombre
  nombres[nCount++] = temp.toFloat();

  // ---- Priorité * et / ----
  // Calculer les multiplications et divisions en premier

  for (int i = 0; i < oCount; i++) {

    if (ops[i] == '*' || ops[i] == '/') {

      float res;

      if (ops[i] == '*')
        res = nombres[i] * nombres[i+1];
      else
        res = nombres[i] / nombres[i+1];

      // Remplacer les deux nombres par le résultat
      nombres[i] = res;

      // Décaler les nombres vers la gauche
      for (int j = i + 1; j < nCount - 1; j++)
        nombres[j] = nombres[j + 1];

      // Décaler les opérateurs vers la gauche
      for (int j = i; j < oCount - 1; j++)
        ops[j] = ops[j + 1];

      nCount--;
      oCount--;
      i--;
    }
  }

  // ---- Calcul des additions et soustractions ----

  float resultat = nombres[0];

  for (int i = 0; i < oCount; i++) {

    if (ops[i] == '+')
      resultat += nombres[i+1];

    if (ops[i] == '-')
      resultat -= nombres[i+1];
  }

  return resultat;   // Retourner le résultat final
}

// ---------------- LOOP ----------------
void loop() {

  // Lire la touche pressée
  char touche = keypad.getKey();

  // Si une touche est pressée
  if (touche) {

    // ---- Touche C : Effacer ----
    if (touche == 'C') {

      expression = "";   // Effacer l'expression
      lcd.clear();       // Effacer l'écran
    }

    // ---- Touche = : Calculer ----
    else if (touche == '=') {

      // Vérifier que l'expression n'est pas vide
      if (expression.length() > 0) {

        float res = calculer(expression);   // Calculer le résultat

        lcd.setCursor(0,2);
        lcd.print("= ");
        lcd.print(res);   // Afficher le résultat

        expression = "";  // Réinitialiser l'expression
      }
    }

    // ---- Autres touches : ajouter à l'expression ----
    else {

      expression += touche;   // Ajouter la touche à l'expression

      lcd.setCursor(0,0);
      lcd.print(expression);  // Afficher l'expression
    }
  }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

#include <Wire.h> // Bibliothèque pour la communication I2C

#include <LiquidCrystal_I2C.h> // Bibliothèque pour contrôler l'afficheur LCD I2C

#include <Keypad.h> // Bibliothèque pour gérer le clavier matriciel

// ---------------- LCD ----------------

// Création d'un objet lcd avec adresse I2C 0x27, 20 colonnes et 4 lignes

LiquidCrystal_I2C lcd(0x27, 20, 4);

// ---------------- Clavier ----------------

// Définition du nombre de lignes et colonnes du clavier

const byte ROWS = 4;

const byte COLS = 4;

// Tableau contenant les caractères de chaque touche du clavier

char keys[ROWS][COLS] = {

{'1','2','3','+'},

{'4','5','6','-'},

{'7','8','9','*'},

{'C','0','=','/'}

};

// Définition des broches Arduino connectées aux lignes du clavier

byte rowPins[ROWS] = {9, 8, 7, 6};

// Définition des broches Arduino connectées aux colonnes du clavier

byte colPins[COLS] = {5, 4, 3, 2};

// Création de l'objet clavier

Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);

// ---------------- Variables ----------------

// Variable pour stocker l'expression mathématique saisie par l'utilisateur

String expression = "";

// ---------------- SETUP ----------------

void setup() {

lcd.init(); // Initialisation de l'afficheur LCD

lcd.backlight(); // Activation du rétroéclairage

lcd.clear(); // Effacement de l'écran

// Affichage du message de démarrage

lcd.setCursor(0,0);

lcd.print("Calculatrice Arduino");

delay(10000); // Attendre 10 secondes

lcd.clear(); // Effacer l'écran

}

// ---------------- Fonction de calcul ----------------

float calculer(String exp) {

// Tableaux pour stocker les nombres et les opérateurs

float nombres[10];

char ops[10];

int nCount = 0; // Compteur de nombres

int oCount = 0; // Compteur d'opérateurs

// ---- Découpage de l'expression ----

// Exemple : "12+3*4"

// nombres = {12,3,4}

// ops = {'+','*'}

String temp = "";

for (int i = 0; i < exp.length(); i++) {

char c = exp[i];

// Si le caractère est un chiffre, on l'ajoute au nombre temporaire

if (isdigit(c)) {

temp += c;

}

// Sinon c'est un opérateur

else {

nombres[nCount++] = temp.toFloat(); // Stocker le nombre

ops[oCount++] = c; // Stocker l'opérateur

temp = ""; // Réinitialiser

}

// Ajouter le dernier nombre

nombres[nCount++] = temp.toFloat();

// ---- Priorité * et / ----

// Calculer les multiplications et divisions en premier

for (int i = 0; i < oCount; i++) {

if (ops[i] == '*' || ops[i] == '/') {

float res;

if (ops[i] == '*')

res = nombres[i] * nombres[i+1];

else

res = nombres[i] / nombres[i+1];

// Remplacer les deux nombres par le résultat

nombres[i] = res;

// Décaler les nombres vers la gauche

for (int j = i + 1; j < nCount - 1; j++)

nombres[j] = nombres[j + 1];

// Décaler les opérateurs vers la gauche

for (int j = i; j < oCount - 1; j++)

ops[j] = ops[j + 1];

nCount--;

oCount--;

i--;

}

// ---- Calcul des additions et soustractions ----

float resultat = nombres[0];

for (int i = 0; i < oCount; i++) {

if (ops[i] == '+')

resultat += nombres[i+1];

if (ops[i] == '-')

resultat -= nombres[i+1];

}

return resultat; // Retourner le résultat final

}

// ---------------- LOOP ----------------

void loop() {

// Lire la touche pressée

char touche = keypad.getKey();

// Si une touche est pressée

if (touche) {

// ---- Touche C : Effacer ----

if (touche == 'C') {

expression = ""; // Effacer l'expression

lcd.clear(); // Effacer l'écran

}

// ---- Touche = : Calculer ----

else if (touche == '=') {

// Vérifier que l'expression n'est pas vide

if (expression.length() > 0) {

float res = calculer(expression); // Calculer le résultat

lcd.setCursor(0,2);

lcd.print("= ");

lcd.print(res); // Afficher le résultat

expression = ""; // Réinitialiser l'expression

}

// ---- Autres touches : ajouter à l'expression ----

else {

expression += touche; // Ajouter la touche à l'expression

lcd.setCursor(0,0);

lcd.print(expression); // Afficher l'expression

}

Grâce à ce programme, la carte Arduino UNO devient une calculatrice fonctionnelle, capable d’interagir avec l’utilisateur via un clavier matriciel et un écran LCD I2C.