Zum Inhalt

Wie man cBots und Indikatoren mit Algos verwaltet

Die Funktionalität zur Verwaltung eines Algorithmus durch einen anderen Algorithmus ermöglicht es Händlern, cBots und Indikatoren mithilfe von Code zu einem Chart hinzuzufügen. Mit dieser Funktion können sie effektive Handelsstrategien planen und entwickeln, dynamische Anpassungen vornehmen, mehrere Strategien ausführen und automatisierte Risikokontrollen anwenden.

In diesem Artikel und dem dazugehörigen Video zeigen wir Ihnen, wie Sie cBots erstellen und damit arbeiten, die andere Algorithmen verwalten.

Einen Indikator mit einem cBot hinzufügen

Öffnen Sie in der Algo-App die Registerkarte cBots. Suchen Sie nach dem Sample Trend cBot-Beispiel und wählen Sie es aus, das Moving Averages verwendet.

Definieren Sie zwei Indikatoren.

1
2
ChartIndicator _indicator1;
ChartIndicator _indicator2;

Fügen Sie zwei Indikatoren zum Chart hinzu.

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

Das Erscheinungsbild des Indikators kann über die Einstellungen seiner Ausgabelinie angepasst werden. Zu den anpassbaren Optionen gehören Farbe, Dicke und Linienstil.

Wir werden die Linie für den ersten Indikator rot und dick machen.

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

Derselbe Vorgang kann angewendet werden, um Indikatoren jederzeit aus einem Chart zu entfernen. Wir werden die Änderungen wirksam machen, wenn sich der Balken ändert.

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

Sie können den vollständigen Code unten kopieren:

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

Um den cBot zu erstellen, verwenden Sie die Tastenkombination Ctrl+B oder klicken Sie auf Erstellen.

Gehen Sie zur Handel-App. Wählen Sie das EURUSD-Chart aus, klicken Sie auf das cBot-Symbol, suchen Sie nach Sample Trend cBot und wählen Sie ihn aus.

Wenn das Fenster Instanz hinzufügen erscheint, klicken Sie auf Anwenden und starten Sie dann den cBot.

Sie sollten sehen, dass die beiden für den Handel verwendeten Moving Averages zum Chart hinzugefügt wurden.

Einen cBot mit einem anderen cBot starten

Wir werden demonstrieren, wie man einen cBot über einen anderen cBot verwaltet. Dieses Mal werden wir einen neuen leeren cBot von Grund auf neu erstellen.

Gehen Sie zur Algo-App und klicken Sie auf den Button Neu unter der Registerkarte cBots. Wählen Sie die Option Leer, geben Sie einen Namen wie Add cBots ein und klicken Sie dann auf Erstellen.

Wir beginnen damit, zwei Chart-Roboter-Objekte zu definieren.

1
2
ChartRobot _robot1;
ChartRobot _robot2;

Wir fügen diese Roboter dann in der Methode OnStart() zum Chart hinzu.

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

Wir können auch einen Event-Handler hinzufügen, um eine Nachricht auszugeben, wenn der cBot gestartet wird.

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

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

Schreiben Sie etwas Logik in die Methode OnBarClosed(), um den ersten Roboter zu starten, wenn sich der Balken ändert, ihn zu stoppen und dann den zweiten Roboter beim nächsten Balken zu starten.

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

Sie können den vollständigen Code unten kopieren:

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

Nachdem Sie den cBot erstellt haben, kehren Sie zur Handel-App zurück, suchen Sie nach Add cBots, wählen Sie ihn aus und starten Sie dann den cBot.

Wenn der Dialog Berechtigungsanfrage erscheint, klicken Sie auf Zulassen.

Die beiden Instanzen von Sample Trend cBot sollten im Chart erscheinen.

Warten Sie, bis der erste Balken abgeschlossen ist, und Sie sollten sehen, wie die erste Instanz des Sample Trend cBot automatisch startet.

Beim nächsten Balken sollten Sie sehen, wie die zweite Instanz des Sample Trend cBot automatisch startet.

Sie können beobachten, wie der cBot unsere Logik ausführt und die beiden anderen cBots basierend auf sich ändernden Bedingungen verwaltet.

cBot-Parameter während der Ausführung ändern

Möglicherweise müssen Sie die Parameter eines cBots ändern, während er läuft. Zum Beispiel entscheiden Sie sich, den Code nach dem Erhalt wichtiger Finanznachrichten oder Updates schnell zu aktualisieren.

Anstatt unseren cBot zu stoppen und neu zu starten, ändern wir sofort den Parameter SlowPeriods für den ersten 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();
}

Jetzt werden wir den cBot neu erstellen.

Sie können den vollständigen Code unten kopieren:

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

Navigieren Sie zur Handel-App und starten Sie den cBot, um zu sehen, wie sich der Indikatorwert bei jedem Balken ändert.

Zusammenfassung

Wir hoffen, dass dieser Artikel Ihnen geholfen hat zu verstehen, wie Sie Algorithmen verwenden, um andere Algorithmen zu starten, zu steuern und zu verwalten.