Le capteur que j’ai réalisé n’a pas la prétention d’un véritable capteur de mesure mais il a l’avantage d’être rudimentaire et de donner une bonne indication sur le rayonnement solaire.

Construction

Ce petit dispositif de mesure du rayonnement solaire a 2 fonctions :

• il complète ma station météo avec une indication sur l’ensoleillement journalier
• il permet de prendre en compte l’ensoleillement dans la gestion de mon chauffage en anticipant l’arrêt du planché chauffant et s’affranchir de son inertie.

Le pyranomètre se présente sous la forme d’une sphère transparente renfermant un capteur de température DS18B20. La sphère en verre est une boule de décoration de Noël. Le fait qu’elle soit en verre permet de pérenniser son excellent luminosité. On trouve très facilement des boules de Noël en plastique mais elles ne sont pas de la même qualité.

Le capteur est peint en noir mat pour mieux absorber le rayonnement infrarouge. Les fils de connexion passent dans un tube en caoutchouc (récupération d’un tuyau de gaz) qui assure la fixation mécanique de la sphère et un tube électrique qui assure la rigidité. L’assemblage n’est pas étanche mais permet l’écoulement des éventuels condensats.

Afin d’assurer une bonne rigidité face au vent, le support est constitué de 2 tubes électriques concentriques. Le pyranomètre est installé sur le toit de mon abri de jardin afin de bénéficier d’un ensoleillement optimum.

Principe de mesure

La conception matérielle de ce capteur est inspirée de celle de Michel.mo http://michel.mo.pagesperso-orange.fr/ensoleillement/1_generalites.htm avec un dispositif un peu plus élaboré et des précisions sur le principe de la mesure. Pour la partie logicielle, je n’ai pas de logiciel spécifique, les calculs sont réalisés par ma boxe domotique.

Le principe de mesure d’ensoleillement est basée sur 2 températures :

• la température mesurée sous abri issue de ma station météo
• la température mesurée par le pyranomètre

La différence entre les 2 mesures est le reflet de la puissance du rayonnement solaire. La corrélation avec l’altitude du soleil variable en cours de journée et dépendant de la saison permet de gérer l’intensité de l’ensoleillement.

Mesures obtenues

Ce dispositif très sensible et très réactif aux changements d’ensoleillement n’as pas une réponse linéaire. Il présente une courbe aplatie et la corrélation n’est pas parfaite avec l’altitude du soleil donc la puissance du rayonnent. La température de la sphère se stabilise avec un maximum de 25°C plus élevée que la température sous abri.

Image ci-dessus par temps froid et ensoleillé au mois de mars : température extérieure sous abri 6°C et température différentielle stabilisée autour de 20 à 22°C.

L’algorithme déterminé mis au point par ajustement permet de déterminer le niveau d’ensoleillement. On voit que les petits passages nuageux vers 12, 15h30 et 16h sont bien détectés.

• la mesure est très sensible à tout inclinaison de la ruche vers l’avant ou l’arrière, ce qui provoque le déplacement du centre de gravité et par là une variation de la mesure.
• le support est composé de deux parties identiques superposées qui nécessitent beaucoup de bois.
• lors des épisodes pluvieux le bois s’imbibe d’eau ce qui fausse la mesure

Le support version 2 comporte 4 cellules de capacité 50 kg portant la charge maximale à 200 kg. C’est surdimensionné mais a pour avantage  de pouvoir assembler les 4 cellules et former un seul pont connectable sur un unique HX711. Les cellules de calibre inférieur (20 kg) disponibles dans le commerce sont pourvues de connexions à 4 fils. Chaque cellule forme un pont de mesure complet, ce qui nécessite plusieurs amplificateurs de mesure HX711.

J’ai profité de changement de conception mécanique pour revoir le passage des connexions et la programmation du module Arduino.

1 Le support

Ce support est une base en bois réalisée à partir d’une moitié de support version 1. Ceci me permet de faire deux bases version 2 à partir d’un support récupéré sur la version 1.

Le plateau support épouse la dimension d’une ruche Warré : 30 x 30 cm.

Quatre équerres vissées sur la base (non présentes sur cette photo) assurent le positionnement précis (avant – arrière) du plateau support en laissant un jeu de mobilité.

Deux cornières en aluminium 5 x 5 cm d’épaisseur 2 mm forment les cotés latéraux reliés par deux traverses en bois. Quatre vis de 5 mm à têtes fraisées bloquent l’ensemble.

Les têtes de vis viennent s’insérer dans des cuvettes conique et laissent le dessus du support sans aspérités. Les extrémités de chaque vis d’assemblage comportent deux écrous bloqués formant une mini cuvette de centrage sur chacune des 4 cellules de pesée.

Les 4 cellules de pesée sont placées aux 4 angles de la ruche. Leurs connexions électriques sont réunies dans un premier boîtiers contenant également l’amplificateur de mesure HX711.

Un second boîtier renferme le reste de l’électronique avec un module Arduino Pro Mini, un régulateur 5V 7805, un régulateur 3.3V LE33, un module de liaison radio NRF24L01 et un mini écouteur faisant office de buzzer. L’alimentation primaire de plusieurs balances passe par un module à haut rendement LM2596 qui converti le 12V en 7V. Le premier régulateur  du boîtier Arduino (7805 : 7V vers 5V) fonctionne en condition optimale sans échauffement perceptible. Le second régulateur LE33 fournit l’alimentation de module NRF24L01.

Un tube PVC relie les deux boîtiers pour le passage des fils. Tout est étanchéifié avec du mastique silicone.

Un capteur de température DS18B20 placé au contact direct de la cellule arrière gauche (à l’opposée du soleil) est relié à la platine Arduino en passant par le premier boîtier et le tube.

Le plateau supérieur est légèrement plus large que la base de façon à laisser un jeu de 1 mm de chaque coté. Les deux profilés latéraux couvrent la base qui est ainsi protégée des intempéries et est guidée latéralement.

Une petite cale en PVC évidée en partie centrale pour éliminer toute contrainte mécanique à la partie sensible de la cellule de pesée assure le positionnement précis par 4 vis à têtes fraisées. Ces cales en PVC ont été découpées dans une chute de récupération de tableau électrique.

L’idéal serait de les dessiner de façon précise avec un logiciel de CAO et de les fabriquer à l’aide d’une imprimante 3D. Je n’ai pour l’instant pas estimé utile d’investir dans ce matériel. Une alternative possible : les faire réaliser par un service en ligne sur Internet.

La vis d’appuis du plateau est terminée par deux écrous bloqués de façon à laisser subsister une petite cuvette de centrage. Cette cuvette vient se positionner sur la pointe de pesée.

Note : sur la version terminée les vis ont été raccourcies pour abaisser le plateau et permettre aux profilés latéraux de descendre de chaque coté de la base.

2 Platine HX711

Les cellules 50 kg sont des modèles à sortie 3 fils de type half-bridge . Ces cellules peuvent être assemblées 2 par 2 ou 4 par 4 pour former un pont complet en full-bridge.

Le pont de jauge alimenté entre E+ et E- délivre son signal de mesure entre A+ et A-. Un petit circuit imprimé connecte les 4 cellules de mesure avec sorties E+E-A+A-.

Pas encore de photo pour la mini platine de raccordement !

3 Platine Arduino

croquis à venir

4 Programme Arduino

Le scketch Arduino Balance_api_V4 est découpé en 4 fichiers :

• Balance_api.h : contient toutes les constantes de paramétrage de l’application
• Balance_api.ino : contient toutes les fonctions de l’application
• Pendule.h : contient les définitions publiques et privées de la classe Pendule
• Pendule.cpp : contient les fonctions de la classe Pendule
• pitches.h : contient les définitions des notes et des mélodies à jouer.

Balance_api_V4-2018-02-23

Note :la version V4 du scketch Arduino est compatible avec cette version  2 du support mécanique.

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.

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.

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

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.

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.

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.

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.

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é.

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.

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.

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.

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).

Je me lance dans l’apiculture depuis cette année. Je ne vais pas bouder les produits de la ruche, en particulier le miel dont je suis friand mais ma motivation principale est l’observation. A cette fin, j’ai installé mes premières ruches à proximité de ma maison afin de pouvoir les observer à loisir.

Quel est le rapport avec Arduino ? Réponse ; une balance électronique connectée!

Les systèmes de balance connectées pour ruches existent déjà chez les professionnels. Pour un amateur c’est également possible mais le prix de l’équipement est dissuasif. Après avoir longuement fureté sur internet, je pense pouvoir réaliser un prototype  personnalisé à mon besoin et à moindre frais.

Une balance connectée, à quoi ça sert ?

Cette balance connectée me permettra, je l’espère, de donner une dimension quantifiable à mes observations visuelles. Un rapprochement des informations de la balance avec celles de ma petite station météo connectée devrait permettre de suivre la vie de la colonie en fonction de la météo.

Pour information, les informations collectées par ma station météo sont visibles sur : https://www.wunderground.com/personal-weather-station/dashboard?ID=IFRANCHE14

Mon projet s’articule en deux parties :

1. une plate forme de mesure associée à un dispositif de transmission des informations placés sous la ruche au fond de mon jardin
2. un système informatique de réception et de traitement des données situé dans ma maison

Le système doit assurer les fonctions suivantes :

1. prendre une mesure de poids périodique
2. transmettre cette information vers mon système domotique
3. mettre en forme les données pour les afficher sous forme de tableau et de courbe
4. diffuser l’information sur ce site
5. surveiller toute variation de poids anormale comme un essaimage en cours ou un désordre sur la ruche et déclencher une alarme par notification push, e-mail ou SMS.

Suite à mes premiers tests et mes premières recherches des composants adéquats, mon dispositif devrait s’articuler comme suit.

1 Mesure du poids

Les jauges de contraintes sont le moyen idéal pour cette mesure. On en trouve sous forme de module prêts à utiliser sur les boutiques de commerce en ligne comme eBay pour environ 7€. Celles-ci ont une capacité totale de 200kg soit 50kg par module. Je n’utilise que 2 modules par balance ce qui me permettra d’en réaliser 2.

Ce type de composant délivrant une tension de quelques millivolts seulement, il est nécessaire d’amplifier le signal recueilli et le convertir en information digitale pour le rendre exploitable par système numérique.

Mon choix s’est porté sur le composant HX711 qui a été conçu spécifiquement pour cet usage. Il intègre un étage amplificateur et un convertisseur analogique- numérique 24 bits et comme avantage supplémentaire d’être compensé en température et de délivrer ses information sur une interface série numérique, donc directement exploitable pour un traitement informatique. On le trouve très facilement sur les plates-formes de vente en ligne pour à prix très modique au vu de ses performances.

Je ne vais pas m’étendre sur la technologie et le principe de mise en œuvre, Internet vous donnera toutes ces informations. La boutique Sparkfun est une mine d’information dans le domaine des tutoriels électroniques.

2 Traitement des informations

Pour ce prototype, j’utilise un module ATmega328P Pro Mini pour le traitement des données. Il existe 2 variantes ; une version 5V 16Mhz et une version 3.3V 8Mhz.

3 Exploitation des données collectées

Il y a d’immenses possibilités dans ce domaine : stockage local sur carte SD, transmission vers un système informatique, connexion à un réseau local via Wifi ou réseau filaire,  transmission par réseau téléphonique GSM, envoi périodique de tableau de bord, etc.

Tout dépend de la situation géographique du rucher et des possibilités. Dans mon cas, je transmet les données à ma box domotique qui intègre nativement toutes les fonctions de stockage et de présentation des données.

Pour ce faire, il y a deux possibilité : transmission filaire ou transmission radio. La  transmission filaire, la plus simple et la plus fiable, nécessite des travaux de petit terrassement. La transmission radio est plus complexe à mettre en œuvre mais ne nécessite pas de travaux. C’est celle que j’utilise dans cette première version.

Une multitude de modules prêts à l’emploi existent. Ils se distinguent par leur fréquence radio : 433 MHz, 868 MHz et 2.4 GHz essentiellement.

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 sur batterie.
• coût très réduit.

Il a pour principal inconvénient sa portée limitée et très perturbée par les obstacles physiques : murs et dalles des bâtiments ou végétation dense.

Un système répéteur ou l’utilisation d’un module amplifié permet de contourner en partie ce problème.

4 Principe de fonctionnement

Le module Arduino déclenche une mesure de poids périodique environ toutes les 5 à 10 minutes et la transmet par radio vers mon système domotique.

En cas de variation de poids supérieur à 0.01kg (10 grammes), la transmission se fait immédiatement.