This project was to create a set of scales that could be used as general scales and for weighing money and displaying the number of coins or notes and the value. Similar to those used by banks.

It is battery operated and rechargeable but you could omit the battery and charging part of the circuit and run from a USB source direct to the Pico.

Parts List

Load Cell Weight Sensor × 1
HX711 Module Weighing Sensor × 1
TP4056 18650 Lithium Battery Charger Module Charging Board x 1
(If you use a smaller battery than 3000mah you may need to reduce the charge current by replacing the control resistor.)
3.7V Lithium Rechargeable Batteries - I used 3000mah × 1
Momentary Push Button Switch Waterproof Push Button Switch Round x 2 (12mm mounting thread)
SPST Mini Toggle Switch × 1 (6mm mounting thread)
OLED Display Board, ARCELI 0.96’’ OLED Display SPI Serial 12864 × 1

When you turn the scales on it will be in Tare mode. Make sure that you have the bowl you wish to use on the scales, either the supplied one designed for money, or a normal bowl if you are going to use it as a general scale. Then press the down button and it will set zero and be ready to weigh in grams. Pressing the down button in grams mode will scroll through the following modes: (You can change this – see below)

· Pounds
· Money 1p coins
· Money 2p coins
· Money 5p coins
· Money 10p coins
· Money 20p coins
· Money 50p coins
· Money £1 coins
· Money £2 coins
· Money £5 notes
· Money £10 notes
· Money £20 notes
· Grams

Pressing the up button in grams mode will return to Tare mode so you can change the bowl and reset zero, otherwise it will scroll up the modes.

Note that there can be weight creep which can be caused by fluctuations in voltage or the components heating up during use. If, after the scales have been on for a while, you start to see a small weight reading when there is nothing on the scales just press the up button in grams mode and reset zero.

Calibrating the Load Cell

To get accurate readings you need to calibrate the Load Cell. After making the project, or a test bed, copy all the programs to the Pico and run hx_calibrate.py through Thonny. Make sure there is nothing on the scales and press the down button to set zero. Then put an item of known weight, e.g. 1KG, on the scales and enter the weigh through Thonny when asked. The system will set the conversion factor used to convert the raw reading to grams and save this in a file for use by the main program.

Changing the currency

The descriptions, value and weight of the coins and notes is held in constant arrays. Simply change these if you wish to use the scales for another currency. You may also need to extend myfont.py to display the currency symbol. The image of the character is held in an array of 0’s and 1’s and any number of characters can be added as long as you extend the dictionary to include them.

3d Printed Case

4 STL files are included to form the case. All can be printed at 0.2mm layer height and 2 walls. The body should be printed with a 35% infill and tree supports (careful when removing to not break the lugs used to mount the oled display). The other elements can be printed with 15% infill and no supports.

Stages of assembly

This is shown in the pictures.

Code - I suggest you use Thonny

Copy all 4 code files and save on the pico in the root directory.

Main.py

# Paul Brace
# May 2026
# General/Money scale
# Using a Load Cell and HX711 amplifier with OLED display

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

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

# set up oled display
WIDTH = 128
HEIGHT = 64

i2c = I2C(0, scl=Pin(9), sda=Pin(8), freq=200000) # Init I2C using pins GP8 & GP9 (default I2C0 pins)
oled = SSD1306_I2C(WIDTH, HEIGHT, i2c) # Init oled display

# create my font for display
myfont = myFont(oled)

# Set up and down button pins
down = Pin(17, Pin.IN, Pin.PULL_DOWN)
up = Pin(16, Pin.IN, Pin.PULL_DOWN)

# To capture button bounce
lastUpPress = time.ticks_ms()
lastDownPress = time.ticks_ms()

# button_pressed used to suppress display while changing mode via interrupt
# otherwise can get mixed displays
button_pressed = False

# Initialize ADC on GPIO29 (ADC3) to read battery voltage
adc_pin = machine.ADC(29)
conversion_factor = 3.3 / 65535

# Change constants for other currencies
# Money weight for Sterling in grams
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

# Money value in pence
VALUE = [1, # 1p, etc
2,
5,
10,
20,
50,
100,
200,
500, # £5
1000, # £10
2000] # £20

# Modes for weighing
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)

# Mode descriptions
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

# Conversion factor from Grams to lb and oz.
GRAMS_POUNDS = const(0.00220462)

hx.OFFSET = 0 # Will be calculated via 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()
# Set offset to reading with no load
hx.tare(times = 15)

def read_scale():
try:
file = open("scale.txt", 'r')
data = file.read()
scale = float(data)
file.close()
except:
# Default value for my Load Cell if no file exists
scale = 1084.36
return scale

# Get stored scale and set
# Stored scale is set using hx_calibrate.py
scale = read_scale()
hx.set_scale(scale)

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

def show_heading(s):
clear_display()
# print heading
myfont.text(s,2,10)

def show_battery_level():
# Read the raw 16-bit value
reading = adc_pin.read_u16()

# Calculate measured voltage and multiply by 3 (for the resistor divider)
volts = reading * conversion_factor * 3
# Display Battery Level
if volts > 3.84:
batt = chr(37) # Full icon
elif volts > 3.7:
batt = chr(38) # 3/4 icon
elif volts > 3.54:
batt = chr(39) # 1/2 icon
elif volts > 3.4:
batt = chr(40) # 1/4 icon
else:
batt = chr(41) # Empty icon
myfont.text(batt, 110, 0)

def show_weight_pounds(heading, weight):
global button_pressed
# Calculate pounds and oz
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()

# Up button pressed
def down_pressed(pin):
global lastDownPress, current_mode, button_pressed
# allow 0.5 second after press to stop bounce and release activation
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
# allow 0.5 second after press to stop bounce and release activation
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:
# Set zero with nothing on scales
tare()
else:
# reset button_pressed so that display refreshes
button_pressed = False
#reading = hx.get_value()
weight = hx.get_units()
# Remove small errors if nothing on scale
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

# MIT License

# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:

# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.

# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# 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()

# create the 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) # get the number of clock cycles
mov(x, osr) .side (0)
jmp(not_x, "power_down") .side (0)
set(pindirs, 0) .side (0) # Initial set pin direction.
# Wait for a high level = start of the DATA pulse
wait(1, pin, 0) .side (0)
# Wait for a low level = DATA signal
wait(0, pin, 0) .side (0)
jmp(x_dec, "bitloop").side(0) # just decrement

label("bitloop")
nop() .side (1)[1]# active edge
in_(pins, 1) .side (0) # get the pin and shift it in
jmp(x_dec, "bitloop").side (0) # test for more bits

push(block) .side (0) # no, deliver data and start over
jmp("start") .side (0) # And start over

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):
# Feed the waiting state machine & get the data
self.sm.restart() # Just in case that it is not at the start.
self.sm.active(1) # start the state machine
self.sm.put(self.GAIN + 24) # set pulse count 25-27, start
start = time.ticks_ms()
while time.ticks_diff(time.ticks_ms(), start) < 1000:
# Wait for the result
if self.sm.rx_fifo() > 0:
break
else:
self.sm.active(0) # stop the state machine
raise OSError("sensor timeout")

result = self.sm.get(None, self.GAIN) # get the result & discard GAIN bits
self.sm.active(0) # stop the state machine
if result == 0x7fffffff:
raise OSError("Sensor does not respond")
# check sign
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
# PB Change May 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)

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

# PB Change
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() # Just in case that it is not at the start.
self.sm.put(0) # mode power down
self.sm.active(1) # start the state machine
time.sleep_ms(1)
self.sm.active(0) # and stop it again

def power_up(self):
self.sm.restart() # Just in case that it is not at the start.
self.sm.active(1) # start the state machine to set clock low
self.sm.active(0) # and stop it again

myfont.py

# (C) Paul Brace May 2026
# Class to display text on an oled display using a custom font V 1.0
# Used for:
# Temperature, Humidity and pressure monitor with clock and weekly history
# Money/General scales

class myFont:
# Define pixels for each letter, number and symbol we need
# First tuple element is the width of the character followed by a tuple containing the bytes
# "0" = pixel off "1" = pixel on
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))

#Large Arrows used to indicate maximum and minimum
#Up arrow
upArrow =(11, (0b00000100000,
0b00001110000,
0b00011111000,
0b00111111100,
0b01111111110,
0b00001110000,
0b00001110000,
0b00001110000,
0b00001110000,
0b00001110000,
0b00001110000))

# Down Arrow
downArrow =(11, (0b00001110000,
0b00001110000,
0b00001110000,
0b00001110000,
0b00001110000,
0b00001110000,
0b01111111110,
0b00111111100,
0b00011111000,
0b00001110000,
0b00000100000))

#Small Arrows used to indicate pressure direction
#Up arrow
upArrowS =(9, (0b000010000,
0b000111000,
0b001111100,
0b011111110,
0b111111111,
0b000111000,
0b000111000))

# Down Arrow
downArrowS =(9, (0b000111000,
0b000111000,
0b111111111,
0b011111110,
0b001111100,
0b000111000,
0b000010000))

# SD card error icon
sdError = (15, (0b110000000000011,
0b011000000000110,
0b111111111111111,
0b100110000011001,
0b100011000110001,
0b100001111100001,
0b100011011111111,
0b100110100011000,
0b111111000001100,
0b011000000000110,
0b110000000000011))

# Battery level icons
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))

# Use dictionary to select character definition
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, # change to chr(33)
chr(34): downArrow, # change to chr(34)
"/": slash,
chr(36): sdError, # change to chr(36)
chr(37): BatteryFull, # change to chr(37)
chr(38): Battery3Q, # change to chr(38)
chr(39): Battery2Q, # change to chr(39)
chr(40): Battery1Q, # change to chr(40)
chr(41): BatteryEmpty, # change to chr(41)
chr(42): upArrowS,
chr(43): downArrowS
}

# initialiser parameter is an instantiated oled display
def __init__(self, display):
self._display = display

# Display text
def text(self, word, x, y):
# Set pixels
for letter in word:
# get the definition - default to _11 if definition not found
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
# Advance x position to position for next character
x += width

hx_calibrate.py

# Paul Brace
# 24 May 2026
# To calibate scales and save calibration in text file for use in Money/General scales code

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)

# Set offset to reading with no load
hx.tare(times = 15) # Will be about -229827.5 for my load cell setup

# Save calculated scale to 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) # Should be about 1,063 for mu Load Cell

# Saved for use in scales_stadalone.py
write_scale(ratio)

hx.set_scale(ratio)

# Test items to check - display in grams
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")

General/Money Scales (Rechargeable) - Weight measure

0.2mm layer, 2 walls, 35% infill, Tree supports

0.2mm layer, 2 walls, 15% infill