Português PT
Ver no GitHub

Básico ATR Parar Tomar

Visão geral

Basic ATR Stop Take transporta o MetaTrader 4 consultor especialista “Basic ATR stop_take consultor especialista” para a estratégia de alto nível StockSharp API. O sistema é intencionalmente mínimo: ele abre exatamente uma posição de mercado na direção escolhida, calcula um intervalo médio verdadeiro (ATR) nas velas de trabalho e atribui níveis protetores de stop-loss e take-profit derivados de multiplicador ATRes. Assim que a negociação for fechada em qualquer nível, a estratégia se prepara imediatamente para a próxima configuração na mesma direção.

Lógica estratégica

Base do indicador

  • Average True Range (ATR) – calculado no tipo de vela subscrito com um lookback configurável. O indicador mede a volatilidade recente e dimensiona as distâncias de stop e alvo.

Regras de entrada

  • É executado no fechamento de cada vela concluída após o ATR estar totalmente formado.
  • Se nenhuma posição estiver aberta e o parâmetro de direção estiver definido como Compra, uma ordem de compra a mercado será enviada usando o volume configurado.
  • Se nenhuma posição estiver aberta e o parâmetro de direção estiver definido como Venda, uma ordem de venda a mercado será enviada com o volume configurado.
  • Escolher Nenhum desativa novas entradas enquanto mantém as posições existentes gerenciadas até que sejam fechadas.

Regras de saída

  • ATR stop-loss – a distância é igual a ATR × Stop Factor. Para compras, o stop é colocado abaixo da entrada; para shorts é colocado acima da entrada. Quando o extremo da vela ultrapassa o nível, a posição é fechada no mercado.
  • ATR take-profit – a distância é igual a ATR × Take Factor. Para posições compradas, a meta de lucro fica acima da entrada; para shorts fica abaixo. Atingir o nível fecha a negociação no mercado.
  • Se um dos multiplicadores estiver definido como 0, o nível correspondente será desativado; a estratégia continua a monitorar o nível restante, se presente.

Gestão de posição

  • Apenas uma posição é permitida por vez. Após uma saída, a estratégia aguarda o fechamento da próxima vela antes de entrar novamente na mesma direção.
  • StartProtection() é invocado durante a inicialização para que as posições manuais externas sejam monitoradas pelo subsistema de proteção StockSharp.

Parâmetros

  • Direção de negociação – lado do mercado para negociação (None, Buy ou Sell).
  • Volume de Negociação – volume de pedidos para entrada no mercado único.
  • ATR Período – número de velas usadas no cálculo de ATR.
  • Stop Factor – multiplicador ATR aplicado à distância stop-loss. Zero desativa a parada protetora.
  • Take Factor – multiplicador ATR aplicado à distância de take-profit. Zero desativa a meta de lucro.
  • Tipo de vela – período de tempo das velas usadas para cálculo de ATR e gerenciamento de negociação.

Notas adicionais

  • Os parâmetros padrão replicam o comportamento do EA (modo somente longo, volume de lote 0,01, período ATR 14, fator de parada 1,5, fator de aceitação 2,0).
  • As comparações de preços usam máximos e mínimos de velas, o que significa que os gatilhos de stop-loss e take-profit ocorrem assim que o nível é ultrapassado dentro da faixa da vela.
  • A estratégia não empilha nem inverte posições; em vez disso, ele sempre fica nivelado e aguarda o fechamento da próxima barra antes de fazer um novo pedido.
  • Somente a implementação C# é fornecida neste pacote; não existe uma versão Python para esta estratégia.
namespace StockSharp.Samples.Strategies;

using System;
using Ecng.Common;
using StockSharp.Algo.Indicators;
using StockSharp.Algo.Strategies;
using StockSharp.Messages;

/// <summary>
/// Basic ATR Stop Take strategy: EMA trend with ATR-based stop/take levels.
/// Enters on EMA direction, manages position with ATR-distance stops.
/// </summary>
public class BasicAtrStopTakeStrategy : Strategy
{
	private readonly StrategyParam<DataType> _candleType;
	private readonly StrategyParam<int> _emaPeriod;
	private readonly StrategyParam<int> _atrPeriod;
	private readonly StrategyParam<decimal> _stopFactor;
	private readonly StrategyParam<decimal> _takeFactor;
	private readonly StrategyParam<int> _signalCooldownCandles;

	private decimal _entryPrice;
	private decimal _stopPrice;
	private decimal _takePrice;
	private bool _prevAboveEma;
	private bool _hasPrevSignal;
	private int _candlesSinceTrade;

	public DataType CandleType { get => _candleType.Value; set => _candleType.Value = value; }
	public int EmaPeriod { get => _emaPeriod.Value; set => _emaPeriod.Value = value; }
	public int AtrPeriod { get => _atrPeriod.Value; set => _atrPeriod.Value = value; }
	public decimal StopFactor { get => _stopFactor.Value; set => _stopFactor.Value = value; }
	public decimal TakeFactor { get => _takeFactor.Value; set => _takeFactor.Value = value; }
	public int SignalCooldownCandles { get => _signalCooldownCandles.Value; set => _signalCooldownCandles.Value = value; }

	public BasicAtrStopTakeStrategy()
	{
		_candleType = Param(nameof(CandleType), TimeSpan.FromMinutes(15).TimeFrame())
			.SetDisplay("Candle Type", "Candle timeframe", "General");
		_emaPeriod = Param(nameof(EmaPeriod), 50)
			.SetGreaterThanZero()
			.SetDisplay("EMA Period", "EMA trend period", "Indicators");
		_atrPeriod = Param(nameof(AtrPeriod), 14)
			.SetGreaterThanZero()
			.SetDisplay("ATR Period", "ATR period", "Indicators");
		_stopFactor = Param(nameof(StopFactor), 1.5m)
			.SetDisplay("Stop Factor", "ATR multiplier for stop loss", "Risk");
		_takeFactor = Param(nameof(TakeFactor), 2.0m)
			.SetDisplay("Take Factor", "ATR multiplier for take profit", "Risk");
		_signalCooldownCandles = Param(nameof(SignalCooldownCandles), 6)
			.SetGreaterThanZero()
			.SetDisplay("Signal Cooldown", "Bars to wait between entries", "Trading");
	}

	/// <inheritdoc />
	protected override void OnReseted()
	{
		base.OnReseted();
		_entryPrice = 0m;
		_stopPrice = 0m;
		_takePrice = 0m;
		_prevAboveEma = false;
		_hasPrevSignal = false;
		_candlesSinceTrade = SignalCooldownCandles;
	}

	/// <inheritdoc />
	protected override void OnStarted2(DateTime time)
	{
		base.OnStarted2(time);
		_entryPrice = 0;
		_hasPrevSignal = false;
		_candlesSinceTrade = SignalCooldownCandles;
		var ema = new ExponentialMovingAverage { Length = EmaPeriod };
		var atr = new AverageTrueRange { Length = AtrPeriod };
		var subscription = SubscribeCandles(CandleType);
		subscription.Bind(ema, atr, ProcessCandle).Start();
	}

	private void ProcessCandle(ICandleMessage candle, decimal ema, decimal atr)
	{
		if (candle.State != CandleStates.Finished) return;
		var close = candle.ClosePrice;
		var aboveEma = close > ema;

		if (_candlesSinceTrade < SignalCooldownCandles)
			_candlesSinceTrade++;

		if (Position > 0 && _entryPrice > 0)
		{
			if (close <= _stopPrice || close >= _takePrice)
			{
				SellMarket();
				_entryPrice = 0;
				_stopPrice = 0;
				_takePrice = 0;
				_candlesSinceTrade = 0;
			}
		}
		else if (Position < 0 && _entryPrice > 0)
		{
			if (close >= _stopPrice || close <= _takePrice)
			{
				BuyMarket();
				_entryPrice = 0;
				_stopPrice = 0;
				_takePrice = 0;
				_candlesSinceTrade = 0;
			}
		}

		if (Position == 0 && atr > 0 && _hasPrevSignal && aboveEma != _prevAboveEma && _candlesSinceTrade >= SignalCooldownCandles)
		{
			if (aboveEma)
			{
				BuyMarket();
				_entryPrice = close;
				_stopPrice = close - atr * StopFactor;
				_takePrice = close + atr * TakeFactor;
				_candlesSinceTrade = 0;
			}
			else
			{
				SellMarket();
				_entryPrice = close;
				_stopPrice = close + atr * StopFactor;
				_takePrice = close - atr * TakeFactor;
				_candlesSinceTrade = 0;
			}
		}

		_prevAboveEma = aboveEma;
		_hasPrevSignal = true;
	}
}