Summary
Learn how to connect an HX711 load cell module to Arduino, wire a four-cell half-bridge platform, read measurements with the HX711 library, calibrate the scale and troubleshoot unstable readings.
An HX711 load cell amplifier lets an Arduino measure small changes in electrical signals produced by a load cell. With a 50kg load cell, an HX711 module, and an Arduino, you can build a digital weighing scale for measuring weight, monitoring loads, or creating a force-measurement project.
To get reliable readings, connect the load cell to the HX711 correctly, wire the module to the Arduino, and calibrate it using a known weight. A four-wire load cell commonly uses red, black, green, and white wires, but the exact colour assignments depend on the manufacturer. For a typical HX711 module, connect VCC to 5V, GND to GND, DT to Arduino digital pin 3, and SCK to digital pin 2. The example below uses the popular HX711 Arduino library.
What Is an HX711?
The HX711 is a 24-bit analog-to-digital converter (ADC) designed for weighing scales and load-cell applications. It amplifies the small differential signal from a load cell and converts it into digital data that a microcontroller can read.
A load cell changes its electrical resistance slightly when force is applied. Many common load cells use strain gauges arranged in a Wheatstone bridge. The resulting output signal is very small, so connecting a typical load cell directly to an Arduino analog input usually does not provide a practical weighing solution.
The HX711 combines signal amplification and analog-to-digital conversion in one module. It communicates with an Arduino using two signal lines, often labelled DT or DOUT for data and SCK or PD_SCK for the clock.
Common applications include:
-
Digital weighing scales
-
Platform scales and parcel weighing
-
Force measurement experiments
-
Material testing and load monitoring
-
Robotics projects that measure applied force
-
DIY inventory and dispensing systems
The HX711 does not determine weight by itself. The load cell provides the force-sensitive signal, while the Arduino uses the HX711 readings and a calibration factor to calculate a value in grams, kilograms, or another chosen unit.
Components and Supplies
HX711 Load Cell Module
- Rs 50/-
- Rs 50/-
-
Rs 70/-
Arduino Uno R3 Original
- Rs 2,320/-
- Rs 2,320/-
-
Rs 3,499/-
HX711 Load Cell Amplifier Module – 24-Bit ADC - 7Semi
- Rs 90/-
- Rs 90/-
-
Rs 139/-
10kg Load Cell with HX711 Weight Sensor
- Rs 165/-
- Rs 165/-
-
Rs 199/-
170 Points Mini Breadboard
- Rs 18/-
- Rs 18/-
-
Rs 29/-
10-Pin Alligator Clip to Male Jumper Wire for Test Lead (20 cm)
- Rs 119/-
- Rs 119/-
-
Rs 209/-
16x2 LCD Display (Blue)
- Rs 175/-
- Rs 175/-
-
Rs 189/-
HX711 Pinout and Specifications
The HX711 breakout board has two groups of connections. One group connects to the load cell, and the other connects to the Arduino.
HX711 pinout
|
Pin |
Function |
Connection |
|---|---|---|
|
E+ |
Bridge excitation positive |
Positive excitation supply for the load-cell bridge |
|
E- |
Bridge excitation negative |
Negative excitation supply for the bridge |
|
A+ |
Channel A positive input |
Positive bridge signal |
|
A- |
Channel A negative input |
Negative bridge signal |
|
B+ |
Channel B positive input |
Optional second differential input |
|
B- |
Channel B negative input |
Optional second differential input |
|
VCC |
Module power |
Usually 5V for the module used in this example |
|
GND |
Ground |
Arduino GND |
|
DT or DOUT |
Digital data output |
Arduino digital pin 3 |
|
SCK or PD_SCK |
Serial clock |
Arduino digital pin 2 |
Channel A is commonly used with a gain setting of 128 for weighing applications. Channel B has a fixed gain of 32. For the Arduino example in this guide, only Channel A is used.
The HX711 module is designed to read a bridge output, not a single resistance measurement directly. Check the labels printed on your particular module because the layout and terminal order can vary.
Important: Check whether your load cell is a half bridge or full bridge
This matters when using the Robocraze 50kg load cell. Its product documentation describes the sensor as a half-bridge load cell. A single half-bridge cell does not provide the complete four-resistor bridge output expected by the HX711. You need a suitable bridge-completion arrangement, or multiple compatible half-bridge cells connected according to the manufacturer's wiring diagram.
For a platform scale, four compatible 50kg half-bridge cells can be arranged to form a complete bridge. Their nominal capacities add up to 200kg when the load is properly distributed and the mechanical design supports it. The actual safe capacity also depends on mounting, load distribution, the platform and its structure.
Do not connect a single half-bridge sensor to E+, E-, A+ and A- as though it were a four-wire full-bridge load cell. If you have a different load cell with a documented four-wire full bridge, follow that sensor's wiring diagram.
Wiring a 50kg Load Cell System to Arduino
For a scale built with four half-bridge load cells, first wire the sensors into a complete Wheatstone bridge. Then connect the bridge output to the HX711. The HX711 connects to the Arduino through its data and clock pins.
1. Connect the four load cells into a bridge
The four half-bridge sensors must be combined so their resistance changes reinforce one another when the platform is loaded. This usually means mounting the cells at the four corners of the platform and connecting the bridge according to the sensor manufacturer's wiring diagram.
Use the sensor's specified wire colours and bridge-combination diagram. Do not assume that every three-wire load cell uses the same colour assignment. For the Robocraze sensor, the product page describes a half-bridge design, so verify the correct bridge wiring before applying power.
The completed bridge will provide four electrical connections to the HX711: E+, E-, A+ and A-. The two excitation terminals power the bridge, while A+ and A- measure the small differential output.
2. Connect the HX711 to Arduino Uno
Once the load-cell bridge is complete, connect the HX711 module to the Arduino as follows.
|
HX711 module |
Arduino Uno |
|---|---|
|
VCC |
5V |
|
GND |
GND |
|
DT or DOUT |
Digital pin 3 |
|
SCK or PD_SCK |
Digital pin 2 |
Keep the load-cell bridge wiring separate from the Arduino's digital signal wiring. Secure loose connections, avoid running the sensitive signal wires alongside noisy motor or relay wiring, and keep the load cell cables away from sources of electrical interference where possible.
The HX711 breakout used here is intended for a 5V setup. If you use a different breakout or a 3.3V microcontroller, check its voltage requirements and logic compatibility before connecting it.
3. Check the wiring before powering on
Before connecting USB or another power source, verify the following:
-
The four half-bridge cells form a complete bridge according to the manufacturer's diagram.
-
The bridge excitation wires connect to E+ and E-.
-
The bridge signal wires connect to A+ and A-.
-
HX711 VCC and GND connect to the correct Arduino power pins.
-
DT and SCK connect to the pins defined in the sketch.
-
No exposed wire strands can short adjacent terminals.
If your load cell is a four-wire full-bridge model rather than the half-bridge type discussed above, use its documented colour code. A common four-wire convention is red for E+, black for E-, green for A+ and white for A-, but the manufacturer's documentation takes priority.
Install the HX711 Arduino Library
The Arduino needs a library to read the HX711's digital output. One widely used option is the open-source HX711 library by Bogdan Necula. It includes functions for reading measurements, averaging readings, setting the scale factor and zeroing the scale.
Follow these steps to install it:
-
Open the Arduino IDE.
-
Select Sketch > Include Library > Manage Libraries.
-
Search for
HX711. -
Find the library by Bogdan Necula, then click Install.
-
Open a new sketch and include the library using
#include "HX711.h".
If you install a different library with the same name, check its documentation because the function names and setup procedure may differ.
Arduino Code to Read a Load Cell
After wiring the HX711 and installing the library, upload this example. It reads the sensor, removes the initial platform weight, and prints a measurement to the Serial Monitor.
The example starts with a scale factor of 1.0 so you can inspect the readings before calibration. The value printed before calibration is not a reliable measurement in grams or kilograms.
#include "HX711.h"
const int LOADCELL_DOUT_PIN = 3;
const int LOADCELL_SCK_PIN = 2;
HX711 scale;
void setup() {
Serial.begin(9600);
scale.begin(LOADCELL_DOUT_PIN, LOADCELL_SCK_PIN);
Serial.println("Starting load cell...");
if (!scale.wait_ready_timeout(2000)) {
Serial.println("HX711 not detected. Check wiring.");
while (true) {
delay(100);
}
}
scale.set_scale(1.0f);
scale.tare();
Serial.println("Remove all weight, then place a known weight.");
}
void loop() {
if (scale.wait_ready_timeout(1000)) {
long rawValue = scale.read();
float reading = scale.get_units(10);
Serial.print("Raw reading: ");
Serial.print(rawValue);
Serial.print(" | Uncalibrated value: ");
Serial.println(reading, 2);
} else {
Serial.println("HX711 is not ready.");
}
delay(500);
}What does the code do?
-
scale.begin()sets the Arduino pins used for data and clock. -
wait_ready_timeout()checks whether the HX711 is responding before the program tries to read it. -
set_scale(1.0f)applies a temporary scale factor. It must be replaced with a calibrated value before using the readings as weight. -
tare()records the unloaded reading as the zero point. -
read()returns a raw ADC reading. -
get_units(10)averages multiple readings and applies the current offset and scale factor. -
Serial.println()displays the result in the Serial Monitor.
Open the Serial Monitor and set the baud rate to 9600. With no weight on the platform, the raw reading will usually be a large positive or negative number. That is normal. The raw value depends on the bridge, wiring, sensor arrangement and electronics. The important part is that the reading changes when you apply and remove a load.
If the HX711 is not detected, check the VCC and GND connections, confirm that DT and SCK match the code, and verify that the bridge wiring is complete.
How to Calibrate a 50kg Load Cell
Calibration converts the HX711's raw measurements into a meaningful weight value. Even if the load cell has a stated capacity of 50kg, you cannot assume the raw reading will automatically correspond to kilograms. The sensor, bridge arrangement, mounting, amplifier and scale factor all affect the result.
For a four-cell platform using four 50kg half-bridge sensors, calibrate the complete assembled platform rather than calibrating each sensor independently and assuming the readings will add correctly.
Step 1: Prepare the scale
Mount the sensors securely and make sure the platform does not touch the frame or other parts that could carry some of the load around the sensors. Place the scale on a firm, level surface.
Check that all four sensors are oriented and wired as required. Uneven mounting, binding, loose fasteners or a flexible platform can cause unstable or inaccurate readings.
Step 2: Record the unloaded reading
Power the Arduino and HX711. Allow the reading to settle, then remove all objects from the platform. The platform itself should remain in place if it is part of the weighing assembly.
Call tare() with the platform empty. The library records the current reading as the offset, which makes the displayed weight zero when the same empty setup is measured again.
If you need to weigh the contents of a container, place the empty container on the platform and tare again. The next measurement will represent the contents rather than the container plus contents.
Step 3: Place a known weight on the platform
Use a known reference weight, ideally one that is large enough to produce a clear change in the reading and is well below the platform's maximum capacity. A calibrated test weight is preferable to an object whose weight is only estimated.
Record the output from get_units(10). With the temporary scale factor set to 1.0, this value is an offset-corrected raw measurement, not necessarily grams or kilograms.
Step 4: Calculate the calibration factor
The bogde/HX711 library uses a scale factor to convert the offset-corrected raw reading into the chosen weight unit.
If the known weight is in kilograms, use this relationship:
For example, suppose a known 5kg weight produces an offset-corrected reading of 25,000 with set_scale(1.0f). The initial factor would be:
This is only an illustrative example. Your actual factor will depend on your load cell assembly and wiring.
Set the calculated value with scale.set_scale(5000.0f), then test again with the known weight. If the value is negative because of the signal polarity, reverse the relevant signal pair according to the wiring diagram or use the correct sign for the calibration factor.
Step 5: Verify and refine the result
After applying the calculated factor, place the reference weight on the platform again. The displayed result should be close to the known value.
Test with at least two or three different known weights across the range you expect to use. The reading should increase consistently as weight increases, return close to zero when the platform is empty, and remain reasonably stable when a fixed weight is left in place.
If readings are consistently high or low, adjust the scale factor and repeat the test. If the error changes significantly with the load, inspect the mechanical installation, bridge wiring and load distribution rather than relying only on software adjustment.
Calibration code after finding the factor
Once you have calculated your factor, use it in the sketch. Replace 5000.0f with the value obtained from your own calibration.
#include "HX711.h"
const int LOADCELL_DOUT_PIN = 3;
const int LOADCELL_SCK_PIN = 2;
HX711 scale;
const float calibrationFactor = 5000.0f; // Example only
void setup() {
Serial.begin(9600);
scale.begin(LOADCELL_DOUT_PIN, LOADCELL_SCK_PIN);
scale.set_scale(calibrationFactor);
Serial.println("Remove all weight from the platform.");
delay(2000);
scale.tare();
Serial.println("Scale ready.");
}
void loop() {
if (scale.wait_ready_timeout(1000)) {
float weightKg = scale.get_units(10);
Serial.print("Weight: ");
Serial.print(weightKg, 3);
Serial.println(" kg");
} else {
Serial.println("HX711 not ready. Check connections.");
}
delay(500);
}This sketch assumes that your calibration factor is calculated for kilograms. If you calibrate using grams instead, the output unit will be grams. The library does not automatically identify the unit; it returns the offset-corrected measurement divided by the factor you provide.
Troubleshooting Incorrect Load Cell Readings
A load cell scale can produce incorrect readings even when the Arduino code compiles correctly. Most problems come from bridge wiring, mechanical mounting, unstable power, electrical noise or an incorrect calibration factor.
1. The reading does not change when weight is applied
First, check whether the HX711 is responding. Compare the raw readings with no load and with a known weight applied. If they barely change, verify that the load cell bridge is complete and connected to E+, E-, A+ and A- correctly.
For a four-cell half-bridge platform, inspect the connections between all four cells. A single loose bridge connection can prevent the module from measuring the load properly. Also confirm that the load is actually transferred through the sensors rather than resting against the frame.
2. The reading is negative
A negative reading does not automatically mean the load cell is damaged. The output polarity may be opposite to what the code expects, or the calibration factor may have the wrong sign.
Check the sensor's wiring diagram and the A+ and A- connections. If the bridge is wired correctly and the readings are stable, the calibration factor may need to be negative. Recalibrate after making any wiring changes.
3. The reading keeps jumping
Small fluctuations are common, but large or continuous changes can indicate electrical interference, unstable connections or mechanical movement.
Try these checks:
-
Secure the load-cell terminals and solder joints.
-
Keep signal wires away from motors, relays and switching power supplies.
-
Use a stable supply and confirm the HX711 module's grounding.
-
Ensure the platform is firm and does not wobble.
-
Allow the readings to settle before taking a measurement.
-
Average several samples with
get_units(10)or another suitable sample count.
Averaging can reduce random noise, but it cannot fix incorrect wiring, mechanical binding or a poorly mounted sensor.
4. The scale reads correctly at one weight but incorrectly at another
A scale factor can correct a consistent proportional error, but it cannot correct every mechanical or electrical problem. If the error grows or changes irregularly as the load increases, inspect the bridge connections, platform stiffness, sensor orientation and how the load is distributed across the cells.
Check the result at multiple known weights. Avoid applying loads beyond the rated capacity of the individual cells or the platform structure.
5. The scale does not return to zero
Remove the load and check whether the platform is physically returning to its original position. If it is, call tare() with the platform empty. If the reading still drifts, check for loose mounting hardware, temperature changes, mechanical friction and unstable electrical connections.
Taring resets the software offset at that moment. It does not repair a mechanical problem or permanently correct temperature drift.
How Many 50kg Load Cells Do You Need for a Scale?
The answer depends on the type of load cell and how the scale is built.
The Robocraze 50kg sensor discussed in this guide is documented as a half-bridge type. Four compatible 50kg half-bridge cells can be connected to form a complete bridge for a platform scale. Their nominal capacities add up to 200kg, provided the mounting and load distribution are suitable.
|
Number of 50kg half-bridge cells |
Nominal combined capacity |
Typical use |
|---|---|---|
|
1 |
50kg cell rating, but requires bridge completion |
Special single-sensor arrangement |
|
2 |
Up to 100kg nominal combined rating when correctly configured |
Suitable paired sensor arrangements |
|
4 |
Up to 200kg nominal combined rating when correctly configured |
Four-corner platform scale |
These figures are nominal combined ratings, not a guarantee that a finished scale can safely weigh that amount. The load must be distributed within each sensor's limits, and the platform, mounting hardware and frame must also support the load. Side forces and uneven loading can affect the reading or damage a cell.
For a straightforward platform scale, four compatible half-bridge sensors and one HX711 module are a common arrangement. Follow the exact bridge wiring diagram for your sensors before connecting the system to the Arduino.
Conclusion
An HX711 module allows an Arduino to measure the small electrical changes produced by a load cell. To build a reliable weighing scale, connect the load cell bridge to the HX711, wire the module's DT and SCK pins to the Arduino, install the HX711 library, and calibrate the assembled platform with a known weight.
Pay particular attention to the load cell type. The Robocraze 50kg sensor referenced here is a half-bridge model, so it needs a suitable bridge-completion arrangement. Four compatible 50kg half-bridge cells can form a complete bridge for a platform scale with a nominal combined capacity of 200kg, provided the mechanical design and load distribution are appropriate.
After wiring, verify the raw readings, set the calibration factor, and test the scale at several known weights. A stable mechanical platform and correctly connected bridge are just as important as the Arduino code.
For your project, explore the 50kg Load Cell with HX711 Weight Sensor and the HX711 Load Cell Module. Check the product details and availability before ordering. If you are building a four-corner platform scale, make sure you have the correct number of compatible half-bridge cells.
Chat