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.

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.
| Componente | Quantità | Funzione |
|---|---|---|
| Arduino Uno (o Nano) | 1 | Legge i tasti, calcola e pilota il display |
| Tastierino a membrana 4x4 | 1 | Cifre 0–9, quattro operazioni, uguale e cancella |
| LCD 16x2 + modulo I2C (PCF8574) | 1 | Mostra operazione e risultato; solo 2 fili dati |
| Cavo jumper maschio-maschio | 12 | 8 collegamenti tastierino + 4 LCD |
| Cavo USB | 1 | Caricamento 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).
| Tasto | Funzione nella calcolatrice |
|---|---|
| 0–9 | Inserimento cifre; il numero cresce cifra per cifra |
| A | Addizione (+) |
| B | Sottrazione (-) |
| C | Moltiplicazione (*) |
| D | Divisione (/) |
| # | Uguale (=), mostra il risultato |
| * | Cancella (C), azzera tutto |

Schema di collegamento: pin per Uno, ESP32 e Pico
| Collegamento | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Tastierino R1 | D9 | GPIO 13 | GP6 |
| Tastierino R2 | D8 | GPIO 14 | GP7 |
| Tastierino R3 | D7 | GPIO 27 | GP8 |
| Tastierino R4 | D6 | GPIO 26 | GP9 |
| Tastierino C1 | D5 | GPIO 25 | GP10 |
| Tastierino C2 | D4 | GPIO 33 | GP11 |
| Tastierino C3 | D3 | GPIO 32 | GP12 |
| Tastierino C4 | D2 | GPIO 4 | GP13 |
| LCD GND | GND | GND | GND |
| LCD VCC | 5V | VIN (5 V) | VBUS (5 V, da USB) |
| LCD SDA | A4 | GPIO 21 | GP4 |
| LCD SCL | A5 | GPIO 22 | GP5 |
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
- 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.
- Collega gli 8 pin del tastierino ai pin digitali di Uno da D9 a D2, nell'ordine della tabella.
- Collega GND e VCC del modulo LCD ai pin GND e 5V di Uno, SDA ad A4 e SCL ad A5.
- Carica il codice qui sotto; all'avvio dovresti vedere sul display la scritta "Hesap Makinesi".
- Premi in sequenza 1, 2, A, 5 e #; se sul display compare 17 come risultato, circuito e codice funzionano.
- 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.
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 / variabile | Cosa fa |
|---|---|
| entry, digits | Numero in digitazione e numero di cifre; su Uno al massimo 7 cifre |
| first, hasFirst | Primo numero o risultato parziale nelle operazioni concatenate |
| op | Operazione 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.
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?.
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)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.
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
| Problema | Causa probabile | Soluzione |
|---|---|---|
| L'LCD è acceso ma senza testo | Contrasto non regolato o indirizzo I2C sbagliato | Gira il trimmer sul retro; prova 0x3F al posto di 0x27 |
| Quadratini neri nella riga superiore | LCD non inizializzato o linea I2C interrotta | Verifica che lcd.init() sia chiamato e che SDA/SCL siano su A4/A5 |
| I tasti danno caratteri sbagliati | Pin di righe e colonne confusi | Scambia o inverti gli array rowPins e colPins |
| Un tasto viene contato due volte | Rimbalzo dei contatti | Aumenta il filtro con keypad.setDebounceTime(50) |
| Nessun tasto funziona | Usati i pin 0/1 su Uno o i GPIO 34–39 su ESP32 | Usa i pin della tabella |
| Ultima cifra sbagliata in grandi moltiplicazioni | Su Uno il float porta solo 6–7 cifre | Mantieni il limite di cifre o usa double su ESP32 |
| Il risultato della divisione è senza decimali | Operazione fatta con due interi (int/long) | Converti almeno un lato in float; in questo codice first è già di tipo Number |
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.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
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.

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.

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…

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.

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…

Utilizzo dello schermo LCD con I2C
Regala al tuo Arduino uno schermo tutto suo e fagli scrivere il primo messaggio.

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…

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).
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

