Português PT
Ver no GitHub

Estratégia Executor AO

Visão geral

Executor AO é uma estratégia de estilo saucer (pires) baseada no Awesome Oscillator, originalmente distribuída como o consultor especialista "Executor AO" do MetaTrader. O porte para StockSharp mantém a detecção de reversão baseada em indicadores enquanto simplifica o gerenciamento de dinheiro para um tamanho de ordem fixo. A estratégia observa velas completadas do período configurado, avalia a mudança de inclinação do Awesome Oscillator e abre uma única posição líquida quando ocorrem condições de alta ou baixa abaixo ou acima da linha zero. O stop de proteção opcional, take-profit e lógica de trailing reproduzem o comportamento de gerenciamento de risco do EA original.

Lógica de negociação

  1. Assinar a série de velas definida por CandleType e alimentar cada vela concluída no Awesome Oscillator com os parâmetros AoShortPeriod e AoLongPeriod configurados.
  2. Armazenar os três últimos valores completados do Awesome Oscillator para reproduzir o padrão de acesso ao buffer do MetaTrader usado pelo especialista original.
  3. Quando nenhuma posição está aberta:
    • Configuração de alta: o último valor de AO é maior que o anterior, o valor anterior é menor que o valor de duas barras atrás (um vale), e o último valor permanece abaixo de -MinimumAoIndent. Nesse caso, enviar uma ordem de compra a mercado com TradeVolume lotes.
    • Configuração de baixa: o último valor de AO é menor que o anterior, o valor anterior é maior que o valor de duas barras atrás (um pico), e o último valor permanece acima de MinimumAoIndent. Nesse caso, enviar uma ordem de venda a mercado com o volume fixo.
  4. Quando existe uma posição, a estratégia emula as saídas do EA:
    • Calcular os preços de stop-loss e take-profit a partir da entrada usando StopLossPips e TakeProfitPips multiplicados pelo tamanho de pip ajustado (o tratamento de 3/5 dígitos do MetaTrader é replicado).
    • Aplicar a regra de trailing stop quando o preço se move a favor da posição por mais de TrailingStopPips + TrailingStepPips pips. O stop só avança se o novo nível estiver além do anterior, correspondendo ao requisito de passo de trailing do EA.
    • Fechar posições compradas quando o preço toca o take-profit ou stop-loss ou quando o valor do Awesome Oscillator da barra anterior fica positivo. Fechar posições vendidas quando o preço atinge seus alvos ou o valor anterior de AO cai abaixo de zero.
  5. Todas as ordens são a mercado; o modelo de posição líquida do StockSharp garante que apenas uma direção esteja ativa por vez.

Parâmetros

Nome Tipo Padrão Descrição
CandleType DataType Velas de 5 minutos Período principal usado para calcular e negociar a estratégia.
TradeVolume decimal 1 Tamanho de ordem fixo usado para cada entrada.
AoShortPeriod int 5 Período rápido para a SMA curta do Awesome Oscillator.
AoLongPeriod int 34 Período lento para a SMA longa do Awesome Oscillator.
MinimumAoIndent decimal 0.001 Distância absoluta mínima de zero necessária para novos sinais. Evita negociações quando AO paira em torno de zero.
StopLossPips decimal 50 Distância de stop-loss protetor expressa em pips estilo MetaTrader. Definir como 0 para desativar o stop.
TakeProfitPips decimal 50 Distância de take-profit expressa em pips. Definir como 0 para desativar o alvo.
TrailingStopPips decimal 5 Distância de ativação do trailing stop. Usado somente quando maior que zero.
TrailingStepPips decimal 5 Melhoria mínima de preço necessária antes de atualizar o trailing stop. Deve permanecer positivo quando o trailing está habilitado.

Diferenças em relação ao EA do MetaTrader

  • A versão do MetaTrader permitia dimensionamento de posição baseado em risco. O porte para StockSharp implementa a opção de lote fixo (TradeVolume) e deixa o gerenciamento por percentual de risco de fora por clareza.
  • O gerenciamento de ordens é simulado dentro da estratégia: quando os limites de stop-loss ou take-profit são atingidos em velas completadas, a estratégia envia ordens a mercado para fechar a posição. Isso espelha o comportamento do EA sem criar ordens filho separadas.
  • Os ajustes de trailing ocorrem em eventos de fechamento de vela, em vez de a cada tick. Isso mantém a implementação consistente com a API de alto nível enquanto segue a mesma lógica de limite.
  • Todos os caminhos de código dependem do padrão SubscribeCandles + Bind de alto nível do StockSharp em vez de copiar manualmente os buffers do indicador.

Dicas de uso

  • Alinhar TradeVolume com o passo de lote do instrumento antes de iniciar a estratégia. O construtor também atribui o mesmo valor a Strategy.Volume, então os métodos auxiliares usam automaticamente o tamanho escolhido.
  • MinimumAoIndent pode ser aumentado em mercados ruidosos para evitar mudanças frequentes perto de zero. Defini-lo como 0 reproduz o comportamento mais agressivo do EA.
  • Ao habilitar o trailing stop, manter TrailingStepPips acima de zero; caso contrário, o construtor lança uma exceção, reproduzindo a validação de parâmetros do EA original.
  • Anexar a estratégia a um gráfico para visualizar tanto as velas quanto o Awesome Oscillator sobreposto. Isso ajuda a validar a detecção de vale/pico após a conversão.

Indicador

  • Awesome Oscillator: diferença entre uma média móvel simples rápida e uma lenta do preço mediano. A configuração padrão 5/34 corresponde ao indicador do MetaTrader.
using System;

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

namespace StockSharp.Samples.Strategies;

/// <summary>
/// Awesome Oscillator swing strategy converted from the "Executor AO" MetaTrader expert.
/// Implements the saucer-based entry logic with optional stop, take-profit, and trailing exit management.
/// </summary>
public class ExecutorAoStrategy : Strategy
{
	private readonly StrategyParam<decimal> _tradeVolume;
	private readonly StrategyParam<int> _aoShortPeriod;
	private readonly StrategyParam<int> _aoLongPeriod;
	private readonly StrategyParam<decimal> _minimumAoIndent;
	private readonly StrategyParam<decimal> _stopLossPips;
	private readonly StrategyParam<decimal> _takeProfitPips;
	private readonly StrategyParam<decimal> _trailingStopPips;
	private readonly StrategyParam<decimal> _trailingStepPips;
	private readonly StrategyParam<DataType> _candleType;
	private static readonly object _sync = new();

	private AwesomeOscillator _ao = null!;

	private decimal? _currentAo;
	private decimal? _previousAo;
	private decimal? _previousAo2;

	private decimal _pipSize;

	private decimal? _longEntryPrice;
	private decimal? _longStop;
	private decimal? _longTake;

	private decimal? _shortEntryPrice;
	private decimal? _shortStop;
	private decimal? _shortTake;

	/// <summary>
	/// Initializes a new instance of the <see cref="ExecutorAoStrategy"/> class.
	/// </summary>
	public ExecutorAoStrategy()
	{
		_tradeVolume = Param(nameof(TradeVolume), 1m)
			.SetGreaterThanZero()
			.SetDisplay("Trade Volume", "Fixed order size", "Risk")
			;

		_aoShortPeriod = Param(nameof(AoShortPeriod), 5)
			.SetDisplay("AO Short Period", "Fast period for Awesome Oscillator", "Indicators")
			;

		_aoLongPeriod = Param(nameof(AoLongPeriod), 34)
			.SetDisplay("AO Long Period", "Slow period for Awesome Oscillator", "Indicators")
			;

		_minimumAoIndent = Param(nameof(MinimumAoIndent), 0.001m)
			.SetNotNegative()
			.SetDisplay("Minimum AO Indent", "Minimum distance from zero before signals are valid", "Logic")
			;

		_stopLossPips = Param(nameof(StopLossPips), 50m)
			.SetNotNegative()
			.SetDisplay("Stop Loss (pips)", "Protective stop distance expressed in pips", "Risk")
			;

		_takeProfitPips = Param(nameof(TakeProfitPips), 50m)
			.SetNotNegative()
			.SetDisplay("Take Profit (pips)", "Target distance expressed in pips", "Risk")
			;

		_trailingStopPips = Param(nameof(TrailingStopPips), 5m)
			.SetNotNegative()
			.SetDisplay("Trailing Stop (pips)", "Trailing distance in pips", "Risk")
			;

		_trailingStepPips = Param(nameof(TrailingStepPips), 5m)
			.SetNotNegative()
			.SetDisplay("Trailing Step (pips)", "Minimum move before trailing adjusts", "Risk")
			;

		_candleType = Param(nameof(CandleType), TimeSpan.FromHours(2).TimeFrame())
			.SetDisplay("Candle Type", "Primary timeframe used for analysis", "General");
	}

	/// <summary>
	/// Fixed order volume used for market entries.
	/// </summary>
	public decimal TradeVolume
	{
		get => _tradeVolume.Value;
		set
		{
			_tradeVolume.Value = value;
			Volume = value;
		}
	}

	/// <summary>
	/// Fast period for the Awesome Oscillator calculation.
	/// </summary>
	public int AoShortPeriod
	{
		get => _aoShortPeriod.Value;
		set => _aoShortPeriod.Value = value;
	}

	/// <summary>
	/// Slow period for the Awesome Oscillator calculation.
	/// </summary>
	public int AoLongPeriod
	{
		get => _aoLongPeriod.Value;
		set => _aoLongPeriod.Value = value;
	}

	/// <summary>
	/// Minimum absolute AO value required before trades are allowed.
	/// </summary>
	public decimal MinimumAoIndent
	{
		get => _minimumAoIndent.Value;
		set => _minimumAoIndent.Value = value;
	}

	/// <summary>
	/// Stop-loss distance in pips.
	/// </summary>
	public decimal StopLossPips
	{
		get => _stopLossPips.Value;
		set => _stopLossPips.Value = value;
	}

	/// <summary>
	/// Take-profit distance in pips.
	/// </summary>
	public decimal TakeProfitPips
	{
		get => _takeProfitPips.Value;
		set => _takeProfitPips.Value = value;
	}

	/// <summary>
	/// Trailing stop distance in pips.
	/// </summary>
	public decimal TrailingStopPips
	{
		get => _trailingStopPips.Value;
		set => _trailingStopPips.Value = value;
	}

	/// <summary>
	/// Minimum step required before the trailing stop moves.
	/// </summary>
	public decimal TrailingStepPips
	{
		get => _trailingStepPips.Value;
		set => _trailingStepPips.Value = value;
	}

	/// <summary>
	/// Candle series used to generate signals.
	/// </summary>
	public DataType CandleType
	{
		get => _candleType.Value;
		set => _candleType.Value = value;
	}

	/// <inheritdoc />
	protected override void OnReseted()
	{
		base.OnReseted();

		_ao = null!;
		_currentAo = null;
		_previousAo = null;
		_previousAo2 = null;
		_pipSize = 0m;
		ResetLongState();
		ResetShortState();
	}

	/// <inheritdoc />
	protected override void OnStarted2(DateTime time)
	{
		base.OnStarted2(time);

		Volume = TradeVolume;
		_pipSize = CalculatePipSize();

		if (TrailingStopPips > 0m && TrailingStepPips <= 0m)
			throw new InvalidOperationException("Trailing step must be positive when trailing stop is enabled.");

		_ao = new AwesomeOscillator
		{
			ShortMa = { Length = AoShortPeriod },
			LongMa = { Length = AoLongPeriod }
		};

		var subscription = SubscribeCandles(CandleType);
		subscription
			.Bind(candle => ProcessCandle(candle))
			.Start();

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

	private void ProcessCandle(ICandleMessage candle)
	{
		if (candle.State != CandleStates.Finished)
			return;

		lock (_sync)
		{
			var aoValue = _ao.Process(new CandleIndicatorValue(_ao, candle) { IsFinal = true });
			if (!aoValue.IsFinal || _ao == null || !_ao.IsFormed)
				return;

			var previousAo = _currentAo;
			var previousAo2 = _previousAo;

			var positionClosed = HandleActivePositions(candle, previousAo);

			StoreAoValue(aoValue.ToDecimal());

			if (positionClosed || !previousAo.HasValue || !previousAo2.HasValue || !_currentAo.HasValue)
				return;

			if (Position != 0m)
				return;

			var current = _currentAo.Value;
			var prev = previousAo.Value;
			var prev2 = previousAo2.Value;
			var indent = MinimumAoIndent;

			if (current > prev && prev < prev2 && current <= -indent)
			{
				OpenLong(candle.ClosePrice);
				return;
			}

			if (current < prev && prev > prev2 && current >= indent)
				OpenShort(candle.ClosePrice);
		}
	}

	private bool HandleActivePositions(ICandleMessage candle, decimal? previousAo)
	{
		if (Position > 0m)
		{
			_longEntryPrice ??= candle.ClosePrice;
			UpdateTrailingForLong(candle);

			if (_longTake.HasValue && candle.HighPrice >= _longTake.Value)
			{
				SellMarket(Math.Abs(Position));
				ResetLongState();
				return true;
			}

			if (_longStop.HasValue && candle.LowPrice <= _longStop.Value)
			{
				SellMarket(Math.Abs(Position));
				ResetLongState();
				return true;
			}

			if (previousAo.HasValue && previousAo.Value > 0m)
			{
				SellMarket(Math.Abs(Position));
				ResetLongState();
				return true;
			}
		}
		else if (Position < 0m)
		{
			_shortEntryPrice ??= candle.ClosePrice;
			UpdateTrailingForShort(candle);

			if (_shortTake.HasValue && candle.LowPrice <= _shortTake.Value)
			{
				BuyMarket(Math.Abs(Position));
				ResetShortState();
				return true;
			}

			if (_shortStop.HasValue && candle.HighPrice >= _shortStop.Value)
			{
				BuyMarket(Math.Abs(Position));
				ResetShortState();
				return true;
			}

			if (previousAo.HasValue && previousAo.Value < 0m)
			{
				BuyMarket(Math.Abs(Position));
				ResetShortState();
				return true;
			}
		}
		else
		{
			ResetLongState();
			ResetShortState();
		}

		return false;
	}

	private void OpenLong(decimal price)
	{
		var volume = GetTradeVolume();
		if (volume <= 0m)
			return;

		BuyMarket(volume);

		_longEntryPrice = price;
		_longStop = StopLossPips > 0m ? price - StopLossPips * _pipSize : null;
		_longTake = TakeProfitPips > 0m ? price + TakeProfitPips * _pipSize : null;
		ResetShortState();
	}

	private void OpenShort(decimal price)
	{
		var volume = GetTradeVolume();
		if (volume <= 0m)
			return;

		SellMarket(volume);

		_shortEntryPrice = price;
		_shortStop = StopLossPips > 0m ? price + StopLossPips * _pipSize : null;
		_shortTake = TakeProfitPips > 0m ? price - TakeProfitPips * _pipSize : null;
		ResetLongState();
	}

	private void UpdateTrailingForLong(ICandleMessage candle)
	{
		if (TrailingStopPips <= 0m || TrailingStepPips <= 0m || !_longEntryPrice.HasValue)
			return;

		var trailingDistance = TrailingStopPips * _pipSize;
		var trailingStep = TrailingStepPips * _pipSize;
		var price = candle.ClosePrice;
		var entry = _longEntryPrice.Value;

		if (price - entry > trailingDistance + trailingStep)
		{
			var minimalAllowed = price - (trailingDistance + trailingStep);
			if (!_longStop.HasValue || _longStop.Value < minimalAllowed)
				_longStop = price - trailingDistance;
		}
	}

	private void UpdateTrailingForShort(ICandleMessage candle)
	{
		if (TrailingStopPips <= 0m || TrailingStepPips <= 0m || !_shortEntryPrice.HasValue)
			return;

		var trailingDistance = TrailingStopPips * _pipSize;
		var trailingStep = TrailingStepPips * _pipSize;
		var price = candle.ClosePrice;
		var entry = _shortEntryPrice.Value;

		if (entry - price > trailingDistance + trailingStep)
		{
			var maximalAllowed = price + (trailingDistance + trailingStep);
			if (!_shortStop.HasValue || _shortStop.Value > maximalAllowed)
				_shortStop = price + trailingDistance;
		}
	}

	private decimal GetTradeVolume()
	{
		var volume = Volume;
		if (volume <= 0m)
			volume = TradeVolume;
		return volume;
	}

	private void StoreAoValue(decimal value)
	{
		_previousAo2 = _previousAo;
		_previousAo = _currentAo;
		_currentAo = value;
	}

	private decimal CalculatePipSize()
	{
		var priceStep = Security?.PriceStep ?? 1m;
		if (priceStep <= 0m)
			priceStep = 1m;

		var decimals = GetDecimalPlaces(priceStep);
		var factor = decimals == 3 || decimals == 5 ? 10m : 1m;
		return priceStep * factor;
	}

	private static int GetDecimalPlaces(decimal value)
	{
		value = Math.Abs(value);
		if (value == 0m)
			return 0;

		var bits = decimal.GetBits(value);
		return (bits[3] >> 16) & 0xFF;
	}

	private void ResetLongState()
	{
		_longEntryPrice = null;
		_longStop = null;
		_longTake = null;
	}

	private void ResetShortState()
	{
		_shortEntryPrice = null;
		_shortStop = null;
		_shortTake = null;
	}
}