Português PT
Ver no GitHub

Estratégia Bruno

O assessor especialista Bruno é um sistema de seguidor de tendência originalmente escrito para MetaTrader 5. O porte mantém a mesma cadeia de confirmação: Average Directional Index (ADX) com movimento direcional, um par de médias móvies exponenciais (EMA 8/21), MACD (13, 34, 8), um Oscilador Estocástico (21, 3, 3) e a inclinação de um Parabolic SAR (0.055, 0.21). Cada filtro que concorda com a direção multiplica o tamanho da ordem por um fator configurável. Se tanto os sinais comprados quanto os vendidos forem amplificados na mesma vela, o trading é ignorado para evitar ordens conflitantes.

Lógica de trading

  • Viés direcional
    • A pressão comprada é fortalecida quando +DI > -DI e +DI > 20.
    • A pressão vendida é fortalecida quando +DI < -DI e +DI < 40.
  • Alinhamento de momentum
    • A preferência comprada requer EMA(8) acima de EMA(21), Estocástico %K acima de %D e %K abaixo do limite de sobrecomprado (padrão 80).
    • A preferência vendida requer EMA(8) abaixo de EMA(21), Estocástico %K abaixo de %D e %K acima do limite de sobrevendido (padrão 20).
  • Filtro MACD
    • Viés comprado: histograma MACD acima de zero e linha principal MACD acima da linha de sinal.
    • Viés vendido: histograma MACD abaixo de zero e linha principal MACD abaixo da linha de sinal.
  • Inclinação do Parabolic SAR
    • O viés comprado é reforçado quando os valores anteriores do SAR estão subindo enquanto EMA(8) > EMA(21).
    • O viés vendido é reforçado quando os valores anteriores do SAR estão caindo enquanto EMA(8) < EMA(21).

Cada condição satisfeita multiplica o tamanho do lote base por SignalMultiplier (padrão 1.6). Apenas um lado pode estar ativo de cada vez. Quando um sinal final é gerado, a estratégia fecha qualquer posição oposta, envia a ordem a mercado com o volume multiplicado e armazena o fechamento atual como preço de entrada.

Gestão de posições

  • Stop-loss / take-profit – distâncias fixas expressas em pips ajustados, correspondendo à versão MetaTrader. Se qualquer nível for atingido intrabarra, a posição é fechada imediatamente.
  • Trailing stop – ativa quando o lucro flutuante excede TrailingStop + TrailingStep pips. O stop é então colocado TrailingStop pips atrás do preço e só avança quando o ganho aumenta pelo menos mais TrailingStep pips.
  • Tratamento de conflito – se ambos os filtros comprado e vendido dispararem na mesma vela, nenhuma nova operação é tomada.

Parâmetros

Grupo Nome Descrição
Trading BaseVolume Tamanho inicial do lote antes dos multiplicadores.
Trading SignalMultiplier Multiplicador de volume aplicado por cada filtro coincidente.
Gestão de risco StopLossPips / TakeProfitPips Distâncias de proteção em pips ajustados. Defina como zero para desabilitar.
Gestão de risco TrailingStopPips / TrailingStepPips Distância de trailing e passo mínimo em pips ajustados.
Indicadores AdxPeriod, AdxPositiveThreshold, AdxNegativeThreshold Comprimento do ADX e limites do DI.
Indicadores FastEmaPeriod, SlowEmaPeriod Comprimentos de EMA usados na confirmação de tendência.
Indicadores MacdFastPeriod, MacdSlowPeriod, MacdSignalPeriod Configuração do MACD.
Indicadores StochasticPeriod, StochasticKsmoothing, StochasticDsmoothing, StochasticOverbought, StochasticOversold Configurações do oscilador estocástico.
Geral CandleType Período usado para toda a cadeia de sinais (padrão 1 hora).

Notas

  • O tamanho de pip ajustado segue a convenção do MetaTrader: instrumentos com 3 ou 5 dígitos decimais são multiplicados por 10.
  • O Parabolic SAR opera com passo de aceleração 0.055 e máximo 0.21, espelhando os padrões do assessor especialista.
  • O porte mantém o estilo de gerenciamento de capital original (empilhamento de volume) mas agrega a exposição em uma única posição do StockSharp.
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>
/// Bruno trend-following strategy using EMA crossover with trend filter.
/// Buys when fast EMA crosses above slow EMA with price above trend EMA.
/// Sells on reverse conditions.
/// </summary>
public class BrunoStrategy : Strategy
{
	private readonly StrategyParam<int> _fastPeriod;
	private readonly StrategyParam<int> _slowPeriod;
	private readonly StrategyParam<int> _trendPeriod;
	private readonly StrategyParam<int> _stopLossPoints;
	private readonly StrategyParam<int> _takeProfitPoints;

	private ExponentialMovingAverage _fast;
	private ExponentialMovingAverage _slow;
	private ExponentialMovingAverage _trend;

	private decimal _prevFast;
	private decimal _prevSlow;
	private decimal _entryPrice;
	private int _cooldown;

	/// <summary>
	/// Fast EMA period.
	/// </summary>
	public int FastPeriod
	{
		get => _fastPeriod.Value;
		set => _fastPeriod.Value = value;
	}

	/// <summary>
	/// Slow EMA period.
	/// </summary>
	public int SlowPeriod
	{
		get => _slowPeriod.Value;
		set => _slowPeriod.Value = value;
	}

	/// <summary>
	/// Trend EMA period.
	/// </summary>
	public int TrendPeriod
	{
		get => _trendPeriod.Value;
		set => _trendPeriod.Value = value;
	}

	/// <summary>
	/// Stop-loss distance in price steps.
	/// </summary>
	public int StopLossPoints
	{
		get => _stopLossPoints.Value;
		set => _stopLossPoints.Value = value;
	}

	/// <summary>
	/// Take-profit distance in price steps.
	/// </summary>
	public int TakeProfitPoints
	{
		get => _takeProfitPoints.Value;
		set => _takeProfitPoints.Value = value;
	}

	/// <summary>
	/// Initializes a new instance of the <see cref="BrunoStrategy"/> class.
	/// </summary>
	public BrunoStrategy()
	{
		_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");

		_trendPeriod = Param(nameof(TrendPeriod), 200)
			.SetGreaterThanZero()
			.SetDisplay("Trend Period", "Trend 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");
	}

	/// <inheritdoc />
	public override IEnumerable<(Security sec, DataType dt)> GetWorkingSecurities()
	{
		yield return (Security, TimeSpan.FromMinutes(5).TimeFrame());
	}

	/// <inheritdoc />
	protected override void OnReseted()
	{
		base.OnReseted();

		_fast = null;
		_slow = null;
		_trend = null;
		_prevFast = 0;
		_prevSlow = 0;
		_entryPrice = 0;
		_cooldown = 0;
	}

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

		_fast = new ExponentialMovingAverage { Length = FastPeriod };
		_slow = new ExponentialMovingAverage { Length = SlowPeriod };
		_trend = new ExponentialMovingAverage { Length = TrendPeriod };

		var subscription = SubscribeCandles(TimeSpan.FromMinutes(5).TimeFrame());
		subscription.Bind(_fast, _slow, _trend, ProcessCandle);
		subscription.Start();
	}

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

		if (!_fast.IsFormed || !_slow.IsFormed || !_trend.IsFormed)
		{
			_prevFast = fastValue;
			_prevSlow = slowValue;
			return;
		}

		if (_cooldown > 0)
		{
			_cooldown--;
			_prevFast = fastValue;
			_prevSlow = slowValue;
			return;
		}

		var close = candle.ClosePrice;
		var step = Security?.PriceStep ?? 1m;

		// Check SL/TP
		if (Position > 0 && _entryPrice > 0)
		{
			if (StopLossPoints > 0 && close <= _entryPrice - StopLossPoints * step)
			{
				SellMarket();
				_entryPrice = 0;
				_cooldown = 80;
				_prevFast = fastValue;
				_prevSlow = slowValue;
				return;
			}

			if (TakeProfitPoints > 0 && close >= _entryPrice + TakeProfitPoints * step)
			{
				SellMarket();
				_entryPrice = 0;
				_cooldown = 80;
				_prevFast = fastValue;
				_prevSlow = slowValue;
				return;
			}
		}
		else if (Position < 0 && _entryPrice > 0)
		{
			if (StopLossPoints > 0 && close >= _entryPrice + StopLossPoints * step)
			{
				BuyMarket();
				_entryPrice = 0;
				_cooldown = 80;
				_prevFast = fastValue;
				_prevSlow = slowValue;
				return;
			}

			if (TakeProfitPoints > 0 && close <= _entryPrice - TakeProfitPoints * step)
			{
				BuyMarket();
				_entryPrice = 0;
				_cooldown = 80;
				_prevFast = fastValue;
				_prevSlow = slowValue;
				return;
			}
		}

		// EMA crossover with trend filter
		if (_prevFast <= _prevSlow && fastValue > slowValue && close > trendValue && Position <= 0)
		{
			if (Position < 0)
				BuyMarket();

			BuyMarket();
			_entryPrice = close;
			_cooldown = 80;
		}
		else if (_prevFast >= _prevSlow && fastValue < slowValue && close < trendValue && Position >= 0)
		{
			if (Position > 0)
				SellMarket();

			SellMarket();
			_entryPrice = close;
			_cooldown = 80;
		}

		_prevFast = fastValue;
		_prevSlow = slowValue;
	}
}