Team BumbleBeez:

•

Franck-upmc

Published January 18, 2022

Connected Hive

Creation of an embedded system that allows monitoring a hive through a sigfox module connected to an IoT platform.

IntermediateFull instructions providedOver 2 days718

Things used in this project

Hardware components

Arduino Nano 33 BLE Sense

DHT22 Temperature Sensor

HARDWARIO DS18B20 Temperature Sensor 1m

Photo resistor

Texas Instruments TPL5110 nano-power system timer

Li-Ion Battery 1000mAh

Male-Header 5 Position- 1 Row- Long (0.1")

Micro-USB to USB Cable (Generic)

Machine Screw, M3

Female Header 8 Position 1 Row (0.1")

Carte BreakOut Sigfox BRKWSO1

SparkFun Load Cell Amplifier - HX711

Bosch Single point load cell H40A

Solar cell SOL2W

Seeed Studio Lider Pro Card

Through Hole Resistor, 33 kohm

Through Hole Resistor, 56 kohm

Through Hole Resistor, 100 kohm

Through Hole Resistor, 330 kohm

Ceramic Disc Capacitor, 470 pF

Capacitor 2.2 µF

Voltage regulator 5V to 3.3V

Digilent 1-pin MTE Cable (5-pack)

Test Cable Assembly, Alligator Terminated Test Lead Set

Software apps and online services

Arduino IDE

powerful IDE which concentrate the whole functionalities we've needed to develop the system

beep

Ubidots

Microsoft Azure

Sigfox

Hand tools and fabrication machines

Soldering iron (generic)

Hot glue gun (generic)

Drill, Screwdriver

Laser cutter (generic)

3D Printer (generic)

Cable Cutter, 12.7mm

Story

BumbleBeez,a connected Hive:

The purpose of this project is to realize a small embedded system that will allow a beekeeper to assess the health of his bees. This year, the mortality of bees during the winter is more important than the previous years. This is due to climate change and the consequences it brings. For example, we find sudden temperature variations, the arrival of new predators such as Asian hornets, or the pesticides used by some farmers that are harmful to these bees. Therefore, this project of connected hive takes all its sense because it will allow to measure several physical quantities and to make them available on a web application so that the beekeeper can know the health status of his bees. The embedded system will be equipped with different sensors such as temperature, humidity, weight, luminosity (etc.).

We decided to use the Arduino nano 33 ble board as a microcontroller because it has a large number of GPIO ports, it consumes very little power and it has a Bluetooth module. The fact that it is an Arduino board also facilitates its programming. In order to start programming the board, it is easier to use the Arduino IDE in which we can add different libraries associated with each sensor.

How to use the sensors:

Humidity

The first step was to start testing the different sensors one by one, starting with the DH22 sensors. These sensors are measuring humidity and temperature with a precision of ± 0, 5°C for temperature and ± 2 % for humidity. We used 2 of them to measure the temperature/humidity inside and outside the hive. To be able to read the measurements, you need to use simple functions included in the library "DHT.h". With it, it’s possible to carry out measurements according to the desired unit of measurement (Kelvin, Celcius). Each DHT22 requires the use of one digital port.

Temperature

The temperature within a hive is a very good indicator of the health of the bees. Indeed, they self-regulate the internal temperature between 20 and 30°C. That's why we added 2 more temperature sensors DS18B20 inside the hive. The advantage of these sensors is that they are waterproof and they are not likely to be damaged by bees. The other advantage they bring is that the two sensors only require the use of a single digital port on the Arduino. To measure the temperature, you just need to know the identifier of each sensor and define a bus in which you will read the temperature. All the necessary functions are described in the library " MaximWire.h”. However, be careful to define the probes in pull-up mode with the #define MAXIMWIRE_EXTERNAL_PULLUP command. Without this, it will be impossible to measure the temperature. The program that allows you to retrieve the identifiers is available in the attachments of this article.

Weight

Finally, we used a force sensor to measure the weight of the hive. This weight is very important because it will send alerts to the beekeeper. For example, when the hive is stolen which is common nowadays considering the price of a frame filled with honey. It also allows to detect swarming which is the departure of half of the colony of bees that follow the old queen to another apiary. This has a strong impact on honey production. To measure the weight, we used a Wheatstone bridge load cell. Once again, you need to use the functions included in the library "HX711.h". This sensor requires the use of 2 digital ports. We have also fixed a frame around this sensor to support the entire hive. Before using the sensor for its intended purpose, it is necessary to perform a calibration. All the details of this calibration can be found in the Arduino library mentioned above.

Luminosity

We also used a photoresistor that allows us to measure the ambient brightness. It is therefore necessary to make a voltage divider bridge to recover the voltage across the photoresistor. We then connect it to one of the analog ports of the board. The value of the resistor for the bridge divider is important because it will determine the current consumed. It is necessary to take a high resistance compared to the photo resistance so that when the photo resistance decreases, the resistance limits the current and therefore the consumption.

How to send the data:

To send our data to a web application, we used a Sigfox antenna to communicate via the LPWAN network. The use of this antenna requires an annual subscription which is not free. It allows among other things the sending of 144 messages per day, each having a maximum size of 12 bytes or 96 bits. The Sigfox payload must respect a certain protocol on which you will easily find all the information. The complicated part is the decoding of the frame on the Sigfox site associated with your card identifier. You have to decode one by one each measurement you have decided to send. To do this, you must specify at which byte the data starts, on how many bits it is encoded, and the number of bits offset from the beginning of the byte. Here is the frame that we decode:

temperature1:0:uint:10 temperature2:1:uint:9::5 temperature3:2:uint:9::4 temperature4:3:uint:9::3 poids:4:uint:10::2 batterie:5:uint:6::0 luminosite:6:uint:20::2 rien:9:uint:8::6 alerte:10:uint:3::6 humidite:10:uint:12::3

We have decided to use Ubidots as a website which is an application where you can collect the data that you send with Sigfox, you can make calculations with them, and display them in an elegant way. It is really easy to use and the API is well documented. However, you can add any IoT hub platform such as Microsoft Azur.

An autonomous system in energy consumption:

As you can imagine, our system must be self-powered and durable over time. So, we used a 1050 mAh battery and a 2W solar cell. It is, thanks to the LipoRider Pro, that we were able to convert the energy of the solar panel into power for the battery. At first, we used the 4.2V to 3.3V converter of the Arduino to convert the battery voltage to power the board. But the converter provided in the Arduino consumes a lot. That's why we made our own converter that we integrated into the PCB. To allow this operation, it is nevertheless necessary to cut a gold track on the back of the Arduino board as shown in the following picture. This allows specifying to the Arduino that we do not want to use its own converter anymore. However, it is now impossible to flash code on the board without powering it with 3.3V.

back of the arduino nano 33 ble

In order to limit our consumption as much as possible, we have reduced the consumption of our sensors. It is the weight sensor that was the most energy-consuming. So, our system is self-sufficient in energy and it sends a message every 10 minutes to a website. But we wanted to reduce the power consumption as much as possible during this time. That's why we used a component called TPL5110 which will cut the consumption of any electronic component. To do this, we need to use a resistor of a certain value between the delay pin of the TPL and its ground. This will allow you to define the time during which the tpl will cut the power supply to the board. In order for it to work in this mode, the gold track on the back of the component must be cut as shown below.

back of the TPL5110

In our case, we used a 57kOhms resistor to cut the power consumption of the board for 10 minutes. The 3.3V of the card is then connected to the DRV pin of the TPL which will supply the card until it receives the information on its DONE pin that it can cut the consumption. It is the Arduino that sends this information with one of its GPIO. Then, the TPL cuts the power supply provided by its DRV pin and it reaches the time associated with the connected resistor. The TPL is still powered but does not consume more than 0.6 uAh. With this method, we have reduced our consumption to 0.6 mAh. With this consumption and our battery, the system is autonomous in theory for about 2 months without recharging. In practice, with the weather conditions, it is necessary to have a solar panel to recharge the battery. Nevertheless, during the different test periods, the battery has always remained above 85%.

Warning, if you want to change the value of the resistor to wait more or less time, you have to cut the power supply of the TPL, change the resistor, and then power supply the TPL again. Otherwise, the new delay value will not be taken into account.

UsefullTips:

Before programming the board, you must install all the packages associated with the Arduino nano 33 ble. When you connect for the first time your board, the ide will detect its model and will propose you to install the packages, do it. Moreover, to program the board, you have to check that it is connected to the right COM. This information is available in the Tool -> Port tab.

Schematics

Code

#define MAXIMWIRE_EXTERNAL_PULLUP
#define PIN_BUS 5

#include "DHT.h"
#include "HX711.h"
#include <Arduino_APDS9960.h>
#include <MaximWire.h>

// Humidity Sensors
DHT dht_ext(D4, DHT22);
DHT dht_int(D3, DHT22);


// Temperature Sensors
MaximWire::Bus bus(PIN_BUS);
MaximWire::DS18B20 device("2892486F09000092");  
MaximWire::DS18B20 device1("28CBE96E0900005B"); 

// HX711 circuit wiring
const int LOADCELL_DOUT_PIN = D7;
const int LOADCELL_SCK_PIN = D9;
HX711 scale;


void setup() {
  pinMode(A7,OUTPUT);
  digitalWrite(A7,LOW);
  Serial1.begin(9600);
  delay(3000);
  digitalWrite(LED_PWR, LOW);               // turn off power LED
  digitalWrite(LED_BUILTIN,LOW);
  digitalWrite(PIN_ENABLE_I2C_PULLUP, LOW); // turn off IC pullup
  
    
  /* Humidity sensors's initialization*/
  dht_ext.begin();
  dht_int.begin();
  
  /* Scale initialization */
  scale.begin(LOADCELL_DOUT_PIN, LOADCELL_SCK_PIN);
  scale.set_scale(28983.1604f);
  scale.set_offset(126846.686f);

  /* Proximity sensor */
  APDS.begin();
  
}

/* Read the battery statement */
int ReadBat(){
  int sensorPin = A0;   
  int sensorValue=0;
  float Vin,Vbat;
  int PourcentageBat;
  sensorValue = analogRead(sensorPin);
  Vin=(float(sensorValue)/1024)*3.3;
  Vbat=Vin*1.303241442;
  PourcentageBat=int(float((Vbat-3.3)/0.715)*100.0);
  if (PourcentageBat>100){PourcentageBat=100;}
  if (PourcentageBat<0){PourcentageBat=0;}

  return PourcentageBat;
}

/* Read the exterior luminosity */
int ReadLum(){
  int sensorLum = A5;   
  int ValueLum=0;
  float Luminosite;
  
  ValueLum = analogRead(sensorLum);
  Luminosite=(float(ValueLum)/1024)*3.3;
  return Luminosite*1000;
}


void loop() {  
  /* Variable initialization */
  int temperature_ext,temperature_int1,temperature_int2,temperature_int3;
  int humidite_ext,humidite_int1;
  int poids,batterie,rien,proximity;
  int payload[3];
  char buffer[100];
  int alerte=0;

  /* Temperature bus update */
  device.Update(bus);
  device1.Update(bus);

  delay(1000);
  
  
 /* measurement of all sensors */
 
  float hum_ext = dht_ext.readHumidity();                // External humidity
  float hum_int_1 = dht_int.readHumidity();              // Internal humidity
  
  float temp_ext = dht_ext.readTemperature();            // Outside temperature (DHT22)
  float temp_int_1 = dht_int.readTemperature();          // Internal temperature 1 (DHT22)
  float temp_int_2 = device.GetTemperature<float>(bus);  // Internal temperature 2 (DS18B20)
  float temp_int_3 = device1.GetTemperature<float>(bus); // Internal temperature 3 (DS18B20)
  float poids_tot = scale.get_units(5);                  // Scale
  float bat_conv = ReadBat()/1.5625;                     // Battery state
  int luminosite = ReadLum();                            // Luminosity
  
  proximity = APDS.readProximity();                      // Proximity
  delay(3000);
  scale.power_down();
  
  digitalWrite(PIN_ENABLE_SENSORS_3V3, LOW);             // We turn off all the 3.3 ports of the arduino board
  
  /* We format the measured data to send them with a good accuracy. */
  temperature_ext=round((temp_ext+20)*10);
  temperature_int1=round((temp_int_1+10)*10);
  temperature_int2=round((temp_int_2+10)*10);
  temperature_int3=round((temp_int_3+10)*10);
  
  humidite_ext=round(hum_ext/1.5625)-1;
  humidite_int1=round(hum_int_1/1.5625)-1;
  
  poids = round(poids_tot*10);
  batterie = (round(bat_conv)-1);
  
  if(proximity > 200){
  alerte = 1;
  }
  
  if(poids_tot<20){
  alerte = 5;
  }
  
  rien = 15;
  
  /* Creation of the payload */
  payload[0]=(temperature_ext << 22) | (temperature_int1 << 13) | (temperature_int2 << 4) | (temperature_int3 >> 5);
  payload[1]=(temperature_int3 << 27) | (poids << 17) | (batterie << 11) | (luminosite >> 9);
  payload[2]=(luminosite << 23) | (rien << 15) | (alerte << 12) | (humidite_ext << 6) | (humidite_int1);
  
  sprintf(buffer,"AT$SF=%08x%08x%08x\r\n",(int)payload[0],(int)payload[1],(int)payload[2]);
  Serial1.write(buffer);
  
  /* We wait until the Sigfox frame is completely sent before putting the module in sleep mode */
  delay(11000);
  while(1){
    digitalWrite(A7,HIGH);
    delay(10);
    digitalWrite(A7,LOW);
    delay(10);
  }

}

// multiple devices OR single parasite powered device requires external pull up of 1.7~2.2 kOm

#define MAXIMWIRE_EXTERNAL_PULLUP

#include <MaximWire.h>

#define PIN_BUS 5

MaximWire::Bus bus(PIN_BUS);
MaximWire::DS18B20 device;

void setup() {
    Serial.begin(9600);
}

void loop() {
    MaximWire::Discovery discovery = bus.Discover();
    do {
        MaximWire::Address address;
        if (discovery.FindNextDevice(address)) {
            Serial.print("FOUND: ");
            Serial.print(address.ToString());
            if (address.IsValid()) {
                Serial.print(" (VALID)");
            } else {
                Serial.print(" (INVALID)");
            }
            if (address.GetModelCode() == MaximWire::DS18B20::MODEL_CODE) {
                Serial.print(" (DS18B20)");
                MaximWire::DS18B20 device(address);
                if (device.IsParasitePowered(bus)) {
                    Serial.print(" (PARASITE POWER)");
                }
                float temp = device.GetTemperature<float>(bus);
                Serial.print(" temp=");
                Serial.print(temp);
                Serial.println();
                device.Update(bus);
            } else {
                Serial.println();
            }
        } else {
            Serial.println("NOTHING FOUND");
        }
    } while (discovery.HaveMore());
    delay(1000);
}

# Ruche_connect_RRLL
Project of embedded systems with sigfox module to scan different parameters like weight, temperature etc.

### Table of content
1. [Starting Point](#starting-point)
2. [Prerequisites](#Prerequisites)
3. [Installation](#installation)
4. [Made with](#made-with)
5. [Versions](#versions)
6. [Authors](#authors)
7. [License](#license)

## Starting Point

Our system works with an Arduino NANO BLE 33 Sense board, which is connected to
an LPWAN transmitter from sigfox which allows a wireless transmission at low energy cost.

![Image text](https://external-content.duckduckgo.com/iu/?u=https%3A%2F%2Ftse2.mm.bing.net%2Fth%3Fid%3DOIP.sGXy-NlOStrLy6MeyubsAAHaEK%26pid%3DApi&f=1)

## Prerequisites

This system allows an online visualization in 'real time' (a weave sent every 10min)
on different platforms (for the moment Ubidots Stems _https://ubidots.com/stem/_ and in the future on Beep _https://beep.nl_) 
with Microsoft's Azur service as an intermediary

## Installation

No installation required, 
to load a new code on the arduino board, you have to unscrew the box, connect the board to the software.
To see the live activity you'll have to enter the password and show the dashboard.

## Made with

* [Arduino Software (IDE)](https://www.arduino.cc/en/software/) - Text editor and arduino download

## Versions

**Latest stable version :** 1.1
**Latest version :** 1.1
List : 

## Authors

* **Thomas Rio** _alias_ [@thomasrPPS](https://github.com/thomasrPPS)
* **Bruce Rosier** _alias_ [@brosier01](https://github.com/brosier01)
* **Youssef Lakhdhar** _alias_ [@Youscoutt](https://github.com/Youscoutt)
* **Franck Laurent** _alias_ [@Franck-upmc](https://github.com/Franck-upmc)

## License
none