Español ES
Ver en GitHub

Estrategia Envelopes EA

Descripción general

La estrategia replica el asesor experto de MetaTrader 4 "EnvelopesEA". Aplica una envolvente de media móvil exponencial al flujo principal de velas y opera reversiones a la media. Cuando el mercado se aleja mucho fuera de la envolvente, se envía una orden de mercado contraria. Las posiciones se cierran tan pronto como el precio vuelve a entrar en la envolvente en la dirección opuesta. El experto original se probó en EUR/USD en 2019; la adaptación a StockSharp conserva la misma lógica y expone todas las entradas clave como parámetros optimizables.

Lógica de trading

  1. Calcular una media móvil exponencial (EMA) de longitud EnvelopePeriod sobre las velas seleccionadas.
  2. Construir una envolvente superior e inferior expandiendo la EMA con UpperDeviationPercent y LowerDeviationPercent, respectivamente.
  3. Aplicar un buffer adicional de entrada definido por EntryOffsetPoints (multiplicado por el paso de precio del instrumento) para evitar operaciones prematuras.
  4. Cuando no hay posición abierta:
    • Entrar largo si el precio de cierre cae por debajo de la envolvente inferior menos el buffer de entrada.
    • Entrar corto si el precio de cierre sube por encima de la envolvente superior más el buffer de entrada.
  5. Cuando existe una posición:
    • Cerrar posiciones largas cuando el precio de cierre vuelva a cruzar por encima de la envolvente superior.
    • Cerrar posiciones cortas cuando el precio de cierre vuelva a cruzar por debajo de la envolvente inferior.

La estrategia mantiene siempre como máximo una posición abierta y usa órdenes de mercado tanto para entradas como para salidas.

Gestión monetaria

El volumen de la orden se especifica directamente mediante el parámetro Volume (lotes). No hay reglas automáticas de martingala ni piramidación, manteniendo el comportamiento idéntico a la última implementación MQ4, donde las funciones de escalado estaban desactivadas por defecto.

Parámetros

Parámetro Descripción Predeterminado
Volume Volumen de orden en lotes. 0.2
EnvelopePeriod Longitud de la EMA que forma la base de la envolvente. 50
UpperDeviationPercent Desviación porcentual aplicada a la banda superior. 0.5
LowerDeviationPercent Desviación porcentual aplicada a la banda inferior. 0.5
EntryOffsetPoints Distancia adicional, en pasos de precio, que el precio debe recorrer más allá de la banda antes de entrar. 100
CandleType Marco temporal usado para velas y cálculos de indicadores. Velas de 30 minutos

Todos los parámetros numéricos (excepto CandleType) están marcados como optimizables para ayudar a reproducir los flujos de optimización originales.

Notas

  • La envolvente usa una EMA en lugar de la SMA de versiones anteriores porque el script MQ4 evolucionó hacia una base exponencial en la iteración más reciente. Esto ofrece una reacción más rápida a los vaivenes del precio y mejora el timing de reversión a la media.
  • El buffer de entrada se multiplica por el PriceStep del instrumento. Asegúrese de que los metadatos del valor contengan un tamaño de paso válido; de lo contrario, la estrategia usa un valor predeterminado conservador de 0.0001.
  • La visualización del gráfico incluye velas de precio, la envolvente EMA y las operaciones de la estrategia, lo que facilita validar el comportamiento de las señales frente al Expert Advisor original.
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;

public class EnvelopesEaStrategy : Strategy
{
	private readonly StrategyParam<int> _fastPeriod;
	private readonly StrategyParam<int> _slowPeriod;
	private readonly StrategyParam<int> _stopLossPoints;
	private readonly StrategyParam<int> _takeProfitPoints;

	private ExponentialMovingAverage _fast;
	private ExponentialMovingAverage _slow;

	private decimal _prevFast;
	private decimal _prevSlow;
	private decimal _entryPrice;
	private int _cooldown;

	public int FastPeriod { get => _fastPeriod.Value; set => _fastPeriod.Value = value; }
	public int SlowPeriod { get => _slowPeriod.Value; set => _slowPeriod.Value = value; }
	public int StopLossPoints { get => _stopLossPoints.Value; set => _stopLossPoints.Value = value; }
	public int TakeProfitPoints { get => _takeProfitPoints.Value; set => _takeProfitPoints.Value = value; }

	public EnvelopesEaStrategy()
	{
		_fastPeriod = Param(nameof(FastPeriod), 14).SetGreaterThanZero().SetDisplay("Fast Period", "Fast EMA period", "Indicator");
		_slowPeriod = Param(nameof(SlowPeriod), 50).SetGreaterThanZero().SetDisplay("Slow Period", "Slow EMA period", "Indicator");
		_stopLossPoints = Param(nameof(StopLossPoints), 200).SetNotNegative().SetDisplay("Stop Loss", "Stop-loss in price steps", "Risk");
		_takeProfitPoints = Param(nameof(TakeProfitPoints), 400).SetNotNegative().SetDisplay("Take Profit", "Take-profit in price steps", "Risk");
	}

	public override IEnumerable<(Security sec, DataType dt)> GetWorkingSecurities()
	{
		yield return (Security, TimeSpan.FromMinutes(5).TimeFrame());
	}

	protected override void OnReseted()
	{
		base.OnReseted();
		_fast = null; _slow = null;
		_prevFast = 0; _prevSlow = 0; _entryPrice = 0; _cooldown = 0;
	}

	protected override void OnStarted2(DateTime time)
	{
		base.OnStarted2(time);
		_fast = new ExponentialMovingAverage { Length = FastPeriod };
		_slow = new ExponentialMovingAverage { Length = SlowPeriod };
		var subscription = SubscribeCandles(TimeSpan.FromMinutes(5).TimeFrame());
		subscription.Bind(_fast, _slow, ProcessCandle);
		subscription.Start();
	}

	private void ProcessCandle(ICandleMessage candle, decimal fastValue, decimal slowValue)
	{
		if (candle.State != CandleStates.Finished) return;
		if (!_fast.IsFormed || !_slow.IsFormed) { _prevFast = fastValue; _prevSlow = slowValue; return; }
		if (_cooldown > 0) { _cooldown--; _prevFast = fastValue; _prevSlow = slowValue; return; }

		var close = candle.ClosePrice;
		var step = Security?.PriceStep ?? 1m;

		if (Position > 0 && _entryPrice > 0)
		{
			if (StopLossPoints > 0 && close <= _entryPrice - StopLossPoints * step) { SellMarket(); _entryPrice = 0; _cooldown = 100; _prevFast = fastValue; _prevSlow = slowValue; return; }
			if (TakeProfitPoints > 0 && close >= _entryPrice + TakeProfitPoints * step) { SellMarket(); _entryPrice = 0; _cooldown = 100; _prevFast = fastValue; _prevSlow = slowValue; return; }
		}
		else if (Position < 0 && _entryPrice > 0)
		{
			if (StopLossPoints > 0 && close >= _entryPrice + StopLossPoints * step) { BuyMarket(); _entryPrice = 0; _cooldown = 100; _prevFast = fastValue; _prevSlow = slowValue; return; }
			if (TakeProfitPoints > 0 && close <= _entryPrice - TakeProfitPoints * step) { BuyMarket(); _entryPrice = 0; _cooldown = 100; _prevFast = fastValue; _prevSlow = slowValue; return; }
		}

		if (_prevFast <= _prevSlow && fastValue > slowValue && Position <= 0)
		{ if (Position < 0) BuyMarket(); BuyMarket(); _entryPrice = close; _cooldown = 100; }
		else if (_prevFast >= _prevSlow && fastValue < slowValue && Position >= 0)
		{ if (Position > 0) SellMarket(); SellMarket(); _entryPrice = close; _cooldown = 100; }

		_prevFast = fastValue; _prevSlow = slowValue;
	}
}