Tipos principais de cBots

Os cBots são ferramentas versáteis que, dependendo do seu código e lógica, podem cumprir várias funções e papéis, desde a negociação totalmente automatizada até ao apoio à implementação de estratégias de negociação manual. Neste artigo e no vídeo correspondente, vamos definir os principais tipos de cBots, delinear as suas principais diferenças e listar algumas melhores práticas para criar e usar cBots de vários tipos.

De um modo geral, existem quatro tipos principais de cBots.

• Estratégias de negociação automatizadas - como o nome implica, os cBots deste tipo executam estratégias de negociação de forma autónoma. Por exemplo, um cBot de Três corvos negros e três soldados brancos coloca uma nova ordem de compra após encontrar três velas verdes consecutivas e uma nova ordem de venda ao enfrentar três velas vermelhas consecutivas.
• Scripts - os cBots pertencentes a este tipo executam uma ação no início e param após a conclusão da execução. Por exemplo, um cBot de script pode estabelecer um stop loss para todas as posições atualmente abertas, independentemente da sua direção, volume ou instrumento.
• Assistentes de negociação - são projetados para executar algum tipo de ação útil que complementa uma estratégia de negociação manual ou automática. Por exemplo, um cBot deste tipo pode gerir os seus stop losses móveis usando regras personalizadas que são diferentes da funcionalidade de stop loss móvel incorporada oferecida pelo cTrader.
• Painéis de negociação - os cBots deste tipo não negoceiam de forma autónoma; em vez disso, criam controlos personalizados que podem ser usados para vários fins. Por exemplo, um cBot pode lançar um WebView de um agregador de notícias Forex enquanto integra botões personalizados de compra e venda, bem como um seletor de símbolos dentro do WebView, permitindo que o utilizador negocie sem sair do site de notícias.

Nas subsecções abaixo, discutimos cada um dos tipos acima em detalhe, delineamos os seus benefícios e limitações e sugerimos vários casos de uso.

Estratégias de negociação algorítmica

Os cBots pertencentes ao tipo de estratégia de negociação automatizada são complexos, mas poderosos. Eles têm de implementar corretamente uma estratégia de negociação, incluindo todos os seus aspetos, como gestão de risco, dimensionamento de posições e análise técnica.

Pode criar uma estratégia de negociação automatizada simples em menos de dois minutos, simplesmente substituindo o modelo padrão de novo cBot pelo código abaixo.

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

using System;
using cAlgo.API;

namespace cAlgo.Robots
{
    [Robot(AccessRights = AccessRights.None)]
    public class BasicTrendBot : Robot
    {
        protected override void OnBar()
        {
            if (Bars.ClosePrices.Last(1) > Bars.ClosePrices.Last(2))
            {
                ExecuteMarketOrder(TradeType.Buy, SymbolName, 1000, "FollowTrend");
            }
            else if (Bars.ClosePrices.Last(1) < Bars.ClosePrices.Last(2))
            {
                ExecuteMarketOrder(TradeType.Sell, SymbolName, 1000, "FollowTrend");
            }
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

import clr
clr.AddReference("cAlgo.API")
from cAlgo.API import *
from robot_wrapper import *

class BasicTrendBot():
    def on_bar(self):
        if api.Bars.ClosePrices.Last(1) > api.Bars.ClosePrices.Last(2):
            api.ExecuteMarketOrder(TradeType.Buy, api.SymbolName, 1000, "FollowTrend")
        elif api.Bars.ClosePrices.Last(1) < api.Bars.ClosePrices.Last(2):
            api.ExecuteMarketOrder(TradeType.Sell, api.SymbolName, 1000, "FollowTrend")

O cBot abre uma nova posição em cada barra. Uma posição longa é aberta se o preço aumentou na barra anterior em comparação com a barra anterior a ela. Por outro lado, uma posição curta é aberta se o preço tiver descido.

Scripts

Os scripts são normalmente necessários para executar algum tipo de ação que seria difícil ou demorada de fazer manualmente. Estas ações são normalmente realizadas no início do cBot para que possa lançar um script, observar os resultados do seu funcionamento e depois parar a sua instância em caso de sucesso para economizar no consumo de RAM e CPU.

Por exemplo, um script pode fechar todas as posições cujo lucro bruto exceda 50 unidades da moeda de depósito da conta do trader. Na prática, o script atuaria como um take profit universal para todas as posições abertas que pode acionar a qualquer momento. Eis como o código para este script ficaria.

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

using System;
using cAlgo.API;
using cAlgo.API.Collections;

namespace cAlgo.Robots
{
    [Robot(AccessRights = AccessRights.None)]
    public class BasicScriptBot : Robot
    {

        protected override void OnStart()
        {
            foreach (var position in Positions) 
            {
                if (position.GrossProfit > 50) 
                {
                    ClosePosition(position);
                }
            }
            Stop();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

import clr
clr.AddReference("cAlgo.API")
from cAlgo.API import *
from robot_wrapper import *

class BasicScriptBot():
    def on_start(self):
        for position in api.Positions:
            if position.GrossProfit > 50:
                api.ClosePosition(position)
        api.Stop()

Após lançar o cBot, deveríamos ver várias posições lucrativas a serem gradualmente fechadas.

Assistentes de negociação

O objetivo dos assistentes de negociação é realizar regularmente ações úteis. Embora isso os torne semelhantes aos scripts, os scripts apenas executam uma ação no início da instância. Em contraste, os assistentes de negociação são projetados para reagir continuamente às condições de mercado ou outros fatores e executar operações em resposta a certos padrões.

Por exemplo, considere um cBot que cobre automaticamente as suas posições assim que as abre. O código para este cBot poderia ser o seguinte.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

using System;
using cAlgo.API;
using cAlgo.API.Collections;

namespace cAlgo.Robots
{
    [Robot(AccessRights = AccessRights.None)]
    public class BasicAssistantBot : Robot

    {
        private bool hasHedgedPosition = false;

        protected override void OnStart()
        {
            Positions.Opened += Positions_Opened;
        }

        private void Positions_Opened(PositionOpenedEventArgs args) 
        {
            if (!hasHedgedPosition) 
            {
                hasHedgedPosition = true;
                var position = args.Position;
                var oppositeTradeType = position.TradeType == TradeType.Buy ? TradeType.Sell : TradeType.Buy;
                ExecuteMarketOrder(oppositeTradeType, SymbolName, position.VolumeInUnits / 2);
            }
            else 
            {
                hasHedgedPosition = false;            
            }
        }
    }
}

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

import clr
clr.AddReference("cAlgo.API")
from cAlgo.API import *
from robot_wrapper import *

class BasicAssistantBot():
    def on_start(self):
        self.hasHedgedPosition = False
        api.Positions.Opened += self.positions_opened

    def positions_opened(self, args):
        if not self.hasHedgedPosition:
            self.hasHedgedPosition = True
            position = args.Position
            opposite = TradeType.Sell if position.TradeType == TradeType.Buy else TradeType.Buy
            api.ExecuteMarketOrder(opposite, api.SymbolName, position.VolumeInUnits / 2)
        else:
            self.hasHedgedPosition = False

Ao abrir uma posição, o cBot tenta imediatamente abrir outra na direção oposta; o volume desta nova posição é exatamente metade do volume da posição original.

Note que estamos a usar o campo hasHedgedPosition para evitar um loop infinito, de modo que o cBot apenas cubra uma nova posição uma vez.

Painéis de negociação

Os painéis de negociação exibem controlos personalizados que acionam várias ações quando interagidos. Normalmente, fornecem melhorias na qualidade de vida à interface do utilizador padrão do cTrader. Por exemplo, um cBot pode exibir um botão Comprar que, quando clicado, executa uma ordem de mercado para um volume predefinido no cTrader.

Para criar tal cBot, basta usar o código abaixo.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

using System;
using cAlgo.API;

namespace cAlgo.Robots
{
    [Robot(AccessRights = AccessRights.None)]
    public class BasicPanelBot : Robot
    {

        Button buttonBuyOrder;

        protected override void OnStart()
        {

            buttonBuyOrder = new Button
            {
                Text = "Buy",
                HorizontalAlignment = HorizontalAlignment.Center,
                VerticalAlignment = VerticalAlignment.Center,
            };

            buttonBuyOrder.Click += ButtonBuyOrder_Click;

            Chart.AddControl(buttonBuyOrder);
        }

        private void ButtonBuyOrder_Click(ButtonClickEventArgs args) 
        {
            ExecuteMarketOrder(TradeType.Buy, SymbolName, 10000);
        }
    }
}

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

import clr
clr.AddReference("cAlgo.API")
from cAlgo.API import *
from robot_wrapper import *

class BasicPanelBot():
    def on_start(self):
        self.buttonBuyOrder = Button()
        self.buttonBuyOrder.Text = "Buy"
        self.buttonBuyOrder.HorizontalAlignment = HorizontalAlignment.Center
        self.buttonBuyOrder.VerticalAlignment = VerticalAlignment.Center
        self.buttonBuyOrder.Click += self.button_buy_order_click
        api.Chart.AddControl(self.buttonBuyOrder)

    def button_buy_order_click(self, args):
        api.ExecuteMarketOrder(TradeType.Buy, api.SymbolName, 10000)

Ao clicar no botão Comprar, é colocada uma nova ordem de mercado para 10.000 unidades. A colocação conveniente do botão permite reagir rapidamente a novas oportunidades de mercado.

Resumo

Todas as quatro categorias de cBots têm usos válidos e podem ser combinadas de acordo com as suas preferências. Por exemplo, pode lançar simultaneamente uma estratégia de negociação automatizada e um assistente de negociação para alcançar os melhores resultados possíveis. Pode experimentar cBots de vários tipos para garantir que a sua abordagem preferida de negociação seja executada totalmente e sem falhas.