Introduction
Solution
Description
Machine learning model
Connectivity
Android App
Demonstration
Do it Yourself
Improvements
Conclusion

Team Sheep Distress:

Rok Štefan

•

Filip Ošlaj

•

Leon Rojc

Published June 1, 2025

Sheep distress detection

Detection of sheep in distress for early attack detection.

IntermediateWork in progress20 hours65

Things used in this project

Hardware components

Nature Guard

LoRaWan Module

USB Power/Battery

Software apps and online services

Android Studio

Edge Impulse Studio

Arduino IDE

Story

Introduction

We present the development of a sheep distress detection system that helps farmers efficiently monitor their sheep in the field. The motivation behind the project is to help farmers detect early attacks, injuries, or stress in their flock. In recent years, sheep farmers in Slovenia have faced a growing challenge: increasing attacks on their flocks by predators, especially wolves and also jackals.Reports from various regions show alarming trends — for example, in areas like Pohorje and along the Slovenia-Austria border, farmers have suffered major livestock losses, with individual attacks wiping out 15–20 sheep in a single night.These opportunistic predators strike rapidly, often leaving farmers with little time to react — most likley just arriving to a site of a massacre that has already occurred.

Our goal is to develop a sheep distress detection system using sound analysis and machine learning, embedded on low-power devices, to alert farmers in real time and help them react before it’s too late.

Solution

Devices are placed in the field, each using LoRaWAN communication to send real-time alerts when distress is detected. These alerts are shown directly in a mobile app, allowing the farmer to take timely action and prevent injury, stress, or animal loss.

Description

The system is built around the Seeed XIAO nRF52840 microcontroller, which has an onboard microphone. Running on the microcontroller is a machine learning model trained with Edge Impulse to listen to sheep vocalizations and detect distress calls. When distress is detected, the device sends a wireless alert using LoRaWAN, which is shown in the connected app.For energy efficiency, the system runs continuous audio monitoring but limits other communications (like battery status and location updates) to a few times per hour.

Machine learning model

We first imported recordings of sheep calls into Edge Impulse and manually classified them. We used the MFCC (Mel-frequency cepstral coefficients) process block to extract features from the audio samples and then trained a machine learning model.

Since it’s difficult to find real audio of sheep during an attack, the model’s accuracy is not yet ideal — but it serves as a proof of concept.

Confusion matrix

We then packaged the trained model into an Arduino-compatible library and uploaded it to the Seeed XIAO nRF52840 controller.

Connectivity

The system uses LoRaWAN to transmit status updates and alerts to a central gateway. This long-range, low-power communication is ideal for covering wide pastures or remote areas where Wi-Fi or cellular networks are not available.

Android App

We designed an Android app that shows a map of all active devices, along with their battery levels. When the app receives an alert sent over LoRaWAN, it immediately displays it, notifying the farmer of a potential distress event.

1 / 2 • Default view

Demonstration

Demonstration of the final project

Do it Yourself

Arduino device detects distressed sheep calls with ML model
Alert is sent via LoRaWAN
The app receives and displays alerts and status data
Action can be taken

Improvements

Improve the machine learning model by expanding the audio dataset with more sheep sounds under various conditions.
Add GPS integration for more precise location tracking.
Work with farmers to gather insights

Conclusion

Our project shows how sound analysis and machine learning can help farmers detect sheep distress in real time, giving them a practical tool to reduce losses and improve animal welfare. With continued development and farmer feedback, this system has the potential to become an essential part of modern livestock monitoring.

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

#include <Zaznavanje-Ovc_inferencing.h>
#include <Arduino.h>
#include <Adafruit_TinyUSB.h>
#include <PDM.h>
#include <stdlib.h>
#include <string.h>

// LoRaWan credentials 
const char* APPEUI = "1212121212121212";
const char* DEVEUI = "70B3D57ED0070838";
const char* APPKEY = "19B1B4AECA76F0ED657FC47AA6C1F386";

// last 20 detected sounds
#define SIZE 20
static bool soundHistory[SIZE] = {0};
static int  historyIndex = 0;
static unsigned long lastBatteryAlert = 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
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);


// LoraWan messages
void sendDistressAlert() {
    String message = "AT+MSG=\"{\\\"type\\\":\\\"alarm\\\",\\\"data\\\":{\\\"status\\\":\\\"distress\\\"}}\"";
    Serial1.println(message);
    Serial.println("DISTRESS ALERT SENT!.");
}

void sendBatteryLevel() {
    int batteryLevel = 75;  
    String message = "AT+MSG=\"{\\\"type\\\":\\\"battery\\\",\\\"data\\\":{\\\"level\\\":" + String(batteryLevel) + "}}\"";
    Serial1.println(message);
    Serial.println("Sent battery level.");
}

void sendLocation() {
    String latitude = "46.04476";
    String longitude = "14.48926";
    String message = "AT+MSG=\"{\\\"type\\\":\\\"location\\\",\\\"data\\\":{\\\"latitude\\\":" + latitude + ",\\\"longitude\\\":" + longitude + "}}\"";
    Serial1.println(message);
    Serial.println("Sent location.");
}


//------------------------------------------------------------------------------
void setup() {
    // USB serial (testing)
    Serial.begin(115200);
    while (!Serial);
    Serial.println("EdgeImpulse on arduino through LoRaWan -> sheep distress");

    // Power on LoRaWan module
    pinMode(5, OUTPUT);
    digitalWrite(5, HIGH);
    Serial1.begin(9600);
    delay(100);

    // Set up LoRaWan connection
    Serial1.write("AT+ID=AppEui,\"1212121212121212\"\r\n");
    delay(1000);
    Serial1.write("AT+ID=DevEui,\"70B3D57ED0070838\"\r\n");
    delay(1000);
    Serial1.write("AT+KEY=AppKey,\"19B1B4AECA76F0ED657FC47AA6C1F386\"\r\n");
    delay(1000);
    Serial1.write("AT+MODE=LWOTAA\r\n");
    delay(1000);
    Serial1.write("AT+JOIN\r\n");
    delay(5000);
    Serial.println("Connection succesfull!");

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

//------------------------------------------------------------------------------
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);
    }

    //  Distress probability
    float distressProbability = 0;
    for (size_t i = 0; i < EI_CLASSIFIER_LABEL_COUNT; i++) {
        if (!strcmp(result.classification[i].label, "iven Klic")) {
            distressProbability = result.classification[i].value;
            break;
        }
    }

    // update history
    soundHistory[historyIndex] = distressProbability > 0.5f;
    historyIndex = (historyIndex + 1) % SIZE;

    // Count positives
    int count = 0;
    for (int i = 0; i < SIZE; i++) {
        if (soundHistory[i]) count++;
    }

    // If 5/20 are positive -> send alert!
    if (count >= 5) {
        sendDistressAlert();
        // Reset the history array
        for (int i = 0; i < SIZE; i++) {
            soundHistory[i] = false;
        }
    }

    // battery and location update every 3min
    if (millis() - lastBatteryAlert >= 180000) {
        sendBatteryLevel();
        sendLocation();
        lastBatteryAlert = millis();
    }
}

//------------------------------------------------------------------------------
// 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);
}