Created August 27, 2025 © GPL3+

MUUU!: Livestock smart collar 🐮

MUUU! is a smart livestock collar with LoRa, GPS, and vital sign sensors to track each animal’s location and health.

ExpertWork in progressOver 4 days67

Things used in this project

Hardware components

PCBWay Custom PCB

Maxim Integrated MAX30102 High-Sensitivity Pulse Oximeter and Heart-Rate Sensor for Wearable Health

Maxim Integrated MAX30205 Human Body Temperature Sensor

Sensirion SHT40

Solar Panel (5V/0.5W)

LiPo 18650

Seeed Studio Wio Tracker L1 E-ink

Software apps and online services

PlatformIO IDE

Arduino IDE

STMicroelectronics STM32CUBEPROG

Hand tools and fabrication machines

Soldering iron (generic)

Solder Wire, Lead Free

3D Printer (generic)

Story

🐄 Introduction: Livestock and Smart Collars

🌍 There are around 1.5 billion cattle worldwide, making livestock one of the main pillars of global agriculture . The sector contributes approximately 40% of total agricultural output and plays a crucial role in food security and rural livelihoods. In the United States alone, livestock generates about $370 billion annually, accounting for nearly 50% of agricultural GDP 💰.

Despite its scale and importance, the industry faces serious challenges:
Around 20% of global livestock production is lost every year due to animal diseases, causing economic losses close to $300 billion.In many regions cattle theft and straying lead to the loss of hundreds of thousands of animals, directly affecting farmers’ income and local food supply.

Cows grazing

📱 Smart livestock collars equipped with GPS and sensors are transforming the sector. They provide real-time location to prevent theft, monitor health and activity for early disease detection , and track fertility cycles to boost productivity 📈.

Farmers also use them to optimize grazing management, reduce labor costs, and improve animal welfare . With the livestock tracking market projected to reach USD 2.78 billion by 2031 , these collars are becoming an essential tool for more efficient, sustainable, and profitable farming 🌾.

Cow with Smart Collar

💡 Solution

The solution is a solar powered smart collar designed for cattle, equipped with vital signs monitoring sensors and LoRa based data communication.

📍 GPS tracking provides real-time location to prevent losses from theft or straying.
🩺 Vital signs sensors (as, body temperature, sweat, rumination, and heart rate) enable early detection of disease, reducing the risk of costly outbreaks.
🌐 LoRa communication technology ensures long-range (up to 10km), low-power data transmission, making the device suitable for remote areas with limited connectivity.

This integrated system improves animal health management, farm efficiency, and overall productivity, while reducing economic losses from disease and livestock disappearance.

Smart Collar

🔍 How it works?

The livestock collar is designed to monitor the health and location of your animals in real time. It integrates multiple sensors to provide essential data:

🛰️ GNNS module: Tracks the animal’s position, helping you locate them reliably even in open fields or challenging environments.
🌡️ Body temperature sensor: Provides high-accuracy body temperature measurements, enabling early detection of illness or heat stress.
💧 Humidity sensor: Measures relative humidity, helping assess sweating and thermal comfort.
❤️‍ Heart rate and SpO₂ sensor: Measures heart rate and blood oxygen saturation (SpO₂) providing key vital signs.

All collected data is processed by the MCU Wio-E5 by Seeed Studio , a low-power microcontroller that integrates a LoRa transceiver 📡 for long-range, low-energy data transmission. This enables efficient communication with gateways over several kilometers while preserving battery life, making it ideal for remote livestock monitoring.

Wio E5 LE by Seeed Studio

🔋 The collar is powered by a 1W solar panel and a LiPo 18650 battery, ensuring continuous operation even in low-sunlight conditions while maintaining low energy consumption for extended autonomy ⏳.

⚡ Boards: PCBWay

A special thanks to PCBWay for sponsoring this project by manufacturing the PCBs and assembling the components, enabling us to bring this modular livestock collar to life, get your board assembled at: https://www.pcbway.com/

Boards: Main + Sensors

Main Board: The main board is the heart of the system. It houses the MCU, the GNSS module, the battery, and the solar panel power management circuit, for flexibility in sensors choosing, the board also features a JST connector that allows the sensor board to be easily connected via I2C, making the system modular and adaptable to different livestock monitoring needs.

Sensors Board: Thanks to its modular design, the sensor board can be easily customized or swapped to include different sensors depending on the specific livestock monitoring requirements.

For this version, designed for cattle monitoring 🐄📊, the following sensors have been integrated in the sensors board:

Body temperature sensor (MAX30205): Provides high-accuracy body temperature measurements with a typical accuracy of ±0.1°C (37°C to 39°C range), enabling early detection of illness or heat stress
Humidity sensor (SHT30): Measures relative humidity with an accuracy of ±2% RH (20–80% RH range), helping assess sweating and thermal comfort.
Heart rate and SpO₂ sensor (MAX30102): Measures heart rate with a typical accuracy of ±3 BPM and blood oxygen saturation (SpO₂) with an accuracy of ±2% SpO₂ (70–100% range), providing reliable vital signs monitoring.

Sensors Board

📦 The enclosure:

The enclosure houses both the main board and the sensor board, providing a compact and organized layout. It incorporates an IR filter and a copper plate: the IR filter blocks ambient light from the heart rate sensor to reduce optical noise, while the copper plate improves thermal conduction from the animal’s body to the temperature sensor, enhancing measurement accuracy.

1 / 3 • Assembly of TX Device

📡 The Receiver

If multiple devices were involved, a gateway would be necessary to collect data from all of them simultaneously. However, since only a single device is being used, a P2P communication approach will be implemented, with the smart collar acting as the transmitter and the wristband as the receiver ⌚.

The receiver will use the Wio Tracker L1 E-ink, which supports LoRa for P2P communication with the smart collar. Additionally, the GPS functionality available on the board will be used to determine the relative distance and direction of the receiver with respect to the collar.

1 / 2 • RX Enclousure

📄 Screen Data

The screen will show the animal’s location relative to yours, using an arrow to indicate direction and a distance reading. It will also display its vital signs, including temperature, perspiration, heart rate, and SpO₂ levels.

1 / 3 • Screen Data

Schematics

Code

#include "sensors.h"
#include "gps.h"  
#include "json_lora.h"

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

  sensors_setup();
  gps_setup();    
  lora_init();
  
  Serial.println("All systems initialized");
}

void loop() {
  sensors_update();
  gps_update();  

 

  float temp = (bodyTemp + ambientTemp) / 2.0;
  temp = roundf(temp * 10) / 10.0;
  
   if (gps.location.isValid()) {
        json_gen(spo2, temp, humidity, heartRate, latitude, longitude);
      
    }
    
    delay(5000); //TX every 5sg
  
}

#ifndef SENSORS_H
#define SENSORS_H

#include <Wire.h>
#include "MAX30105.h"
#include "spo2_algorithm.h"
#include "Protocentral_MAX30205.h"
#include "Adafruit_SHT31.h"

// --- Sensors ---
extern MAX30105 particleSensor;    // Heart Rate + SpO2
extern MAX30205 tempSensor;        // Body temp
extern Adafruit_SHT31 sht31;       // ambient temp & hum

// --- Heart Rate vars ---
extern int32_t heartRate;
extern int8_t validHeartRate;
extern int32_t spo2;
extern int8_t validSPO2;

extern uint32_t irBuffer[100];
extern uint32_t redBuffer[100];

// --- Temp and Hum vars ---
extern float bodyTemp;
extern float ambientTemp;
extern int humidity;

// --- Functions ---
void sensors_setup();
void sensors_update();  // update HR, SpO2, temp and hum

#endif

#include "sensors.h"

// --- Sensors ---
MAX30105 particleSensor;
MAX30205 tempSensor;
Adafruit_SHT31 sht31;

// --- HR vars---
int32_t heartRate;
int8_t validHeartRate;
int32_t spo2;
int8_t validSPO2;

uint32_t irBuffer[100];
uint32_t redBuffer[100];

// --- Temp and Hum vars ---
float bodyTemp;
float ambientTemp;
int humidity;

void sensors_setup() {
    Wire.begin();
    

    // --- MAX30105 ---
    if(!particleSensor.begin(Wire, I2C_SPEED_FAST)) {
        Serial.println(F("MAX30105 no encontrado"));
        while(1);
    }
  particleSensor.setup();
    

    // --- MAX30205 ---
    while(!tempSensor.scanAvailableSensors()) {
        Serial.println(F("No se detecta MAX30205"));
        delay(30000);
    }
    tempSensor.begin();

    // --- SHT31 ---
    if(!sht31.begin(0x44)) {
        Serial.println(F("No se detecta SHT31/SHT30"));
    }
}

void sensors_update() {
    const int bufferLength = 100;

    // --- MAX30105 ---
    for(int i = 25; i < bufferLength; i++) {
        redBuffer[i-25] = redBuffer[i];
        irBuffer[i-25]  = irBuffer[i];
    }

    for(int i = 75; i < bufferLength; i++) {
        while(!particleSensor.available()) particleSensor.check();
        redBuffer[i] = particleSensor.getRed();
        irBuffer[i]  = particleSensor.getIR();
        particleSensor.nextSample();
    }

    maxim_heart_rate_and_oxygen_saturation(irBuffer, bufferLength, redBuffer,
                                           &spo2, &validSPO2, &heartRate,                                                   &validHeartRate);

    // --- Temp and Hum---
    bodyTemp    = tempSensor.getTemperature();
    ambientTemp = sht31.readTemperature();
    humidity    = sht31.readHumidity();
}

#include "json_lora.h"
#include <Adafruit_NeoPixel.h>
#include <STM32LowPower.h>
#include "gps.h"

// WS2812 setup
#define PIN_WS2812  PB4
#define NUMPIXELS   1
Adafruit_NeoPixel pixels(NUMPIXELS, PIN_WS2812, NEO_GRB + NEO_KHZ800);

STM32WLx radio = new STM32WLx_Module();

static const uint32_t rfswitch_pins[] = {PA4, PA5, RADIOLIB_NC};
static const Module::RfSwitchMode_t rfswitch_table[] = {
  {STM32WLx::MODE_IDLE,  {LOW,  LOW}},
  {STM32WLx::MODE_RX,    {HIGH, LOW}},
  {STM32WLx::MODE_TX_LP, {HIGH, HIGH}},
  END_OF_MODE_TABLE,
};

bool transmittedFlag = false;

// ************************************************************************************************
void lora_init() {
    
    
    
    Serial.println("**** LoRa Init ****");

    pixels.begin();
    pixels.show();

    radio.setRfSwitchTable(rfswitch_pins, rfswitch_table);

    int state = radio.begin(868, 62.5, 12, 5, 0x12, 14, 8, 1.7, 0);
    if (state == RADIOLIB_ERR_NONE) {
        Serial.println("radio.begin() success!");
    } else {
        Serial.print("radio.begin() failed, code ");
        Serial.println(state);
        while(true) {
            pixels.setPixelColor(0, pixels.Color(255, 0, 0));
            pixels.show();
            delay(100);
            pixels.setPixelColor(0, pixels.Color(0, 0, 0));
            pixels.show();
            delay(100); 
        }
    }

    radio.setDio1Action(setFlag);
    LowPower.begin();
}

// ************************************************************************************************
void setFlag(void) {
    uint16_t irqstatus = radio.getIrqStatus();
    if(irqstatus == RADIOLIB_SX126X_IRQ_TX_DONE) {
        transmittedFlag = true;
    }
}


void json_gen(int32_t spo2, float temp, int humedad, int32_t hr, float lat, float lon) {
    char payload[256]; // Buffer for JSON
    memset(payload, 0, sizeof(payload));
    // Create JSON object
    StaticJsonDocument<256> doc;

    // GPS hour and date to string
    String timeString = String(gps.time.hour() + 2) + ":" + String(gps.time.minute()) + ":" + String(gps.time.second());
    String dateString = String(gps.date.day()) + "/" + String(gps.date.month()) + "/" + String(gps.date.year());

    // Add fields to Json
    doc["time"] = timeString;
    doc["date"] = dateString;
    doc["lat"] = lat;
    doc["lon"] = lon;
    doc["temp"] = temp;
    doc["humedad"] = humedad;
    doc["hr"] = hr;
    doc["spo2"] = spo2;

    // Serializar el JSON al buffer
    size_t jsonLength = serializeJson(doc, payload, sizeof(payload));
    payload[jsonLength] = '\0'; // TERMINADOR NULO

    Serial.write((uint8_t*)payload, jsonLength);
    Serial.println();

   transmittedFlag = false;
    int state = radio.startTransmit((uint8_t*)payload, jsonLength);

    pixels.setPixelColor(0, pixels.Color(0, 255, 0));  // Led verde transmisin
    pixels.show();

    // Wait until TX is finished
    while(!transmittedFlag) {
        while(SubGhz.isBusy());
    }

    pixels.setPixelColor(0, pixels.Color(0, 0, 0));
    pixels.show();

    if(state == RADIOLIB_ERR_NONE) {
        Serial.println("JSON transmitted successfully!");
    } else {
        Serial.print("Transmission failed, code: ");
        Serial.println(state);
    }
}

#include "gps.h"

// Inicializar LPUART en PC0 (TX) y PC1 (RX) para GPS
HardwareSerial GPS_LPUART{PC0, PC1};
TinyGPSPlus gps;

double latitude = 0.0;
double longitude = 0.0;

void gps_setup()
{
  
  Serial.println("Iniciando sistema GPS...");

  GPS_LPUART.begin(9600); // Inicializar UART del GPS
  
  Serial.print("Esperando seal GPS...");
 

  while (latitude == 0.0 && longitude == 0.0 && gps.satellites.value() == 0)
  {
    while (GPS_LPUART.available())
    {
      if (gps.encode(GPS_LPUART.read()))
      {
        latitude = gps.location.lat();
        longitude = gps.location.lng();
        Serial.print(".");
        //Serial.print("Latitud: "); Serial.println(latitude, 6);
        //Serial.print("Longitud: "); Serial.println(longitude, 6);
      }
    }
  }
  Serial.print("\nGPS Inicializado Coordenadas: ");
  Serial.print("Latitud: "); Serial.println(latitude, 6);
  Serial.print("Longitud: "); Serial.println(longitude, 6);


}
void gps_update()
{
    // Esperar hasta que haya datos disponibles y vlidos
    while (true)
    {
        while (GPS_LPUART.available())
        {
            if (gps.encode(GPS_LPUART.read()))
            {
                // Actualizar latitud y longitud solo si son vlidas
                if (gps.location.isUpdated() && gps.time.isUpdated())
                {
                    latitude = gps.location.lat();
                    longitude = gps.location.lng();
            
                    return; // Datos vlidos, salir de la funcin
                }
            }
        }
        delay(10); // Evitar bloqueo total y darle tiempo al GPS
    }
}

// BSP : STM32 boards groups by STMicroelectronics 2.7.1
// Board select : STM Boards groups / LoRa boards
// Board part number : LoRa-E5 mini

#include <RadioLib.h>           // 6.4.2  https://github.com/jgromes/RadioLib
#include <ArduinoJson.h>        // https://arduinojson.org/

// RM0461 Reference manual Rev 8  37.1.4 IEEE 64-bit unique device ID register (UID64)
#define MASTER_UID  *((uint32_t*)0x1FFF7580)    // use uid64 for Master device UID
#define LED_RED          PB5

STM32WLx radio = new STM32WLx_Module();

static const uint32_t rfswitch_pins[] = {PA4, PA5, RADIOLIB_NC};
static const Module::RfSwitchMode_t rfswitch_table[] = {
  {STM32WLx::MODE_IDLE,  {LOW,  LOW}},
  {STM32WLx::MODE_RX,    {HIGH, LOW}},
  {STM32WLx::MODE_TX_HP, {LOW, HIGH}},  // for LoRa-E5 mini
  END_OF_MODE_TABLE,
};

#define dataNum   256            // data bytes
union unionData {                   // for data type conversion
  uint32_t  dataBuff32[dataNum/4];
  float     dataBuff32F[dataNum/4];
  int16_t   dataBuff16[dataNum/2];
  uint8_t   dataBuff8[dataNum];
};
union unionData ud;

String rxdata = "";          // received data packet string
bool receivedFlag = false;   // flag that a packet was received

// *******************************************************************************************************
void setup() {
  Serial.begin(115200);
  while(!Serial);
  delay(2000);

  pinMode(LED_RED, OUTPUT);         // built-in LED
  digitalWrite(LED_RED, HIGH);

  // STM32WL initialization
  radio.setRfSwitchTable(rfswitch_pins, rfswitch_table);

  // LoRa begin(frequency, bandwidth, spreading factor, coding rate, syncWord, power, preambleLength, tcxoVoltage, useRegulatorLDO)
  int state =  radio.begin(868, 62.5, 12, 5, 0x12, 14, 8, 1.7, 0);

  if (state == RADIOLIB_ERR_NONE) {
    Serial.println("radio.begin() success!");
  } else {
    Serial.print("failed, code ");
    Serial.println(state);
    while(true) {
      digitalWrite(LED_RED, LOW);
      delay(100);
      digitalWrite(LED_RED, HIGH);
      delay(100);      
    }
  }

  // callback function when received or transmitted
  radio.setDio1Action(setFlag);
}

// callback function when received or transmitted
void setFlag(void) 
{
  uint16_t irqstatus = radio.getIrqStatus();
  if(irqstatus == RADIOLIB_SX126X_IRQ_RX_DONE) {
    receivedFlag = true;
  } else {
    receivedFlag = false;
  }
}

// ***********************************************************************************************************
void loop() 
{
  Serial.println("Waiting for incoming Slave transmitting packet ... ");

  // start listening for LoRa packets
  int state = radio.startReceive();
  if (state != RADIOLIB_ERR_NONE) {
    Serial.print("failed, code ");
    Serial.println(state);
    while (true) {
      digitalWrite(LED_RED, LOW);
      delay(100);
      digitalWrite(LED_RED, HIGH);
      delay(100);    
    }
  }

  // wait until packet is received
  while(!receivedFlag) {
    while(SubGhz.isBusy());
  }
  receivedFlag = false;

  // read a packet
  state = radio.readData(ud.dataBuff8, dataNum);

  if (state == RADIOLIB_ERR_NONE) {
    // convert received bytes to String (stop at null terminator)
    rxdata = "";
    for(int i = 0; i < dataNum; i++) {
      if(ud.dataBuff8[i] == 0) break;
      rxdata += (char)ud.dataBuff8[i];
    }

    int rssi = radio.getRSSI();
    int snr  = radio.getSNR();

    Serial.println("Received raw JSON:");
    Serial.println(rxdata);

    // parse JSON
    StaticJsonDocument<256> doc;  // ajustar tamao segn JSON
    DeserializationError error = deserializeJson(doc, rxdata);

    if (error) {
      Serial.print("JSON parse failed: ");
      Serial.println(error.c_str());
    } else {
      // leer campos del JSON
      const char* time   = doc["time"];
      const char* date   = doc["date"];
      float lat          = doc["lat"] | 0.0;
      float lon          = doc["lon"] | 0.0;
      float temp         = doc["temp"] | 0.0;
      int humedad        = doc["humedad"] | 0;
      int hr             = doc["hr"] | 0;
      int spo2           = doc["spo2"] | 0;

      // imprimir valores
      Serial.println("Parsed JSON data:");
      Serial.print("Time: "); Serial.println(time);
      Serial.print("Date: "); Serial.println(date);
      Serial.print("Latitude: "); Serial.println(lat, 8);
      Serial.print("Longitude: "); Serial.println(lon, 8);
      Serial.print("Temperature: "); Serial.println(temp);
      Serial.print("Humedad: "); Serial.println(humedad);
      Serial.print("Heart Rate: "); Serial.println(hr);
      Serial.print("SpO2: "); Serial.println(spo2);
      Serial.printf("RSSI: %d dBm, SNR: %d dB\n", rssi, snr);
    }
  } else {
    Serial.print("failed to read packet, code ");
    Serial.println(state);
  }

  delay(100);
}

Credits

JuanVi

4 projects • 6 followers

MUUU!: Livestock smart collar 🐮

Things used in this project

Hardware components

Software apps and online services

Hand tools and fabrication machines

Story

🐄 Introduction: Livestock and Smart Collars

💡 Solution

🔍 How it works?

⚡ Boards: PCBWay

📦 The enclosure:

📡 The Receiver

Custom parts and enclosures

Bottom_TX

Top_TX

Bottom_RX

Top_RX

Button_1_RX

Button_2_RX

Switch_RX

Schematics

Schematics Main Board

Main Board Layers

Code

main.ino

sensors.h

sensors.cpp

json_lora.h

json_lora.cpp

gps.h

gps.cpp

LORA_RX.ino

Credits

JuanVi

Comments

Embed the widget on your own site

MUUU!: Livestock smart collar 🐮

MUUU!: Livestock smart collar 🐮

Things used in this project

Hardware components

Software apps and online services

Hand tools and fabrication machines

Story

🐄 Introduction: Livestock and Smart Collars

💡 Solution

🔍 How it works?

⚡ Boards: PCBWay

📦 The enclosure:

📡 The Receiver

Custom parts and enclosures

Bottom_TX

Top_TX

Bottom_RX

Top_RX

Button_1_RX

Button_2_RX

Switch_RX

Schematics

Schematics Main Board

Main Board Layers

Code

main.ino

sensors.h

sensors.cpp

json_lora.h

json_lora.cpp

gps.h

gps.cpp

LORA_RX.ino

Credits

JuanVi

Comments

Related channels and tags