•

•

•

Published January 18, 2022

Bee-Happy - Connected beehive

A connected hive is the beekeeper's best ally for monitoring bees, making bee monitoring easier and saving the beekeeper time.

BeginnerFull instructions provided2,408

Things used in this project

Hardware components

Maxim Integrated DS18B20 Programmable Resolution 1-Wire Digital Thermometer

DHT22 Temperature Sensor

Arduino Nano 33 BLE Sense

SparkFun Load Cell Amplifier - HX711

solar panel SOL2W. .

Carte LiPo Rider Pro 106990008

Batterie Li-Ion 3,7V 1050 mAh

Grove Connector

Antenne Sigfox, LoRa et GSM X000016

Sigfox Breakout board BRKWS01

Software apps and online services

fritzing

Hand tools and fabrication machines

Bantam Tools Desktop PCB Milling Machine

PCB Holder, Soldering Iron

Solder Wire, Lead Free

Wire Stripper & Cutter, 18-10 AWG / 0.75-4mm² Capacity Wires

Soldering iron (generic)

Hot glue gun (generic)

Drill / Driver, Cordless

Digilent Mastech MS8217 Autorange Digital Multimeter

Breadboard, 270 Pin

Plier, Cutting

3D Printer (generic)

Servo Motor, Premium Male/Male Jumper Wires

Story

Context

For the last ten years, the bee population has been decreasing very sharply, with a total disappearance in certain areas. The CCD (colony collapse disorder) suddenly causes the disappearance of bees in the hives without any dead bodies being found nearby.

To fight against this phenomenon, we have worked on a connected hive, which allows easier monitoring of the bees and time saving for the beekeeper. It also allows a reduction in the mortality rate of bees and optimization of the yield of the hives.

We have developed an embedded system to measure several physical quantities and make them available to the beekeeper on a web application.

Thus, we decided to monitor :

The inside temperature of each frame of the hive
The outside temperature
The inside humidity of the hive
The light received
Its weight

Why these sensors?

Measuring the temperature on each frame makes it possible to determine the approximate number of bees in the colony.

The measurement of the external temperature makes it possible to check whether the insulation of the hive is functional.

Measuring the humidity in the hive helps to prevent the onset of certain diseases (in particular Nosema, which seals the fate of the hive as it is incurable) if the hive is too wet.

The luminosity helps the beekeeper to place the hive.

The weight measurement allows the beekeeper to visualize the honey flow or to notify the beekeeper of abnormal weight drops.

Project planning

Description of the general system

General system

To have a permanent follow-up of the state of its hive, the various sensors installed on the BEE HAPPY hive are:

Inside the hive:

3 Groove DS18B20 temperature sensors are arranged as follows: one at each end of the hive and one in the center
1 DHT22 humidity sensor in the center of the hive

Outside the hive:

1 weight sensor
1 DHT22 temperature and humidity sensor
1 solar cell with a photoresist

Final schematic with PCB (printed circuit board)

We have designed the PCB in Kicad:

Kicad schematic

This schematic represents the first step of the PCB design.

In this schematic, you can see all the components used and to be included in the PCB. The schematic is divided into several blocks and we opted for labels to make our schematic clearer.

You can see our Arduino nano board, our two DHT22, the three external temperature sensors, the weight sensor, the Wisol module, the photoresistor, the led, and finally the power supply block.

Once printed, we start by soldering the cms and the LDO (Low-dropout regulator), before adding the resistors and the various connectors (grove and others).

NOTE: We put an LDO that is to say a voltage regulator which allows us to regulate the output voltage to 3.3V. Indeed, using an LDO allows avoiding the double conversion 5V =>3.3V and thus consuming less energy. To use this LDO, we cut the 3.3 line of the card and place the two jumpers which allow the card to operate in 3.3Vand which consume much less energy.

Finally, when everything is well soldered, we get to the end of the PCB design, and it's time to connect all our sensors and test the system:

PCB schematic

Here is our final system:

Final system

System communication with Sigfox and Ubidots

The Sigfox module

We used a kit with a Sigfox telecommunication module and a Lora and Sigfox antenna. In the same way, as for a classical operator, we need to take out a subscription. The kit offers a 1-year subscription with which you can, per day :

send 140 messages,
receive 4 messages.

A message is 12 bytes maximum.

Sigfox module

To be able to send messages, we need to activate the Wisol module. To do this, we must go to the Sigfox activation page: https://buy.sigfox.com/activate.

You will be asked, among other things, to fill in the following information successively:

- your country, the unique identifier (ID) and the PAC code specified on the module's packaging, an email address and a password.

If it is not included, you will have to take out an annual subscription to send at least 100 variables per day (11 euros HTC). Once the activation is complete, your sent messages will be viewable on the Sigfox backend: https://backend.sigfox.com/auth/login

Ubidots platform:

To see the latest data from your hive, log in to Ubidots via the following link: https://stem.ubidots.com/accounts/signin/ with :

a username and a password:

you should arrive on this interface:

Ubidots

Then click on Data =>Dasboard.

At this point you should be on the dashboard and viewing the following page:

Dasboard designed

On this page, you will be able to view all your data and follow their evolution over time, including indoor and outdoor temperatures on the same graph, indoor and outdoor humidity, hive weight, battery percentage, and luminosity.

Project code

The final code can be found in the files provided at the end of this article. Our code is organized in small functions in which, using the library made available through the Arduino IDE, we retrieve the various data measured by the different sensors.

In the void setup() function, the code is organized as follows:

We initialize the different elements we need in our void loop() function. The dhts, the scale ( and its settings), as well as the pins for the LEDs and the button are thus declared.

Here we test the state taken by the pin to which the button/switch is connected. If the pin is high (i.e. equal to 1), the button is on and the system is therefore in a working state. The green LED is then lit to let the user know if the system is switched on.

Declaration of the variables that will be used in the various function calls.

Initialization of the weight table and the frame table. Concerning the weight, we decided to take 10 successive measurements of the weight and to average them to have a more precise value and less fluctuation from one callback to another. We initialize the frame table to 0 so that the cells do not contain unknown values.

Calling the different functions to fill the previously declared variables with the measurements made by the different sensors.

Here we fill the different cells of the frames with our different variables. frame[3] being an array of int each cell has a size of 32 bits. Therefore, we fill it accordingly and by shifting. For more information, you can refer to the representation of our frames provided below.

We display the frames, this print allows us to control the frames sent to Sigfox. Then, thanks to the command "AT$SF=" we send the frames to Sigfox.

After that you can see a calling up the sleep and wake-up function, detailed in the following article. Setting up a delay to put the system to sleep.

Project code and code optimization to reduce power consumption

The measurement of the system's power consumption was carried out with the Otii development tool.

To optimize the system we decided to turn off some components of our system during the delay set in our code.

In this optimization function called "sleep", we turned off the scale, turned off the pull-up resistors, and the I2C port useless here, we also decided to turn off sensors and the green LED. In the "wake up" function, we wake up the scale, so that the sensors can perform their measurement.

The average consumption of the system after optimization is 3.427 mAh which gives a system autonomy of about 13 days.

Recharge of the system

For the system to be autonomous, we have coupled a battery and a photovoltaic panel, in particular through the use of the lipo rider pro module. This ensures the autonomous operation of our system.

Recharging system

Prerequisites

Microcontroller (programming language Arduino)
Electronics (Numeric & Analogic)
PCB
Computer scienceIt took us 4 months to almost complete this project.

Code

Code

#include "DHT.h"

#define MAXIMWIRE_EXTERNAL_PULLUP
#include <MaximWire.h>

#include "HX711.h"

//TEMPERATURE INTERNE
#define PIN_BUS D3
MaximWire::Bus bus(PIN_BUS);
MaximWire::DS18B20 device;
#define PIN_BUS1 D4
MaximWire::Bus bus1(PIN_BUS1);
MaximWire::DS18B20 device1;

//TEMPERATURE EXTERNE
#define DHTPIN 2  // Digital pin connected to the DHT 
#define DHTPIN2 7

DHT dht[] = {
  {DHTPIN, DHT22},
  {DHTPIN2, DHT22},
};

//POIDS
const int LOADCELL_DOUT_PIN = 5;
const int LOADCELL_SCK_PIN = 6;
int zero;
HX711 scale;

//BATTERIE
const int BATTERYPIN = A0;    //pin de la batterie
const float TensionMin = 3.2; //tension min
const float TensionMax = 4.2; //tension max

// PHOTORESISTANCE
int photocellPin = A1; 
int valLum =0; 
float Luminosite;

//BOUTON DE POUSSOIR
int bouton;  
const int led = D8; 

/**     FONCTION BATTERIE      **/
int getBattery ()
{
  int b = analogRead(BATTERYPIN); //valeur analogique
  float Vin,Vbat;
  Vin =(float(b)/1024)*3.3;
  Vbat=Vin*(float(197)/float(150));

  int p = ((Vbat - TensionMin) / (TensionMax - TensionMin)) * 100; //mettre en pourcentage

  if (p > 100) //max is 100%
    p = 100;

  else if (p < 0) //min is 0%
    p = 0;

  Serial.print("Batterie:");
  Serial.println(p); 
  return p;
}


/*  tab[0] => temp_ext , tab[1] => temp_int, tab1[0] => hum_ext,tab1[1] => hum_int  */
/**     FONCTION TEMPERATURE INTERIEUR/EXTERIEUR DHT22      **/
int getTempHum_ext(int* tab,int* tab1,int count){
  float temp[2];
  float hum[2];
  for(int i = 0; i<2; i++){
    temp[i]=dht[i].readTemperature(); 
    hum[i]=dht[i].readHumidity(); 
  }
  count++;
  for(int i=0;i<2;i++){
    tab[i] = round((temp[i]+15)*10);
    tab1[i] = round(hum[i]*10);
  }
    Serial.print("Temperature_ext:"); 
    Serial.println(tab[0]); 
    Serial.print("Humidite_ext:"); 
    Serial.println(tab1[0]); 
    Serial.print("\t"); 

    Serial.print("Temperature_int:"); 
    Serial.println(tab[1]); 
    Serial.print("Humidite_int:"); 
    Serial.println(tab1[1]); 
  return count;
}

/**     FONCTION TEMPERATURE INTERIEUR      **/
void getTemp_int(int* tab,int* tab2){
  MaximWire::Discovery discovery = bus.Discover();
  MaximWire::Discovery discovery1 = bus1.Discover();
  int i = 0; 
  int k=0;
   do {
       MaximWire::Address address;
       if (discovery.FindNextDevice(address)) {
           if (address.GetModelCode() == MaximWire::DS18B20::MODEL_CODE) {
               MaximWire::DS18B20 device(address);
                 float temp = device.GetTemperature<float>(bus);
                 
                 tab[i] = round(temp*10); 
                 Serial.print("temp =");
                 Serial.print(temp);
                 Serial.print(i);
                 Serial.print("*C\t");
                 Serial.println();
                
                 i++; 
                 device.Update(bus);
           } else {
               Serial.println();
           }
       } else {
           Serial.println("NOTHING FOUND");
       }
    } while (discovery.HaveMore());  

   do {
       MaximWire::Address address1;
       if (discovery1.FindNextDevice(address1)) {
           if (address1.GetModelCode() == MaximWire::DS18B20::MODEL_CODE) {
               MaximWire::DS18B20 device1(address1);
                 float temp1 = device1.GetTemperature<float>(bus1);
              
                 tab2[k] = round(temp1*10); // diviser par 20 sur ubidots 
                 
                 Serial.print("temp1 =");
                 Serial.print(temp1);
                 Serial.print("*C\t");
                 Serial.println();
                 k++; 
                 device1.Update(bus1);
           } else {
               Serial.println();
           }
       } else {
           Serial.println("NOTHING FOUND**");
       }
    } while (discovery1.HaveMore());
    }
    
/**     FONCTION POIDS      **/   
int getPoids(int* tab){

  float temp = 0;
  int poids_reel = 0;
  

  for(int i=0;i<10;i++){
    float p = scale.get_units(10);
    Serial.print ("poids:");
    Serial.print(p);
    Serial.println("kg\n");
    tab[i] = round(p*10);
    temp+=tab[i];
  }
  poids_reel = temp/10;
  return poids_reel;
}

/**    FONCTION PHOTORESISTANCE   **/
int photoRes(void){
  
  valLum = analogRead(photocellPin);
  int a = (float(valLum)/1024)*100;
  Serial.print("lum "); 
  Serial.println(a);
  return a;
  
}

void sommeil(){
  scale.power_down();
  digitalWrite(PIN_ENABLE_I2C_PULLUP,LOW); //teindre rsistance de pull-up 
  digitalWrite(PIN_ENABLE_SENSORS_3V3,LOW); //teindre les capteurs
  delay(3000);
  
}

void reveil(){
   scale.power_up();
   delay(5000);

}

void setup() {
  Serial1.begin(9600);
  digitalWrite(LED_PWR,LOW); //teindre la Led 
  dht[0].begin();
  dht[1].begin(); 
  scale.begin(LOADCELL_DOUT_PIN, LOADCELL_SCK_PIN);
  scale.set_scale(28881.84f);
  zero = 132606;
  scale.set_offset(zero);

  pinMode(bouton, INPUT); // Initialise la broche 4 comme entre
  pinMode(led, OUTPUT);   // Initialise la broche 12 comme sortie
}


void loop(){

// si l'on appuie sur le bouton alors le sytme est en marche
if (digitalRead(bouton) == 1){
     digitalWrite(led,HIGH);
     delay(2000);
     digitalWrite(led,LOW);
     
    int bat = 0; 
    
    // variables pour la temprature et humidit externe
    int count=0;
    int temp_extint[2];
    int hum_extint[2];
  
    // variables pour la temprature interne
    int temp_int[3]; 
    int temp_int1[3];
  
    // variable pour le poids 
    int poids[10];
    int poids_reel =0;

    // variable pour les trames 
    int trame[3];
  
    //valable pour photorsistance
    int pRes =0;

    for(int i=0;i<10;i++){
      poids[i] = 0;
    }
  
    for (int j=0;j<3;j++){
      trame[j]=0;
    }
    
    poids_reel=getPoids(poids);
    bat = getBattery(); 
    count = getTempHum_ext(temp_extint,hum_extint,count);
    getTemp_int(temp_int,temp_int1);
    pRes= photoRes();
  
    trame[0]= (temp_extint[0] << 22) | (hum_extint[0] << 12) | (temp_int[0] << 2);
    trame[1] = (temp_int[1] << 22)| (temp_int1[0] << 12)|(poids_reel<<2);
    trame[2] = (hum_extint[1] <<22)|(bat << 12)|(pRes<<2); 
   
  
    if(count < 3){
      Serial1.println("AT$SF="+String((int)trame[0],HEX)+String((int)trame[1],HEX)+String((int)trame[2],HEX));
      Serial.println("AT$SF="+String((int)trame[0],HEX)+String((int)trame[1],HEX)+String((int)trame[2],HEX));
    }
   sommeil();
    delay(15000); 
   reveil();
}
}

Credits

Thanks to Team bee happy. .

Comments

Please log in or sign up to comment.

Bee-Happy - Connected beehive