# How to connect load cell to arduino?

I got this 200KG Load Cell, it has 4 wires:

Red:   +EXC  12V
Black: -EXC  0V

Green: +IN
White: -IN

Sens. 2.000mV/V


According to tech support I have on Green/White:

200Kg  -> 2.4V
100Kg  -> 1.2V


I want to connect it to the arduino to measure, for example, 3Kg, but the signal is too low for the Analog in. Can somebody post what parts and schematic I need to have it done?

I saw mentions to these parts:

AD 620
INA 125P
MAX4208
OP07


but also:

ADS1234


I am confused and where I live there are none of those parts, so I need some assured part list to buy over internet and wait then arrive by mail.

Will be happy for some light.

• "Sens. 2.000mV/V". Shouldn't that be something like mV/V/kg? – stevenvh Aug 24 '12 at 15:52
• @stevenvh: To my knowledge, load cell / strain gage sensitivities are given in terms of full-scale load specification, thus the mV/V in OP's question. I believe this tradition is the case in order to simplify the calculation, but I'd agree with a system with mV/V/kg, because that would allow more meaningful comparison of load cells even with different rated maximum loads. – boardbite Aug 26 '12 at 14:52
• @boardbite - It would be especially useful for people who don't know about that convention, like me :-). "mV/V/kg" should be more clear, and I don't see how it would complicate calculations: 10 mV/V/kg at 10 V supply gives you 100 mV/kg. Can it be more clear and unambiguous than that?? – stevenvh Aug 26 '12 at 14:58
• Indeed! And by "Simplify the calculation", I meant it would allow more ready computation of what one's full-scale voltage output when one would apply X volts of excitation; this would serve as a useful (but obviously incomplete) indicator when buying a load cell. And of course, any true engineer can just as easily infer this from a mV/V/kg spec; that was just my guess at the origin of this tradition of mV/V. – boardbite Aug 27 '12 at 13:40

First, some basic concepts:

Loadcells (and in general, Strain gage setups) have three important parameters:

• Capacity: The maximum (full-scale) amount of weight that can be applied to the loadcell without damage
• Recommended excitation voltage: Voltage to be applied to generate an output voltage difference in the Wheatstone bridge of the load cell
• Sensitivity: When you apply a load equal to the Maximum capacity, the Sensitivity spec tells you what voltage the loadcell will output for EACH volt of excitation voltage that you apply

So, once you measure the output signal voltage of the load cell, you can use the above specs and easily infer your load measurement in kg.

In your load cell's case, it appears you would have to apply an excitation voltage of 12 V across Red (12V) and Black (GND). But now, suppose you were to directly connect the output wires as follows:

Green to an input of the Arduino (and White either to GND or to another input for a differential measurement). Then, based on your load cell's sensitivty spec, you can see that, for even the maximum capacity load, the output voltage would be on the order of only a few millivolts.

Thus you will notice from your Arduino readings that the output voltage across Green and White is way too small to be measured with any meaningful precision by the Arduino. This is because the Arduino has an ADC that has only 10-bit resolution.

Thus it is clear that you either need to (Option 1) Make the small signal bigger or (Option 2) Use a more precise way of reading the small signal.

Two solutions/approaches for the load cell measurement problem:

So with the above in mind, I suggest you approach your project using one of two options (these are among the standard methods used with load cells/strain gages):

• You can amplify the load cell's output voltage signal, THEN feed it into the Arduino's ADC. You can use a pre-packaged instrumentation-amp IC like the INA125. To get much clearer understanding of how you might interface the load cell, the INA125, and an Arduino, check out this Arduino project, as well as this one

• Or instead, you can skip the whole amplification stage, and simply measure with a High-resolution ADC, which you then interface with your Arduino. Here are three options for a 24-bit sigma-delta ADC, or lower resolution of you don't need that much precision: (1) the LTC2400 for 24-bit single-ended measurements, or (2) the LTC2440 for 24-bit differential measurements, or (3) the MCP3422/MCP3424 for 18-bit differential measurements. All of those three ADC options are fairly straightforward to use and interface with the Arduino, especially if you use existing libraries/code. For example, you can check out this tutorial for LTC2400, or instead this tutorial for LTC2440, or lastly this tutorial for MCP3422/MCP3424.

A couple of related notes:

• Be sure to choose/apply an excitation voltage that is small enough that the final output signal won't damage your amplifier, your ADC, or your Arduino. Be sure to measure voltages with a DMM at various points along the stages the signal goes through to ensure that the signals are within the safe region.
• For either of the above approaches that I mentioned, note that in order to get high precision in your measurement, you will want to use what is called a "Precision voltage reference" when you apply the excitation voltage. There are several options available for Voltage references; let me know if you have trouble finding one for your desired voltage.
• Hi, first, thank you for your great anwser! INA125 here is double price than AD 620. If possible I preffer to buy the AD 620. Can it easily be connected to the 12V, the load cell and the arduino? Can you put here some schematic using it? If too complicated, please tell me and I will buy the INA125. – Tony Aug 24 '12 at 2:09
• Of course it is not too complicated; just take a look at the datasheet of AD620, especially Pages 14-15 - the part just has 8 pins, all of which are very obvious to understand; please try it yourself first. Also, if the design using the amplifier is complicated for you, I suggest you instead go with the 2nd Approach I described above, i.e. directly using a High-resolution ADC chip interfaced to Arduino. This will also help with your budget b/c IIRC the three ADCs I mentioned are very inexpensive, as well as easy to interface. – boardbite Aug 24 '12 at 2:21
• Thank you very much! Now with all this information I will try to get the parts. May the Virgin Mary bless you. – Tony Aug 24 '12 at 2:28
• I don't recommend the 24-bit ADC approach with no amplification. 24-bit ADCs are not for beginners. – Rocketmagnet Aug 24 '12 at 9:26
• Although this post is old, I'd like to add that the tutorial for INA125 has an error which may or may not have been compensated for in code... User powers the INA125 with 5V from the arduino and then utilizes the Vref5 which is 5V. However the datasheet states that in order to use the Vref5 or any of the other Vrefs, you have to be 1.25V above said Vref (ie. V+ must >= 6.25V to use Vref5). Just a word of caution. – user2066639 Jun 6 '13 at 8:42

I would use a Wheatstone Bridge into an instrumentation amplifier like this one. I did this all the time when I was at INDOT and it's a pretty standard configuration for pressure cells and strain gauges, much easier than adding an external ADC.

R4 is your load cell. Be sure to set the instrumentation amplifier gain so it fills the span of the ADC as close as possible. Depending on the load cell, either it will be an open when not loaded, or some fixed resistance. The datasheet will tell you this. That information will be needed to set R3, and determine the gain. I don't know if Arduino defaults to 2.56 or 5V, that's a question for somebody that's used one.

• Can you please add a schematic? For example: I want to connect the Load Cell to 12V and then mV signal to the AD8421 and the output goes do Analog 1 of Arduino. – Tony Aug 24 '12 at 2:37
• Where to buy the AD8421 with international shipping? – Tony Aug 24 '12 at 2:43
• You can use any old instrumentation amplifier available locally, or build your own. That was just an AD part I was looking at for another project. The schematic is basic, and what else you need to add will depend on which instrumentation amplifier you choose. – Matt Young Aug 24 '12 at 3:16
• The load cell is a Wheatstone bridge. R4 doesn't model the load cell. Green and white wires directly to an IA is much better. Your circuit is correct for one strain gage, but not for a load cell – Scott Seidman Sep 23 '12 at 0:53

It's worth mentioning that the HX711 weigh scale sensor interface chip has become quite popular for this purpose, especially in Arduino-type projects as it is widely sold on various inexpensive PCB modules and there is reference Arduino code (trivially ported to other platforms with two spare I/Os) which can get a system up and running in a few minutes. It works with 5v, 3.3v and somewhat lower voltage systems, too.

An HX711-based solution may not be where a design effort should end, but for someone trying to use a load cell for the first time, it could well be a good place to start and gain some practical experience.

In addition to the good and comprehensive answers by Chris Stratton and broadbite, I wanted to detail my solutions to a similar problem. They are cross-posted from Electrical Engineering.

I tried two ways: with a pre-programmed SparkFun OpenScale and with a custom circuit with Arduino Nano. Both ways do without the Sense cables, which serve for more accurate readings. They also use 5V instead of 10V, which reduces precision but seems OK for my application (see Elliot Alderson's answer for an excellent guidance on calculating precision and the difference with accuracy). Both use a serial interface, such as the one from the Arduino app (choose Tools > Port, then Tools > Serial Monitor), and both use components specifically for this purpose of load cells.

# Easy way with SparkFun OpenScale

SparkFun has an OpenScale made specifically for load cells and provides a tutorial to connect to them. You can calibrate the measurements via the serial interface, as well as other settings. The OpenScale is basically an Arduino mounted on a printed circuit board, so you can also modify the open-source code and flash it to the OpenScale, e.g. with the Arduino app.

# Custom way with micro-controller and HX711

The HX711 is an amplifier specifically for load cells (and used in the OpenScale board). I found this tutorial on using an HX711 amplifier and analogue-to-digital converter. It took readings from the load cell and sent to the Arduino nano with 24 bits of depth. See that website for the circuit and for installing the QHX711 library. The result is here:

And I modified the original code to refactor the readings, add a tare button, and include a LCD1602 screen:

// Liquid Crystal Display directions from
#include <LiquidCrystal.h>

// HX711 and load cell directions from
#include <Q2HX711.h>

// Constant variables for display
const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;

// Constant variables for load cell
const byte HX711_DATA_PIN = 7;
const byte HX711_CLOCK_PIN = 8;
const float KNOWN_WEIGHT = 199.0; // calibrated mass to be added
const long AVG_NUM = 10; // amount of averages for each mass measurement

// Constant variables for the pushbutton
const int buttonPin = 10;

// Global variables for load cell
float slope = 0.0;
long tare = 0L;

// Declare HX711 and LCD
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
Q2HX711 hx711(HX711_DATA_PIN, HX711_CLOCK_PIN);

long x = 0L;
for (int i = 0; i < AVG_NUM; i++) {
delay(10);
}
return x / AVG_NUM;
}

void setup() {
// Initialize serial connection at this baud
Serial.begin(9600);

// Initialize LCD
lcd.begin(16, 2);

// initialize the pushbutton pin as an input:
pinMode(buttonPin, INPUT);

// allow load cell and hx711 to settle
delay(1000);

// Take initial reading for tare

// Request known weight
char buffer[16];
dtostrf(KNOWN_WEIGHT, 3, 1, buffer);

Serial.println(buffer);
lcd.setCursor(0, 1);
lcd.print(buffer);
// calibration procedure (mass should be added equal to KNOWN_WEIGHT)
while (hx711.read() < tare + 10000) {
delay(100);
}

// This slope is fixed throughout
slope = KNOWN_WEIGHT / (reading - tare);

Serial.println("Calibration Complete");
lcd.setCursor(0, 0);
lcd.print("Weight (g):      ");
}

void loop() {

// calculating mass based on calibration and linear fit
float mass = (reading - tare) * slope;

// Format string
char weight[6];
dtostrf(mass, 3, 1, weight);
Serial.println(weight);

char buffer[16];
lcd.setCursor(0, 1);
sprintf(buffer, "%16s", weight);
lcd.print(buffer);

// Check if the pushbutton is pressed. If it is, the buttonState is HIGH: