---
title: 'HGAD: Hover-Based Greedy Adaptive Download'
url: https://www.emergentmind.com/topics/hover-based-greedy-adaptive-download-hgad
type: topic
---

# HGAD: Hover-Based Greedy Adaptive Download

The Hover-based Greedy Adaptive Download (HGAD) strategy is an adaptive scheduling algorithm for unmanned aerial vehicles (UAVs) serving as data mules in sensor networks. HGAD is designed to maximize data transfer throughput by leveraging buffer-aware and signal-to-noise ratio (SNR)-aware logic, enabling intelligent hovering over sensors during periods of peak signal quality. As established in “Resilient UAV Data Mule via Adaptive Sensor Association under Timing Constraints” [2601.06000], HGAD is validated through digital twin (DT) and real-world (RW) experiments and demonstrably outperforms conventional Greedy heuristics that solely exploit strongest instantaneous signals.

## 1. System Model and Formal Problem Definition

The UAV operates as a data mule for a set of ground sensors $\mathcal{S} = \{1,2,\ldots,N\}$ over a slotted time horizon $t = 0,1,\ldots,T-1$, where each slot has duration $\Delta t$. Let $r_t \in \mathbb{R}^2$ denote the UAV’s horizontal position, $Q_i(t) \ge 0$ the remaining bits in sensor $i$’s buffer, $x_{i,t} \in \{0,1\}$ the indicator for UAV association to sensor $i$ in slot $t$, and $y_{i,t} \ge 0$ the bits downloaded from sensor $i$ in slot $t$. The instantaneous SNR in dB, when the UAV is at $r$, is:

$$
\mathrm{SNR}_i^{\rm dB}(r) = P_{\rm tx}^{\rm dBm} + G_{\rm tx}^{\rm dBi} - \mathrm{PL}^{\rm dB}(\|r-s_i\|) + G_{\rm rx}^{\rm dBi} - N_0^{\rm dBm}
$$

where $s_i$ is the fixed location of sensor $i$, $P_{\rm tx}$ its transmit power, $G_{\rm tx}, G_{\rm rx}$ antenna gains, $N_0$ noise power, and $\mathrm{PL}(\cdot)$ path-loss. The achievable rate is mapped via a lookup table $f(\cdot)$:

$$
R_i(r) = f(\mathrm{SNR}_i(r))
$$

Buffer dynamics, association, and motion constraints are:

$$
\begin{aligned}
&\sum_{i\in\mathcal S} x_{i,t} \le 1, \quad 0 \le y_{i,t} \le R_i(r_t) x_{i,t}, \\
&Q_i(t+1) = \max\{ Q_i(t) - y_{i,t}, 0 \},\quad Q_i(0) = Q_i, \\
&\| r_{t+1} - r_t \| \le v_{\max} \Delta t, \quad r_t \in \mathcal G, \\
&r_0 = r_{\rm start},\quad r_{T-1} = r_{\rm end}
\end{aligned}
$$

with the additional constraint $\sum_{t=0}^{T-1} y_{i,t} \le Q_i$ (no overserving). The objective is:

$$
\max_{\{ r_t, x_{i,t} \}} \sum_{i\in\mathcal S} \sum_{t=0}^{T-1} y_{i,t} \text{ s.t. all constraints above}
$$

## 2. Algorithmic Strategies: Baseline Greedy and HGAD

### Baseline Greedy

The classic Greedy heuristic selects, at each slot, the sensor with the maximal instantaneous SNR among those with available buffered data. The algorithm ignores buffer requirements and peak SNR opportunities, switching sensors frequently and downloading at the current achievable rate:

```python
Input: buffer Q_i(0), positions s_i, UAV trajectory {r_t}
For t = 0 to T-1:
    Let A = { i : Q_i(t) > 0 }
    If A = ∅: break and return home
    i* ← argmax_{i∈A} SNR_i(r_t)
    y ← min{ R_{i*}(r_t)*Δt , Q_{i*}(t) }
    Q_{i*}(t+1) = Q_{i*}(t) – y
    Q_j(t+1) = Q_j(t)   for j≠i*
    Record download y from i*
End
```

### Hover-based Greedy Adaptive Download (HGAD)

HGAD introduces buffer-awareness and a hover trigger mechanism. It maintains per-sensor SNR thresholds $\gamma_i$ (e.g., sensor historical maxima). If $R_{i^*}(r_t) \ge \gamma_{i^*}$, the UAV initiates a hover interval over sensor $i^*$ to exploit favorable channel conditions. Hover duration is bounded by both the remaining buffer and a maximum rate condition:

$$
T^{\rm hover}_i = \min\left( \frac{D_i^{\rm rem}}{R_i^{\max}}, T_i^{\max} \right)
$$

where $D_i^{\rm rem}$ is the sensor’s remaining buffer, $R_i^{\max}$ the sensor’s maximal historical rate, and $T_i^{\max}$ an imposed cap.

```python
Input: buffers Q_i(0), positions s_i, thresholds {γ_i}, UAV path mobility model
For t = 0 to T-1:
    A ← {i: Q_i(t)>0}
    If A = ∅: return home
    i* ← argmax_{i∈A} R_i(r_t)
    If R_{i*}(r_t) ≥ γ_{i*} and not currently hovering:
        Compute D_rem = Q_{i*}(t)
        T_hover = min{ D_rem/R_{i*}^{max}, T_{i*}^{max} }
        Set hover_timer = T_hover
        hovering = True
    EndIf
    y ← min{R_{i*}(r_t)*Δt, Q_{i*}(t)}
    Q_{i*}(t+1)=Q_{i*}(t)–y, others unchanged
    Record download from i*
    If hovering:
        hover_timer ← hover_timer – Δt
        If hover_timer ≤ 0: hovering = False
    Else
        Move UAV along planned route (or toward next-highest buffer sensor)
    EndIf
End
```

HGAD thereby reduces handover frequency, dedicates increased dwell time to exploiting local SNR optima, and respects sensor buffer quotas.

## 3. Theoretical Performance Bound

Switching between sensors incurs handover downtime $t_s > 0$ (e.g., re-sync, beam-steering). HGAD minimizes the number of such handovers relative to Greedy, yielding a strict throughput advantage. For $S_{\rm G}$ (Greedy switches) and $S_{\rm H}$ (HGAD switches), Lemma 1 establishes:

$$
\Delta R \ge (S_{\rm G} - S_{\rm H})\,t_s \times \min_i R_i^{\min}
$$

The throughput improvement is at least the product of the reduction in switches, average lost time per switch, and the worst-case rate. Rapid switching in Greedy incurs recurring data loss intervals, while HGAD's "hover blocks" mitigate switch-induced inefficiencies.

## 4. Experimental Methodology

HGAD and Greedy are benchmarked in:

- Simulation (ideal free-space path-loss model, Python UAVSimFramework)
- Digital Twin (terrain-aware channel traces replayed in real time on NSF-AERPAW emulation cluster)
- Real-World (NSF-AERPAW outdoor testbed with quadrotor UAV and USRP SDR sensors)

Scenarios utilize both fixed (pre-defined geofence) and autonomous mobility patterns (UAV waypoint planner guided by buffer/SNR metrics). Experiments use USRP B205mini (UAV) and B210 (ground sensors) SDRs on sub-6 GHz bands. Channel acquisition occurs via replayed traces (DT) and logged GPS-SNR data (RW). Performance metrics include total cumulative data downloaded, per-sensor fulfillment ratio, handover counts, hover time fraction, and UAV distance traveled.

## 5. Quantitative Results

| Scenario               | Greedy (Mbit) | HGAD (Mbit) | Improvement |
|------------------------|--------------|-------------|-------------|
| DT, fixed (T=500 s)    | 1233         | 1930        | +57%        |
| Sim, fixed (T=500 s)   | 2218         | 2518        | +14%        |
| Sim, autonomous (500 s)| 2223         | 2864        | +29%        |
| RW Flight 1 (360 s)    | 563          | 787         | +40%        |
| RW Flight 2 (1100 s)   | 2002         | 3944        | +97%        |

In both DT and RW environments, Greedy often triggers $>$200 sensor switches, generating unproductive intervals. HGAD reduces handovers by $60$–$80\%$ and allocates more hover time to sensors with peak SNR, yielding superior overall download rates. The RW Flight 2 scenario demonstrates a $+97\%$ throughput increase via extensive hovering on sensors with moderate SNR yet significant buffer quotas. Cumulative distribution plots confirm greater RW channel volatility and HGAD’s robustness in exploiting SNR peaks. The UAV distance traveled in HGAD decreases by up to $25\%$, suggesting consequential energy savings.

## 6. Implementation Considerations, Limitations, and Future Directions

HGAD is compatible with existing UAV data-mule stacks, requiring only channel SNR lookup tables and per-sensor historical $\gamma_i$ settings. The approach is robust to real-world multipath effects and hardware-induced delays. However, selection of $\gamma_i$ mandates site-specific calibration, and HGAD assumes static ground sensors; extension to mobile sensors represents ongoing research. HGAD remains heuristic with no guarantee of global optimality in arbitrary fading environments.

Advancing HGAD may incorporate:

1. Reinforcement-learning agents for online $\gamma_i$ adaptation and joint trajectory/scheduling optimization.
2. Multi-UAV coordination with hovering and buffer load balancing.
3. Integration of energy-aware models considering battery discharge and wind disturbances.

These directions seek to generalize HGAD for diverse sensor network deployments and heterogeneous UAV fleets.

Source: https://www.emergentmind.com/topics/hover-based-greedy-adaptive-download-hgad