Expert Advisor IA MT5 Deriv — Tutoriel MQL5

//+------------------------------------------------------------------+
//| RSI_Mean_Reversion_EA.mq5 - IA Trader Pro                       |
//| Stratégie: V75 RSI mean reversion avec risk management          |
//+------------------------------------------------------------------+
#property copyright "Dan Machado / IA Trader Pro"
#property version   "1.00"
#property strict

#include <Trade\Trade.mqh>
CTrade trade;

// === INPUTS ===
input int    RSI_Period      = 14;     // Période RSI
input int    Oversold        = 30;     // Seuil oversold
input int    Overbought      = 70;     // Seuil overbought
input double RiskPercent     = 2.0;    // % balance par trade
input double DailyLossLimit  = 5.0;    // Limite perte journalière %
input int    MaxTradesPerDay = 8;      // Max trades / jour
input int    StopLossPoints  = 1000;   // SL en points
input int    TakeProfitPoints= 2000;   // TP en points (ratio 1:2)
input int    MagicNumber     = 75001;  // ID unique de cet EA

// === GLOBAL VARS ===
int rsiHandle;
double rsi[];
double startDayBalance;
int tradesToday = 0;
int consecLosses = 0;
datetime lastTradeDate = 0;
datetime cooldownUntil = 0;

//+------------------------------------------------------------------+
//| Initialization                                                    |
//+------------------------------------------------------------------+
int OnInit() {
    rsiHandle = iRSI(_Symbol, PERIOD_CURRENT, RSI_Period, PRICE_CLOSE);
    if(rsiHandle == INVALID_HANDLE) {
        Print("Erreur création RSI handle");
        return INIT_FAILED;
    }
    ArraySetAsSeries(rsi, true);
    startDayBalance = AccountInfoDouble(ACCOUNT_BALANCE);
    Print("EA RSI Mean Reversion démarré sur ", _Symbol);
    return INIT_SUCCEEDED;
}

//+------------------------------------------------------------------+
//| Deinitialization                                                  |
//+------------------------------------------------------------------+
void OnDeinit(const int reason) {
    IndicatorRelease(rsiHandle);
    Print("EA arrêté");
}

//+------------------------------------------------------------------+
//| Main tick handler                                                 |
//+------------------------------------------------------------------+
void OnTick() {
    // Reset daily counters at midnight
    MqlDateTime dt;
    TimeToStruct(TimeCurrent(), dt);
    static int lastDay = -1;
    if(dt.day != lastDay) {
        tradesToday = 0;
        startDayBalance = AccountInfoDouble(ACCOUNT_BALANCE);
        lastDay = dt.day;
    }
    
    // Skip if cooldown active
    if(cooldownUntil > 0 && TimeCurrent() < cooldownUntil) return;
    if(cooldownUntil > 0 && TimeCurrent() >= cooldownUntil) {
        cooldownUntil = 0;
        consecLosses = 0;
    }
    
    // Check daily loss limit
    double currentBalance = AccountInfoDouble(ACCOUNT_BALANCE);
    double lossPct = ((startDayBalance - currentBalance) / startDayBalance) * 100;
    if(lossPct >= DailyLossLimit) {
        return; // Stop trading for today
    }
    
    // Check max trades
    if(tradesToday >= MaxTradesPerDay) return;
    
    // Skip if already in position
    if(PositionsTotalForMagic(MagicNumber) > 0) return;
    
    // Update RSI
    if(CopyBuffer(rsiHandle, 0, 0, 3, rsi) < 3) return;
    
    // Detect signals (crossover logic)
    double rsi_current = rsi[0];
    double rsi_prev = rsi[1];
    
    bool buySignal = (rsi_prev < Oversold && rsi_current >= Oversold);
    bool sellSignal = (rsi_prev > Overbought && rsi_current <= Overbought);
    
    if(buySignal) PlaceTrade(ORDER_TYPE_BUY);
    else if(sellSignal) PlaceTrade(ORDER_TYPE_SELL);
}

//+------------------------------------------------------------------+
//| Calculate lot size (2% risk)                                      |
//+------------------------------------------------------------------+
double CalculateLotSize() {
    double balance = AccountInfoDouble(ACCOUNT_BALANCE);
    double risk_amount = balance * (RiskPercent / 100);
    double point_value = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE);
    double lot = risk_amount / (StopLossPoints * point_value);
    
    // Round to broker requirements
    double min_lot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
    double lot_step = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
    lot = MathFloor(lot / lot_step) * lot_step;
    lot = MathMax(lot, min_lot);
    
    return lot;
}

//+------------------------------------------------------------------+
//| Place trade with SL/TP                                            |
//+------------------------------------------------------------------+
void PlaceTrade(ENUM_ORDER_TYPE type) {
    double price = (type == ORDER_TYPE_BUY) ?
                   SymbolInfoDouble(_Symbol, SYMBOL_ASK) :
                   SymbolInfoDouble(_Symbol, SYMBOL_BID);
    
    double sl = (type == ORDER_TYPE_BUY) ?
                price - StopLossPoints * _Point :
                price + StopLossPoints * _Point;
    
    double tp = (type == ORDER_TYPE_BUY) ?
                price + TakeProfitPoints * _Point :
                price - TakeProfitPoints * _Point;
    
    double lot = CalculateLotSize();
    
    trade.SetExpertMagicNumber(MagicNumber);
    
    bool success = false;
    if(type == ORDER_TYPE_BUY) {
        success = trade.Buy(lot, _Symbol, price, sl, tp, "RSI Bull");
    } else {
        success = trade.Sell(lot, _Symbol, price, sl, tp, "RSI Bear");
    }
    
    if(success) {
        tradesToday++;
        Print("Trade placé: ", EnumToString(type), " ", lot, " @ ", price);
        LogTrade(type, price, lot);
    }
}

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

//+------------------------------------------------------------------+
//| Log trade to CSV                                                  |
//+------------------------------------------------------------------+
void LogTrade(ENUM_ORDER_TYPE type, double price, double lot) {
    int handle = FileOpen("RSI_EA_Trades.csv",
                         FILE_WRITE|FILE_READ|FILE_CSV|FILE_ANSI, ',');
    if(handle == INVALID_HANDLE) return;
    
    FileSeek(handle, 0, SEEK_END);
    FileWrite(handle,
              TimeToString(TimeCurrent()),
              _Symbol,
              (type == ORDER_TYPE_BUY ? "BUY" : "SELL"),
              DoubleToString(price, _Digits),
              DoubleToString(lot, 2),
              DoubleToString(AccountInfoDouble(ACCOUNT_BALANCE), 2)
    );
    FileClose(handle);
}

//+------------------------------------------------------------------+
//| Trade event handler — track consecutive losses                    |
//+------------------------------------------------------------------+
void OnTradeTransaction(const MqlTradeTransaction& trans,
                        const MqlTradeRequest& request,
                        const MqlTradeResult& result) {
    if(trans.type == TRADE_TRANSACTION_DEAL_ADD) {
        HistoryDealSelect(trans.deal);
        if(HistoryDealGetInteger(trans.deal, DEAL_MAGIC) == MagicNumber) {
            double profit = HistoryDealGetDouble(trans.deal, DEAL_PROFIT);
            if(profit < 0) {
                consecLosses++;
                if(consecLosses >= 3) {
                    cooldownUntil = TimeCurrent() + 3600; // 60 min cooldown
                    Print("3 pertes consécutives. Cooldown 60min.");
                }
            } else if(profit > 0) {
                consecLosses = 0;
            }
        }
    }
}
//+------------------------------------------------------------------+