Grid cBot¶

ภาพรวมกลยุทธ์ ¶

Grid cBot ดำเนินกลยุทธ์การเทรดแบบ Grid โดยการวางคำสั่งซื้อหรือขายหลายรายการสำหรับสัญลักษณ์หนึ่งๆ ที่ช่วงราคาปกติหรือ "ขั้นตอน" เพื่อสร้าง "กริด" ของโพสิชัน เมื่อราคาของสัญลักษณ์เปลี่ยนแปลง โพสิชันใหม่จะถูกเปิดอย่างต่อเนื่องเพื่อใช้ประโยชน์จากการเปลี่ยนแปลงของราคา

Grid cBot ใช้การคำนวณทางคณิตศาสตร์พื้นฐานและการตรวจสอบเชิงตรรกะเพื่อเปิดโพสิชัน คำนวณกำไรและจัดการการดำเนินการเทรด กลยุทธ์นี้มีประสิทธิภาพสูงสุดในตลาดที่เคลื่อนไหวในกรอบหรือตลาดที่เคลื่อนไหวด้านข้าง นอกจากนี้ยังทำงานได้ดีในสภาวะที่มีความผันผวนต่ำและตลาดที่มีระดับแนวรับและแนวต้านที่รู้จัก

การสร้าง cBot ¶

เรียนรู้วิธี สร้าง cBot โดยใช้ C# หรือ Python ใน คู่มือ ขั้นตอนต่อขั้นตอนของเรา

โค้ด Grid cBot มีอยู่ในที่เก็บสาธารณะของเราใน C# และ Python โค้ดเดียวกันนี้ถูกจัดเตรียมเป็นเทมเพลตใน วิซาร์ดการสร้างอัลกอริทึม ใน cTrader Windows หรือ Mac หรือคุณสามารถคัดลอกและใช้ตัวอย่างโค้ดด้านล่างได้:

 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

การรวมอินดิเคเตอร์ ¶

Grid cBot ไม่ได้พึ่งพา Indicator ใดๆ เพื่อกำหนดกลยุทธ์ Grid ของมัน มันไม่ได้พยายามทำนายว่าคราคาของสัญลักษณ์จะขึ้นหรือลง แต่กลับมุ่งเป้าไปที่การเทรดที่ทำกำไรจากการเคลื่อนไหวของราคาในทุกทิศทาง

cBot จะดำเนินการเทรดตามกฎง่ายๆ ดังนี้: หากราคาของสัญลักษณ์เคลื่อนไหวเกินจำนวน pips ที่กำหนด (กำหนดโดยพารามิเตอร์ StepPips) cBot จะเปิดโพสิชันใหม่

การคำนวณและตรรกะ ¶

การดำเนินการคำสั่งซื้อขายเริ่มต้น ¶

เมื่อ cBot เริ่มต้น มันจะตรวจสอบว่ามีโพสิชันที่เปิดอยู่ใน Grid หรือไม่ หากไม่มีโพสิชันที่เปิดอยู่ cBot จะเปิดโพสิชันแรกทันทีผ่านเมธอด OpenPosition() ขั้นตอนแรกนี้ทำให้มั่นใจว่า Grid จะเริ่มต้นด้วยการเทรดเริ่มต้นตามด้านการเทรดที่ระบุ (TradeType)

การติดตามกำไร ¶

ในแต่ละ Tick (เช่น การอัปเดตราคาแต่ละครั้ง) cBot จะตรวจสอบว่ากำไรสุทธิสะสมของโพสิชัน Grid ที่เปิดอยู่ทั้งหมดตรงหรือเกินกำไรเป้าหมายที่กำหนด (TargetProfit) หรือไม่ หากกำไรเป้าหมายถูกบรรลุถึง โพสิชันที่เปิดอยู่ทั้งหมดจะถูกปิด และ cBot จะหยุดทำงาน

กำไรเป้าหมายคือผลรวมของกำไรสุทธิจากแต่ละโพสิชันใน Grid

\(n\) – จำนวนโพสิชันที่เปิดอยู่ใน Grid

\(\text{NetProfit}(p_i)\) – กำไรสุทธิของโพสิชัน \(i\)

การเปิดโพสิชัน ¶

หากยังไม่ถึงเป้าหมายกำไรและมีโพสิชันที่เปิดอยู่ cBot จะคำนวณระยะทาง (เป็น pip) ระหว่างโพสิชันกริดที่เปิดล่าสุดและราคาตลาดปัจจุบัน

สำหรับโพสิชัน Long:

สำหรับโพสิชัน Short:

\(D_b\) – ระยะทางเป็น pip ระหว่างราคาเข้าและราคา Ask ปัจจุบัน

\(D_s\) – ระยะทางเป็น pip ระหว่างราคา Bid ปัจจุบันและราคาเข้า

\(P_e\) – ราคาที่โพสิชัน Long ล่าสุดสำหรับสัญลักษณ์ถูกเปิด

\(P_a\) – ราคา Ask ปัจจุบันสำหรับสัญลักษณ์

\(P_b\) – ราคา Bid ปัจจุบันสำหรับสัญลักษณ์

\(S\) – มูลค่าของหนึ่ง pip สำหรับสัญลักษณ์

หากระยะทางที่คำนวณได้มากกว่าหรือเท่ากับขนาดขั้นที่กำหนด (StepPips) โพสิชันใหม่จะถูกเปิดโดยใช้เมธอด OpenPosition()

ทุกครั้งก่อนที่จะเปิดโพสิชันใหม่ cBot จะตรวจสอบและยืนยันว่ามีเงินทุนเพียงพอสำหรับการดำเนินการ หากเงินทุนไม่เพียงพอ cBot จะหยุดการพยายามเปิดโพสิชันใหม่และบันทึกข้อความ "Not enough money to open additional positions"

การปิดโพสิชัน ¶

เมื่อถึง TargetProfit แล้ว cBot จะบันทึกข้อความ "Target profit is reached. Closing all grid positions"

จากนั้นเมธอด CloseGridPositions() จะวนลูปผ่านโพสิชันทั้งหมดที่เปิดอยู่ในกริด ปิดโพสิชันเหล่านั้น และ cBot จะบันทึกข้อความ "All grid positions are closed. Stopping cBot" จากนั้น cBot จะถูกหยุด

พารามิเตอร์ ¶

การประยุกต์ ¶

ตลาดที่เคลื่อนไหวในกรอบหรือตลาดด้านข้าง ¶

Grid cBot มีประสิทธิภาพสูงสุดในตลาดที่เคลื่อนไหวในกรอบ โดยที่ราคาแกว่งตัวระหว่างระดับ Support และ Resistance ในตลาดดังกล่าว เนื่องจากราคามักเคลื่อนที่ขึ้นและลงภายในกรอบที่กำหนด cBot จะเปิดโพสิชันเป็นประจำและใช้ประโยชน์จากความผันผวน

ตลาดที่มีความผันผวนต่ำ ¶

ในตลาดที่มีความผันผวนต่ำ การเคลื่อนไหวของราคามักจะช้าและไม่รุนแรง เมื่อราคาเคลื่อนที่อย่างค่อยเป็นค่อยไป Grid cBot จะมีเวลามากพอที่จะเปิดหลายโพสิชันโดยไม่ต้องเผชิญกับความเสี่ยงของการเคลื่อนไหวของตลาดที่ใหญ่และรวดเร็ว

ตลาดที่มีระดับที่ทราบ ¶

Grid cBot สามารถทำงานได้ดีในตลาดที่มีระดับแนวรับและแนวต้านที่แข็งแกร่งและชัดเจน ระดับเหล่านั้นทำหน้าที่เป็นกำแพงราคาและทำให้ตลาดมักจะเด้งกลับ ส่งผลให้เกิดช่วงราคาที่ cBot สามารถใช้ประโยชน์ได้

ตลาดที่ไม่มีการเคลื่อนไหวในทิศทางที่ชัดเจน ¶

คู่สกุลเงินบางคู่แสดงการเคลื่อนไหวที่ไม่มีการเคลื่อนไหวในทิศทางที่ชัดเจน โดยมีการผันผวนของราคาบ่อยครั้ง แต่ราคาของมันไม่แสดงแนวโน้มระยะยาวที่แข็งแกร่ง Grid cBot ทำงานได้ดีในตลาดดังกล่าวเพราะสามารถจับการผันผวนบ่อยครั้งได้โดยไม่มีความเสี่ยงที่จะติดอยู่ในแนวโน้มระยะยาว

สรุป ¶

Grid cBot ดำเนินการบนสมมติฐานที่ว่าในช่วงตลาดขาขึ้นและขาลง จะมีการถดถอยหรือดึงกลับ มันจะซื้อต่ำและขายสูงในตลาดขาขึ้น และขายสูงและซื้อต่ำในตลาดขาลง; Grid cBot จะจับกำไรเมื่อตลาดกลับสู่แนวโน้มหลักหลังจากถดถอย

เนื่องจาก Grid cBot ไม่ใช้อินดิเคเตอร์ มันจึงไม่สามารถประเมินได้ว่าตลาดกำลังอยู่ในแนวโน้มหรืออยู่ในช่วง มันเพียงแค่เปิดตำแหน่งตามการเคลื่อนไหวของราคาเท่านั้น โดยไม่สนใจความรู้สึกของตลาดหรือความแข็งแกร่งของแนวโน้ม

การไม่มีอินดิเคเตอร์ทำให้กระบวนการเทรดเป็นไปอย่างกลไกล้วนๆ; Grid cBot พึ่งพาเพียงกฎที่กำหนดไว้ล่วงหน้าในการเปิดตำแหน่งเป็นระยะ แม้ว่าวิธีการนี้จะสามารถทำกำไรได้ในตลาดที่อยู่ในช่วง แต่ก็มักจะประสบปัญหาในตลาดที่มีแนวโน้ม, มีความผันผวนสูง หรือเปลี่ยนแปลงอย่างรวดเร็ว

นอกจากการกำหนดค่า Grid cBot เพื่อใช้กลยุทธ์ส่วนตัวแล้ว นักเทรดอาจพิจารณาใช้อินดิเคเตอร์เพื่อกรองการเทรดตามสภาพตลาด:

• Moving Averages (MA) สามารถช่วยระบุแนวโน้มของตลาดได้ ทำให้ cBot สามารถเทรดได้เฉพาะในทิศทางของแนวโน้ม
• Relative Strength Index (RSI) สามารถส่งสัญญาณภาวะซื้อมากเกินไปหรือขายมากเกินไป ช่วยให้ cBot หลีกเลี่ยงการเปิดโพสิชันใหม่เมื่อตลาดถูกยืดในทิศทางเดียว
• Bollinger Bands สามารถให้ข้อมูลเกี่ยวกับความผันผวนของราคา ทำให้ cBot สามารถปรับระยะห่างของกริดหรือหยุดเทรดในช่วงที่มีความผันผวนสูง