Aller au contenu

Comment gérer les cBots et les indicateurs à l'aide d'algorithmes

La fonctionnalité de gestion d'un algorithme par un autre algorithme permet aux traders d'ajouter des cBots et des indicateurs à un graphique à l'aide de code. Grâce à cette capacité, ils peuvent planifier et développer des stratégies de trading efficaces, effectuer des ajustements dynamiques, exécuter plusieurs stratégies et appliquer des contrôles de risque automatisés.

Dans cet article et sa vidéo correspondante, nous vous montrerons comment créer et travailler avec des cBots qui gèrent d'autres algorithmes.

Ajouter un indicateur à l'aide d'un cBot

Dans l'appli Algo, ouvrez l'onglet cBots. Recherchez et choisissez l'échantillon Sample Trend cBot, qui utilise des moyennes mobiles.

Définissez deux indicateurs.

1
2
ChartIndicator _indicator1;
ChartIndicator _indicator2;

Ajoutez deux indicateurs au graphique.

1
2
_indicator1 = Chart.Indicators.Add("Simple Moving Average", SourceSeries, FastPeriods, MAType);
_indicator2 = Chart.Indicators.Add("Simple Moving Average", SourceSeries, SlowPeriods, MAType);

L'apparence de l'indicateur peut être personnalisée via les paramètres de sa ligne de sortie. Les options personnalisables incluent la couleur, l'épaisseur et le style de ligne.

Nous rendrons la ligne du premier indicateur rouge et épaisse.

1
2
_indicator1.Lines[0].Color = Color.Red;
_indicator1.Lines[0].Thickness = 3;

La même opération peut être appliquée pour supprimer des indicateurs d'un graphique à tout moment. Nous ferons en sorte que les modifications prennent effet lorsque la barre change.

1
2
3
4
5
protected override void OnBarClosed()
{
    Chart.Indicators.Remove(_indicator1);
    Chart.Indicators.Remove(_indicator2);
}

Vous pouvez copier le code complet 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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
using cAlgo.API;
using cAlgo.API.Indicators;

namespace cAlgo
{
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None, AddIndicators = true)]
    public class SampleTrendcBot : Robot
    {
        [Parameter("Quantity (Lots)", Group = "Volume", DefaultValue = 1, MinValue = 0.01, Step = 0.01)]
        public double Quantity { get; set; }

        [Parameter("MA Type", Group = "Moving Average")]
        public MovingAverageType MAType { get; set; }

        [Parameter("Source", Group = "Moving Average")]
        public DataSeries SourceSeries { get; set; }

        [Parameter("Slow Periods", Group = "Moving Average", DefaultValue = 10)]
        public int SlowPeriods { get; set; }

        [Parameter("Fast Periods", Group = "Moving Average", DefaultValue = 5)]
        public int FastPeriods { get; set; }

        private MovingAverage slowMa;
        private MovingAverage fastMa;
        private const string label = "Sample Trend cBot";   

        ChartIndicator _indicator1;
        ChartIndicator _indicator2;

        protected override void OnStart()
        {
            fastMa = Indicators.MovingAverage(SourceSeries, FastPeriods, MAType);
            slowMa = Indicators.MovingAverage(SourceSeries, SlowPeriods, MAType);

            _indicator1 = Chart.Indicators.Add("Simple Moving Average", SourceSeries, FastPeriods, MAType);
            _indicator2 = Chart.Indicators.Add("Simple Moving Average", SourceSeries, SlowPeriods, MAType);

            _indicator1.Lines[0].Color = Color.Red;
            _indicator1.Lines[0].Thickness = 3;
        }

        protected override void OnBarClosed()
        {
            Chart.Indicators.Remove(_indicator1);
            Chart.Indicators.Remove(_indicator2);
        }

        protected override void OnTick()
        {
            var longPosition = Positions.Find(label, SymbolName, TradeType.Buy);
            var shortPosition = Positions.Find(label, SymbolName, TradeType.Sell);

            var currentSlowMa = slowMa.Result.Last(0);
            var currentFastMa = fastMa.Result.Last(0);
            var previousSlowMa = slowMa.Result.Last(1);
            var previousFastMa = fastMa.Result.Last(1);

            if (previousSlowMa > previousFastMa && currentSlowMa <= currentFastMa && longPosition == null)
            {
                if (shortPosition != null)
                    ClosePosition(shortPosition);

                ExecuteMarketOrder(TradeType.Buy, SymbolName, VolumeInUnits, label);
            }
            else if (previousSlowMa < previousFastMa && currentSlowMa >= currentFastMa && shortPosition == null)
            {
                if (longPosition != null)
                    ClosePosition(longPosition);

                ExecuteMarketOrder(TradeType.Sell, SymbolName, VolumeInUnits, label);
            }
        }

        private double VolumeInUnits
        {
            get { return Symbol.QuantityToVolumeInUnits(Quantity); }
        }
    }
}

Pour créer le cBot, utilisez le raccourci clavier Ctrl+B ou cliquez sur Créer.

Accédez à l'appli Trade. Sélectionnez le graphique EURUSD, cliquez sur l'icône cBot, recherchez et sélectionnez Sample Trend cBot.

Lorsque la fenêtre Ajouter une instance apparaît, cliquez sur Appliquer, puis démarrez le cBot.

Vous devriez voir que les deux moyennes mobiles utilisées pour le trading ont été ajoutées au graphique.

Démarrer un cBot à l'aide d'un autre cBot

Nous allons démontrer comment gérer un cBot via un autre cBot. Cette fois, nous allons créer un nouveau cBot vide à partir de zéro.

Accédez à l'appli Algo et cliquez sur le bouton Nouveau sous l'onglet cBots. Sélectionnez l'option Vierge, saisissez un nom tel que Add cBots, puis cliquez sur Créer.

Nous commençons par définir deux objets de robot de graphique.

1
2
ChartRobot _robot1;
ChartRobot _robot2;

Nous ajoutons ensuite ces robots au graphique dans la méthode OnStart().

1
2
_robot1 = Chart.Robots.Add("Sample Trend cBot", 0.01, MovingAverageType.Simple, Bars.ClosePrices, 10, 5);
_robot2 = Chart.Robots.Add("Sample Trend cBot", 0.01, MovingAverageType.Simple, Bars.ClosePrices, 12, 7);

Nous pouvons également ajouter un gestionnaire d'événements pour imprimer un message chaque fois que le cBot est démarré.

1
2
3
4
5
6
Chart.Robots.RobotStarted += ChartRobots_RobotStarted;

private void ChartRobots_RobotStarted(ChartRobotStartedEventArgs obj)
{
    Print ("Robot Started");
}

Écrivez une logique dans la méthode OnBarClosed() pour démarrer le premier robot lorsque la barre change, l'arrêter, puis démarrer le deuxième robot à la barre suivante.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
protected override void OnBarClosed()
{
    if (_robot1.State == RobotState.Stopped)
    {
        _robot1.Start();
        _robot2.Stop();
            }
    else if (_robot1.State == RobotState.Running)
    {
        _robot1.Stop();
        _robot2.Start();
    }
}

Vous pouvez copier le code complet 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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
using System;
using cAlgo.API;
using cAlgo.API.Collections;
using cAlgo.API.Indicators;
using cAlgo.API.Internals;

namespace cAlgo.Robots
{
    [Robot(AccessRights = AccessRights.None, AddIndicators = true)]
    public class AddcBots : Robot
    {

        ChartRobot _robot1;
        ChartRobot _robot2;

        protected override void OnStart()
        {
            _robot1 = Chart.Robots.Add("Sample Trend cBot", 0.01, MovingAverageType.Simple, Bars.ClosePrices, 10, 5);
            _robot2 = Chart.Robots.Add("Sample Trend cBot", 0.01, MovingAverageType.Simple, Bars.ClosePrices, 12, 7);

            Chart.Robots.RobotStarted += ChartRobots_RobotStarted;
        }

        private void ChartRobots_RobotStarted(ChartRobotStartedEventArgs obj)
        {
            Print ("Robot Started");

        }

        protected override void OnBarClosed()
        {
            if (_robot1.State == RobotState.Stopped)
            {
                _robot1.Start();
                _robot2.Stop();
            }

            else if (_robot1.State == RobotState.Running)
            {
                _robot2.Start();
                _robot1.Stop();
            }
        }

        protected override void OnStop()
        {
            // Handle cBot stop here
        }
    }
}

Après avoir créé le cBot, retournez à l'appli Trade, recherchez et sélectionnez Add cBots, puis démarrez le cBot.

Lorsque la boîte de dialogue Demande de permission apparaît, cliquez sur Autoriser.

Les deux instances de Sample Trend cBot devraient apparaître sur le graphique.

Attendez que la première barre se termine et vous devriez voir la première instance du Sample Trend cBot démarrer automatiquement.

À la barre suivante, vous devriez voir la deuxième instance du Sample Trend cBot démarrer automatiquement.

Vous pouvez observer comment le cBot exécute notre logique et gère les deux autres cBots en fonction des conditions changeantes.

Modifier les paramètres du cBot pendant l'exécution

Vous pourriez avoir besoin de modifier les paramètres d'un cBot pendant qu'il est en cours d'exécution. Par exemple, vous décidez de mettre rapidement à jour le code en cours de route après avoir reçu des nouvelles financières importantes ou des mises à jour.

Plutôt que d'arrêter et de redémarrer notre cBot, modifions immédiatement le paramètre SlowPeriods pour le premier cBot.

1
2
3
4
5
6
else if(_robot1.State == RobotState.Running)
{
_robot1.Stop();
_robot1.Parameters["SlowPeriods"].Value = (int)_robot2.Parameters["SlowPeriods"].Value + 1;
_robot1.Start();
}

Maintenant, nous allons reconstruire le cBot.

Vous pouvez copier le code complet 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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
using System;
using cAlgo.API;
using cAlgo.API.Collections;
using cAlgo.API.Indicators;
using cAlgo.API.Internals;

namespace cAlgo.Robots
{
    [Robot(AccessRights = AccessRights.None, AddIndicators = true)]
    public class AddcBots : Robot
    {

        ChartRobot _robot1;
        ChartRobot _robot2;

        protected override void OnStart()
        {
            _robot1 = Chart.Robots.Add("Sample Trend cBot", 0.01, MovingAverageType.Simple, Bars.ClosePrices, 10, 5);
            _robot2 = Chart.Robots.Add("Sample Trend cBot", 0.01, MovingAverageType.Simple, Bars.ClosePrices, 12, 7);

            Chart.Robots.RobotStarted += ChartRobots_RobotStarted;
        }

        private void ChartRobots_RobotStarted(ChartRobotStartedEventArgs obj)
        {
            Print ("Robot Started");

        }

        protected override void OnBarClosed()
        {
            if (_robot1.State == RobotState.Stopped)
            {
                _robot1.Start();
                _robot2.Stop();
            }

            else if (_robot1.State == RobotState.Running)
            {
                _robot1.Stop();
                _robot1.Parameters["SlowPeriods"].Value = (int)_robot2.Parameters["SlowPeriods"].Value + 1;
                _robot1.Start();
            }
        }

        protected override void OnStop()
        {
            // Handle cBot stop here
        }
    }
}

Accédez à l'appli Trade et démarrez le cBot pour voir comment la valeur de l'indicateur change à chaque barre.

Résumé

Nous espérons que cet article vous a aidé à comprendre comment utiliser des algorithmes pour démarrer, contrôler et gérer d'autres algorithmes.