Como lidar com eventos de barras

Os eventos de barras são essenciais para o ciclo de vida de qualquer cBot. Lidar adequadamente com estes eventos é crucial para gerir a forma como os seus cBots reagem a novas condições de mercado. Neste artigo e no vídeo correspondente, iremos demonstrar os principais tipos de eventos de barras e discutir os manipuladores destes eventos expostos pela API do cTrader.

• Barra - refere-se a diferentes tipos de objetos que são desenhados sequencialmente no gráfico de negociação pelo cTrader. Podem ser velas, tijolos Renko, barras de intervalo ou até velas Heiken Ashi.

Lidar com o evento BarOpened

Os eventos de barras ocorrem quando uma nova barra começa a ser traçada no gráfico de negociação associado a um cBot. O evento BarOpened ocorre para a nova barra que acabou de começar a ser desenhada no gráfico.

O tratamento deste evento é feito através do método OnBar(), que é um método herdado da classe base Robot. Vamos agora criar um cBot que lida com o evento BarOpened como parte da nossa estratégia para analisar o sentimento do mercado. Vamos eliminar os métodos OnStart() e OnStop() do modelo e substituir o manipulador OnTick() pelo manipulador OnBar().

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

protected override void OnBar()
{
    var previousBar = Bars[Bars.Count - 2];
    var priceDifference = ((Bars.LastBar.Open - previousBar.Open) / previousBar.Open) * 100;
    if (priceDifference > 1)
    {
        ExecuteMarketOrder(TradeType.Buy, SymbolName, 10000);
    }
    else if (priceDifference < -1)
    {
        ExecuteMarketOrder(TradeType.Sell, SymbolName, 10000);
    }
    else 
    {
        foreach (var position in Positions) 
        {
            position.Close();
        }
    }
}

O cBot deve ser executado em gráficos com o intervalo de tempo D1 (diário). Em cada barra, compara a diferença do preço de abertura com o preço de abertura da barra anterior e coloca uma nova ordem numa direção adequada. Se a diferença de preço for insignificante, o bot fecha todas as posições atualmente abertas.

Se executarmos um teste de verificação deste bot simples, os resultados parecem ser encorajadores.

Lidar com o evento BarClosed

Quando uma nova barra é aberta, ela efetivamente não possui dados de preço além do seu preço de abertura. Em muitos casos, pode querer que o seu cBot aceda aos dados da barra anterior para garantir uma execução suave da estratégia. É por isso que o evento BarClosed ocorre para a barra que acabou de fechar (a imediatamente anterior à nova barra) e permite que utilize facilmente os seus dados de preço e volume. Quando o evento BarClosed é acionado, a barra recém-aberta é totalmente omitida da coleção Bars

Para lidar com o evento BarClosed, a API expõe o método OnBarClosed.

Vamos criar um cBot simples que usa o manipulador OnBarClosed() da seguinte forma.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

protected override void OnBarClosed()
{
    var lowCloseDifference = ((Bars.LastBar.Close - Bars.LastBar.Low) / Bars.LastBar.Close) * 100;
    if (lowCloseDifference > 0.5)
    {
        foreach (var position in Positions)
        {
            position.Close();
        }
        ExecuteMarketOrder(TradeType.Buy, SymbolName, 10000, null, null, 50);

    }
}

O cBot deteta um padrão de alta (hammer) avaliando o comprimento da mecha inferior de uma vela. Se um padrão hammer for detetado, todas as posições previamente abertas são fechadas e uma nova ordem de compra é colocada com um stop loss de 50 pips.

Se fizermos um teste de verificação do bot, obteremos resultados decentes.

Adicionar manipuladores de eventos personalizados

Ao lidar com os eventos BarOpened e BarClosed, também pode usar uma sintaxe ligeiramente diferente atribuindo estes eventos a manipuladores personalizados. Enquanto OnBar() e OnBarClosed() são acionados apenas uma vez, pode atribuir tantos manipuladores personalizados quanto quiser, o que permite adicionar lógica complexa.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

protected override void OnStart() 
{
    Bars.BarClosed += BarClosedHandler;
    Bars.BarClosed += AnotherClosedHandler;
    Bars.BarOpened += BarOpenedHandler;
}

void BarClosedHandler(BarClosedEventArgs args) {}
void AnotherClosedHandler(BarClosedEventArgs args) {}
void BarOpenedHandler(BarOpenedEventArgs args) {}

Vamos criar outro cBot que usa dois manipuladores personalizados para o evento BarOpened para reagir a possíveis reversões de alta e baixa.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

protected override void OnStart() 
{
    Bars.BarOpened += BullishReversal;
    Bars.BarOpened += BearishReversal;

}

private void BullishReversal(BarOpenedEventArgs args) 
{
    if (Bars.LastBar.Open > Bars.Last(1).Close && Bars.LastBar.Open > Bars.Last(2).Close) 
    {
        ExecuteMarketOrder(TradeType.Buy, SymbolName, 10000, null, 10, 50);
    }
}

private void BearishReversal(BarOpenedEventArgs args) 
{
    if (Bars.LastBar.Open < Bars.Last(1).Close && Bars.LastBar.Open < Bars.Last(2).Close) 
    {
        ExecuteMarketOrder(TradeType.Sell, SymbolName, 10000, null, 10, 50);
    }
}

O cBot verifica se o preço de abertura da barra recém-aberta é superior aos preços de fecho das duas barras anteriores. Se for o caso, é colocada uma ordem de compra. Se o preço de abertura for inferior aos preços de fecho das duas barras anteriores, é colocada uma ordem de venda. O uso de dois manipuladores de eventos separados permite-nos dividir a nossa lógica de negociação em componentes menores que podemos modificar facilmente mais tarde, se necessário.

Os resultados do teste de verificação num intervalo de tempo D1 também são positivos.

Resumo

Ao aprender a lidar adequadamente com os eventos das barras, pode fazer com que os seus cBots façam exatamente o que quer que eles façam e quando quer que o façam.