Balance version 1 : Alimentation et programme Arduino

1 Circuit d’alimentation

J’utilise une batterie type auto de 40Ah, ça dure un bon moment. Pour alimenter mon circuit qui fonctionne en 5V, un convertisseur à haut rendement de type LM2596 délivre une tension ajustable avec un débit de 2A. C’est plus qu’il n’en faut.

module convertisseur 12V v
module alimentation convertisseur 12V 5V

Pour la surveillance de la tension batterie, il est nécessaire d’ajouter un pont diviseur destiné à abaisser la tension batterie variable de 12 à 14v à une valeur compatible avec l’entrée analogique de l’Atmega qui est de 5V maxi. Ceci est réalisé par un pont diviseur composé de 2 résistances de 24000 ohms et 10000 ohms.

Ceci donne un rapport de 14 / (24+10) * 10 = 4.12V , tension maximale compatible avec l’entrée de mesure analogique de l’Atmega.

Circuit d'alimentation et de mesure de tension batterie
Circuit d’alimentation

2 Croquis ou sketch Arduino

Il gère les fonctions suivante :

  • gestion du module interface HX711 avec la cellule de charge
  • mémorisation de la valeur de la tare en mémoire EEPROM avec possibilité de réinitialiser par appuis sur un bouton
  • interface avec un capteur de température Dallas DS18B20
  • dialogue avec le module émetteur récepteur radio NRF24L01
  • enclenchement périodique d’une séquence de mesure de poids
  • surveillance du poids de la ruche
  • transmission de la valeur de poids périodique ou sur variation rapide de poids.

Scketch Arduino en cours d’évolution à copier coller dans un nouveau projet sur l’IDE Arduino.

Attention, il est nécessaire d’installer les librairies MySensors.h, HX711.h, One Wire.h, DallasTemperature.h et Vcc.h qui ne sont pas installées par défaut dans l’IDE Arduino.

/*  Sketch pour la création d'une balance connectée à usage apiculture
    Une cellule de charge à jauge de contrainte de gamme de mesure 75kg
    est insérée sous la ruche dont on veut surveiller le poids.
    Un module HX711 spécialisé pour les ponts de mesure converti le signal
    analogique en information digitales.
    Une sonde Dallas DS18B20 sert de capteur de température ambiante.
    Un module radio 2.4 Ghz NRF24L01 transmet les informations suivant le
    protocole MySensors.
    Un module Arduino Pro Mini constitue le coeur du système
    La valeur de la tare est enregistrée dans la mémoire EEPROM de l'Arduino
    Un bouton permet de réinitialiser la tare.
*/

// Enable debug prints : debug trames MySensors
//#define MY_DEBUG

// Enable and select radio type attached
#define MY_RADIO_NRF24
#define MY_NODE_ID 182        // Sets a static id for a node

// Definitions des paramètres application
#define DebugProg
#define SN "Balance api v2"    // nom du scketch MySensors
#define SV "26/08/2016"       // version du sckletch

#include <SPI.h>
#include <MySensors.h>
#include "HX711.h"
#include <EEPROM.h>
#include <DallasTemperature.h>
#include <OneWire.h>
#include <Vcc.h>

// Definition des connexions E/S
const int analogInPin = A5; // Analog pin the voltage divider is attached to
const int BOUTON = 2;            // bouton de reset tare actif niveau bas
const int ONE_WIRE_BUS = 3;        // Pin where dallase sensor is connected
const int DOUT2 = 5;            // Pin data HX711 num 2
const int CLK2 = 6;                // Pin clock HX711 num 2
const int DOUT1 = 7;            // Pin data HX711 num 1
const int CLK1 = 8;                // Pin clock HX711 num 1

// Identifiants MySensors
const int ID_TEMP = 0;
const int ID_POIDS = 1;
const int ID_BatPcnt = 2;
const int ID_BATT = 3;
const int ID_TARE = 4;

const int GAIN = 128;            // gain amplificateur HX711
const float calibration_factor = 461; // coefficient de calibration : 10g / unité
const uint16_t SLEEP_TIME = 60 / 15; // tempo envoi en secondes

// Tension mini en-dessous de laquelle la batterie doit être rechargée :
const float VccMin   = 12;  // Vcc mini 11V batterie déchargée
const float VccMax   = 13.6;  // Vcc Maximum 14V batterie complètement chargée
const float R1 = 24000;     // Voltage divider R1 (Ohm)
const float R2 = 10000;     // Voltage divider R2 (Ohm)
const float VccCorrection = 4.98 / 5.16; // Vcc multimetre / Vcc mesuré par l'Arduino

// Déclaration des variables
boolean receivedConfig = false;
boolean metric = true;
boolean envoiTare = true;    // pour envoyer la valeur de la tare au reset
uint8_t battLoop = 10;       // pour envoi tension batterie dès le reset
uint16_t seconde = 0;        // compteur seconde pendule
int oldBatteryPcnt = 0;
long lastPoids = 0;
long tare;

// Déclaration des objets
OneWire oneWire(ONE_WIRE_BUS);          // pour capteur de temperature DS18B20
DallasTemperature sensors(&oneWire);    // pour librairie Dallas
Vcc vcc(VccCorrection);                 // pour mesure tension d'alimentation
HX711 scale1(DOUT1, CLK1, GAIN);        // pour module HX711 n°1
//HX711 scale2(DOUT2, CLK2, GAIN);        // pour module HX711 n°2

// Déclaration des messages MySensors
MyMessage msgTemp(ID_TEMP, V_TEMP);            // type V_TEMP pour temperature
MyMessage msgPoids(ID_POIDS, V_WEIGHT);    // type V_WEIGHT au lieu de V_VAR1
MyMessage msgBAT(ID_BATT, V_VOLTAGE);        // type V_VOLTAGE au lieu de V_VAR2
MyMessage msgTare(ID_TARE, V_VAR3);            // type V_VAR3 pour la tare HX711

//***********************************************************************************
//***** Code d'initialisation à faire avant demarrage de MySensors *****
//***********************************************************************************
void before() {
  // This will execute before MySensors starts up
}

//************************************************************************************
//*****   Fonction de presentation du noeud    *****
//************************************************************************************
void presentation() {
  // Send the sketch version information to the gateway and Controller
  sendSketchInfo(SN, SV);

  // présentation identifiants MySensors et type de données
  present(ID_TEMP, V_TEMP);
  present(ID_POIDS, V_WEIGHT);
  present(ID_BATT, V_VOLTAGE);
  present(ID_TARE, V_VAR3);

  metric = getConfig().isMetric;
}

//**********************************************************************************
//*****     FONCTION SETUP = Code d'initialisation générale du programme       *****
//**********************************************************************************
void setup() {
  Serial.begin(115200);                    //standard serial
  delay(200);

  digitalWrite(BOUTON, HIGH);   // active résistance de pullup interne

  Serial.println();
  Serial.print(SN);
  Serial.print(" - ");
  Serial.println(SV);

  sensors.begin();                            // init capteur de température DS18B20
  // Fetch the number of attached temperature sensors
  int numSensors = sensors.getDeviceCount();
#ifdef DebugProg
  Serial.print(numSensors);
  Serial.println(F(" DS18B20 trouvé"));
#endif

#ifdef DebugProg
  long zero_factor = scale1.read_average();  //Get a baseline reading
  Serial.print(F("Zero factor: "));
  Serial.println(zero_factor);
#endif

  // forçage valeur de la tare
  //tare = 664120;              // ancienne tare
  //EEPROMWritelong(EEPROM_LOCAL_CONFIG_ADDRESS, tare);

  scale1.power_up();            // pour alimenter la cellule de charge
  scale1.set_scale(calibration_factor);        // Adjust to this calibration factor
  tare = EEPROMReadlong(EEPROM_LOCAL_CONFIG_ADDRESS); // recupere valeur tare en EEPROM
  scale1.set_offset(tare);                // initialise la tare
  scale1.power_down();

#ifdef DebugProg
  Serial.print(F("Init tare depuis EEPROM = "));
  Serial.println(tare);
#endif

  check_batt();
  seconde = 0;
}

//************************************************************************************
//*****             FONCTION mesure tension batterie                            ******
//************************************************************************************
float tension_batt() {
  // mesure de Vcc
  float Vcc = vcc.Read_Volts();

  // read the analog in value:
  int sensorValue = analogRead(analogInPin);

  // Serial.println(sensorValue); // for debug / calibration
  float v_pin = Vcc * sensorValue / 1023.;
  float v_bat = v_pin / (R2 / (R1 + R2));
#ifdef DebugProg
  Serial.print(F("Tension batterie: Vcc:"));
  Serial.print(Vcc);              // affiche Vcc
  Serial.print(F(" v_pin:"));
  Serial.print(v_pin);            // affiche tension sortie diviseur tension
  Serial.print(F(" Vbatt= "));
  Serial.println(v_bat);          // affiche tension batterie calculée
#endif

  return (v_bat);
}

//************************************************************************************
//*****    FONCTION controle tension batterie   ******
//************************************************************************************
void check_batt()
{
  // mesure de Vcc
  //float batteryVolt = vcc.Read_Volts();
  float batteryVolt = tension_batt();
  /*
    #ifdef DebugProg
    Serial.print(F("Tension batterie = "));
    Serial.println(batteryVolt);
    #endif
  */
  // calcul du % de charge batterie
  float batteryPcnt = 100 * ((batteryVolt - VccMin) / (VccMax - VccMin));

  sendBatteryLevel(batteryPcnt);            // envoi % batterie
  oldBatteryPcnt = batteryPcnt;
  send(msgBAT.set(batteryVolt, 2));            // et tension avec 2 décimales
}

//************************************************************************************
//*****    FONCTION reception messages NRF24L01   ******
//************************************************************************************
void incomingMessage(const MyMessage &message) {
  Serial.print(F("reception Message: "));
  Serial.print(message.sensor);
  Serial.print(F(" msg-type: "));
  Serial.println(message.type);

  int value = 0;
  if (message.type == V_VAR3) {
    tare = atol( message.data);
    scale1.set_offset(tare);                // parametre la valeur de la tare
    saveState(ID_TARE, tare);                // memorise la tare en eprom
    send(msgTare.set(value) );                // retourne la valeur de la tare à Jeedom
#ifdef DebugProg
    Serial.print(F("Reception tare Jeedom ="));
    Serial.println(tare);
#endif
  }
}
//************************************************************************************
// This function will write a 4 byte (32bit) long to the eeprom at
// the specified address to address + 3.
//************************************************************************************
void EEPROMWritelong(int address, long value)
{
  //Decomposition from a long to 4 bytes by using bitshift.
  //One = Most significant -> Four = Least significant byte
  byte four = (value & 0xFF);
  byte three = ((value >> 8) & 0xFF);
  byte two = ((value >> 16) & 0xFF);
  byte one = ((value >> 24) & 0xFF);

  //Write the 4 bytes into the eeprom memory.
  EEPROM.write(address, four);
  EEPROM.write(address + 1, three);
  EEPROM.write(address + 2, two);
  EEPROM.write(address + 3, one);
}

//************************************************************************************
// This function will return a 4 byte (32bit) long from the eeprom
// at the specified address to address + 3.
//************************************************************************************
long EEPROMReadlong(long address)
{
  //Read the 4 bytes from the eeprom memory.
  long four = EEPROM.read(address);
  long three = EEPROM.read(address + 1);
  long two = EEPROM.read(address + 2);
  long one = EEPROM.read(address + 3);

  //Return the recomposed long by using bitshift.
  return ((four << 0) & 0xFF) + ((three << 8) & 0xFFFF) + ((two << 16) & 0xFFFFFF) + ((one << 24) & 0xFFFFFFFF);
}

//**********************************************************************************
//*****  Fonction Msure de poids  *****
//**********************************************************************************
long Mesure() {
  scale1.power_up();
  long mesureP = -scale1.get_units(20);
  scale1.power_down();

#ifdef DebugProg
  Serial.print("Poids = ");
  Serial.println(mesureP);
#endif

  return (mesureP);
}

//**********************************************************************************
//*************** FONCTION LOOP = Boucle sans fin = coeur du programme *************
//**********************************************************************************
void loop() {
  long Poids = Mesure();
  if (abs(lastPoids - Poids) > 10) {
    send(msgPoids.set(Poids));
    lastPoids = Poids;
  }

  // Surveillance du bouton de reset tare
  // tempo 1 seconde
  for (uint8_t i = 0; i < 118; i++) {
    if (digitalRead(BOUTON) == LOW) {
      scale1.power_up();
      scale1.tare(10);               //Reset the scale to 0
      tare = scale1.get_offset();    // lit la valeur de la tare
      scale1.power_down();
      EEPROMWritelong(EEPROM_LOCAL_CONFIG_ADDRESS, tare);

#ifdef DebugProg
      Serial.print(F("Reset tare = "));
      Serial.println(tare);
#endif
      envoiTare = true;             // pour envoi tare à Jeedom
    }
    sleep(100);                     // pour tempo en ms
  }

  seconde += 3;
  /*
    #ifdef DebugProg
    Serial.print("Tempo ");
    Serial.print(seconde);
    Serial.print(' ');
    #endif
  */

  // envoi tare à Jeedom si reset Arduino ou réinitialisation tare
  if (envoiTare) {
    send( msgTare.set(tare) );
    envoiTare = false;
    sleep(1000);                    // tempo 1 seconde
  }

  if (seconde >= SLEEP_TIME) {
    // Fetch temperatures from Dallas sensors
    sensors.requestTemperatures();
    float temperature =
      static_cast<float>
      (static_cast<int>
       ((getConfig().isMetric ?
         sensors.getTempCByIndex(0) :
         sensors.getTempFByIndex(0)) * 10.)) / 10.;
#ifdef DebugProg
    Serial.print(F("Temperature = "));
    Serial.println(temperature, 1);
#endif

    if ( temperature > -30.0)   // elimine valeur erronnées
      send(msgTemp.set(temperature, 1));

    send(msgPoids.set(Poids));
    lastPoids = Poids;
    seconde = 0;

    // test batterie toutes les 10 minutes
    battLoop++;
    if (battLoop >= 10) {
      check_batt();
      battLoop = 0;
      envoiTare = true;
    }
  }
}

Vous pouvez ajouter ou supprimer les // en début de paramètre pour activer ou désactiver les fonctions de debug sur la console.

//#define MY_DEBUG // Enable and select radio type attached

//#define DebugProg

Les valeurs de résistance sont à modifier en fonction du pont diviseur que vous avez mesuré.

const float R1 = 24000;     // Voltage divider R1 (Ohm)
const float R2 = 10000;     // Voltage divider R2 (Ohm)

Au sujet de la librairie Vcc, cette fonction sert à apporter les compensations dues aux écarts de tension d’alimentation de l’Atmega. Elle n’est pas indispensable si vous ne recherchez pas une grande précision

 

Balance version 1 : Exploitation des données

Notre système étant capable de mesure le poids de la ruche et de le transmettre par radio, il reste à exploiter les données reçues. C’est ma box domotique Jeedom qui fait tout le boulot.

Cette box domotique est disponible sous forme de logiciel prêt à installer sur tout PC fonctionnant avec Linux ou sous forme de box complète prête à l’emploi. Pour la version logiciel à installer, un mini PC type Raspberry Pi fait très bien l’affaire. Pour bâtir un système opérationnel avec matériel et logiciel installé, il faut mettre un peu les mains dans le cambouis. Tout est très bien expliqué en français sur le site de Jeedom.

Voici mes premiers relevés sur 10 jours.

Poids_temperature
Graphe du 16 au 22 juillet : poids en jaune et température ambiante en bleu. Les petits écarts sont dus à de petites opérations sur la ruche ou sur le système de mesure
Poids_humidite
Graphe du 16 au 22 juillet : poids en jaune et humidité ambiante en bleu. Les petits écarts sont dus à de petites opérations sur la ruche ou sur le système de mesure.

Malgré un temps estival entre le 17 et le 21 juillet, le poids de la ruche semble diminuer. Cette dérive peut avoir plusieurs causes possibles :

  1. dérive intrinsèque du circuit de mesure
  2. dérive du circuit de mesure due aux paramètres environnementaux (température, humidité)
  3. dérive réelle du poids de la ruche causée par son contenu (les abeilles et les provisions) ou par son enveloppe (humidité contenue dans le bois)

Je n’ai pas encore réalisé de test permettant de déterminer la ou les causes possibles.

D’après mes observations, la cause numéro 3 est la plus plausible.

  1. la période du 17 au 21 juillet a été très chaude et très sèche, le bois de la ruche a perdu son humidité.
  2. la période précédente du 11 au 15 juillet (non visible sur le graphe) fraîche, humide et très pluvieuse faisait apparaître une augmentation du poids brut de la ruche alors que les abeilles sortaient très peu. Le bois de la ruche se saturait en eau.

J’en déduis que l’information brute du poids de la ruche est relative. Elle donne une  bonne indication mais doit être pondérée avec les données météo.

Balance version 1 : Transmission des informations

Rappel sur le choix du système de transmission radio

nRF24L01 2.4ghz module émetteur-récepteur sans fil pour (pour Arduino) - noir
NRF24L01 en version de base à faible consommation
NRF24L01_PA
NRF24L01 en version longue distance avec amplificateur et antenne externe

Mon choix se porte sur le module NRF24L01 2.4Ghz pour les raisons suivantes :

  • transmission bis-directionnelle avec fonction émetteur et récepteur dans un module unique.
  • fonction intégrées puissantes avec contrôle de transmission.
  • protocole de transmission très souple permettant de transmettre des informations de toute nature.
  • très faible puissance permettant une alimentation par pile.
  • coût très réduit.

Ce module peut se connecter à de nombreux dispositifs en respectant le protocole de dialogue.

Pour mon usage, c’est le protocole MySensors qui est utilisé en association avec ma box domotique. Le site internet du projet MySensors.org est très bien documenté. Il est en anglais mais tout traducteur en ligne pourra vous aider dans votre lecture.

Arduino_Pro_Mini
Connexion du module NRF24L01 sur un Arduino Pro mini
Arduino NRF24L01+ Comment
GND GND Black
5VReg
3.3V
VCC Red
9 CE Orange
10 CSN/CS Yellow
13 SCK Green
11 MOSI Blue
12 MISO Violet
2 IRQ Gray

Note : la connexion 2 IRQ n’est pas nécessaire.

Attention : le module NRF24L01 doit être alimenté sous 3.3V. Une alimentation directe en 5V risque de l’endommager.

Voir sur le site MySensors.org pour plus de détails.

Chaîne de transmission

Pour la transmission, il faut 2 modules identiques :

  • un module connecté à l’Arduino pour l’envoi des données
  • un module connecté sur le PC de traitement pour la réception des données.

 

Balance version 1 : Mesure de poids

1 Conception mécanique de la balance (version 100kg)

Contraintes du projet

Je débute l’apiculture depuis mais 2016 avec des ruches Warré. Ces ruches sont peu courantes contrairement aux ruches Dadant très utilisées par les professionnels et d’amateurs.

Des différences essentielles caractérisent les deux modèles :

  • ruche Dadant : ruche basse et large avec un grand corps principal est un ou plusieurs éléments secondaires qui viennent se superposer pour recevoir le miel. Les rayons de cire sont dans des cadres préfabriqués.
  • ruche Warré : ruche étroite et haute avec des éléments de plus petite dimension tous identiques et superposables. Une ruche de base se compose de 2 ou 3 éléments mais ça peut monter jusqu’à 7 pur les grosses colonies et les bonnes années apicoles. Le rayons de cire sont librement construits par les abeilles sans cadres préfabriqués.

Le modèle de ruche que j’ai choisi a conditionné la mécanique de ma balance.

Les jauges de contraintes sont le moyen le plus simple et le plus fiable pour une pesée électronique. On trouve dans le commerce 2 grandes familles de cellules de pesée :

  • une cellule unique sous forme de barreau carré avec un pont de jauge complet (connexion à 4 fils) supportant tout le poids et le maintient latéral de la charge.
  • des cellules combinées sous forme de pastilles avec 1/2 pont de jauge (connexion à 3 fils) à associer 2 par 2 et ne supportant qu’une poussé verticale sans aucun maintient latéral. Pour une ruche il en faut donc 4 : une à chaque angle.

Du fait que mes ruches sont étroites et hautes, j’ai pensé que ces deux solutions n’offraient pas suffisamment de résistance au vent latéral. J’ai donc retenu une troisième solution : une base mécanique très rigide articulée comme un compas avec seulement 2 cellules positionnées sous la ruche. L’étalonnage permet de compenser la pesée partielle.

La solution que j’ai retenue

Le support de ce premier prototype est en bois de récupération. Il se présente sous la forme d’un compas avec une branche inférieure constituant le socle et recevant les deux cellules de charge et une branche supérieure constituant l’assise de la ruche.

La branche supérieure repose sur la branche inférieure par des têtes de vis qui viennent en appuis sur les points de force des cellules de charge. L’ensemble est articulé à environ 60 cm vers l’avant de la ruche de façon à avoir un report minimum de poids sur l’articulation.

Pour avoir une mesure précise, le centre de gravité de la charge (la ruche) doit être placé sur l’axe matérialisé par les cellules de charge. Afin de diminuer l’erreur de positionnement, un tasseau fixé à 35 cm constitue une butée mécanique vers laquelle le plancher de la ruche doit être placé.

support de balance : vue de dessus
support de balance version 100kg : vue de dessus
support de balance : vue compas ouvert
support de balance version 100kg : vue compas ouvert avec les 2 cellules de charge 50kg
support de balance : vue coté emplacement ruche
support de balance version 100kg : vue coté emplacement ruche

Les files de connexion des cellules de charge, très fins et d’environ 30 cm, sont protégés avec de la gaine thermorétractable. Les cellules de charge sont logées dans des cuvettes et les fils sont insérérs dans des rainures et maintenus par de la colle chaude.

Variante version 75kg

Lors de ma dernière commande, j’ai reçu des cellules de charge 75kg au lieu de cellules 50kg. Second constat ; les cellules sont à sorties 4 fils, c’est à dire qu’elles forment un pont complet (full bridge). Je dois donc modifier légèrement mon support afin d’intégrer une seule cellule sous le centre de gravité de la ruche. Il n’est pas possible de câbler 2 ponts complets sur une seule entrée du module de conditionnement. Une autre solution serait de garder les 2 cellules et de les connecter séparément sur les entrées A et B du module et obtenir ainsi une balance 150kg. Ce n’est pas cette option que je retiens actuellement.

L’avantage de la solution à une seule cellule full bridge est que les 4 fils peuvent se connecter directement sur le module. Il n’est plus nécessaire d’avoir un circuit intermédiaire pour former le pont à partir des 2 demi ponts.

Croquis coté du support

Support_balance_100kg

Support_balance_75kg

Modification de l’emplacement des cellules

Pour ma troisième version de support, j’ai déplacé les cellules à l’extrémité du support et plus sous le centre de gravité de la ruche. Ce procédé augment légèrement le poids reporté sur l’articulation mais ceci est compensé par l’étalonnage de la balance. Par contre il a l’avantage d’augmenter la distance entre l’articulation et le point de mesure. Cette distance devrait être la plus longue possible pour réduire l’influence d’un mauvais centrage ou d’un mauvais aplomb de la ruche.

2 Module de conditionnement des cellules de charge

Un petit circuit imprimé permet de transformer 2 cellules de charge à sortie 3 fils en un pont à 4 fils. J’ai réalisé celui-ci à partir d’un morceau du circuit prototype à pistes cuivrées et de barrettes de connexion mâle et femelle au pas 2.54 mm.

platine_HX711_100kg
Mini circuit imprimé permettant d’assembler 2 cellules à 3 sortie 3 fils en un pont complet à sortie 4 fils

3 Module de traitement des mesures

La connexion du module amplificateur est très simple. Coté cellule de charge : 4 fils correspondant aux 4 sommets du pont de résistance. Si les couleurs des fils sont différentes, pas de problème, il suffit de mesurer les résistances entre fils. On doit avoir environ 1000 ohms entre les sommets du pont et 738 ohms entre fils d’une même branche.

Il est possible d’intervertir excitation et output sans dommage pour la cellule. Si le signal de sortie est inversé, il suffit d’intervertir les fils d’alimentation ou les fils de sortie.

Wheatstone-Bridge
Schéma électrique d’une cellule de charge full bridge

Ci dessous le schéma de connexion du module de traitement entre une cellule à sortie 4 fils (full bridge) un un Arduino Uno. Pour un Arduino Pro Mini, le branchement est identique.

Schema_connexion_cellule
connexion HX711 sur cellule avec pont complet à 4 fils

Coté cellule de charge : alimentation E+ et E- et sortie mesure A+ et A-

Coté Arduino : alimentation Vcc et Gnd et signaux horloge (SCK) et données (DT).