Expert Advisor AI for MT5 Deriv — MQL5 Tutorial

//+------------------------------------------------------------------+
//|                                       RSI_EA_IATraderPro.mq5    |
//|                          IA Trader Pro - Educational use only    |
//+------------------------------------------------------------------+
#property copyright "IA Trader Pro 2026"
#property version   "1.00"
#property strict

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

// === INPUTS ===
input int    RSI_Period     = 14;
input double RSI_Oversold   = 30.0;
input double RSI_Overbought = 70.0;
input double Risk_Percent   = 2.0;    // 2% per trade
input double SL_Points      = 500;    // Stop-loss in points
input double TP_Points      = 1000;   // Take-profit in points
input int    Magic_Number   = 20260514;
input int    Max_Trades     = 1;      // Concurrent positions

// === GLOBAL ===
int rsi_handle;
double rsi_buffer[];

//+------------------------------------------------------------------+
int OnInit() {
   rsi_handle = iRSI(_Symbol, _Period, RSI_Period, PRICE_CLOSE);
   if(rsi_handle == INVALID_HANDLE) {
      Print("ERROR: Failed to create RSI indicator");
      return(INIT_FAILED);
   }
   ArraySetAsSeries(rsi_buffer, true);
   trade.SetExpertMagicNumber(Magic_Number);
   trade.SetDeviationInPoints(10);
   trade.SetTypeFilling(ORDER_FILLING_FOK);

   Print("RSI EA initialised. Symbol=", _Symbol,
         " Period=", _Period);
   return(INIT_SUCCEEDED);
}

void OnDeinit(const int reason) {
   IndicatorRelease(rsi_handle);
   Print("RSI EA stopped. Reason=", reason);
}

//+------------------------------------------------------------------+
void OnTick() {
   if(!IsNewBar()) return;

   if(CopyBuffer(rsi_handle, 0, 0, 3, rsi_buffer) < 3) return;

   double rsi_now = rsi_buffer[0];
   double rsi_prev = rsi_buffer[1];

   if(CountOpenPositions() >= Max_Trades) return;

   // BUY signal: RSI crosses ABOVE oversold from below
   if(rsi_prev < RSI_Oversold && rsi_now >= RSI_Oversold) {
      OpenBuy();
   }
   // SELL signal: RSI crosses BELOW overbought from above
   else if(rsi_prev > RSI_Overbought && rsi_now <= RSI_Overbought) {
      OpenSell();
   }
}

void OpenBuy() {
   double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
   double point = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
   double sl = ask - SL_Points * point;
   double tp = ask + TP_Points * point;
   double volume = CalcLotSize(SL_Points);

   if(trade.Buy(volume, _Symbol, ask, sl, tp,
                "IATraderPro RSI BUY")) {
      Print("BUY opened: vol=", volume, " SL=", sl, " TP=", tp);
   } else {
      Print("BUY failed: ", trade.ResultRetcodeDescription());
   }
}

void OpenSell() {
   double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
   double point = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
   double sl = bid + SL_Points * point;
   double tp = bid - TP_Points * point;
   double volume = CalcLotSize(SL_Points);

   if(trade.Sell(volume, _Symbol, bid, sl, tp,
                 "IATraderPro RSI SELL")) {
      Print("SELL opened: vol=", volume, " SL=", sl, " TP=", tp);
   } else {
      Print("SELL failed: ", trade.ResultRetcodeDescription());
   }
}

//+------------------------------------------------------------------+
double CalcLotSize(double sl_points) {
   double balance = AccountInfoDouble(ACCOUNT_BALANCE);
   double risk_amount = balance * Risk_Percent / 100.0;
   double tick_value = SymbolInfoDouble(_Symbol,
                                       SYMBOL_TRADE_TICK_VALUE);
   double tick_size = SymbolInfoDouble(_Symbol,
                                      SYMBOL_TRADE_TICK_SIZE);
   double point = SymbolInfoDouble(_Symbol, SYMBOL_POINT);

   double pip_value = (tick_value / tick_size) * point;
   double lot_size = risk_amount / (sl_points * pip_value);

   // Normalize to broker minimum/maximum
   double min_lot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
   double max_lot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);
   double step = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);

   lot_size = MathFloor(lot_size / step) * step;
   lot_size = MathMax(min_lot, MathMin(max_lot, lot_size));
   return(NormalizeDouble(lot_size, 2));
}

int CountOpenPositions() {
   int count = 0;
   for(int i = PositionsTotal() - 1; i >= 0; i--) {
      if(PositionGetTicket(i) > 0 &&
         PositionGetInteger(POSITION_MAGIC) == Magic_Number) {
         count++;
      }
   }
   return(count);
}

bool IsNewBar() {
   static datetime last_bar = 0;
   datetime current = iTime(_Symbol, _Period, 0);
   if(current != last_bar) {
      last_bar = current;
      return(true);
   }
   return(false);
}
//+------------------------------------------------------------------+