Introduction
Features
Prerequisites for developers
How does it work
What sensors are used
Implementation of the model
Creation of the electronic map
Connections with Sigfox and Ubidots Prototype implementation
Realization of the case
Conclusion

Published January 19, 2022 © GPL3+

Open Ruche

This project consists in creating a connected hive

BeginnerProtip14 days386

Things used in this project

Hardware components

DHT22 Temperature Sensor

Maxim Integrated DS18B20 Programmable Resolution 1-Wire Digital Thermometer

SparkFun Load Cell Amplifier - HX711

Battery, 3.7 V

Solar Panel, 2.5 W

Resistor 10k ohm

Arduino MKR Fox 1200

Software apps and online services

Ubidots

Sigfox

altium

Arduino IDE

Beep

Hand tools and fabrication machines

Solder Wire, Lead Free

Breadboard, 170 Pin

Soldering iron (generic)

Drill / Driver, Cordless

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

Plier, Long Nose

Story

Introduction

According to Greenpeace, Europe’s honey bee population has fallen by 25% in just 20 years. This decline translates into an increase in winter mortality, which can reach and exceed about 30% in some regions of France. Intensive use of pesticides and significant destruction of bee housing areas also pose a threat to this species. The collapse of the colonies is brutal and concerns both amateur beekeepers and professional beekeepers. This is a concern because environmental and economic issues are important. Human beings would be directly affected by the disappearance of bees. We are very dependent on bees for our food, for the pollination of wildlife.

As part of our training at Polytech Sorbonne, we have been entrusted with a project to build a connected hive to help the beekeepers monitor the state of the hive and its environment thanks to the information provided in real time by the sensors installed on the hive.

Our system must be able to send certain characteristic data, such as the internal and external temperatures of the hive, the internal and external humidity as well as the weight of it, to the beekeeper via several sensors and a cloud server. The prototype we created is autonomous and recharges thanks to a solar panel and a battery connected to it.

This article describes the overall functioning process of the connected hive set up during a project conducted during our fourth year in the EI-2I training at Polytech Sorbonne.

Features

For the information sent to the farmer to be consistent with the bee environment we need to collect:

• Hive weight (Amplifier HX711)

• Internal and external hive temperature (DHT 22 humidity sensor and DS18B20 temperature sensor)

• Internal and external humidity of the hive (DHT22 sensor)

Prerequisites for developers

• Knowledge of microcontroller programming (Arduino)

• Know how to read a data sheet and extract the relevant data

• Know how to use software such as Sigfox (receiving and sending data), Ubidots (viewing data), Altium (to create the PCB)

How does it work ?

The main idea of the hive is the following, we find in pale pink, the main actions of our sensors, in green the materials used, in white the actions and data to be analyzed by the beekeeper :

We can have a more detailed diagram which explains the system :

Diagram of function

description of function

And here we have a schematic which shows the connexions between the components

synoptic diagram

What sensors are used ?

For this project, we used two DHT22 sensors, three DS18B20 sensors, an HX711 amplifier made up of a strain gauge. After a comparison among various sensors, our team retained these components for their accuracy and measurement ranges. They are faithful to the climatic conditions of the Paris region and to the conditions within the hive.

sensors

The DS18B20 sensors will be positioned in the hive to measure internal temperatures at various locations within the hive. We will also place a DHT22 sensor inside the hive to observe the internal humidity of the hive, the second DHT22 sensor will be used to measure the external temperature and humidity. All of these measures allow us to monitor the environmental conditions of bees both inside and outside the hive. The weight will also be raised to better understand the situation of the hive and the bees.

All this information collected by the sensors will then be transmitted by the SigFox antenna at an interval of 12 minutes. A dashboard on Ubidots will allow us to monitor the evolution of the environment.

Implementation of the model

This system will be mounted on an Arduino MKRFOX 1200 board which will then be placed in the case. We also thought about a power system that will allow our case to operate in autonomy. A LIPO battery will be connected to the Arduino board, and a solar panel. The percentage of battery charge will also be monitored. To reduce the consumption during the waiting period between each sending of information by the board with SigFox, we will put the Arduino board into sleep mode. This will reduce its energy consumption. In addition, we will also put the HX711 amplifier in sleep mode between each measurement. To do this, after each measurement we put the observation of the weight sensor in sleep mode, and we will wake it before each measurement. The time measurement will be done by the sleep time of the Arduino board. This allows us to save more than 20 mA over a 12-minute time between each data send.

Once our LabDec tests were successful, we moved on to the creation of the PCB (Printed Circuit Board).

Simulation

Creation of the electronic map

To begin, we used the Altium software, an integrated computer-aided design software chain for electronic systems. First of all, we modeled the diagram as in the image below.

To import the MKRFOX board, we installed the Loader V2.2 library and the 110990030 library for the sensors. We linked the components with labels to make the diagram readable.

As you can see with the picture below, we have exported our schematic to PCB. Here are the steps we did:

- Define the outline of the board so that the printer targets a particular area

- Define the width of the components (min width: 16 millimeters, max width: 39 millimeters)

- Choose the layer to be used for wiring and soldering (here we chose the bottom layer)

- Define the ground plane

- Route the board (the wires must not cross each other)

Electrical diagram

PCB

Connections with Sigfox and Ubidots Prototype implementation

The Sigfox network specializes in the Machine to Machine via energy-efficient low-flow networks which promotes the autonomy of our hive. It contributes to the Internet of Things by allowing interconnection via an LPWAN gateway.

To set up the Sigfox module:

• You must register your device with the Sigfox back end. Go to https://backend.sigfox.com/activate and you will find a list of Sigfox compatible development kits, choose your kit to continue.

• Next, you will need to choose a Sigfox operator for the country in which you are going to activate your device. Find your country and select the operator to continue.

• Once your device is saved in the Sigfox backend, you should see it in the Device section as shown in the image below:

Sigfox backend

This technology allows us to send 140 messages per day over a maximum of 12 bytes so we have adapted our codes with these conditions, so we send sensor data every 12 min over 12 bytes. This data can be accessed on the Sigfox Backend.

Sigfox backend

To interact with the IoT data analysis and visualization platform that is Ubidots, you just need to configure callbacks that allow us to transmit our data from Sigfox to Ubidots.

· • To configure a callbakc to the Ubidots API, use the

· Type : Data - Uplink

· Channel : UTL • Custom payload config : value0::uint:8 value1::uint:8 value2::uint:8 value3::uint:8 value4::uint:8 • URL pattern: https://industrial.api.ubidots.com/api/v1.6/devices/{device}/

· Using the HTTP method: POST

· Send SNI : Checked

· Headers : x-auth-token BBFF-SSwnDYhu1rEvidVo5vDVpgpMvam4Ky

· Content Type : application/json • Body: { "Temperature" : {"value":"{customData#value0}"}, "Humidity" : {"value":"{customData#value1}"}, "TempIntern" : {"value":"{customData#value2}"}, "Anemo" : {"value":"{customData#value3}"}, "Poids" : {"value":"{customData#value4}"} }

Once your device is ready, go to your Ubidots account to view the new device created with the variables. In the Ubidots account, create a new currency in the Devices menu. Afterwards, you can view the different variables by clicking on them. On the temperature, because we had multiplied it by 10:

Dashboard Ubidots

To have it in degree, we divide our first temperature variable by 10:

Then we create our Dashboard, in a more aesthetic way so that the beekeeper can easily read the data of the hive and interpret it in real time. To send the notifications to the farmer we went through Ubidots, we clicked on the data, then on Events:

Dashboard warning

Then, click on Create Event:

Button Create

And we set our e-mails.

Workflow

Ubidots notification

Realization of the case

Initially, the cables were twisted and sealed by covering them with plastic sheaths. Then our team weld all the components to the board. After checking the correct operation of the assembly. We drilled the box to pass the cables, in addition, we added a fabric to protect the internal moisture sensor from honey and beeswax.

final system

Once the box was hermetically sealed, we proceeded to install the box on the hive. We also put in place a button to turn on and off the case, an led tells us the ignition and sends the data while flashing.

Conclusion

This project allowed our group to work on producing a marketable product from start to finish. We wrote the Arduino code, built the PCB board, welded the components, prepared the sensors and the case. This allowed us to improve our technical skills and our ingenuity in order to carry out this project. We gained a lot of experience and improved our management skills, and programming skills.

Code

Codes sources

#include <SigFox.h>
#include <Adafruit_Sensor.h>
#include <DHT.h>
#include <HX711.h>
#include <OneWire.h>
#include <ArduinoLowPower.h>

int DEBUG = 1; //0 pour debug et 1 pour autonomie

#define LEDPIN 6
//===================================================================================================================================================== POIDS SUR HX711
#define LOADCELL_DOUT_PIN  2 // pour le capteur de poids
#define LOADCELL_SCK_PIN  3 // pour le capteur de poids
HX711 scale;
float calibration_factor = 21067; // pour 16,6 kg -> 21067 and for ~93,5 kg -> 21387, on a actuellement une marge de 300g
float zero_factor = 199457; //Numeric value of 0 Kg
//===================================================================================================================================================== POIDS SUR HX711
/*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
//===================================================================================================================================================== TEMP ET HUM SUR DHT22 Externe
#define DHTPINE 4     // Pin digital connecte au DHT sensor
#define DHTTYPE    DHT22     // DHT 22 (AM2302)
DHT dhtE(DHTPINE, DHTTYPE);
//===================================================================================================================================================== TEMP ET HUM SUR DHT22 Externe
/*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
//===================================================================================================================================================== TEMP ET HUM SUR DHT22 Interne
#define DHTPINI 7     // Pin digital connecte au DHT sensor
DHT dhtI(DHTPINI, DHTTYPE);
//===================================================================================================================================================== TEMP ET HUM SUR DHT22 Interne
/*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
//===================================================================================================================================================== TEMP INTERNE SUR DS18B20
/* Broche du bus 1-Wire */
const byte BROCHE_ONEWIRE = 5; 

OneWire ds(BROCHE_ONEWIRE);
/* Adresses des capteurs de température */
const byte SENSOR_ADDRESS_1[8] = {  0x28, 0x46, 0xC8, 0x31, 0xC, 0x0, 0x0, 0xB9 };
const byte SENSOR_ADDRESS_2[8] = { 0x28, 0x2C, 0xDE, 0x75, 0xD0, 0x1, 0x3C, 0xC0 };
const byte SENSOR_ADDRESS_3[8] = { 0x28, 0x75, 0x91, 0x16, 0xA8, 0x1, 0x3C, 0x2C };
//===================================================================================================================================================== TEMP INTERNE SUR DS18B20
/*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
//===================================================================================================================================================== BATTERIE
int analogPin = A3; // potentiometer wiper (middle terminal) connected to analog pin 3
float val = 0;  // variable to store the value read
float resultat= 0; // le resultat en volt
float pourcentage=0; //la charge de la batterie en pourcentage
//===================================================================================================================================================== BATTERIE
/*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
/*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
/*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
//===================================================================================================================================================== STRUCTURE DU MESSAGE
//Struct to send values to Sigfox __attribute__ ((packed)) sigfox_message 
typedef struct {
  int8_t pourcentage;    //1 o
  int8_t HumiditeEXT;    //1 o
  int8_t tempEXT;        //1 o
  int8_t HumiditeINT;    //1 o
  int16_t temperature1;  //2 o
  int16_t temperature2;  //2 o
  int16_t temperature3;  //2 o
  int16_t poids;         //2 o
} SigfoxMessage;

SigfoxMessage ValeursCapteurs;
//===================================================================================================================================================== STRUCTURE DU MESSAGE
/*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
/*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
/*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
//============================================================================================================================================================================================= TEMP INTERNE SUR DS18B20 DEBUT
/**
 * Fonction de lecture de la température via un capteur DS18B20.
 */
float getTemperature(const byte addr[]) {
  byte data[9];
  // data[] : Données lues depuis le scratchpad
  // addr[] : Adresse du module 1-Wire détecté
  
  /* Reset le bus 1-Wire et sélectionne le capteur */
  ds.reset();
  ds.select(addr);
  
  /* Lance une prise de mesure de température et attend la fin de la mesure */
  ds.write(0x44, 1);
  delay(800);
  
  /* Reset le bus 1-Wire, sélectionne le capteur et envoie une demande de lecture du scratchpad */
  ds.reset();
  ds.select(addr);
  ds.write(0xBE);
 
 /* Lecture du scratchpad */
  for (byte i = 0; i < 9; i++) {
    data[i] = ds.read();
  }
  /* Calcul de la température en degré Celsius */
  return (int16_t) ((data[1] << 8) | data[0]) * 0.0625; 
}
/*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
/*
void getTempExt() {
  ValeursCapteurs.tempEXT = SigFox.internalTemperature() * 10;
  if(DEBUG == 0){
  Serial.print(F("Temperature: "));
  Serial.print(ValeursCapteurs.tempEXT);
  Serial.println(F("°C"));
  }
}
*/
/*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
void getTempInterne(){
   
  /* Lit les températures des trois capteurs */
  ValeursCapteurs.temperature1 = (int16_t)(getTemperature(SENSOR_ADDRESS_1)*10);
  ValeursCapteurs.temperature2 = (int16_t)(getTemperature(SENSOR_ADDRESS_2)*10);
  ValeursCapteurs.temperature3 = (int16_t)(getTemperature(SENSOR_ADDRESS_3)*10);

  if(DEBUG == 0){
      /* Affiche les températures */
      Serial.print(F("\n------------------------------------\n"));
      Serial.print(F("Temperatures internes : \n"));
      Serial.print(F("Temperature du capteur 1 : "));
      Serial.print(ValeursCapteurs.temperature1);
      Serial.print(F("° C, "));
      Serial.print(F("\nTemperature du capteur 2 : "));
      Serial.print(ValeursCapteurs.temperature2);
      Serial.print(F("° C, "));
      Serial.print(F("\nTemperature du capteur 3 : "));
      Serial.print(ValeursCapteurs.temperature3);
      Serial.println("° C");
      Serial.print(F("------------------------------------\n"));
  }
}
//============================================================================================================================================================================================= TEMP INTERNE SUR DS18B20 FIN
/*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
/*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
/*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/

//============================================================================================================================================================================================= TEMP ET HUM SUR DHT22 Externe DEBUT
void getCapteurDHTEXT() {
  ValeursCapteurs.tempEXT = dhtE.readTemperature(); // temperature degrees
  ValeursCapteurs.HumiditeEXT = dhtE.readHumidity(); //humidite percent
 

  if (isnan(ValeursCapteurs.tempEXT)) {
    if(DEBUG == 0){
      Serial.println(F("Error reading temperature!"));
      }
    }
      
  if (isnan(ValeursCapteurs.HumiditeEXT)) {
    if(DEBUG == 0){
      Serial.println(F("Error reading humidity!"));
      }
    }

  if(DEBUG == 0){
  Serial.print(F("tempEXT: "));
  Serial.print(ValeursCapteurs.tempEXT);
  Serial.println(F("°C"));
       
  Serial.print(F("HumiditeEXT: "));
  Serial.print(ValeursCapteurs.HumiditeEXT);
  Serial.println(F("%"));
  }
}
//============================================================================================================================================================================================= TEMP ET HUM SUR DHT22 Externe FIN
//============================================================================================================================================================================================= TEMP ET HUM SUR DHT22 Interne DEBUT
void getCapteurDHTINT() {
  ValeursCapteurs.HumiditeINT = dhtI.readHumidity(); //humidite percent
      
  if (isnan(ValeursCapteurs.HumiditeINT)) {
    if(DEBUG == 0){
      Serial.println(F("Error reading humidity!"));
      }
    }

  if(DEBUG == 0){
       
  Serial.print(F("HumiditeINT: "));
  Serial.print(ValeursCapteurs.HumiditeINT);
  Serial.println(F("%"));
  }
}
//============================================================================================================================================================================================= TEMP ET HUM SUR DHT22 FIN
/*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
/*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
/*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
//============================================================================================================================================================================================= POIDS SUR HX711 DEBUT
void getPoids(){
    //Get weight

    scale.power_up();
    ValeursCapteurs.poids = (int16_t) (scale.get_units() * 10);
    scale.power_down();

    
    if(DEBUG == 0){
    Serial.print("Reading: ");
    Serial.print(ValeursCapteurs.poids, 1);
    Serial.print(" kg ");
    Serial.println();
    }
  }
//============================================================================================================================================================================================= POIDS SUR HX711 FIN
/*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
/*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
/*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
//============================================================================================================================================================================================= BATTERIE DEBUT
void getBaterie(){
  analogReadResolution(10);
  val = analogRead(analogPin);  // read the input pin
  //map(value, fromLow, fromHigh, toLow, toHigh)
  if (val>0)
  {
  ValeursCapteurs.pourcentage = map(val,0,403,0,100);
  }
  else
  ValeursCapteurs.pourcentage=(int8_t)0;

  if(DEBUG == 0){
    Serial.println("val :"); 
    Serial.println(val); 
    Serial.println("Pourcentage batterie :");          // debug value
    Serial.println(ValeursCapteurs.pourcentage);
  }
}
//============================================================================================================================================================================================= BATTERIE FIN
/*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
/*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
/*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
//============================================================================================================================================================================================= ENVOIE SIGFOX DEBUT
void envoi(){ //protocole pour envoyer un message à Sigfox
 SigFox.begin();
 SigFox.beginPacket();
 SigFox.write((uint8_t*)&ValeursCapteurs, sizeof(SigfoxMessage));
   if(DEBUG == 0){
     Serial.print("Status: ");
     Serial.println(SigFox.endPacket());
   }
   else{
      SigFox.endPacket();
   }
 SigFox.end();
}

void reboot() {
 NVIC_SystemReset();
 while (1);
}
//============================================================================================================================================================================================= ENVOIE SIGFOX FIN
/*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
/*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
/*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
//============================================================================================================================================================================================= SETUP DEBUT
void setup() {
  if(DEBUG == 0){
      Serial.begin(9600);
  }

  pinMode(LEDPIN, OUTPUT);
  digitalWrite(LEDPIN, HIGH);
  delay(1000);
  digitalWrite(LEDPIN, LOW);
  delay(1000);
  dhtE.begin();
  dhtI.begin();
    if(DEBUG == 0){
         while (!Serial);
    }

   if (!SigFox.begin()) {
       if(DEBUG == 0){
           Serial.println("SigFox error, rebooting");
       }
   reboot();
   }
   delay(100); // Wait at least 30ms after first configuration
   // Enable debug prints and LED indication
   SigFox.debug();
  //Set weight sensor
  scale.begin(LOADCELL_DOUT_PIN, LOADCELL_SCK_PIN);
  scale.set_scale(calibration_factor);
  scale.set_offset(zero_factor);

  pinMode(analogPin, INPUT); //For the battery, configuration of ADC

   SigFox.status();
}
//============================================================================================================================================================================================= SETUP FIN
/*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
/*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
/*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
//============================================================================================================================================================================================= MAIN
void loop() {
  Serial.print(F("------------------------------------------------------------------------------------------------------------\n"));
  getBaterie();
  getCapteurDHTEXT();
  getCapteurDHTINT();
//  getTempExt();
  getTempInterne();
  getPoids();
  envoi();
  Serial.print(F("------------------------------------------------------------------------------------------------------------\n"));
  //delay(60000);
  LowPower.sleep(720000);
  //LowPower.deepSleep(720000);
  //LowPower.deepSleep(30000);
  }

Open Ruche

Things used in this project

Hardware components

Software apps and online services

Hand tools and fabrication machines

Story

Introduction

Features

Prerequisites for developers

How does it work ?

What sensors are used ?

Implementation of the model

Creation of the electronic map

Connections with Sigfox and Ubidots Prototype implementation

Realization of the case

Conclusion

Schematics

PCB

Code

Codes sources

Codes sources

Credits

Pascoal Kiangangu

Comments

Embed the widget on your own site

Open Ruche

Open Ruche

Things used in this project

Hardware components

Software apps and online services

Hand tools and fabrication machines

Story

Introduction

Features

Prerequisites for developers

How does it work ?

What sensors are used ?

Implementation of the model

Creation of the electronic map

Connections with Sigfox and Ubidots Prototype implementation

Realization of the case

Conclusion

Schematics

PCB

Code

Codes sources

Codes sources

Credits

Pascoal Kiangangu

Comments

Related channels and tags