AIoT in agriculture and livestock: when the fields begin to make decisions

This archive includes automatic translations. Audio, video and text inside images remain in their original language.

On an agricultural farm, a decision as old as watering no longer depends only on the calendar, the feel of the earth or looking at the sky. In some fields, that decision starts on a screen. A sensor buried at different depths detects how moisture moves in the soil. A platform crosses this data with the weather, the crop phase and other agronomic parameters. And, from there, it proposes a concrete action: today yes, tomorrow no, here more, there less.

That is, in essence, AIoT applied to the field: the combination of connected sensors—the Internet of Things—with algorithms capable of interpreting what happens and converting it into operational decisions. It is not about filling agriculture with gadgets, but about solving classic problems with a new layer of intelligence: using less water, applying inputs better, detecting a disease earlier or reorganizing a task that until now depended on a lot of labor.

Recent literature identifies multiple applications of AIoT in precision agriculture, including smart irrigation, crop monitoring, nutrient management, pest and disease detection, yield estimation, and agricultural robotics (Majeed et al., 2024). But the interest of AIoT in agriculture is not in the technology alone, but in what changes on the ground: less isolated intuition, more continuous observation; less late response, more precise intervention.

From data to cultivation: what really changes

From the outside, AIoT may sound like a technical label. Seen from a farm, it is better understood: a digital nervous system spread across the countryside. The sensors measure; connectivity transmits; the platform orders; the algorithm interprets. The result is not an abstraction, but a useful recommendation.

Example of architecture of an agricultural AIoT/IoT system. Source: Rehman et al. (2022)

Another example of an agricultural AIoT/IoT system architecture. Source: https://s3.amazonaws.com/s3-biz4intellia/images/applications-of-iot-in-agriculture.jpg/

A soil sensor does not “improve” a crop by itself. It improves it when it allows irrigation to be adjusted. A camera does not “make a vineyard more sustainable” on its own. It does so when, together with predictive models and alerts, it helps to intervene earlier and with greater precision. That is the difference between digitizing a process and truly transforming it.

The most compelling part of this transformation is not in the sales brochures, but in the cases where the entire chain can be followed: initial problem, technological solution and observable result. That's where AIoT stops looking like futuristic and starts looking like applied agronomy.

Anyone who wants to explore this topic in more detail can visit the AIoT Agriculture Wiki by Saturdays.AI, an interactive resource that expands on many of the concepts featured in this article and organizes them visually into sections such as sensors, hardware, connectivity, and applications. In this way, the reader can move from the narrative journey of the post to a more structured exploration of the technologies that are shaping smart agriculture. The project can also be consulted at public repository on SaturdaysAI GitHub, where the technical base of the wiki is collected.

View of the AIoT Agriculture Wiki by Saturdays.AI, an interactive resource to explore smart agriculture sensors, hardware, connectivity and applications. Repository available at SaturdaysAI GitHub.

When a potato plant is watered with data and not intuition

In technological discourse on agriculture, water often appears as an abstract concept: water scarcity, efficiency, sustainability. But the real difference is measured in everyday decisions. A potato grower doesn't need a theory about water: he needs to know if he should activate irrigation this afternoon or wait until tomorrow.

That's where CropX fits in. The Israeli company has built a digital agronomy platform based on connected soil sensors, combined with meteorological data, satellite images and agronomic models. According to the company's public documentation and an Amazon report on its cloud infrastructure, these sensors allow the conditions of the soil profile to be analyzed and translated into concrete irrigation recommendations: when to water and how much water to apply (CropX, 2025; Amazon News, 2023).

CropX soil moisture sensor. Source: CropX (2025)

The interesting thing is that the case does not remain in the technical description. In the collaboration between CropX and PepsiCo Mexico, collected by Amazon, potato farmers who use the application consume up to 25% less water by applying “the right amount, in the right place and at the right time.” That figure matters because it anchors the story: it does not speak of promises, but of a verifiable result in a real agricultural chain. And it also makes clear a fundamental idea of AIoT: the savings do not come from the sensor, but from the decision improved by the sensor.

When irrigation stops depending on fixed routines: AI to manage green areas

One of the classic problems of irrigation is that it is usually organized with rigid criteria: predefined shifts, general estimates or decisions made with incomplete information. But neither a plot nor a green area always responds the same. Humidity changes, the weather moves and the real needs of the terrain do not always coincide with the routine.

The “AI Based Innovation Project for Automated Smart Management and Smart Irrigation of Green Areas” project (see Tupl, 2024) is especially revealing here, in which Tupl participates together with the Smart City Cluster, the University of Malaga, Innova IRV and Cordis SUITE. According to the public description of the project, the system allows real-time monitoring and control of agricultural areas and urban spaces, integrating sensors, weather stations, satellites and other devices to translate field data into concrete irrigation recommendations and operational alerts.

Likewise, the Trops Agrarian Transformation Society contributed to the development by providing crop data collected by its tensiometers, a collaboration that was key to building the system models. Although Trops no longer actively participates in the project, this contribution shows well how a real agricultural case can serve to train tools later applicable to water management on the ground.

Mango plantation in Trops. Source: Trops (2026)

The interesting thing about the case is that it shows a very recognizable transformation of daily work. The person in charge no longer waters “by calendar”, but rather based on signals from the environment. Water is no longer applied as a habit and is administered as a contextual and reviewable decision. That is where AIoT stops seeming like an added technological layer and begins to function as a new form of agronomic criteria.

A vineyard that monitors itself: foliar humidity, predictive models and disease

Plant health has always been a race against time. In the vineyard, waiting to see the problem clearly usually means arriving late. That is why the way in which some European platforms are approaching risk detection and forecasting is so interesting.

xFarm Technologies offers sensors and defense modules that monitor decisive variables for the development of pathologies. Its leaf humidity sensor measures the onset and duration of humidity on a simulated leaf, and the company itself explains that this data is critical to predict when certain infections may begin. Furthermore, in the case of the Azienda Vitivinicola Enrico Crola (Novara, Piedmont, Italy), a very specific use is described: sensors in the field, real-time visualization of rainfall, temperature and foliar humidity, and predictive models that help estimate the degree of protection of the vineyard against downy mildew and powdery mildew and the best time to treat (xFarm Technologies, 2021 and 2022).

Assessment of the risk of pathogen attack on the vineyard at Enrico Crola's wine estate with xFarm technology. Source: xFarm Technologies (2021)

This case has informative value precisely because it does not need to be exaggerated. It does not promise miracles. It tells something much more useful: since 2019, a winery has incorporated technology to better observe its vineyard and decide more judiciously. And it adds a relevant effect although not quantified in percentage: thanks to the defense module, the farm can better estimate the risk of disease and decide with greater precision when to apply phytosanitary treatments. In applied science, sometimes the strength of the example lies more in the traceability of the process than in a round figure.

The robot not only harvests: it also generates a new layer of information

Agricultural robotics are often narrated as if the only objective was to replace labor. But something more interesting is happening in the greenhouse: the robot not only executes a task, it also collects data while executing it.

MetoMotion, an Israeli company specialized in greenhouses, presents its GRoW robot as an autonomous platform for tomato harvesting with 3D vision, perception algorithms and crop analytics. In its own documentation it explains that the system identifies fruits according to their degree of ripeness, works with limited human support and uses the flow of data generated by sensors to improve crop management. In a corporate article published in 2023, the company adds two very specific impact figures: the robot can reduce working hours by 80% and cut harvesting and labor costs in half (MetoMotion, 2023a, b and c).

The most revealing part of the story is not just the automation, but the information that remains afterward. The robot records how much it has harvested, where it has been harvested, which fruits were not yet ready and which rows should be reviewed the next day. That is, the machine is not limited to replacing a human gesture; turns a repetitive task into a structured source of agronomic intelligence.

Metomotion tomato harvesting robot. Source: Calcalistech (2019)

Livestock also enters the AIoT: collars, virtual fences and animal behavior

The imaginary of agricultural AIoT usually focuses on crops, but livestock farming is also fully entering into this logic. Here the problem is not detecting soil moisture or ripening of a fruit, but rather following animal behavior with sufficient granularity to convert it into management.

Halter, a company born in New Zealand, bases its proposal on collars with GPS and sensors that allow cows to be monitored in real time, herds to be moved remotely and virtual fences to be established. Their website summarizes the promise in very clear terms: virtual fencing, remote movement and continuous monitoring of animals and pastures, 24/7. In its technical documentation it adds two pieces of information that are especially useful for a rigorous story: the company describes the use of algorithms that train the animals using directional sound signals and a high-precision GPS positioning system to locate the livestock on the plot (Halter, s.f.).

Detail of the Halter smart collar and management of cattle with it. Source: Miller (s.f.)

From sensor to code: a decisive layer in smart agriculture

When talking about smart agriculture, we usually think first of sensors, weather stations, cameras or connected platforms. But between the data and the decision there is another less visible and, nevertheless, fundamental piece: the code.

That's where programming becomes especially useful. Not as a futuristic promise, but as a practical tool to translate information from the field into concrete operations: an alert, an irrigation recommendation, a simple estimate or a small but valuable automation.

The examples that follow are not intended to represent all the complexity of a real exploitation. His interest is in showing something simpler and closer: how part of the logic of smart agriculture can also start with a few well-thought-out lines of code.

Smart irrigation system with Raspberry Pi

Shahid (2021) presents a simple smart irrigation system composed of a Raspberry Pi computer, a soil moisture sensor, a single-channel relay and a water pump. When the sensor detects that there is no moisture in the soil (according to sensitivity adjusted by a potentiometer) irrigation is activated. The irrigation system scheme is as follows:

Smart irrigation system scheme. Source: Shahid (2021)

And the Python code that makes it work is:

import RPi.GPIO as gp  
 gp.setmode(gp.BOARD)  
 gp.setup(8,gp.IN)  
 gp.setup(12,gp.OUT, initial=gp.LOW)  
 gp.setup(26,gp.OUT,initial=gp.LOW)  
 gp.setup(32,gp.OUT,initial=gp.LOW)
 while True:  
   try:  
     print(not gp.input(8))  
     gp.output(36,gp.input(8))  
     gp.output(32,not gp.input(8))  
     gp.output(12,gp.input(8))  
   except KeyboardInterrupt:  
     gp.cleanup()

Controlling a light sensor with MicroPython on the STEMinds ESP32 board Eduponics mini dev board

STEMinds ESP32 Eduponics mini dev board. Source: https://www.mouser.es/new/steminds/steminds-eduponics-mini-esp32-dev-board/?_gl=1*1mw7s4o*_ga*dW5kZWZpbmVk*_ga_15W4STQT4T*dW5kZWZpbmVk*_ga_1KQLCYKRX3*dW5kZWZpbmVk

The STEMinds ESP32 Eduponics mini dev board has a number of interesting functionalities for its application in smart agriculture. Among them is the control of the BH1750 photodiode or light sensor, which is used to measure the intensity of ambient light in lux. The MicroPython code used is the following (see https://github.com/STEMinds/micropython-eduponics/blob/main/examples/bh1750.py):

from Eduponics import bh1750
import time
# initialize the bh1750 sensor
light = bh1750.BH1750()
# while true, print the light values in lux
while True:
    print(light.readLight())
    time.sleep(1)

We see that the code first initializes the sensor and then enters an infinite loop in which it reads the light value once per second and displays it on the screen.

Intelligent plant monitoring system

This project is a smart plant monitoring system that has been developed using an ESP32 microcontroller along with various sensors such as the DHT11, an ultrasonic sensor, a soil moisture sensor and a Blynk application to monitor plant health remotely (https://github.com/Shishir3D/PlantMonitoringSystem).

Intelligent plant monitoring system. Source: https://github.com/Shishir3D/PlantMonitoringSystem

The following Arduino/C++ code shows how this solution is technically articulated: reading different sensors, displaying data on an LCD screen, sending information to Blynk and activating automatic responses based on the state of the plant and its immediate environment.

#define BLYNK_TEMPLATE_ID "TMPL6YpEK4W37"
#define BLYNK_TEMPLATE_NAME "switch"

#define BLYNK_FIRMWARE_VERSION        "0.1.0"
#define BLYNK_PRINT Serial
#define APP_DEBUG

#include "BlynkEdgent.h"

#include "DHT.h"
#include <LiquidCrystal_I2C.h>

#define DHTPIN 4
#define DHTTYPE DHT11
DHT dht(DHTPIN, DHTTYPE);

// Pins
const int trigPin = 5;
const int echoPin = 18;
const int buzzerPin = 15;
const int moisturePin = 32; //the analog pin
const int motorControlPin = 2;

// LCD
const int lcdColumns = 16;
const int lcdRows = 2;
LiquidCrystal_I2C lcd(0x27, lcdColumns, lcdRows);

// Constants
#define SOUND_SPEED 0.034
int soilMoisture;
BlynkTimer timer; //create an object named timer of class BlynkTimer

// Function prototypes
void setup();
void readTemperatureAndHumidity();
void displayTemperatureAndHumidity(float temperature, float humidity);
void ultrasonicSensor();
void moistureSensor();

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

  delay(100);
  BlynkEdgent.begin();

  Serial.println(F("DHTxx test!"));

  pinMode(motorControlPin, OUTPUT);
  digitalWrite(motorControlPin, LOW);

  pinMode(moisturePin, INPUT);
  pinMode(buzzerPin, OUTPUT);
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);

  dht.begin();
  lcd.init();
  lcd.backlight();

  timer.setInterval(2000L, moistureSensor); //timer will run every two secs 
  timer.setInterval(2000L, readTemperatureAndHumidity); //timer will run every two secs
  timer.setInterval(2000L, ultrasonicSensor); //timer will run every two secs
  timer.setInterval(5800L, lcdClear); //lcd will get cleared every 5.8 secs
}

void loop() {
  BlynkEdgent.run();
  timer.run();
}

BLYNK_WRITE(V0) {
  int value = param.asInt();
  if (value) {
    digitalWrite(motorControlPin, HIGH);
  } else {
    digitalWrite(motorControlPin, LOW);
  }
}

void readTemperatureAndHumidity() {
  float h = dht.readHumidity();
  float t = dht.readTemperature();
  float f = dht.readTemperature(true);

  if (isnan(h) || isnan(t) || isnan(f)) {
    Serial.println(F("Failed to read from DHT sensor!"));
    return;
  }

  displayTemperatureAndHumidity(t, h);

  Blynk.virtualWrite(V2, h); //writes humidity
  Blynk.virtualWrite(V3, t); //write temperature
}

void displayTemperatureAndHumidity(float temperature, float humidity) {
  lcd.setCursor(0, 0);
  lcd.print("H: " + String(int(humidity)) + "%");

  lcd.setCursor(8, 0);
  lcd.print("T: " + String(int(temperature)));
}

void ultrasonicSensor() {
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  long duration = pulseIn(echoPin, HIGH);
  float distanceCm = duration * SOUND_SPEED / 2;

  Serial.print("Distance (cm): ");
  Serial.println(distanceCm);

  lcd.setCursor(8, 1);
  lcd.print("D :" + String(distanceCm) + "cm");

  if (distanceCm < 5) {
    digitalWrite(buzzerPin, HIGH);
    delay(500);
    digitalWrite(buzzerPin, LOW);
    Serial.println("BEEP!!!");
  } else {
    digitalWrite(buzzerPin, LOW);
  }

  Blynk.virtualWrite(V1, distanceCm);
}

void moistureSensor() {
  soilMoisture = analogRead(moisturePin);
  Serial.println("Soil Moisture : " + String(soilMoisture));

  int moisturePercentage = map(soilMoisture, 4095, 0, 0, 100);
  Blynk.virtualWrite(V4, moisturePercentage);

  lcd.setCursor(0, 1);
  lcd.print("M :" + String(moisturePercentage) + "%");

  if (soilMoisture < 30) { //if soil is dry and moisture level is less than 30 percent
    Serial.println("Soil is DRY!");
    digitalWrite(motorControlPin, LOW); //when soil is dry, motor will stay off
    lcd.setCursor(0, 0);
  } else { //if moisture percentage is more than 30 percent then
    Serial.println("Soil is MOIST!");
    digitalWrite(motorControlPin, HIGH); //when soil is moist, motor is work
    lcd.setCursor(0, 0);
  }
}

void lcdClear() {
  lcd.clear();
}

Altogether, the system clearly illustrates a central logic of smart agriculture: capturing data from the environment, interpreting it and translating it into concrete actions. On a small scale, this type of integration between sensorization, connectivity and automation allows us to understand how many current solutions convert continuous observation into practical support for decision making.

Tractor Telemetry

After obtaining the tractor telemetry data using the John Deere API, the next step is to prepare it for analysis. In Choudhary (2025), this Python fragment is presented precisely as the processing phase: converting the raw values into a manageable temporal structure, cleaning anomalous readings, smoothing signal noise, and marking possible operating anomalies in parameters such as engine revolutions.

# Data processing for telemetry using pandas and numpy
import pandas as pd
import numpy as np
from scipy import signal

def process_telemetry_data(raw_data):
    """Process raw telemetry data: clean, filter, and analyze"""
    df = pd.DataFrame(raw_data['values'])
    df['timestamp'] = pd.to_datetime(df['timestamp'])
    df.set_index('timestamp', inplace=True)

    # Remove outliers using z-score
    z_scores = np.abs((df['engine_rpm'] - df['engine_rpm'].mean()) / df['engine_rpm'].std())
    df = df[z_scores < 3]

    # Apply low-pass filter for noise reduction
    sos = signal.butter(10, 0.1, btype='low', analog=False, output='sos')
    df['filtered_rpm'] = signal.sosfilt(sos, df['engine_rpm'].values)

    # Calculate rolling statistics for anomaly detection
    df['rpm_mean_rolling'] = df['filtered_rpm'].rolling(window=10).mean()
    df['anomaly'] = np.where(
        np.abs(df['filtered_rpm'] - df['rpm_mean_rolling']) > df['filtered_rpm'].std(),
        1,
        0
    )

    return df

# Example usage (assuming telemetry_data from previous example)
if telemetry_data:
    processed_df = process_telemetry_data(telemetry_data)
    print(processed_df.tail())
    anomalies = processed_df[processed_df['anomaly'] == 1]
    print(f"Detected {len(anomalies)} anomalies")

In other words, this code acts as a bridge between capturing tractor telemetry and more advanced analytical layers. First organize the data in a DataFrame indexed by date, then delete outliers Using z-score, it applies a Butterworth low-pass filter to reduce noise and, finally, calculates a moving average to highlight deviations that could anticipate mechanical incidents or anomalous behavior. Thus, telemetry ceases to be a simple collection of readings and becomes a useful basis for monitoring, alerts and predictive maintenance.

Smart livestock collar

Within the MUUU!: Livestock smart collar project, this fragment corresponds to the sensory layer in charge of initializing and updating the biometric and environmental measurements of the collar. The project, published on Hackster by JuanVi (2026), presents a device for livestock with LoRa communication, geolocation and vital signs monitoring, so that the firmware must periodically capture key variables of the animal before transmitting them to the system.

Livestock Smart Collar kit. Source: JuanVi (2026)

The following Arduino/C++ code shows precisely this logic: the sensors and global variables are declared, the I2C bus is configured, and the heart rate/SpO₂, body temperature, and ambient temperature/humidity modules are initialized.

#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();
}

Together, this code makes the sensor board the primary source of physiological and environmental data for the collar. The sensors_update() routine fills in the buffers optical devices, perform heart rate and oxygen saturation calculations, and also update body temperature, ambient temperature, and humidity, leaving those readings ready for the rest of the system to package and send over LoRa along with the GPS position. Thus, this part of firmware acts as the bridge between the physical acquisition of signals in the animal and the intelligent telemetry that makes sense of the smart collar within a precision livestock scenario.

What AIoT really changes in the field

The cases that have been presented throughout this article have something in common. They do not show a field converted into a futuristic laboratory, but rather a set of very earthly decisions that become more precise: water better, treat better, harvest better, move a flock better. That is the real transformation.

Of course, there remain limits. Connectivity remains uneven in many rural areas. The initial investment is not always affordable for any farm. And the integration between sensors, software, machinery and agronomic criteria is still far from perfect. But even with those limitations, the direction is clear: agriculture is moving from episodic observation toward continuous monitoring, and from delayed reaction toward informed intervention.

Perhaps that is the best way to understand AIoT in agriculture: not as a collection of code or devices, but as a new way of listening to what is happening in the field. And, above all, to respond with more judgment when the field speaks.

Source: Xenber (2025)

References

Amazon News (2023). How agricultural firm CropX uses AWS cloud computing for farming. https://www.aboutamazon.com/news/aws/how-cropx-uses-aws-cloud-computing-for-farming

Calcalistech (2019). Tomato-Picking Robot Developer MetoMotion Raises $1.5 Million. https://www.calcalistech.com/ctech/articles/0,7340,L-3767459,00.html

Choudhary, A. (2025). John Deere API: Python Scripts for AgTech Farm Equipment Telemetry. https://johal.in/john-deere-api-python-scripts-for-agtech-farm-equipment-telemetry/

CropX (2025). Digital Agronomy Platform. https://cropx.com/

Halter (n.d.). Virtual fencing and pasture management. https://www.halterhq.com/

https://github.com/Shishir3D/PlantMonitoringSystem

https://github.com/STEMinds/micropython-eduponics/blob/main/examples/bh1750.py

https://s3.amazonaws.com/s3-biz4intellia/images/applications-of-iot-in-agriculture.jpg

JuanVi (2026). MUUU!: Livestock smart necklace. https://www.hackster.io/JuanVi/muuu-livestock-smart-collar-70614e

Majeed, Y., Fu, L., & He, L. (2024). Editorial: Artificial intelligence-of-things (AIoT) in precision agriculture. Frontiers in Plant Science, 15, 1369791. DOI: 10.3389/fpls.2024.1369791.

MetoMotion (2023a).Greenhouse Robotic Worker. https://metomotion.com/robotic-worker/

MetoMotion (2023b). Intelligent Agricultural Robotics for Speed and Accuracy. https://metomotion.com/technology/

MetoMotion (2023c). Robot tomato farmers could help solve Israel’s agricultural labor shortage. https://metomotion.com/greenhouse-innovation/robots-solve-agricultural-crisis/

Miller, T. (n.d.). Embracing Innovation: Journey with Halter’s Virtual Fencing Technology. https://www.grazinglands.org/education/embracing-innovation

Rehman, A., Saba, T., Kashif, M., Fati, S., Bahaj, S., and Chaudhry, H. (2022). A Revisit of Internet of Things Technologies for Monitoring and Control Strategies in Smart Agriculture. Agronomy. 12. 127. 10.3390/agronomy12010127.

Shahid, M, (2021_). Smart Irrigation system Raspberry Pi_. Techatronic. https://techatronic.com/smart-irrigation-system-raspberry-pi/

Trops (2026). About Trops. https://www.trops.es/sobre-trops/

Tupl (2024). AI Based Innovation Project for Automated Smart Management and Smart Irrigation of Green Areas. https://tupl.com/ai-based-innovation-project-for-automated-smart-management-and-smart-irrigation-of-green-areas/

Xenber (2025). Diversify into Artificial Intelligence of Things (AIoT). Evolution of Internet of Things (IoT). https://xenber.com/aiot-evolution/

xFarm Technologies (2021). Digital Viticulture – Az. Vit. Enrico Crola. https://www.xfarm.ag/en/blog-posts/viticoltura-digitale-az-vit-enrico-crola

xFarm Technologies (2022). How to improve your crop protection with the Defense module of xFarm. https://www.xfarm.ag/en/blog-posts/come-migliorare-la-protezione-delle-tue-colture-con-il-modulo-difesa-di-xfarm