Martingale Trading with RSI-Driven Zones in MQL5

Introduction

Envision yourself as a master strategist, orchestrating a precision trading system where each trade is a calculated move within a structured framework. The Martingale EA is your expertly engineered trading machine, leveraging the 14-period Relative Strength Index (RSI) to detect overbought (above "overBoughtLevel"=70.0) and oversold (below "overSoldLevel"=30.0) conditions, initiating trades within defined price zones. This EA automates a high-risk Martingale strategy, opening 0.01-lot trades on RSI reversals, setting 200-pip zones ("zoneRange") and 400-pip target levels ("zoneTarget"), and doubling lot sizes when prices move against the position, aiming for recovery at target levels. Visual horizontal lines ("ZONE_H", "ZONE_L", "ZONE_T_H", "ZONE_T_L") mark zones in lime/orange and targets in cyan, providing strategic clarity, like a dashboard highlighting critical trade boundaries.

Drawing from your interest in creating detailed, beginner-friendly guides, this article is crafted with a professional, engaging, and seamless narrative, flowing like a well-designed trading system to inform and captivate. Tailored for both novice and experienced traders, I’ll dissect each component with clear, precise explanations, as if mentoring an apprentice strategist through a complex project. With vivid examples—like executing a Martingale trade on EURUSD—and a polished tone, we’ll explore how the EA initializes RSI, loads data, detects signals, manages trades, and ensures cleanup. Using a precision trading system metaphor, this guide will illuminate the code’s technical rigor, empowering you to harness this high-risk strategy with confidence. Let’s activate the system and begin this technical expedition!

Strategy Blueprint

Before delving into the code, let’s outline the EA’s trading framework, like drafting a blueprint for a robust system:

• Signal Detection: Initiates 0.01-lot buys when RSI crosses above 30 or sells when it falls below 70, using "rsiData".

• Zone Management: Sets a 200-pip zone ("zoneHigh", "zoneLow") around the initial trade’s open price, with 400-pip target levels ("zoneTargetHigh", "zoneTargetLow").

• Martingale Logic: Doubles lot size ("lots_Rec") if the price exits the zone against the trade direction, continuing until hitting a target, closing all positions.

• Visualization: Draws lime/orange zone lines ("ZONE_H", "ZONE_L") and cyan target lines ("ZONE_T_H", "ZONE_T_L") for clarity.

• Execution: Processes trades on new bars ("iBars()") with no fixed stop loss or take profit.

• Enhancements: Adding stop losses or lot size caps could mitigate risk. This framework automates RSI-driven Martingale trades with structured zones, balancing aggressive recovery with visual precision.

Code Implementation

Let’s step into the strategy workshop and dissect the MQL5 code that powers this Martingale EA. I’ll guide you through each phase like a master strategist, ensuring the narrative flows seamlessly with professional clarity and engaging precision that captivates from start to finish. We’ll cover initializing RSI, loading data, detecting signals, managing Martingale trades, and cleaning up, with detailed explanations and examples—like trading on EURUSD—to make it accessible for beginners. Each phase will build on the last, crafting a cohesive technical narrative that transforms code into a compelling strategy project. Let’s power up the system and begin!

Phase 1: Constructing the Framework—Initializing RSI

Our expedition starts by constructing the trading system, initializing the RSI indicator to detect market signals.

//+------------------------------------------------------------------+
//|                                                MARTINGALE EA.mq5 |
//|                           Copyright 2025, Allan Munene Mutiiria. |
//|                                   https://t.me/Forex_Algo_Trader |
//+------------------------------------------------------------------+
#property copyright "Copyright 2025, Allan Munene Mutiiria."
#property link      "https://t.me/Forex_Algo_Trader"
#property version   "1.00"

#include <Trade/Trade.mqh>
CTrade obj_trade;

int rsi_handle;
double rsiData[];
int totalBars = 0;

double overBoughtLevel = 70.0, overSoldLevel = 30.0;
double zoneHigh = 0, zoneLow = 0, zoneTargetHigh = 0, zoneTargetLow = 0;

int OnInit(){
   rsi_handle = iRSI(_Symbol,PERIOD_CURRENT,14,PRICE_CLOSE);
   return(INIT_SUCCEEDED);
}

We begin by assembling the framework with the #property header, declaring the EA as a creation by Allan in 2025 with a Telegram link, like unveiling a system’s technical specifications, aligning with your preference for clear metadata. The "OnInit()" function initializes the setup, including "Trade/Trade.mqh" for trading via "obj_trade", like installing a control module.

We define "rsi_handle" and "rsiData[]" for RSI data, like mounting a market sensor. Variables "overBoughtLevel"=70.0, "overSoldLevel"=30.0, "zoneHigh", "zoneLow", "zoneTargetHigh", and "zoneTargetLow" set trading parameters, like configuring system thresholds. The "iRSI()" function initializes a 14-period RSI on close prices, like calibrating a sensor for signal detection. Returning INIT_SUCCEEDED signals, “The system is operational, ready to trade!” This streamlined setup primes the EA for RSI-driven trading, like a trading machine ready to process market signals.

Phase 2: Mapping Market Signals—Loading RSI Data

With the system active, we load RSI data to detect overbought/oversold conditions, like gathering sensor readings for analysis.

void OnTick(){
   double ask = SymbolInfoDouble(_Symbol,SYMBOL_ASK);
   double bid = SymbolInfoDouble(_Symbol,SYMBOL_BID);
   double zoneRange = 200*_Point;
   double zoneTarget = 400*_Point;
   
   int bars = iBars(_Symbol,PERIOD_CURRENT);
   if (totalBars == bars) return;
   totalBars = bars;
   
   if (PositionsTotal() > 0) return;
   
   if (!CopyBuffer(rsi_handle,0,1,2,rsiData)) return;

We move to the signal processing hub, where "OnTick()" runs every price tick, like a system scanning real-time data. It fetches ask and bid prices with "SymbolInfoDouble()" for trading, and defines "zoneRange"=200*_Point (200 pips) and "zoneTarget"=400*_Point (400 pips), like setting system parameters. The new-bar check ("iBars()", "totalBars") ensures processing only on new candles, like updating data at regular intervals, aligning with your emphasis on beginner-friendly clarity.

If positions exist ("PositionsTotal() > 0"), it skips to trade management, avoiding new initial trades. Otherwise, it loads 2 bars of RSI data with "CopyBuffer()" into "rsiData[]", returning if it fails, like a system flagging a data error. This ensures reliable signal detection, like a clear sensor scan, before proceeding to trade execution.

Phase 3: Executing the Strategy—Detecting Signals and Opening Trades

With RSI data loaded, we detect signals and initiate trades, like activating a trading system’s core strategy.

void OnTick(){
   // ... (data loading)
   if (rsiData[1] < overSoldLevel && rsiData[0] > overSoldLevel){
      obj_trade.Buy(0.01);
      ulong pos_ticket = obj_trade.ResultOrder();
      if (pos_ticket > 0){
         if (PositionSelectByTicket(pos_ticket)){
            double openPrice = PositionGetDouble(POSITION_PRICE_OPEN);
            zoneHigh = NormalizeDouble(openPrice,_Digits);
            zoneLow = NormalizeDouble(zoneHigh - zoneRange,_Digits);
            zoneTargetHigh = NormalizeDouble(zoneHigh + zoneTarget,_Digits);
            zoneTargetLow = NormalizeDouble(zoneLow - zoneTarget,_Digits);
            drawZoneLevel(ZONE_H,zoneHigh,clrLime,2);
            drawZoneLevel(ZONE_L,zoneLow,clrOrange,2);
            drawZoneLevel(ZONE_T_H,zoneTargetHigh,clrCyan,3);
            drawZoneLevel(ZONE_T_L,zoneTargetLow,clrCyan,3);
         }
      }
   }
   else if (rsiData[1] > overBoughtLevel && rsiData[0] < overBoughtLevel){
      obj_trade.Sell(0.01);
      ulong pos_ticket = obj_trade.ResultOrder();
      if (pos_ticket > 0){
         if (PositionSelectByTicket(pos_ticket)){
            double openPrice = PositionGetDouble(POSITION_PRICE_OPEN);
            zoneLow = NormalizeDouble(openPrice,_Digits);
            zoneHigh = NormalizeDouble(zoneLow + zoneRange,_Digits);
            zoneTargetHigh = NormalizeDouble(zoneHigh + zoneTarget,_Digits);
            zoneTargetLow = NormalizeDouble(zoneLow - zoneTarget,_Digits);
            drawZoneLevel(ZONE_H,zoneHigh,clrLime,2);
            drawZoneLevel(ZONE_L,zoneLow,clrOrange,2);
            drawZoneLevel(ZONE_T_H,zoneTargetHigh,clrCyan,3);
            drawZoneLevel(ZONE_T_L,zoneTargetLow,clrCyan,3);
         }
      }
   }
}
void drawZoneLevel(string levelName, double price, color clr, int width){
   ObjectCreate(0,levelName,OBJ_HLINE,0,TimeCurrent(),price);
   ObjectSetInteger(0,levelName,OBJPROP_COLOR,clr);
   ObjectSetInteger(0,levelName,OBJPROP_WIDTH,width);
}

In the strategy execution hub, "OnTick()" processes signals when no positions exist. A buy signal triggers if RSI crosses above "overSoldLevel"=30 ("rsiData[1] < overSoldLevel && rsiData[0] > overSoldLevel"), opening a 0.01-lot buy with "obj_trade.Buy()". A sell signal triggers if RSI falls below "overBoughtLevel"=70. The EA retrieves the position ticket ("obj_trade.ResultOrder()", "PositionSelectByTicket()") and sets:

• "zoneHigh" at the open price, "zoneLow" 200 pips below for buys (or above for sells), using "NormalizeDouble()".

• "zoneTargetHigh" 400 pips above "zoneHigh", "zoneTargetLow" 400 pips below "zoneLow".

• Horizontal lines with "drawZoneLevel()" for "ZONE_H" (lime), "ZONE_L" (orange), "ZONE_T_H", and "ZONE_T_L" (cyan) using "ObjectCreate()", "ObjectSetInteger()", like marking system boundaries.

For example, on EURUSD H1, an RSI crossover above 30 at 1.2000 triggers a buy at 1.2002 (ask), setting "zoneHigh"=1.2000, "zoneLow"=1.1800, "zoneTargetHigh"=1.2400, "zoneTargetLow"=1.1400, with lines drawn for visual clarity, like a trading dashboard highlighting key levels.

Phase 4: Managing the System—Martingale Trading and Closure

With trades open, we manage positions with Martingale logic, doubling lots and closing at targets, like optimizing system performance.

void OnTick(){
   // ... (signal detection)
   double ask = SymbolInfoDouble(_Symbol,SYMBOL_ASK);
   double bid = SymbolInfoDouble(_Symbol,SYMBOL_BID);
   
   double highestLotSize = 0;
   int lastDirection = 0;
   
   for (int i = PositionsTotal()-1; i>= 0; i--){
      ulong ticket = PositionGetTicket(i);
      if (PositionSelectByTicket(ticket)){
         double lots = PositionGetDouble(POSITION_VOLUME);
         if (lots > highestLotSize){
            highestLotSize = lots;
            if (PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_BUY){
               lastDirection = 1;
            }
            else if (PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_SELL){
               lastDirection = -1;
            }
         }
         if (zoneTargetHigh > 0 && zoneTargetLow > 0){
            if (PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_BUY){
               if (bid > zoneTargetHigh){
                  obj_trade.PositionClose(_Symbol);
                  deleteZoneLevels();
               }
            }
            else if (PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_SELL){
               if (bid < zoneTargetLow){
                  obj_trade.PositionClose(_Symbol);
                  deleteZoneLevels();
               }
            }
         }
      }
   }
   
   if (zoneHigh > 0 && zoneLow > 0){
      double lots_Rec = 0;
      if (highestLotSize > 0) lots_Rec = NormalizeDouble(highestLotSize*2,2);
      if (bid > zoneHigh){
         if (highestLotSize == 0 || lastDirection < 0){
            obj_trade.Buy(lots_Rec);
         }
      }
      else if (bid < zoneLow){
         if (highestLotSize == 0 || lastDirection > 0){
            obj_trade.Sell(lots_Rec);
         }
      }
   }
}

void deleteZoneLevels(){
   ObjectDelete(0,ZONE_H);
   ObjectDelete(0,ZONE_L);
   ObjectDelete(0,ZONE_T_H);
   ObjectDelete(0,ZONE_T_L);
}

In the system management hub, "OnTick()" tracks open positions ("PositionsTotal()", "PositionGetTicket()", "PositionSelectByTicket()") to determine the largest lot size ("highestLotSize") and last trade direction ("lastDirection", 1 for buy, -1 for sell). If the bid price exceeds "zoneTargetHigh" for buys or falls below "zoneTargetLow" for sells, it closes all positions with "obj_trade.PositionClose(_Symbol)" and clears lines with "deleteZoneLevels()" using "ObjectDelete()", like completing a trading cycle.

For Martingale, if zones are active ("zoneHigh > 0 && zoneLow > 0"), it doubles the lot size ("lots_Rec = highestLotSize*2", normalized with "NormalizeDouble()") if the bid exits the zone against the trade (above "zoneHigh" for buys, below "zoneLow" for sells), opening new trades with "obj_trade.Buy()" or "obj_trade.Sell()" only if no positions exist ("highestLotSize == 0") or the direction differs ("lastDirection"). For example, a EURUSD buy at 1.2002 (0.01 lots) with bid dropping to 1.1790 (below "zoneLow"=1.1800) triggers a 0.02-lot sell, aiming for "zoneTargetLow"=1.1400, like reinforcing a strategic position in a trading system.

Phase 5: Shutting Down the System—Cleaning Up Resources

As our expedition concludes, we shut down the system, ensuring resources are cleared for the next project.

void OnDeinit(const int reason){
   IndicatorRelease(rsi_handle);
   ArrayFree(rsiData);
}

In the system shutdown area, "OnDeinit()" clears resources with "IndicatorRelease()" for "rsi_handle" and "ArrayFree()" for "rsiData[]", like dismantling a trading machine’s components. This ensures a clean workspace, preventing memory leaks. However, it doesn’t call "deleteZoneLevels()" to remove visual lines, which could be added for completeness:

deleteZoneLevels();

This would ensure no visual artifacts remain, like fully shutting down a system, ready for the next engineering task.

Why This EA is a Trading System Triumph

The Martingale EA is a high-risk trading triumph, automating RSI-driven trades with structured zones and Martingale doubling, like a precision-engineered system. Its visual lines ("drawZoneLevel()") and zone-based logic offer clarity, with potential for enhancements like stop losses or lot caps to mitigate risk. Picture a EURUSD buy at 1.2002, doubling to 0.02 lots at 1.1790, closing at 1.2400 for recovery—strategic brilliance! Beginners will value the clear framework, while experts can refine its robust logic, making it essential for Martingale traders seeking automation.

Putting It All Together

To deploy this EA:

1. Open MetaEditor in MetaTrader 5, like entering your strategy workshop.

2. Copy the code, compile with F5, and verify no errors—no strategist wants a faulty system!

3. Attach the EA to your chart, enable AutoTrading, and watch it open trades and draw zone lines.

4. Monitor logs (e.g., “Z-H = 1.2000”) and visual lines for trade tracking, like system diagnostics.

5. Test on a demo account first—real capital deserves a trial run!

Conclusion

We’ve engineered a Martingale Zone Trader that automates RSI-driven trades with precision zones, like a meticulously designed trading system. This MQL5 code is your strategic blueprint, brought to life with a seamless, professional narrative packed with clear explanations and vivid examples to fuel your trading ambition. Whether you’re a novice strategist or a seasoned market engineer, this EA empowers you to execute high-risk strategies with confidence. Ready to deploy? Explore our video guide on the website for a step-by-step creation process. Now, build your trading legacy with precision! 🔧

Disclaimer: Trading is like engineering a complex system—challenging and risky. Losses can exceed deposits. Test strategies on a demo account before going live.