🐝 Open Hive – An Autonomy-Driven IoT Solution for Beekeeping
I. Why We Built Open Hive
II. Specifications
III. Prototype Development
IV. Data Communication
V. Power Consumption & Autonomy
VI. Management & Team Organization
VII. Conclusion

Oumert Amine

•

Gloire Dembi

•

Léa Lacouture

Published May 6, 2025 © GPL3+

Open Ruche : A Connected Beehive for Smart Bee Monitoring

Connected beehive project using sensors & open tech to monitor hive health in real-time and protect bees through smart data.

IntermediateProtipOver 1 day522

Open Ruche : A Connected Beehive for Smart Bee Monitoring

Things used in this project

Hardware components

Arduino MKR WAN 1310

LoRaWAN-enabled microcontroller

DHT22 Temperature Sensor

Indoor and outdoor air data

Adafruit Waterproof DS18B20 Digital temperature sensor

Redundant internal temperature readings

DFRobot SEN0562

Light Sensor

DFRobot Gravity: I2C 1Kg Weight Sensor Kit - HX711

Hive weight monitoring

Seeed Studio LiPo Rider Pro

Power management & backup battery

LiPo Battery

Power management & backup battery

Solar Panel

Recharges battery off-grid

Through Hole Resistor, 82 kohm

Voltage divider

Resistor 22.1k ohm

Voltage divider

Breadboard (generic)

Hardware, PCB Mounting Kit

Custom breakout & cabling

Enclosure & mounting hardware

Weatherproof housing for sensors & board

Software apps and online services

KiCad

PCB

Ubidots

Dashboard and alert

Beep

Dashboard and alert

Arduino IDE

Dev code

The Things Industries The Things Stack

Receive LoRa data

Hand tools and fabrication machines

Solder Wire, Lead Free

For soldering

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

Wire cutter

Drill / Driver, Cordless

For hole on box

Soldering iron (generic)

For soldering

Soldering Gun Kit, Instant Heat

For heat wires

Multitool, Screwdriver

For everything

Premium Female/Male Extension Jumper Wires, 40 x 6" (150mm)

For every connection

Box, General Purpose

A waterproof enclosure that contains the entire system

Seeed Studio Grove - Universal 4 Pin Buckled 5cm Cable (5 PCs Pack)

For each connection on the PCB

Tape, Electrical

For electrical isolation, the safety and the duracity

Story

🐝 Open Hive – An Autonomy-Driven IoT Solution for Beekeeping 🐝

I. Why We Built Open Hive 🐝

Beekeepers worldwide face a silent crisis: colonies vanish without warning, weights drop mysteriously, ad hives fall victim to theft or extreme weather. Traditional inspections are labor-intensive and reactive. We imagined a future where every hive reports its own health, day and night, powered solely by sun and battery. Open Hive is a self-powered, LoRaWAN-enabled sensor node that monitors hive temperature, humidity, weight and ambient light every ten minutes, then pushes the data to The Things Network. Users visualize real-time dashboards on Ubidots STEM and BEEP Monitor, and receive instant alerts via SMS or e-mail if—for example—the hive weight drops dramatically, temperature soars, or solar battery falls below safe thresholds.

II. Specifications 🐝

Target sensor accuracies :

Temperature ± 0.5 °C (internal/external)
Humidity ± 2 %
Weight ± 100 g
Light resolution for solar yield

III. Prototype Development 🐝

To transform the Open Hive concept into a working device, we followed a three-stage prototype workflow—breadboard validation, custom PCB design, and final enclosure assembly.

1.Breadboard Validation & Sensor TestsWe began by mounting the Arduino MKR WAN 1310 on a solderless breadboard alongside each sensor:

DS18B20 probes for internal temperature
DHT22 for external temperature & humidity
HX711 amplifier paired with a load cell under the hive base
SEN0562 for ambient light

Each sensor was powered from the MKR’s 3.3 V rail and wired to unique GPIO pins. We wrote standalone sketches to verify:

Temperature accuracy against a lab thermometer
Humidity consistency versus a calibrated hygrometer
Load-cell readings on a precision scale
Lux values compared to a handheld lux meter

This step caught early issues—loose breadboard jumpers, noisy DHT22 readings before PCB design.

Electrical schematic: overview of sensor interconnections (MKR WAN 1310, DHT22, DS18B20, HX711, SEN0562 )

Battery Schematic

Sensors Schematic

2.Schematic & PCB LayoutOnce each sensor sketch passed validation, we translated our breadboard into a formal KiCad schematic:

Power management: LiPo Rider Pro charger, voltage regulator, and divider for battery monitoring
Sensor connectors: DS18B20, DHT22, HX711 cell, and SEN0562 module
Microcontroller: MKR WAN 1310 with LoRa antenna connector

The PCB layout tightly packs all components. Ground pours and star-point placement keep analog load-cell measurements clean. After Gerber export, we etched and soldered the board by hand, then inspected all joints under magnification to eliminate cold-solder defects.

PCB design: KiCad layout, Gerber export, component placement

PCB Schematic

PCB Layout

PCB Schematic on Kicad

3.Enclosure & Final AssemblyFor rugged outdoor use, the PCB and battery rider sit inside a box:

Cable glands seal each sensor lead from moisture
The solar panel attaches via exterior mounting holes

During the testing and validation phase, we pinpointed two critical sensor issues that required root‐cause analysis and remediation. First, the HX711 load‐cell amplifier exhibited erratic zero-drift readings: under static loads, output values would randomly fluctuate by several hundred grams. Trace inspection revealed a handful of cold solder joints on the amplifier’s gain resistors. After reflowing these joints with fresh solder and adding flux, the drift vanished and the amplifier delivered stable, repeatable measurements within the ± 100 g tolerance.

Second, our batch of DHT22 modules showed up to ± 5 % humidity variance at high RH levels, exceeding its ± 2 % specification. By cross-referencing each sensor against a calibrated reference hygrometer, we established unique calibration curves for each DHT22 in software. A small subset of units remained outliers even after calibration; these were deemed defective and replaced. Post-calibration testing confirmed that all retained DHT22 sensors now report humidity within ± 2 % of the reference, ensuring consistent environmental readings across deployments.

Mechanical enclosure: Box, cable glands, solar panel mount

Final Assembly

IV. Data Communication 🐝

LoRaWAN & TTN Encoding and Transmission

Each sensor reading (float) is multiplied by 100, cast to a 16-bit integer, and packed into a 16-byte buffer
The payload is transmitted via OTAA to The Things Network, after which the module goes to sleep.

The Things Network receives and decrypts the incoming frame.

Ubidots: real-time visualization via graphical widgets (thermometers, gauges, graphics).

BEEPMonitor: receives the same payload to trriger alerts when critical thresholds are reached (swarming, weight loss, low battery).

Alerts :

V. Power Consumption & Autonomy 🐝

1. To maximize autonomy to over 30 days on a LiPo battery, we focused on software optimization:

DeepSleep Mode: After each LoRa transmission, the Arduino MKR WAN 1310 enters DeepSleep mode for 10 minutes.

Disabling Unused Peripherals : The I²C interface (Wire.end()) and the HX711 converter (scale.power_down()) are shut down before entering Deepsleep Mode.

Result :

Before power optimization: 1.7 days of battery life

After power optimization: 30.3 days of battery life

VI. Management & Team Organization 🐝

The success of the Connected Beehive project relied on structured organization, extensive use of collaborative tools, and the early establishment of clear team-wide working principles. In a multidisciplinary context combining electronics, embedded systems, and wireless communication, effective task coordination and a fair distribution of responsibilities were crucial.

Working Framework and Foundational Principles

From the outset, the team agreed on a set of operating principles designed to ensure a healthy, productive, and coherent working dynamic throughout the semester. These principles included:

Encouraging constant and transparent communication, regardless of topic;
Trusting in each member’s individual competencies, allowing for autonomy in specific areas of expertise;
Openly sharing technical difficulties, enabling fast, collective problem-solving;
Defining a clear division of roles, while maintaining flexibility in response to workload variations or unforeseen issues.
This collaborative framework created a climate of trust that fostered individual accountability while promoting collective responsibility.

Development Methodology and Organizational Approach

Rather than following a rigid project management model (e.g., Scrum, Waterfall), the team adopted an agile approach based on short, iterative phases. Each member was assigned specific modules (sensors, communication interface, power supply, embedded software) aligned with their skills and interests.

Development proceeded incrementally, through prototyping, individual testing, and final system integration. This modular organization enabled early detection of issues and streamlined the final assembly.

Advanced Use of GitHub for Collaborative Project Management

GitHub was the cornerstone of our collaborative infrastructure. Beyond code versioning, we leveraged its full project management capabilities:

GitHub Projects: A customizable Kanban board structured all project tasks. Each card corresponded to a feature, bug, test, or documentation item, facilitating visual tracking of progress.
Roadmap: This view helped plan critical milestones (e.g., sensor integration, LoRa validation, field testing, final deliverables) and ensured alignment with deadlines.

Roadmap

Assignees and Labels: Every task (issue) was assigned to a team member, categorized (feature, bug, test, documentation), and prioritized (high, medium, low).
Milestones: Key development phases were defined and tracked to support structured planning and time management.
Team Capacity: This feature allowed workload estimation based on availability and expertise, enabling a more balanced task distribution.

Team capacity

My Items: Each member had a personalized dashboard displaying only their assigned tasks, enhancing individual focus while maintaining collective visibility.

my items

The systematic use of pull requests, combined with peer reviews, ensured high code quality and smooth integration.

https://github.com/OUMERTAmine/Ruche

Communication and Team Coordination

Effective collaboration relied on a mix of synchronous and asynchronous communication tools:

WhatsApp for daily updates and quick decisions;
Google Meet for weekly technical meetings and milestone reviews;
In-person sessions for hardware-related tasks such as soldering, system assembly, and debugging.

This hybrid communication model supported flexibility while ensuring consistent coordination across the team.

Feedback and Lessons Learned

At the conclusion of the project, several key takeaways emerged:

Setting a clear collaborative framework from the start was instrumental in avoiding misunderstandings and balancing team efforts;
A work culture based on mutual trust and skills recognition significantly enhanced efficiency and engagement;
Fully exploiting GitHub as a project management platform, not just a code repository, provided real-time visibility, improved traceability, and facilitated structured collaboration;
The project offered valuable technical learning opportunities: PCB design using KiCad, wireless communication via LoRaWAN, precision soldering, embedded debugging, and development of reliable standalone systems.

Ultimately, this project served as a practical immersion into real-world collaborative engineering. It demonstrated the importance of a flexible yet disciplined organizational approach, and enabled each team member to grow both technically and methodologically.

VII. Conclusion 🐝

In conclusion, thanks to rigorous organization, effective collaboration, and a strategic distribution of tasks, the team successfully designed a functional, modular, and scalable system that met both technical and educational expectations.

Beyond its functional achievements, this project served as a valuable learning opportunity. Each member was able to consolidate and expand their skills in various areas such as electronics, wireless communication, embedded development, system integration, as well as project management and teamwork in a distributed environment.

Several areas for improvement have been identified for future development:

Correction of persistent anomalies in the light measurement module;
Integration of new sensors such as a microphone for sound detection or a camera for visual monitoring inside the beehive;
Improvement of the system’s ergonomics and autonomy.

All in all, this project stands as a formative and enriching experience—both technically and personally—paving the way for concrete future developments in more advanced and field-ready IoT applications.

You can find our entire project on our github ! : https://github.com/OUMERTAmine/Ruche

Schematics

Code

Firmware Implementation (Arduino C/C++)

Firmware Implementation (Arduino C/C++)

C/C++

Every ten minutes, the Arduino MKR WAN 1310 wakes from deep sleep and runs a single sketch written in C/C++. First, it powers up the DHT22 and DS18B20 sensors to sample internal and external temperature/humidity, then reads the HX711 amplifier for hive weight and the BH1750 (SEN0562) for ambient light. These four measurements are packed into a compact 12-byte payload, which the on-board LoRaWAN library transmits to The Things Network. After a successful uplink (or a short retry on failure), the MCU shuts down radios and sensors, then returns to deep sleep—minimizing power draw until the next scheduled wake-up.

#include <MKRWAN.h>
#include <Wire.h>
#include "ArduinoLowPower.h"
#include <DHT.h>
#include <OneWire.h>
#include <DallasTemperature.h>
#include <BH1750.h>
#include "HX711.h"
#include <FlashStorage.h>

////////////////////////
///     SETUP      ///
////////////////////////

LoRaModem modem;
#define SECRET_APP_EUI "0000000000000001"
#define SECRET_APP_KEY "8062D07A1C984423278A7D938C73E534"
String appEui = SECRET_APP_EUI;
String appKey = SECRET_APP_KEY;

#define DHT22_PIN 2
#define DHT11_PIN 3
#define DS18B20_PIN 7
#define LOADCELL_DOUT_PIN 0
#define LOADCELL_SCK_PIN 1
#define BATTERY_SENSOR_PIN A1

const float R1 = 82.0;
const float R2 = 22.0;
const float Vref = 3.3;
const int resolution = 1023;

DHT dht22(DHT22_PIN, DHT22);
DHT dht22_outside(DHT11_PIN, DHT22);
OneWire oneWire(DS18B20_PIN);
DallasTemperature ds18b20(&oneWire);
BH1750 lightMeter;
HX711 scale;

float tempDHT22, humDHT22;
float tempDHT11, humDHT11;
float tempDS18B20;
float luminosite;
float poids;
float batteryVoltage;
int batteryPercentage;
float calibration_factor = 30226.0;
byte buffer[16];

// Stockage du tare HX711 en flash
FlashStorage(tareStorage, long);

void connection() {
  if (!modem.begin(EU868)) {
    Serial.println("chec de l'initialisation LoRa !");
    while (1);
  }
  Serial.print("Version module : ");
  Serial.println(modem.version());
  Serial.print("Device EUI : ");
  Serial.println(modem.deviceEUI());

  if (!modem.joinOTAA(appEui, appKey)) {
    Serial.println("chec de connexion  TTN !");
    while (1);
  }
  Serial.println("Connect  TTN !");
}

void setup() {
  Serial.begin(115200);
  Serial.println("=== Dmarrage du systme ===");

  connection();

  dht22.begin();
  dht22_outside.begin();
  ds18b20.begin();

  Wire.begin();
  if (!lightMeter.begin()) {
    Serial.println("Erreur : BH1750 non dtect !");
    while (1);
  }

  Serial.println("Initialisation du HX711...");
  scale.begin(LOADCELL_DOUT_PIN, LOADCELL_SCK_PIN);
  delay(5000);

  long tareOffset = tareStorage.read();
  if (tareOffset == 0 || tareOffset == -1L) {
    Serial.println("Premire utilisation : calibration en cours...");
    scale.tare(); // Mettre la balance  vide pour cette tape !
    tareOffset = scale.get_offset();
    tareStorage.write(tareOffset);
    Serial.println("Tare calibr et sauvegard !");
  } else {
    Serial.println("Tare trouv en mmoire, utilisation directe.");
    scale.set_offset(tareOffset);
  }

  scale.set_scale(calibration_factor);
}

void measureBattery() {
  int rawValue = analogRead(BATTERY_SENSOR_PIN);
  float Vmesure = (rawValue * Vref) / resolution;
  batteryVoltage = Vmesure * 1.28;
  batteryPercentage = getBatteryPercentage(batteryVoltage);
  buildMessage(batteryPercentage, 14);
}

int getBatteryPercentage(float voltage) {
  if (voltage >= 4.2) return 100;
  else if (voltage >= 4.1) return 95;
  else if (voltage >= 4.05) return 90;
  else if (voltage >= 4.0) return 85;
  else if (voltage >= 3.95) return 80;
  else if (voltage >= 3.9) return 75;
  else if (voltage >= 3.85) return 70;
  else if (voltage >= 3.8) return 65;
  else if (voltage >= 3.75) return 60;
  else if (voltage >= 3.7) return 55;
  else if (voltage >= 3.65) return 50;
  else if (voltage >= 3.6) return 45;
  else if (voltage >= 3.55) return 40;
  else if (voltage >= 3.5) return 35;
  else if (voltage >= 3.45) return 30;
  else if (voltage >= 3.4) return 20;
  else if (voltage >= 3.35) return 10;
  else if (voltage >= 3.3) return 5;
  else return 0;
}

void measureDHTSensors() {
  humDHT22 = dht22.readHumidity();
  tempDHT22 = dht22.readTemperature();
  humDHT11 = dht22_outside.readHumidity();
  tempDHT11 = dht22_outside.readTemperature();
  buildMessage(tempDHT22, 0);
  buildMessage(humDHT22, 2);
  buildMessage(tempDHT11, 4);
  buildMessage(humDHT11, 6);
}

void measureDS18B20() {
  ds18b20.requestTemperatures();
  tempDS18B20 = ds18b20.getTempCByIndex(0);
  buildMessage(tempDS18B20, 8);
}

void measureLuminosity() {
  luminosite = lightMeter.readLightLevel();
  buildMessage(luminosite, 10);
}

void measureWeight() {
  poids = scale.get_units(10);
  buildMessage(poids, 12);
}

void buildMessage(float donnee_float, int index) {
  short donnee_short = (short)(donnee_float * 100);
  buffer[index] = donnee_short & 0xFF;
  buffer[index + 1] = (donnee_short >> 8) & 0xFF;
}

bool sendMessageSafe() {
  modem.beginPacket();
  modem.write(buffer, 16);
  int err = modem.endPacket(true);
  return err > 0;
}

void loop() {
  if (modem.getDataRate() == -1) {
    Serial.println("Connexion LoRa perdue, reconnexion...");
    connection();
  }

  measureDHTSensors();
  measureDS18B20();
  measureLuminosity();
  measureWeight();
  measureBattery();

  if (!sendMessageSafe()) {
    Serial.println("Envoi LoRa chou !");
    connection(); 
    connection();
  } else {
    Serial.println("Donnes envoyes !");
  }

  Wire.end();
  scale.power_down();
  modem.sleep();

  Serial.println("Deep Sleep 10 minutes...");
  LowPower.deepSleep(600000); 

  Serial.println("Rveil !");
  Wire.begin();
  scale.power_up();
}

Open Ruche : A Connected Beehive for Smart Bee Monitoring