•

•

•

Published January 18, 2022

The beehive of the future

A smart beehive that can keep the beekeeper in the know about everything related to the beehive and to the bees.

IntermediateShowcase (no instructions)24 hours491

Things used in this project

Hardware components

Arduino MKR Fox 1200

DHT22 Temperature Sensor

SparkFun Load Cell Amplifier - HX711

Rechargeable Battery, 3.7 V

Solar Panel, 2.5 W

Weight sensor

Adafruit Waterproof DS18B20 Digital temperature sensor

Software apps and online services

Arduino IDE

Sigfox

Microsoft Windows 10

CircuitMaker by Altium Circuit Maker

Ubidots

Hand tools and fabrication machines

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

Solder Wire, Lead Free

Soldering iron (generic)

Hot glue gun (generic)

Drill / Driver, Cordless

Multitool, Screwdriver

Breadboard, 170 Pin

Digilent Mastech MS8217 Autorange Digital Multimeter

Story

Overhead view :

Introduction :

This article will be centred around the Connected BeeHive project, done as part of our fourth year of the “EI-2I”cycle at Polytech Sorbonne.

In this project, we created a system that will be linked to a BeeHive, and it will allow us to collect data about the beehive using captors linked to an Arduino card.

The main goal is to send this data through SigFox, and make it visible and accessible to the bee farmer, giving him the option to monitor his beehive and bees.

System objectives :

The system should allow us to capture and send the following values :

o The external temperature.

This information is important for the bee farmer, it allows him to predict and explain bee behaviour.

o The internal temperature.

Allows the farmer to detect any irregularities.
The existence of three captors also allows the farmer to get an idea about the bee expansion inside the beehive.

o The external humidity.

This info can be an indication for the amount of honey and the number of bees in the beehive.also allowing him to take action in case of extreme situations.

o The total weight and mass of the Hive.

This info can be an indication for the amount of honey and the number of bees in the beehive.

o The current level of the battery.

Despite the fact that the battery is charged through a solar cell, having this information allows the farmer to identify if there is a problem with the charging or with the energy user.

o The luminosity received by the solar panel/cell.

This goes hand in hand with the battery level, it would allow the farmer to recognize if there is a problem with energy intake.
It would also allow the farmer to get information about the situation in case he is far from his beehive.

The data needs to be readable and understandable without further analysis, The farmer should be able to check on it throughout the day, and understand if everything’s going well, or if there is a problem on first look.

It is also important to make a durable system, that needs the least amount of maintenance possible.

The system :

The basic structure :

Basic system structure

We can see above the structure of the system, all the sensors are linked to our main piece, the Arduino MKR FOX 1200 card.

Our card takes the sensors data in, and prepares it for export to Sigfox, this exportation is done using an antenna and the Sigfox module on the card. The data is then processed by Sigfox and attributed to all the different variables.

The data received by Sigfox

The data is then sent to Ubidots, to give it visibility.

Data display on Ubidots

We can represent the system in the following way :

Simplified view of our system

The system starts with the beehive, and ends at the user, in our case, it’s the farmer himself, just like it would have before the implementation of our system, except now, we simplify the analysis part of the process, allowing the farmer to use his time for more important tasks, while giving access to data he wouldn’t have gotten without bothering the beehive system.

Data acquisition :

As explained before, the data is received on the Arduino MKR FOX 1200 card from the sensors, it is then processed by the card, mainly by using the Arduino libraries for each sensor, and incorporating them into our software.

The processing includes reading the data, adjusting it into the right magnitude, the right unity, then defining the precision we want the value to be in, this is important, because we have to be aware of the amount of data we are sending through Sigfox, since we can only send 12 Bytes of data at once.

Another step to be taken with the data acquisition, is the data calibration, this is important because sensors are often not perfect, and do not always report the exact values, this means we have to add in some software adjustments to get closer to the actual value, as an example, this calibration was necessary for the weight, where we used a known mass, with allowed to get the necessary adjustments.

Using Sigfox :

Now that we have seen how the data is obtained, the next step is to get it off the beehive, and into the cloud, and that is where our choice of card comes into play, the MKR FOX 1200 is capable of connecting to the Sigfox infrastructure, which covers a large portion of Europe, so we get access to this big network without any necessary investments or complicated set up.

In addition to the data size limit specified earlier, there is also another limitation with Sigfox, a number of messages cap at 140, so we aren’t able to just continuously send data, but because of the type of data we are dealing with, an update every 15 minutes is more than enough to get a representative view of the Beehive situation, with this frequency, we end up sending 96 messages per day.

Once the data is sent with the MKR FOX 1200 card using the antenna, we can now access it trough Sigfox, and we can now recover the information by telling Sigfox how the data is structured and where each value is.

Displaying the data with Ubidots :

Now that we got our values, the next step is to display these values in a readable way, and the tool we have chosen is UBIDOTS, the reason behind this choice is that it allows us easy communication with Sigfox, and the ability to display values in all kinds of styles, and more importantly, being able to showcase the evolution of our data throughout time.

Link between Sigfox and Ubidots

The above image shows the configuration that allows us to send the data to Ubidots, we only need to specify the destination, and the data we are sending.

When the data is received on ubidots, we can process it, by applying mathematical operations on it, then choose the way we want to display it.

Data processing on Ubidots

Ubidots is also easily accessible everywhere, which would allow the farmer to check on his bees as often as needed.

Conclusion :

This project was a great experience, we got to create a system that incorporates multiple types of technologies, while working on a real life subject, where our system would be helpful and more than just a school project.

This was also the first IOT experience for most of us, it allowed us to get into this big world in a very accessible manner.

We have also learned the importance of project management, a facet that we could improve on in the future, its importance was also heavily emphasised by the current COVID crisis, which caused multiple unexpected absences, where we had to adapt to overcome them.

Code

ruche.ino

/*____________INCLUDE DES BIBLIOTHEQUES_________________________________________*/
/*------------------------------------------------------------------------------*/
#include <SigFox.h>
#include "DHT.h"
#include "HX711.h"
#include <OneWire.h>
#include "ArduinoLowPower.h"
/*------------------------------------------------------------------------------*/
/*______________________________________________________________________________*/

/*_____________STRUCTURE MESSAGE SIGFOX ET DATA_________________________________*/
/*------------------------------------------------------------------------------*/
byte data[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
int dataTemp = 0;                      // BufferTemporaire
float h =0;
float t =0;                            // Temp et Hum DHT22
uint16_t temperatureDS18B20[3] = {0};  // Temp EXT 1 a 3
uint16_t poids = 0;
uint8_t batterie = 0;
uint8_t panneau = 0;

typedef struct __attribute__ ((packed)) sigfox_message {  
  uint16_t humidite_DHT22:10; // Humidite sur 10bits
  int16_t temp_DHT22:11;      // Temprature sur 11bits
  int16_t temp_OW_NUM1:11;    // Temprature sur 11bits
  int16_t temp_OW_NUM2:11;    // Temprature sur 11bits
  int16_t temp_OW_NUM3:11;    // Temprature sur 11bits
  int16_t poids:11;           // Poids sur 11bits
  uint8_t batterie:7;         // Tension Batterie sur 7bits
  uint8_t panneau:7;          // Tension Panneau sur 7bits
} SigfoxMessage; 
/*------------------------------------------------------------------------------*/
/*______________________________________________________________________________*/


 
/*____________DEFINE PIN AND REFERENCE__________________________________________*/
/*------------------------------------------------------------------------------*/
#define DHTPIN 2  
#define DHTTYPE DHT22  
#define VREF 4.2
#define PAUSE 40000
#define OFFSET 68455
#define DEBUG 1
/*------------------------------------------------------------------------------*/
/*______________________________________________________________________________*/



/*____________PRIVATE VARIABLES_________________________________________________*/
/*------------------------------------------------------------------------------*/
int DAT = 5;                    // Pin Data Capteur de Poids
int CLK = 4;                    // Pin Clock Capteur de Poids
float valeur = 0.0f;            // Valeur Poids
float tarage = 0;                // Variable Tarage du capteur
float valInt = 0;                // Valeur Intermediaire de Poids
const byte BROCHE_ONEWIRE = 3;  // Pin Capteur Temp
long int lastTime = 0;          // Variable utile au delai
uint8_t* ptr;                   // Pointeur affichage trame binaire

const byte SENSOR_ADDRESS_1[] = {0x28,0xA6,0x81,0x23,0x1C,0x19,0x01,0xFF};
const byte SENSOR_ADDRESS_2[] = {0x28,0x73,0x7B,0xF4,0x36,0x19,0x01,0xB2};
const byte SENSOR_ADDRESS_3[] = {0x28,0x17,0xE2,0x26,0x0,0x0,0x80,0x6C};
unsigned long intervalle = 40000; 
unsigned long previousMillis = 0;
/*------------------------------------------------------------------------------*/
/*______________________________________________________________________________*/



/*____________PRIVATE OBJECTS___________________________________________________*/
/*------------------------------------------------------------------------------*/
DHT dht(DHTPIN, DHTTYPE);
HX711 capteur;
OneWire ds(BROCHE_ONEWIRE);
SigfoxMessage msg;
/*------------------------------------------------------------------------------*/
/*______________________________________________________________________________*/


void setup() { 

  pinMode(13, OUTPUT); 
  digitalWrite(13, HIGH);
  
  // Declaration des alimentations capteurs 
  pinMode(10, OUTPUT); 
  pinMode(11, OUTPUT); 
  pinMode(12, OUTPUT); 

  Serial.begin(115200); 
  dht.begin(); 
  
  // Demarrage HX711
  capteur.begin(DAT, CLK); 
  capteur.set_scale(14100);
  tarage=35416;
  
  /* Tarage du capteur
  Serial.println("HX711");
  Serial.println("Tarage du capteur");
  Serial.println("Le capteur doit tre fix et ne pas tre touch ou dplac");
  tarage = capteur.read_average(50);
  Serial.print("Tarage : ");
  Serial.println(tarage);*/

  // Demarrage module Sigfox
  if (!SigFox.begin()) { 
    Serial.println("SigFox error, rebooting"); 
    reboot(); 
  } 
  delay(100);
  SigFox.debug(); 

  // Demarrage programme
  Serial.println("DEMARRAGE PROG");

  digitalWrite(13, LOW);
  
} 
 
void loop() {
  
  unsigned long currentMillis = millis();

  allumerCapteur();
  delay(1200);
  
  mesureDHT22();
  mesureDS18B20();
  mesureHX711();

  mesureValBatterie();
  mesureValPanneau();
  
  eteindreCapteur();

#if DEBUG

     affichageBatterie();
     affichagePanneau();
     affichagePoids();
     affichageDHT22();
     affichageDS18B20();

     //affichageTrame();
#endif
      sendData();
      LowPower.sleep(720000);
      resetData();
      
}


void resetData(){
  for(uint8_t i=0; i<11; i++){
    data[i]= 0x00;
  }
}

void sendData(){

      
  //digitalWrite(13, HIGH);
       
  /*_______________Envoie de la structure precedemment creer ______________________*/
  /*-------------------------------------------------------------------------------*/
  SigFox.status(); 
  SigFox.beginPacket(); 
  SigFox.write((uint8_t*)&data, sizeof(data)); 
  Serial.print("Status: "); 
  Serial.println(SigFox.endPacket()); 
  Serial.println("ENVOIE MESSAGE !!!\n\n");
  /*-------------------------------------------------------------------------------*/
  /*_______________________________________________________________________________*/

  //digitalWrite(13, LOW);

  
}
void reboot() { 
  //NVIC_SystemReset(); 
  while (1); 
} 

String printBinaryReverse(uint8_t * ptr, byte n){
  String trame = "";
  for (int i = 0 ; i <n; i++) {
    for (int b = 7; b >= 0; --b) {
      if (bitRead(*(ptr + i), b)) trame+="1";
      else  trame+="0";
    }
  }
  return trame;
}

void printBinary(uint8_t * ptr, byte n){
  for (int i = n-1 ; i>= 0; --i) {
    for (int b = 7; b >= 0; --b) {
      if (bitRead(*(ptr + i), b)) Serial.print("1");
      else Serial.print("0");
    }
    Serial.print(" ");
  }
}

int readBinaryString(char *s) {
  int result = 0;
  while(*s) {
    result <<= 1;
    if(*s++ == '1') result |= 1;
  }
  return result;
}

void startTemperatureMeasure(const byte addr[]) {
  ds.reset();
  ds.select(addr);
  ds.write(0x44, 1);
}


float readTemperatureMeasure(const byte addr[]) {
  byte data[9];
  ds.reset();
  ds.select(addr);
  ds.write(0xBE);
  for (byte i = 0; i < 9; i++) {
    data[i] = ds.read(); //  Scratchpad
  }
  // Temp en degrs
  return ((data[1] << 8) | data[0]) * 0.0625; 
}


void allumerCapteur(){
  digitalWrite(10, HIGH);
  digitalWrite(11, HIGH);
  digitalWrite(12, HIGH);
  capteur.power_up();
}

void eteindreCapteur(){
  digitalWrite(10, LOW);
  digitalWrite(11, LOW);
  digitalWrite(12, LOW);
  capteur.power_down();
}

void mesureDHT22(){
  h = dht.readHumidity();              // Lecture Humidite DHT22
  uint16_t hTemp = (uint16_t)(h*10);   // Affectation structure
  dataTemp = data[0]|(hTemp>>2);
  data[0] = lowByte(dataTemp);
  dataTemp = data[1]|(hTemp)<<6;
  data[1] = lowByte(dataTemp);
 
  t = dht.readTemperature();           // Lecture Temperature DHT22
  uint16_t tTemp = (uint16_t)((t+20)*10);     // Affectation structure
  dataTemp = data[1]|(tTemp>>5);
  data[1] = lowByte(dataTemp);
  dataTemp = data[2]|(tTemp)<<3;
  data[2] = lowByte(dataTemp);
}
 
void mesureDS18B20(){
  temperatureDS18B20[3];              // Tableau de Temperature
  startTemperatureMeasure(SENSOR_ADDRESS_1);  // Debut Mesure Capteur 1
  startTemperatureMeasure(SENSOR_ADDRESS_2);  // Debut Mesure Capteur 2
  startTemperatureMeasure(SENSOR_ADDRESS_3);  // Debut Mesure Capteur 3
  delay(800);                                 // Attente de mesure

  temperatureDS18B20[0] = (uint16_t)((readTemperatureMeasure(SENSOR_ADDRESS_1)+20)*10);
  temperatureDS18B20[1] = (uint16_t)((readTemperatureMeasure(SENSOR_ADDRESS_2)+20)*10);
  temperatureDS18B20[2] = (uint16_t)((readTemperatureMeasure(SENSOR_ADDRESS_3)+20)*10);

  dataTemp = data[2]|(temperatureDS18B20[0]>>8);
  data[2] = lowByte(dataTemp);
  dataTemp = data[3]|(temperatureDS18B20[0]);
  data[3] = lowByte(dataTemp);

  dataTemp = data[4]|(temperatureDS18B20[1]>>3);
  data[4] = lowByte(dataTemp);
  dataTemp = data[5]|(temperatureDS18B20[1]<<5);
  data[5] = lowByte(dataTemp);

  dataTemp = data[5]|(temperatureDS18B20[2]>>6);
  data[5] = lowByte(dataTemp);
  dataTemp = data[6]|(temperatureDS18B20[2]<<2);
  data[6] = lowByte(dataTemp);  
}

void mesureHX711(){
  valInt =  capteur.read_average(5) - tarage;              // Lecture Poids
  valeur =  0.00005021931f * (float)valInt;                // Conversion kg
  poids = (uint16_t)valeur*10; //(uint16_t)(-valeur)*10;   // Affectation structure
  dataTemp = data[7]|(poids>>3);
  data[7] = lowByte(dataTemp);
  dataTemp = data[8]|(poids<<5);
  data[8] = lowByte(dataTemp);
}

void mesureValBatterie(){
  uint16_t valBatterie = analogRead(A6);       // Lecture Tension Batterie
  uint8_t position = map(valBatterie, 870, 1023, 0, 100);
  if (position >= 100)  position = 100;
  else if(position <= 0)  position = 0;    
  batterie = position;
  dataTemp = data[9]|(batterie<<1);
  data[9] = lowByte(dataTemp);
}

void mesureValPanneau(){
  uint16_t valPanneau =  analogRead(A5)/10;         // Lecture Tension Pannneau
  panneau = valPanneau;              // Affectation structure
  dataTemp = data[10]|(panneau<<1);
  data[10] = lowByte(dataTemp);
}
  
void affichageBatterie(){
  /*_______________Affichage Tension Batterie (HEX,DEC)____________________________*/
  /*-------------------------------------------------------------------------------*/
  Serial.print("Batterie: "); 
  Serial.println(batterie); // display what we will send in Hexadecimal
  /*-------------------------------------------------------------------------------*/
  /*_______________________________________________________________________________*/
}

void affichagePanneau(){
  /*_______________Affichage Tension Panneau (HEX,DEC)_____________________________*/
  /*-------------------------------------------------------------------------------*/
  Serial.print("Panneau: "); 
  Serial.println(panneau); // display what we will send in Hexadecimal
  /*-------------------------------------------------------------------------------*/
  /*_______________________________________________________________________________*/
}

void affichageDHT22(){
  /*_______________Affichage Temperature DHT22 (HEX,DEC)___________________________*/
  /*-------------------------------------------------------------------------------*/
  Serial.print("Temperature DHT 22 : "); 
  Serial.println(t);
  /*-------------------------------------------------------------------------------*/
  /*_______________________________________________________________________________*/
 
  /*_______________Affichage Humidite DHT22 (HEX,DEC)______________________________*/
  /*-------------------------------------------------------------------------------*/
  Serial.print("Humidite DHT22 : "); 
  Serial.println(h); // display what we will send in Decimal 
  /*-------------------------------------------------------------------------------*/
  /*_______________________________________________________________________________*/
}

void affichageDS18B20(){
  /*_______________Affichage Temperature DS18BS20 EXT1 (HEX,DEC)___________________*/
  /*-------------------------------------------------------------------------------*/
  Serial.print("Temperature_EXT1 : ");
  Serial.println(((float)temperatureDS18B20[0]/10)-20);
  /*-------------------------------------------------------------------------------*/
  /*_______________________________________________________________________________*/

  /*_______________Affichage Temperature DS18BS20 EXT2 (HEX,DEC)___________________*/
  /*-------------------------------------------------------------------------------*/
  Serial.print("Temperature_EXT2 : ");
  Serial.println(((float)temperatureDS18B20[1]/10)-20);
  /*-------------------------------------------------------------------------------*/
  /*_______________________________________________________________________________*/

  /*_______________Affichage Temperature DS18BS20 EXT3 (HEX,DEC)___________________*/
  /*-------------------------------------------------------------------------------*/
  Serial.print("Temperature_EXT3 : ");
  Serial.println(((float)temperatureDS18B20[2]/10)-20);
  /*-------------------------------------------------------------------------------*/
  /*_______________________________________________________________________________*/
}

void affichagePoids(){
  /*_______________Affichage Poids en Kilogrammes (HEX,DEC)________________________*/
  /*-------------------------------------------------------------------------------*/
  Serial.print("Poids: ");
  Serial.println(poids); 
  /*-------------------------------------------------------------------------------*/
  /*_______________________________________________________________________________*/
}

void affichageTrame(){
  /*_______________Affichage de la Trame en format Binaire et de sa taille ________*/
  /*-------------------------------------------------------------------------------*/
  Serial.println("****** structure de base ******");
  Serial.print("Taille du message = ");
  Serial.println(sizeof(data));
  ptr = (uint8_t *) &data;
  printBinary(ptr, sizeof(data));
 
  /*-------------------------------------------------------------------------------*/
  /*_______________________________________________________________________________*/
}