Vai al contenuto

Come gestire cBot e indicatori utilizzando algoritmi

La funzionalità di gestione di un algoritmo da parte di un altro algoritmo permette ai trader di aggiungere cBot e indicatori a un grafico utilizzando il codice. Con questa capacità, possono pianificare e sviluppare strategie di trading efficaci, apportare modifiche dinamiche, eseguire più strategie e applicare controlli automatici del rischio.

In questo articolo e nel video corrispondente, ti mostreremo come creare e lavorare con cBot che gestiscono altri algoritmi.

Aggiungere un indicatore utilizzando un cBot

Nell'app Algo, apri la scheda cBot. Cerca e scegli il campione Sample Trend cBot, che utilizza le moving averages.

Definisci due indicatori.

1
2
ChartIndicator _indicator1;
ChartIndicator _indicator2;

Aggiungi due indicatori al grafico.

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

L'aspetto dell'indicatore può essere personalizzato tramite le impostazioni della linea di output. Le opzioni personalizzabili includono colore, spessore e stile della linea.

Renderemo la linea del primo indicatore rossa e spessa.

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

La stessa operazione può essere applicata per rimuovere gli indicatori da un grafico in qualsiasi momento. Faremo in modo che le modifiche abbiano effetto quando la barra cambia.

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

Puoi copiare il codice completo qui sotto:

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

Per compilare il cBot, usa la scorciatoia Ctrl+B o clicca su Compila.

Vai all'app Trade. Seleziona il grafico EURUSD, fai clic sull'icona cBot, cerca e seleziona Sample Trend cBot.

Quando viene visualizzata la finestra Aggiungi istanza, fai clic su Applica e poi avvia il cBot.

Dovresti vedere che le due moving averages utilizzate per il trading sono state aggiunte al grafico.

Avviare un cBot utilizzando un altro cBot

Dimostreremo come gestire un cBot tramite un altro cBot. Questa volta creeremo un nuovo cBot vuoto da zero.

Vai all'app Algo e fai clic sul pulsante Nuovo nella scheda cBot. Seleziona l'opzione Vuoto, inserisci un nome come Add cBots e poi fai clic su Crea.

Iniziamo definendo due oggetti robot del grafico.

1
2
ChartRobot _robot1;
ChartRobot _robot2;

Aggiungiamo quindi quei robot al grafico nel metodo 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);

Possiamo anche aggiungere un gestore di eventi per stampare un messaggio ogni volta che il cBot viene avviato.

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

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

Scrivi della logica all'interno del metodo OnBarClosed() per avviare il primo robot quando la barra cambia, interromperlo e poi avviare il secondo robot sulla barra successiva.

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

Puoi copiare il codice completo qui sotto:

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

Dopo aver compilato il cBot, torna all'app Trade, cerca e seleziona Add cBots e poi avvia il cBot.

Quando viene visualizzata la finestra di dialogo Richiesta di permesso, fai clic su Consenti.

Le due istanze di Sample Trend cBot dovrebbero apparire sul grafico.

Attendi il completamento della prima barra e dovresti vedere la prima istanza del Sample Trend cBot avviarsi automaticamente.

Sulla barra successiva, dovresti vedere la seconda istanza del Sample Trend cBot avviarsi automaticamente.

Puoi osservare come il cBot esegue la nostra logica e gestisce gli altri due cBot in base alle condizioni che cambiano.

Modificare i parametri del cBot durante l'esecuzione

Potresti aver bisogno di modificare i parametri di un cBot mentre è in esecuzione. Ad esempio, decidi di aggiornare rapidamente il codice al volo dopo aver ricevuto notizie finanziarie importanti o aggiornamenti.

Invece di interrompere e riavviare il nostro cBot, modifichiamo immediatamente il parametro SlowPeriods per il primo 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();
}

Ora ricompileremo il cBot.

Puoi copiare il codice completo qui sotto:

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

Vai all'app Trade e avvia il cBot per vedere come il valore dell'indicatore cambia su ogni barra.

Speriamo che questo articolo ti abbia aiutato a capire come utilizzare gli algoritmi per avviare, controllare e gestire altri algoritmi.