Grid cBot¶

Gambaran keseluruhan strategi ¶

Grid cBot melaksanakan strategi dagangan grid di mana pelbagai pesanan beli atau jual untuk simbol diletakkan pada selang harga yang tetap atau "langkah", membentuk "grid" posisi. Apabila harga simbol berubah, posisi baharu dibuka secara berterusan untuk mengambil kesempatan daripada turun naik.

Grid cBot menggunakan gabungan aritmetik mudah dan pemeriksaan logik untuk membuka posisi, mengira keuntungan dan menguruskan operasi dagangan. Ia paling berkesan dalam pasaran terikat julat atau sisi. Ia juga berprestasi baik dalam keadaan turun naik rendah dan pasaran dengan tahap rintangan dan sokongan yang diketahui.

Penciptaan cBot ¶

Pelajari cara mencipta cBot, menggunakan sama ada C# atau Python, dalam panduan langkah demi langkah kami.

Kod Grid cBot tersedia dalam repositori awam kami C# dan Python. Kod yang sama disediakan sebagai templat dalam panduan penciptaan algoritma dalam cTrader Windows atau Mac, atau anda hanya boleh menyalin dan menggunakan coretan di bawah:

 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
81
82
83
84
85
86
87
88
89
90
91
92
93

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using cAlgo.API;
using cAlgo.API.Collections;
using cAlgo.API.Indicators;
using cAlgo.API.Internals;

namespace cAlgo.Robots
{
    [Robot(AccessRights = AccessRights.None)]
    public class Grid : Robot
    {
        [Parameter("Volume (lots)", DefaultValue = 0.01, MinValue = 0.01, Step = 0.01)]
        public double VolumeInLots { get; set; }

        [Parameter("Trade Side")]
        public TradeType TradeType { get; set; }

        [Parameter("Step (pips)", DefaultValue = 5, MinValue = 0.1, Step = 0.1)]
        public double StepPips { get; set; }

        [Parameter("Target Profit", DefaultValue = 20)]
        public double TargetProfit { get; set; }

        private bool enoughMoney = true;

        protected override void OnStart()
        {
            if (GridPositions.Length == 0)
                OpenPosition();
        }

        protected override void OnTick()
        {
            if (GridPositions.Sum(p => p.NetProfit) >= TargetProfit)
            {
                Print("Target profit is reached. Closing all grid positions");
                CloseGridPositions();
                Print("All grid positions are closed. Stopping cBot");
                Stop();
            }
            if (GridPositions.Length > 0 && enoughMoney)
            {
                var lastGridPosition = GridPositions.OrderBy(p => p.Pips).Last();
                var distance = CalculateDistanceInPips(lastGridPosition);

                if (distance >= StepPips)
                    OpenPosition();
            }
        }

        private Position[] GridPositions
        {
            get
            {
                return Positions
                    .Where(p => p.SymbolName == SymbolName && p.TradeType == TradeType)
                    .ToArray();
            }
        }

        private double CalculateDistanceInPips(Position position)
        {
            if (position.TradeType == TradeType.Buy)
                return (position.EntryPrice - Symbol.Ask) / Symbol.PipSize;
            else
                return (Symbol.Bid - position.EntryPrice) / Symbol.PipSize;
        }

        private void OpenPosition()
        {
            var result = ExecuteMarketOrder(TradeType, SymbolName, Symbol.QuantityToVolumeInUnits(VolumeInLots), "Grid");
            if (result.Error == ErrorCode.NoMoney)
            {
                enoughMoney = false;
                Print("Not enough money to open additional positions");
            }
        }

        private void CloseGridPositions()
        {
            while (GridPositions.Length > 0)
            {
                foreach (var position in GridPositions)
                {
                    ClosePosition(position);
                }
            }
        }
    }
}

 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

import clr

clr.AddReference("cAlgo.API")

# Import cAlgo API types
from cAlgo.API import *

# Import trading wrapper functions
from robot_wrapper import *

class GridSample():
    def on_start(self):
        self.volumeInUnits = api.Symbol.QuantityToVolumeInUnits(api.VolumeInLots)
        self.enoughMoney = True
        if len(self.get_grid_positions()) == 0:
            self.open_position()

    def on_tick(self):
        grid_positions = self.get_grid_positions()
        net_profit_sum = sum([p.NetProfit for p in grid_positions])
        if net_profit_sum >= api.TargetProfit:
            api.Print("Target profit is reached. Closing all grid positions")
            self.close_grid_positions()
            api.Print("All grid positions are closed. Stopping cBot")
            api.Stop()

        if len(grid_positions) > 0 and self.enoughMoney == True:
            position_with_highest_pips = sorted(grid_positions, key=lambda pos: pos.Pips, reverse=True)[0]
            distance = self.get_distance_in_pips(position_with_highest_pips)          
            if distance >= api.StepPips:
                self.open_position()

    def get_grid_positions(self):
        return [pos for pos in api.Positions if pos.SymbolName == api.SymbolName and pos.TradeType == api.TradeType]

    def open_position(self):
        result = api.ExecuteMarketOrder(api.TradeType, api.SymbolName, self.volumeInUnits, "Grid")
        if result.Error == ErrorCode.NoMoney:
            self.enoughMoney = False
            api.Print("Not enough money to open additional positions")

    def close_grid_positions(self):
        for position in self.get_grid_positions():
            position.Close()

        if len(self.get_grid_positions()) > 0:
            self.close_grid_positions()

    def get_distance_in_pips(self, position):
        return (position.EntryPrice - api.Symbol.Ask if position.TradeType == TradeType.Buy else api.Symbol.Bid - position.EntryPrice) / api.Symbol.PipSize

Integrasi indikator ¶

Grid cBot tidak bergantung pada mana-mana penunjuk untuk menentukan strategi gridnya; ia tidak cuba meramalkan sama ada harga simbol akan naik atau turun. Sebaliknya, ia mensasarkan dagangan yang menguntungkan daripada pergerakan harga dalam mana-mana arah.

cBot melaksanakan dagangan berdasarkan peraturan mudah ini: Jika harga simbol bergerak melebihi bilangan pip yang ditetapkan (ditakrifkan oleh parameter StepPips), cBot membuka posisi baharu.

Pengiraan dan logik ¶

Pelaksanaan dagangan awal ¶

Apabila cBot bermula, ia memeriksa sama ada terdapat sebarang posisi terbuka dalam grid. Jika tiada posisi terbuka, cBot membuka posisi pertama dengan serta-merta melalui kaedah OpenPosition(). Langkah pertama ini memastikan grid bermula dengan dagangan awal berdasarkan bahagian dagangan yang ditetapkan (TradeType).

Pemantauan keuntungan ¶

Pada setiap tik (contohnya, setiap kemas kini harga), cBot memeriksa sama ada keuntungan bersih kumulatif semua posisi grid terbuka memenuhi atau melebihi keuntungan sasaran yang ditetapkan (TargetProfit). Jika keuntungan sasaran telah dicapai, semua posisi terbuka ditutup, dan cBot berhenti berjalan.

Keuntungan sasaran adalah jumlah keuntungan bersih daripada setiap posisi dalam grid.

\(n\) – bilangan posisi terbuka dalam grid

\(\text{NetProfit}(p_i)\) – keuntungan bersih posisi \(i\)

Membuka posisi ¶

Jika keuntungan sasaran belum dicapai dan terdapat posisi terbuka, cBot mengira jarak (dalam pip) antara posisi grid terakhir yang dibuka dan harga pasaran semasa.

Untuk posisi beli:

Untuk posisi jual:

\(D_b\) – jarak dalam pip antara harga entri dan harga tawaran semasa.

\(D_s\) – jarak dalam pip antara harga bidaan semasa dan harga entri.

\(P_e\) – harga di mana posisi beli terakhir untuk simbol dibuka.

\(P_a\) – harga tawaran semasa untuk simbol.

\(P_b\) – harga bidaan semasa untuk simbol.

\(S\) – nilai satu pip untuk simbol.

Jika jarak yang dikira adalah lebih besar atau sama dengan saiz langkah yang ditentukan (StepPips), posisi baharu dibuka menggunakan kaedah OpenPosition().

Setiap kali sebelum membuka posisi baharu, cBot memeriksa dan mengesahkan bahawa terdapat dana yang mencukupi untuk operasi tersebut. Jika dana tidak mencukupi, cBot berhenti cuba membuka posisi baharu dan mencatat mesej "Tidak cukup wang untuk membuka posisi tambahan".

Menutup posisi ¶

Sebaik sahaja TargetProfit dicapai, cBot mencatat mesej "Keuntungan sasaran telah dicapai. Menutup semua posisi grid".

Kaedah CloseGridPositions() kemudian mengulangi semua posisi terbuka dalam grid, menutupnya dan kemudian cBot mencatat mesej "Semua posisi grid telah ditutup. Menghentikan cBot". cBot kemudiannya dihentikan.

Parameter ¶

Penggunaan ¶

Pasaran terikat julat atau sisi ¶

Grid cBot paling berkesan dalam pasaran terikat julat di mana harga berayun antara tahap sokongan dan rintangan. Dalam pasaran sedemikian, apabila harga kerap bergerak naik dan turun dalam julat yang ditentukan, cBot membuka posisi secara tetap dan mengambil kesempatan daripada turun naik.

Pasaran turun naik rendah ¶

Dalam pasaran turun naik rendah, pergerakan harga cenderung perlahan dan kurang ketara. Apabila harga bergerak secara beransur-ansur, Grid cBot mendapat masa yang mencukupi untuk membuka pelbagai posisi tanpa menghadapi risiko pergerakan pasaran yang besar dan pantas.

Pasaran dengan tahap yang diketahui ¶

Grid cBot boleh berfungsi dengan baik dalam pasaran dengan tahap sokongan dan rintangan yang kuat dan jelas ditentukan. Tahap tersebut bertindak sebagai halangan harga dan menyebabkan pasaran kerap melantun kembali, menghasilkan julat yang boleh dieksploitasi oleh cBot.

Pasaran tidak berarah ¶

Pasangan mata wang tertentu menunjukkan pergerakan tidak berarah dengan turun naik harga yang kerap, tetapi harganya tidak menunjukkan trend jangka panjang yang kuat. Grid cBot berfungsi dengan baik dalam pasaran sedemikian kerana ia boleh menangkap turun naik yang kerap tanpa risiko terperangkap dalam trend jangka panjang.

Ringkasan ¶

Grid cBot beroperasi berdasarkan andaian bahawa semasa pasaran menaik dan menurun, akan ada pembalikan atau penarikan balik. Ia membeli rendah dan menjual tinggi dalam pasaran menaik dan menjual tinggi dan membeli rendah dalam pasaran menurun; cBot mendapat keuntungan apabila pasaran menyambung semula trend utama selepas pembalikan.

Oleh kerana cBot tidak menggunakan indikator, ia tidak dapat menilai sama ada pasaran sedang menunjukkan trend atau berada dalam julat. Ia hanya membuka posisi berdasarkan pergerakan harga sahaja, mengabaikan sentimen pasaran atau kekuatan trend.

Ketiadaan indikator menjadikan proses dagangan benar-benar mekanikal; cBot hanya bergantung pada peraturan yang telah ditetapkan untuk membuka posisi pada selang yang tetap. Walaupun pendekatan ini boleh menguntungkan dalam pasaran terikat julat, ia cenderung mengalami kerugian dalam pasaran yang menunjukkan trend, sangat tidak menentu atau berubah dengan cepat.

Selain mengkonfigurasi cBot untuk menggunakan strategi peribadi mereka, pedagang boleh mempertimbangkan untuk memperkenalkan indikator untuk menapis dagangan berdasarkan keadaan pasaran:

• Moving Averages (MA) boleh membantu mengenal pasti trend pasaran, membolehkan cBot berdagang hanya mengikut arah trend.
• Relative Strength Index (RSI) boleh memberi isyarat keadaan terlebih beli atau terlebih jual, membantu cBot mengelak daripada membuka posisi baharu apabila pasaran terlebih regangan dalam satu arah.
• Bollinger Bands boleh memberikan gambaran tentang turun naik harga, membolehkan cBot menyesuaikan jarak grid atau menahan diri daripada berdagang semasa tempoh turun naik yang tinggi.