Team RucheG2: Youssef Chaoui, Monsieur-ugur, diadji, Rizlène.B

Published January 22, 2024 © GPL3+

Projet OpenRucheG2

Hive monitoring using sensors and LoraWan network.

IntermediateShowcase (no instructions)Over 1 day427

Things used in this project

Hardware components

Arduino MKRWAN1300

DFRobot DHT22 Temperature and Humidity Sensor

Adafruit Waterproof DS18B20 Digital temperature sensor

DFRobot DHT22 Temperature and Humidity Sensor

SparkFun Load Cell Amplifier - HX711

M5Stack ESP32 Camera Module Development Board

Lipo 3.7V 1000mAh

LiPo Rider Pro 106990008

Arduino MKR WAN 1300

Solar Pannel 180x80

Grove amplifier (and CAN) for HX711

Adafruit Microphone Amplifier Breakout

Multiconductor Cable, Flexible

(4 wires inside)

Adafruit TPL5510

Software apps and online services

Ubidots

In this project we used BEEP but Ubidots is a free and easy alternative.

The Things Industries The Things Stack

Arduino IDE

KiCad

Hand tools and fabrication machines

Solder Wire, Lead Free

Soldering iron (generic)

3D Printer (generic)

(optional)

Drill / Driver, Cordless

Story

Bee colony are threatened by predators, pesticides and lack of food, thus limiting the pollinisation of plants and reducing our harvest in honey.

The focus of this project is to monitor the health of your colony with sensors and send them to "The Things Network", allowing you to check all of the data on your colony in order to help you make decisions.

This project is an alternative of the "BEEP" project that help scientist and apicultor to do statistics on domestic bees in Europe for scientific purpose.

What is it :

It is a prototype that measure different characteristic of the hive:

Temperature inside the hive in 3 points
Humidity inside the hive
Temperature and humidity outside the hive
frequency in the hives
luminosity and battery level
Presence of bees/hornet (not implemented but codes and advices are given below)

The DHT22 is not perfectly waterproof, which is why I would recommend you to put the one outside below the hive and the one inside should be in a corner to be protected from the bees.

My box before I was uploading my code on the card, and sealing it,

I was afraid that because of the movement the sensors would be disconnect so I put some cardboard at the bottom of the box to fix my card to it.

How does it work:

The code is built around 4 steps: First connect to the lora notework by using the modem.begin from mkrwan.h library, then read the values from the sensors, after this stage we send the values measured as a byte vector to the lora Network and finally enter in sleep mode by cutting the power from the sensors with the power switch.

After reception of the byte vector on the things network we will decode the measure from each sensor using the payload formatter (see attached)..The decoded values will then be sent to the client's interface BEEP through a webhook.

The BEEP interface give a lot of insight on the fluctuation of the data in the time, while also giving some easy to read interface for real time data.

Consumption

We are using a switch load to limit the current consumed by our captor while our card is on sleep mode (between two uplinks).

The wiring of the sensor is done according to the KiCAD schematics that you can find in "attachment".

With all of the optimization, we reach a total of 40 hours in theory, with measure at 20°C, we then put our prototype outdoor in a hive, it is self sufficient in energy with the solar panel, but would last 10 days without it (in temperature around 0°C).

Wiring:

You should take the grove connector, from the DHT22 and solder it with the wires in the multistrand cable, try to respect the colors you chose at both sides of the cable.

For the multistrand cable with the 6 cables inside, cut the cables of the two DS18B20, solder them together (the two DS18B20 work with special protocol so they can share the same wire for data, power and ground, the other 3 cables will be soldered with another DHT22.

Try to respect the color you choose for the different cables (GND, POWER, DATA) on each part to ensure that your sensors work well (taking pictures of both end of the cable is a good idea ;-) ).

Do not forget to put heat-shrink tubes on all for the part you soldered and seal the wires coming out of your boxes in order to protect them from the rain.

IA and hornet detection:

We trained an IA that detect hornet and count bees but didn't implement it for two reasons:

Using an IA embedded on a board consume a lot of energy
The communication between the board and the MKRWAN need a DC converter (3.3V to 5V) for the ESP32CAM which take up space on the PCB and consume more.

You will find in the attatchment section the trainned IA model or train your own with a no code solution using Edge Impulse, here are the performance of our trainned model (on a dataset from our hive):

It has trouble differentiating the bees from the background, which is due to the fact that when an Asian hornet comes close to the hive, the bees will all come to the landing board to protect the hive, making it difficult to label them

While it may seem problematic that 60% of the bees aren't detected, it isn't, as the number of bees is only useful when there is a swarm, to double-check if there really is a hornet.

Code

#include <MKRWAN.h>
#include "DHT.h"
#include <OneWire.h>
#include <ArduinoLowPower.h>
#include <HX711.h>
#include <arduinoFFT.h>
#include <DFRobot_B_LUX_V30B.h>
#include <DallasTemperature.h>
#define DONEPIN A3
#define DELAY A2
#define DHT22PIN1 7 //V
#define DHT22PIN2 8 //V

//#define LUMIERE A0 //V
DFRobot_B_LUX_V30B    myLux(0, 0, 1); 
#define BATTERIE A1 //pin de la batterie V
#define BUZZER 5

#define TENSIONMIN 2.4973 //tension min
#define TENSIONMAX 3.1784 //tension max

#define RXESP 13
#define TXESP 14

#define ONE_WIRE_BUS 10
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);


// HX711 circuit wiring
const int LOADCELL_DOUT_PIN = 11;
const int LOADCELL_SCK_PIN = 12;
static int timetosleep=10;
int frequency = 600000;

//OneWire  ds(10);  // on pin 10 (a 4.7K resistor is necessary)

#define DHTTYPE DHT22
DHT dht1(DHT22PIN1, DHT22);
DHT dht2(DHT22PIN2, DHT22);
LoRaModem modem;

HX711 scale; //création de l'instance de l'objet HX11 nommé scale
String appEui = "AAAAAAAAAAAAAAAA";
String appKey = "B53BAECF2AA9B641F7840FA68292E8EA";

//String appEui = "1122334455667788";
//String appKey = "901D1126F748C4C69F9D7B0F501A366F";

bool connected;
int err_count;
short con;

//FFT
short s_bin098_146Hz = 0; //this short takes the sum of the amplitudes within this frequency span
short s_bin146_195Hz = 0; 
short s_bin195_244Hz = 0;
short s_bin244_293Hz = 0; 
short s_bin293_342Hz = 0;
short s_bin342_391Hz = 0;
short s_bin391_439Hz = 0;
short s_bin439_488Hz = 0;



  // Decoder function to convert byte array to string
  String decodeBytes(byte* bytes, int length) {
    String result = "";
    for (int i = 0; i < length; i++) {
      result += char(bytes[i]);
    }
    return result;
  }

  void scale_init(){
    scale.begin(LOADCELL_DOUT_PIN, LOADCELL_SCK_PIN);
    scale.set_scale(30105.f); // the scale value that was found while calibrating the wheight scale

  }

  void batterie_init(){
    pinMode(BATTERIE, INPUT); //put the battery pin as input
  }

  int getWeight() {
    scale.power_up(); //leave sleep mode

    float weightFloat = scale.get_units(10)-4; //get measure
    delay(1000); //we need this delay or the waight scale sends weird values

    scale.power_down(); //enter low power mode

    int weight = (int)(100*weightFloat); // cast
    //Serial.println("weight :");
    //Serial.println(weight);

    return weight;
  }



int getLum() { 
    //Serial.print("value: ");
    //Serial.print(myLux.lightStrengthLux());
    //Serial.println(" (lux).");
}


short getBattery () // sur la pin A0
{
  float b = analogRead(BATTERIE); //valeur analogique
  b= 3.3*(b /(0.24*1023.0));
  //Serial.println("batterie :");
  //Serial.println(b*100);
  return (short)(b*100); //returns battery percentage in volts
}





//Analyse son
//fft with filtering 
const int micPin = A4;
const int sampleSize = 512; 
const double samplingFrequency = 10000;

arduinoFFT FFT = arduinoFFT();
 
double vReal[sampleSize];
double vImag[sampleSize];


const double cutoffFrequency = 50.0;
const double RC = 1.0 / (cutoffFrequency * 2 * 3.1416);
const double dt = 1.0 / samplingFrequency;
const double alpha = RC / (RC + dt);

double lastFilteredValue = 0;



 //Analyse son
  void son(){
  for (int i = 0; i < sampleSize; i++) {
      vReal[i] = analogRead(micPin);
      vImag[i] = 0;
      delayMicroseconds(1000000 / samplingFrequency);
    }

    FFT.Windowing(vReal, sampleSize, FFT_WIN_TYP_HAMMING, FFT_FORWARD);
    FFT.Compute(vReal, vImag, sampleSize, FFT_FORWARD);
    FFT.ComplexToMagnitude(vReal, vImag, sampleSize);

    double maxAmplitude = 0;
    int maxIndex = 0;
    for (int i = 5; i < (sampleSize / 2); i++) {
      if (vReal[i] > maxAmplitude) {
        maxAmplitude = vReal[i];
        maxIndex = i;
      }
    }




    for(int i = 5; i < (sampleSize / 2); i ++){
      if (((double)i * samplingFrequency / sampleSize)*1.06667/10 >= 98 && ((double)i * samplingFrequency / sampleSize)*1.06667/10 <= 146){
        s_bin098_146Hz += vReal[i];
      }
      if (((double)i * samplingFrequency / sampleSize)*1.06667/10 >= 146 && ((double)i * samplingFrequency / sampleSize)*1.06667/10 <= 195){
        s_bin146_195Hz += vReal[i];
      }
      if (((double)i * samplingFrequency / sampleSize)*1.06667/10 >= 195 && ((double)i * samplingFrequency / sampleSize)*1.06667/10 <= 244){
        s_bin195_244Hz += vReal[i];
      }
      if (((double)i * samplingFrequency / sampleSize)*1.06667/10 >= 244 && ((double)i * samplingFrequency / sampleSize)*1.06667/10 <= 293){
        s_bin244_293Hz += vReal[i];
      }
      if (((double)i * samplingFrequency / sampleSize)*1.06667/10 >= 293 && ((double)i * samplingFrequency / sampleSize)*1.06667/10 <= 342){
        s_bin293_342Hz += vReal[i];
      }
      if (((double)i * samplingFrequency / sampleSize)*1.06667/10 >= 342 && ((double)i * samplingFrequency / sampleSize)*1.06667/10 <= 391){
        s_bin342_391Hz += vReal[i];
      }
      if (((double)i * samplingFrequency / sampleSize)*1.06667/10 >= 391 && ((double)i * samplingFrequency / sampleSize)*1.06667/10 <= 439){
        s_bin391_439Hz += vReal[i];
      }
      if (((double)i * samplingFrequency / sampleSize)*1.06667/10 >= 439 && ((double)i * samplingFrequency / sampleSize)*1.06667/10 <= 488){
        s_bin439_488Hz += vReal[i];
      }
    }



    double maxFrequency = (double)maxIndex * samplingFrequency / sampleSize;
      double frequence = maxFrequency*1.06667/10;
  }





void setup() {

  dht1.begin(); //begin comm with dht sensors
  sensors.begin(); //begin comm with dsb18x20 sensors

  
  
  modem.begin(EU868); //begin lora comm on 868MHz
  scale_init();
  
 
  delay(2000);  // apparently the murata dislike if this tempo is removed...
  connected = false;
  err_count = 0;
  con = 0;


  
    //put your setup code here, to run once:
  pinMode(BUZZER, OUTPUT); 
  digitalWrite(BUZZER, HIGH); //generate sound on buzzer to let know the system has been powered on
  delay(1000);
  digitalWrite(BUZZER,LOW); //stops
  
  pinMode(DONEPIN, OUTPUT);
  pinMode(DELAY, OUTPUT); //pins to command the TPL that powers sensors
}





void loop() {
  // active le TPL
  digitalWrite(DONEPIN,LOW);
  digitalWrite(DELAY, HIGH);// power the sensors
  modem.minPollInterval(60);
  delay(500);
  byte i;
  byte present = 0;
  byte type_s;
  byte data[9];
  byte addr[8];
  float celsius, fahrenheit;
  delay(100);
 
  for( i = 0; i < 8; i++) {
    
  }

  
  sensors.requestTemperatures(); // Send the command to get temperatures
  
  float tempA = sensors.getTempCByIndex(0); //temperature on index 0
  float tempB = sensors.getTempCByIndex(1); //temperature on index 1
  

  short temp_intA = short(10*tempA); //cast to save bits
  short temp_intB = short(10*tempB);
  
   
  short humidite = (short)(10*dht1.readHumidity()); //humidity cast to save bits and get wanted resolution
  
  short temperature = (short)10*dht1.readTemperature();
  
  short temperature2 = (short)(10*dht2.readTemperature());
  
  short humidite2 = (short)(10*dht2.readHumidity());
     

  short weight = short(getWeight() );
   
  short batterie= getBattery();

  short lumiere = getLum();

  short test = 27;

  while (!connected) { //to connect to the lora network
    
    int ret = modem.joinOTAA(appEui, appKey);
    if (ret) {
      connected = true;
      modem.minPollInterval(60);
      modem.dataRate(5);  // switch to SF7
      delay(100);         // because ... more stable
      err_count = 0;
    }
  }

  
  if (connected) { // send the data packet
    
    int err = 0;
    
    modem.beginPacket();
    modem.write(humidite);
  
    modem.write(temperature);
  
      modem.write(weight);

      modem.write(temp_intA); 

   modem.write(lumiere);

    modem.write(batterie);
 
    modem.write(s_bin098_146Hz);


    modem.write(s_bin146_195Hz);


    modem.write(s_bin195_244Hz);


    modem.write(s_bin244_293Hz);

    modem.write(s_bin293_342Hz);


    modem.write(s_bin342_391Hz);

    modem.write(s_bin391_439Hz);
 
    modem.write(s_bin439_488Hz);


    modem.write(humidite2);

    modem.write(temperature2);

    modem.write(temp_intB);


    
    err = modem.endPacket();



    s_bin098_146Hz = 0; // reset the values measured with former fft
    s_bin146_195Hz = 0; 
    s_bin195_244Hz = 0;
    s_bin244_293Hz = 0; 
    s_bin293_342Hz = 0;
    s_bin342_391Hz = 0;
    s_bin391_439Hz = 0;
    s_bin439_488Hz = 0;




    if (err <= 0) {
     
      err_count++;
      if (err_count > 50) {
        connected = false;
      }
      // wait for 2min for duty cycle with SF12 - 1.5s frame
      for (int i = 0; i < 120; i++) {
        delay(1000); //1000
      }
    } else {
      err_count = 0;
     
      // Demonstration of decodeBytes function
      byte receivedBytes[] = { 72, 101, 108, 108, 111 };  // Represents the string "Hello"
      String decodedString = decodeBytes(receivedBytes, 5);
    
    } if (!modem.available()) { // downlink code
    //Serial.println("No downlink message received at this time.");
    delay(10000);
    //return;
  }
  else{
  char rcv[64]; 
  int i = 0;
  while (modem.available()) {//downlink received
    rcv[i++] = (char)modem.read(); 
  }
  //Serial.print("Received: ");
  for (unsigned int j = 0; j < i; j++) {
    //Serial.print(rcv[j] >> 4, HEX);
    //Serial.print(rcv[j] & 0xF, HEX);
    //Serial.print(" ");
  }
  int frequency = rcv[1] | (rcv[0] << 8); //get the value from the byte vector
  //Serial.print("Frequence envoi: ");
  //Serial.println(frequency);
  }


 
 }
 
  
  //desactive le TPL
  //delay(frequency);
digitalWrite(DELAY, LOW); // cut the power on sensors
  digitalWrite(DONEPIN,HIGH);
  
  LowPower.sleep(frequency); //sleep the mkrwan 1310 for 10 minutes
  }

function decodeUplink(input) {
 var data = {};

 
data.h = (input.bytes[1] << 8 | (input.bytes[0]))/10.0;
data.t_i = (input.bytes[3] << 8 | (input.bytes[2]))/10.0;
data.weight_kg = (input.bytes[5] << 8 | (input.bytes[4]))/100.0 ;
data.t_0 = (input.bytes[7]) << 8 | (input.bytes[6])/10.0;
// data.l = ((input.bytes[9]) << 8 | (input.bytes[8]))/10.0;
data.bv = ((input.bytes[11]) << 8 | (input.bytes[10]))/100.0;
data.key = "v8d1e7hghewrts33"
//data.s_bin098_146Hz = ((input.bytes[13]) << 8 | (input.bytes[12]));
//data.s_bin146_195Hz = ((input.bytes[15]) << 8 | (input.bytes[14]));
//data.s_bin195_244Hz = ((input.bytes[17]) << 8 | (input.bytes[16]));
//data.s_bin244_293Hz = ((input.bytes[19]) << 8 | (input.bytes[18]));
//data.s_bin293_342Hz = ((input.bytes[21]) << 8 | (input.bytes[20]));
//data.s_bin342_391Hz = ((input.bytes[23]) << 8 | (input.bytes[22])); 
//data.s_bin391_439Hz = ((input.bytes[25]) << 8 | (input.bytes[24]));
//data.s_bin439_488Hz = ((input.bytes[27]) << 8 | (input.bytes[26]));
//data.t_4 = ((input.bytes[29]) << 8 | (input.bytes[28]))/10.0;
//data.t_2 =  ((input.bytes[31]) << 8 | (input.bytes[30]))/10.0;
data.t_3 = ((input.bytes[33]) << 8 | (input.bytes[32]))/10.0;
 return {
 data: data,
 warnings: [],
 errors: []
 };
}