Nevenka Pavlovska

•

Ana Jenko

•

lo7909

•

Luka Mali

Published June 1, 2025

BoarMap - Detect & Alert Boar Intrusions

BoarMap detects boar sounds and alerts users, helping farmers protect their land and stay notified in real time.

IntermediateFull instructions provided246

BoarMap - Detect & Alert Boar Intrusions

Things used in this project

Hardware components

Seeed Studio XIAO nRF52840 Sense (XIAO BLE Sense)

Arduino Nano 33 BLE Sense

Android device

Software apps and online services

Edge Impulse Studio

Arduino IDE

Android Studio

The Things Industries The Things Network

Story

In many rural areas, wild boars are a growing threat to livestock and farmland. This project aims to help farmers in such areas detect the presence of boars using sound recognition and send real-time alerts through a mobile app - BoarMap. Whether it’s to track their movement or deter them, this smart system provides a non-invasive early warning tool.

This project was created not only because it was technically challenging but also provides real-world value — something that could benefit people or the environment in a meaningful way. While brainstorming ideas, problems that were often overlooked but still impactful, especially in rural communities emerged. With the hardware and tools already available — like microphones, microcontrollers, and access to Edge Impulse — the idea of building something practical while using sound detection was born. Or more specifically, the idea of a system to detect wild boar activity. This project is meant to act as a solution that could help farmers and rural residents protect their land and livestock, using simple, energy-efficient technology.

Creatingtheproject

-Dataset:

For the purpose of this project firstly, a dataset needed to be created. The dataset was split into three main sound categories:

1.Boars

2.Humans

3.Forest/environmentsounds

The data was collected by firstly acquiring the recordings for all the sound categories. Most of the recordings were gathered from online compilations that were later converted into.wav formats and ensure they all have the same sample rate and duration.

Length of dataset

Each file was trimmed and labeled accordingly. To convert the recordings into their appropriate formats a Python script was used to facilitate the process. The code used to achieve this was attached in the project.

After, the data was uploaded to Edge-impulse, a platform for training machine learning models on edge devices, by "manually" uploading the sounds using the microphone on the seeed studio xiao nrf52840 board.

seeed studio xiao nrf52840 board

What followed after uploading the data on Edge-impulse was its preprocessing.

To create an "impulse", the following parameters were set:

The "impulse" that was created

As a processing block, the Audio(MFE)block was added, This block processes raw audio and converts it into features the model can understand. This block transforms the waveform into a time-frequency representation (a spectrogram-like matrix), making it easier for the model to learn the differences between boar, forest, and human sounds.

After training and testing the model, the accuracy for it wasn`t the most reliable. There might be several reasons for the "weaker" accuracy, despite the dataset being accurate and well-extracted.

1 / 2 • Confusion matrix

Once satisfied with the accuracy, the trained model was deployed as an Arduino library (C++ code) ready for use on embedded devices - seeed studio xiao nrf52840 board.

-Preparing the code:

This code runs on an Arduino-compatible microcontroller for real-time sound classification using an Edge Impulse model and a PDM microphone. It's designed to detect wild boar sounds and send alerts via a LoRa network when such sounds are reliably recognized.

At startup, USB serial communication is initialized, and the LoRa module is powered on. The code sets up the LoRa connection using AT commands and OTAA credentials (DevEUI, AppEUI, AppKey). After joining the network, the Edge Impulse classifier and microphone buffers are initialized.

In the main loop, the system records a slice of audio, waits for the buffer to fill, and converts the data for inference. The classifier results, including labels, confidence scores, and optionally anomaly scores, are printed to the serial monitor. If the label "Boar" has a confidence above 0.5, it’s considered a detection.

To reduce false positives, a rolling buffer of the last 20 classifications is used. If "boar" is detected in 15 or more of the last 20 slices, an alert is sent via LoRa (AT+MSG="1"), along with a simulated sound effect. If not, and 30+ seconds have passed since the last "no boar" message, it sends AT+MSG="0".

Audio capture uses interrupt-driven callbacks from the PDM library, which swap between two buffers to avoid data loss. The classifier uses a helper function to convert int16 samples to float. On completion or shutdown, the microphone stops and buffers are freed to maintain system stability.

- Application designing:

The mobile application is developed using Android Studio and is designed to assist farmers in monitoring wild boar activity through sensor data. It consists of two main activities:

1. A configuration activity

2. A map activity for sensor location and boar status visualization.

The configuration activity allows the user to set up the sensor's location with ease. The farmer visits the field or installation site with a mobile device and simply presses the “Get your current phone location” button. This action captures the device’s GPS coordinates, which can then be saved locally on the phone.

Device configuration

Once saved, the map activity reads this stored location and places a marker accordingly on the map interface. The second activity displays a satellite map with the sensor's position clearly marked, along with color-coded icons that indicate the presence or absence of wild boars based on the latest sensor data. Red marker icon indicates that boar sounds have been detected at the specific sensor location, green one indicates that boars were not detected and the orange one indicates connection interruption.

1 / 3 • Red marker indicating boars` presence

This visual feedback helps the user monitor boar movement remotely and take preventive action to protect crops. Additionally, the application sends a notification to the user's phone whenever a boar is detected, ensuring the farmer is alerted immediately even without actively checking the app.

Notification message shown when boars are detected

The application ensures a user-friendly experience, enabling fast setup in the field and real-time status updates, making it a practical and efficient tool for modern farming and wildlife management.

BoarMap - DEMO

Code

/* Edge Impulse ingestion SDK
 * Copyright (c) 2022 EdgeImpulse Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 */

// If your target is limited in memory remove this to save 10K RAM
#define EIDSP_QUANTIZE_FILTERBANK   1

#define EI_CLASSIFIER_SLICES_PER_MODEL_WINDOW 4
#define EI_CLASSIFIER_FREQUENCY               16000

#include <Arduino.h>
#include <Adafruit_TinyUSB.h>
#include <PDM.h>
#include <MIS_Projekt_inferencing.h>
#include <stdlib.h>
#include <string.h>

// LoRa credentials (MSB-order hex strings from TTN console)
const char* DEVEUI = "70B3D57ED0070695";
const char* APPEUI = "2CF7F1206310299A";
const char* APPKEY = "D336DA7D41E50C50F661D51AEB152134";

// Timing for no boar & battery alerts
static unsigned long lastNoBoarAlertTime  = 0;
static unsigned long lastBatteryAlertTime = 0;

// Boar-history smoothing
#define BOAR_HISTORY_SIZE 20
static bool boarHistory[BOAR_HISTORY_SIZE] = {0};
static int  boarHistoryIndex               = 0;

// Inference buffers & state
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;

// Forward prototypes (no empty bodies!)
static void pdm_data_ready_inference_callback(void);
static bool microphone_inference_start(uint32_t n_samples);
static bool microphone_inference_record(void);
static int  microphone_audio_signal_get_data(size_t offset, size_t length, float *out_ptr);
static void microphone_inference_end(void);

//------------------------------------------------------------------------------
// Payload = 1 => boar detected
void sendBoarAlert() {
    Serial.println("ALERT: Boar sound detected (divja_svinja)!");
    Serial1.print("AT+MSG=\"1\"\r\n");
}

// Payload = 0 => no boar
void sendNoBoarAlert() {
    Serial.println("Regular alert: No boar detected.");
    Serial1.print("AT+MSG=\"0\"\r\n");
}

void triggerSound() {
    Serial.println("Sound triggered: Beep beep beep!");
}

void sendBatteryLevel() {
    Serial.println("Battery level: 75%");
}

//------------------------------------------------------------------------------
// Helper: send a simple AT command
void sendAT(const char *cmd) {
    Serial.print(">> "); Serial.println(cmd);
    Serial1.print(cmd);
    Serial1.write("\r\n");
    delay(200);
    // echo any reply
    while (Serial1.available()) {
        Serial.write(Serial1.read());
    }
}

//------------------------------------------------------------------------------
// setup(): USB console, LoRa AT init, Edge Impulse init
void setup() {
    // USB serial
    Serial.begin(115200);
    while (!Serial);

    Serial.println("Edge Impulse Inferencing + LoRa Demo");

    // Power on LoRa module (if you wire VCC to D5)
    pinMode(5, OUTPUT);
    digitalWrite(5, HIGH);

    // ATlink
    Serial1.begin(9600);
    delay(100);

    // 1) Sanity
    sendAT("AT");

    // 2) IDs
    Serial1.print("AT+ID=DevEui,\""); Serial1.print(DEVEUI); Serial1.print("\"\r\n");
    delay(200); while (Serial1.available()) Serial.write(Serial1.read());
    Serial1.print("AT+ID=AppEui,\""); Serial1.print(APPEUI); Serial1.print("\"\r\n");
    delay(200); while (Serial1.available()) Serial.write(Serial1.read());
    Serial1.print("AT+KEY=AppKey,\"");Serial1.print(APPKEY); Serial1.print("\"\r\n");
    delay(200); while (Serial1.available()) Serial.write(Serial1.read());

    // 3) OTAA + join
    sendAT("AT+MODE=LWOTAA");
    sendAT("AT+JOIN");
    delay(3000); // allow join

    //  Edge Impulse inferencing init 
    ei_printf("Inferencing settings:\n");
    ei_printf("\tInterval: %.2f ms.\n", (float)EI_CLASSIFIER_INTERVAL_MS);
    ei_printf("\tFrame size: %d\n", EI_CLASSIFIER_DSP_INPUT_FRAME_SIZE);
    ei_printf("\tSample length: %d ms.\n", EI_CLASSIFIER_RAW_SAMPLE_COUNT/16);
    ei_printf("\tNo. of classes: %d\n",
              sizeof(ei_classifier_inferencing_categories)/
              sizeof(ei_classifier_inferencing_categories[0]));

    run_classifier_init();
    if (!microphone_inference_start(EI_CLASSIFIER_SLICE_SIZE)) {
        ei_printf("ERR: Could not allocate audio buffer\n");
        while (1);
    }
}

//------------------------------------------------------------------------------
// loop(): record, classify, and send alerts over LoRa
void loop() {
    if (!microphone_inference_record()) {
        ei_printf("ERR: Failed to record audio\n");
        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};

    if (run_classifier_continuous(&signal, &result, false) != EI_IMPULSE_OK) {
        ei_printf("ERR: Classifier error\n");
        return;
    }

    // Print out each detected class and its confidence:
    for (size_t i = 0; i < EI_CLASSIFIER_LABEL_COUNT; i++) {
        Serial.printf("%s: %.5f\n",
                      result.classification[i].label,
                      result.classification[i].value);
    }

    // If you also want the anomaly score (when enabled):
    #if EI_CLASSIFIER_HAS_ANOMALY == 1
    Serial.printf("anomaly score: %.5f\n", result.anomaly);
    #endif

    // extract Boar score
    float boarScore = 0;
    for (size_t i = 0; i < EI_CLASSIFIER_LABEL_COUNT; i++) {
        if (!strcmp(result.classification[i].label, "Boar")) {
            boarScore = result.classification[i].value;
            break;
        }
    }
    bool currentBoar = (boarScore > 0.5f);

    // update history
    boarHistory[boarHistoryIndex] = currentBoar;
    boarHistoryIndex = (boarHistoryIndex + 1) % BOAR_HISTORY_SIZE;

    // count positives
    int count = 0;
    for (int i = 0; i < BOAR_HISTORY_SIZE; i++) {
        if (boarHistory[i]) count++;
    }

    // if 15/20  boar alert
    if (count >= 15) {
        sendBoarAlert();
        triggerSound();
    }
    else if (millis() - lastNoBoarAlertTime >= 30000) {
        sendNoBoarAlert();
        lastNoBoarAlertTime = millis();
    }

    // battery update every 2s
    if (millis() - lastBatteryAlertTime >= 2000) {
        sendBatteryLevel();
        lastBatteryAlertTime = millis();
    }

    // echo any leftover module replies
    while (Serial1.available()) {
        Serial.write(Serial1.read());
    }
    delay(5000);
}

//------------------------------------------------------------------------------
// PDM Buffer Full Callback
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;
            }
        }
    }
}

//------------------------------------------------------------------------------
// Allocate buffers & start PDM
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)) {
        ei_printf("Failed to start PDM!\n");
    }
    PDM.setGain(127);
    record_ready = true;
    return true;
}

//------------------------------------------------------------------------------
// Wait for next filled buffer
static bool microphone_inference_record(void) {
    bool ret = true;
    if (inference.buf_ready == 1) {
        ei_printf("Error sample buffer overrun. Decrease slices per window\n");
        ret = false;
    }
    while (inference.buf_ready == 0) {
        delay(1);
    }
    inference.buf_ready = 0;
    return ret;
}

//------------------------------------------------------------------------------
// Copy raw int16  float
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;
}

//------------------------------------------------------------------------------
// Tear down PDM & free buffers
static void microphone_inference_end(void) {
    PDM.end();
    free(inference.buffers[0]);
    free(inference.buffers[1]);
    free(sampleBuffer);
}

import wave
import numpy as np
import os

def split_wav(input_file, output_dir, segment_duration):
    # Open the input file and extract parameters
    with wave.open(input_file, 'rb') as wf:
        framerate = wf.getframerate()
        n_channels = wf.getnchannels()
        sampwidth = wf.getsampwidth()
        n_frames = wf.getnframes()
        audio_data = wf.readframes(n_frames)
   
    # Determine the NumPy data type based on sample width
    if sampwidth == 2:
        dtype = np.int16
    elif sampwidth == 1:
        dtype = np.uint8
    else:
        raise ValueError("Unsupported sample width: {}".format(sampwidth))
   
    # Convert binary data to a NumPy array and reshape if necessary
    audio_array = np.frombuffer(audio_data, dtype=dtype)
    if n_channels > 1:
        audio_array = audio_array.reshape(-1, n_channels)
   
    # Calculate the total duration of the audio in seconds
    total_duration = n_frames / framerate
    print(f"Total duration: {total_duration:.2f} seconds")
   
    # Create the output directory if it doesn't exist
    os.makedirs(output_dir, exist_ok=True)
   
    # Calculate the number of segments needed
    segment_duration_sec = segment_duration
    n_segments = int(np.ceil(total_duration / segment_duration_sec))
   
    for i in range(n_segments):
        start_time = i * segment_duration_sec
        end_time = min((i + 1) * segment_duration_sec, total_duration)
       
        start_sample = int(start_time * framerate)
        end_sample = int(end_time * framerate)
       
        segment_array = audio_array[start_sample:end_sample]
        segment_bytes = segment_array.tobytes()
       
        # Build output filename in the format gozd_[n].wav within the output directory
        output_file = os.path.join(output_dir, f"gozd_{i+1}.wav")
        with wave.open(output_file, 'wb') as wf_out:
            wf_out.setnchannels(n_channels)
            wf_out.setsampwidth(sampwidth)
            wf_out.setframerate(framerate)
            wf_out.writeframes(segment_bytes)
       
        print(f"Segment {i+1} saved: {output_file}")

if __name__ == "__main__":
    # Update these values as needed
    input_file = r"FOREST DUSK  2H Live-Recorded European Forest Ambience  No Loop [9-c1QNq-D7E].wav"
    output_dir = "gozd"  # Subfolder for segments
    segment_duration = 600  # 10 minutes = 600 seconds

    split_wav(input_file, output_dir, segment_duration)