Problème poids hx117

International Français
1

bonjour, je suis entrain de réaliser le projet d'une balance qui est sensé chanter une chanson quand il dépasse un certain poids, le problème c'est quand la balance atteint ce poids le mémo ne fait que se répéter chaque deux seconde, on dirait qu'il re détecte le poids a chaque fois...

j'ai essayer avec des port analogique, et avec des port numérique ça donne le même résultat..

voilà le code analogique:
(Use Code tags, </> on the menu si vous plait)

// Hx711.DOUT - pin #A11
// Hx711.SCK - pin #A10

#include <Hx711.h>
Hx711 scale(A11, A10);

int test;
int weight;
int pinLedvert,pinLedroug;

///////////////////////////////////////////////
//////////  blibliothèque speaker /////////////
///////////////////////////////////////////////
#include <pcmConfig.h>
#include <pcmRF.h>
#include <TMRpcm.h>
#include <SD.h>
#define SD_Pin 53               //define CS pin
TMRpcm speaker;                 //objet "speaker
////////////////////////////////////////////////////
////////////////voice///////////////
///////////////////////////////////
String voice;
int voix;

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

  pinLedvert = 20;
pinLedroug = 23;

pinMode(pinLedvert, OUTPUT);
pinMode(pinLedroug, OUTPUT);

///////////////////////////////////////////////
//////////  déclaration speaker ///////////////
///////////////////////////////////////////////
speaker.speakerPin = 46;         //définnie le pin du speaker. Il faut utiliser le 9 car la library utilise ce pin !

if (!SD.begin(SD_Pin)) {        // si carte non inceré, ne rien faire
  return;
}
speaker.setVolume(6);           //volume level : 0 to 7
}

void loop() {

weight=scale.getGram();
Serial.print(weight, 1);
Serial.println(" g");
delay(200);

  if (weight < 40) //on teste si etatAllumage est à 1
{
  digitalWrite(pinLedvert, HIGH);
  digitalWrite(pinLedroug, LOW);
 
}

if (weight > 40)
{
  digitalWrite(pinLedvert, LOW);
  digitalWrite(pinLedroug, HIGH);//on éteint la LED
  speaker.play("17.wav");
  return;
}
}

et voilà le code en numérique:

#include "HX711.h"
#define DOUT  A11
#define CLK  A10
HX711 scale(DOUT, CLK);

float weight;
float calibration_factor = -99300; // for me this value works just perfect 419640

///////////////////////////////////////////////
//////////  blibliothèque speaker /////////////
///////////////////////////////////////////////
#include <pcmConfig.h>
#include <pcmRF.h>
#include <TMRpcm.h>
#include <SD.h>
#define SD_Pin 53               //define CS pin
TMRpcm speaker;                 //objet "speaker
////////////////////////////////////////////////////
////////////////voice///////////////
///////////////////////////////////
String voice;
int voix;

int pinBouton, pinLedvert, pinLedroug;

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

 long zero_factor = scale.read_average(); //Get a baseline reading
 Serial.print("Zero factor: "); //This can be used to remove the need to tare the scale. Useful in permanent scale projects.
 Serial.println(zero_factor);
 pinLedvert = 20;
 pinLedroug = 23;
 pinBouton = 21;
 etatAllumage = 0;
 pinMode(pinBouton, INPUT_PULLUP);
 pinMode(pinLedvert, OUTPUT);
 pinMode(pinLedroug, OUTPUT);

 ///////////////////////////////////////////////
 //////////  déclaration speaker ///////////////
 ///////////////////////////////////////////////
 speaker.speakerPin = 46;         //définnie le pin du speaker. Il faut utiliser le 9 car la library utilise ce pin !

 if (!SD.begin(SD_Pin)) {        // si carte non inceré, ne rien faire
   return;
 }
 speaker.setVolume(6);           //volume level : 0 to 7

 scale.set_scale();
 scale.tare(); //Reset the scale to 0

}

void alarme() {
 scale.set_scale(calibration_factor); //Adjust to this calibration factor
 weight = scale.get_units(5);
 //Serial.print(scale.get_units(), 2);
 // Serial.print(" lbs"); //Change this to kg and re-adjust the calibration factor if you follow SI units like a sane person

 if (Serial.available())
 {
   char temp = Serial.read();
   if (temp == '+' || temp == 'a')
     calibration_factor += 100;
   else if (temp == '-' || temp == 'z')
     calibration_factor -= 100;
 }

 /////////////////////////////////////////////////////
if (weight < 0.2) //on teste si etatAllumage est à 1
 {
   digitalWrite(pinLedvert, HIGH);
   digitalWrite(pinLedroug, LOW);
  
 }

 if (weight > 0.5)
 {
   digitalWrite(pinLedvert, LOW);
   digitalWrite(pinLedroug, HIGH);//on éteint la LED
   speaker.play("17.wav");

 }
}

void loop() {

 Serial.print("Kilogram:");
 Serial.print( weight);
 Serial.print(" Kg");

 alarme();
}
2

Bonsoir

ça ressemble beaucoup au message posté il y a 3 jours.......avc un titre légèrement différent
https://forum.arduino.cc/index.php?topic=687992.msg4626891#msg4626891
sur ce forum on n'apprécie pas les doublons
le postitif c'est le fait que le code est maintenant publiée entre les balises
Il aurait mieux valu éditer le premier message pour corriger le code et non le dupliquer

Si la mesure du poids est faite en boucle et si l'émission du message est liée à un simple seuil il n'est pas surprenant d'observer une répétition

3

hello
dans la loop:

void loop() {
.....
.....
 alarme();
}

et dans alarme:

if (weight > 0.5)
 {
   digitalWrite(pinLedvert, LOW);
   digitalWrite(pinLedroug, HIGH);//on éteint la LED
   speaker.play("17.wav");

 }

ce que tu constates est on ne peux plus normal

tu déclares un "pinBouton = 21;"

tu pourrais peut etre t'en servir pour conditionner l'appel à "Alarme", et ne le faire qu'une fois

4

Bonjour merci pour les réponses.. mais je n'ai pas compris !! Faudrait il que j'enlève l'exécution du loup ? Ou bien y'a t il une autre solution ?? Je suis débutante...

5

:slight_smile: loup loup y es tu ?

c'est de "loop" qu'il s'agit.

voici une façon de régler ton problème

non compilée car pas voulu charger les librairies et donc non testée
mais ça te mettra sur la voie. :slight_smile:

#include "HX711.h"
#define DOUT  A11
#define CLK  A10
HX711 scale(DOUT, CLK);

float weight;
float calibration_factor = -99300; // for me this value works just perfect 419640

///////////////////////////////////////////////
//////////  blibliothèque speaker /////////////
///////////////////////////////////////////////
#include <pcmConfig.h>
#include <pcmRF.h>
#include <TMRpcm.h>
#include <SD.h>
#define SD_Pin 53               //define CS pin
TMRpcm speaker;                 //objet "speaker
////////////////////////////////////////////////////
////////////////voice///////////////
///////////////////////////////////
String voice;
int voix;

int pinBouton, pinLedvert, pinLedroug;

void setup()
{
  Serial.begin(9600);
  long zero_factor = scale.read_average(); //Get a baseline reading
  Serial.print("Zero factor: "); //This can be used to remove the need to tare the scale. Useful in permanent scale projects.
  Serial.println(zero_factor);
  pinLedvert   = 20;
  pinLedroug   = 23;
  pinBouton    = 21;
  etatAllumage =  0;
  pinMode(pinBouton, INPUT_PULLUP);
  pinMode(pinLedvert,      OUTPUT);
  pinMode(pinLedroug,      OUTPUT);

  ///////////////////////////////////////////////
  //////////  déclaration speaker ///////////////
  ///////////////////////////////////////////////
  speaker.speakerPin = 46;         //définnie le pin du speaker. Il faut utiliser le 9 car la library utilise ce pin !

  if (!SD.begin(SD_Pin)) // si carte non inceré, ne rien faire
  {
    return;
  }
  speaker.setVolume(6);           //volume level : 0 to 7
  scale.set_scale();
  scale.tare();
}
void calibration()
{
  char temp = Serial.read();
  if (temp == '+' || temp == 'a')
  {
    calibration_factor += 100;
  }
  else
  { if (temp == '-' || temp == 'z')
    {
      calibration_factor -= 100;
    }
  }
  scale.set_scale(calibration_factor); //Adjust to this calibration factor
}


void alarme()
{
  if (weight < 0.2)                   //on teste si poids < à 0.2
  {
    digitalWrite(pinLedvert, HIGH);
    digitalWrite(pinLedroug, LOW);
  }
  if (weight > 0.5)                   //on teste si poids > à 0.5
  {
    digitalWrite(pinLedvert, LOW);
    digitalWrite(pinLedroug, HIGH);   //on éteint la LED
    speaker.play("17.wav");           //musique d'avertissement
  }
}


void loop()
{
  if (Serial.available())       // si demande de calibration
  {
    calibration();              // on exécute la calibration
  }
  weight = scale.get_units(5);  //on fait une pesée
  Serial.print("poids:");
  Serial.print( weight);        //affiche le poids sur le moniteur
  Serial.print(" Kg");
  alarme();                     //va voir si poids dans fourchette et musique si nécessaire
  do {
    weight = scale.get_units(5); // fait une pesée tant que poids supérieur à 0.1
  } while (weight > 0.1 );         //oblige à libérer le plateau
}
6

Le correcteur automatique, quel invention....

Merci pour le code je viens de l'essayer... il marche mais ce que je cherche, c'est qu'il continue à lire les données de la balance régulièrement... or avec ce code il ne le fait pas...
J'ai fais la même chose avec une photoresistance... quand on dépasse une certaine lumière une alarme sonne.. ce code marche très bien et l'alarme ne sonne qu'une fois... je ne comprend pas pourquoi cela ne fonctionne pas avec un capteur de poids...

7

en principe, après une pesée, le code t'oblige à libérer le plateau pour pouvoir refaire une pesée avec alarme ( si nécessaire)

8

Oui j'ai remarqué que quand j'enlève le poids, il reprends la pesée... mais si par exemple: je mets un poids au-dessous du poids limité et que je rajoute un autre.. il ne le lit pas... et moi c'est ce que je cherches...

9

si pesée sans alarme, on autorise une nouvelle pesée
si pesée avec alarme, on doit libérer le plateau pour pouvoir refaire une pesée

#include "HX711.h"
#define DOUT  A11
#define CLK  A10
HX711 scale(DOUT, CLK);
boolean flag_alarme = false;
float weight;
float calibration_factor = -99300; // for me this value works just perfect 419640

///////////////////////////////////////////////
//////////  blibliothèque speaker /////////////
///////////////////////////////////////////////
#include <pcmConfig.h>
#include <pcmRF.h>
#include <TMRpcm.h>
#include <SD.h>
#define SD_Pin 53               //define CS pin
TMRpcm speaker;                 //objet "speaker
////////////////////////////////////////////////////
////////////////voice///////////////
///////////////////////////////////
String voice;
int voix;

int pinBouton, pinLedvert, pinLedroug;

void setup()
{
  Serial.begin(9600);
  long zero_factor = scale.read_average(); //Get a baseline reading
  Serial.print("Zero factor: "); //This can be used to remove the need to tare the scale. Useful in permanent scale projects.
  Serial.println(zero_factor);
  pinLedvert   = 20;
  pinLedroug   = 23;
  pinBouton    = 21;
  etatAllumage =  0;
  pinMode(pinBouton, INPUT_PULLUP);
  pinMode(pinLedvert,      OUTPUT);
  pinMode(pinLedroug,      OUTPUT);

  ///////////////////////////////////////////////
  //////////  déclaration speaker ///////////////
  ///////////////////////////////////////////////
  speaker.speakerPin = 46;         //définnie le pin du speaker. Il faut utiliser le 9 car la library utilise ce pin !

  if (!SD.begin(SD_Pin)) // si carte non inceré, ne rien faire
  {
    return;
  }
  speaker.setVolume(6);           //volume level : 0 to 7
  scale.set_scale();
  scale.tare();
}
void calibration()
{
  char temp = Serial.read();
  if (temp == '+' || temp == 'a')
  {
    calibration_factor += 100;
  }
  else
  { if (temp == '-' || temp == 'z')
    {
      calibration_factor -= 100;
    }
  }
  scale.set_scale(calibration_factor); //Adjust to this calibration factor
}


void alarme()
{
  if (weight < 0.2)                   //on teste si poids < à 0.2
  {
    digitalWrite(pinLedvert, HIGH);
    digitalWrite(pinLedroug, LOW);
  }
  if (weight > 0.5)                   //on teste si poids > à 0.5
  {
    flag_alarme=true;
    digitalWrite(pinLedvert, LOW);
    digitalWrite(pinLedroug, HIGH);   //on éteint la LED
    speaker.play("17.wav");           //musique d'avertissement
  }
}


void loop()
{
  if (Serial.available())       // si demande de calibration
  {
    calibration();              // on exécute la calibration
  }
  weight = scale.get_units(5);  //on fait une pesée
  Serial.print("poids:");
  Serial.print( weight);        //affiche le poids sur le moniteur
  Serial.print(" Kg");
  alarme();                     //va voir si poids dans fourchette et musique si nécessaire
  if (flag_alarme==true)
  {
    do {
  
    weight = scale.get_units(5); // fait une pesée tant que poids supérieur à 0.1
  } while (weight > 0.1 );         //oblige à libérer le plateau
 }
 flag_alarme=false;
 
}