Arduino avec cellule de charge et amplificateur HX711 (balance numérique)

Arduino avec cellule de charge et amplificateur HX711 (balance numérique)

Dans ce guide, vous apprendrez à créer une balance numérique avec l’Arduino à l’aide d’une cellule de charge et de l’amplificateur HX711. Tout d’abord, vous apprendrez à câbler la cellule de charge et l’amplificateur HX711 à l’Arduino pour construire une balance. Ensuite, nous vous montrerons comment calibrer la balance, et un exemple simple pour obtenir le poids des objets. Plus tard, nous ajouterons également un écran pour afficher les mesures et un bouton pour tarer la balance.

Balance numérique Arduino avec cellule de charge et amplificateur HX711

Table des matières

Dans ce didacticiel, nous aborderons les sujets suivants :

Présentation des cellules de charge

Une cellule de charge convertit une force en un signal électrique qui peut être mesuré. Le signal électrique change proportionnellement à la force appliquée. Il existe différents types de cellules de charge : jauges de contrainte, pneumatiques et hydrauliques. Dans ce didacticiel, nous aborderons les cellules de charge à jauge de contrainte.

carte de composant de cellule de charge

Les cellules de charge à jauge de contrainte sont composées d’une barre métallique avec des jauges de contrainte attachées (sous la colle blanche dans l’image ci-dessus). Une jauge de contrainte est un capteur électrique qui mesure la force ou la contrainte exercée sur un objet. La résistance des jauges de contrainte varie lorsqu’une force externe est appliquée à un objet, ce qui entraîne une déformation de la forme de l’objet (dans ce cas, la barre métallique). La résistance de la jauge de contrainte est proportionnelle à la charge appliquée, ce qui permet de calculer le poids des objets.

Habituellement, les cellules de charge ont quatre jauges de contrainte connectées dans un pont de Wheatstone (comme indiqué ci-dessous) qui nous permettent d’obtenir des mesures de résistance précises. Pour une explication plus détaillée du fonctionnement des jauges de contrainte, lire cet article.

pont de wheatstone de cellule de charge

Les fils provenant de la cellule de charge ont généralement les couleurs suivantes :

  • Rouge : CCV (E+)
  • Noir : GND (E-)
  • Blanc : Sortie – (A-)
  • Vert : Sortie + (A+)

Applications

Les cellules de charge à jauge de contrainte peuvent être utilisées dans une grande variété d’applications. Par exemple:

  • vérifier si le poids d’un objet change avec le temps ;
  • mesurer le poids d’un objet;
  • détecter la présence d’un objet ;
  • estimer le niveau de liquide d’un récipient ;
  • etc.

Étant donné que les changements de contrainte lors de la pondération d’objets sont si faibles, nous avons besoin d’un amplificateur. La cellule de charge que nous utilisons est généralement vendue avec un amplificateur HX711. Donc, c’est l’amplificateur que nous allons utiliser.

Amplificateur HX711

L’amplificateur HX711 est une carte de dérivation qui vous permet de lire facilement les cellules de charge pour mesurer le poids. Vous câblez les fils de la cellule de charge d’un côté et le microcontrôleur de l’autre côté. Le HX711 communique avec le microcontrôleur à l’aide d’une interface à deux fils (horloge et données).

Amplificateur HX711

Vous devez souder des broches d’en-tête sur les broches GND, DT, SCK et VCC pour vous connecter à l’Arduino. J’ai soudé les fils de la cellule de charge directement aux broches E+, E-, A- et A+. Les fils de la cellule de charge étaient très fins et fragiles, faites attention lors de la soudure pour ne pas endommager les fils.

Amplificateur HX711 soudé

Pour plus d’informations sur l’amplificateur HX711, vous pouvez consulter la fiche technique HX711.

Configuration de la cellule de charge

Notre kit de cellule de charge est livré avec deux plaques en acrylique et quelques vis pour configurer la cellule de charge comme une balance. Vous pouvez utiliser des plaques de bois ou imprimer en 3D vos propres plaques.

paquet d'amplificateur de cellule de charge hx711

Vous devez fixer les plaques à la cellule de charge de manière à créer une tension entre les extrémités opposées de la barre métallique. La plaque inférieure contient la cellule de charge et la plaque supérieure est l’endroit où vous placez les objets.

balance de configuration de cellule de charge

La figure suivante montre à quoi ressemble ma cellule de charge avec les plaques acryliques.

échelle de cellule de charge

Où acheter une cellule de charge avec HX711 ?

Vous pouvez vérifier la cellule de charge avec le HX711 sur Maker Advisor pour trouver le meilleur prix (avec ou sans plaques acryliques incluses). Il existe des cellules de charge avec différentes plages de mesure. Les poids maximums les plus courants sont de 1 kg, 5 kg, 10 kg et 20 kg.

Amplificateur de cellule de charge HX711

Vous pouvez utiliser les liens précédents ou accéder directement à MakerAdvisor.com/tools pour trouver toutes les pièces pour vos projets au meilleur prix !

1679845156 241 Arduino avec cellule de charge et amplificateur HX711 balance numerique

Câblage de la cellule de charge et de l’amplificateur HX711 à l’Arduino

L’amplificateur HX711 communique via une interface à deux fils. Vous pouvez le connecter à n’importe quelle broche numérique de votre carte Arduino. Nous connectons la broche de données (DT) à la broche 2 et la broche d’horloge (CLK) à la broche 3.

Suivez le tableau suivant ou le diagramme schématique pour câbler la cellule de charge à la carte Arduino.

Cellule de charge HX711 HX711 Arduino
Rouge (Mi+) Mi+ Terre Terre
Noir (E-) E- DT Broche 2
Blanc (A-) UN- SCK Broche 3
Vert (A+) A+ VCC 5V
Schéma de câblage Arduino avec cellule de charge HX711

Installation de la bibliothèque HX711

Il existe plusieurs bibliothèques différentes pour obtenir des mesures à partir d’une cellule de charge à l’aide de l’amplificateur HX711. Nous utiliserons le Bibliothèque HX711 par bodge. Il est compatible avec les ESP32, ESP8266 et Arduino.

EDI Arduino

Suivez les instructions suivantes pour installer la bibliothèque si vous utilisez Arduino IDE.

  1. Ouvrez l’IDE Arduino et accédez à Sketch> Inclure la bibliothèque> Gérer les bibliothèques.
  2. Recherchez « HX711 Arduino Library » et installez la bibliothèque de Bogdan Necula.
Installer la bibliothèque Bogdan HX711

Étalonnage de la balance (Arduino avec cellule de charge)

À ce stade, nous supposons que vous avez câblé la cellule de charge à l’amplificateur HX711 et l’amplificateur à la carte Arduino. Vous devez également avoir configuré votre balance (deux plaques câblées aux extrémités opposées sur la cellule de charge) et avoir installé la bibliothèque HX711.

Avant d’obtenir le poids des objets, vous devez d’abord étalonner votre cellule de charge en obtenant le facteur d’étalonnage. Votre facteur d’étalonnage sera différent du mien, vous ne devriez donc pas ignorer cette section.

1) Préparez un objet avec un poids connu. J’ai utilisé ma balance de cuisine et pesé un verre d’eau (107 g).

2) Téléchargez le code suivant sur votre carte Arduino. Nous avons écrit le code suivant en tenant compte des instructions pour calibrer la cellule de charge fournies par la documentation de la bibliothèque.

/*
  Rui Santos
  Complete project details at https://Raspberryme.com/arduino-load-cell-hx711/
  
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files.
  
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
*/

// Calibrating the load cell
#include "HX711.h"

// HX711 circuit wiring
const int LOADCELL_DOUT_PIN = 2;
const int LOADCELL_SCK_PIN = 3;

HX711 scale;

void setup() {
  Serial.begin(57600);
  scale.begin(LOADCELL_DOUT_PIN, LOADCELL_SCK_PIN);
}

void loop() {

  if (scale.is_ready()) {
    scale.set_scale();    
    Serial.println("Tare... remove any weights from the scale.");
    delay(5000);
    scale.tare();
    Serial.println("Tare done...");
    Serial.print("Place a known weight on the scale...");
    delay(5000);
    long reading = scale.get_units(10);
    Serial.print("Result: ");
    Serial.println(reading);
  } 
  else {
    Serial.println("HX711 not found.");
  }
  delay(1000);
}

//calibration factor will be the (reading)/(known weight)

Afficher le code brut

3) Après le téléchargement, ouvrez le moniteur série à un débit en bauds de 57600, puis appuyez sur le bouton RESET intégré à l’Arduino.

4) Suivez les instructions sur le moniteur série : retirez tous les poids de la balance (elle se tarera automatiquement). Ensuite, placez un objet avec un poids connu sur la balance et attendez jusqu’à ce que vous obteniez une valeur.

5) Calculez votre facteur d’étalonnage à l’aide de la formule :

calibration factor = (reading)/(known weight)
Calibrer le moniteur série Arduino de la cellule de charge

Dans notre cas, la lecture est -49171. Le poids connu est de 107g, donc notre facteur de calibrage sera : -49171/107 = -459.542.

calibration factor = -49171/107 = -459.542

Enregistrez votre facteur d’étalonnage car vous en aurez besoin plus tard. Le vôtre sera différent du nôtre.

Parce que la sortie du capteur est proportionnelle à la force appliquée à la cellule de charge, vous pouvez calibrer votre balance en utilisant n’importe quelle unité qui vous convient. J’ai utilisé des grammes, mais vous pouvez utiliser des livres, des kilogrammes ou même des morceaux de nourriture pour chat (comme dans cette vidéo d’Andreas Spiess).


Objets de pondération (Arduino avec cellule de charge)

Maintenant que vous connaissez votre facteur d’étalonnage, vous pouvez utiliser votre cellule de charge pour peser des objets. Commencez par peser des objets avec un poids connu et répétez le processus d’étalonnage si les valeurs ne sont pas exactes.

Copiez le code suivant dans votre IDE Arduino. Avant de le télécharger sur votre carte, n’oubliez pas d’insérer votre facteur d’étalonnage à la ligne 43/44 du code. Le code suivant est le exemple fourni par la bibliothèque qui démontre l’utilisation de la plupart de ses fonctions.

/**
 * Complete project details at https://Raspberryme.com/arduino-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 = 2;
const int LOADCELL_SCK_PIN = 3;

HX711 scale;

void setup() {
  Serial.begin(57600);
  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(-459.542);
  //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);

  delay(5000);
}

Afficher le code brut

Comment fonctionne le code

Commencez par inclure la bibliothèque requise.

#include "HX711.h"

Les lignes suivantes définissent les broches que vous utiliserez pour vous connecter à l’amplificateur HX711. Nous avons choisi les broches 2 et 3. Vous pouvez utiliser n’importe quelle autre broche numérique.

const int LOADCELL_DOUT_PIN = 2;
const int LOADCELL_SCK_PIN = 3;

Ensuite, créez une instance de la bibliothèque HX711 appelée échelle que vous utiliserez plus tard pour obtenir les mesures.

HX711 scale;

installation()

Dans le setup(), initialisez le moniteur série.

Serial.begin(57600);

Initialisez la cellule de pesée en appelant la méthode begin() sur l’objet balance et en passant les broches numériques comme arguments.

scale.begin(LOADCELL_DOUT_PIN, LOADCELL_SCK_PIN);

Ensuite, il appelle plusieurs méthodes que vous pouvez utiliser pour obtenir des lectures à l’aide de la bibliothèque.

  • read() : obtient une lecture brute du capteur
  • read_average(nombre de lectures) : obtient la moyenne du dernier nombre défini de lectures
  • get_value(nombre de lectures) : obtient la moyenne du dernier nombre défini de lectures moins la tare ;
  • get_units(nombre de lectures) : obtient la moyenne du dernier nombre défini de lectures moins le poids de la tare divisé par le facteur d’étalonnage — cela produira une lecture dans les unités souhaitées.
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)

Dans la ligne suivante, n’oubliez pas d’insérer votre facteur d’étalonnage. Il utilise la méthode set_scale().

scale.set_scale(INSERT YOUR CALIBRATION FACTOR)

Ensuite, appelez la méthode tare() pour tarer la balance.

scale.tare();               // reset the scale to 0

Après cette configuration, la balance devrait être prête à obtenir des lectures précises dans l’unité souhaitée. L’exemple appelle les mêmes méthodes précédentes afin que vous puissiez voir la différence avant et après la configuration de l’échelle.

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

boucle()

Dans la boucle(), l’exemple appelle la méthode get_units() de deux manières différentes : pour obtenir une seule lecture (sans aucun paramètre) et pour obtenir la moyenne des 10 dernières lectures.

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

Il arrête l’ADC qui lit le capteur en utilisant la méthode power_down(). Ensuite, il attend 5 secondes, allume l’ADC (power_up()) et la boucle() se répète. Ainsi, vous obtiendrez de nouvelles lectures sur le moniteur série toutes les 5 secondes.

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

Manifestation

Téléchargez le code sur votre carte Arduino. Après le téléchargement, ouvrez le moniteur série à un débit en bauds de 115 200.

Laissez le code s’exécuter quelques secondes afin qu’il ait le temps de configurer la balance (vous verrez le message sur le moniteur série). Ensuite, placez n’importe quel objet sur la balance pour le mesurer et vous obtiendrez les résultats sur le moniteur série.

Démonstration de la cellule de charge Arduino IDE Serial Monitor

J’ai expérimenté plusieurs objets et les ai comparés à la valeur de ma balance de cuisine, et les résultats étaient les mêmes. Donc, je peux dire que ma balance Arduino est au moins aussi précise que ma balance de cuisine.


Balance numérique avec Arduino

Dans cette section, nous allons créer une balance numérique simple avec l’Arduino. Nous ajouterons un écran OLED pour afficher les résultats et un bouton poussoir pour tarer la balance.

Balance numérique Arduino

Pièces requises

Voici une liste des pièces nécessaires pour ce projet :

Diagramme schématique

Ajoutez un écran OLED et un bouton poussoir à votre circuit précédent sur les broches suivantes :

Écran OLED Arduino
VCC 3,3 V ou 5 V*
Terre Terre
SDA A4
SCL A5

*connecter à 3,3V ou 5V selon le modèle.

Vous n’êtes pas familier avec l’écran OLED ? Lire : Guide pour l’affichage I2C OLED avec Arduino.

Câblez le bouton-poussoir via une résistance pull-down de 10kOhm à la broche 4. L’autre fil du bouton-poussoir doit être connecté à 5V. Vous pouvez utiliser n’importe quelle autre broche numérique Arduino.

Vous pouvez suivre le diagramme schématique suivant pour câbler vos pièces.

Schéma de principe de la balance numérique ESP8266

Balance numérique Arduino – Code

Pour plus de simplicité, nous allons gérer le bouton-poussoir à l’aide d’une bibliothèque simple qui détecte les pressions sur les boutons avec anti-rebond (nous n’avons donc pas à nous en soucier dans notre code). Pour écrire sur l’écran OLED, nous utiliserons le Adafruit SSD1306 et Adafruit GFX bibliothèques.

Bibliothèque de boutons-poussoirs

Il existe de nombreuses bibliothèques avec de nombreuses fonctionnalités pour gérer les boutons-poussoirs. Nous utiliserons le bibliothèque de boutons poussoirs par polulu. C’est une bibliothèque simple mais qui contient tout ce dont nous avons besoin pour ce projet. Dans votre IDE Arduino, accédez à Sketch> Inclure la bibliothèque> Gérer les bibliothèques et recherchez « bouton-poussoir ». Installez la bibliothèque de boutons-poussoirs de polulu.

Bibliothèque de boutons-poussoirs Arduino IDE Polulu

Alternativement, si vous ne souhaitez pas utiliser la bibliothèque, vous pouvez ajouter vous-même le code anti-rebond (ce qui n’est pas difficile). Pour un exemple de code anti-rebond, dans l’IDE Arduino, vous pouvez accéder à Fichier > Exemples > Numérique > Anti-rebond.

Bibliothèques OLED

Nous utiliserons les bibliothèques suivantes pour contrôler l’affichage OLED. Assurez-vous que ces bibliothèques sont installées :

Vous pouvez installer les bibliothèques à l’aide du gestionnaire de bibliothèque Arduino. Accédez à Esquisse > Inclure la bibliothèque > Gérer les bibliothèques et recherchez le nom de la bibliothèque.

Code

Copiez le code suivant dans votre IDE Arduino. Avant de le télécharger sur la carte Arduino, vous devez insérer votre facteur d’étalonnage (obtenu précédemment).

/*
  Rui Santos
  Complete project details at https://Raspberryme.com/arduino-load-cell-hx711/
  
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files.
  
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
*/

// Library HX711 by Bogdan Necula: https://github.com/bogde/HX711
// Library: pushbutton by polulu: https://github.com/pololu/pushbutton-arduino

#include "HX711.h"
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <Pushbutton.h>

// HX711 circuit wiring
const int LOADCELL_DOUT_PIN = 2;
const int LOADCELL_SCK_PIN = 3;

HX711 scale;
int reading;
int lastReading;
//REPLACE WITH YOUR CALIBRATION FACTOR
#define CALIBRATION_FACTOR -476.592

//OLED Display
#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 64 // OLED display height, in pixels

// Declaration for an SSD1306 display connected to I2C (SDA, SCL pins)
#define OLED_RESET     -1 // Reset pin # (or -1 if sharing Arduino reset pin)
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

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

void displayWeight(int weight){
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(WHITE);
  display.setCursor(0, 10);
  // Display static text
  display.println("Weight:");
  display.display();
  display.setCursor(0, 30);
  display.setTextSize(2);
  display.print(weight);
  display.print(" ");
  display.print("g");
  display.display();  
}

void setup() {
  Serial.begin(57200);

  if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) { 
    Serial.println(F("SSD1306 allocation failed"));
    for(;;);
  }
  delay(2000);
  display.clearDisplay();
  display.setTextColor(WHITE);
  
  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();
  }
  
  if (scale.wait_ready_timeout(200)) {
    reading = round(scale.get_units());
    Serial.print("Weight: ");
    Serial.println(reading);
    if (reading != lastReading){
      displayWeight(reading); 
    }
    lastReading = reading;
  }
  else {
    Serial.println("HX711 not found.");
  }
}

Afficher le code brut

Comment fonctionne le code

Commencez par inclure les bibliothèques requises :

#include "HX711.h"
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <Pushbutton.h>

Définissez les broches pour le HX711 (cellule de charge) – nous utilisons la même chose que les exemples précédents :

// HX711 circuit wiring
const int LOADCELL_DOUT_PIN = 2;
const int LOADCELL_SCK_PIN = 3;

Créez une instance HX711 appelée scale.

HX711 scale;

Les variables suivantes contiendront la lecture de poids actuelle et la dernière lecture de poids. Nous ne voulons mettre à jour l’écran OLED qu’en cas de nouvelle lecture, c’est pourquoi nous avons besoin de ces deux variables. De plus, nous ne voulons pas mesurer des décimales de grammes, ce qui rendrait l’échelle trop sensible pour notre application. C’est pourquoi ces variables sont des nombres entiers. Si vous avez besoin de décimales dans vos mesures, vous pouvez définir des variables flottantes à la place.

int reading;
int lastReading;

N’oubliez pas de remplacer la valeur suivante par votre facteur d’étalonnage. Dans mon cas, cette ligne de code ressemble à ceci (ma valeur est négative):

#define CALIBRATION_FACTOR -459.542

Ensuite, nous devons définir la largeur et la hauteur OLED :

#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 64 // OLED display height, in pixels

Et créez une instance de la bibliothèque Adafruit_SSD1306 appelée display.

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

Définissez le GPIO que vous utiliserez pour lire le bouton et créez un objet Pushbutton appelé bouton sur cette broche.

#define BUTTON_PIN 4
Pushbutton button(BUTTON_PIN);

fonction displayWeight()

Nous avons créé une fonction appelée displayWeight() qui accepte en argument le poids que vous souhaitez afficher sur l’OLED.

void displayWeight(int weight){
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(WHITE);
  display.setCursor(0, 10);
  // Display static text
  display.println("Weight:");
  display.display();
  display.setCursor(0, 30);
  display.setTextSize(2);
  display.print(weight);
  display.print(" ");
  display.print("g");
  display.display();  
}

Vous n’êtes pas familier avec l’écran OLED ? Lire: Guide pour l’affichage I2C OLED avec Arduino

installation()

Dans setup(), initialisez le Serial Monitor.

Serial.begin(57200);

Initialisez l’affichage OLED :

if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) { 
  Serial.println(F("SSD1306 allocation failed"));
  for(;;);
}
delay(2000);
display.clearDisplay();
display.setTextColor(WHITE);

Et enfin, initialisez la cellule de charge :

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

boucle()

La bibliothèque de boutons-poussoirs nous permet d’attendre un événement en cas d’appui ou de relâchement d’un bouton-poussoir. Dans ce cas, nous vérifions si le bouton-poussoir a été enfoncé à l’aide de la méthode getSingleDebouncePress() et appelons la fonction tare() si le bouton a été enfoncé.

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

Le HX711 fournit un méthode non bloquante pour obtenir des lectures. Il définit un délai maximum d’attente pour l’initialisation du matériel et ne bloque pas votre code en cas de déconnexion de la balance ou en cas de panne matérielle.

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

Dans la boucle (), nous obtenons constamment de nouvelles lectures et les vérifions par rapport à la dernière lecture. Si nous obtenons une nouvelle mesure, nous appelons la fonction displayWeight() pour mettre à jour l’affichage OLED.

if (reading != lastReading){
  displayWeight(reading); 
}

Manifestation

Après avoir téléchargé le code sur votre carte, vous pouvez commencer à peser des objets avec votre cellule de charge. Les lectures s’afficheront sur l’écran OLED. Vous pouvez tarer la balance en appuyant sur le bouton poussoir.

Démonstration de la balance numérique Arduino

Encore une fois, les lectures sur ma balance numérique Arduino correspondent aux lectures sur ma balance de cuisine.

1679845157 764 Arduino avec cellule de charge et amplificateur HX711 balance numerique

Conclusion

Dans ce didacticiel, vous avez appris à interfacer une cellule de charge à jauge de contrainte avec la carte Arduino à l’aide de l’amplificateur HX711. La sortie de la cellule de charge est proportionnelle à la force appliquée. Ainsi, vous pouvez le calibrer pour l’utiliser en g, kg, ib ou toute autre unité qui a du sens pour votre projet.

En résumé, vous avez appris à calibrer la balance et à obtenir le poids des objets. Vous avez également appris à créer une balance numérique simple avec l’Arduino en utilisant un écran OLED pour afficher les mesures et un bouton-poussoir pour tarer la balance.

Nous espérons que vous avez trouvé ce didacticiel utile pour vous familiariser avec une cellule de pesée. En plus d’être utile pour mesurer le poids d’objets, il peut également être utile dans de nombreuses applications comme détecter la présence d’un objet, estimer le niveau de liquide dans un réservoir, calculer le taux d’évaporation de l’eau, vérifier s’il y a de la nourriture dans la gamelle de votre animal, etc. .

Nous avons des tutoriels pour d’autres capteurs populaires qui pourraient vous être utiles :

En savoir plus sur l’Arduino avec nos ressources :

Découvrez l’histoire de Raspberry Pi dans cette vidéo :

YouTube video

  • Module de charge 3KG amplificateur HX711, Module de capteur de poids de balance de cuisine portable numérique AD pesant pour Arduino framboise Pi
    ? Liens vers des tutoriels et bibliothèques : https://www.instructables.com/id/Arduino-Scale-With-5kg-Load-Cell-and-HX711-Amplifi/ https://learn.sparkfun.com/tutorials/load-cell-amplifier-hx711-breakout-hookup-guide https://github.com/aguegu/ardulibs/trelibs/trelibs/treE/Master/HXX 711 ? Fonctionne pour Arduino et Raspberry Pi, nous avons un type de cellule de charge de 1 kg, 3 kg, 5 kg, 10 kg, 20 kg ? Contrôle numérique simple et interface série : commandes pilotées par broche, aucune programmation nécessaire ? Contenu de l'emballage : 1 capteur de charge de 3 kg et 1 module amplificateur de cellules A/D HX711 ? Comment nous envoyer un e-mail ? Veuillez cliquer sur « Stemedu » (vendu par Stemedu sous le bouton « Acheter maintenant »), dans la nouvelle page, cliquez sur « Posez une question » pour nous envoyer un e-mail
  • Stemedu Module de charge 10KG amplificateur HX711, Module de capteur de poids de balance de cuisine portable numérique AD pesant pour Arduino framboise Pi
    ? Liens vers des tutoriels et bibliothèques : https://www.instructables.com/id/Arduino-Scale-With-5kg-Load-Cell-and-HX711-Amplifi/ https://learn.sparkfun.com/tutorials/load-cell-amplifier-hx711-breakout-hookup-guide https://github.com/aguegu/ardulibs/trelibs/trelibs/treE/Master/HXX 711 ? Ce module HX711 utilise une puce convertisseur A/D 24 haute précision HX711. Elle est spécialement conçue pour la balance électronique de haute précision avec deux canaux d'entrée analogique et l'intégration interne de l'amplificateur de gain programmable. Fonctionne pour Arduino et Raspberry Pi ? Nous avons un capteur de pesée de 1 kg, 2 kg, 3 kg, 5 kg, 10 kg, 20 kg ? Contenu de l'emballage : 1 cellule de charge de 10 kg et 1 module amplificateur A/D HX711 ? Comment nous envoyer un e-mail ? Veuillez cliquer sur « Stemedu » (vendu par Stemedu sous le bouton « Acheter maintenant »), dans la nouvelle page, cliquez sur « Posez une question » pour nous envoyer un e-mail
  • Stemedu Module de charge 5KG amplificateur HX711, Module de capteur de poids de balance de cuisine portable numérique AD pesant pour Arduino framboise Pi
    ? Liens vers des tutoriels et bibliothèques : https://www.instructables.com/id/Arduino-Scale-With-5kg-Load-Cell-and-HX711-Amplifi/ https://learn.sparkfun.com/tutorials/load-cell-amplifier-hx711-breakout-hookup-guide https://github.com/aguegu/ardulibs/trelibs/trelibs/treE/Master/HXX 711 ? Fonctionne pour Arduino et Raspberry Pi ? Le module HX711 utilise 24 puces convertisseur A/D haute précision hx711 ; HX711 a spécialement conçu pour la balance électronique de haute précision avec deux canaux d'entrée analogique, l'intégration interne de l'amplificateur de gain programmable. ? Consommation de courant avec régulateur d'alimentation analogique sur puce : fonctionnement normal < 1,5 mA, mise hors tension < 1 uA ? Contrôle numérique simple et interface série : commandes pilotées par broche, aucune programmation nécessaire