Português PT
Ver no GitHub

Estratégia cm RSI

Visão geral

Esta estratégia é um port direto do especialista MetaTrader 4 "cm_RSI". Usa o indicador de Força Relativa (RSI) para capturar reversões de momentum.

O algoritmo monitora os valores do RSI calculados a partir dos preços de abertura das velas. Uma posição comprada é aberta quando o RSI sobe acima de um nível de compra configurável após estar abaixo. Uma posição vendida é aberta quando o RSI cai abaixo de um nível de venda configurável após estar acima. Cada negociação é protegida por valores fixos de take profit e stop loss expressos em pontos de preço.

Lógica da estratégia

  1. Calcular o RSI com um período definido pelo usuário usando os preços de abertura das velas.
  2. Se o valor anterior do RSI estava abaixo do nível de compra e o valor atual cruza acima, abrir uma posição comprada a mercado.
  3. Se o valor anterior do RSI estava acima do nível de venda e o valor atual cruza abaixo, abrir uma posição vendida a mercado.
  4. Cada negociação usa o mesmo volume configurável e é protegida com ordens de stop loss e take profit.

Parâmetros

Nome Descrição
RsiPeriod Período de cálculo do RSI.
BuyLevel Nível do RSI usado para acionar entradas compradas.
SellLevel Nível do RSI usado para acionar entradas vendidas.
TakeProfit Take profit em pontos de preço absolutos.
StopLoss Stop loss em pontos de preço absolutos.
OrderVolume Volume aplicado a cada negociação.
CandleType Tipo de velas usadas para os cálculos.

Notas

  • A estratégia processa apenas velas concluídas.
  • Mantém uma única posição aberta a qualquer momento.
  • StartProtection é usado para gerenciar automaticamente as ordens de stop loss e 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;
	}
}