Published January 23, 2020 © LGPL

Don't Worry Bee Happy

Retrieves air moisture, temperature, detects the presence of the queen bee, and also gives the weight of the bee hive.

BeginnerFull instructions providedOver 8 days1,997

Things used in this project

Hardware components

DHT22 Temperature Sensor

STM32 Nucleo STM32 L432KC

Sigfox Breakout TD1208R

SparkFun Load Cell Amplifier - HX711

Battery, 3.7 V

Solar Panel 2W

Pololu

Seeed Studio Seeed LiPo Rider Pro

Seeed Studio Seeed Grove - Universal 4 pin connector

SparkFun Female Header

SparkFun Break away header - Straight

Software apps and online services

Sigfox

arm MBED

CircuitMaker by Altium Circuit Maker

KiCad

Ubidots

Hand tools and fabrication machines

3D Printer (generic)

Soldering iron (generic)

Solder Wire, Lead Free

PCB Holder, Soldering Iron

Premium Female/Male Extension Jumper Wires, 40 x 6" (150mm)

Story

About this project

As part of our studies at Polytech Sorbonne, Sorbonne Université (ex Polytech Paris UPMC, Université Pierre-et-Marie-Curie), our teacher gave us a project which consists in retrieving air moisture, temperature, detecting the presence of the queen bee and gives the weight of the bee hive. The goal is to monitor on site and online the hive’s environment.

Temperature / humidity acquisition

The temperature of a hive and its humidity says a lot about its condition. It is possible to know if the bees are still active or if the temperature inside the hive is insufficient for the survival of the bees. To collect this information, we use a DHT22 sensor which captures both the temperature and humidity of the air.

Mass acquisition

The weight of the hive is an important factor for the beekeeper. It lets you know if the hive is healthy and it also lets the beekeeper know when to harvest honey. To weigh the hive, we opted for a system that contains a strain gauge (sensor) coupled with an HX771 amplifier. This allows loads of up to 200kg to be weighed while being reliable under unfavorable climatic conditions.

Sound acquisition / processing

The sound produced by the colony is a precious source of information for the beekeeper. Once the audio signal has been captured and processed, the program embedded in the microcontroller will be able to deduce two crucial pieces of information:

presence or not of the queen in the colony
detection of the start of swarming: when the colony becomes too large, the queen and part of the colony leaves in search of a place to build a new hive. It is useful for the beekeeper to know when the swarming is going to take place so that he prevents it and thus keeps his entire colony.

These two pieces of information are detectable by the frequency of the sound that the colony produces. If one of these two frequencies is detected, it is possible to send the queen presence or swarming information to the remote web interface.

At regular time intervals, the system picks up the sound from the hive using a microphone / amplifier and calculates the FFT (Fourier Transform) in order to obtain all the frequencies contained in the audio signal. It then remains to be seen whether the characteristic frequencies sought are in this set of frequencies.

Power management

The system must be self-sufficient in energy. To accomplish this, we power the STM32 card using a solar panel and a Lithium battery which will take over when the sun is not enough. A power card serves as an intermediary between the 3 components, the latter was designed on the basis of the Lipo Rider card in less energy.

The main goal of the connected hive project is to develop a swarm monitoring system. All the information will be taken directly on or in the hive, then send by wireless transmission module in order to view this data on a clear online interface.

Once the project is completed, it will above all serve beekeepers to optimize their harvest while ensuring the sustainability of the hive

We will use IoT technology for wireless data transmission and services from Sigfox. Sigfox limiting the sending of messages to 140 per day we will have to make sure to send messages every 10 minutes.

As for data display, the Ubidots platform allows you to view the information retrieved by the Sigfox service on any medium via the Web.

1) The code

To develop our project, we used Mbed, a collaborative online programming software that helped us finish our project. The special part of this website is that you can edit your code wherever you want.

Another advantage of MBED is the possibility to find a great number of microcontrollers libraries.

Here are the 3 main parts of our program :

measure of the weight
measure of temperature and humidity with the DHT22
detection of the sound of the queen bee before swarming

For the latter, we will explain what we do to detect the sound of the queen bee :

we sample the surrounding sound of the bee hive with our microphone
we calculate the FFT of this sound
we look at the amplitude of the frequencies in the FFT that interest us

The frequency we are interested in are around 380Hz. We found this value by listening to youtube videos where the queen bee makes this sound.

When the queen bee makes her sound, we see that the amplitude around 380Hz are higher than when she doesn't. We simply have to find a threshold experimentally so that we can consider that when the amplitude around 380Hz is higher than that threshold than it means that the queen bee is making her sound.

We are constantly listening for the presence of the queen bee, but when we send the message for the presence of the queen bee, we stop listening.

2) The card

Finally, we chose Altium and Kicad to create our PCB. Kicad is also a free tool and it’s very friendly for student, Altium need a license, there are many useful libraries, it’s very helpful to check the component is adaptable or not.

KiCad

3) The box

The last part is about how to package our system. To be original, we have drawn our own box in 3D with Cad, an open source software that allows us to draw our box easily and in details.

3D box:

We also designed a box for the sensor humidity and the solar panel.

System complete:

Dashboard in Ubidots

Custom parts and enclosures

Error uploading file to Sketchfab.

Schematics

Code

Main function

#include "mbed.h"
#include "DHT.h"
#include "HX711.h"
/* Include arm_math.h mathematic functions */
#include "arm_math.h"
/* Include mbed-dsp libraries */
#include "arm_common_tables.h"
#include "arm_const_structs.h"
#include "math_helper.h"


/* FFT settings */
#define SAMPLES                 512             /* 256 real party and 256 imaginary parts */
#define FFT_SIZE                SAMPLES / 2     /* FFT size is always the same size as we have samples, so 256 in our case */
#define SEUIL                   0.6
#define TEMPS_ATTENTE_CAPTEURS  10 //mettre 10
#define TEMPS_ATTENTE_ENVOI_MSG_REINE  1

DigitalOut myled(LED1);
Serial pc(USBTX,USBRX); // Déclaration du port série USB
Serial device(D1,D0);
HX711 Balance(D5,D6);   // Déclaration de l'objet HX711
DHT sensor(A7,DHT22);   // Use the DHT22 sensor

Timer timerSon;
Timer timerCapteurs;
Timer timerEnvoiMsgReine;
bool msgReineEnvoye = false;
int reineEstPresente = 0;

/* Global variables */
float32_t Input[SAMPLES];
float32_t Output[FFT_SIZE];
bool      trig=0;

AnalogIn loudness(A6);
Ticker     timer;

/*Sensor variables*/
int err;


long valeurHx;
long valeurHxTare ;
double poids;

void sample(){
    trig=1;
}


void tacheCapteurs(void) {
    printf("\r\nDHT Test program");
    printf("\r\n*******Dont Worry Bee Happy***********\r\n");
    myled = 1;
         
    valeurHx = Balance.getValue(); // On récupère la valeur du module
    poids = ((double)valeurHx-(double)valeurHxTare)/11500;  // Conversion de la valeur de l'ADC en grammes
    poids = 1000*(poids/1.88);
         
    err = sensor.readData();
    printf("Temperature is %4.2f C \r\n",sensor.ReadTemperature(CELCIUS));
    printf("Humidity is %4.2f \r\n",sensor.ReadHumidity());
    printf("weight is %4.2f \r\n",poids);
        
    wait(1);
    
    printf("\r\nErr %i \n",err);
    myled = 0;            
        
    pc.printf("Valeur : %ld   valeurTar: %ld      Poids : %.3lf\n\r",valeurHx,valeurHxTare,poids);    // Affichage du poids
    
    //Envoi vers Sigfox
    device.printf("AT$SF=%02X%02X%04X%02X\r\n",(int)sensor.ReadTemperature(CELCIUS),(int)sensor.ReadHumidity(),(int)poids, (int)reineEstPresente);

}


int main() {
    pc.baud(9600);
    valeurHxTare = Balance.getValue(); 

    //timerSon.start();
    timerCapteurs.start(); 
    timerEnvoiMsgReine.start();
    
    wait(1); // wait 1 second for device stable status
    pc.printf("\nDebut Enregistrement\n");
    
    while (1) {
        //if(!msgReineEnvoye) {
         //   tacheSon();
        //}
        
        if (timerCapteurs.read() > TEMPS_ATTENTE_CAPTEURS) {
          tacheCapteurs();
          timerCapteurs.reset();
        }
        
        if(timerEnvoiMsgReine.read() > TEMPS_ATTENTE_ENVOI_MSG_REINE) {
            msgReineEnvoye = false;
            timerEnvoiMsgReine.reset();
        }
    }
}