Churning — Kẻ Thù Im Lặng Phá Hủy Tài Khoản Lưới

Hãy tưởng tượng bot Nhị Quái V6 Pro vừa hoàn thành một thao tác Gặt X hoàn hảo: chốt lời tầng Buy số 5 tại đúng mức +X pips. Tài khoản cộng thêm một khoản lãi nhỏ, margin được giải phóng. Mọi thứ diễn ra đúng kế hoạch.

Nhưng thị trường ngay lập tức chơi xấu: giá quay đầu nhỏ và dao động ngay tại ranh giới tầng vừa đóng, lên xuống lên xuống trong một biên độ vài pips. Nếu không có cơ chế bảo vệ, bot sẽ:

1. Phát hiện giá vượt xuống mức tầng 5 → mở Buy lại
2. Giá vừa nhúc nhích lên → đạt +X → Gặt X → đóng lại
3. Giá lại xuống → mở Buy lại lần nữa
4. Lặp lại vô hạn trong vài phút…

Kết quả: mỗi lần mở/đóng, sàn thu spread + commission. 100 lần mở đóng tại một tầng = 100 lần nộp phí cho sàn. Tài khoản bị bào mòn từ từ bởi chi phí giao dịch dù trên màn hình có vẻ bot đang “hoạt động bình thường” — đây gọi là hiện tượng Churning (rác lệnh).

Thuật toán Khóa Tầng & Vùng Đệm Khoảng Lùi An Toàn (Reopen Buffer) trong Nhị Quái V6 Pro được thiết kế chính xác để ngăn chặn kịch bản này.

---

1. Toán Học Hysteresis: Nguyên Lý Kiểm Soát Vùng Đệm

1.1. Vấn Đề Với Trigger Đơn Điểm

Trong kỹ thuật điều khiển tự động, khi một hệ thống chỉ có một ngưỡng kích hoạt duy nhất (ON/OFF threshold), nó sẽ rung động liên tục khi tín hiệu dao động gần ngưỡng đó. Ví dụ: thermostat bật/tắt liên tục khi nhiệt độ phòng dao động ngay quanh 25°C.

Giải pháp kinh điển là Hysteresis: thiết lập hai ngưỡng riêng biệt — ngưỡng BẬT và ngưỡng TẮT — tạo ra một vùng đệm trung lập giữa hai trạng thái.

1.2. Áp Dụng Hysteresis Vào Lưới Giao Dịch

Trong Nhị Quái V6 Pro, logic Hysteresis được áp dụng cho việc mở khóa tầng như sau:

• Trạng thái LOCKED (khóa): Kích hoạt ngay khi tầng chốt lời (Gặt X hoặc Trailing Plow)
• Vùng đệm trung lập: Tầng ở trạng thái “nghỉ ngơi bắt buộc”, không nhận lệnh mới
• Trạng thái UNLOCKED (mở khóa): Chỉ kích hoạt khi giá lùi ra xa khỏi tầng ≥ ReopenBuffer

Công thức tính khoảng đệm an toàn:

// Khoảng lùi tối thiểu cần thiết để mở khóa tầng
ReopenMin = (InpReopenBuffer / 100.0) × GridStep

// Điều kiện mở khóa (cho Buy grid):
|CurrentPrice - StepPrice| > ReopenMin

1.3. Chọn Giá Trị ReopenBuffer Thực Chiến

Buffer %	Ưu điểm	Nhược điểm	Phù hợp
20-30%	Mở khóa nhanh, ít bỏ lỡ	Vẫn có thể bị churning nhẹ	Thị trường xu hướng mạnh
40-60%	Cân bằng, hiệu quả tốt	Mức trung bình	Đa số tình huống
70-100%	Chống churning tối đa	Có thể bỏ lỡ cơ hội vào lệnh	Thị trường sideway nhiều

---

2. Kiến Trúc Hai Lớp Khóa: X_CLOSED và PLOW_CLOSED

2.1. Tại Sao Cần Hai Loại Cờ Khóa?

Nhị Quái V6 Pro phân biệt hai nguồn gốc đóng lệnh khác nhau và xử lý hậu kỳ khác nhau:

• _X_CLOSED_: Tầng đóng do Gặt X (chốt lời tại mức cố định +X). Tầng này có thể mở khóa tương đối sớm vì giá đã bounce một lần rõ ràng.
• _PLOW_CLOSED_: Tầng đóng do Trailing Plowing (giá chạy xa, cày nhiều mốc). Tầng này cần vùng đệm lớn hơn vì thường xảy ra trong xu hướng mạnh và giá có thể tiếp tục chạy xa trước khi pullback.

// Cấu trúc tên Global Variable cho cờ khóa
string GV_X_CLOSED    = prefix + "_" + step_str + "_X_CLOSED";
string GV_PLOW_CLOSED = prefix + "_" + step_str + "_PLOW_CLOSED";

// Khi Gặt X thành công:
GlobalVariableSet(GV_X_CLOSED, TimeCurrent());

// Khi Trailing Plow đóng:
GlobalVariableSet(GV_PLOW_CLOSED, TimeCurrent());

2.2. Lưu Timestamp Thay Vì Boolean Flag

Thay vì lưu true/false đơn giản, Nhị Quái lưu TimeCurrent() (timestamp Unix khi khóa được đặt). Lý do:

• Debug dễ hơn: Biết chính xác tầng bị khóa lúc mấy giờ
• Timeout tự động: Có thể thiết lập cơ chế mở khóa tự động sau N giờ nếu cần
• Audit trail: Trace lại lịch sử hoạt động của từng tầng

---

3. Mã Nguồn MQL5 Đầy Đủ Thực Chiến

3.1. Hàm IsSafeToReopen() — Kiểm Tra Vùng Đệm

//+------------------------------------------------------------------+
//| Kiểm tra xem tầng giá đã đủ xa để mở khóa chưa                 |
//| step_price: giá danh nghĩa của tầng cần kiểm tra                |
//| price_ref : giá tham chiếu hiện tại (bid hoặc ask)              |
//| step_size : khoảng cách một bước lưới (tính bằng giá, không pips)|
//| buffer_pct: % khoảng lùi tối thiểu so với step_size             |
//+------------------------------------------------------------------+
bool IsSafeToReopen(double step_price, double price_ref,
                    double step_size, double buffer_pct) {
    if(step_size <= 0 || buffer_pct  buffer_dist);
}

3.2. Hàm CheckAndReopenLayer() — Xử Lý Mở Khóa

//+------------------------------------------------------------------+
//| Kiểm tra và mở khóa tầng nếu điều kiện vùng đệm đã thỏa mãn   |
//+------------------------------------------------------------------+
void CheckAndReopenLayer(int magic, int step, double step_price,
                         double price_ref, double step_size) {
    string prefix    = GetGVPrefix(magic);
    string step_str  = IntegerToString(step);
    string gv_x      = prefix + "_" + step_str + "_X_CLOSED";
    string gv_plow   = prefix + "_" + step_str + "_PLOW_CLOSED";

    bool is_x_locked    = GlobalVariableCheck(gv_x);
    bool is_plow_locked = GlobalVariableCheck(gv_plow);

    // Không có cờ khóa nào → không cần làm gì
    if(!is_x_locked && !is_plow_locked) return;

    // Kiểm tra điều kiện vùng đệm
    double buffer_pct = InpReopenBuffer;  // Từ input parameters
    bool safe = IsSafeToReopen(step_price, price_ref, step_size, buffer_pct);

    if(safe) {
        // Xóa cờ khóa để giải phóng tầng
        if(is_x_locked) {
            GlobalVariableDel(gv_x);
            PrintFormat("🔓 [REOPEN] Tầng %d (magic=%d) mở khóa X_CLOSED. "
                        "Khoảng lùi: %.1f pips",
                        step, magic,
                        MathAbs(price_ref - step_price) / _Point);
        }
        if(is_plow_locked) {
            GlobalVariableDel(gv_plow);
            PrintFormat("🔓 [REOPEN] Tầng %d (magic=%d) mở khóa PLOW_CLOSED.",
                        step, magic);
        }
    }
}

3.3. Tích Hợp Vào Vòng Lặp Quét Chính

//+------------------------------------------------------------------+
//| Quét toàn bộ tầng và cập nhật trạng thái khóa                  |
//+------------------------------------------------------------------+
void ProcessAllLayerLocks(int magic, ENUM_POSITION_TYPE pos_type) {
    double p0         = GlobalVariableGet(GetGVPrefix(magic) + "_P0");
    double step_size  = (magic == InpBuyMagic) ? InpBuyStep : InpSellStep;
    int    max_layers = (magic == InpBuyMagic) ? InpBuyMaxLayer : InpSellMaxLayer;

    double price_ref  = (pos_type == POSITION_TYPE_BUY) ?
                        SymbolInfoDouble(_Symbol, SYMBOL_BID) :
                        SymbolInfoDouble(_Symbol, SYMBOL_ASK);

    // Quét từ tầng âm đến tầng dương
    for(int s = -max_layers; s <= max_layers; s++) {
        if(s == 0) continue;  // Tầng 0 không áp dụng khóa

        double step_price = p0 + s * step_size;
        CheckAndReopenLayer(magic, s, step_price, price_ref, step_size);
    }
}

---

4. Sơ Đồ Luồng Khóa — Vùng Đệm — Mở Khóa

Chu Kỳ Khóa — Vùng Đệm — Mở Khóa Tầng Lưới

Tầng s: READY → Mở lệnh

Chốt lời: Gặt X / Plow

🔒 LOCKED — Cờ GV đặt = TimeCurrent()

Vùng Đệm: giá chưa lùi đủ buffer_dist

|price – step| > ReopenMin?

🔓 UNLOCKED — Sẵn sàng chu kỳ mới

NO → chờ tiếp
YES

---

5. Tương Tác Với FSM Chống Trùng Lệnh (Bài 4)

Reopen Buffer và FSM (Bài 4) cùng bảo vệ một mục tiêu nhưng ở hai tầng khác nhau:

Cơ chế	Bảo vệ khỏi	Thời điểm hoạt động
FSM (Bài 4)	Trùng lệnh trong khi chờ server xác nhận	Ngay khi gửi OrderSend
Reopen Buffer	Churning sau khi tầng đã đóng	Sau khi lệnh đóng thành công

// Logic kiểm tra kết hợp trước khi mở lệnh:
bool CanOpenLayerBuy(int magic, int step, double step_price) {
    // Kiểm tra 1: FSM không bận
    if(GetFSMState(magic, step, POSITION_TYPE_BUY) == STEP_BUSY)
        return false;

    // Kiểm tra 2: Reopen Buffer đã đủ khoảng lùi
    double step_size = InpBuyStep;
    double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
    string gv_x    = GetGVPrefix(magic) + "_" + IntegerToString(step) + "_X_CLOSED";
    string gv_plow = GetGVPrefix(magic) + "_" + IntegerToString(step) + "_PLOW_CLOSED";

    if(GlobalVariableCheck(gv_x) || GlobalVariableCheck(gv_plow)) {
        if(!IsSafeToReopen(step_price, ask, step_size, InpReopenBuffer))
            return false;
    }

    // Kiểm tra 3: Chưa có lệnh Buy đang mở tại tầng này
    if(HasOpenPositionAtLayer(magic, step, POSITION_TYPE_BUY))
        return false;

    return true;
}

---

6. Debugging Và Monitoring Vùng Đệm

// Hàm hiển thị trạng thái tất cả tầng trên Dashboard
void ShowLayerStatus(int magic, ENUM_POSITION_TYPE pos_type) {
    double p0        = GlobalVariableGet(GetGVPrefix(magic) + "_P0");
    double step_size = (magic == InpBuyMagic) ? InpBuyStep : InpSellStep;
    double price_ref = SymbolInfoDouble(_Symbol,
                       pos_type == POSITION_TYPE_BUY ? SYMBOL_BID : SYMBOL_ASK);
    int    max_s     = (magic == InpBuyMagic) ? InpBuyMaxLayer : InpSellMaxLayer;

    string type_str = (magic == InpBuyMagic) ? "BUY" : "SELL";
    Comment("=== LAYER STATUS [" + type_str + "] ===n");

    for(int s = max_s; s >= -max_s; s--) {
        if(s == 0) continue;
        string prefix   = GetGVPrefix(magic);
        string step_str = IntegerToString(s);
        bool x_locked   = GlobalVariableCheck(prefix+"_"+step_str+"_X_CLOSED");
        bool p_locked   = GlobalVariableCheck(prefix+"_"+step_str+"_PLOW_CLOSED");

        double step_p   = p0 + s * step_size;
        double dist     = MathAbs(price_ref - step_p) / _Point;
        double need     = (InpReopenBuffer/100.0) * step_size / _Point;

        string status   = "FREE";
        if(x_locked)    status = "X_LOCK (dist=" + DoubleToString(dist,0) + " need>" + DoubleToString(need,0) + ")";
        if(p_locked)    status = "PLOW_LOCK";

        Print("[s=" + step_str + "] " + status);
    }
}

---

7. Tuning Reopen Buffer Theo Điều Kiện Thị Trường

7.1. Phân Tích ATR Để Chọn Buffer Phù Hợp

// Tính ATR 14 kỳ và so sánh với bước lưới để gợi ý buffer
double ATR14 = iATR(_Symbol, _Period, 14);
double ratio = ATR14 / InpBuyStep;

double recommended_buffer;
if(ratio < 0.3) {
    recommended_buffer = 30.0;  // Thị trường ít biến động → buffer nhỏ
} else if(ratio < 0.7) {
    recommended_buffer = 50.0;  // Biến động trung bình
} else {
    recommended_buffer = 70.0;  // Biến động cao → buffer lớn
}

PrintFormat("ATR14=%.1f pips, Step=%.1f pips, Ratio=%.2f → Gợi ý ReopenBuffer=%.0f%%",
            ATR14/_Point, InpBuyStep/_Point, ratio, recommended_buffer);

7.2. Adaptive Buffer (Nâng Cao)

// Buffer tự động điều chỉnh theo spread hiện tại
double GetAdaptiveBuffer(double base_buffer_pct) {
    double spread    = SymbolInfoInteger(_Symbol, SYMBOL_SPREAD) * _Point;
    double step_size = InpBuyStep;

    // Tối thiểu buffer = 3× spread để đảm bảo không bị churning
    double min_buffer_pct = (spread * 3 / step_size) * 100;

    return MathMax(base_buffer_pct, min_buffer_pct);
}

---

8. Kết Luận: Lá Chắn Tài Chính Thiết Yếu

Thuật toán Reopen Buffer là lá chắn tài chính thiết yếu nhưng thường bị đánh giá thấp. Trong khi các thuật toán như Gặt X và Trailing Plowing mang lại lợi nhuận, Reopen Buffer bảo vệ lợi nhuận đó không bị bào mòn bởi chi phí giao dịch lặp lại tại cùng một tầng giá.

Nguyên tắc quan trọng nhất cần ghi nhớ:

• Luôn lưu cờ khóa vào Global Variable — không phải biến tạm trong RAM
• Timestamp thay vì boolean — linh hoạt hơn cho debugging và timeout logic
• Hai loại cờ riêng biệt (X_CLOSED, PLOW_CLOSED) — xử lý khác nhau nếu cần
• Kết hợp với FSM (Bài 4) — hai tầng bảo vệ bổ sung nhau

Trong bài tiếp theo (Bài 6 — FSM Chống Trùng Lệnh), chúng ta sẽ đi sâu vào cơ chế ngăn ngừa bot mở nhiều lệnh cùng lúc tại cùng một tầng trong những nano-giây thị trường biến động cực mạnh.