Questo progetto mirava a creare un set di bilance che potessero essere utilizzate come bilance generiche e per pesare il denaro, mostrando il numero di monete o banconote e il relativo valore. Simili a quelle utilizzate dalle banche.

È alimentata a batteria e ricaricabile, ma è possibile omettere la batteria e la parte di ricarica del circuito e alimentarla direttamente da una sorgente USB al Pico.

Elenco dei componenti

Raspberry Pi Pico
Sensore di peso a cella di carico × 1
Sensore di pesata modulo HX711 × 1
Modulo caricabatterie per batterie al litio TP4056 18650 x 1
(Se si utilizza una batteria inferiore a 3000mAh, potrebbe essere necessario ridurre la corrente di carica sostituendo il resistore di controllo.)
Batterie ricaricabili al litio da 3,7V - Ho utilizzato 3000mAh × 1
Interruttore a pulsante momentaneo impermeabile rotondo x 2 (filettatura di montaggio da 12mm)
Interruttore a levetta mini SPST × 1 (filettatura di montaggio da 6mm)
Scheda display OLED, Display OLED seriale SPI ARCELI 0,96’’ 12864 × 1
2 viti M4 e 2 viti M5

Quando si accende la bilancia, questa sarà in modalità Tara. Assicurarsi di aver posizionato sulla bilancia la ciotola che si desidera utilizzare, sia quella fornita progettata per il denaro, sia una normale ciotola se si intende usarla come bilancia generica. Quindi premere il pulsante giù per azzerare e renderla pronta per la pesatura in grammi. Premendo il pulsante giù in modalità grammi si scorreranno le seguenti modalità: (È possibile modificarle – vedere sotto)

· Libbre
· Denaro monete da 1p
· Denaro monete da 2p
· Denaro monete da 5p
· Denaro monete da 10p
· Denaro monete da 20p
· Denaro monete da 50p
· Denaro monete da £1
· Denaro monete da £2
· Denaro banconote da £5
· Denaro banconote da £10
· Denaro banconote da £20
· Grammi

Premendo il pulsante su in modalità grammi si tornerà alla modalità Tara per poter cambiare la ciotola e azzerare nuovamente, altrimenti si scorreranno le modalità verso l'alto.

Si noti che può verificarsi una deriva del peso, causata da fluttuazioni di tensione o dal riscaldamento dei componenti durante l'uso. Se, dopo che la bilancia è rimasta accesa per un po', si inizia a vedere una piccola lettura di peso quando non c'è nulla sulla bilancia, basta premere il pulsante su in modalità grammi e azzerare.

Calibrazione della cella di carico

Per ottenere letture accurate è necessario calibrare la cella di carico. Dopo aver realizzato il progetto, o un banco di prova, copiare tutti i programmi sul Pico ed eseguire hx_calibrate.py tramite Thonny. Assicurarsi che non ci sia nulla sulla bilancia e premere il pulsante giù per azzerare. Quindi posizionare sulla bilancia un oggetto di peso noto, ad esempio 1 kg, e inserire il peso tramite Thonny quando richiesto. Il sistema imposterà il fattore di conversione utilizzato per convertire la lettura grezza in grammi e lo salverà in un file per l'uso da parte del programma principale.

Modifica della valuta

Le descrizioni, il valore e il peso delle monete e delle banconote sono memorizzati in array costanti. È sufficiente modificarli se si desidera utilizzare la bilancia per un'altra valuta. Potrebbe essere necessario anche estendere myfont.py per visualizzare il simbolo della valuta. L'immagine del carattere è contenuta in un array di 0 e 1 ed è possibile aggiungere qualsiasi numero di caratteri, purché si estenda il dizionario per includerli.

Custodia stampata in 3D

Sono inclusi 4 file STL per formare la custodia. Tutti possono essere stampati con altezza layer di 0,2 mm e 2 pareti. Il corpo dovrebbe essere stampato con un riempimento del 35% e supporti ad albero (fare attenzione durante la rimozione per non rompere le alette utilizzate per montare il display OLED). Gli altri elementi possono essere stampati con un riempimento del 15% e senza supporti.

Fasi di assemblaggio

Questo è mostrato nelle immagini.

Codice - Suggerisco di utilizzare Thonny

Copiare tutti e 4 i file di codice e salvarli sul Pico nella directory principale.

Main.py

# Paul Brace
# Maggio 2026
# Bilancia Generica/Denaro
# Utilizzo di una cella di carico e amplificatore HX711 con display OLED

from machine import Pin, I2C
from hx711_pio import *
from ssd1306 import SSD1306_I2C
from myfont import myFont
from utime import ticks_ms, ticks_diff, sleep, sleep_ms

# impostazione hx711
pin_OUT = Pin(3, Pin.IN, pull=Pin.PULL_DOWN)
pin_SCK = Pin(2, Pin.OUT)
hx = HX711(pin_SCK, pin_OUT)

# impostazione display oled
WIDTH = 128
HEIGHT = 64

i2c = I2C(0, scl=Pin(9), sda=Pin(8), freq=200000) # Inizializza I2C usando i pin GP8 e GP9 (pin I2C0 predefiniti)
oled = SSD1306_I2C(WIDTH, HEIGHT, i2c) # Inizializza display oled

# crea il mio font per il display
myfont = myFont(oled)

# Imposta i pin dei pulsanti su e giù
down = Pin(17, Pin.IN, Pin.PULL_DOWN)
up = Pin(16, Pin.IN, Pin.PULL_DOWN)

# Per catturare il rimbalzo del pulsante
lastUpPress = time.ticks_ms()
lastDownPress = time.ticks_ms()

# button_pressed usato per sopprimere il display durante il cambio modalità tramite interrupt
# altrimenti si possono ottenere display misti
button_pressed = False

# Inizializza ADC su GPIO29 (ADC3) per leggere la tensione della batteria
adc_pin = machine.ADC(29)
conversion_factor = 3.3 / 65535

# Cambia le costanti per altre valute
# Peso delle monete in Sterline in grammi
WEIGHT = [3.56, # 1p
7.12, # 2p
3.25, # 5p
6.50, # 10p
5.00, # 20p
8.00, # 50p
8.75, # £1
12.00, # £2
0.70, # £5
0.85, # £10
0.92] # £20

# Valore delle monete in penny
VALUE = [1, # 1p, ecc
2,
5,
10,
20,
50,
100,
200,
500, # £5
1000, # £10
2000] # £20

# Modalità di pesatura
SETUP = const(0)
GRAMS = const(1)
POUNDS = const(2)
MONEY1P = const(3)
MONEY2P = const(4)
MONEY5P = const(5)
MONEY10P = const(6)
MONEY20P = const(7)
MONEY50P = const(8)
MONEY100P = const(9)
MONEY200P = const(10)
MONEY500P = const(11)
MONEY1000P = const(12)
MONEY2000P = const(13)

# Descrizioni delle modalità
DESC = ["Setup",
"Grams",
"Pounds",
"1p coins",
"2p coins",
"5p coins",
"10p coins",
"20p coins",
"50p coins",
"£1 coins",
"£2 coins",
"£5 notes",
"£10 notes",
"£20 notes"]

current_mode = SETUP

# Fattore di conversione da Grammi a lb e oz.
GRAMS_POUNDS = const(0.00220462)

hx.OFFSET = 0 # Sarà calcolato tramite tare()
hx.set_gain(128)
sleep_ms(50)

def tare():
clear_display()
oled.text("Remove all items", 1, 10)
oled.text("from scales and", 1, 25)
oled.text("press down", 1, 40)
oled.text("button.", 1, 55)
oled.show()
while current_mode == SETUP:
pass
oled.fill(0)
myfont.text("Setting", 10, 15);
myfont.text(" zero...", 10, 35);
oled.show()
# Imposta l'offset sulla lettura senza carico
hx.tare(times = 15)

def read_scale():
try:
file = open("scale.txt", 'r')
data = file.read()
scale = float(data)
file.close()
except:
# Valore predefinito per la mia cella di carico se non esiste il file
scale = 1084.36
return scale

# Ottieni la scala memorizzata e impostala
# La scala memorizzata è impostata usando hx_calibrate.py
scale = read_scale()
hx.set_scale(scale)

def clear_display():
# pulisci display
oled.fill(0);

def show_heading(s):
clear_display()
# stampa intestazione
myfont.text(s,2,10)

def show_battery_level():
# Leggi il valore grezzo a 16 bit
reading = adc_pin.read_u16()

# Calcola la tensione misurata e moltiplica per 3 (per il divisore di tensione)
volts = reading * conversion_factor * 3
# Mostra livello batteria
if volts > 3.84:
batt = chr(37) # Icona piena
elif volts > 3.7:
batt = chr(38) # Icona 3/4
elif volts > 3.54:
batt = chr(39) # Icona 1/2
elif volts > 3.4:
batt = chr(40) # Icona 1/4
else:
batt = chr(41) # Icona vuota
myfont.text(batt, 110, 0)

def show_weight_pounds(heading, weight):
global button_pressed
# Calcola libbre e once
lb = int(weight)
oz = round((weight - lb) * 16, 1)
show_heading(heading)
myfont.text(str(lb) + "lb " + str(oz) + "oz", 2, 30)
if not button_pressed:
show_battery_level()
oled.show()

def show_weight_grams(heading, grams):
global button_pressed
show_heading(heading)
myfont.text(str(grams) + "g", 2, 30)
if not button_pressed:
show_battery_level()
oled.show()

def show_weight_money(heading, value, weight, number_coins):
global button_pressed
amount = value * number_coins / 100
show_heading(heading)
myfont.text("Wgt. " + str(round(weight, 1)) + "g", 2, 30)
myfont.text(str(number_coins) + " : £" + f"{amount:.2f}",2,50)
if not button_pressed:
show_battery_level()
oled.show()

# Pulsante su premuto
def down_pressed(pin):
global lastDownPress, current_mode, button_pressed
# attendi 0,5 secondi dopo la pressione per evitare il rimbalzo e l'attivazione al rilascio
if time.ticks_ms() - lastDownPress > 500:
lastDownPress = time.ticks_ms()
current_mode += 1
if current_mode > MONEY2000P:
current_mode = GRAMS
show_heading(DESC[current_mode])
oled.show()
button_pressed = True

def up_pressed(pin):
global lastUpPress, current_mode, button_pressed
# attendi 0,5 secondi dopo la pressione per evitare il rimbalzo e l'attivazione al rilascio
if time.ticks_ms() - lastUpPress > 500:
lastUpPress = time.ticks_ms()
current_mode -= 1
if current_mode < SETUP:
current_mode = GRAMS
show_heading(DESC[current_mode])
oled.show()
button_pressed = True

def set_pin_handlers():
up.irq(trigger=Pin.IRQ_FALLING, handler = up_pressed)
down.irq(trigger=Pin.IRQ_FALLING, handler = down_pressed)

set_pin_handlers()

while True:
if current_mode == SETUP:
# Azzera con nulla sulla bilancia
tare()
else:
# resetta button_pressed in modo che il display si aggiorni
button_pressed = False
#reading = hx.get_value()
weight = hx.get_units()
# Rimuovi piccoli errori se non c'è nulla sulla bilancia
if weight < 0.1:
weight = 0.0
if current_mode == GRAMS:
show_weight_grams(DESC[current_mode], round(weight, 1))
elif current_mode == POUNDS:
show_weight_pounds(DESC[current_mode], weight * GRAMS_POUNDS)
elif current_mode >=MONEY1P or current_mode <= MONEY2000P:
show_weight_money(DESC[current_mode],
VALUE[current_mode-MONEY1P],
weight,
round(weight / WEIGHT[current_mode - MONEY1P]))

hx711_pio.py

# Licenza MIT

# Copyright (c) 2021

# Con la presente si concede, a titolo gratuito, a chiunque ottenga una copia
# di questo software e dei file di documentazione associati (il "Software"), di trattare
# il Software senza restrizioni, inclusi senza limitazione i diritti
# di usare, copiare, modificare, unire, pubblicare, distribuire, concedere in sublicenza e/o vendere
# copie del Software, e di consentire alle persone a cui il Software è
# fornito di fare lo stesso, soggette alle seguenti condizioni:

# L'avviso di copyright sopra riportato e questa nota di autorizzazione devono essere inclusi in tutte
# le copie o parti sostanziali del Software.

# IL SOFTWARE VIENE FORNITO "COSÌ COM'È", SENZA GARANZIE DI ALCUN TIPO, ESPRESSE O
# IMPLICITE, INCLUSE MA NON LIMITATE ALLE GARANZIE DI COMMERCIABILITÀ,
# IDONEITÀ PER UN PARTICOLARE SCOPO E NON VIOLAZIONE. IN NESSUN CASO GLI
# AUTORI O I TITOLARI DEL COPYRIGHT SARANNO RESPONSABILI PER QUALSIASI RECLAMO, DANNO O ALTRO
# RESPONSABILITÀ, SIA IN UN'AZIONE DI CONTRATTO, ILLECITO O ALTRO, DERIVANTE DA,
# IN CONNESSIONE CON IL SOFTWARE O L'USO O ALTRE OPERAZIONI NEL
# SOFTWARE.

from machine import Pin, Timer
import time
import rp2

class HX711:
def __init__(self, clock, data, gain=128, state_machine=0):
self.clock = clock
self.data = data
self.clock.value(False)

self.GAIN = 0
self.OFFSET = 0
self.SCALE = 1

self.time_constant = 0.25
self.filtered = 0
self.sm_timer = Timer()

# crea la state machine
self.sm = rp2.StateMachine(state_machine, self.hx711_pio, freq=1_000_000,
sideset_base=self.clock, in_base=self.data,
set_base=self.data, jmp_pin=self.data)

self.set_gain(gain);

@rp2.asm_pio(
sideset_init=rp2.PIO.OUT_LOW,
in_shiftdir=rp2.PIO.SHIFT_LEFT,
autopull=False,
autopush=False,
)
def hx711_pio():
label("start")
pull() .side (0) # ottieni il numero di cicli di clock
mov(x, osr) .side (0)
jmp(not_x, "power_down") .side (0)
set(pindirs, 0) .side (0) # Impostazione iniziale direzione pin.
# Attendi livello alto = inizio impulso DATI
wait(1, pin, 0) .side (0)
# Attendi livello basso = segnale DATI
wait(0, pin, 0) .side (0)
jmp(x_dec, "bitloop").side(0) # decrementa e basta

label("bitloop")
nop() .side (1)[1]# fronte attivo
in_(pins, 1) .side (0) # leggi il pin e fai lo shift
jmp(x_dec, "bitloop").side (0) # verifica altri bit

push(block) .side (0) # no, fornisci i dati e ricomincia
jmp("start") .side (0) # E ricomincia

label("power_down")
jmp("power_down") .side (1)

def __call__(self):
return self.read()

def set_gain(self, gain):
if gain is 128:
self.GAIN = 1
elif gain is 64:
self.GAIN = 3
elif gain is 32:
self.GAIN = 2

self.read()
self.filtered = self.read()

def read(self):
# Alimenta la state machine in attesa e ottieni i dati
self.sm.restart() # Nel caso non sia all'inizio.
self.sm.active(1) # avvia la state machine
self.sm.put(self.GAIN + 24) # imposta conteggio impulsi 25-27, inizio
start = time.ticks_ms()
while time.ticks_diff(time.ticks_ms(), start) < 1000:
# Attendi il risultato
if self.sm.rx_fifo() > 0:
break
else:
self.sm.active(0) # ferma la state machine
raise OSError("sensor timeout")

result = self.sm.get(None, self.GAIN) # ottieni il risultato e scarta i bit GAIN
self.sm.active(0) # ferma la state machine
if result == 0x7fffffff:
raise OSError("Sensor does not respond")
# controlla il segno
if result > 0x7fffff:
result -= 0x1000000

return result

def read_average(self, times=3):
sum = 0
for i in range(times):
sum += self.read()
return sum / times

def read_lowpass(self):
self.filtered += self.time_constant * (self.read() - self.filtered)
return self.filtered

def get_value(self):
# return self.read_lowpass() - self.OFFSET
# Modifica PB Maggio 2026
return self.read_average(times = 10) - self.OFFSET

def get_units(self):
return self.get_value() / self.SCALE

def tare(self, times=15):
self.set_offset(self.read_average(times))

def set_scale(self, scale):
self.SCALE = scale

def set_offset(self, offset):
self.OFFSET = offset
#print("Offset = ", self.OFFSET)

# Modifica PB
def resetFiltered(self):
self.filtered = 0
print("Filtered = ", self.filtered)

# Modifica PB
def getOffset(self):
return self.OFFSET

def set_time_constant(self, time_constant = None):
if time_constant is None:
return self.time_constant
elif 0 < time_constant < 1.0:
self.time_constant = time_constant

def power_down(self):
self.sm.restart() # Nel caso non sia all'inizio.
self.sm.put(0) # modalità spegnimento
self.sm.active(1) # avvia la state machine
time.sleep_ms(1)
self.sm.active(0) # e fermala di nuovo

def power_up(self):
self.sm.restart() # Nel caso non sia all'inizio.
self.sm.active(1) # avvia la state machine per impostare il clock basso
self.sm.active(0) # e fermala di nuovo

myfont.py

# (C) Paul Brace Maggio 2026
# Classe per visualizzare testo su un display oled usando un font personalizzato V 1.0
# Usato per:
# Monitor di temperatura, umidità e pressione con orologio e storico settimanale
# Bilance Denaro/Generica

class myFont:
# Definisci i pixel per ogni lettera, numero e simbolo necessario
# Il primo elemento della tupla è la larghezza del carattere seguito da una tupla contenente i byte
# "0" = pixel spento "1" = pixel acceso
G11 = (11, (0b00011111000,
0b00110001100,
0b01100000110,
0b01100000000,
0b01100000000,
0b01100011110,
0b01100000110,
0b01100000110,
0b01100000110,
0b00110001100,
0b00011111000))

P11 = (11, (0b01111111100,
0b01100001110,
0b01100000110,
0b01100000110,
0b01100001110,
0b01111111100,
0b01100000000,
0b01100000000,
0b01100000000,
0b01100000000,
0b01100000000))

H11 = (11, (0b01100000110,
0b01100000110,
0b01100000110,
0b01100000110,
0b01100000110,
0b01111111110,
0b01100000110,
0b01100000110,
0b01100000110,
0b01100000110,
0b01100000110))

N11 = (11, (0b01100000110,
0b01110000110,
0b01101000110,
0b0110100110,
0b01100100110,
0b01100100110,
0b01100100110,
0b01100010110,
0b01100010110,
0b01100001110,
0b01100000110))

W11 = (11, (0b01100000110,
0b01100000110,
0b01100000110,
0b01100000110,
0b01100000110,
0b01100000110,
0b0110000110,
0b01100100110,
0b01101110110,
0b01110001110,
0b01100000110))

a11 = (11, (0b00000000000,
0b00000000000,
0b00000000000,
0b00111111100,
0b01110000110,
0b01100000110,
0b01100000110,
0b01100000110,
0b01100001110,
0b01110010110,
0b00111100110))

b11 = (11, (0b01100000000,
0b01100000000,
0b01100000000,
0b01101111000,
0b01110000100,
0b01100000110,
0b01100000110,
0b01100000110,
0b01100000110,
0b01110000100,
0b01101111000,
0b00000000000,
0b00000000000,
0b00000000000))

u11 = (11, (0b00000000000,
0b00000000000,
0b00000000000,
0b01100000110,
0b01100000110,
0b01100000110,
0b01100000110,
0b01100000110,
0b01100001110,
0b00110011110,
0b00011110110))

m11 = (11, (0b00000000000,
0b00000000000,
0b00000000000,
0b00111011100,
0b01100100110,
0b01100100110,
0b01100100110,
0b01100100110,
0b01100100110,
0b01100100110,
0b01100100110))

n11 = (11, (0b00000000000,
0b00000000000,
0b00000000000,
0b00111011100,
0b01100000110,
0b01100000110,
0b01100000110,
0b01100000110,
0b01100000110,
0b01100000110,
0b01100000110))

i11 = (6, (0b001100,
0b001100,
0b000000,
0b001100,
0b001100,
0b001100,
0b001100,
0b001100,
0b001100,
0b001100,
0b001100))

d11 = (11, (0b00000000110,
0b00000000110,
0b00000000110,
0b00111111110,
0b01110001110,
0b01100000110,
0b01100000110,
0b01100000110,
0b01100001110,
0b01110011110,
0b00111110110))

S11 = (11, (0b00011111000,
0b00111111100,
0b01110000000,
0b00111000000,
0b00000111000,
0b00000000100,
0b00000000110,
0b00000000110,
0b01100000100,
0b00011111100,
0b00001111000))

T11 = (11, (0b01111111110,
0b01111111110,
0b00000110000,
0b00000110000,
0b00000110000,
0b00000110000,
0b00000110000,
0b00000110000,
0b00000110000,
0b00000110000,
0b00000110000))

_11 = (11, (0b01111111110,
0b01111111110,
0b00111111100,
0b00011111000,
0b00001110000,
0b00111111100,
0b00001110000,
0b00011110100,
0b00111111100,
0b01111111110,
0b01111111110))

e11 = (11, (0b00000000000,
0b00000000000,
0b00000000000,
0b00111111100,
0b01110000110,
0b01100000010,
0b01110000110,
0b01101111000,
0b01100000000,
0b00110000010,
0b00011111100))

c11 = (11, (0b00000000000,
0b00000000000,
0b00000000000,
0b00111111100,
0b00110000110,
0b01100000000,
0b01100000000,
0b01100000000,
0b01100000000,
0b00110000110,
0b00011111100))

l11 = (11, (0b01100000000,
0b01100000000,
0b01100000000,
0b01100000000,
0b01100000000,
0b01100000000,
0b01100000000,
0b01100000000,
0b01100000000,
0b00110000000,
0b00011111100))

o11 = (11, (0b00000000000,
0b00000000000,
0b00000000000,
0b00011111000,
0b00110001100,
0b01100000110,
0b01100000110,
0b01100000110,
0b01100000110,
0b00110001100,
0b00011111000))

p11 = (11, (0b00000000000,
0b00000000000,
0b00000000000,
0b00011111000,
0b01110000100,
0b01100000110,
0b01100000110,
0b01100000110,
0b01100000110,
0b01110000100,
0b01101111000,
0b01100000000,
0b01100000000,
0b01100000000))

g11 = (11, (0b00000000000,
0b00000000000,
0b00000000000,
0b00011111000,
0b00100000100,
0b01100000110,
0b01100000110,
0b01100000110,
0b01100000110,
0b00100001110,
0b00011111110,
0b00000000110,
0b01000000110,
0b00111111100))

r11 = (11, (0b00000000000,
0b00000000000,
0b00000000000,
0b00011111100,
0b01110000010,
0b01100000000,
0b01100000000,
0b01100000000,
0b01100000000,
0b01100000000,
0b01100000000))

s11 = (11, (0b00000000000,
0b00000000000,
0b00000000000,
0b00111111110,
0b01100000000,
0b01100000000,
0b00111111100,
0b00000000110,
0b00000000110,
0b00000000110,
0b01111111100))

t11 = (11, (0b01100000000,
0b01100000000,
0b01111111100,
0b01100000000,
0b01100000000,
0b01100000000,
0b01100000000,
0b01100000000,
0b01100000000,
0b00110000000,
0b00011111100))

z11 = (11, (0b00000000000,
0b00000000000,
0b00000000000,
0b01111111110,
0b00000001100,
0b00000011000,
0b00000110000,
0b00001100000,
0b00011000000,
0b01100000000,
0b01111111110))

colon11 = (6, (0b000000,
0b000000,
0b000000,
0b001100,
0b001100,
0b001100,
0b000000,
0b000000,
0b001100,
0b001100,
0b001100))

stop11 = (6, (0b000000,
0b000000,
0b000000,
0b000000,
0b000000,
0b000000,
0b000000,
0b000000,
0b001100,
0b001100,
0b001100))

space11 = (6, (0b000000,
0b000000,
0b000000,
0b000000,
0b000000,
0b000000,
0b000000,
0b000000,
0b000000,
0b000000,
0b000000))

minus11 = (8, (0b00000000,
0b00000000,
0b00000000,
0b00000000,
0b00000000,
0b00111110,
0b00111110))

slash = (8, (0b00000000,
0b00000110,
0b00000110,
0b00001100,
0b00001100,
0b00011000,
0b00011000,
0b00110000,
0b00110000,
0b01100000,
0b01100000))

pd11 = (11, (0b00011111000,
0b00110001100,
0b01100000110,
0b01100000000,
0b01111110000,
0b01100000000,
0b01111110000,
0b01100000000,
0b01100000000,
0b01100000000,
0b01111111110))

n011 =(11, (0b00001111000,
0b00011111100,
0b00110001110,
0b00110000110,
0b00110000110,
0b00110000110,
0b00110000110,
0b00110000110,
0b00110000110,
0b00011111100,
0b00001111000))

n111 = (11, (0b00000110000,
0b00001110000,
0b00010110000,
0b00000110000,
0b00000110000,
0b00000110000,
0b00000110000,
0b00000110000,
0b00000110000,
0b00011111100,
0b00011111100))

n211 = (11, (0b00011111000,
0b00111111100,
0b01100000110,
0b00000000110,
0b00000011000,
0b00000110000,
0b00001100000,
0b00011000000,
0b00110000000,
0b01111111110,
0b01111111110))

n311 = (11, (0b00011111000,
0b00111111100,
0b01100000110,
0b00000000110,
0b00000011100,
0b00000111000,
0b00000011100,
0b00000000110,
0b01100000110,
0b00111111100,
0b00011111000))

n411 =(11, (0b00000011000,
0b00000111000,
0b00001111000,
0b00011011000,
0b00110011000,
0b01100011100,
0b01111111100,
0b01111111000,
0b00000011000,
0b00000111100,
0b00000111100))

n511 =(11, (0b00111111100,
0b00111111100,
0b00110000000,
0b00110000000,
0b00111111000,
0b00000011100,
0b00000000110,
0b00000000110,
0b00110000110,
0b00111111100,
0b00011111000))

n611 =(11, (0b00000111100,
0b00011111100,
0b00011000000,
0b00110000000,
0b00110111100,
0b00111111110,
0b00110000110,
0b00110000110,
0b00110000110,
0b00111111100,
0b00001110000))

n711 =(11, (0b00011111110,
0b00011111110,
0b00000000110,
0b00000001100,
0b00000001100,
0b00000011000,
0b00000011000,
0b00000110000,
0b00000110000,
0b00001100000,
0b00001100000))

n811 =(11, (0b00001111000,
0b00011111100,
0b00110001110,
0b00110000110,
0b00011001100,
0b00011111100,
0b00111001110,
0b00110000110,
0b00110000110,
0b00011111100,
0b00001111000))

n911 =(11, (0b00000111000,
0b00011111110,
0b00110000110,
0b00110000110,
0b00110000110,
0b00111111110,
0b00011110110,
0b00000000110,
0b00000001100,
0b00011111100,
0b00011110000))

#Frecce grandi usate per indicare massimo e minimo
#Freccia su
upArrow =(11, (0b00000100000,
0b00001110000,
0b00011111000,
0b00111111100,
0b01111111110,
0b00001110000,
0b00001110000,
0b00001110000,
0b00001110000,
0b00001110000,
0b00001110000))

# Freccia giù
downArrow =(11, (0b00001110000,
0b00001110000,
0b00001110000,
0b00001110000,
0b00001110000,
0b00001110000,
0b01111111110,
0b00111111100,
0b00011111000,
0b00001110000,
0b00000100000))

#Frecce piccole usate per indicare la direzione della pressione
#Freccia su
upArrowS =(9, (0b000010000,
0b000111000,
0b001111100,
0b011111110,
0b111111111,
0b000111000,
0b000111000))

# Freccia giù
downArrowS =(9, (0b000111000,
0b000111000,
0b111111111,
0b011111110,
0b001111100,
0b000111000,
0b000010000))

# Icona errore scheda SD
sdError = (15, (0b110000000000011,
0b011000000000110,
0b111111111111111,
0b100110000011001,
0b100011000110001,
0b100001111100001,
0b100011011111111,
0b100110100011000,
0b111111000001100,
0b011000000000110,
0b110000000000011))

# Icone livello batteria
BatteryFull = (16, (0b1111111111111100,
0b1111111111111100,
0b1111111111111111,
0b1111111111111111,
0b1111111111111111,
0b1111111111111100,
0b1111111111111100))

Battery3Q = (16, (0b1111111111111100,
0b1111111111000100,
0b1111111111000111,
0b1111111111000111,
0b1111111111000111,
0b1111111111000100,
0b1111111111111100))

Battery2Q = (16, (0b1111111111111100,
0b1111111000000100,
0b1111111000000111,
0b1111111000000111,
0b1111111000000111,
0b1111111000000100,
0b1111111111111100))

Battery1Q = (16, (0b1111111111111100,
0b1111000000000100,
0b1111000000000111,
0b1111000000000111,
0b1111000000000111,
0b1111000000000100,
0b1111111111111100))

BatteryEmpty = (16, (0b1111111111111100,
0b1000000000000100,
0b1000000000000111,
0b1000000000000111,
0b1000000000000111,
0b1000000000000100,
0b1111111111111100))

# Usa il dizionario per selezionare la definizione del carattere
font = {
"G": G11,
"H": H11,
"N": N11,
"W": W11,
"S": S11,
"P": P11,
"a": a11,
"c": c11,
"g": g11,
"u": u11,
"m": m11,
"n": n11,
"i": i11,
"d": d11,
"T": T11,
"b": b11,
"e": e11,
"o": o11,
"p": p11,
"r": r11,
"s": s11,
"t": t11,
"z": z11,
"l": l11,
"u": u11,
"0": n011,
"1": n111,
"2": n211,
"3": n311,
"4": n411,
"5": n511,
"6": n611,
"7": n711,
"8": n811,
"9": n911,
" ": space11,
".": stop11,
":": colon11,
"-": minus11,
"^": upArrow,
"|": downArrow,
"/": slash,
"£": pd11,
"#": sdError,
">": BatteryFull,
"!": Battery3Q,
"$": Battery2Q,
"%": Battery1Q,
"<": BatteryEmpty,
chr(33): upArrow, # cambia in chr(33)
chr(34): downArrow, # cambia in chr(34)
"/": slash,
chr(36): sdError, # cambia in chr(36)
chr(37): BatteryFull, # cambia in chr(37)
chr(38): Battery3Q, # cambia in chr(38)
chr(39): Battery2Q, # cambia in chr(39)
chr(40): Battery1Q, # cambia in chr(40)
chr(41): BatteryEmpty, # cambia in chr(41)
chr(42): upArrowS,
chr(43): downArrowS
}

# il parametro initialiser è un display oled istanziato
def __init__(self, display):
self._display = display

# Visualizza testo
def text(self, word, x, y):
# Imposta pixel
for letter in word:
# ottieni la definizione - predefinito a _11 se non trovata
data = self.font.get(letter, self._11)
width = data[0]
pattern = "{:0" + str(width) + "b}"
pos = x
line = y
for row in data[1]:
pixels = pattern.format(row)
for pix in pixels:
self._display.pixel(pos, line, int(pix))
pos += 1
line += 1
pos = x
# Avanza la posizione x per il carattere successivo
x += width

hx_calibrate.py

# Paul Brace
# 24 Maggio 2026
# Per calibrare le bilance e salvare la calibrazione in un file di testo per l'uso nel codice delle bilance Denaro/Generica

from machine import Pin
from hx711_pio import *

pin_OUT = Pin(3, Pin.IN, pull=Pin.PULL_DOWN)
pin_SCK = Pin(2, Pin.OUT)
hx = HX711(pin_SCK, pin_OUT)

#from utime import ticks_ms, ticks_diff, sleep, sleep_ms
from machine import Pin

hx.OFFSET = 0
hx.set_gain(128)
sleep_ms(50)

# Imposta l'offset sulla lettura senza carico
hx.tare(times = 15) # Sarà circa -229827.5 per la mia configurazione della cella di carico

# Salva la scala calcolata nel file
def write_scale(scale):
file = open("scale.txt", 'w')
file.write(str(scale))
file.close()

input("Place a known weight on the scale and press Enter: ")
reading = hx.get_value()
print("Raw reading less offset: ", reading)

weight = float(input("Enter weight of item in grams as a float and press enter: "))
ratio = reading / weight
print("Scale = ", ratio) # Dovrebbe essere circa 1.063 per la mia cella di carico

# Salvato per l'uso in scales_stadalone.py
write_scale(ratio)

hx.set_scale(ratio)

# Oggetti di test da controllare - visualizza in grammi
input("Place item to weigh on the scales and press Enter")

while True:
reading = hx.get_value()
weight = hx.get_units()
print("Raw = ", reading)
print("Weight = ", weight)
input("Place another item to weigh on the scales and press Enter")

Modelos de impressão 3D Bilancia da cucina e ficheiros STL gratuitos