Grid cBot¶

Ikhtisar strategi ¶

Grid cBot menerapkan strategi trading grid di mana beberapa order beli atau jual untuk suatu simbol ditempatkan pada interval harga reguler atau "langkah", membentuk "grid" posisi. Saat harga simbol berubah, posisi baru terus dibuka untuk memanfaatkan fluktuasi.

Grid cBot menggunakan kombinasi aritmatika sederhana dan pemeriksaan logis untuk membuka posisi, menghitung keuntungan, dan mengelola operasi trading-nya. Ini paling efektif dalam pasar yang terikat rentang atau sideways. Ini juga berkinerja baik dalam kondisi volatilitas rendah dan pasar dengan level resistance dan support yang diketahui.

Pembuatan cBot ¶

Pelajari cara membuat cBot, menggunakan C# atau Python, dalam panduan langkah demi langkah kami.

Kode Grid cBot tersedia di repositori publik kami C# dan Python. Kode yang sama disediakan sebagai templat dalam wizard pembuatan algoritma di cTrader Windows atau Mac, atau Anda dapat menyalin dan menggunakan cuplikan di bawah ini:

 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 indikator apa pun untuk mendefinisikan strategi grid-nya; ia tidak mencoba memprediksi apakah harga simbol akan naik atau turun. Sebaliknya, ia menargetkan trading yang menguntungkan dari pergerakan harga ke segala arah.

cBot mengeksekusi trading berdasarkan aturan sederhana ini: Jika harga simbol bergerak melampaui jumlah pip tertentu (ditentukan oleh parameter StepPips), cBot membuka posisi baru.

Perhitungan dan logika ¶

Eksekusi trading awal ¶

Ketika cBot mulai, ia memeriksa apakah ada posisi terbuka dalam grid. Jika tidak ada posisi terbuka, cBot membuka posisi pertama segera melalui metode OpenPosition(). Langkah pertama ini memastikan bahwa grid dimulai dengan trading awal berdasarkan sisi trading yang ditentukan (TradeType).

Pemantauan laba ¶

Pada setiap tick (misalnya, setiap pembaruan harga), cBot memeriksa apakah laba bersih kumulatif dari semua posisi grid yang terbuka memenuhi atau melebihi laba target yang ditentukan (TargetProfit). Jika laba target telah tercapai, semua posisi terbuka akan ditutup, dan cBot berhenti berjalan.

Laba target adalah jumlah laba bersih dari setiap posisi dalam grid.

\(n\) – jumlah posisi terbuka dalam grid

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

Pembukaan posisi ¶

Jika laba target belum tercapai dan ada posisi terbuka, cBot menghitung jarak (dalam pip) antara posisi grid terakhir yang dibuka dan harga pasar saat ini.

Untuk posisi beli:

Untuk posisi jual:

\(D_b\) – jarak dalam pip antara harga entri dan harga Ask saat ini.

\(D_s\) – jarak dalam pip antara harga Bid saat ini dan harga entri.

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

\(P_a\) – harga Ask saat ini untuk simbol.

\(P_b\) – harga Bid saat ini untuk simbol.

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

Jika jarak yang dihitung lebih besar atau sama dengan ukuran langkah yang ditentukan (StepPips), posisi baru dibuka menggunakan metode OpenPosition().

Setiap kali sebelum membuka posisi baru, cBot memeriksa dan memastikan bahwa ada cukup dana untuk operasi tersebut. Jika dana tidak mencukupi, cBot berhenti mencoba membuka posisi baru dan mencatat pesan "Dana tidak cukup untuk membuka posisi tambahan".

Menutup posisi ¶

Setelah TargetProfit tercapai, cBot mencatat pesan "Target profit tercapai. Menutup semua posisi grid".

Metode CloseGridPositions() kemudian mengulang semua posisi terbuka dalam grid, menutupnya, dan kemudian cBot mencatat pesan "Semua posisi grid telah ditutup. Menghentikan cBot". cBot kemudian dihentikan.

Parameter ¶

Penerapan ¶

Pasar yang bergerak sideways atau dalam rentang ¶

Grid cBot paling efektif di pasar range-bound di mana harga berosilasi antara level support dan resistance. Di pasar seperti itu, karena harga sering bergerak naik turun dalam rentang yang ditentukan, cBot membuka posisi secara teratur dan memanfaatkan fluktuasi.

Pasar dengan volatilitas rendah ¶

Di pasar dengan volatilitas rendah, pergerakan harga cenderung lambat dan kurang jelas. Saat harga bergerak secara bertahap, Grid cBot mendapatkan waktu yang cukup untuk membuka beberapa posisi tanpa menghadapi risiko pergerakan pasar yang besar dan cepat.

Pasar dengan level yang diketahui ¶

Grid cBot dapat berkinerja baik di pasar dengan level support dan resistance yang kuat dan terdefinisi dengan baik. Level-level tersebut bertindak sebagai penghalang harga dan menyebabkan pasar sering memantul kembali, menghasilkan rentang yang dapat dieksploitasi oleh cBot.

Pasar non-direksional ¶

Pasangan mata uang tertentu menunjukkan pergerakan non-direksional dengan fluktuasi harga yang sering, tetapi harganya tidak menunjukkan tren jangka panjang yang kuat. Grid cBot bekerja dengan baik di pasar seperti ini karena dapat menangkap fluktuasi yang sering tanpa risiko terjebak dalam tren jangka panjang.

Ringkasan ¶

Grid cBot beroperasi dengan asumsi bahwa selama pasar bullish dan bearish, akan ada retracement atau pullback. Ia membeli rendah dan menjual tinggi di pasar bullish serta menjual tinggi dan membeli rendah di pasar bearish; cBot menangkap keuntungan ketika pasar melanjutkan tren utama setelah retracement.

Karena cBot tidak menggunakan indikator, ia tidak dapat menilai apakah pasar sedang trending atau ranging. Ia hanya membuka posisi berdasarkan pergerakan harga saja, mengabaikan sentimen pasar atau kekuatan tren.

Tidak adanya indikator membuat proses trading menjadi murni mekanis; cBot hanya mengandalkan aturan yang telah ditentukan sebelumnya untuk membuka posisi pada interval yang teratur. Meskipun pendekatan ini dapat menguntungkan di pasar yang terikat range, cenderung menderita di pasar yang trending, sangat volatil, atau berubah dengan cepat.

Selain mengonfigurasi cBot untuk menerapkan strategi pribadi mereka, trader dapat mempertimbangkan untuk memperkenalkan indikator untuk memfilter trading berdasarkan kondisi pasar:

• Moving Averages (MA) dapat membantu mengidentifikasi tren pasar, memungkinkan cBot untuk trading hanya dalam arah tren.
• Relative Strength Index (RSI) dapat menandakan kondisi overbought atau oversold, membantu cBot menghindari pembukaan posisi baru saat pasar terlalu tertekam ke satu arah.
• Bollinger Bands dapat memberikan wawasan tentang volatilitas harga, memungkinkan cBot untuk menyesuaikan jarak grid atau menahan diri dari trading selama periode volatilitas tinggi.