Guide · 10 min di lettura

Calcolatrice Arduino con Tastierino 4x4 e LCD I2C: 4 Operazioni

Calcolatrice Arduino con tastierino 4x4 e LCD I2C: collegamenti, mappatura tasti, numeri a più cifre, quattro operazioni, divisione per zero, codice Uno, ESP32 e Pico.

La calcolatrice Arduino è un progetto divertente che ti insegna davvero a programmare, e lo realizzi con un tastierino 4x4, un display LCD I2C 16x2 e pochi cavetti jumper. Digiti i numeri con i tasti, scegli addizione, sottrazione, moltiplicazione o divisione con A, B, C e D, premi # per vedere il risultato sul display, mentre * cancella tutto. In questa guida impari passo dopo passo a montare il circuito, associare i tasti alle operazioni, comporre un numero a più cifre dai tasti premuti, gestire errori come la divisione per zero e portare lo stesso progetto su ESP32 e Raspberry Pi Pico.

Anche se sembra un piccolo progetto, la calcolatrice contiene quasi tutti i concetti base del firmware: lettura di input con scansione a matrice, stato tenuto in variabili, strutture decisionali, limiti dei numeri in virgola mobile e feedback chiaro all'utente. Per questo è molto usata nei progetti scolastici, nelle fiere scientifiche e nei corsi di coding. Ti spiego ogni riga importante del codice; alla fine saprai aggiungere da solo il punto decimale, un tasto memoria o il suono dei tasti.

Tastierino a membrana 4x4
Tastierino a membrana 4x4: 16 tasti, 8 pin (4 righe + 4 colonne). È l'unità di input della calcolatrice.

Come funziona la calcolatrice Arduino?

Dividere il progetto in tre parti lo rende molto più semplice. Lato input, il tastierino restituisce il tasto premuto come singolo carattere (come '7', 'A', '#'). Lato elaborazione, Arduino conserva in variabili il numero in digitazione, il primo numero (o il risultato parziale) e l'operazione scelta. Lato output, l'LCD I2C mostra nella riga superiore il primo numero con l'operazione e in quella inferiore il numero che stai digitando o il risultato. Le calcolatrici tascabili funzionano proprio così: ogni tasto modifica un piccolo stato interno e il display ne riflette la situazione attuale.

ComponenteQuantitàFunzione
Arduino Uno (o Nano)1Legge i tasti, calcola e pilota il display
Tastierino a membrana 4x41Cifre 0–9, quattro operazioni, uguale e cancella
LCD 16x2 + modulo I2C (PCF8574)1Mostra operazione e risultato; solo 2 fili dati
Cavo jumper maschio-maschio128 collegamenti tastierino + 4 LCD
Cavo USB1Caricamento del codice e alimentazione

Come si legge un tastierino? La scansione righe-colonne

Il tastierino 4x4 contiene 16 pulsanti separati ma ha solo 8 pin. I pulsanti sono disposti in una griglia di 4 righe e 4 colonne; premendo un tasto, questo collega una linea di riga a una linea di colonna. La libreria Keypad imposta i pin delle righe come ingressi con pull-up interno, porta a LOW le colonne una alla volta e controlla quale riga legge LOW. Per esempio, se con la colonna 2 a LOW anche la riga 3 legge LOW, il tasto premuto è '8', all'incrocio tra riga 3 e colonna 2. Questa scansione avviene centinaia di volte al secondo, quindi non senti nessun ritardo. La libreria applica anche un debounce interno di circa 10 ms, così una sola pressione non viene contata due volte. I dettagli della scansione li trovi nell'articolo Come usare il tastierino (keypad).

TastoFunzione nella calcolatrice
0–9Inserimento cifre; il numero cresce cifra per cifra
AAddizione (+)
BSottrazione (-)
CMoltiplicazione (*)
DDivisione (/)
#Uguale (=), mostra il risultato
*Cancella (C), azzera tutto
Display LCD 16x2 I2C
LCD 16x2 con modulo I2C PCF8574 saldato dietro: l'operazione appare in alto, numero e risultato in basso.

Schema di collegamento: pin per Uno, ESP32 e Pico

CollegamentoArduino UnoESP32Raspberry Pi Pico
Tastierino R1D9GPIO 13GP6
Tastierino R2D8GPIO 14GP7
Tastierino R3D7GPIO 27GP8
Tastierino R4D6GPIO 26GP9
Tastierino C1D5GPIO 25GP10
Tastierino C2D4GPIO 33GP11
Tastierino C3D3GPIO 32GP12
Tastierino C4D2GPIO 4GP13
LCD GNDGNDGNDGND
LCD VCC5VVIN (5 V)VBUS (5 V, da USB)
LCD SDAA4GPIO 21GP4
LCD SCLA5GPIO 22GP5
Nella maggior parte dei tastierini a membrana gli 8 pin, da sinistra a destra, sono in ordine R1, R2, R3, R4, C1, C2, C3, C4, ma alcuni modelli hanno un ordine diverso. Se premendo '1' vedi '4', 'A' o 'D', righe e colonne sono scambiate o invertite: invece di staccare i cavi, correggi gli array rowPins e colPins nel codice. Su Uno non usare i pin 0 e 1: sono riservati alla comunicazione seriale USB e impediscono il caricamento del codice.

Il modulo LCD I2C ha solo quattro fili: GND, VCC, SDA e SCL. Su Uno SDA va ad A4 e SCL ad A5. La maggior parte dei moduli usa l'indirizzo 0x27, mentre quelli con chip PCF8574A usano 0x3F. Se la retroilluminazione è accesa ma non vedi testo, prima gira con un piccolo cacciavite il trimmer blu del contrasto sul retro del modulo. Se non sei sicuro dell'indirizzo, esegui lo sketch scanner I2C dell'articolo Come usare un display LCD I2C; se sei curioso di sapere come due soli fili gestiscano tanti dispositivi, cos'è l'I2C è un buon punto di partenza.

Installazione passo dopo passo

  1. Apri il Gestore Librerie dell'Arduino IDE e installa le librerie Keypad (Mark Stanley, Alexander Brevig) e LiquidCrystal I2C (Frank de Brabander). Se non sai come fare, leggi l'articolo su come aggiungere librerie.
  2. Collega gli 8 pin del tastierino ai pin digitali di Uno da D9 a D2, nell'ordine della tabella.
  3. Collega GND e VCC del modulo LCD ai pin GND e 5V di Uno, SDA ad A4 e SCL ad A5.
  4. Carica il codice qui sotto; all'avvio dovresti vedere sul display la scritta "Hesap Makinesi".
  5. Premi in sequenza 1, 2, A, 5 e #; se sul display compare 17 come risultato, circuito e codice funzionano.
  6. Se non vedi il testo, regola il contrasto e prova l'indirizzo 0x3F; se i tasti sono confusi, controlla gli array dei pin.

Codice della calcolatrice per Arduino Uno

Il codice non accumula il numero digitato come testo (String), ma direttamente come intero di tipo long: è veloce e non appesantisce i 2 KB di RAM di Uno. Il primo numero e i risultati sono invece conservati in un tipo chiamato Number (float su Uno), così possono avere una parte decimale. Abbiamo scritto una funzione per ogni tipo di tasto; così loop() resta un breve smistatore che manda il tasto premuto alla funzione giusta e il codice si legge facilmente.

C++ (Arduino IDE)
1#include <Wire.h>
2#include <LiquidCrystal_I2C.h>
3#include <Keypad.h>
4
5using Number = float;                 // ESP32'de double yapılabilir / can be double on ESP32
6const byte MAX_DIGITS = 7;            // float ~7 basamak / float ~7 digits
7const Number LIMIT = 99999999.0;      // taşma sınırı / overflow limit
8
9const byte ROWS = 4;
10const byte COLS = 4;
11char keys[ROWS][COLS] = {
12  {'1', '2', '3', 'A'},
13  {'4', '5', '6', 'B'},
14  {'7', '8', '9', 'C'},
15  {'*', '0', '#', 'D'}
16};
17byte rowPins[ROWS] = {9, 8, 7, 6};    // R1-R4
18byte colPins[COLS] = {5, 4, 3, 2};    // C1-C4
19
20Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);
21LiquidCrystal_I2C lcd(0x27, 16, 2);   // adres 0x27 ya da 0x3F / address 0x27 or 0x3F
22
23long entry = 0;                       // yazılan sayı / number being typed
24byte digits = 0;                      // girilen hane / digits typed
25Number first = 0;                     // ilk sayı ya da ara sonuç / first operand or running result
26bool hasFirst = false;
27char op = 0;                          // '+', '-', '*', '/' ya da 0 / or 0
28bool justCalculated = false;          // sonuç ekranda mı? / is a result shown?
29
30void printNumber(Number v) {
31  long n = (long)(v >= 0 ? v + 0.5 : v - 0.5);
32  if (fabs(v - n) < 0.0005) lcd.print(n);   // tam sayı / whole number
33  else lcd.print(v, 3);                     // 3 ondalık / 3 decimals
34}
35
36void showScreen() {
37  lcd.clear();
38  if (hasFirst) {                     // üst satır: ilk sayı ve işlem / top row: first operand and operator
39    printNumber(first);
40    if (op) {
41      lcd.print(' ');
42      lcd.print(op);
43    }
44  }
45  lcd.setCursor(0, 1);                // alt satır: yazılan sayı / bottom row: number being typed
46  if (digits > 0) lcd.print(entry);
47  else if (!hasFirst) lcd.print('0');
48}
49
50void clearState() {
51  entry = 0;
52  digits = 0;
53  first = 0;
54  hasFirst = false;
55  op = 0;
56  justCalculated = false;
57}
58
59void clearAll() {
60  clearState();
61  showScreen();
62}
63
64void showError(const char *msg) {
65  lcd.clear();
66  lcd.print("Hata / Error");
67  lcd.setCursor(0, 1);
68  lcd.print(msg);
69  delay(1500);
70  clearAll();
71}
72
73bool applyOp(Number b) {              // first = first (op) b
74  if (op == '/' && b == 0) {
75    showError("Sifira bolunmez");     // sıfıra bölme / division by zero
76    return false;
77  }
78  Number r;
79  switch (op) {
80    case '+': r = first + b; break;
81    case '-': r = first - b; break;
82    case '*': r = first * b; break;
83    case '/': r = first / b; break;
84    default:  r = b; break;
85  }
86  if (fabs(r) > LIMIT) {
87    showError("Tasma");               // taşma / overflow
88    return false;
89  }
90  first = r;
91  return true;
92}
93
94void handleDigit(char k) {
95  if (justCalculated) clearState();   // yeni hesap / new calculation
96  if (entry == 0) digits = 0;         // baştaki sıfırları sayma / ignore leading zeros
97  if (digits >= MAX_DIGITS) return;
98  entry = entry * 10 + (k - '0');     // sayı biriktirme / build the number
99  digits++;
100  showScreen();
101}
102
103void handleOperator(char newOp) {
104  if (digits > 0) {
105    if (!hasFirst) {
106      first = entry;
107      hasFirst = true;
108    } else if (!applyOp(entry)) {
109      return;                         // hata oldu / an error occurred
110    }
111    entry = 0;
112    digits = 0;
113  } else if (!hasFirst) {
114    return;                           // henüz sayı yok / no number yet
115  }
116  op = newOp;
117  justCalculated = false;
118  showScreen();
119}
120
121void handleEquals() {
122  if (!hasFirst || op == 0 || digits == 0) return;   // eksik işlem / incomplete operation
123  if (!applyOp(entry)) return;
124  entry = 0;
125  digits = 0;
126  op = 0;
127  justCalculated = true;
128  lcd.clear();
129  lcd.print("Sonuc:");
130  lcd.setCursor(0, 1);
131  printNumber(first);
132}
133
134void setup() {
135  lcd.init();
136  lcd.backlight();
137  lcd.print("Hesap Makinesi");
138  lcd.setCursor(0, 1);
139  lcd.print("BlueGrays");
140  delay(1500);
141  clearAll();
142}
143
144void loop() {
145  char k = keypad.getKey();
146  if (!k) return;                     // tuş yok / no key
147  if (k >= '0' && k <= '9') handleDigit(k);
148  else if (k == 'A') handleOperator('+');
149  else if (k == 'B') handleOperator('-');
150  else if (k == 'C') handleOperator('*');
151  else if (k == 'D') handleOperator('/');
152  else if (k == '#') handleEquals();
153  else if (k == '*') clearAll();
154}

Come funziona il codice?

Funzione / variabileCosa fa
entry, digitsNumero in digitazione e numero di cifre; su Uno al massimo 7 cifre
first, hasFirstPrimo numero o risultato parziale nelle operazioni concatenate
opOperazione scelta: '+', '-', '*', '/' oppure 0 (nessuna operazione)
handleDigit()Aggiunge la cifra in fondo al numero: entry = entry × 10 + cifra
handleOperator()Sposta il numero in first, applica l'eventuale operazione in sospeso e registra la nuova
applyOp()Esegue le quattro operazioni; segnala errore su divisione per zero e overflow
handleEquals()Calcola il risultato e lo mostra nella riga inferiore
clearAll()Tasto *: azzera tutte le variabili e pulisce il display

Il segreto per comporre i numeri è una sola formula: entry = entry × 10 + cifra. Immagina di premere 4, 7 e 2. Alla prima pressione entry diventa 0 × 10 + 4 = 4, alla seconda 4 × 10 + 7 = 47, alla terza 47 × 10 + 2 = 472. Per convertire il carattere premuto in numero usiamo l'espressione k - '0': nella tabella ASCII il codice del carattere '0' è 48 e quello di '7' è 55, e la differenza è esattamente 7. Perché gli zeri iniziali non sprechino il limite di cifre, quando entry vale 0 il contatore delle cifre viene azzerato: se digiti 0, 0, 5 il numero è 5 e conta come una sola cifra. Il limite di 7 cifre dipende dalla precisione del float, che spieghiamo nella prossima sezione.

La parte più furba del codice sono le operazioni concatenate. Se scrivi 5 + 3 e invece di # premi direttamente B (sottrazione), handleOperator() esegue prima l'addizione in sospeso, scrive il risultato parziale 8 in first e poi registra la sottrazione; quindi 5 + 3 - 2 viene calcolato da sinistra a destra, come su una calcolatrice tascabile, e dà 6. Ricorda che non c'è precedenza degli operatori: 2 + 3 × 4 dà 20 e non 14, come fanno la maggior parte delle calcolatrici semplici. Dopo aver mostrato un risultato, se premi un tasto operazione il risultato diventa il primo numero e continui il calcolo; se premi una cifra, inizia un nuovo calcolo. Il flag justCalculated che gestisce questo comportamento è in realtà una piccola macchina a stati; per approfondire leggi l'articolo sulla macchina a stati in Arduino.

Controllo della divisione per zero e dell'overflow

Dividere un numero per zero è indefinito in matematica e Arduino non lo impedisce da solo: nella divisione float un numero positivo diviso per zero dà inf (infinito) e zero diviso zero dà nan (non un numero), e sul display finisce un valore privo di senso. Per questo applyOp() controlla prima della divisione se il divisore è zero; se lo è, mostra per 1,5 secondi il messaggio "Sifira bolunmez" e azzera la calcolatrice. La seconda protezione riguarda l'overflow. Su Uno il float è a 32 bit e offre circa 6–7 cifre significative; gli interi sopra 16.777.216 non si possono più memorizzare esattamente e l'ultima cifra può essere arrotondata. Inoltre la funzione print di Arduino scrive "ovf" per i float oltre circa 4,29 miliardi. Il codice dà l'errore "Tasma" se il valore assoluto del risultato supera 99.999.999, così non mostra mai risultati che non entrano nelle 16 colonne del display o che non sono affidabili.

La tabella caratteri dell'LCD non contiene lettere turche come ş, ı, ğ; per questo i messaggi sul display sono scritti con caratteri ASCII, come "Sonuc" e "Sifira bolunmez". Se vuoi caratteri speciali, con createChar() puoi definire fino a 8 caratteri personalizzati. Se noti uno sfarfallio, a ogni tasto aggiorna solo la riga cambiata invece di usare lcd.clear(): il comando clear() dura circa 2 ms e cancella per un attimo l'immagine.

Calcolatrice con ESP32

Lo stesso codice funziona anche su ESP32; devi cambiare solo gli array dei pin e, se vuoi, il tipo numerico. Per l'LCD si usano i pin I2C predefiniti dell'ESP32, GPIO 21 (SDA) e GPIO 22 (SCL); la libreria LiquidCrystal I2C avvia Wire con questi pin da sola. C'è un altro vantaggio: sull'ESP32 il double è davvero a 64 bit e offre circa 15 cifre significative. Se imposti Number come double, puoi portare il limite a 9 cifre e calcolare grandi moltiplicazioni esatte fino all'ultima cifra. Su Uno double e float sono lo stesso tipo a 32 bit, quindi lì la modifica non cambia nulla. Se è la tua prima volta con l'ESP32, la configurazione della scheda è spiegata in Cos'è l'ESP32?.

C++ (Arduino IDE)
1// ESP32: Uno kodunda yalnız bu satırları değiştir / change only these lines in the Uno code
2using Number = double;                  // 64 bit, ~15 basamak / 64-bit, ~15 digits
3const byte MAX_DIGITS = 9;              // 9 haneli giriş / 9-digit input
4const Number LIMIT = 999999999.0;       // long sınırına sığar / fits in a long
5
6byte rowPins[ROWS] = {13, 14, 27, 26};  // R1-R4
7byte colPins[COLS] = {25, 33, 32, 4};   // C1-C4
8// LCD: SDA = GPIO 21, SCL = GPIO 22 (Wire varsayılanı / Wire default)
I pin dell'ESP32 lavorano a 3,3 V e ufficialmente non tollerano i 5 V. Se alimenti il modulo LCD dal pin VIN (5 V), le resistenze di pull-up sulla scheda PCF8574 portano SDA e SCL a 5 V. Nelle prove brevi di solito non succede nulla, ma in un dispositivo permanente inserisci un convertitore di livello logico. Per il tastierino non usare i GPIO 34–39: sono solo ingressi e non hanno pull-up interni. È più sicuro anche evitare i pin di strapping come GPIO 0, 2, 12 e 15, che influenzano il comportamento della scheda all'avvio.

Calcolatrice con Raspberry Pi Pico e MicroPython

Sul Pico, al posto della libreria Keypad di Arduino scriviamo noi la scansione: è un ottimo esercizio per capire davvero la scansione a matrice. Le righe vanno su GP6–GP9 come ingressi con pull-up, le colonne su GP10–GP13 come uscite, e ogni colonna viene portata a LOW a turno. Poiché in MicroPython non c'è un modulo LCD già pronto, devi copiare sul Pico con Thonny i file driver lcd_api.py e pico_i2c_lcd.py. Anche sul Pico il float è a 32 bit, quindi il limite resta 7 cifre; però in Python è molto facile accumulare il numero come testo e convertirlo con float(). L'avviso sui 5 V dato per l'ESP32 vale anche per il Pico. Se il Pico è nuovo per te, dai un'occhiata a Cos'è il Raspberry Pi Pico? e ai fondamenti di MicroPython.

MicroPython
1from machine import Pin, I2C
2import time
3from pico_i2c_lcd import I2cLcd          # lcd_api.py + pico_i2c_lcd.py Pico'da olmalı / must be on the Pico
4
5KEYS = [["1", "2", "3", "A"],
6        ["4", "5", "6", "B"],
7        ["7", "8", "9", "C"],
8        ["*", "0", "#", "D"]]
9OPS = {"A": "+", "B": "-", "C": "*", "D": "/"}
10
11rows = [Pin(p, Pin.IN, Pin.PULL_UP) for p in (6, 7, 8, 9)]     # R1-R4
12cols = [Pin(p, Pin.OUT, value=1) for p in (10, 11, 12, 13)]    # C1-C4
13
14i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=100000)
15lcd = I2cLcd(i2c, 0x27, 2, 16)           # adres, satır, sütun / address, rows, columns
16
17def get_key():
18    for c, col in enumerate(cols):
19        col.value(0)                     # bu sütunu LOW yap / drive this column LOW
20        for r, row in enumerate(rows):
21            if row.value() == 0:
22                time.sleep_ms(20)        # debounce
23                if row.value() == 0:
24                    while row.value() == 0:   # bırakılmasını bekle / wait for release
25                        time.sleep_ms(5)
26                    col.value(1)
27                    return KEYS[r][c]
28        col.value(1)
29    return None
30
31def fmt(x):
32    if abs(x - round(x)) < 0.0005:
33        return str(int(round(x)))        # tam sayı / whole number
34    return "{:.3f}".format(x)            # 3 ondalık / 3 decimals
35
36def show(top, bottom):
37    lcd.clear()
38    lcd.putstr(top[:16])
39    lcd.move_to(0, 1)
40    lcd.putstr(bottom[:16])
41
42def calc(a, o, b):
43    if o == "+":
44        r = a + b
45    elif o == "-":
46        r = a - b
47    elif o == "*":
48        r = a * b
49    else:
50        if b == 0:
51            raise ValueError("Sifira bolunmez")   # sıfıra bölme / division by zero
52        r = a / b
53    if abs(r) > 99999999:
54        raise ValueError("Tasma")                  # taşma / overflow
55    return r
56
57def screen():
58    top = ""
59    if first is not None:
60        top = fmt(first) + (" " + op if op else "")
61    show(top, entry or ("0" if first is None else ""))
62
63first, op, entry, done = None, None, "", False
64show("Hesap Makinesi", "Pico hazir")
65time.sleep(1.5)
66screen()
67
68while True:
69    k = get_key()
70    if k is None:
71        time.sleep_ms(10)
72        continue
73    try:
74        if k == "*":                     # temizle / clear
75            first, op, entry, done = None, None, "", False
76        elif k.isdigit():
77            if done:                     # yeni hesap / new calculation
78                first, op, done = None, None, False
79            if entry == "0":
80                entry = ""               # baştaki sıfırı at / drop leading zero
81            if len(entry) < 7:
82                entry += k
83        elif k in OPS:
84            if entry:
85                b = float(entry)
86                first = b if (first is None or op is None) else calc(first, op, b)
87                entry = ""
88            if first is not None:
89                op = OPS[k]
90                done = False
91        elif k == "#" and first is not None and op and entry:
92            first = calc(first, op, float(entry))
93            entry, op, done = "", None, True
94    except ValueError as e:
95        show("Hata / Error", str(e))
96        time.sleep(1.5)
97        first, op, entry, done = None, None, "", False
98    if done:
99        show("Sonuc:", fmt(first))
100    else:
101        screen()

Idee per migliorare la calcolatrice

  • Punto decimale: assegna la funzione di punto decimale a una combinazione di tasti non usata; aggiungi ogni cifra dopo il punto con moltiplicatori decrescenti come 0,1 e 0,01.
  • Tasti memoria (M+, MR): salva il risultato nella EEPROM; l'ultimo risultato non si perde nemmeno se Arduino si spegne.
  • Suono dei tasti: aggiungi un buzzer per un breve bip a ogni pressione; per un buzzer sul pin D10 basta la riga tone(10, 2000, 30).
  • Modalità scientifica: aggiungi radice quadrata (sqrt), potenza (pow) e percentuale con un secondo livello di tasti.
  • Display più grande: al posto dell'LCD 16x2 usa un display OLED e mostra la cronologia dei calcoli riga per riga.
  • Registro dei calcoli: stampa ogni risultato anche sul Serial Monitor per tenere la cronologia sul computer.
  • Serratura a codice: con lo stesso tastierino e LCD costruisci una serratura a codice per porta; la logica di accumulo dei numeri funziona identica anche lì.

Errori comuni e soluzioni

ProblemaCausa probabileSoluzione
L'LCD è acceso ma senza testoContrasto non regolato o indirizzo I2C sbagliatoGira il trimmer sul retro; prova 0x3F al posto di 0x27
Quadratini neri nella riga superioreLCD non inizializzato o linea I2C interrottaVerifica che lcd.init() sia chiamato e che SDA/SCL siano su A4/A5
I tasti danno caratteri sbagliatiPin di righe e colonne confusiScambia o inverti gli array rowPins e colPins
Un tasto viene contato due volteRimbalzo dei contattiAumenta il filtro con keypad.setDebounceTime(50)
Nessun tasto funzionaUsati i pin 0/1 su Uno o i GPIO 34–39 su ESP32Usa i pin della tabella
Ultima cifra sbagliata in grandi moltiplicazioniSu Uno il float porta solo 6–7 cifreMantieni il limite di cifre o usa double su ESP32
Il risultato della divisione è senza decimaliOperazione fatta con due interi (int/long)Converti almeno un lato in float; in questo codice first è già di tipo Number
Quando cerchi un errore, testa il codice a pezzi: prima stampa sul Serial Monitor solo il tasto premuto con keypad.getKey(), poi invia all'LCD solo un testo fisso. Se le due parti funzionano separatamente, il problema è nella logica di calcolo; con Serial.print puoi seguire a ogni tasto i valori di entry, first e op e trovare facilmente l'errore.

Questa calcolatrice con tastierino e LCD I2C riunisce in un solo progetto lettura dell'input, gestione dello stato, gestione degli errori e limiti dei numeri in memoria. Riutilizzerai la stessa logica in serrature a codice, contatori e sistemi di menu. Nell'app BlueGrays puoi esplorare passo dopo passo, con schemi e codice pronto, progetti come la calcolatrice I2C, l'applicazione password con tastierino 4x4 e LCD e la cassaforte elettronica intelligente, e sviluppare la tua versione.

Domande frequenti

Come si costruisce una calcolatrice con Arduino?

Bastano un Arduino Uno, un tastierino 4x4 e un LCD I2C 16x2. Gli 8 pin del tastierino vanno ai pin digitali, SDA e SCL dell'LCD ad A4 e A5. Con le librerie Keypad e LiquidCrystal I2C si leggono i tasti, i numeri si compongono con la formula entry = entry × 10 + cifra e l'operazione scelta si applica con il tasto #.

Quanti pin usa un tastierino 4x4?

Un tastierino 4x4 usa 8 pin digitali in totale, per 4 righe e 4 colonne. Su Arduino Uno di solito si scelgono i pin D2–D9, perché D0 e D1 sono riservati alla comunicazione seriale. Se i pin non bastano, un modulo tastierino I2C basato su PCF8574 riduce il collegamento a due fili dati.

Come mostrare risultati decimali nella calcolatrice Arduino?

Tieni il risultato in una variabile float e indica il numero di decimali con il secondo parametro, ad esempio lcd.print(risultato, 3). Se dividi due interi (int o long) la parte decimale si perde: 7 / 2 dà 3. Se converti in float almeno uno dei due numeri prima della divisione, ottieni 3,5.

Cosa succede in Arduino se divido per zero?

Con gli interi la divisione per zero è indefinita e può produrre valori incoerenti; con i float il risultato è inf o nan. Arduino continua a funzionare, ma sul display compare un valore senza senso. Per questo prima della divisione devi controllare con un if che il divisore non sia zero e mostrare un messaggio di errore.

Perché l'LCD I2C non mostra il testo?

Le due cause più comuni sono il contrasto non regolato e l'indirizzo I2C sbagliato. Gira il trimmer sul retro del modulo per regolare il contrasto, poi prova l'indirizzo 0x27 e 0x3F. Se il problema persiste, controlla con lo sketch scanner I2C se il modulo è visibile sul bus.

La calcolatrice Arduino rispetta la precedenza degli operatori?

Il codice di questa guida esegue le operazioni da sinistra a destra, come la maggior parte delle calcolatrici tascabili: 2 + 3 × 4 dà 20. Per la precedenza devi scrivere un parser che salvi prima l'espressione in un array e calcoli moltiplicazioni e divisioni prima di addizioni e sottrazioni. È un bell'esercizio di programmazione per il livello successivo.

Vedi tutti i progetti
Calcolatrice Arduino I2C
AR-94Intermedio
Premium

Calcolatrice Arduino I2C

Si tratta di un progetto di calcolatore basato su Arduino che esegue operazioni di addizione, sottrazione, moltiplicazione e divisione utilizzando una tastiera a membrana 4x4 e un display LCD I2C 16x2. Grazie all'I2C, il collegamento del display avviene con soli 2 cavi, riducendo così l'ingombro dei cavi e mantenendo un maggior numero di pin utilizzabili. Sono inoltre disponibili l'ingresso di numeri decimali e il supporto di numeri negativi.

5.0(31)
43
Funzionamento del tastierino 4x4
AR-63Principiante
Premium

Funzionamento del tastierino 4x4

Sul tastierino 4x4, molto simile ai tasti di un telefono, l'Arduino capisce subito quale tasto hai premuto e lo scrive sullo schermo del computer.

4.5(27)
35
Serratura con password, tastierino 4x4 e LCD
AR-64Avanzato
Premium

Serratura con password, tastierino 4x4 e LCD

Una piccola serratura elettronica che non fa entrare chi non conosce il codice. Premi il tasto cancelletto e digiti il codice sul tastierino; se è giusto, lo schermo indica accesso consentito, si…

4.8(59)
75
Funzionamento del tastierino 3x4
AR-61Principiante

Funzionamento del tastierino 3x4

L'Arduino capisce subito quale tasto premi su un tastierino da 12 tasti simile a quello di un telefono, e lo scrive sullo schermo del tuo computer.

4.5(24)
32
Controllo LED con tastierino 3x4
AR-62Intermedio
Premium

Controllo LED con tastierino 3x4

Con un tastierino come quello di un telefono comandi tre luci separate. I tasti 1, 2 e 3 accendono i LED verde, blu e giallo, i tasti 4, 5 e 6 spengono le stesse luci, il tasto asterisco le accende…

4.6(29)
38
Utilizzo dello schermo LCD con I2C
AR-32Principiante
Premium

Utilizzo dello schermo LCD con I2C

Regala al tuo Arduino uno schermo tutto suo e fagli scrivere il primo messaggio.

4.8(53)
70
Cassaforte elettronica intelligente
AR-92Avanzato
Premium

Cassaforte elettronica intelligente

Una piccola cassaforte per le tue cose di valore che si apre con un codice. Digiti il tuo codice a quattro cifre sul tastierino; se è giusto, il servomotore apre la serratura, si accende la luce…

4.7(42)
63
Schermo LCD I2C per ESP32 (16x2)
ES-17Intermedio
Premium

Schermo LCD I2C per ESP32 (16x2)

In questo progetto colleghiamo un display LCD 16x2 a caratteri all'ESP32 tramite I2C per mostrare del testo. Con l'I2C bastano 2 pin dati (SDA e SCL) invece dei 6+ pin di un collegamento parallelo classico. Il codice scrive un messaggio fisso sulla prima riga e un contatore che sale ogni secondo sulla seconda. All'avvio uno scanner I2C stampa l'indirizzo del display sul Serial Monitor (di solito 0x27 o 0x3F).

4.9(23)
40