Español ES
Ver en GitHub

Estrategia Exp de Trailing ATR

Este ejemplo demuestra cómo gestionar posiciones existentes con un trailing stop basado en el indicador Average True Range (ATR). La estrategia no genera señales de entrada; solo ajusta el nivel de salida de una posición abierta según la volatilidad del mercado.

Cómo funciona

  1. La estrategia se suscribe a datos de velas de un marco temporal elegido.
  2. Un indicador AverageTrueRange se calcula en cada vela.
  3. Para posiciones largas, el nivel de stop se sube a Close - ATR * BuyFactor.
  4. Para posiciones cortas, el nivel de stop se baja a Close + ATR * SellFactor.
  5. Cuando el precio cruza el nivel de trailing, la posición se cierra a mercado.

El trailing stop solo se mueve en la dirección del trade y nunca retrocede, proporcionando una salida ajustada a la volatilidad.

Parámetros

Nombre Descripción
AtrPeriod Período de cálculo del ATR.
BuyFactor Multiplicador aplicado al ATR al hacer trailing de una posición larga.
SellFactor Multiplicador aplicado al ATR al hacer trailing de una posición corta.
CandleType Marco temporal de las velas utilizadas para el análisis.

Notas de uso

  • Adjuntar la estrategia a un instrumento y abrir una posición manualmente o desde otra estrategia.
  • Adecuada para gestión de riesgos donde las salidas se controlan por separado de las entradas.
  • El área del gráfico muestra velas, valores ATR y trades ejecutados para análisis visual.

Referencias

using System;
using System.Collections.Generic;

using Ecng.Common;

using StockSharp.Algo.Indicators;
using StockSharp.Algo.Strategies;
using StockSharp.BusinessEntities;
using StockSharp.Messages;

namespace StockSharp.Samples.Strategies;

/// <summary>
/// ATR trailing stop strategy. Enters on EMA crossover, exits when ATR trailing stop is hit.
/// </summary>
public class ExpAtrTrailingStrategy : Strategy
{
	private readonly StrategyParam<int> _stdPeriod;
	private readonly StrategyParam<decimal> _stdFactor;
	private readonly StrategyParam<int> _fastEma;
	private readonly StrategyParam<int> _slowEma;
	private readonly StrategyParam<DataType> _candleType;

	private decimal _longTrail;
	private decimal _shortTrail;
	private decimal _prevFast;
	private decimal _prevSlow;
	private bool _hasPrev;

	public int StdPeriod { get => _stdPeriod.Value; set => _stdPeriod.Value = value; }
	public decimal StdFactor { get => _stdFactor.Value; set => _stdFactor.Value = value; }
	public int FastEma { get => _fastEma.Value; set => _fastEma.Value = value; }
	public int SlowEma { get => _slowEma.Value; set => _slowEma.Value = value; }
	public DataType CandleType { get => _candleType.Value; set => _candleType.Value = value; }

	public ExpAtrTrailingStrategy()
	{
		_stdPeriod = Param(nameof(StdPeriod), 14)
			.SetGreaterThanZero()
			.SetDisplay("StdDev Period", "StdDev period", "Indicators");

		_stdFactor = Param(nameof(StdFactor), 2m)
			.SetDisplay("StdDev Factor", "StdDev multiplier for trailing stop", "Indicators");

		_fastEma = Param(nameof(FastEma), 10)
			.SetGreaterThanZero()
			.SetDisplay("Fast EMA", "Fast EMA for entry", "Indicators");

		_slowEma = Param(nameof(SlowEma), 30)
			.SetGreaterThanZero()
			.SetDisplay("Slow EMA", "Slow EMA for entry", "Indicators");

		_candleType = Param(nameof(CandleType), TimeSpan.FromHours(4).TimeFrame())
			.SetDisplay("Candle Type", "Type of candles", "General");
	}

	public override IEnumerable<(Security sec, DataType dt)> GetWorkingSecurities()
		=> [(Security, CandleType)];

	protected override void OnReseted()
	{
		base.OnReseted();
		_longTrail = 0;
		_shortTrail = 0;
		_prevFast = 0;
		_prevSlow = 0;
		_hasPrev = false;
	}

	protected override void OnStarted2(DateTime time)
	{
		base.OnStarted2(time);

		var fast = new ExponentialMovingAverage { Length = FastEma };
		var slow = new ExponentialMovingAverage { Length = SlowEma };
		var stdDev = new StandardDeviation { Length = StdPeriod };

		var subscription = SubscribeCandles(CandleType);
		subscription
			.Bind(fast, slow, stdDev, ProcessCandle)
			.Start();

		var area = CreateChartArea();
		if (area != null)
		{
			DrawCandles(area, subscription);
			DrawIndicator(area, fast);
			DrawIndicator(area, slow);
			DrawOwnTrades(area);
		}
	}

	private void ProcessCandle(ICandleMessage candle, decimal fast, decimal slow, decimal stdVal)
	{
		if (candle.State != CandleStates.Finished)
			return;

		// Trail management
		if (Position > 0)
		{
			var stop = candle.ClosePrice - stdVal * StdFactor;
			if (stop > _longTrail)
				_longTrail = stop;

			if (candle.LowPrice <= _longTrail)
			{
				SellMarket();
				_longTrail = 0;
			}
		}
		else if (Position < 0)
		{
			var stop = candle.ClosePrice + stdVal * StdFactor;
			if (stop < _shortTrail || _shortTrail == 0)
				_shortTrail = stop;

			if (candle.HighPrice >= _shortTrail)
			{
				BuyMarket();
				_shortTrail = 0;
			}
		}

		// Entry signals
		if (_hasPrev && stdVal > 0)
		{
			var crossUp = _prevFast <= _prevSlow && fast > slow;
			var crossDown = _prevFast >= _prevSlow && fast < slow;

			if (crossUp && Position <= 0)
			{
				BuyMarket();
				_longTrail = candle.ClosePrice - stdVal * StdFactor;
				_shortTrail = 0;
			}
			else if (crossDown && Position >= 0)
			{
				SellMarket();
				_shortTrail = candle.ClosePrice + stdVal * StdFactor;
				_longTrail = 0;
			}
		}

		_prevFast = fast;
		_prevSlow = slow;
		_hasPrev = true;
	}
}