Triết Lý Âm Dương: Lợi Nhuận Bù Lỗ

Trong chiến lược lưới hai chiều, tại bất kỳ thời điểm nào cũng có cả lệnh Buy lẫn lệnh Sell đang mở. Một số lệnh đang lãi (dương), một số đang lỗ (âm). Chiến lược Gặt X (Bài 7) và Trailing Plowing (Bài 8) chốt lời từng tầng đơn lẻ — nhưng điều gì xảy ra với những tầng đang “kẹt” lỗ?

Basket TP áp dụng triết lý Âm Dương bù trừ: thay vì xét từng tầng riêng lẻ, nhìn vào tổng lợi nhuận của toàn bộ cluster:

Total_Net = P_realized + P_floating

Trong đó:

• P_realized: Lợi nhuận đã chốt (từ Gặt X, Plowing đã thực hiện trong phiên)
• P_floating: Lợi nhuận nổi của tất cả vị thế đang mở (bao gồm cả tầng đang lỗ)

Khi Total_Net >= InpBasketTarget, robot đóng toàn bộ vị thế và reset cluster về trạng thái ban đầu. Kết quả: các tầng đang lãi “bù đắp” cho các tầng đang lỗ, và toàn bộ cluster kết thúc với lợi nhuận dương.

Đây là lý do tại sao chiến lược lưới có thể sinh lời ngay cả khi một số tầng đang lỗ nặng — miễn là tổng thể vẫn dương.

Kiến Trúc Basket TP

Tính P_Realized: Theo Dõi Lợi Nhuận Đã Chốt

Phần khó nhất của Basket TP là theo dõi P_realized — tổng lợi nhuận từ các lệnh đã đóng trong phiên hiện tại (từ lúc cluster bắt đầu đến bây giờ).

// Lưu P_realized trong GlobalVariable (tích lũy trong phiên)
string GetRealizedKey(long magic)
{
    return "_BASKET_REALIZED_" + IntegerToString((int)magic);
}

// Cộng thêm lợi nhuận mỗi khi Gặt X hoặc Plowing đóng lệnh
void AddRealizedProfit(long magic, double profit)
{
    string key = GetRealizedKey(magic);
    double current = GlobalVariableCheck(key) ? GlobalVariableGet(key) : 0.0;
    GlobalVariableSet(key, current + profit);

    Print("P_realized cập nhật: +", profit,
          " | Tổng=", current + profit);
}

// Đọc P_realized hiện tại
double GetRealizedProfit(long magic)
{
    string key = GetRealizedKey(magic);
    if(!GlobalVariableCheck(key)) return 0.0;
    return GlobalVariableGet(key);
}

// Reset P_realized khi bắt đầu cluster mới
void ResetRealizedProfit(long magic)
{
    string key = GetRealizedKey(magic);
    GlobalVariableDel(key);
    Print("P_realized đã reset về 0.");
}

Gọi AddRealizedProfit Ở Đâu?

Cần cộng lợi nhuận vào P_realized ngay sau khi lệnh được đóng thành công — trong hàm CloseStepWithLock():

// Trong CloseStepWithLock(), ngay sau OrderSend thành công:
double closed_profit = PositionGetDouble(POSITION_PROFIT)  // Đọc trước khi đóng
                     + PositionGetDouble(POSITION_SWAP);

// ... (gửi lệnh đóng)

if(result.retcode == TRADE_RETCODE_DONE)
{
    // Cộng vào P_realized cho Basket TP
    AddRealizedProfit(magic, closed_profit);

    // Đặt cờ Reopen Buffer (Bài 9)
    if(reason == CLOSE_REASON_HARVEST_X)
        SetXClosedFlag(magic, step, result.price);
    else if(reason == CLOSE_REASON_PLOWING)
        SetPlowClosedFlag(magic, step, result.price);
}

Tính P_Floating: Lợi Nhuận Nổi Hiện Tại

//+------------------------------------------------------------------+
//| Tính tổng lợi nhuận nổi của tất cả vị thế trong cluster         |
//+------------------------------------------------------------------+
double GetFloatingProfit(long magic)
{
    double total_floating = 0.0;
    int total = PositionsTotal();

    for(int i = 0; i < total; i++)
    {
        ulong ticket = PositionGetTicket(i);
        if(ticket == 0) continue;
        if(PositionGetInteger(POSITION_MAGIC) != magic) continue;
        if(PositionGetString(POSITION_SYMBOL) != _Symbol) continue;

        total_floating += PositionGetDouble(POSITION_PROFIT);
        total_floating += PositionGetDouble(POSITION_SWAP);
    }

    return NormalizeDouble(total_floating, 2);
}

Hàm CheckBasketTP: Logic Chính

input double InpBasketTarget = 50.0;  // Target lợi nhuận tổng ($)
input bool   InpEnableBasket = true;  // Bật/tắt Basket TP
input long   InpMagicNumber  = 20240101;

//+------------------------------------------------------------------+
//| Kiểm tra điều kiện Basket TP (gọi trong OnTick)                 |
//| Trả về true nếu đã kích hoạt và đóng toàn bộ cluster           |
//+------------------------------------------------------------------+
bool CheckBasketTP()
{
    if(!InpEnableBasket) return false;

    // Tính Total_Net
    double p_realized = GetRealizedProfit(InpMagicNumber);
    double p_floating = GetFloatingProfit(InpMagicNumber);
    double total_net  = NormalizeDouble(p_realized + p_floating, 2);

    // Hiển thị trên chart (debug)
    string status = StringFormat(
        "Basket TP | Realized: $%.2f | Floating: $%.2f | Total: $%.2f | Target: $%.2f",
        p_realized, p_floating, total_net, InpBasketTarget
    );
    Comment(status);

    // Kiểm tra điều kiện
    if(total_net = Target=", InpBasketTarget);
    Print("   P_realized=", p_realized, " | P_floating=", p_floating);

    // Đóng tất cả vị thế
    bool all_closed = CloseAllPositions(InpMagicNumber);

    if(all_closed)
    {
        Print("✅ Basket TP hoàn tất! Đóng tất cả vị thế.");

        // Reset cluster
        ResetCluster(InpMagicNumber);
        return true;
    }
    else
    {
        Print("❌ Basket TP: Một số lệnh đóng thất bại. Thử lại tick tiếp theo.");
        return false;
    }
}

//+------------------------------------------------------------------+
//| Đóng tất cả vị thế của EA (dùng cho Basket TP)                  |
//+------------------------------------------------------------------+
bool CloseAllPositions(long magic)
{
    bool all_ok = true;
    int  attempts = 0;
    int  max_attempts = 3;

    // Thử đóng tối đa 3 lần (retry cho lệnh thất bại)
    while(attempts = 0; i--)
        {
            ulong ticket = PositionGetTicket(i);
            if(ticket == 0) continue;
            if(PositionGetInteger(POSITION_MAGIC) != magic) continue;
            if(PositionGetString(POSITION_SYMBOL) != _Symbol) continue;

            ENUM_POSITION_TYPE pos_type =
                (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
            double volume = PositionGetDouble(POSITION_VOLUME);

            MqlTradeRequest request = {};
            MqlTradeResult  result  = {};

            request.action   = TRADE_ACTION_DEAL;
            request.symbol   = _Symbol;
            request.position = ticket;
            request.volume   = volume;
            request.type     = (pos_type == POSITION_TYPE_BUY)
                               ? ORDER_TYPE_SELL : ORDER_TYPE_BUY;
            request.price    = (pos_type == POSITION_TYPE_BUY)
                               ? SymbolInfoDouble(_Symbol, SYMBOL_BID)
                               : SymbolInfoDouble(_Symbol, SYMBOL_ASK);
            request.deviation = 30;  // Slippage rộng hơn cho tình huống khẩn
            request.magic    = magic;
            request.comment  = "BASKET_TP";

            request.price = NormalizeDouble(request.price,
                            (int)SymbolInfoInteger(_Symbol, SYMBOL_DIGITS));

            if(!OrderSend(request, result) || result.retcode != TRADE_RETCODE_DONE)
            {
                Print("Lỗi đóng ticket=", ticket,
                      " retcode=", result.retcode);
                remaining++;
                all_ok = false;
            }
            else
            {
                Print("Đóng ticket=", ticket, " OK @ ", result.price);
            }
        }

        if(remaining == 0) break;  // Tất cả đã đóng
        attempts++;
        Print("Còn ", remaining, " lệnh chưa đóng. Retry ", attempts, "/", max_attempts);
    }

    return all_ok;
}

Hàm ResetCluster: Bắt Đầu Chu Kỳ Mới

//+------------------------------------------------------------------+
//| Reset toàn bộ trạng thái sau khi Basket TP hoàn tất             |
//+------------------------------------------------------------------+
void ResetCluster(long magic)
{
    Print("=== RESET CLUSTER ===");

    // 1. Reset P_realized
    ResetRealizedProfit(magic);

    // 2. Xóa tất cả cờ Reopen Buffer
    for(int step = -InpMaxStep; step <= InpMaxStep; step++)
    {
        string x_key    = GetXClosedKey(magic, step);
        string plow_key = GetPlowClosedKey(magic, step);

        if(GlobalVariableCheck(x_key))    GlobalVariableDel(x_key);
        if(GlobalVariableCheck(plow_key)) GlobalVariableDel(plow_key);
    }

    // 3. Xóa tất cả cờ Plowing Stage
    for(int step = -InpMaxStep; step <= InpMaxStep; step++)
    {
        string stage_key = GetPlowStageKey(magic, step);
        if(GlobalVariableCheck(stage_key)) GlobalVariableDel(stage_key);
    }

    // 4. Reset mảng grid state
    ArrayFree(g_steps);
    g_step_count = 0;

    // 5. Ghi thời điểm reset
    GlobalVariableSet("_CLUSTER_START_" + IntegerToString((int)magic),
                      (double)TimeCurrent());

    Print("Cluster đã reset. Bắt đầu chu kỳ mới tại ",
          TimeToString(TimeCurrent(), TIME_DATE|TIME_MINUTES));
}

Điều Chỉnh Target Theo Số Vị Thế

Một cải tiến thực chiến: target không cố định mà tỉ lệ với số vị thế đang mở. Cluster có nhiều vị thế hơn → target cao hơn:

input double InpBasketTargetPerStep = 5.0;  // $5 mỗi tầng đang mở
input double InpBasketTargetMin     = 20.0; // Target tối thiểu

double GetDynamicBasketTarget(long magic)
{
    int open_count = 0;
    int total = PositionsTotal();

    for(int i = 0; i < total; i++)
    {
        ulong ticket = PositionGetTicket(i);
        if(ticket == 0) continue;
        if(PositionGetInteger(POSITION_MAGIC) != magic) continue;
        if(PositionGetString(POSITION_SYMBOL) != _Symbol) continue;
        open_count++;
    }

    double dynamic_target = open_count * InpBasketTargetPerStep;
    return MathMax(dynamic_target, InpBasketTargetMin);
}

// Trong CheckBasketTP():
double target = InpEnableDynamicTarget
                ? GetDynamicBasketTarget(InpMagicNumber)
                : InpBasketTarget;

if(total_net < target) return false;

Edge Cases Quan Trọng

Edge Case 1: Một Số Lệnh Không Đóng Được

Trong CloseAllPositions(), cơ chế retry tối đa 3 lần xử lý trường hợp này. Nếu sau 3 lần vẫn còn lệnh, hàm trả về false và CheckBasketTP() sẽ thử lại ở tick tiếp theo — không reset cluster cho đến khi tất cả lệnh đã đóng.

Edge Case 2: Basket TP Kích Hoạt Khi Đang Có FSM BUSY

// Trong CloseAllPositions(), bỏ qua FSM check vì đây là emergency close
// FSM sẽ tự timeout sau 10s nếu có

// Tuy nhiên, sau CloseAllPositions(), cần reset tất cả FSM:
void ClearAllFSM(long magic)
{
    for(int step = -InpMaxStep; step <= InpMaxStep; step++)
    {
        SetFSMReady(magic, step, ORDER_TYPE_BUY);
        SetFSMReady(magic, step, ORDER_TYPE_SELL);
    }
}

// Gọi trong ResetCluster():
ClearAllFSM(magic);

Edge Case 3: P_Realized Bị Mất Khi EA Restart

GlobalVariable lưu P_realized tồn tại qua MetaTrader restart. Nhưng nếu VPS bị reboot (mất disk GV), P_realized về 0. Giải pháp nâng cao: tính lại P_realized từ lịch sử giao dịch trong OnInit():

// Trong OnInit() — tính lại P_realized từ deal history
void RecalcRealizedProfit(long magic)
{
    // Lấy thời điểm bắt đầu cluster
    string start_key = "_CLUSTER_START_" + IntegerToString((int)magic);
    if(!GlobalVariableCheck(start_key)) return;

    datetime cluster_start = (datetime)GlobalVariableGet(start_key);

    // Quét deal history từ cluster_start đến hiện tại
    if(!HistorySelect(cluster_start, TimeCurrent())) return;

    double recalc = 0.0;
    int deals = HistoryDealsTotal();

    for(int i = 0; i < deals; i++)
    {
        ulong deal_ticket = HistoryDealGetTicket(i);
        if(deal_ticket == 0) continue;
        if(HistoryDealGetInteger(deal_ticket, DEAL_MAGIC) != magic) continue;
        if(HistoryDealGetString(deal_ticket, DEAL_SYMBOL) != _Symbol) continue;

        ENUM_DEAL_ENTRY entry =
            (ENUM_DEAL_ENTRY)HistoryDealGetInteger(deal_ticket, DEAL_ENTRY);
        if(entry != DEAL_ENTRY_OUT) continue;  // Chỉ tính lệnh đóng

        recalc += HistoryDealGetDouble(deal_ticket, DEAL_PROFIT);
        recalc += HistoryDealGetDouble(deal_ticket, DEAL_SWAP);
    }

    GlobalVariableSet(GetRealizedKey(magic), recalc);
    Print("Tái tính P_realized=", recalc,
          " từ ", HistoryDealsTotal(), " deals.");
}

Basket TP Và Các Thuật Toán Khác: Ma Trận Tương Tác

Tổng Kết

Basket TP hoàn thiện hệ thống chốt lời bằng cách giải quyết câu hỏi cuối cùng: Khi nào toàn bộ cluster đã “xong việc”? Điểm mấu chốt:

• Total_Net = P_realized + P_floating: Công thức đơn giản nhưng hiệu quả
• ResetCluster(): Làm sạch toàn bộ trạng thái, bắt đầu chu kỳ mới
• Retry mechanism: Tối đa 3 lần đóng để xử lý lỗi mạng
• Tái tính P_realized từ history: Phòng trường hợp mất GV sau VPS reboot
• Triết lý Âm Dương: Lợi nhuận thuận xu hướng bù đắp tầng kẹt ngược chiều

Ở Bài 11 — bài cuối cùng của series — chúng ta sẽ đến với Equity Lockdown: thuật toán quản trị rủi ro cực hạn, kết hợp Volume Bias (Bài 3) với nhiều tầng ngưỡng để đóng băng tài khoản khi equity rơi xuống mức nguy hiểm. Đây là “lưới an toàn” cuối cùng khi mọi thuật toán khác đều không đủ để bảo vệ tài khoản.

Đặng Trí Thanh

Giám đốc Công nghệ · DNT Digital · Giảng viên HNDL

1.322 Bài viết

15.4k Người theo dõi

120k+ Lượt đọc

Đào tạo và triển khai thực chiến Python, MT5 và hệ thống bot auto trading / IB cho học viên và doanh nghiệp.

Theo dõi Liên hệ Zalo