Primero, algunos conceptos básicos:

Las celdas de carga (y, en general, las configuraciones de galgas extensiométricas) tienen tres parámetros importantes:

• Capacidad: La cantidad máxima (escala completa) de peso que se puede aplicar a la celda de carga sin dañarla.
• Tensión de excitación recomendada: Tensión a aplicar para generar una diferencia de tensión de salida en el puente de Wheatstone de la celda de carga
• Sensibilidad: cuando aplica una carga igual a la capacidad máxima, la especificación de sensibilidad le indica qué voltaje generará la celda de carga por CADA voltio de voltaje de excitación que aplique

Entonces, una vez que mida el voltaje de la señal de salida de la celda de carga, puede usar las especificaciones anteriores e inferir fácilmente su medida de carga en kg.

Para su configuración:

En el caso de su celda de carga, parece que tendría que aplicar un voltaje de excitación de 12 V en rojo (12 V) y negro (GND). Pero ahora, suponga que conecta directamente los cables de salida de la siguiente manera:

Verde a una entrada del Arduino (y Blanco a GND o a otra entrada para una medida diferencial). Luego, según la especificación de sensibilidad de su celda de carga, puede ver que, incluso para la carga de capacidad máxima, el voltaje de salida sería del orden de solo unos pocos milivoltios.

Por lo tanto, notará en las lecturas de su Arduino que el voltaje de salida en verde y blanco es demasiado pequeño para que el Arduino lo mida con una precisión significativa. Esto se debe a que Arduino tiene un ADC que solo tiene una resolución de 10 bits.

Por lo tanto, está claro que necesita (Opción 1) Hacer que la señal pequeña sea más grande o (Opción 2) Usar una forma más precisa de leer la señal pequeña.

Dos soluciones/enfoques para el problema de medición de celdas de carga:

Entonces, con lo anterior en mente, le sugiero que aborde su proyecto usando una de dos opciones (estos son algunos de los métodos estándar que se usan con las celdas de carga/galgas extensométricas):

• Puede amplificar la señal de voltaje de salida de la celda de carga, LUEGO alimentarla al ADC de Arduino. Puede usar un IC de amplificador de instrumentación preempaquetado como el INA125. Para obtener una comprensión mucho más clara de cómo puede conectar la celda de carga, el INA125 y un Arduino, consulte este proyecto de Arduino , así como este

• O en su lugar, puede omitir toda la etapa de amplificación y simplemente medir con un ADC de alta resolución, que luego conecta con su Arduino. Aquí hay tres opciones para un ADC sigma-delta de 24 bits, o una resolución más baja si no necesita tanta precisión: (1) el LTC2400 para mediciones de un solo extremo de 24 bits, o (2) el LTC2440 para 24 bits. mediciones diferenciales de bit, o (3) el MCP3422/MCP3424 para mediciones diferenciales de 18 bits. Todas esas tres opciones de ADC son bastante sencillas de usar e interactúan con Arduino, especialmente si usa bibliotecas/códigos existentes. Por ejemplo, puede consultar este tutorial para LTC2400 o, en su lugar, este tutorial para LTC2440 o, por último, este tutorial para MCP3422/MCP3424 .

Un par de notas relacionadas:

• Asegúrese de elegir/aplicar un voltaje de excitación que sea lo suficientemente pequeño para que la señal de salida final no dañe su amplificador, su ADC o su Arduino. Asegúrese de medir los voltajes con un DMM en varios puntos a lo largo de las etapas por las que pasa la señal para garantizar que las señales estén dentro de la región segura.
• Para cualquiera de los enfoques anteriores que mencioné, tenga en cuenta que para obtener una alta precisión en su medición, querrá usar lo que se llama una "referencia de voltaje de precisión" cuando aplica el voltaje de excitación. Hay varias opciones disponibles para las referencias de voltaje; avíseme si tiene problemas para encontrar uno para el voltaje deseado.

Usaría un puente de Wheatstone en un amplificador de instrumentación como este. Hice esto todo el tiempo cuando estaba en INDOT y es una configuración bastante estándar para celdas de presión y medidores de tensión, mucho más fácil que agregar un ADC externo.

R4 es su celda de carga. Asegúrese de configurar la ganancia del amplificador de instrumentación para que llene el intervalo del ADC lo más cerca posible. Dependiendo de la celda de carga, estará abierta cuando no esté cargada o alguna resistencia fija. La hoja de datos le dirá esto. Esa información será necesaria para configurar R3 y determinar la ganancia. No sé si Arduino tiene un valor predeterminado de 2,56 o 5 V, esa es una pregunta para alguien que haya usado uno.

Vale la pena mencionar que el chip de interfaz del sensor de escala de peso HX711 se ha vuelto muy popular para este propósito, especialmente en proyectos de tipo Arduino, ya que se vende ampliamente en varios módulos de PCB económicos y hay un código Arduino de referencia (portado trivialmente a otras plataformas con dos repuestos). E/S) que pueden poner en marcha un sistema en unos minutos. También funciona con sistemas de voltaje de 5v, 3.3v y algo más bajos.

Es posible que una solución basada en HX711 no sea el lugar donde debe terminar un esfuerzo de diseño , pero para alguien que intenta usar una celda de carga por primera vez, bien podría ser un buen lugar para comenzar y adquirir algo de experiencia práctica.

Además de las buenas y completas respuestas de Chris Stratton y broadbite, quería detallar mis soluciones a un problema similar. Se contabilizan desde Ingeniería Eléctrica .

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. 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;
  }
}