Español ES
Ver en GitHub

EMA Estrategia de retroceso

Descripción general

La estrategia de retroceso EMA es una adaptación de alto nivel del asesor experto MetaTrader "Ema". Observa un par de promedios móviles exponenciales (EMA) con los períodos 5 y 10 calculados sobre los precios medios de las velas. Cuando aparece un cruce alcista o bajista, la estrategia espera a que el precio retroceda hacia el extremo de la vela anterior antes de entrar en la dirección del cruce. Los niveles fijos de toma de ganancias y límite de pérdidas medidos en puntos de precio gestionan el riesgo una vez que la posición está abierta.

Lógica de trading

  1. Suscríbase a la serie de velas configurada (predeterminado: período de tiempo de 5 minutos) y calcule dos EMA en el precio medio (high + low) / 2.
  2. Detecta un cruce alcista cuando el EMA rápido cruza por encima del EMA lento, o un cruce bajista cuando el EMA rápido cruza por debajo del } lento.
  3. Armar una entrada de retroceso después de que ocurra el cruce:
    • Para una configuración larga, espere hasta que el precio de cierre retroceda hasta el máximo de la vela anterior menos el desplazamiento MoveBackPoints mientras el EMA rápido permanece por encima del EMA lento en al menos dos puntos de precio.
    • Para una configuración corta, espere hasta que el precio de cierre vuelva al mínimo de la vela anterior más el MoveBackPoints compensado mientras el EMA lento se mantiene por encima del EMA rápido en al menos dos puntos de precio.
  4. Cuando se cumpla la condición de retroceso, envíe una orden de mercado con el volumen comercial configurado.
  5. Al ingresar, calcule los niveles estáticos de toma de ganancias y límite de pérdidas usando las configuraciones TakeProfitPoints y StopLossPoints, convertidos en compensaciones de precio absoluto del precio de entrada.
  6. Supervise cada vela terminada y cierre la posición una vez que el máximo o mínimo de la vela toque el nivel de toma de ganancias o de stop-loss.

Parámetros

Nombre Predeterminado Descripción
TradeVolume 0.1 Volumen utilizado para cada orden de mercado.
FastLength 5 Periodo de la EMA rápida aplicado a los precios medianos.
SlowLength 10 Período de lentitud EMA aplicado a los precios medios.
MoveBackPoints 3 Distancia de retroceso, en puntos de precio, medida desde el extremo de la vela anterior.
TakeProfitPoints 5 Distancia de obtención de beneficios, en puntos de precio.
StopLossPoints 20 Distancia de stop-loss, en puntos de precio.
CandleType 5m Marco de tiempo utilizado para la suscripción de velas y los cálculos de indicadores.

Notas

  • Sólo se procesan velas completamente formadas para evitar señales prematuras.
  • La estrategia alinea automáticamente la propiedad Strategy.Volume con el parámetro TradeVolume al inicio.
  • Todos los cálculos se basan en el instrumento PriceStep para convertir distancias basadas en puntos en precios absolutos.
  • La estrategia abre como máximo una posición a la vez y requiere un nuevo cruce EMA antes de preparar otra operación.
using System;
using System.Collections.Generic;

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

namespace StockSharp.Samples.Strategies;

/// <summary>
/// EMA Pullback strategy - fast/slow EMA crossover with pullback entry.
/// After a bullish crossover, waits for a pullback to fast EMA to enter long.
/// After a bearish crossover, waits for a pullback to fast EMA to enter short.
/// </summary>
public class EmaPullbackStrategy : Strategy
{
	private readonly StrategyParam<int> _fastPeriod;
	private readonly StrategyParam<int> _slowPeriod;
	private readonly StrategyParam<DataType> _candleType;

	private decimal _prevFast;
	private decimal _prevSlow;
	private decimal _prevClose;
	private bool _hasPrev;
	private bool _bullishCross;
	private bool _bearishCross;

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

	public EmaPullbackStrategy()
	{
		_fastPeriod = Param(nameof(FastPeriod), 8)
			.SetDisplay("Fast EMA", "Fast EMA period", "Indicators");

		_slowPeriod = Param(nameof(SlowPeriod), 21)
			.SetDisplay("Slow EMA", "Slow EMA period", "Indicators");

		_candleType = Param(nameof(CandleType), TimeSpan.FromHours(4).TimeFrame())
			.SetDisplay("Candle Type", "Candle timeframe", "General");
	}

	public override IEnumerable<(Security sec, DataType dt)> GetWorkingSecurities() => [(Security, CandleType)];
	protected override void OnReseted() { base.OnReseted(); _prevFast = 0m; _prevSlow = 0m; _prevClose = 0m; _hasPrev = false; _bullishCross = false; _bearishCross = false; }

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

		_hasPrev = false;
		_bullishCross = false;
		_bearishCross = false;

		var fast = new ExponentialMovingAverage { Length = FastPeriod };
		var slow = new ExponentialMovingAverage { Length = SlowPeriod };

		var subscription = SubscribeCandles(CandleType);
		subscription
			.Bind(fast, slow, ProcessCandle)
			.Start();
	}

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

		var close = candle.ClosePrice;

		if (!_hasPrev)
		{
			_prevFast = fast;
			_prevSlow = slow;
			_prevClose = close;
			_hasPrev = true;
			return;
		}

		// Detect crossovers
		if (_prevFast <= _prevSlow && fast > slow)
		{
			_bullishCross = true;
			_bearishCross = false;
		}
		else if (_prevFast >= _prevSlow && fast < slow)
		{
			_bearishCross = true;
			_bullishCross = false;
		}

		// Pullback entry: after bullish cross, wait for close to touch fast EMA
		if (_bullishCross && fast > slow && _prevClose > _prevFast && close <= fast && Position <= 0)
		{
			if (Position < 0)
				BuyMarket();
			BuyMarket();
			_bullishCross = false;
		}
		// Pullback entry: after bearish cross, wait for close to touch fast EMA
		else if (_bearishCross && fast < slow && _prevClose < _prevFast && close >= fast && Position >= 0)
		{
			if (Position > 0)
				SellMarket();
			SellMarket();
			_bearishCross = false;
		}
		// Exit on opposite crossover
		else if (Position > 0 && fast < slow)
		{
			SellMarket();
		}
		else if (Position < 0 && fast > slow)
		{
			BuyMarket();
		}

		_prevFast = fast;
		_prevSlow = slow;
		_prevClose = close;
	}
}