Build a Precision Arduino Weight Sensor with HX711 and Load Cell

To build a reliable Arduino weight sensor, you need three core components: a strain gauge load cell, an HX711 24-bit analog-to-digital converter (ADC), and a microcontroller. The load cell converts mechanical force into a tiny change in electrical resistance, and the HX711 amplifies that microvolt-level signal into a digital value your board can read. This guide targets the Arduino Uno R3 (ATmega328P) and Nano v3 variants, though the code and wiring apply to any 5V-tolerant AVR board.

Below, we cover the exact hardware specifications, wiring diagrams, compilable code with error handling, and the specific debugging steps required when the serial monitor hangs.

Hardware Spec Sheet & Parts List

Load cells are rated by capacity and sensitivity. The sensitivity is measured in mV/V (millivolts of output per volt of excitation). A standard 5kg straight-bar load cell with a 2.0 mV/V rating powered by a 5V excitation source will output a maximum of 10mV at full load. The HX711 features a programmable gain amplifier (PGA) with a default gain of 128 on Channel A, perfectly matched to read this tiny voltage swing.

Required Parts

• Microcontroller: Arduino Uno R3 or Nano v3 (5V logic).
• ADC Module: HX711 Breakout Board (SparkFun SEN-13879 or generic equivalent).
• Load Cell: 5kg Straight Bar Aluminum Load Cell (e.g., Tal220 or generic equivalent).
• Hardware: M4 or M5 screws to mount the load cell, rigid base plate, and top plate.
• Wiring: 22 AWG solid core jumper wires.

Wiring the Arduino Weight Sensor

The load cell outputs four wires that form a Wheatstone bridge. Wire colors can vary between manufacturers, but the standard color code for the straight-bar cells is Red (E+), Black (E-), White (A+), and Green (A-). Always verify with your specific datasheet if the readings are inverted or erratic.

Table 2: HX711 to Arduino Pin Mapping

HX711 Pin	Arduino Uno/Nano Pin	Function
VCC	5V	Module Power (Do not use 3.3V on 5V boards)
GND	GND	Common Ground
DT (Data)	D2	Digital Output from ADC
SCK (Clock)	D3	Clock Input to ADC

Physical Wiring Steps

1. Mount the Load Cell: Bolt the load cell to a rigid base. Leave the overhanging end free to deflect downward when weight is applied.
2. Connect Load Cell to HX711: Solder or screw the four load cell wires into the HX711 E+, E-, A+, and A- terminals. Ensure the connections are tight; loose screws introduce noise and thermal drift.
3. Connect HX711 to Arduino: Wire VCC to 5V, GND to GND, DT to D2, and SCK to D3.
4. Verify Jumper Pads: On many generic HX711 boards, there is a solder jumper on the back labeled RATE. If the pad is bridged to H, the output rate is 80 SPS (samples per second). If bridged to L, it is 10 SPS. Leave it at L (10 SPS) for standard weighing applications to maximize noise rejection.

Compilable Code & Calibration

This code relies on the widely used HX711 library by bogde (available via the Arduino Library Manager). The script includes a non-blocking readiness check to prevent the microcontroller from freezing if the HX711 is disconnected or unpowered.

#include "HX711.h"

// Pin definitions - Must match physical wiring
const int LOADCELL_DOUT_PIN = 2;
const int LOADCELL_SCK_PIN  = 3;

HX711 scale;

// Calibration factor. Adjust this based on your specific load cell.
// See calibration steps below to find your exact number.
float calibration_factor = -21500.0; 

void setup() {
  Serial.begin(9600);
  Serial.println("Initializing Arduino Weight Sensor...");

  // Initialize the HX711 library with our pin definitions
  scale.begin(LOADCELL_DOUT_PIN, LOADCELL_SCK_PIN);

  Serial.println("Before setting scale factor: " + String(scale.read()));
  
  // Tare the scale (set current weight to zero)
  // We take 10 readings for a stable average
  Serial.println("Taring... remove all weight from the sensor.");
  scale.tare(10);
  Serial.println("Tare complete. Place a known weight on the sensor.");
  
  // Set the scale factor for grams (or your preferred unit)
  scale.set_scale(calibration_factor);
}

void loop() {
  // Error handling: Check if HX711 is ready before reading
  // This prevents the code from hanging if the module loses power or connection
  if (scale.is_ready()) {
    float weight = scale.get_units(5); // Average 5 readings
    Serial.print("Weight: ");
    Serial.print(weight, 1); // Print to 1 decimal place
    Serial.println(" g");
  } else {
    Serial.println("ERROR: HX711 not found. Check wiring and power.");
  }
  
  // Allow time for serial printing and sensor settling
  delay(200);
}

How to Calibrate

1. Upload the code and open the Serial Monitor at 9600 baud.
2. Place an object of known mass (e.g., a 500g calibration weight or a bag of sugar verified on a commercial scale) on the load cell.
3. If the serial output reads 250.0 g instead of 500.0 g, your calibration factor is off by a factor of 2.
4. Use the formula: New_Factor = Old_Factor * (Reported_Weight / Known_Weight). In this case: -21500 * (250 / 500) = -10750.
5. Update the calibration_factor variable in the code and re-upload.

Debugging: "HX711 Not Found" & Timeout Errors

The most common failure mode when building an Arduino weight sensor is the serial monitor hanging entirely, or the custom error string ERROR: HX711 not found. Check wiring and power. printing repeatedly. If you are using an older version of the library without the is_ready() check, the code will throw a timeout waiting for HX711 error or simply freeze at the scale.read() function.

The scale.read() function blocks execution until the DOUT pin goes LOW, which signals that a conversion is complete. If DOUT stays HIGH, the loop hangs indefinitely. Here are the first three things to check when this happens:

1. Swapped SCK and DT Pins

If you accidentally wire SCK to D2 and DT to D3, the Arduino will send clock pulses to the data line and try to read the clock line. The HX711 will never pull the clock line LOW to signal readiness. Swap the physical wires or update the pin definitions in the code.

2. Missing Common Ground

The HX711 and the Arduino must share a common ground reference. If you are powering the HX711 from an external 5V supply but forgot to connect the supply's GND to the Arduino's GND, the digital logic levels will float, and the DOUT pin will never register a valid LOW state on the ATmega328P.

3. Wheatstone Bridge Miswiring

If the load cell wires are connected to the wrong terminals (e.g., swapping A+ and E-), the HX711's internal PGA will read an out-of-range voltage. The chip's internal comparator will fail to trigger a conversion, leaving DOUT HIGH. Verify your wire colors against the manufacturer's schematic. As noted in the Adafruit HX711 documentation, generic Chinese load cells frequently swap the White and Green signal wires.

Extending and Simplifying the Build

Depending on your project requirements, you may need to scale this architecture up for industrial use or scale it down for a quick prototype.

How to Extend the Build (Multi-Cell Scales)

If you are building a platform scale (like a bathroom scale or a large hopper), a single load cell is insufficient because off-center loads will cause twisting and inaccurate readings. To fix this, use four half-bridge load cells wired into a full Wheatstone bridge. You will need a Load Cell Summing Junction Board (often sold as a "4-wire to HX711 combiner"). This board handles the parallel wiring and resistor balancing, allowing you to feed the combined signal into a single HX711 Channel A. For high-speed industrial logging, consider upgrading the microcontroller to an ESP32 to push the weight data over MQTT to a local dashboard.

How to Simplify the Build (Digital I2C Alternatives)

If you want to bypass the HX711 calibration process and raw ADC management entirely, swap the HX711 and bare load cell for a pre-calibrated digital weight sensor module. Modules like the SparkFun Qwiic Scale (NAU7802) or fully integrated I2C load cell modules feature onboard EEPROM that stores the calibration factor. This allows you to read weight directly in grams via standard I2C commands, eliminating the need to recalculate calibration factors every time the board loses power. This approach costs roughly $15–$25 more in BOM (Bill of Materials) costs but saves hours of bench time.