Discussion :

[P1GOU1]

Bonjour à tous,

Je souhaite brancher ce capteur de poids : https://hackspark.fr/fr/weight-senso...ell-0-5kg.html

amplifié avec ce module : https://www.robotshop.com/eu/fr/ampl...SABEgIMFvD_BwE

Puis lu sur ma carte Arduino alimenté à 5V.

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 !

[f-leb]

Salut,

Je souhaite brancher ce capteur de poids : https://hackspark.fr/fr/weight-senso...ell-0-5kg.html

Les caractéristiques fournies par le site sont à pisser de rire...
La caractéristique intéressante :

Rated output(MV/V): 2.0c2±0.15

des Mégavolts/Volt

Si j'ai bien compris, à supposer qu'il faille lire 2.0±0.15 mV/V (millivolt/volt hein !), cela signifierait que si on passe de 0 à 5kg sur le capteur, on mesurerait une variation de 2 mV par Volt d'excitation, c-à-d 10 mV pour une alimentation en 5V.

Je n'ai pas regardé encore la doc du HX711 qui m'a l'air plus complète...

[P1GOU1]

Salut !

Donc si je suis bien, la sensibilité est de 2mV par volt d’excitation, avec une précision de + ou - 0.15mV, alors pour une charge de 5kg elle sera de 0v, et sans charge sur le capteur une tension de 10mV sera délivrée par ce dernier ? (Sans parler d'ampli pour l'instant).

Quid de la résolution du capteur ? (Je dirais 5V / 1024 (CAN de l'arduino), donc une résolution 0.004kg (4 grammes), et encore ça c'est si l'arduino arrive à lire le signal amplifié de 128 par l'ampli, c'est à dire les valeur de 0 à 1,28V (10*128) avec des intervalles de 1,25mV entre chaque point (1,28V/1024). Suis je sur le bon chemin...?

Merci par avance pour ton temps f-leb ^^

[f-leb]

Donc si je suis bien, la sensibilité est de 2mV par volt d’excitation, avec une précision de + ou - 0.15mV, alors pour une charge de 5kg elle sera de 0v, et sans charge sur le capteur une tension de 10mV sera délivrée par ce dernier ? (Sans parler d'ampli pour l'instant).

Disons que c'est une variation de 5kg qui devrait entraîner une variation de 10mV. Il y aura probablement un décalage du zéro (offset) à compenser lors de l'étalonnage.

Quid de la résolution du capteur ? (Je dirais 5V / 1024 (CAN de l'arduino), donc une résolution 0.004kg (4 grammes), et encore ça c'est si l'arduino arrive à lire le signal amplifié de 128 par l'ampli, c'est à dire les valeur de 0 à 1,28V (10*128) avec des intervalles de 1,25mV entre chaque point (1,28V/1024). Suis je sur le bon chemin...?

Le CAN de l'Arduino n'est pas utilisé, la communication entre le HX711 et l'Arduino est numérique (liaison série à 2 fils, data et clock).

La variation de tension est d'abord amplifiée (gain réglable 32, 64 ou 128) puis passe par un CAN 24 bits !

[P1GOU1]

J'ai l'impression qu'une jauge de contrainte obtient le maximum de sa résistance lorsqu'on y place une charge (plus les extensomètres s’étirent avec le poids, plus la résistance augmente) : https://fr.wikipedia.org/wiki/Jauge_de_d%C3%A9formation

Pour le reste, merci pour ces réponses claires f-leb. Bonne journée !

[f-leb]

J'ai l'impression qu'une jauge de contrainte obtient le maximum de sa résistance lorsqu'on y place une charge (plus les extensomètres s’étirent avec le poids, plus la résistance augmente) : https://fr.wikipedia.org/wiki/Jauge_de_d%C3%A9formation

Ici c'est un peu plus compliqué, ton capteur comporte 4 jauges de contrainte :

https://learn.sparkfun.com/tutorials/getting-started-with-load-cells

2 jauges sont étirées (R+dR), les 2 autres sont comprimées (R-dR).
Les 4 jauges sont montées en pont complet (pont de Wheastone) pour augmenter la sensibilité.

[P1GOU1]

Bonjour,

Me voila avec mon Arduino, ma jauge de contrainte et mon programme entre les mains. Ce programme fonctionne grâce à une librairie de fonction destinée à mon module d'amplification sen 0160, sur lequel repose mon Hx711. Tout fonctionne bien sauf deux choses, je souhaite visualiser le deuxième chiffre après le 0 (centième de gramme), et j'aimerais augmenter le nombre d’échantillon pour la moyenne, car en effet parfois les résultats vacille et je voudrais lisser un peu (fonction average ci dessous).

Voici la forme avec laquelle je reçois les données pour l'instant (avec le poids de mon super stylo) :

13.8 g
13.8 g
13.8 g
13.8 g
13.8 g
13.8 g
13.8 g
13.8 g
13.8 g
13.8 g

Voici les fichiers de la librairie de mon module sen0160 rattaché au Hx711 fichier :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
#include "Hx711.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);
	return (float) val / _scale;
}

************************************************************************************

HEADER :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#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 = 100);
	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

Oui, sans commentaires, ça pique !!

Et le code sur mon logiciel est celui ci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//A l'allumage du capteur, ne rien poser sur le plateau, afin que la tare des 0Kg se fasse
 
/*Poids entre 0.1g et 1Kg, attention à ne pas depasser cette fourchette sous peine 
d'alterer les reistances*/
 
#include <Hx711.h>
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() {
  Serial.print(scale.getGram(), 1); //Affichage du poids en gramme
  Serial.println(" g"); //Affichage en caractère de l'unité gramme
  delay(200); //Delai de 200ms 
}

Merci par avance pour votre aide !

[f-leb]

Bonsoir,

vite fait en passant...

je souhaite visualiser le deuxième chiffre après le 0 (centième de gramme)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

  Serial.print(scale.getGram(), 1); //Affichage du poids en gramme

Le deuxième paramètre est justement le nombre de décimales à afficher.

Je repasserai plus tard...

[f-leb]

et j'aimerais augmenter le nombre d’échantillon pour la moyenne

dans le .h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

long averageValue(byte times = 100);

100 est le nombre d'échantillons par défaut.

[P1GOU1]

Merci, en effet c’était ça... Le chiffre oscille un peu entre les centième de gramme, et ce même avec une moyenne sur un long échantillon, je pense pas pouvoir faire grand chose...?

Y à t'il un moyen de récupérer uniquement des valeurs absolues, sans que cela affiche parfois -0.00g ? J'ai essayer Serial.print(scale.getGram(), abs(2)); Mais ça ne fonctionne pas.

[P1GOU1]

Je réponds à mon problème par le type de solution utilisé pour avoir une valeur absolue :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
#include <stdlib.h>
#include <math.h>
 
int main()
{
    double absolu=0, nombre=-24;
 
    absolu=fabs(nombre);
 
    return 0;
}

[P1GOU1]

Bonjour à tous !

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
//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

[P1GOU1]

Problème résolu avec condition du type :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

ainsi la dizaine de chiffres après la décimale n'est pas prise en compte !