Esta estratégia reproduz o especialista MetaTrader Expert_ABC_WS_Stoch.mq5, que combina padrões clássicos de reversão de três velas com confirmação do oscilador Stochastic. Um sinal longo requer a formação de alta dos "Três Soldados Brancos" junto com uma linha de sinal de sobrevenda Stochastic, enquanto um sinal curto depende dos "Três Corvos Negros" de baixa confirmados por um Stochastic sobrecomprado. A lógica de saída monitora cruzamentos da linha de sinal através de bandas configuráveis para fechar posições.
Lógica de negociação
Detecção de padrões
Acompanhe as últimas três velas concluídas.
Identifique os Três Soldados Brancos quando todas as três velas estiverem otimistas e cada fechamento for maior que o anterior.
Identifique os Três Corvos Negros quando todas as três velas estiverem em baixa e cada fechamento for menor que o anterior.
Confirmação do oscilador
Calcule um oscilador Stochastic com períodos %K, %D e Slowing idênticos ao especialista original (47, 9, 13 por padrão).
Use a linha de sinal (%D) como confirmação:
Insira longo se o valor da linha de sinal anterior estiver abaixo do limite de sobrevenda (padrão 30).
Insira short se o valor da linha de sinal anterior estiver acima do limite de sobrecompra (padrão 70).
Condições de saída
Feche uma negociação longa quando a linha de sinal ultrapassar os limites de saída inferior ou superior (padrão 20 e 80).
Feche uma negociação a descoberto quando a linha de sinal voltar abaixo desses limites.
Ambas as verificações de saída dependem dos valores da linha de sinal anterior e anterior para detectar cruzamentos genuínos.
Parâmetros
Nome
Padrão
Descrição
CandleType
1h período de tempo
Prazo para assinatura da vela.
StochKPeriod
47
Período de lookback para %K.
StochDPeriod
9
Comprimento médio móvel da linha de sinal.
StochSlowing
13
Suavização adicional aplicada a %K.
OversoldLevel
30
Nível de linha de sinal necessário para confirmar uma entrada longa.
OverboughtLevel
70
Nível de linha de sinal necessário para confirmar uma entrada curta.
ExitLowerLevel
20
Limite inferior usado para cruzamentos de saída longos.
ExitUpperLevel
80
Limite superior usado para cruzamentos de saída curtos.
Todos os parâmetros numéricos suportam intervalos de otimização correspondentes ao modelo MetaTrader, para que o comportamento possa ser ajustado por meio do Strategy Designer.
Gerenciamento de ordens
A estratégia inverte posições quando um sinal oposto aparece adicionando o tamanho absoluto da posição atual ao Volume configurado.
StartProtection() está habilitado para integração com os controles de risco da plataforma, embora nenhum nível explícito de stop-loss ou take-profit seja aplicado por padrão.
Visualização
Quando executada dentro do Strategy Designer, a estratégia desenha:
Preço das velas para o símbolo e período selecionados.
O oscilador Stochastic configurado.
Marcadores comerciais para destacar entradas e saídas.
Notas de uso
Confirme se o instrumento fornece histórico suficiente para o oscilador Stochastic aquecer antes de esperar sinais.
Considere combinar a estratégia com filtros de risco adicionais (volatilidade, filtros de sessão, etc.) ao implantar ao vivo.
Os limites são expostos como parâmetros, permitindo a experimentação rápida com diferentes bandas de confirmação sem edição de código.
namespace StockSharp.Samples.Strategies;
using System;
using Ecng.Common;
using StockSharp.Algo.Indicators;
using StockSharp.Algo.Strategies;
using StockSharp.Messages;
/// <summary>
/// Three Soldiers Stochastic strategy: detects three consecutive bullish/bearish candles
/// confirmed by RSI levels.
/// </summary>
public class ThreeSoldiersStochasticStrategy : Strategy
{
private readonly StrategyParam<DataType> _candleType;
private readonly StrategyParam<int> _rsiPeriod;
private readonly StrategyParam<int> _signalCooldownCandles;
private int _bullCount;
private int _bearCount;
private int _candlesSinceTrade;
public DataType CandleType { get => _candleType.Value; set => _candleType.Value = value; }
public int RsiPeriod { get => _rsiPeriod.Value; set => _rsiPeriod.Value = value; }
public int SignalCooldownCandles { get => _signalCooldownCandles.Value; set => _signalCooldownCandles.Value = value; }
public ThreeSoldiersStochasticStrategy()
{
_candleType = Param(nameof(CandleType), TimeSpan.FromMinutes(60).TimeFrame())
.SetDisplay("Candle Type", "Candle timeframe", "General");
_rsiPeriod = Param(nameof(RsiPeriod), 14)
.SetGreaterThanZero()
.SetDisplay("RSI Period", "RSI period for confirmation", "Indicators");
_signalCooldownCandles = Param(nameof(SignalCooldownCandles), 6)
.SetGreaterThanZero()
.SetDisplay("Signal Cooldown", "Bars to wait between trades", "Trading");
}
/// <inheritdoc />
protected override void OnReseted()
{
base.OnReseted();
_bullCount = 0;
_bearCount = 0;
_candlesSinceTrade = SignalCooldownCandles;
}
/// <inheritdoc />
protected override void OnStarted2(DateTime time)
{
base.OnStarted2(time);
_bullCount = 0;
_bearCount = 0;
_candlesSinceTrade = SignalCooldownCandles;
var rsi = new RelativeStrengthIndex { Length = RsiPeriod };
var subscription = SubscribeCandles(CandleType);
subscription.Bind(rsi, ProcessCandle).Start();
}
private void ProcessCandle(ICandleMessage candle, decimal rsi)
{
if (candle.State != CandleStates.Finished) return;
if (_candlesSinceTrade < SignalCooldownCandles)
_candlesSinceTrade++;
if (candle.ClosePrice > candle.OpenPrice)
{
_bullCount++;
_bearCount = 0;
}
else if (candle.ClosePrice < candle.OpenPrice)
{
_bearCount++;
_bullCount = 0;
}
else
{
_bullCount = 0;
_bearCount = 0;
}
if (_bullCount >= 3 && rsi < 65 && Position <= 0 && _candlesSinceTrade >= SignalCooldownCandles)
{
BuyMarket();
_bullCount = 0;
_candlesSinceTrade = 0;
}
else if (_bearCount >= 3 && rsi > 35 && Position >= 0 && _candlesSinceTrade >= SignalCooldownCandles)
{
SellMarket();
_bearCount = 0;
_candlesSinceTrade = 0;
}
}
}
import clr
clr.AddReference("StockSharp.Messages")
clr.AddReference("StockSharp.Algo")
clr.AddReference("StockSharp.Algo.Indicators")
clr.AddReference("StockSharp.Algo.Strategies")
from System import TimeSpan
from StockSharp.Messages import DataType, CandleStates
from StockSharp.Algo.Indicators import RelativeStrengthIndex
from StockSharp.Algo.Strategies import Strategy
class three_soldiers_stochastic_strategy(Strategy):
def __init__(self):
super(three_soldiers_stochastic_strategy, self).__init__()
self._rsi_period = self.Param("RsiPeriod", 14) \
.SetDisplay("RSI Period", "RSI period for confirmation", "Indicators")
self._signal_cooldown = self.Param("SignalCooldownCandles", 6) \
.SetDisplay("Signal Cooldown", "Bars to wait between trades", "Trading")
self._rsi = None
self._bull_count = 0
self._bear_count = 0
self._candles_since_trade = 0
@property
def rsi_period(self):
return self._rsi_period.Value
@property
def signal_cooldown(self):
return self._signal_cooldown.Value
def OnReseted(self):
super(three_soldiers_stochastic_strategy, self).OnReseted()
self._rsi = None
self._bull_count = 0
self._bear_count = 0
self._candles_since_trade = self.signal_cooldown
def OnStarted2(self, time):
super(three_soldiers_stochastic_strategy, self).OnStarted2(time)
self._rsi = RelativeStrengthIndex()
self._rsi.Length = self.rsi_period
self._bull_count = 0
self._bear_count = 0
self._candles_since_trade = self.signal_cooldown
subscription = self.SubscribeCandles(DataType.TimeFrame(TimeSpan.FromMinutes(60)))
subscription.Bind(self._rsi, self._process_candle)
subscription.Start()
def _process_candle(self, candle, rsi_value):
if candle.State != CandleStates.Finished:
return
if not self._rsi.IsFormed:
return
rsi_val = float(rsi_value)
if self._candles_since_trade < self.signal_cooldown:
self._candles_since_trade += 1
close = float(candle.ClosePrice)
open_p = float(candle.OpenPrice)
if close > open_p:
self._bull_count += 1
self._bear_count = 0
elif close < open_p:
self._bear_count += 1
self._bull_count = 0
else:
self._bull_count = 0
self._bear_count = 0
if self._bull_count >= 3 and rsi_val < 65.0 and self.Position <= 0 and self._candles_since_trade >= self.signal_cooldown:
self.BuyMarket()
self._bull_count = 0
self._candles_since_trade = 0
elif self._bear_count >= 3 and rsi_val > 35.0 and self.Position >= 0 and self._candles_since_trade >= self.signal_cooldown:
self.SellMarket()
self._bear_count = 0
self._candles_since_trade = 0
def CreateClone(self):
return three_soldiers_stochastic_strategy()