Types clés de cBots

Les cBots sont des outils polyvalents qui, selon leur code et leur logique, peuvent remplir divers rôles et fonctions allant du trading entièrement automatisé au soutien de la mise en œuvre de stratégies de trading manuel. Dans cet article et sa vidéo correspondante, nous définirons les types clés de cBots, décrirons leurs principales différences et énumérerons quelques bonnes pratiques pour créer et utiliser des cBots de différents types.

De manière générale, il existe quatre types clés de cBots.

• Stratégies de trading automatisées - comme l'indique le nom, les cBots de ce type exécutent de manière autonome des stratégies de trading. Par exemple, un cBot Three black crows & three white soldiers place un nouvel ordre d'achat après avoir rencontré trois bougies vertes consécutives, et un nouvel ordre de vente face à trois bougies rouges consécutives.
• Scripts - les cBots appartenant à ce type effectuent une action au démarrage et s'arrêtent une fois l'exécution terminée. Par exemple, un cBot de script peut établir un stop loss pour toutes les positions actuellement ouvertes, indépendamment de leur sens de transaction, de leur volume ou de leur instrument.
• Assistants de trading - sont conçus pour effectuer une action utile qui complète une stratégie de trading manuelle ou automatique. Par exemple, un cBot de ce type peut gérer vos stop loss suiveurs en utilisant des règles personnalisées différentes de la fonctionnalité de stop loss suiveur intégrée offerte par cTrader.
• Panneaux de trading - les cBots de ce type ne tradent pas de manière autonome ; au lieu de cela, ils créent des contrôles personnalisés qui peuvent être utilisés à diverses fins. Par exemple, un cBot peut lancer une WebView d'un agrégateur de nouvelles Forex tout en intégrant des boutons d'achat et de vente personnalisés ainsi qu'un sélecteur de symboles à l'intérieur de la WebView, permettant à l'utilisateur de trader sans quitter le site d'actualités.

Dans les sous-sections ci-dessous, nous discutons de chacun des types ci-dessus en détail, décrivons leurs avantages et leurs limites, et suggérons divers cas d'utilisation.

Stratégies de trading algorithmique

Les cBots appartenant au type de stratégie de trading automatisée sont complexes mais puissants. Ils doivent correctement mettre en œuvre une stratégie de trading incluant tous ses aspects tels que la gestion des risques, le dimensionnement des positions et l'analyse technique.

Vous pouvez créer une stratégie de trading automatisée simple en moins de deux minutes en remplaçant simplement le modèle de nouveau cBot par défaut par le code ci-dessous.

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

Le cBot ouvre une nouvelle position à chaque barre. Une position longue est ouverte si le cours a augmenté dans la barre précédente par rapport à la barre qui la précède. Inversement, une position courte est ouverte si le cours a baissé.

Scripts

Les scripts sont généralement nécessaires pour effectuer une action qui serait difficile ou chronophage à faire manuellement. Ces actions sont généralement effectuées au démarrage du cBot afin que vous puissiez lancer un script, observer les résultats de son fonctionnement, puis arrêter son instance en cas de succès pour économiser la RAM et la consommation du processeur.

Par exemple, un script peut fermer toutes les positions dont le profit brut dépasse 50 unités de la devise de dépôt du compte d'un trader. En effet, le script agirait comme un take profit universel pour toutes les positions ouvertes que vous pouvez déclencher à tout moment. Voici à quoi ressemblerait le code de ce script.

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

Après le lancement du cBot, nous devrions voir plusieurs positions rentables se fermer progressivement.

Assistants de trading

Le but des assistants de trading est d'effectuer régulièrement des actions utiles. Bien que cela les rende similaires aux scripts, les scripts n'effectuent une action qu'au démarrage de l'instance. En revanche, les assistants de trading sont conçus pour réagir en permanence aux conditions du marché ou à d'autres facteurs, et exécuter des opérations en réponse à certains motifs.

Par exemple, considérez un cBot qui couvre automatiquement vos positions dès que vous les ouvrez. Le code de ce cBot pourrait ressembler à ce qui suit.

 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

Dès l'ouverture d'une position, le cBot tente immédiatement d'en ouvrir une autre dans le sens opposé ; le volume de cette nouvelle position est exactement la moitié du volume de la position d'origine.

Notez que nous utilisons le champ hasHedgedPosition pour éviter une boucle infinie afin que le cBot ne couvre une nouvelle position qu'une seule fois.

Panneaux de trading

Les panneaux de trading affichent des contrôles personnalisés qui déclenchent diverses actions lorsqu'on interagit avec eux. Ils apportent généralement des améliorations de qualité de vie à l'interface utilisateur par défaut de cTrader. Par exemple, un cBot peut afficher un bouton Acheter qui, lorsqu'on clique dessus, exécute un ordre du marché pour un volume prédéfini dans cTrader.

Pour créer un tel cBot, utilisez simplement le code ci-dessous.

 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)

En cliquant sur le bouton Acheter, un nouvel ordre du marché de 10 000 unités est placé. L'emplacement pratique du bouton permet de réagir rapidement aux nouvelles opportunités du marché.

Résumé

Les quatre catégories de cBots ont des utilisations valables et peuvent être combinées selon vos préférences. Par exemple, vous pouvez lancer simultanément une stratégie de trading automatisée et un assistant de trading pour obtenir les meilleurs résultats possibles. Vous pouvez expérimenter avec des cBots de différents types pour vous assurer que votre approche préférée du trading est exécutée pleinement et sans défaut.