Português PT
Ver no GitHub

Estratégia Eli

Visão geral

A Estratégia Elli transporta o consultor especialista MetaTrader 4 "Elli" para o StockSharp API de alto nível. O robô original combinou a estrutura Ichimoku Kinko Hyo no período H1 com um filtro de período inferior ADX e parâmetros de risco rígidos. A conversão mantém a mesma lógica direcional, substitui o gerenciamento manual de pedidos por StartProtection e expõe cada botão de ajuste como um StrategyParam<T> otimizável para que o comportamento possa ser adaptado a diferentes mercados.

Lógica de negociação

  1. Ichimoku estrutura de tendência
    • A estratégia segue o período definido por CandleType (H1 por padrão) e calcula os períodos Tenkan-sen, Kijun-sen e Senkou usando os períodos originais (19, 60, 120).
    • Uma configuração de alta requer Tenkan > Kijun > Senkou Span A > Senkou Span B com a vela fechada acima de Kijun. As configurações de baixa refletem essa condição.
    • A distância absoluta entre Tenkan e Kijun deve exceder TenkanKijunGapPips pips para evitar nuvens planas ou extensas.
  2. Confirmação de movimento direcional
    • Uma segunda assinatura de vela executa o Índice Direcional Médio no período especificado por AdxCandleType (M1 por padrão).
    • Sinais longos são permitidos somente quando o valor +DI anterior estiver abaixo de ConvertLow e o +DI atual estiver acima de ConvertHigh. Os shorts requerem o mesmo relacionamento para o componente −DI, replicando o filtro de aceleração presente no código MT4.
  3. Execução de entrada
    • Quando todos os filtros estão alinhados, a estratégia emite uma ordem de mercado com volume OrderVolume + |Position|. Isso fecha automaticamente qualquer exposição oposta antes de aderir à tendência.
    • Apenas uma exposição direcional é mantida por vez, seguindo a guarda OrdersTotal() < 1 original.
  4. Gerenciamento de riscos
    • StartProtection anexa ordens simétricas de stop loss e takeprofit convertidas de distâncias de pip usando o tamanho do pip do instrumento.
    • Caso contrário, a posição é gerenciada passivamente, permitindo que as ordens de proteção lidem com as saídas da mesma forma que o consultor especialista MT4.

Indicadores e assinaturas de dados

  • Velas primárias: CandleType (velas padrão de 1 hora) para processamento de Ichimoku.
  • ADX velas: AdxCandleType (velas padrão de 1 minuto) para verificações de aceleração DI.
  • Indicadores: Ichimoku (Tenkan, Kijun, Senkou Span B) e AverageDirectionalIndex (fornecendo +DI/−DI).
  • Ambas as assinaturas suportam renderização de gráfico por meio de DrawCandles, DrawIndicator e DrawOwnTrades se uma área de gráfico estiver disponível.

Parâmetros

Nome Padrão Descrição
OrderVolume 1 Volume base de ordens de mercado.
TakeProfitPips 60 Distância de lucro expressa em pips.
StopLossPips 30 Distância de stop-loss expressa em pips.
TenkanPeriod 19 Período Tenkan-sen para o indicador Ichimoku.
KijunPeriod 60 Período Kijun-sen para o indicador Ichimoku.
SenkouSpanBPeriod 120 Período Senkou Span B para a nuvem Ichimoku.
TenkanKijunGapPips 20 Distância mínima Tenkan/Kijun (em pips) exigida antes da negociação.
ConvertHigh 13 Limite DI que o valor atual deve exceder para confirmar o impulso.
ConvertLow 6 Limite DI, o valor anterior deve ficar abaixo antes de uma nova negociação.
AdxPeriod 10 Período usado para o cálculo ADX.
CandleType H1 Prazo que orienta o cálculo de Ichimoku.
AdxCandleType M1 Prazo usado para monitoramento de ADX e DI.

Todos os parâmetros são implementados com ajudantes StrategyParam<T>, permitindo otimização e ajustes de tempo de execução dentro do StockSharp Designer.

Notas de implementação

  • A conversão do pip segue a convenção forex padrão (0,0001 para cotações de 5 dígitos e 0,01 para instrumentos de 3 dígitos) para preservar os limites originais baseados em pip.
  • Os valores ADX são armazenados em cache em _latestPlusDi, _previousPlusDi, _latestMinusDi e _previousMinusDi, garantindo que a verificação de aceleração DI corresponda às chamadas MQL iADX com turnos 0 e 1.
  • IsFormedAndOnlineAndAllowTrading() bloqueia sinais até que a estratégia, os indicadores e os feeds de dados estejam prontos, evitando negociações prematuras durante o aquecimento.
  • As entradas no mercado dependem de Volume + Math.Abs(Position) para que as mudanças de direção instantaneamente achatem as negociações existentes, emulando o comportamento de posição única do script MT4.
using System;

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

namespace StockSharp.Samples.Strategies;

/// <summary>
/// Elli: EMA crossover with ATR momentum confirmation.
/// Fast EMA above slow EMA = bullish, below = bearish.
/// Entry when ATR expansion confirms trend strength.
/// </summary>
public class ElliStrategy : Strategy
{
	private readonly StrategyParam<DataType> _candleType;
	private readonly StrategyParam<int> _fastLength;
	private readonly StrategyParam<int> _slowLength;
	private readonly StrategyParam<int> _atrLength;

	private decimal _prevFast;
	private decimal _prevSlow;
	private decimal _prevAtr;
	private decimal _entryPrice;

	public ElliStrategy()
	{
		_candleType = Param(nameof(CandleType), TimeSpan.FromHours(4).TimeFrame())
			.SetDisplay("Candle Type", "Timeframe.", "General");

		_fastLength = Param(nameof(FastLength), 19)
			.SetDisplay("Fast EMA", "Fast EMA period.", "Indicators");

		_slowLength = Param(nameof(SlowLength), 60)
			.SetDisplay("Slow EMA", "Slow EMA period.", "Indicators");

		_atrLength = Param(nameof(AtrLength), 14)
			.SetDisplay("ATR Length", "ATR period for momentum.", "Indicators");
	}

	public DataType CandleType
	{
		get => _candleType.Value;
		set => _candleType.Value = value;
	}

	public int FastLength
	{
		get => _fastLength.Value;
		set => _fastLength.Value = value;
	}

	public int SlowLength
	{
		get => _slowLength.Value;
		set => _slowLength.Value = value;
	}

	public int AtrLength
	{
		get => _atrLength.Value;
		set => _atrLength.Value = value;
	}

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

		_prevFast = 0;
		_prevSlow = 0;
		_prevAtr = 0;
		_entryPrice = 0;
	}

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

		_prevFast = 0;
		_prevSlow = 0;
		_prevAtr = 0;
		_entryPrice = 0;

		var fast = new ExponentialMovingAverage { Length = FastLength };
		var slow = new ExponentialMovingAverage { Length = SlowLength };
		var atr = new AverageTrueRange { Length = AtrLength };

		var subscription = SubscribeCandles(CandleType);
		subscription
			.Bind(fast, slow, atr, 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 fastVal, decimal slowVal, decimal atrVal)
	{
		if (candle.State != CandleStates.Finished)
			return;

		if (_prevFast == 0 || _prevSlow == 0 || atrVal <= 0)
		{
			_prevFast = fastVal;
			_prevSlow = slowVal;
			_prevAtr = atrVal;
			return;
		}

		var close = candle.ClosePrice;

		// Exit: stop or take based on ATR
		if (Position > 0)
		{
			if (close <= _entryPrice - atrVal * 2m || close >= _entryPrice + atrVal * 3m)
			{
				SellMarket();
				_entryPrice = 0;
			}
			else if (fastVal < slowVal)
			{
				SellMarket();
				_entryPrice = 0;
			}
		}
		else if (Position < 0)
		{
			if (close >= _entryPrice + atrVal * 2m || close <= _entryPrice - atrVal * 3m)
			{
				BuyMarket();
				_entryPrice = 0;
			}
			else if (fastVal > slowVal)
			{
				BuyMarket();
				_entryPrice = 0;
			}
		}

		// Entry: EMA crossover with ATR expansion
		if (Position == 0)
		{
			var atrRising = atrVal > _prevAtr;

			if (_prevFast <= _prevSlow && fastVal > slowVal && atrRising)
			{
				_entryPrice = close;
				BuyMarket();
			}
			else if (_prevFast >= _prevSlow && fastVal < slowVal && atrRising)
			{
				_entryPrice = close;
				SellMarket();
			}
		}

		_prevFast = fastVal;
		_prevSlow = slowVal;
		_prevAtr = atrVal;
	}
}