Español ES
Ver en GitHub

Estrategia cm RSI

Descripción general

Esta estrategia es un port directo del experto de MetaTrader 4 "cm_RSI". Utiliza el indicador de Fuerza Relativa (RSI) para detectar reversiones de momentum.

El algoritmo monitorea los valores del RSI calculados a partir de los precios de apertura de las velas. Una posición larga se abre cuando el RSI sube por encima de un nivel de compra configurable después de estar por debajo. Una posición corta se abre cuando el RSI cae por debajo de un nivel de venta configurable después de estar por encima. Cada operación está protegida por valores fijos de take profit y stop loss expresados en puntos de precio.

Lógica de la estrategia

  1. Calcular el RSI con un período definido por el usuario usando los precios de apertura de las velas.
  2. Si el valor anterior del RSI estaba por debajo del nivel de compra y el valor actual cruza por encima, abrir una posición larga a mercado.
  3. Si el valor anterior del RSI estaba por encima del nivel de venta y el valor actual cruza por debajo, abrir una posición corta a mercado.
  4. Cada operación usa el mismo volumen configurable y está protegida con órdenes de stop loss y take profit.

Parámetros

Nombre Descripción
RsiPeriod Período de cálculo del RSI.
BuyLevel Nivel de RSI utilizado para disparar entradas largas.
SellLevel Nivel de RSI utilizado para disparar entradas cortas.
TakeProfit Take profit en puntos de precio absolutos.
StopLoss Stop loss en puntos de precio absolutos.
OrderVolume Volumen aplicado a cada operación.
CandleType Tipo de velas utilizadas para los cálculos.

Notas

  • La estrategia procesa solo velas terminadas.
  • Mantiene una única posición abierta en cualquier momento.
  • StartProtection se utiliza para gestionar automáticamente las órdenes de stop loss y take profit.
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;

/// <summary>
/// Strategy based on RSI cross signals from the original cm_RSI expert.
/// </summary>
public class CmRsiStrategy : Strategy
{
	private readonly StrategyParam<int> _rsiPeriod;
	private readonly StrategyParam<decimal> _buyLevel;
	private readonly StrategyParam<decimal> _sellLevel;
	private readonly StrategyParam<int> _takeProfit;
	private readonly StrategyParam<int> _stopLoss;
	private readonly StrategyParam<decimal> _orderVolume;
	private readonly StrategyParam<DataType> _candleType;

	private decimal _prevRsi;
	private bool _isFirst = true;

	/// <summary>
	/// RSI calculation period.
	/// </summary>
	public int RsiPeriod { get => _rsiPeriod.Value; set => _rsiPeriod.Value = value; }

	/// <summary>
	/// RSI level to trigger long entries.
	/// </summary>
	public decimal BuyLevel { get => _buyLevel.Value; set => _buyLevel.Value = value; }

	/// <summary>
	/// RSI level to trigger short entries.
	/// </summary>
	public decimal SellLevel { get => _sellLevel.Value; set => _sellLevel.Value = value; }

	/// <summary>
	/// Take profit in price points.
	/// </summary>
	public int TakeProfit { get => _takeProfit.Value; set => _takeProfit.Value = value; }

	/// <summary>
	/// Stop loss in price points.
	/// </summary>
	public int StopLoss { get => _stopLoss.Value; set => _stopLoss.Value = value; }

	/// <summary>
	/// Volume applied to each trade.
	/// </summary>
	public decimal OrderVolume { get => _orderVolume.Value; set => _orderVolume.Value = value; }

	/// <summary>
	/// Candle type for calculations.
	/// </summary>
	public DataType CandleType { get => _candleType.Value; set => _candleType.Value = value; }

	/// <summary>
	/// Initialize <see cref="CmRsiStrategy"/>.
	/// </summary>
	public CmRsiStrategy()
	{
		_rsiPeriod = Param(nameof(RsiPeriod), 14)
			.SetGreaterThanZero()
			.SetDisplay("RSI Period", "RSI calculation period", "Indicators")
			
			.SetOptimize(7, 21, 1);

		_buyLevel = Param(nameof(BuyLevel), 30m)
			.SetDisplay("Buy Level", "RSI level to enter long", "Indicators")
			
			.SetOptimize(10m, 40m, 5m);

		_sellLevel = Param(nameof(SellLevel), 70m)
			.SetDisplay("Sell Level", "RSI level to enter short", "Indicators")
			
			.SetOptimize(60m, 90m, 5m);

		_takeProfit = Param(nameof(TakeProfit), 200)
			.SetDisplay("Take Profit", "Take profit in price points", "Risk Management")
			
			.SetOptimize(100, 400, 50);

		_stopLoss = Param(nameof(StopLoss), 100)
			.SetDisplay("Stop Loss", "Stop loss in price points", "Risk Management")
			
			.SetOptimize(50, 200, 50);

		_orderVolume = Param(nameof(OrderVolume), 0.1m)
			.SetGreaterThanZero()
			.SetDisplay("Order Volume", "Volume of each trade", "General")
			
			.SetOptimize(0.1m, 1m, 0.1m);

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

	/// <inheritdoc />
	public override IEnumerable<(Security sec, DataType dt)> GetWorkingSecurities()
	{
		return [(Security, CandleType)];
	}

	/// <inheritdoc />
	protected override void OnReseted()
	{
		base.OnReseted();
		_prevRsi = 0;
		_isFirst = true;
	}

	/// <inheritdoc />
	protected override void OnStarted2(DateTime time)
	{
		base.OnStarted2(time);

		_isFirst = true;
		_prevRsi = 0;

		var rsi = new RelativeStrengthIndex { Length = RsiPeriod };

		var subscription = SubscribeCandles(CandleType);
		subscription
			.Bind(rsi, ProcessCandle)
			.Start();

		var area = CreateChartArea();
		if (area != null)
		{
			DrawCandles(area, subscription);
			DrawIndicator(area, rsi);
			DrawOwnTrades(area);
		}
	}

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

		if (!IsFormedAndOnlineAndAllowTrading())
		{
			_prevRsi = rsiValue;
			_isFirst = false;
			return;
		}

		if (_isFirst)
		{
			_prevRsi = rsiValue;
			_isFirst = false;
			return;
		}

		// Open long when RSI crosses above buy level
		if (_prevRsi < BuyLevel && rsiValue > BuyLevel && Position <= 0)
			BuyMarket();

		// Open short when RSI crosses below sell level
		if (_prevRsi > SellLevel && rsiValue < SellLevel && Position >= 0)
			SellMarket();

		_prevRsi = rsiValue;
	}
}