Go Down

Topic: Sensibilité d'un capteur de force (Read 927 times) previous topic - next topic

P1GOU1

Bonjour à tous,

Je souhaite brancher ce capteur de poids : https://hackspark.fr/fr/weight-sensor-load-cell-0-5kg.html

amplifié avec ce module : https://www.robotshop.com/eu/fr/amplificateur-cellule-force-hx711.html?gclid=EAIaIQobChMI_6mmpPj_2AIVRTgbCh25Mg5wEAQYBSABEgIMFvD_BwE

Puis lu sur ma carte Arduino.

Hors j'ai encore du mal à lire les spécifications techniques d'un capteur, et je voudrais savoir quelle est sa précision de lecture (0.1G, 1G...?) et surtout à quoi voir et calculer ça ?

Merci à tous par avance !

bisra

Le capteur que tu veux utiliser s'alimente en 5 ou 10V continu. Lorsque tu poses 5 kg dessus, le signal est de 10mV avec une alimentation de 5V. Ce capteur est donné pour 2000 points certifiés. Donc, l'échelon en 2000 points sera de 10mV/2000 = 20 microvolts.
Le circuit conditionneur de jauge HX711 a une sensibilité de 20mV pour 24 bits. Donc, dans ton cas, tu disposera de 23 bits (la moitié). Il faudra écrire une fonction d'étalonnage interactive et disposer d'un poids étalon de 1, 2 ou 5kg.
Le plateau de pesée ne devra pas dépasser 300mm x 300mm.

Si après cela tu as encore envie de te lancer, je peux te donner des pistes pour le logiciel d'étalonnage.

P1GOU1

Bonjour à tous !

Me revoilà avec ma jauge de contrainte dont voici le code :

Code: [Select]
//A l'allumage du capteur, ne rien poser sur le plateau, afin que la tare des 0Kg se fasse

/*Poids entre 0.01g et 1Kg (Precision à +- 0.02g), attention à ne pas depasser une charge de 1Kg
 * sous peine d'alterer les resistances de la jauge*/

#include <Hx711.h> //Utiliser la librairie modifié
Hx711 scale(A2, A3); //Prise du signal differentiel entre la pin A2 et A3

void setup() {
  scale.setScale(2050); //Reglage de l'echelle pour etaloner la jauge de contrainte
  Serial.begin(9600); //Initialisation de la liaison serie
}

void loop() {
 
  float toro = scale.getGram();
   
  if (toro == 13.87) {
  Serial.println("OUF");
      }

      Serial.print(toro); //Affichage du poids en gramme
     
  Serial.println(" g"); //Affichage en caractère de l'unité gramme
  }


Le problème est que quand la fonction de la jauge Hx711 me renvoi bien 13.87, ça ne rentre pas dans la condition if, alors que si je retire la partie décimal donc en mettant toro en int et que je mets 13 dans la condition, cela fonctionne très bien. Que se passe il avec cette décimal ?

Bonne soirée

biggil

et bien par exemple si toro vaut 13.87001, la condition if (toro == 13.87) ne passe pas, c'est normal !
Pour faire des comparaisons entre nombres réels, il faut toujours accepter une incertitude :
Code: [Select]

float epsilon = 0.01;
if ( toro >= 13.87 - epsilon && toro <= 13.87 + epsilon ) ...

passera si  13.86 <= toro <= 1.88

P1GOU1

En effet biggil ça fonctionne, j'avais pas pensé à regarder dans ce sens, merci !

Pour écrire moins de code, je me demande s'il est possible avec la librairie de mon module d'arrondir à deux décimales, plutôt qu'avoir une longue série de chiffre après le virgule, j'ai cherché sans vraiment trouvé, je mets la librairies du module ici ou quelqu'un puisse m'éclairer :

hx711.cpp :

Code: [Select]
/*
 * Hx711.cpp
 *
 *  Created on: Oct 31, 2012
 *      Author: agu
 */

#include "Hx711.h"
#include <math.h>

Hx711::Hx711(uint8_t pin_dout, uint8_t pin_slk) :
_pin_dout(pin_dout), _pin_slk(pin_slk)
{
pinMode(_pin_slk, OUTPUT);
pinMode(_pin_dout, INPUT);

digitalWrite(_pin_slk, HIGH);
delayMicroseconds(100);
digitalWrite(_pin_slk, LOW);

averageValue();
this->setOffset(averageValue());
this->setScale();
}

Hx711::~Hx711()
{

}

long Hx711::averageValue(byte times)
{
long sum = 0;
for (byte i = 0; i < times; i++)
{
sum += getValue();
}

return sum / times;
}

long Hx711::getValue()
{
byte data[3];

while (digitalRead(_pin_dout))
;

for (byte j = 0; j < 3; j++)
{
for (byte i = 0; i < 8; i++)
{
digitalWrite(_pin_slk, HIGH);
bitWrite(data[2 - j], 7 - i, digitalRead(_pin_dout));
digitalWrite(_pin_slk, LOW);
}
}

digitalWrite(_pin_slk, HIGH);
digitalWrite(_pin_slk, LOW);

return ((long) data[2] << 16) | ((long) data[1] << 8) | (long) data[0];
}

void Hx711::setOffset(long offset)
{
_offset = offset;
}

void Hx711::setScale(float scale)
{
_scale = scale;
}

float Hx711::getGram()
{
long val = (averageValue() - _offset);
    long absolu=0;

    absolu=fabs(val); //Ajout du résultat en valeur absolue

return (float) absolu / _scale;
}


et Hx711.h :

Code: [Select]
#ifndef HX711_H_
#define HX711_H_

#include "Arduino.h"

class Hx711
{
public:
Hx711(uint8_t pin_din, uint8_t pin_slk);
virtual ~Hx711();
long getValue();
long averageValue(byte times = 200);
void setOffset(long offset);
void setScale(float scale = 1992.f);
float getGram();

private:
const uint8_t _pin_dout;
const uint8_t _pin_slk;
long _offset;
float _scale;
};

#endif /* HX711_H_ */

kamill

Bonjour,

Les flottants sont codés en binaire et toi tu veux arrondir la valeur en décimale.
Il n'est pas possible (en général) d'arrondir la valeur d'un flottant (en interne) à un nombre de décimale données.

Pour t'en convaincre essaie
Code: [Select]
  float val=13.87;
  Serial.println(val,7);


Ca te donne: 13.8699998

La bonne méthode pour tester l'égalité de deux float (avec la précision désirée) est celle donnée par biggil.

Go Up