Español ES
Ver en GitHub

Estrategia de Cronex RSI

La Estrategia de Cronex RSI recrea el asesor experto Exp_CronexRSI.mq5 en la API de alto nivel de StockSharp. La pila de indicadores combina un Índice de Fuerza Relativa (RSI) clásico con dos medias móviles secuenciales para reducir el ruido. Las decisiones de trading se basan en cruces entre las curvas RSI suavizadas rápida y lenta, con permisos de entrada/salida configurables que coinciden con los parámetros MQL5 originales.

Lógica de trading

  1. Construir el RSI desde el precio aplicado y el período de retroceso seleccionados.
  2. Suavizar el valor RSI con una media móvil rápida, luego suavizar el resultado con una media móvil lenta.
  3. Evaluar cruces con un desplazamiento de confirmación configurable:
    • Cuando la curva rápida estaba por encima de la curva lenta una barra antes y cae por debajo en la barra confirmada, la estrategia cierra posiciones cortas y, si está habilitado, abre una posición larga.
    • Cuando la curva rápida estaba por debajo de la curva lenta y cruza por encima en la barra confirmada, la estrategia cierra posiciones largas y puede entrar en operaciones cortas.
  4. Los volúmenes son simétricos en ambas direcciones. Cuando una nueva señal revierte la posición, la estrategia primero cubre la exposición existente y luego abre el nuevo lado usando el volumen base configurado.

Por defecto la estrategia espera una vela completamente cerrada antes de actuar sobre una señal, reproduciendo el comportamiento SignalBar = 1 de Exp_CronexRSI. Establecer el desplazamiento en cero procesa el cruce inmediatamente en la barra de cierre.

Parámetros

Nombre Descripción
RsiPeriod Período de retroceso RSI.
FastPeriod Longitud de la media móvil de suavizado rápido.
SlowPeriod Longitud de la segunda media móvil de suavizado.
SignalShift Número de barras completadas utilizadas para confirmación (0 reacciona instantáneamente).
SmoothingMethod Tipo de media móvil aplicado durante ambas etapas de suavizado (simple, exponencial, suavizada, ponderada linealmente, ponderada por volumen).
AppliedPrice Componente de precio pasado al RSI (cierre, apertura, máximo, mínimo, mediana, típico, ponderado).
CandleType Serie de velas procesada por la estrategia.
TradeVolume Tamaño de orden base utilizado para nuevas entradas.
EnableLongEntry / EnableShortEntry Permitir abrir posiciones largas/cortas.
EnableLongExit / EnableShortExit Permitir cerrar posiciones en respuesta a señales opuestas.

Notas de implementación

  • El método de suavizado utiliza clases de media móvil de StockSharp. La opción VolumeWeighted también cubre los estilos VIDYA/AMA de MQL5 aplicando un sustituto pragmático ponderado por volumen.
  • La selección de precio aplicado coincide con las entradas del indicador Cronex y refleja el asistente utilizado dentro del asesor experto original.
  • Todos los valores de indicadores se procesan a través de instancias DecimalIndicatorValue para permanecer compatibles con la tubería de indicadores de StockSharp mientras se evita el sondeo directo de valores.
  • La estrategia redimensiona automáticamente su historial interno cuando cambia el desplazamiento de confirmación, asegurando que la lógica de cruce mantenga la estructura exacta de retroceso de la versión MQL5.

Uso

  1. Adjuntar la estrategia a una cartera y valor en el diseñador de StockSharp o mediante código.
  2. Configurar el marco temporal de velas, el estilo de suavizado y los permisos de trading para que coincidan con la configuración preferida de Cronex RSI.
  3. Lanzar la estrategia. Se suscribirá a la serie de velas seleccionada, actualizará la combinación RSI/MA y enviará órdenes a mercado en cruces confirmados.
  4. Usar los asistentes de gráficos integrados para visualizar las curvas de indicadores y las operaciones ejecutadas para mayor validación.
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 CronexRsiStrategy : 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 CronexRsiStrategy()
	{
		_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;
	}
}