Español ES
Ver en GitHub

Estrategia de impulso general EMA

Esta estrategia es una conversión del MetaTrader 4 asesor experto 0Graal-CROSSmuvingi. Negocia cambios de tendencia que ocurren cuando un promedio móvil exponencial rápido (EMA) en los precios de cierre cruza un EMA más lento calculado en los precios de apertura. Un oscilador de impulso confirma la dirección de ruptura y una toma de ganancias de distancia fija replica el modelo de ejecución original de MT4.

Idea comercial

  1. Fast EMA al cerrar rastrea la acción del precio más reciente.
  2. EMA lenta en apertura se queda atrás y forma la línea de base de cruce.
  3. Oscilador de impulso (período 14) mide con qué fuerza se acelera el precio alejándose del valor neutral (100). La estrategia solo opera cuando el impulso se desvía de 100 en más de un filtro configurable y continúa fortaleciéndose en la misma dirección.
  4. Take Profit cierra operaciones después de una distancia predefinida medida en puntos del instrumento, reflejando el parámetro MT4 TakeProfit.

Reglas de entrada

  • Configuración larga
    • El EMA rápido cruza por encima del EMA lento en la vela finalizada actual, mientras que la barra anterior tenía el EMA rápido por debajo o igual al EMA lento.
    • El impulso (valor menos 100) es mayor que el umbral MomentumFilter y también mayor que la lectura de impulso de la barra anterior.
    • Las posiciones cortas existentes se cierran antes de abrir una nueva larga. El nuevo tamaño largo es igual al Volume configurado más cualquier cantidad necesaria para invertir una posición corta abierta.
  • Configuración corta
    • El EMA rápido cruza por debajo del EMA lento mientras que la barra anterior tenía el EMA rápido por encima o igual al EMA lento.
    • El impulso (valor menos 100) está por debajo del umbral negativo MomentumFilter y es menor que la lectura de impulso de la barra anterior.
    • Las posiciones largas existentes se cierran antes de abrir una nueva venta corta. El nuevo tamaño corto equivale al Volume configurado más la cantidad necesaria para cubrir un largo abierto.

Reglas de salida

  • Las posiciones se cierran automáticamente cuando el precio alcanza el objetivo de obtención de beneficios calculado (TakeProfitPoints * PriceStep).
  • Una nueva señal opuesta también invierte la posición inmediatamente porque el tamaño del pedido siempre incluye la cantidad de la posición actual.

Parámetros

Nombre Descripción Predeterminado
FastPeriod Duración del EMA sobre precios de cierre. 13
SlowPeriod Duración del EMA sobre precios de apertura. 34
MomentumPeriod Mirada retrospectiva del oscilador de momento. 14
MomentumFilter Desviación mínima del impulso absoluto de 100 requerida para operar. 0.1
TakeProfitPoints Distancia al objetivo de ganancias en puntos de precio (multiplicada por PriceStep). 200
CandleType Tipo de datos de vela utilizado para los cálculos (período de tiempo de 15 minutos de forma predeterminada). plazo de 15 minutos
Volume Tamaño del pedido utilizado para nuevas entradas. El motor lo hereda de la clase base. 1

Notas de implementación

  • Las señales se procesan únicamente en velas cerradas (CandleStates.Finished).
  • La estrategia se suscribe al tipo de vela elegido con SubscribeCandles y vincula tanto EMA como los indicadores de impulso a través del nivel alto API.
  • El EMA lenta se actualiza manualmente con precios de apertura dentro de la devolución de llamada de enlace para replicar el comportamiento de MT4 donde se usó PRICE_OPEN.
  • La gestión de toma de ganancias observa los altibajos intrabar para emular la lógica de salida basada en puntos de MT4.
  • StartProtection() está habilitado al inicio para protegerse contra posiciones abiertas inesperadas antes de que la estrategia comience a operar.
using System;

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

namespace StockSharp.Samples.Strategies;

public class GraalEmaMomentumStrategy : Strategy
{
	private readonly StrategyParam<int> _fastPeriod;
	private readonly StrategyParam<int> _slowPeriod;
	private readonly StrategyParam<int> _momentumPeriod;
	private readonly StrategyParam<int> _cooldownCandles;
	private readonly StrategyParam<DataType> _candleType;

	private decimal _prevFast;
	private decimal _prevSlow;
	private bool _hasPrev;
	private int _cooldownRemaining;

	public int FastPeriod { get => _fastPeriod.Value; set => _fastPeriod.Value = value; }
	public int SlowPeriod { get => _slowPeriod.Value; set => _slowPeriod.Value = value; }
	public int MomentumPeriod { get => _momentumPeriod.Value; set => _momentumPeriod.Value = value; }
	public int CooldownCandles { get => _cooldownCandles.Value; set => _cooldownCandles.Value = value; }
	public DataType CandleType { get => _candleType.Value; set => _candleType.Value = value; }

	public GraalEmaMomentumStrategy()
	{
		_fastPeriod = Param(nameof(FastPeriod), 20).SetDisplay("Fast EMA", "Fast EMA period", "Indicators");
		_slowPeriod = Param(nameof(SlowPeriod), 80).SetDisplay("Slow EMA", "Slow EMA period", "Indicators");
		_momentumPeriod = Param(nameof(MomentumPeriod), 14).SetDisplay("Momentum", "Momentum period", "Indicators");
		_cooldownCandles = Param(nameof(CooldownCandles), 100).SetDisplay("Cooldown", "Candles between signals", "General");
		_candleType = Param(nameof(CandleType), TimeSpan.FromMinutes(5).TimeFrame()).SetDisplay("Candle Type", "Candle timeframe", "General");
	}

	/// <inheritdoc />
	protected override void OnReseted()
	{
		base.OnReseted();
		_prevFast = default;
		_prevSlow = default;
		_hasPrev = default;
		_cooldownRemaining = default;
	}

	protected override void OnStarted2(DateTime time)
	{
		base.OnStarted2(time);
		_prevFast = 0;
		_prevSlow = 0;
		_hasPrev = false;
		_cooldownRemaining = 0;

		var fast = new ExponentialMovingAverage { Length = FastPeriod };
		var slow = new ExponentialMovingAverage { Length = SlowPeriod };
		var mom = new Momentum { Length = MomentumPeriod };
		var subscription = SubscribeCandles(CandleType);
		subscription.Bind(fast, slow, mom, ProcessCandle).Start();
	}

	private void ProcessCandle(ICandleMessage candle, decimal fast, decimal slow, decimal mom)
	{
		if (candle.State != CandleStates.Finished) return;
		if (!_hasPrev) { _prevFast = fast; _prevSlow = slow; _hasPrev = true; return; }

		if (_cooldownRemaining > 0)
		{
			_cooldownRemaining--;
			_prevFast = fast;
			_prevSlow = slow;
			return;
		}

		if (_prevFast <= _prevSlow && fast > slow && mom > 0 && Position <= 0)
		{
			if (Position < 0) BuyMarket();
			BuyMarket();
			_cooldownRemaining = CooldownCandles;
		}
		else if (_prevFast >= _prevSlow && fast < slow && mom < 0 && Position >= 0)
		{
			if (Position > 0) SellMarket();
			SellMarket();
			_cooldownRemaining = CooldownCandles;
		}
		_prevFast = fast;
		_prevSlow = slow;
	}
}