Português PT
Ver no GitHub

Estratégia PricerEA

Visão geral

A Estratégia PricerEA recria o comportamento do MetaTrader 4 especialista "PricerEA v1.0" usando o StockSharp API de alto nível. Ele coloca até quatro ordens pendentes (stop de compra, stop de venda, limite de compra e limite de venda) em níveis de preços definidos manualmente. Uma vez qualquer ordem pendente é preenchida, a estratégia anexa ordens protetoras de stop-loss e take-profit, habilitando opcionalmente um trailing stop e ajuste de ponto de equilíbrio para seguir o Expert Advisor original.

Como funciona

  1. Ordens pendentes – a estratégia lê os níveis de preços absolutos das entradas e envia apenas as ordens pendentes correspondentes uma vez na inicialização. A expiração opcional pode ser configurada em minutos.
  2. Seleção de volume – os usuários podem manter o tamanho de lote manual fixo ou mudar para o modo automático de onde o volume é derivado o saldo da carteira e o análogo do fator de risco MT4.
  3. Proteção – depois que uma ordem de entrada é preenchida, a estratégia cria ordens de stop-loss e take-profit na distância configurada (expresso em faixas de preço). Quando o trailing e o ponto de equilíbrio estão ativados, o stop segue as condições originais MQL: é movido somente depois que o preço cobriu a distância do ponto de equilíbrio mais o stop inicial.
  4. Manutenção de pedidos – os pedidos pendentes são cancelados automaticamente quando seu tempo de vida expira ou quando a estratégia é interrompida.

Parâmetros

Parâmetro Descrição
BuyStopPrice, SellStopPrice, BuyLimitPrice, SellLimitPrice Preços absolutos para as ordens pendentes correspondentes. Um valor de 0 desativa o pedido.
TakeProfitPoints Distância do preço de entrada até a ordem take-profit, medida em faixas de preço (Security.PriceStep).
StopLossPoints Distância do preço de entrada até a ordem stop-loss, também medida em pontos de preço.
EnableTrailingStop Ativa a lógica de trailing stop.
TrailingStepPoints Movimento mínimo (em pontos) necessário antes do stop móvel ser movido.
EnableBreakEven Ativa a regra de ponto de equilíbrio que eleva o stop acima/abaixo da entrada após lucro suficiente.
BreakEvenTriggerPoints Lucro extra (pontos) necessário antes que o stop seja movido para atingir o ponto de equilíbrio.
PendingExpiryMinutes Vida útil das ordens pendentes em minutos. 0 os mantém ativos até serem preenchidos ou cancelados manualmente.
VolumeMode Escolhe entre volume manual e dimensionamento automático.
RiskFactor Multiplicador de risco usado pelo dimensionamento automático (espelha a entrada MQL).
ManualVolume Tamanho de lote fixo usado quando VolumeMode é definido como Manual.

Diferenças versus a versão MT4

  • O cálculo automático do volume utiliza o saldo do portfólio StockSharp e o multiplicador do contrato de segurança. Corretores diferentes pode usar fórmulas distintas, portanto o valor resultante pode ser ligeiramente diferente de MetaTrader.
  • As ordens de proteção são feitas por meio de ajudantes StockSharp e respeitam a etapa de volume do local, volume mínimo e máximo.
  • A expiração é implementada dentro da estratégia (MetaTrader depende da expiração do pedido no lado do servidor).

Notas de uso

  • Configure os níveis de preços antes de iniciar a estratégia. Valores iguais a zero deixam a ordem correspondente desabilitada.
  • Para imitar a lógica de "dígitos" do MT4, os parâmetros baseados em pontos operam em unidades Security.PriceStep.
  • Combine a estratégia com o portfólio e ferramentas de registro de StockSharp para monitorar ordens pendentes e paradas protetoras.
namespace StockSharp.Samples.Strategies;

using System;
using Ecng.Common;
using StockSharp.Algo.Indicators;
using StockSharp.Algo.Strategies;
using StockSharp.Messages;

/// <summary>
/// PricerEA strategy: Bollinger Bands mean reversion with RSI filter.
/// Buys at lower band when RSI is oversold, sells at upper band when overbought.
/// </summary>
public class PricerEaStrategy : Strategy
{
	private readonly StrategyParam<DataType> _candleType;
	private readonly StrategyParam<int> _bbPeriod;
	private readonly StrategyParam<int> _rsiPeriod;
	private readonly StrategyParam<int> _atrPeriod;
	private readonly StrategyParam<int> _signalCooldownCandles;
	private int _candlesSinceTrade;

	public DataType CandleType { get => _candleType.Value; set => _candleType.Value = value; }
	public int BbPeriod { get => _bbPeriod.Value; set => _bbPeriod.Value = value; }
	public int RsiPeriod { get => _rsiPeriod.Value; set => _rsiPeriod.Value = value; }
	public int AtrPeriod { get => _atrPeriod.Value; set => _atrPeriod.Value = value; }
	public int SignalCooldownCandles { get => _signalCooldownCandles.Value; set => _signalCooldownCandles.Value = value; }

	public PricerEaStrategy()
	{
		_candleType = Param(nameof(CandleType), TimeSpan.FromMinutes(30).TimeFrame())
			.SetDisplay("Candle Type", "Candle timeframe", "General");
		_bbPeriod = Param(nameof(BbPeriod), 20)
			.SetGreaterThanZero()
			.SetDisplay("BB Period", "Bollinger Bands period", "Indicators");
		_rsiPeriod = Param(nameof(RsiPeriod), 14)
			.SetGreaterThanZero()
			.SetDisplay("RSI Period", "RSI period", "Indicators");
		_atrPeriod = Param(nameof(AtrPeriod), 14)
			.SetGreaterThanZero()
			.SetDisplay("ATR Period", "ATR period for adaptive band distance", "Indicators");
		_signalCooldownCandles = Param(nameof(SignalCooldownCandles), 8)
			.SetGreaterThanZero()
			.SetDisplay("Signal Cooldown", "Bars to wait between trades", "Trading");
	}

	/// <inheritdoc />
	protected override void OnReseted()
	{
		base.OnReseted();
		_candlesSinceTrade = SignalCooldownCandles;
	}

	/// <inheritdoc />
	protected override void OnStarted2(DateTime time)
	{
		base.OnStarted2(time);
		_candlesSinceTrade = SignalCooldownCandles;
		var sma = new SimpleMovingAverage { Length = BbPeriod };
		var rsi = new RelativeStrengthIndex { Length = RsiPeriod };
		var atr = new AverageTrueRange { Length = AtrPeriod };
		var subscription = SubscribeCandles(CandleType);
		subscription.Bind(sma, rsi, atr, ProcessCandle).Start();
	}

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

		var close = candle.ClosePrice;
		var bandDistance = atr * 2.5m;

		if (_candlesSinceTrade < SignalCooldownCandles)
			_candlesSinceTrade++;

		if (Position > 0 && (close >= sma || rsi >= 50))
		{
			SellMarket();
			_candlesSinceTrade = 0;
		}
		else if (Position < 0 && (close <= sma || rsi <= 50))
		{
			BuyMarket();
			_candlesSinceTrade = 0;
		}
		else if (Position == 0 && _candlesSinceTrade >= SignalCooldownCandles && close <= sma - bandDistance && rsi < 30)
		{
			BuyMarket();
			_candlesSinceTrade = 0;
		}
		else if (Position == 0 && _candlesSinceTrade >= SignalCooldownCandles && close >= sma + bandDistance && rsi > 70)
		{
			SellMarket();
			_candlesSinceTrade = 0;
		}
	}
}