HX711 es poco estable

Buenas, es el primer tema que escribo así que si hay alguna cosa mal por favor decirme para poder cambiarla, dicho esto:

El problema reside en que estoy intentando hacer una bascula que cuente las unidades, pongo a continuación el código simplificado de esta parte,:


//Pantalla OLED
#include <Wire.h>
#include <Adafruit_GFX.h>      // libreria para pantallas graficas OLED
#include <Adafruit_SSD1306.h>  // libreria para controlador SSD1306

#define ANCHO 128  // reemplaza ocurrencia de ANCHO por 128
#define ALTO 64    // reemplaza ocurrencia de ALTO por 64

#define OLED_RESET 4                                    // necesario por la libreria pero no usado
Adafruit_SSD1306 oled(ANCHO, ALTO, &Wire, OLED_RESET);  // crea objeto

int Menu = 2;
int MenuAnt = 0;
int estadoA;
int estadoPrevioA;

String NombreMenu = "Inicial";

//Botones
const int P6 = 16;
const int P5 = 17;
const int P4 = 18;
const int P3 = 19;
const int P2 = 4;
const int P1 = 15;

boolean buttonState[7] = { 0, 0, 0, 0, 0, 0, 0 };

boolean flanco[7] = { 0, 1, 1, 1, 1, 1, 1 };

float reading = 0;
float PesoUnitario = 0;

//HX711
#include "HX711.h"
const int LOADCELL_DOUT_PIN = 25;
const int LOADCELL_SCK_PIN = 26;
HX711 balanza;

void setup() {

  //Comunicaciones
  Serial.begin(9600);

  pinMode(P1, INPUT);
  pinMode(P2, INPUT);
  pinMode(P3, INPUT);
  pinMode(P4, INPUT);
  pinMode(P5, INPUT);
  pinMode(P6, INPUT);

  //HX711
  balanza.begin(LOADCELL_DOUT_PIN, LOADCELL_SCK_PIN);
  balanza.set_scale(1811.59);
  balanza.tare(10);

  //OLED
  Wire.begin();                            // inicializa bus I2C
  oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);  // inicializa pantalla con direccion 0x3C

  oled.clearDisplay();
  oled.display();
}

void loop() {

  if (MenuAnt != Menu) {

    if (Menu == 0) {

      NombreMenu = "Inicial";
      MenuAnt = Menu;
    }

    if (Menu == 1) {

      NombreMenu = "Provedores";
      flanco[0] = 0;
      MenuAnt = Menu;
    }

    if (Menu == 2) {

      NombreMenu = "Bascula";
      flanco[0] = 0;
      MenuAnt = Menu;
    }

    Serial.print("Menu: ");
    Serial.println(Menu);
    Serial.print("MenuAnt: ");
    Serial.println(MenuAnt);
    Serial.print("NombreMenu: ");
    Serial.println(NombreMenu);
  }

  buttonState[1] = digitalRead(P1);
  buttonState[2] = digitalRead(P2);
  buttonState[3] = digitalRead(P3);
  buttonState[4] = digitalRead(P4);
  buttonState[5] = digitalRead(P5);
  buttonState[6] = digitalRead(P6);


  if (Menu == 2) {
    if (flanco[0] == 0) {
      oled.clearDisplay();
      oled.setTextColor(WHITE);
      oled.setCursor(0, 0);
      oled.setTextSize(1);
      oled.print("PROTOTIPO HCH MENU:");
      oled.print(Menu);
      oled.setCursor(10, 10);
      oled.setTextSize(1);
      oled.print(NombreMenu);
      oled.setTextColor(WHITE, BLACK);
      oled.setTextSize(1);
      flanco[0] = 1;
      oled.display();
    }
    reading = balanza.get_units(5);

    oled.setTextColor(WHITE, BLACK);
    oled.setTextSize(1);
    oled.setCursor(5, 25);
    oled.print("Peso actual:");
    oled.print(-reading);
    oled.print("g ");
    oled.setCursor(5, 35);
    oled.print("Peso Ud:");
    oled.print(-PesoUnitario);
    oled.print("g ");
    oled.setTextSize(2);
    oled.setCursor(5, 45);
    oled.print("Cant:");
    oled.print(reading / PesoUnitario);
    oled.print("  ");
    oled.display();
    Serial.println(-reading);
    //Botones
    if (buttonState[1] != flanco[1]) {
      if (buttonState[1] == HIGH) {

        oled.setTextSize(1);
        oled.setTextColor(WHITE, BLACK);
        oled.setCursor(55, 10);
        oled.print("Tarando...");
        oled.display();

        balanza.tare(232);

        oled.setTextSize(1);
        oled.setTextColor(WHITE, BLACK);
        oled.setCursor(55, 10);
        oled.print("Tarado    ");
        oled.display();
      }
    }

    if (buttonState[2] != flanco[2]) {
      if (buttonState[2] == HIGH) {
        PesoUnitario = balanza.get_units(232);
      }
    }

    if (buttonState[3] != flanco[3]) {
      if (buttonState[3] == HIGH) {
        PesoUnitario = balanza.get_units(5);
      }
    }
  }

  flanco[1] = buttonState[1];
  flanco[2] = buttonState[2];
  flanco[3] = buttonState[3];
  flanco[4] = buttonState[4];
  flanco[5] = buttonState[5];
  flanco[6] = buttonState[6];
}

La cosa es que la lectura varia mucho y no se mantiene estable, incluso aunque lo ponga con el balanza.get_units(232), que es el máximo de lecturas que puedes hacer.

Estoy usando un ESP 32 de AzDelivery y un conjunto de HX711 y celda de 1Kg.

Si alguien me puede dar alguna solución estaría muy agradecido, por que ahora mismo estoy bastante perdido y no se si es un problema de los componentes o si hay algo mal en mi código.

Muchas gracias de antemano.

Fíjate si te sirve de ayuda

el hx711 es un ADC de 24 bits. Eso requiere estabilidad de fuente.
Como lo alimentas?


Esta es la manera correcta con un ESP32
Mira el tutorial a ver si te ayuda.

Aparte de lo dicho por los compañeros, el HX711 parece ser algo sensible a las perturbaciones electro-magnéticas ya que algunos VENDEDORES lo suministran para montarlos bajo una pequeña caja de Faraday. Yo tendría esas perturbaciones en consideración.

Muchas gracias por las respuestas a todos, voy a ir probando cosas y a ver si alguna soluciona el problema, de momento lo único que he visto distinto es que estaba alimentando a la celda con 5V en vez de los 3.3V de la imagen que ha pasado @Surbyte , pero me leeré todo bien a ver si puedo encontrar el fallo, ya que eso no ha cambiado demasiado.

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.