Build an Arduino Digital Scale with a 5kg Load Cell and HX711 Amplifie

Project Overview

Arduino Scale with 5kg Load Cell and HX711: A load cell is a piece of aluminum with strain gauges bonded to it — bend it and the gauges' resistance changes by a tiny amount. The HX711 is a 24-bit amplifier chip built specifically to measure that tiny change and hand clean numbers to a microcontroller. Put them together with an Arduino and two flat plates and you have a legitimate digital scale that can weigh up to 5 kg with impressive precision.

Time: 1–2 hours (plus mounting hardware)
Skill level: Beginner
What you will build: A calibrated weighing scale that streams readings to the serial monitor.

Arduino scale built with a 5kg load cell and HX711 amplifier — The finished scale: load cell between two plates, HX711, and an Arduino.

5kg bar load cell and HX711 amplifier kit — The two key parts: a 5kg bar load cell and the HX711 breakout.

Parts List

From ShillehTek

5kg Load Cell with HX711 Amplifier Kit — both parts in one kit
Arduino Nano V3 — or any Arduino UNO-compatible board
120pcs 20cm Dupont Jumper Wires

External

Two sturdy, flat mounting surfaces (hardwood or metal work best)
Standoffs or washers as spacers, plus M4/M5 bolts for the load cell's tapped holes
USB cable or power supply for the Arduino

Note: The HX711 runs from 2.7–5.5V, so the Arduino's 5V pin powers everything. The same wiring works on ESP32 and Raspberry Pi Pico — just use 3.3V.

Step-by-Step Guide

Step 1 — Mount the Load Cell

Goal: Fix the cell so that applied weight actually bends it.

What to do: The aluminum bar has four tapped holes and a label with an arrow. Bolt the unlabeled end to your fixed base and the labeled end to the moving platform, with the arrow pointing down — the direction the platform moves under load. Three rules make or break accuracy: keep both plates as rigid as possible, and always put spacers (standoffs or washers) between each plate and the cell. Without that gap, force travels straight from plate to plate and bypasses the load cell entirely.

5kg load cell mounted between two rigid plates with spacers — Spacers on both ends let the bar flex freely — that flex is the measurement.

Expected result: A platform that floats on the load cell, with nothing else bridging the two plates.

Step 2 — Wire the Load Cell and HX711

Goal: Connect the Wheatstone bridge to the amplifier and the amplifier to the Arduino.

What to do: The strain gauges inside the bar are already wired as a Wheatstone bridge, so the four leads just need the right terminals:

Load cell -> HX711:   Red -> E+   Black -> E-   White -> A-   Green -> A+

HX711 -> Arduino:     VCC -> 5V   GND -> GND
                      DOUT (DAT) -> D3   SCK (CLK) -> D2

Wiring diagram connecting the load cell to HX711 and Arduino — Four bridge wires into the HX711, four wires from the HX711 to the Arduino.

Expected result: All connections made; almost any Arduino pins work for DOUT/CLK if you update the sketch defines.

Step 3 — Install the HX711 Library

Goal: Add driver support to the Arduino IDE.

What to do: Install bogde's HX711 library — search "HX711" in the IDE's Library Manager or grab it from GitHub (github.com/bogde/HX711) and add the ZIP through Sketch → Include Library.

Expected result: #include "HX711.h" compiles cleanly.

Step 4 — Calibrate the Scale

Goal: Find your setup's calibration factor with a known weight.

What to do: Every mechanical build is a little different, so calibrate once. Upload SparkFun's calibration sketch (public-domain, by Nathan Seidle), open the serial monitor with nothing on the scale, then place a known weight and tap + / - (or a / z) until the reading matches:

// SparkFun HX711 calibration sketch (Nathan Seidle, public domain)
#include "HX711.h"

#define LOADCELL_DOUT_PIN 3
#define LOADCELL_SCK_PIN 2

HX711 scale;
float calibration_factor = -7050; // worked for a 440lb setup; yours will differ

void setup() {
  Serial.begin(9600);
  Serial.println("HX711 calibration sketch");
  Serial.println("Remove all weight from scale");
  Serial.println("After readings begin, place known weight on scale");
  Serial.println("Press + or a to increase calibration factor");
  Serial.println("Press - or z to decrease calibration factor");

  scale.begin(LOADCELL_DOUT_PIN, LOADCELL_SCK_PIN);
  scale.set_scale();
  scale.tare(); // Reset the scale to 0

  long zero_factor = scale.read_average(); // baseline reading
  Serial.print("Zero factor: ");
  Serial.println(zero_factor);
}

void loop() {
  scale.set_scale(calibration_factor);
  Serial.print("Reading: ");
  Serial.print(scale.get_units(), 1);
  Serial.print(" lbs"); // change to kg and re-calibrate if you prefer SI
  Serial.print(" calibration_factor: ");
  Serial.print(calibration_factor);
  Serial.println();

  if (Serial.available()) {
    char temp = Serial.read();
    if (temp == '+' || temp == 'a')
      calibration_factor += 10;
    else if (temp == '-' || temp == 'z')
      calibration_factor -= 10;
  }
}

Calibrating the Arduino scale with a known weight — Adjust the factor until the serial reading matches your known weight.

Expected result: A calibration factor (positive or negative — both are normal) that makes readings match reality.

Step 5 — Weigh Things!

Goal: Run the scale with your calibration factor baked in.

What to do: Drop your factor into the demo sketch and upload. It tares at boot and then prints live weight readings forever — the perfect starting point to hack into a kitchen scale, parts counter, or filament monitor:

// SparkFun HX711 demo sketch (Nathan Seidle, public domain)
#include "HX711.h"

#define calibration_factor -7050.0 // from the calibration sketch

#define LOADCELL_DOUT_PIN 3
#define LOADCELL_SCK_PIN 2

HX711 scale;

void setup() {
  Serial.begin(9600);
  Serial.println("HX711 scale demo");

  scale.begin(LOADCELL_DOUT_PIN, LOADCELL_SCK_PIN);
  scale.set_scale(calibration_factor);
  scale.tare(); // no weight at boot = zero

  Serial.println("Readings:");
}

void loop() {
  Serial.print("Reading: ");
  Serial.print(scale.get_units(), 1);
  Serial.print(" lbs");
  Serial.println();
}

Expected result: Stable, accurate weight readings in the serial monitor — your scale is done.

Conclusion

You mounted a 5kg bar load cell the right way, wired its Wheatstone bridge into the HX711 amplifier, calibrated against a known weight, and turned an Arduino into a genuine digital scale. The same HX711 + load cell recipe scales (pun intended) from gram-level kitchen scales to hundred-kilogram platforms — only the cell and the calibration factor change.

Want the exact parts used in this build? Grab them from ShillehTek.com. If you want help customizing this project, check out our IoT consulting services.

Credits

All photos and images in this tutorial are credited to Instructables. The original guide by DegrawSt served as the reference for this ShillehTek version, and the example sketches are Nathan Seidle's public-domain SparkFun code. We thank them for their excellent work in the maker community.