Bilancia con OLED
In questo post descrivo il mio progetto per la costruzione di una piccola bilancia.
Materiale utilizzato:
Display OLED 0.96 pollici 128x64 con I2C.
Arduino Nano
Batteria 9V ricaricabile
1 interruttore On-Off
2 pulsanti momentanei
2 resistenze da 10k
1 resistenza da 44 K
1 resistenza da 56 K
Cella di carico da 5 Kg
modulo HX711
Per la realizzazione di questa bilancia devo ringraziare Paolo Aliverti i suoi video sull'argomento mi hanno permesso di completare con successo questo progetto, in particolar modo i video 214, 215, 216.
Ho seguito le indicazioni per la taratura della cella di carico, ed ho utilizzato il codice indicato da Paolo.
Inizialmente ho montato il tutto su BB per mettere a punto il programma.
Il mio progetto realizza una bilancia con batteria ricaricabile ed un tasto per azzerare la Tara, ho aggiunto un secondo tasto Mem che serve per bloccare una pesata già fatta.
Una volta accesa mostra 0 g. appoggiando l'oggetto mostra il peso, premendo il tasto tara si memorizza la tara e si azzera il display, si può aggiungere altro materiale e si visualizza il peso di quanto aggiunto.
Il peso tara viene indicato in piccolo in alto a sinistra (giallo nel mio display).
Per azzerare la Tara premere il tasto Tara con bilancia vuota.
Si può premere il tasto Mem e il display si blocca sul peso indicato, e rimane cosi anche togliendo l'oggetto, per azzerare premere nuovamente il tasto Mem.
Ho inserito un controllo della tensione in ingresso a VIN per segnalare batteria scarica
Si accende in alto a destra piccola indicazione BAT.
appoggiato piccolo peso da 50g.
Posizionato un peso da 50g e premuto il tasto Tara appare 50 in giallo in alto e azzera il peso bilancia.
Appoggiato peso da 100g. si vede in giallo la tara ed il peso aggiunto.
Tasto Mem attivato si conserva la lettura fatta fino a nuova pressione del tasto.
La struttura della bilancia è molto semplice una Base in legno sulla quale ho posizionato i componenti (cella di carico, batteria, Arduino, HX711, resistenze).
I tasti ed il display sono alloggiati sulla parte superiore realizzata con stampa 3d.
Collegato con cablaggio filare i vari componenti.
Vista della parte superiore.
Qui sotto lo schema dei collegamenti
Per la realizzazione del programma ho seguito le indicazioni di Paolo
qui sotto il mio sketch per Arduino.
E' tutto commentato e penso che sia comprensibile in ogni caso guardate anche i video di Paolo Aliverti. (214,215,216).
// BILANCIA CON DISPLAY OLED
// SERGIO PRENLELOUP
// 16/07/2025
//*****************************
// PROGETTO CHE PREVEDE
// DI MOSTRARE PESO IN GRAMMI
// SUL DISPLAY OLED
// UN TASTO "TARA"
// UN TASTO "MEM" PER BLOCCARE IL PESO
// e Per visualizzarlo MEM in alto
// premendo nuovamente
// torna normale
// *****************************
// controllo batteria se minore di 7,7 V
// segnala BAT.
// SUL PIN A0 si porta la tensione rilevata
// con partitore di resistenze
// R1 44k - R2 56k
//****************************************
//
// VERSIONE DEL 03/08/2025
// NUM V030825
//****************************************
#include "HX711.h"
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 64 // OLED display height, in pixels
#define OLED_RESET -1 // Reset pin # (or -1 if sharing Arduino reset pin)
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);
//**************************************************************************
HX711 scale(2, 3);
//*************************************************************************
unsigned long t1;
// per memorizzare il tempo millis al setup
int bat = 1;
// per controllo livello batteria
// 1 > 7.7 Volt 0 < 7.7 V.
int Tara_Button = 7;
int Mem_Button = 8;
//pulsanti = pin dei pulsanti
//stato corrente dei bottoni
int stato_bottoni[2];
boolean stato_switch[2];
// costante calibrazione peso
float calibration_factor = -456;
// units dove inserisco lettura peso della libreria
float units;
int pesodisplay = 0; // peso visualizzato
int pesotara = 0; // peso tara
int mempesata = 0; // MEM pesata
void setup()
{
if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C))
{
Serial.println(F("Error..."));
for(;;);
}
// the library initializes this with an Adafruit splash screen.
display.display();
display.clearDisplay();
display.setTextSize(2);
display.setTextColor(WHITE);
display.setCursor(10,30);
display.print("V030825");
display.display();
delay (300);
display.clearDisplay();
scale.set_scale();
scale.tare();
scale.set_scale(calibration_factor);
pinMode (Tara_Button, INPUT);
pinMode (Mem_Button, INPUT);
stato_bottoni[0] = 0;
stato_bottoni[1] = 0;
t1 = millis();
}
void aggiornaStato(int bottone, int& statoBottoneVecchio, boolean& statoSwitch)
{
//Si legge lo stato corrente del bottone (se premuto o no)
int statoBottoneCorrente = digitalRead (bottone);
//Se lo stato corrente del bottone è cambiato (diverso dal vecchio stato)
//si deve gestire il nuovo stato
if (statoBottoneCorrente != statoBottoneVecchio)
{
//se stiamo passando da rilasciato a premuto allora gestiamo la
//logica antirimbalzo e attiviamo/disattiviamo lo swith
if (statoBottoneCorrente == HIGH)
{
delay(15);
statoSwitch = !statoSwitch;
}
//il nuovo stato diventa lo stato corrente
statoBottoneVecchio = statoBottoneCorrente;
}
}
void controllaPulsante()
{
aggiornaStato(Tara_Button, stato_bottoni[0], stato_switch[0]);
aggiornaStato(Mem_Button, stato_bottoni[1], stato_switch[1]);
}
void controlloBat()
{
// per monitor carica batteria
int v = analogRead(A0);
int tensione = map(v, 0,1023, 0,9000);
bat = 1;
if (tensione < 7700)
{ bat = 0;}
}
void memoriaPesata ()
{
// quando premuto tasto memoria
// memorizza pesata
// rimane ferma la visualizzazione fino ad
// una seconda pressione del tasto memoria
//************************************************
while (stato_switch[1] == 1)
{
// ferma la visualizzazione
// fino alla pressione del
// tasto Memoria
display.clearDisplay();
controlloBat();
if ( bat == 0)
{
display.setTextSize(1);
display.setTextColor(WHITE);
display.setCursor(70,1);
display.print("BAT");
}
display.setTextSize(1);
display.setTextColor(WHITE);
display.setCursor(30,1);
display.print("MEM");
display.setTextSize(3);
display.setTextColor(WHITE);
display.setCursor(10,30);
display.print(mempesata);
display.print(" g.");
display.display();
controllaPulsante();
}
}
void tastoTara ()
{
while (stato_switch[0] == 1)
{
units = scale.get_units();
if (units < 0)
{
units = 0.00;
}
pesodisplay = units;
pesodisplay = pesodisplay - pesotara;
visualizzaPeso();
controllaPulsante();
if (stato_switch [1] == 1)
{
mempesata = pesodisplay;
memoriaPesata();
stato_switch[1]= 0;
}
else { visualizzaPeso();}
}
}
void visualizzaPeso ()
{
unsigned long dt = millis() - t1;
if (dt > 1000)
{
display.clearDisplay();
controlloBat();
if ( bat == 0)
{
display.setTextSize(1);
display.setTextColor(WHITE);
display.setCursor(70,1);
display.print("BAT");
}
display.setTextSize(1);
display.setTextColor(WHITE);
display.setCursor(1,1);
display.print(pesotara);
display.setTextSize(3);
display.setTextColor(WHITE);
display.setCursor(10,30);
display.print(pesodisplay);
display.print(" g.");
display.display();
controllaPulsante();
t1 = millis();
}
}
void loop()
{
controllaPulsante();
units = scale.get_units();
if (units < 0) {
units = 0.00;
}
pesodisplay = units;
pesotara = units;
if (stato_switch [1] == 1)
{
mempesata = pesodisplay;
stato_switch[1]= 0;
}
controllaPulsante();
if (stato_switch[0] == 1)
{
// TASTO TARA PREMUTO
tastoTara();
}
else { visualizzaPeso();}
if (stato_switch [1] == 1)
{
mempesata = pesodisplay;
}
if (stato_switch [1] == 1)
{
memoriaPesata();
stato_switch[1]= 0;
}
else { visualizzaPeso();}
}
Spero che il post vi sia piaciuto lasciate un commento.
Se avete domande o riscontrate errori scrivete Vi risponderò appena possibile.
Grazie ed un saluto a tutti.
Carino e ottimo progetto
RispondiElimina