Published September 3, 2025 © Apache-2.0

SkySense - The Perfect Flying Laboratory

A flying laboratory equipped with everything you need. : ESP32 Cam, BME680, and Wio Tracker L1 Series. Perfect for any occasion.

IntermediateWork in progress24 hours322

Base Award

Meshtastic Device Design Challenge

Things used in this project

Hardware components

Seeed Studio Wio Tracker L1 Series

One for the ground station and the other for the laboratory

Esp32cam

Micro SD

Seeed Studio Grove - Temperature, Humidity, Pressure and Gas Sensor (BME680)

Battery 1860 3.7V

Jumper wires (generic)

Machine Screw, M3

Machine Screw, M2

Hot Air Balloon

Rope 1m

Software apps and online services

Autodesk Fusion

Arduino IDE

Meshtastic

Fritzing.

Hand tools and fabrication machines

3D Printer (generic)

Soldering iron (generic)

Hot glue gun (generic)

Story

What is SkySense?

Everyone has found themselves staring at the sky at least once in their lives, as if completely alienated. Since I was a child, I loved observing the summer sky, especially at night. As I grew older, my interest embraced the scientific world, and at the "WOW" a child exclaims, I moved on to asking questions, but my love for the sky and space remained the same.

SkySense was born from this love. A small laboratory connected to a hot air balloon to answer some of those questions.

How is it built?

To build SkySense, I used simple components. An ESP32 CAM to take photos at different altitudes and save them to an SD card, a BME680 module that allows me to obtain temperature, humidity, and pressure data, and finally a Wio Tracker L1 Series, which, thanks to its LoRa connectivity, allows me to send the recorded data to the ground station along with the capsule's position via GPS. Finally, SkySense will be powered by a 3.7V 1860 Lipo battery that provides about 4 hours of battery life.

Observe the internal structure of SkySense thanks to this video

ESP32 CAM: It's a small card from the ESP family equipped with a small camera and an SD card reader. It allows you to take photos at regular intervals and save them directly to the SD card.
BME680: It's a simple sensor that allows you to obtain temperature, humidity, and atmospheric pressure data. I chose this sensor for connectivity with the Seed board thanks to the Grove connector that allows for a quick and secure connection.
WIO TRACKER L1 SERIES: This board is the true brain of SkySense. Thanks to the Grove connector, it receives data from the BME sensor and sends it to the ground via LoRa connectivity. It also features a GPS module to receive the Capsule's real-time position during ascent. The board also has a solar power connector, which could be used in future versions of SkySense.
BATTERY: To power everything I used a 3.7V 1860 LiPo battery which allows for about 4 hours of autonomy on a full charge.

I connected all the components together according to this diagram.

Here are some photos of how I built and connected all the SkySense electronics. Note that near the lithium battery I placed a master switch and a small two-port jack for charging the battery.

1 / 3 • BME680 module

The Structure

To design the SkySense structure, I used Autodesk Fusion 360. The structure features a screw-on lid that houses the specially organized electronics. To connect everything I used several M2 and M3 screws.

The capsule has two holes, one for the ESP camera and the other for the downward-facing LoRa antenna. At the top and bottom, there are four connectors for attaching the balloon in various ways, or for tethering the capsule to the ground using a tether in initial tests.

You can download all the 3D models from the attachments below.

Using an Anycubic Mega S, the print time for all models was around 20 hours, considering a 15% infill and a fairly slow print speed. To facilitate printing the main component, the 3D model was cut in two and then joined together using superglue. I highly recommend cutting the 3D models and joining them post-printing for a perfect result. Also, as in my case, I recommend sanding the models to remove any printing residue and other supports.

Here are some photos of the printed models.

1 / 2 • The final structure fully printed, but not yet joined

The Base

To receive the data sent by Skysense, I used a twin board, without a GPS module but connected via USB-C to my laptop. The base station received the data sent by Skysense every 15 minutes (BME sensor data, GPS coordinates, and board information such as battery percentage). Each time the base station received a packet, it forwarded it to my PC's serial port, and using software written in Python, which we'll explore later, it allowed me to view all the SkySense information in real time.

To complete the Base it was encapsulated in a small 3D printed case

The Base

The Programming

To program the two boards, I followed the official guide. This allowed me to get the boards up and running in no time. The Skysense board was set as a Tracker, while the Base station board was set as a Client. Once the boards were configured, I simply connected the GPS module and the BME sensor to immediately obtain the first data and share it on the channel.
Please note that once connected to the Skysense board it is necessary to activate telemetry from the node settings. This will immediately allow you to record the values obtained from the sensor.

1 / 2 • The first data

For the ESP32, I used the software you'll find in the attachments. It's a very simple code that takes a photo every second (you can increase this interval to save battery life). I also added a small flash that blinks as soon as the ESP starts up, so you have visual feedback.

The Blink

The GUI

As mentioned in previous chapters, to better visualize the data received from Skysense, I developed a simple Python interface with a Map to display GPS coordinates and three labels used to display telemetry data and battery status.

Thanks to the simplicity of the meshtastic library, I was able to decode the incoming packets and display them graphically in just a few simple steps. You can download the Python program below.

The GUI

Screen

The Final Test

For the final test, I connected the Skysense module to a series of helium balloons so it would rise into the air. I also attached a rope to a weight so it wouldn't be blown away by the wind. The result was amazing. Only four balloons, with a total of about 5 liters of helium, were needed to allow Skysense to take flight. The base station immediately received the packets even when it was at a suitable distance (about 500 meters) thanks to LoRa connectivity.

1 / 4

Here are some photos taken directly from SkySense.

1 / 2

Conclusion

It was a fantastic project, and this is only the first version. Thanks to Meshtastic technology, it was incredibly easy to get everything up and running, and the results are amazing. In future versions, I'll definitely add solar panels and a camera pointing to the sky so I can conduct star-focused experiments. Skysense has great potential, especially since it's so cheap (about €90). I can't wait to see where this project takes me.

Custom parts and enclosures

Sketchfab still processing.

Schematics

Code

ESP32CAM Code

#include "esp_camera.h"
#include "FS.h"
#include "SD_MMC.h"

// ESP32-CAM AI-Thinker pin definition
#define PWDN_GPIO_NUM     -1
#define RESET_GPIO_NUM    -1
#define XCLK_GPIO_NUM      0
#define SIOD_GPIO_NUM     26
#define SIOC_GPIO_NUM     27

#define Y9_GPIO_NUM       35
#define Y8_GPIO_NUM       34
#define Y7_GPIO_NUM       39
#define Y6_GPIO_NUM       36
#define Y5_GPIO_NUM       21
#define Y4_GPIO_NUM       19
#define Y3_GPIO_NUM       18
#define Y2_GPIO_NUM        5
#define VSYNC_GPIO_NUM    25
#define HREF_GPIO_NUM     23
#define PCLK_GPIO_NUM     22

void setup() {
  Serial.begin(115200);
  Serial.println("Starting ESP32-CAM...");

  // Camera configuration
  camera_config_t config;
  config.ledc_channel = LEDC_CHANNEL_0;
  config.ledc_timer   = LEDC_TIMER_0;
  config.pin_d0       = Y2_GPIO_NUM;
  config.pin_d1       = Y3_GPIO_NUM;
  config.pin_d2       = Y4_GPIO_NUM;
  config.pin_d3       = Y5_GPIO_NUM;
  config.pin_d4       = Y6_GPIO_NUM;
  config.pin_d5       = Y7_GPIO_NUM;
  config.pin_d6       = Y8_GPIO_NUM;
  config.pin_d7       = Y9_GPIO_NUM;
  config.pin_xclk     = XCLK_GPIO_NUM;
  config.pin_pclk     = PCLK_GPIO_NUM;
  config.pin_vsync    = VSYNC_GPIO_NUM;
  config.pin_href     = HREF_GPIO_NUM;
  config.pin_sscb_sda = SIOD_GPIO_NUM;
  config.pin_sscb_scl = SIOC_GPIO_NUM;
  config.pin_pwdn     = PWDN_GPIO_NUM;
  config.pin_reset    = RESET_GPIO_NUM;
  config.xclk_freq_hz = 20000000;
  config.pixel_format = PIXFORMAT_JPEG;

  // Resolution and quality
  config.frame_size = FRAMESIZE_SVGA;  // 800x600 (try UXGA, VGA, QVGA...)
  config.jpeg_quality = 12;            // 0-63 (lower = better quality)
  config.fb_count = 1;

  // Initialize camera
  if (esp_camera_init(&config) != ESP_OK) {
    Serial.println("Camera init failed!");
    return;
  }

  // Initialize SD card
  if (!SD_MMC.begin("/sdcard", true)) { // true = 1-bit mode (more stable)
    Serial.println("SD Card Mount Failed!");
    return;
  }

  if (SD_MMC.cardType() == CARD_NONE) {
    Serial.println("No SD Card detected!");
    return;
  }

  Serial.println("Initialization done!");
}

void loop() {
  // Capture photo
  camera_fb_t * fb = esp_camera_fb_get();
  if (!fb) {
    Serial.println("Camera capture failed!");
    return;
  }

  // Create unique file name
  static int photo_num = 0;
  String path = "/photo_" + String(photo_num++) + ".jpg";

  // Save to SD
  fs::FS &fs = SD_MMC;
  File file = fs.open(path.c_str(), FILE_WRITE);
  if (!file) {
    Serial.println("Failed to open file for writing!");
  } else {
    file.write(fb->buf, fb->len);
    Serial.printf("Saved file: %s (%u bytes)\n", path.c_str(), fb->len);
  }
  file.close();

  // Return the frame buffer back to the driver
  esp_camera_fb_return(fb);

  // Wait 15 seconds
  delay(15000);
}

Credits

pasquale887

4 projects • 10 followers

Comments

Awards

Base Award

Meshtastic Device Design Challenge

SkySense - The Perfect Flying Laboratory