Cómo manejar eventos de barras

Los eventos de barras son esenciales para el ciclo de vida de cualquier cBot. Manejar correctamente estos eventos es crucial para gestionar cómo sus cBots reaccionan a las nuevas condiciones del mercado. En este artículo y su correspondiente video, demostraremos los tipos clave de eventos de barras y discutiremos los manejadores para estos eventos expuestos por la API de cTrader.

• Barra - se refiere a diferentes tipos de objetos que se dibujan secuencialmente en el gráfico de operaciones por cTrader. Pueden ser velas, ladrillos de Renko, barras de rango o incluso velas de Heiken Ashi.

Manejar el evento BarOpened

Los eventos de barras ocurren cuando una nueva barra comienza a trazarse en el gráfico de operaciones vinculado a un cBot. El evento BarOpened ocurre para la nueva barra que acaba de comenzar a dibujarse en el gráfico.

El manejo de este evento se realiza a través del método OnBar(), que es un método heredado de la clase base Robot. Ahora crearemos un cBot que maneja el evento BarOpened como parte de nuestra estrategia para analizar el sentimiento del mercado. Eliminaremos los métodos OnStart() y OnStop() de la plantilla y reemplazaremos el manejador OnTick() con el manejador 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();
        }
    }
}

Se supone que el cBot se lanzará en gráficos con el marco de tiempo D1 (diario). En cada barra, compara la diferencia de precio de apertura con el precio de apertura de la barra anterior y coloca una nueva orden en una dirección adecuada. Si la diferencia de precio es insignificante, el bot en su lugar cierra todas las posiciones actualmente abiertas.

Si ejecutamos un backtest de este bot simple, los resultados parecen ser alentadores.

Manejar el evento BarClosed

Cuando se abre una nueva barra, efectivamente carece de cualquier dato de precio aparte de su precio de apertura. En muchos casos, es posible que desee que su cBot acceda a los datos de la barra anterior para garantizar una ejecución fluida de la estrategia. Es por eso que el evento BarClosed ocurre para la barra que acaba de cerrarse (la inmediatamente anterior a la nueva barra) y le permite usar fácilmente sus datos de precio y volumen. Cuando se activa el evento BarClosed, la barra recién abierta se omite completamente de la colección Bars

Para manejar el evento BarClosed, la API expone el método OnBarClosed.

Crearemos un cBot simple que utiliza el controlador OnBarClosed() de la siguiente manera.

 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);

    }
}

El cBot detecta un patrón alcista (hammer) evaluando la longitud de la mecha inferior de una vela. Si se detecta un patrón hammer, se cierran todas las posiciones abiertas previamente y se coloca una nueva orden de compra con un stop loss de 50 pips.

Si hacemos backtesting del bot, obtendremos resultados decentes.

Agregar controladores de eventos personalizados

Al manejar los eventos BarOpened y BarClosed, también puede utilizar una sintaxis ligeramente diferente asignando estos eventos con controladores personalizados. Mientras que OnBar() y OnBarClosed() solo se activan una vez, puede asignar tantos controladores personalizados como desee, lo que permite agregar lógica compleja.

 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) {}

Crearemos otro cBot que utiliza dos controladores personalizados para el evento BarOpened para reaccionar a posibles reversiones alcistas y bajistas.

 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);
    }
}

El cBot verifica si el precio de apertura de la nueva barra abierta es más alto que los precios de cierre de las dos barras anteriores. Si este es el caso, se coloca una orden de compra. Si el precio de apertura es más bajo que los precios de cierre de las dos barras anteriores, se coloca una orden de venta. El uso de dos controladores de eventos separados nos permite dividir nuestra lógica de operaciones en componentes más pequeños que podemos modificar fácilmente más adelante si es necesario.

Los resultados del backtesting en un marco temporal D1 también son positivos.

Resumen

Al aprender a manejar correctamente los eventos de las barras, puede hacer que sus cBots hagan exactamente lo que usted quiere que hagan y cuando quiere que lo hagan.