Martingale Zone Recovery RSI Trading System in MQL5

Introduction

Imagine managing trades with a precision risk management engine, using a martingale approach to recover losses while visualizing key price zones for clarity. The Martingale EA is your advanced trading tool, designed to automate zone recovery trading on MetaTrader 5. It uses a 14-period RSI ("iRSI()", "rsi_handle") to trigger initial buy (RSI > 30) or sell (RSI < 70) trades ("obj_trade.Buy()", "obj_trade.Sell()") with a 0.01-lot size. If the market moves 200 pips against the trade ("zoneRange"), it opens opposite trades with doubled lot sizes ("recovery_lot"), closing all positions at 400-pip target zones ("zoneTarget"). Horizontal lines are drawn ("drawZoneLevel()", "ZONE_H", "ZONE_L", "ZONE_T_H", "ZONE_T_L") to mark recovery and target zones. The strategy ensures one-directional recovery ("lastDirection", "isBuyDone", "isSellDone") and resets after closures ("deleteZoneLevels()"). Managed via "CTrade", this strategy suits traders seeking automated loss recovery, requiring significant margin and careful risk monitoring.

This article is crafted with a professional, engaging, and seamless narrative, flowing like a well-calibrated risk management engine, designed to inform and captivate readers. Tailored for both novice and experienced traders, we’ll dissect each code component with clear, precise explanations, as if guiding an apprentice engineer through a risk management project. With vivid examples—like recovering a buy on EURUSD—and a polished tone, we’ll explore how the EA initializes, triggers trades, manages recovery zones, and ensures cleanup. Using a precision risk management engine metaphor, this guide will illuminate the code’s technical rigor, empowering you to trade with confidence. Let’s activate the system and begin this risk management expedition!

Strategy Blueprint

Let’s outline the EA’s trading framework, like drafting specifications for a risk management engine:

• Initialization: Sets up a 14-period RSI ("iRSI()", "rsi_handle") in "OnInit()".

• Signal Detection: Triggers buy (RSI > 30) or sell (RSI < 70) trades ("obj_trade.Buy()", "obj_trade.Sell()") with 0.01 lots on new bars ("iBars()", "totalBars").

• Zone Recovery: Opens opposite trades with doubled lots ("recovery_lot") when price hits a 200-pip zone ("zoneHigh", "zoneLow"), targeting 400-pip zones ("zoneTargetHigh", "zoneTargetLow").

• Visual Zones: Draws lines ("drawZoneLevel()") for recovery and target zones ("ZONE_H", "ZONE_L", "ZONE_T_H", "ZONE_T_L").

• Trade Management: Closes positions at target zones and resets ("deleteZoneLevels()") for new signals.

• Enhancements: Adding configurable lot sizes, zone ranges, or magic numbers could improve flexibility. This framework automates loss recovery with precision, balancing risk and reward.

Code Implementation

Let’s step into the risk management engine hub and dissect the MQL5 code that powers this Martingale EA. We’ll guide you through each phase like expert engineers, ensuring the narrative flows seamlessly with professional clarity and engaging precision that captivates readers. We’ll cover initialization, signal detection, zone recovery, visual zones, and cleanup, with detailed explanations and examples—like recovering a buy 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 risk management project. Let’s power up the system and begin!

Phase 1: Constructing the Framework—Initialization

We start by building the trading system, initializing the RSI indicator.

//+------------------------------------------------------------------+
//|                                                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"

#define ZONE_H "ZH"
#define ZONE_L "ZL"
#define ZONE_T_H "ZTH"
#define ZONE_T_L "ZTL"

#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);
}

The system begins with the #property header, establishing copyright and contact details, like calibrating a risk management engine’s core. The "OnInit()" function initializes the setup, including "Trade/Trade.mqh" for trading ("CTrade", "obj_trade") and creating a 14-period RSI handle ("iRSI()", "rsi_handle", PRICE_CLOSE) without validity checks. It defines zone names ("ZONE_H", "ZONE_L", "ZONE_T_H", "ZONE_T_L") and variables ("rsiData", "overBoughtLevel"=70.0, "overSoldLevel"=30.0, "zoneHigh", etc.). Returning INIT_SUCCEEDED signals, “Engine is ready, let’s manage risks!” This primes the EA for RSI-based trading and zone recovery, like an engine poised for action. Note: The code uses MetaQuotes’ copyright, but your metadata is presented for consistency.

Phase 2: Detecting Signals—Triggering Initial Trades

We check RSI signals to initiate trades, like activating the engine’s sensors.

void OnTick(){
   double ask = SymbolInfoDouble(_Symbol,SYMBOL_ASK);
   double bid = SymbolInfoDouble(_Symbol,SYMBOL_BID);
   double zoneRange = 200*_Point;
   double zoneTarget = 400*_Point;
   static int lastDirection = 0; // -1=sell, 1=buy
   static double recovery_lot = 0;
   static bool isBuyDone=NULL, isSellDone=NULL;
   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;
   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);
            lastDirection = 1; // last dir is a buy
            recovery_lot = 0.01*2;
            isBuyDone=true; isSellDone=false;
         }
      }
   }
   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);
            lastDirection = -1; // sell is the last dir
            recovery_lot = 0.01*2;
            isBuyDone=false; isSellDone=true;
         }
      }
   }
}

In the signal detection hub, "OnTick()" retrieves prices ("SymbolInfoDouble()") and defines zone parameters ("zoneRange"=200*_Point, "zoneTarget"=400*_Point). It checks for new bars ("iBars()", "totalBars") and skips if positions exist ("PositionsTotal() > 0"). It retrieves two RSI values ("CopyBuffer()", "rsiData") and exits if insufficient. A buy signal (RSI crossing above 30, "rsiData[1] < overSoldLevel && rsiData[0] > overSoldLevel") opens a 0.01-lot buy ("obj_trade.Buy()") and sets zones: "zoneHigh"=openPrice, "zoneLow"=openPrice-200 pips, "zoneTargetHigh"=openPrice+400 pips, "zoneTargetLow"=openPrice-600 pips, drawing lines ("drawZoneLevel()") in lime, orange, and cyan. A sell signal (RSI crossing below 70) sets zones inversely. It updates "lastDirection"=1/-1, "recovery_lot"=0.02, and flags ("isBuyDone", "isSellDone"). For example, on EURUSD H1, RSI rising from 28 to 32 opens a buy at 1.2050, setting zones at 1.2050, 1.1850, 1.2450, and 1.1450, like activating the engine’s sensors.

Phase 3: Managing Recovery Zones—Handling Counter-Trades

We implement zone recovery to manage losses, like fine-tuning the engine’s recovery mechanism.

void OnTick(){
   // ... (signal detection)
   if (zoneHigh > 0 && zoneLow > 0){
      double lots_Rec = NormalizeDouble(recovery_lot,2);
      if (bid > zoneHigh){
         if (isBuyDone == false || lastDirection < 0){
            obj_trade.Buy(lots_Rec);
            lastDirection = 1;
            recovery_lot = recovery_lot*2;
            isBuyDone=true; isSellDone=false;
         }
      }
      else if (bid < zoneLow){
         if (isSellDone==false || lastDirection > 0){
            obj_trade.Sell(lots_Rec);
            lastDirection = -1;
            recovery_lot = recovery_lot*2;
            isBuyDone=false; isSellDone=true;
         }
      }
   }
}

In the recovery hub, "OnTick()" checks if zones are active ("zoneHigh > 0 && zoneLow > 0") and uses "recovery_lot" (e.g., 0.02). If the bid exceeds "zoneHigh" and the last trade was a sell or no buy is done ("isBuyDone == false || lastDirection < 0"), it opens a buy ("obj_trade.Buy()") with doubled lots, updating "lastDirection"=1, doubling "recovery_lot", and toggling flags. If the bid falls below "zoneLow", it opens a sell. For example, on EURUSD, a buy at 1.2050 with bid dropping to 1.1840 triggers a sell at 0.02 lots, doubling to 0.04 for the next recovery, like fine-tuning the engine’s recovery.

Phase 4: Closing Trades and Visualizing Zones—Securing Profits

We close positions at targets and draw zones, like optimizing the engine’s output.

void OnTick(){
   if (zoneTargetHigh > 0 && zoneTargetLow > 0){
      if (bid > zoneTargetHigh || bid < zoneTargetLow){
         deleteZoneLevels();
         for (int i=PositionsTotal()-1; i>=0; i--){
            ulong ticket = PositionGetTicket(i);
            if (ticket > 0){
               if (PositionSelectByTicket(ticket)){
                  obj_trade.PositionClose(ticket);
               }
            }
         }
         zoneHigh=0; zoneLow=0; zoneTargetHigh=0; zoneTargetLow=0;
         lastDirection = 0;
         recovery_lot = 0;
         isBuyDone=false; isSellDone=false;
      }
   }
}

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);
}

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

In the trade management hub, "OnTick()" closes all positions ("obj_trade.PositionClose()") when the bid hits "zoneTargetHigh" or "zoneTargetLow", deletes lines ("deleteZoneLevels()", "ObjectDelete()"), and resets variables ("zoneHigh", "recovery_lot", etc.). "drawZoneLevel()" creates horizontal lines ("OBJ_HLINE") for zones ("ZONE_H"=lime, "ZONE_L"=orange, "ZONE_T_H"=cyan, "ZONE_T_L"=cyan). For example, on EURUSD, a buy at 1.2050 triggers a sell at 1.1850; if bid reaches 1.2450, all positions close, lines are removed, and the strategy resets, like optimizing the engine’s output.

Phase 5: Shutting Down the System—Cleaning Up Resources

As our expedition concludes, we shut down the system, ensuring resource release.

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

In the shutdown control room, "OnDeinit()" releases the RSI handle ("IndicatorRelease(rsi_handle)") and frees the buffer ("ArrayFree(rsiData)"), ensuring a clean shutdown, like powering down the engine’s systems. Note: Zone lines persist unless removed in "OnDeinit()".

Why This EA is a Risk Management Triumph

The Martingale EA is a risk management triumph, automating loss recovery with precision, like a master-crafted engine. Its RSI signals ("rsiData", "overSoldLevel"), martingale recovery ("recovery_lot"), and visual zones ("drawZoneLevel()") balance risk and reward, with potential for configurable parameters or trailing stops. Picture recovering a buy on EURUSD at 1.2050 with a doubled sell at 1.1850—strategic brilliance! Beginners will value the automated clarity, while experts can enhance its flexibility, making it essential for traders in volatile markets.

Putting It All Together

To deploy this EA:

1. Open MetaEditor in MetaTrader 5, like entering your risk management hub.

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

3. Attach the EA to your chart (e.g., EURUSD H1) to monitor RSI signals and manage recovery zones.

4. Monitor logs (e.g., “Position closed”, zone updates) and chart lines for trade actions.

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

Conclusion

We’ve engineered a Martingale Zone Recovery RSI system that manages trades with precision, like a master-crafted risk management engine. This MQL5 code is your strategic tool, brought to life with a seamless, professional narrative packed with clear explanations and vivid examples to fuel your trading confidence. Whether you’re a novice trader or a seasoned market strategist, this EA empowers you to recover losses with ease. Ready to manage risks? Watch our video guide on the website for a step-by-step creation process. Now, safeguard your trading with precision! 🔍

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