Si usa una celda de carga clasificada para 200 kg de carga completa, con una salida de 2 mV/V y un voltaje de suministro de 5 V, entonces su voltaje de salida será de 10 mV para una carga de 200 kg o de 5 mV para una carga de 100 kg. Un cambio en la carga de 2 kg provocará un cambio de voltaje de 0,1 mV.

Si está digitalizando esto con un ADC perfecto usando un voltaje de referencia de 5V, necesita al menos 16 bits de resolución para ver tal cambio en el voltaje. Esto no sucederá con un Arduino. El ADC de un Arduino tiene 10 bits de resolución, por lo que puede ver cambios de aproximadamente 5 mV. Y ni siquiera hemos hablado de precisión todavía.

Por lo tanto, debe proporcionar una ganancia diferencial de al menos 100X si desea utilizar un Arduino. De lo contrario, necesita encontrar un ADC mejor. También debe asegurarse de que su voltaje de referencia analógico para el ADC y el voltaje de excitación para las celdas de carga sean tan estables y precisos como desea que sean sus mediciones.

Probé de dos maneras: con un SparkFun OpenScale preprogramado y con un circuito personalizado con Arduino Nano. Ambas formas prescinden de los cables Sense, que sirven para lecturas más precisas. También usan 5V en lugar de 10V, lo que reduce la precisión pero parece estar bien para mi aplicación (consulte la respuesta de Elliot Alderson para obtener una excelente guía sobre cómo calcular la precisión y la diferencia con la precisión). Ambos usan una interfaz serial, como la de la aplicación Arduino (elija Tools > Port, luego Tools > Serial Monitor), y ambos usan componentes específicos para este propósito de celdas de carga.

Manera fácil con SparkFun OpenScale

SparkFun tiene un OpenScale hecho específicamente para celdas de carga y proporciona un tutorial para conectarse a ellas. Puede calibrar las medidas a través de la interfaz serial, así como otras configuraciones. OpenScale es básicamente un Arduino montado en una placa de circuito impreso, por lo que también puede modificar el código fuente abierto y actualizarlo en OpenScale, por ejemplo, con la aplicación Arduino.

Modo personalizado con microcontrolador y HX711

El HX711 es un amplificador específico para celdas de carga (y se usa en la placa OpenScale). Encontré este tutorial sobre el uso de un amplificador HX711 y un convertidor de analógico a digital. Tomó lecturas de la celda de carga y las envió al Arduino nano con 24 bits de profundidad. Consulte ese sitio web para ver el circuito y para instalar la biblioteca QHX711. Consulte también este tutorial para la pantalla LCD1602 y este tutorial para agregar un botón pulsador. El resultado está aquí:

Y modifiqué el código original para refactorizar las lecturas, agregar un botón de tara e incluir una pantalla LCD1602:

// Liquid Crystal Display directions from
// https://create.arduino.cc/projecthub/najad/interfacing-lcd1602-with-arduino-764ec4
// www.diyusthad.com
#include <LiquidCrystal.h>

// HX711 and load cell directions from
// https://makersportal.com/blog/2019/5/12/arduino-weighing-scale-with-load-cell-and-hx711
#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 take_reading() {
  long x = 0L;
  for (int i = 0; i < AVG_NUM; i++) {
    delay(10);
    x += hx711.read();
  }
  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
  tare = take_reading();

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

  Serial.print("Add known weight (g): ");
  Serial.println(buffer);
  lcd.print("Add known weight (g)");
  lcd.setCursor(0, 1);
  lcd.print(buffer);
  // calibration procedure (mass should be added equal to KNOWN_WEIGHT)
  while (hx711.read() < tare + 10000) {
    delay(100);
  }
  long reading = take_reading();
  Serial.println(reading);

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

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

void loop() {
  // averaging reading
  long reading = take_reading();

  // 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:
  if (digitalRead(buttonPin)== HIGH) {
    while(digitalRead(buttonPin) == HIGH) {
      delay(100);
    }
    // Lazy debounce
    delay(100);
    tare = reading;
  }
}

Tienes un sistema compuesto por CUATRO resistencias, de un valor aproximado de 400 ohmios cada una.

Aliméntelos con +5 voltios, instale un capacitor de 0.1uF a través de los cables de salida diferencial y conéctelo a las entradas diferenciales de su microcontrolador.

La salida de modo común del puente será de aproximadamente VDD/2 o 2,5 voltios.

Si no tiene entradas diferenciales a la MCU, aún puede conectar las salidas del puente a DOS entradas del ADC y restar los voltajes informados. Se producirán algunos errores.

Para el rechazo de ruido (fuentes de alimentación conmutadas, chispas de conmutadores de motores, transmisores de radio AM, teléfonos celulares, etc.) considere esto

^{simular este circuito : esquema creado con CircuitLab}