Expert Advisor AI cho MT5 (Deriv) — Tutorial MQL5 Đầy Đủ

// Triggered once khi EA attached to chart
int OnInit() {
    // Initialize: set parameters, validate inputs
    return INIT_SUCCEEDED;
}

// Triggered on every tick (price update)
void OnTick() {
    // Main logic: check conditions, place trades
}

// Triggered khi EA removed
void OnDeinit(const int reason) {
    // Cleanup: close positions, save state
}

//+------------------------------------------------------------------+
//|                                IATraderPro_V75_RSI.mq5            |
//|                                Copyright 2026, IA Trader Pro      |
//|                                https://iatraderpro.com/            |
//+------------------------------------------------------------------+
#property copyright "Copyright 2026, IA Trader Pro"
#property link      "https://iatraderpro.com/"
#property version   "1.00"
#property strict

#include <Trade\Trade.mqh>

// === INPUT PARAMETERS ===
input group "=== Strategy ==="
input int    RSI_Period = 14;
input double RSI_Oversold = 30.0;
input double RSI_Overbought = 70.0;

input group "=== Risk Management ==="
input double RiskPercent = 2.0;       // Risk per trade %
input int    StopLossPips = 50;       // SL in pips
input int    TakeProfitPips = 100;    // TP in pips
input int    MaxPositions = 1;        // Max concurrent positions

input group "=== EA Settings ==="
input ulong  MagicNumber = 20260513;  // Unique identifier
input int    Slippage = 10;           // Max slippage in pips

// === GLOBAL VARIABLES ===
CTrade trade;
int rsi_handle;
double rsi_buffer[];

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit() {
    // Validate inputs
    if (RSI_Period < 2) {
        Print("ERROR: RSI_Period must be >= 2");
        return INIT_FAILED;
    }
    if (RiskPercent <= 0 || RiskPercent > 10) {
        Print("ERROR: RiskPercent must be between 0 and 10");
        return INIT_FAILED;
    }
    
    // Initialize RSI indicator
    rsi_handle = iRSI(_Symbol, PERIOD_M5, RSI_Period, PRICE_CLOSE);
    if (rsi_handle == INVALID_HANDLE) {
        Print("ERROR: Failed to create RSI indicator");
        return INIT_FAILED;
    }
    
    // Set buffer as series
    ArraySetAsSeries(rsi_buffer, true);
    
    // Configure trade object
    trade.SetExpertMagicNumber(MagicNumber);
    trade.SetDeviationInPoints(Slippage);
    trade.SetTypeFilling(ORDER_FILLING_FOK);
    
    Print("✓ IATraderPro EA initialized for ", _Symbol);
    Print("  RSI Period: ", RSI_Period, " | Risk: ", RiskPercent, "%");
    Print("  SL: ", StopLossPips, " pips | TP: ", TakeProfitPips, " pips");
    
    return INIT_SUCCEEDED;
}

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason) {
    IndicatorRelease(rsi_handle);
    Print("EA deinitialized. Reason: ", reason);
}

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick() {
    // Only process on new bar to avoid over-trading
    static datetime last_bar_time = 0;
    datetime current_bar_time = iTime(_Symbol, PERIOD_M5, 0);
    if (current_bar_time == last_bar_time) return;
    last_bar_time = current_bar_time;
    
    // Check max positions
    if (CountOpenPositions() >= MaxPositions) return;
    
    // Get RSI value
    if (CopyBuffer(rsi_handle, 0, 0, 3, rsi_buffer) < 3) {
        Print("ERROR: Failed to copy RSI buffer");
        return;
    }
    
    double rsi_current = rsi_buffer[0];
    double rsi_previous = rsi_buffer[1];
    
    // BUY signal: RSI crosses up from oversold
    if (rsi_previous <= RSI_Oversold && rsi_current > RSI_Oversold) {
        OpenPosition(ORDER_TYPE_BUY);
    }
    // SELL signal: RSI crosses down from overbought
    else if (rsi_previous >= RSI_Overbought && rsi_current < RSI_Overbought) {
        OpenPosition(ORDER_TYPE_SELL);
    }
}

//+------------------------------------------------------------------+
//| Open position with calculated lot size                           |
//+------------------------------------------------------------------+
void OpenPosition(ENUM_ORDER_TYPE order_type) {
    double price = (order_type == ORDER_TYPE_BUY) ? 
                   SymbolInfoDouble(_Symbol, SYMBOL_ASK) :
                   SymbolInfoDouble(_Symbol, SYMBOL_BID);
    
    double point = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
    int digits = (int)SymbolInfoInteger(_Symbol, SYMBOL_DIGITS);
    
    double sl_distance = StopLossPips * point * 10;
    double tp_distance = TakeProfitPips * point * 10;
    
    double sl_price, tp_price;
    if (order_type == ORDER_TYPE_BUY) {
        sl_price = NormalizeDouble(price - sl_distance, digits);
        tp_price = NormalizeDouble(price + tp_distance, digits);
    } else {
        sl_price = NormalizeDouble(price + sl_distance, digits);
        tp_price = NormalizeDouble(price - tp_distance, digits);
    }
    
    double lot_size = CalculateLotSize(sl_distance);
    
    // Place order
    bool result = false;
    if (order_type == ORDER_TYPE_BUY) {
        result = trade.Buy(lot_size, _Symbol, price, sl_price, tp_price, "IATraderPro RSI");
    } else {
        result = trade.Sell(lot_size, _Symbol, price, sl_price, tp_price, "IATraderPro RSI");
    }
    
    if (result) {
        string dir = (order_type == ORDER_TYPE_BUY) ? "BUY" : "SELL";
        Print("✓ ", dir, " order placed. Lot: ", lot_size, " SL: ", sl_price, " TP: ", tp_price);
    } else {
        Print("✗ Order failed. Error: ", trade.ResultRetcode(), " - ", trade.ResultComment());
    }
}

//+------------------------------------------------------------------+
//| Calculate lot size based on risk percent                        |
//+------------------------------------------------------------------+
double CalculateLotSize(double sl_distance) {
    double balance = AccountInfoDouble(ACCOUNT_BALANCE);
    double risk_amount = balance * RiskPercent / 100.0;
    
    double tick_value = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE);
    double tick_size = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);
    
    double lot_size = risk_amount / (sl_distance / tick_size * tick_value);
    
    // Normalize to broker constraints
    double min_lot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
    double max_lot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);
    double lot_step = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
    
    lot_size = MathRound(lot_size / lot_step) * lot_step;
    lot_size = MathMax(min_lot, MathMin(max_lot, lot_size));
    
    return lot_size;
}

//+------------------------------------------------------------------+
//| Count current open positions for this EA                        |
//+------------------------------------------------------------------+
int CountOpenPositions() {
    int count = 0;
    for (int i = PositionsTotal() - 1; i >= 0; i--) {
        ulong ticket = PositionGetTicket(i);
        if (PositionSelectByTicket(ticket)) {
            if (PositionGetInteger(POSITION_MAGIC) == MagicNumber &&
                PositionGetString(POSITION_SYMBOL) == _Symbol) {
                count++;
            }
        }
    }
    return count;
}
//+------------------------------------------------------------------+