Operator-side Assistance (downlink)

What

Operator-side Assistance (downlink) is the optional stage between feedback release and operator presentation. It can preserve the released feedback, transform it, add a supplementary package, or suppress it. The paper places prediction, state estimation, feedback filtering, and warning generation at this attachment point.

It does not apply delay and does not update the authoritative robot. It receives packages that Downlink Communication has already released and publishes the package or packages that the operator-side presentation should consume.

Why

The same delayed feedback can support different operator-side techniques. A baseline can show only the delayed video, while another condition can add a command timeline, a predicted path, or an uncertainty envelope. Keeping that choice in one module lets a study vary the assistance technique while holding the vehicle, task, observation streams, and communication conditions fixed.

How

The module receives feedback after Downlink Communication releases it, then preserves, transforms, or supplements that feedback before it reaches Operator Presentation.

The Kernel queues released packages before calling ProcessPackage. After all released packages for the tick are processed, it calls UpdateAssistance, allowing an implementation to publish output from a declared dependency even when no new feedback package arrived.

• Input. A released feedback package, plus dependencies such as command history, vehicle configuration, route information, communication delay, or a reconstructed map.
• Output. The implementation publishes the feedback package, a transformed package, or an additional package on a declared stream.
• Timing. The module does not add communication delay. Any output it publishes is available to the downstream presentation path in the same kernel cycle.

Boundary

Contract

Implementations inherit the package queue and publish through PackageProduced. The base class calls ProcessPackage for released feedback and then calls UpdateAssistance.

using System;
using Unite.Core;

public abstract class DownlinkOperatorSideAssistanceModule
    : TeleroboticsModule, IPackageSource, IPackageConsumer
{
    public event Action<Package> PackageProduced;

    protected abstract void ProcessPackage(
        Package package,
        double timestampSeconds);

    protected virtual void UpdateAssistance(
        double timestampSeconds)
    {
    }

    protected void PublishPackage(Package package)
    {
        PackageProduced?.Invoke(package);
    }
}

• Call PublishPackage(package) to preserve the released feedback.
• Publish a new Package when the assistance output is supplementary or transformed.
• Use the original package's stream and source timestamp when preserving its identity; use a declared assistance stream for an overlay or additional feedback.
• Do not modify the vehicle or the authoritative remote state from this module.

Examples

The four conditions keep communication, vehicle, task, and observation settings fixed while changing the presentation assistance.

public abstract class EveryMoveAssistanceBase : DownlinkOperatorSideAssistanceModule
{
    protected override void ProcessPackage(
        Package package,
        double timestamp)
    {
        PublishPackage(package);
    }
}

[EveryMoveCondition("condition-baseline")]
public sealed partial class NoAssistance
    : EveryMoveAssistanceBase
{
}

[EveryMoveCondition("condition-network")]
public sealed partial class CommandTimelineAssistance
    : CommandTimelineAssistanceBase
{
    // The shared base converts mapped commands into
    // NetworkTimelinePackage feedback.
}

[EveryMoveCondition("condition-path")]
public sealed partial class IdealTrajectoryAssistance
    : TrajectoryAssistanceBase
{
    protected override object BuildOverlayPayload(
        TurtleBotState state,
        PredictedPose[] centre)
    {
        PredictedPose[] left = Offset(
            centre, -vehicleConfiguration.wheelbase * .5f);
        PredictedPose[] right = Offset(
            centre, vehicleConfiguration.wheelbase * .5f);
        return new PathAssistancePackage(centre, left, right);
    }
}

[EveryMoveCondition("condition-envelope")]
public sealed partial class WorstCaseEnvelopeAssistance
    : TrajectoryAssistanceBase
{
    protected override object BuildOverlayPayload(
        TurtleBotState state,
        PredictedPose[] centre)
    {
        float uncertainty = Mathf.Clamp01(
            vehicleConfiguration.wheelSlipFactor *
                vehicleConfiguration.terrainRoughness +
            vehicleConfiguration.motorResponseVariation +
            vehicleConfiguration.wheelRadiusVariation +
            vehicleConfiguration.encoderNoise +
            vehicleConfiguration.vibrationIntensity);
        float offset = vehicleConfiguration.wheelbase * .5f;

        PredictedPose[] left = Integrate(
            state, 1f - uncertainty, 1f, -offset);
        PredictedPose[] right = Integrate(
            state, 1f, 1f - uncertainty, offset);
        return new EnvelopeAssistancePackage(
            centre, left, right,
            Integrate(state, 1f - uncertainty * .5f, 1f, 0f),
            Integrate(state, 1f, 1f - uncertainty * .5f, 0f));
    }
}

Config

1. Implement DownlinkOperatorSideAssistanceModule in the study's Runtime assembly.
2. Attach one selected implementation to the TeleroboticsAgent; the module connects to the configured downlink feedback path.
3. Declare and wire only the dependencies the technique needs. The demo's trajectory assistance uses the uplink queue, vehicle configuration, communication configuration, and the captured state attached to the released view package.
4. Configure the selected assistance component in the Inspector for the study condition.