Tresavis

La bàscula.

ESP8266 NodeMCU amb cèl·lula de càrrega.

Descripció.

Aprenem a crear una bàscula de cuina mitjançant la placa ESP8266 i una cèl·lula de càrrega amb l’amplificador HX711.

Contingut:

Introducció a las cèl·lules de càrrega (Extensòmetres).

La cèl·lula de carrega converteix una força física en senyal elèctrica que és pot mesurar.

Existeixen diferents tipus de cèl·lules de carrega: pneumàtiques hidràuliques i extensòmetres. En aquesta practica estudiem aquestes ultimes.

La cèl·lula de càrrega amb extensòmetres està composta per una barra metàl·lica amb un sensor encolat a la barra que conté quatre extensòmetres connectats en un pont de Wheatstone.

Aquestes cèl·lules de càrrega s’utilitzen per:

Observar si canvia el pes d’un objecte en el temps.

Mesurar el pes d’un objecte.

Detectar la presencia d’un objecte per el seu determinat pes.

Estimar el nivell d’un líquid en un recipient.

Amplificador HX711 i les connexions.

La senyal produïda per el sensor és molt petita, necessitem amplificar-la, utilitzem el amplificador HX711. El amplificador el connectarem al micro-controlador ESP8266.

Les connexions son com les que segueixen:

Construcció de la bascula.

En el nostre cas ja l’hem comprat amb les peces ja muntades.

En altres casos les peces venen sense muntar. Les dues planxes de plàstic, la barra metàl·lica i el amplificador.

Llibreria HX711.

Fem servir la llibreria HX711 library by Bodgam Necula. I com editor de codi utilitzem el IDE d’Arduino.

Per instal·lar la llibreria ho fem amb el gestor de biblioteques:

Anar a Eines / Gestor les biblioteques...

Escrivim: HX711 library:

Calibratge de l’escala de pesos.

Ja tenim totes les connexions fetes, com mostra la següent imatge:

Tenim que obtenir el factor de calibratge, aquest factor pot variar del obtingut per nosaltres.

Preparem un pes amb un pes conegut, nosaltres agafem un paquet d’arròs de 1000 grams, pot ser qualsevol pes.

Carreguem el següent codi al micro-controlador. Aquest codi és tret de la documentació de la llibreria:

/**
 * Complete project details at https://RandomNerdTutorials.com/esp8266-load-cell-hx711/
 * 
 * HX711 library for Arduino - example file
 * https://github.com/bogde/HX711
 *
 * MIT License
 * (c) 2018 Bogdan Necula
 *
**/

#include <Arduino.h>
#include "HX711.h"

// HX711 circuit wiring
const int LOADCELL_DOUT_PIN = 12;
const int LOADCELL_SCK_PIN = 13;

HX711 scale;

void setup() {
  Serial.begin(115200);
  Serial.println("HX711 Demo");
  Serial.println("Initializing the scale");

  scale.begin(LOADCELL_DOUT_PIN, LOADCELL_SCK_PIN);

  Serial.println("Before setting up the scale:");
  Serial.print("read: \t\t");
  Serial.println(scale.read());      // print a raw reading from the ADC

  Serial.print("read average: \t\t");
  Serial.println(scale.read_average(20));   // print the average of 20 readings from the ADC

  Serial.print("get value: \t\t");
  Serial.println(scale.get_value(5));   // print the average of 5 readings from the ADC minus the tare weight (not set yet)

  Serial.print("get units: \t\t");
  Serial.println(scale.get_units(5), 1);  // print the average of 5 readings from the ADC minus tare weight (not set) divided
            // by the SCALE parameter (not set yet)
            
  scale.set_scale(-478.507);
  //scale.set_scale(-471.497);                      // this value is obtained by calibrating the scale with known weights; see the README for details
  scale.tare();               // reset the scale to 0

  Serial.println("After setting up the scale:");

  Serial.print("read: \t\t");
  Serial.println(scale.read());                 // print a raw reading from the ADC

  Serial.print("read average: \t\t");
  Serial.println(scale.read_average(20));       // print the average of 20 readings from the ADC

  Serial.print("get value: \t\t");
  Serial.println(scale.get_value(5));   // print the average of 5 readings from the ADC minus the tare weight, set with tare()

  Serial.print("get units: \t\t");
  Serial.println(scale.get_units(5), 1);        // print the average of 5 readings from the ADC minus tare weight, divided
            // by the SCALE parameter set with set_scale

  Serial.println("Readings:");
}

void loop() {
  Serial.print("one reading:\t");
  Serial.print(scale.get_units(), 1);
  Serial.print("\t| average:\t");
  Serial.println(scale.get_units(10), 5);

  scale.power_down();             // put the ADC in sleep mode
  delay(5000);
  scale.power_up();
}

El resultat és: 438417

Factor de calibratge= resultat/pes conegut= 438417/1000= 438.417

Guardem aquest factor perquè el necessitarem posteriorment per el codi definitiu.

Circuit definitiu.

Afegim al circuit anterior un display OLED per mostrar el resultat de la pesada. També afegim un botó per obtenir la tara.

Per instal·lar la llibreria ho fem amb el gestor de biblioteques:

Anar a Eines / Gestor les biblioteques...

Escrivim: HX711 library:

Components necessaris i esquema elèctric.

Micro-controlador ESP8266
Cèl·lula  de càrrega amb amplificador HX711
Display OLED 128x64
Botó
Resistència de 10 k Ohms
Protoboard i cablejat.
Ide d’Arduino

         

Esquema elèctric.

Mes llibreries.

La llibreria HX711 per el amplificador ja l’hem instal·lat anteriorment.

Pushbutton library by Polulu:

Aquesta llibreria controla les pressions sobre el botó i els seus rebots.

Per instal·lar-la ho fem amb el gestor de biblioteques:
Anar a Eines / Gestor les biblioteques...
Escrivim: Pushbutton.             
         

Instal·lem la llibreria firmada per Polulu.

Oled llibreria:

Per instal·lar-la ho fem amb el gestor de biblioteques:
Anar a Eines / Gestor les biblioteques...
Escrivim: U8g2.             
         

Instal·lem la llibreria de Oliver.

Codi definitiu.

//Recordeu que és té que posar el factor de calibratge obtingut anteriorment.

// Complete project details at https://RandomNerdTutorials.com/esp8266-load-cell-hx711/
// Library HX711 by Bogdan Necula: https://github.com/bogde/HX711
// Library: pushbutton by polulu: https://github.com/pololu/pushbutton-arduino
// Library: U8g2 by Oliver per el display Oled
#include <Arduino.h>
#include "HX711.h"
#include <Wire.h>

#include <U8g2lib.h>    //oled
#include <Pushbutton.h>

// HX711 circuit wiring
const int LOADCELL_DOUT_PIN = 12;
const int LOADCELL_SCK_PIN = 13;

HX711 scale;
float reading;
float lastReading;
//REPLACE WITH YOUR CALIBRATION FACTOR
#define CALIBRATION_FACTOR 438.417

//OLED Display
// Definir constants de la pantalla oled
#define AMPLE_PANTALLA 128 //pantalla OLED
#define ALT_PANTALLA 64 //pantalla OLED
// Objecte de la clase U8g2: u8g2
U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, U8X8_PIN_NONE);

//////metode que prepara la pantalla////////////
void u8g2_prepare() {
  u8g2.setFont(u8g2_font_6x10_tf);
  u8g2.setFontRefHeightExtendedText();
  u8g2.setDrawColor(1);
  u8g2.setFontPosTop();
  u8g2.setFontDirection(0);
}

//Button
#define BUTTON_PIN 14
Pushbutton button(BUTTON_PIN);



void setup() {
  Serial.begin(115200);
// Iniciar pantalla OLED
  u8g2.begin();           
  u8g2.clearBuffer();
  u8g2_prepare();
  //delay(2000);
  //escribim en pantalla    
  u8g2.drawStr(5,2,"Grams:"); 
  u8g2.sendBuffer();
  Serial.println("Initializing the scale");
  scale.begin(LOADCELL_DOUT_PIN, LOADCELL_SCK_PIN);

  scale.set_scale(CALIBRATION_FACTOR);   // this value is obtained by calibrating the scale with known weights
  scale.tare();               // reset the scale to 0
}

void loop() {
  
  if (button.getSingleDebouncedPress()){
    Serial.print("tare...");
    scale.tare();
  }
  u8g2_prepare();
  if (scale.wait_ready_timeout(200)) {
    reading = round(scale.get_units());
    //convertim reading de float a String
    //el display OLed només escriu Strings
    char readingStr[8];
    dtostrf(reading, 6, 2, readingStr);
    Serial.print("Weight: ");
    Serial.println(reading);
    if (reading != lastReading){
     u8g2.clearBuffer();
      u8g2.drawStr(5,2,"Grams:"); 
      u8g2.drawStr(60,40,readingStr);
      u8g2.sendBuffer();
    }
    lastReading = reading;
  }
  else {
    Serial.println("Oled not found.");
  }
}

Com funciona el codi.

Creem una instancia de la classe HX711:

HX711 scale;           
         

Guardem les lectures del pes en les variables:

float reading;
float lastReading;           
         

Necessitem les dues variables per actualitzar la pantalla Oled.

Posem el nostre factor de calibratge:

#define CALIBRATION_FACTOR 438.417
          

Preparem la pantalla Oled:

//////metode que prepara la pantalla////////////
void u8g2_prepare() {
  u8g2.setFont(u8g2_font_6x10_tf);
  u8g2.setFontRefHeightExtendedText();
  u8g2.setDrawColor(1);
  u8g2.setFontPosTop();
  u8g2.setFontDirection(0);
}              
          

Definim el GPIO per el botó i creem l’objecte button de la classe Pushbutton:

#define BUTTON_PIN 14
Pushbutton button(BUTTON_PIN);              
          

En el setup(), primer inicialitzem la pantalla Oled:

// Iniciar pantalla OLED
  u8g2.begin();           
  u8g2.clearBuffer();
  u8g2_prepare();
  //delay(2000);
  //escribim en pantalla la capsalera    
  u8g2.drawStr(5,2,"Grams:"); 
  u8g2.sendBuffer();             
          

Inicialitzem la cèl·lula de càrrega:

Serial.println("Initializing the scale");
scale.begin(LOADCELL_DOUT_PIN, LOADCELL_SCK_PIN);

scale.set_scale(CALIBRATION_FACTOR);   // this value is obtained by calibrating the scale with known weights
scale.tare();               // reset the scale to 0              
          

En el loop(). La llibreria Pushbutton espera per el event del botó que interessa al desenvolupador, en el nostre cas: prem. Al prémer el botó crida a la funció de Scale tare().

if (button.getSingleDebouncedPress()){
  Serial.print("tare...");
  scale.tare();
}             
          

HX711 té un mètode per no bloquejar les lectures dels pesos. Defineix un màxim de timeout.

if (scale.wait_ready_timeout(200)) {
  reading = round(scale.get_units());
  Serial.print("Weight: ");
  Serial.println(reading);
}              
          

En el loop tenim constantment noves lectures, si canvia la mesura del pes, les escrivim en la pantalla Oled.

//convertim reading de float a String
    //el display OLed només escriu Strings
    char readingStr[8];
    dtostrf(reading, 6, 2, readingStr);
    Serial.print("Weight: ");
    Serial.println(reading);
    if (reading != lastReading){
     u8g2.clearBuffer();
      u8g2.drawStr(5,2,"Grams:"); 
      u8g2.drawStr(60,40,readingStr);
      u8g2.sendBuffer();
    }
    lastReading = reading;
  }              
          

Demostració.

Després de carregar el codi a la placa ESP8266, podem veure la lectura de la pesada en la pantalla OLED. Podem obtenir la tara amb el botó.

Bibliografia.

Ens hem basat en la pàgina de randomnerdtutorials:

Per codificar la pantalla OLED hem visitat la pàgina de TresAvis: