Claudia Álvarez

•

Nuria Cuenca caracuel

•

José António Vigário Novo

•

ainhoa cid

•

Luka Mali

Published June 10, 2025

Detection of Illegal Traffic in Protected Natural Areas

A sound-based system to detect and report unauthorized vehicle access in protected natural environments.

IntermediateFull instructions provided190

Detection of Illegal Traffic in Protected Natural Areas

Things used in this project

Hardware components

Seeed Studio XIAO nRF52840 Sense (XIAO BLE Sense)

USB Cable, USB Type C Plug

Software apps and online services

Edge Impulse Studio

Arduino IDE

Story

Introduction

For years, protected natural areas have faced the challenge of illegal vehicles entering core zones, threatening delicate ecosystems. Despite legal protections, these intrusions cause harm to soil, plants, and wildlife.

Inspired by advances in sound recognition technology, we created a smart system that listens to nature’s sounds — distinguishing animal calls, weather, and human activity from unauthorized vehicles. By combining Arduino hardware with acoustic analysis, our device acts as a silent guardian, monitoring protected zones around the clock.

When a suspicious vehicle is detected, an instant SMS alert is sent to park authorities, enabling quick action to protect these vital ecosystems. Our project represents a modern solution to an age-old problem, using technology to preserve the natural world.

Solution

Based on systems that detect sound, our program can identify and isolate the sounds related to the vehicles that most frequent illegal traffic areas. In addition to detecting sounds related to nature, animals, wheat and the presence of humans, to improve efficiency and make a more accurate analysis of whether what it is detecting is really an illegal vehicle.

This technology will be installed at strategic points in the core areas, where irregularities are frequented, monitoring the restricted area 24 hours a day and sending a notification, at the time of detection, via SMS to the authorities of the national park where it has been installed.

Users

The main user of this project would be national park authorities, rangers, environmental protection bodies or environmental NGOs that need the monitoring of certain areas restricted to vehicles to preserve nature in areas with great biodiversity.

Connectivity

Our system is designed to ensure reliable and immediate communication between the sound detection sensors and the end user. When the Arduino-based sensor identifies the sound of an unauthorized vehicle, it automatically sends an SMS alert to the registered user associated with that monitoring area.

To begin receiving alerts, users must complete a simple registration process. First, they sign up by providing essential information such as their organization's phone number, email address, company name, and by creating a secure user profile and password. During this step, users also input the specific locations they wish to monito, r typically the areas most affected by unauthorized vehicle traffic.

Once registered, users select the subscription plan that best suits their needs, depending on the duration of use and the number of devices they want to deploy. The available subscription options are:

Free Trial: allows one device with up to 3 detections, but without access to detection history or advanced configuration.
Monthly Plan: €20 per device per month, renewable monthly. Includes unlimited alerts, access to 20 days of detection history, and basic support
Quarterly Plan: €55 per device every quarter. Offers the same benefits as the monthly plan, with the addition of medium-level priority support.
Annual Plan: €200 per device per year. Includes all features from previous plans plus top priority support

After the account is fully activated, the system starts operating in real time. Whenever a vehicle sound is detected in any of the configured locations, an SMS alert is instantly sent to the user, allowing them to take immediate action to protect the natural area.

This seamless connectivity ensures that park authorities and environmental organizations can respond faster, more efficiently, and without the need for constant physical presence in remote protected zones.

Machine learning

To implement intelligent sound detection in our system, we utilized the Edge Impulse platform to train a machine learning model capable of recognizing different types of acoustic events. Our dataset was structured into two primary categories:

Type 1: Vehicle Sounds: Motorcycle, Truck
Type 2: Environmental Sounds: Storm, Thunder, Wind, Human Voices, Other ambient sounds

The objective was for the model to accurately distinguish between natural environmental sounds and unauthorized vehicle noise, triggering alerts only when relevant intrusions occurred.

Unfortunately, our model did not deliver the desired accuracy. One of the major challenges was that certain environmental sounds — particularly wind and thunder — produced audio patterns similar to motorized vehicles. This led to false positives and misclassifications. Additionally, many sound samples sourced from open datasets contained overlapping noises, further complicating classification and confusing the model during training.

To improve future iterations of the model, we recommend:

Recording audio directly in the target environment, capturing realistic and context-specific vehicle and nature sounds.
Expanding the dataset to include a wider range of sounds, including various animal calls, several types of vehicles and motors, and different types of terrain noise.
Cleaning the dataset to avoid mixed or low-quality samples that can degrade model performance.
Experimenting with additional features and model architectures in Edge Impulse to improve real-time inference accuracy.

Hardware Integration and Connectivity

For real-time audio detection and processing, we used the XIAO nRF52840 Sense, a compact and efficient microcontroller equipped with an onboard microphone. The firmware was developed using the Arduino IDE, and we based our initial implementation on the Nano BLE33 microphone streaming example, adapting it to our specific hardware and use case.

Our modified code enabled:

Continuous microphone data capture
Communication with the Edge Impulse inference engine
Integration of a LoRaWAN module to establish a long-range, low-power connection suitable for remote areas

The final goal was to send an SMS alert to park authorities when a vehicle was detected. While the LoRaWAN transmission of detection data was implemented, we were not able to complete the full integration of the SMS alert system due to time constraints and hardware limitations. The full code is available in the end.

Conclusion

Our project demonstrates a concept that applies machine learning and wireless communication to address an ongoing issue in conservation: the unauthorized presence of vehicles in protected natural areas. Although our model had limitations in prediction accuracy and full SMS functionality, it lays the bases for a scalable, automated solution.

By permantly listening to sounds, this system allows park authorities to react quickly, reduce damage, and better preserve ecosystems — all with minimal human intervention.

With further refinement and field testing, this silent guardian could become a valuable asset in the global effort to protect biodiversity and natural heritage.

Untitled file

#include <Arduino.h>
#include <PDM.h>
#include <MIT_Project_inferencing.h>  // Your Edge Impulse inferencing header

#define LORA_POWER_PIN 5
#define LORA_SERIAL Serial1

#define VEHICLE_DETECTION_THRESHOLD 0.7f

typedef struct {
    signed short *buffers[2];
    unsigned char buf_select;
    unsigned char buf_ready;
    unsigned int buf_count;
    unsigned int n_samples;
} inference_t;

static inference_t inference;
static bool record_ready = false;
static signed short *sampleBuffer;

static int print_results = -(EI_CLASSIFIER_SLICES_PER_MODEL_WINDOW);

void sendAlertMessage(const char *msg) {
  LORA_SERIAL.println("AT+MSG=\"" + String(msg) + "\"");
  Serial.print("Sent alert: ");
  Serial.println(msg);
  delay(1000); // wait a bit after sending
}

// PDM callback - from your code
static void pdm_data_ready_inference_callback(void) {
  int bytesAvailable = PDM.available();
  int bytesRead = PDM.read((char *)&sampleBuffer[0], bytesAvailable);

  if (record_ready) {
    for (int i = 0; i < bytesRead >> 1; i++) {
      inference.buffers[inference.buf_select][inference.buf_count++] = sampleBuffer[i];
      if (inference.buf_count >= inference.n_samples) {
        inference.buf_select ^= 1;
        inference.buf_count = 0;
        inference.buf_ready = 1;
      }
    }
  }
}

static bool microphone_inference_start(uint32_t n_samples) {
  inference.buffers[0] = (signed short *)malloc(n_samples * sizeof(signed short));
  if (!inference.buffers[0]) return false;

  inference.buffers[1] = (signed short *)malloc(n_samples * sizeof(signed short));
  if (!inference.buffers[1]) {
    free(inference.buffers[0]);
    return false;
  }

  sampleBuffer = (signed short *)malloc((n_samples >> 1) * sizeof(signed short));
  if (!sampleBuffer) {
    free(inference.buffers[0]);
    free(inference.buffers[1]);
    return false;
  }

  inference.buf_select = 0;
  inference.buf_count = 0;
  inference.n_samples = n_samples;
  inference.buf_ready = 0;

  PDM.onReceive(&pdm_data_ready_inference_callback);
  PDM.setBufferSize((n_samples >> 1) * sizeof(int16_t));

  if (!PDM.begin(1, EI_CLASSIFIER_FREQUENCY)) {
    Serial.println("Failed to start PDM!");
    return false;
  }
  PDM.setGain(127);

  record_ready = true;
  return true;
}

static bool microphone_inference_record(void) {
  if (inference.buf_ready == 1) {
    Serial.println("Error: sample buffer overrun, decrease EI_CLASSIFIER_SLICES_PER_MODEL_WINDOW");
    return false;
  }
  while (inference.buf_ready == 0) delay(1);
  inference.buf_ready = 0;
  return true;
}

static int microphone_audio_signal_get_data(size_t offset, size_t length, float *out_ptr) {
  numpy::int16_to_float(&inference.buffers[inference.buf_select ^ 1][offset], out_ptr, length);
  return 0;
}

void setupCommunication() {
  pinMode(LORA_POWER_PIN, OUTPUT);
  digitalWrite(LORA_POWER_PIN, HIGH);
  delay(100);

  LORA_SERIAL.begin(9600);
  while (!LORA_SERIAL);

  LORA_SERIAL.println("AT+ID=AppEui,\"0807022103180204\"");
  delay(1000);
  LORA_SERIAL.println("AT+ID=DevEui,\"70B3D57ED007083C\"");
  delay(1000);
  LORA_SERIAL.println("AT+KEY=AppKey,\"AAFF6BE2A06CB4FE1FDEF2A0B3B2A7E0\"");
  delay(1000);
  LORA_SERIAL.println("AT+MODE=LWOTAA");
  delay(1000);
  LORA_SERIAL.println("AT+JOIN");
  delay(5000);
}

void setup() {
  Serial.begin(115200);
  while (!Serial);

  Serial.println("Starting Edge Impulse vehicle detection with LoRa alert");

  setupCommunication();

  run_classifier_init();

  if (!microphone_inference_start(EI_CLASSIFIER_SLICE_SIZE)) {
    Serial.println("Failed to start microphone inference");
    while (1);
  }
}

void loop() {
  if (!microphone_inference_record()) {
    Serial.println("Failed to record audio");
    return;
  }

  signal_t signal;
  signal.total_length = EI_CLASSIFIER_SLICE_SIZE;
  signal.get_data = &microphone_audio_signal_get_data;
  ei_impulse_result_t result = {0};

  EI_IMPULSE_ERROR err = run_classifier_continuous(&signal, &result, false);
  if (err != EI_IMPULSE_OK) {
    Serial.print("Classifier error ");
    Serial.println((int)err);
    return;
  }

  if (++print_results >= EI_CLASSIFIER_SLICES_PER_MODEL_WINDOW) {
    print_results = 0;
    Serial.println("Predictions:");
    for (size_t ix = 0; ix < EI_CLASSIFIER_LABEL_COUNT; ix++) {
      Serial.print("    ");
      Serial.print(result.classification[ix].label);
      Serial.print(": ");
      Serial.println(result.classification[ix].value, 5);

      if (strcmp(result.classification[ix].label, "vehicle") == 0 &&
          result.classification[ix].value >= VEHICLE_DETECTION_THRESHOLD) {
        sendAlertMessage("Illegal movement detected");
      }
    }
  }
}

Detection of Illegal Traffic in Protected Natural Areas