Constructing a Martingale Grid Buying and selling Technique in MQL5 (Half 1) – Buying and selling Methods – 6 June 2025

Constructing a Martingale Grid Buying and selling Technique in MQL5

1. Introduction to Martingale Grid Buying and selling

The Martingale technique is a well known (and infrequently controversial) buying and selling method the place place sizes are elevated after losses, with the expectation that eventual wins will get better earlier losses. When utilized as a grid technique, it includes inserting orders at progressively higher costs because the market strikes in opposition to your preliminary place.

How Grid Martingale Works:

• An preliminary place is opened on the present market value
• Extra positions are added at predetermined intervals as value strikes in opposition to you
• Every subsequent place is bigger than the earlier (usually 1.5-2x)
• All positions are closed when the common break-even value is reached

2. The MQL5 Implementation

Let’s study the whole code construction with detailed explanations for every element.

2.1. Contains and Preliminary Setup

#embrace 
CTrade commerce;

#embrace 
static CAccountInfo accountInfo;

Rationalization:

• CTrade class supplies simplified commerce execution strategies (market orders, place administration)
• CAccountInfo offers entry to account-related features (margin checks, stability info)

2.2. Grid Buying and selling Parameters

double initialLotSize = 0.01;
double lotMultiplier = 1.5;
int gridStepPoints = 300;
double gridStep = gridStepPoints * _Point;
int breakEvenTPPoints = 100;
double breakEvenTP = breakEvenTPPoints * _Point;
int digits_number;


double currentBuyGridStep = 0;

Parameter Breakdown:

2.3. Initialization Perform

void InitializeVariables() {
    digits_number = (int)SymbolInfoInteger(_Symbol, SYMBOL_DIGITS);
    
    if (currentBuyGridStep == 0) {
        currentBuyGridStep = gridStep;
    }
}

Key Features:

• SymbolInfoInteger(_Symbol, SYMBOL_DIGITS) – Will get the variety of decimal locations for the present image
• Initializes currentBuyGridStep if not already set

3. Core Buying and selling Logic

3.1. Principal Execution Movement

void OnTick() {
    InitializeVariables();
    RunTradingStrategy();
}

void RunTradingStrategy() {
   int nr_buy_positions = CountBuyPositions();
   double askPrice = SymbolInfoDouble(_Symbol, SYMBOL_ASK);

   
   if (nr_buy_positions == 0) {
      OpenInitialBuyPosition();
   }

   CheckBuyGridLevels();
   SetBreakEvenTP();
}

Course of Movement:

1. Initialize crucial variables on every tick
2. Depend current purchase positions
3. Open preliminary place if none exists
4. Test if new grid ranges ought to be triggered
5. Monitor for break-even exit circumstances

3.2. Place Counting Perform

int CountBuyPositions() {
   int depend = 0;
   for (int i = 0; i < PositionsTotal(); i++) {
      ulong ticket = PositionGetTicket(i);
      if (PositionSelectByTicket(ticket) && 
          PositionGetString(POSITION_SYMBOL) == _Symbol &&
          PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY) {
         depend++;
      }
   }
   return depend;
}

Key Factors:

• Iterates via all open positions
• Filters positions for present image and purchase kind
• Returns depend of matching positions

4. Grid Place Administration

4.1. Opening the Preliminary Place

void OpenInitialBuyPosition() {
   double askPrice = SymbolInfoDouble(_Symbol, SYMBOL_ASK); 
   double lotSize = NormalizeLotSize(initialLotSize);
   double requiredMargin = accountInfo.MarginCheck(_Symbol, ORDER_TYPE_BUY, lotSize, askPrice);
   
   if(requiredMargin > accountInfo.FreeMargin()) {
      Print("Not sufficient margin for preliminary purchase! Required: ", requiredMargin, " Free: ", accountInfo.FreeMargin());
      return;
   }

   if (!commerce.Purchase(lotSize, _Symbol, askPrice, 0, 0, "Preliminary Purchase")) {
      Print("Preliminary purchase error: ", GetLastError());
   } else {
      Print("Preliminary purchase place opened at ", askPrice, " with lot dimension ", lotSize);
   }
}

Security Options:

• Lot dimension normalization to adjust to dealer restrictions
• Margin examine earlier than opening place
• Error dealing with and logging

4.2. Grid Stage Monitoring

void CheckBuyGridLevels() {
   double minBuyPrice = DBL_MAX;
   int nr_buy_positions = 0;

   for (int i = 0; i < PositionsTotal(); i++) {
      ulong ticket = PositionGetTicket(i);
      if (PositionSelectByTicket(ticket) && PositionGetString(POSITION_SYMBOL) == _Symbol) {
         if (PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY) {
            double entryPrice = PositionGetDouble(POSITION_PRICE_OPEN);
            if (entryPrice < minBuyPrice) {
               minBuyPrice = entryPrice;
            }
            nr_buy_positions++;
         }
      }
   }

   if (nr_buy_positions > 0) {
      double nextGridBuyPrice = NormalizeDouble(minBuyPrice - currentBuyGridStep, digits_number);
      double currentAsk = NormalizeDouble(SymbolInfoDouble(_Symbol, SYMBOL_ASK), digits_number);

      if (currentAsk <= nextGridBuyPrice) {
         double newLotSize = NormalizeLotSize(initialLotSize * MathPow(lotMultiplier, nr_buy_positions));
         double requiredMargin = accountInfo.MarginCheck(_Symbol, ORDER_TYPE_BUY, newLotSize, currentAsk);
         
         if(requiredMargin > accountInfo.FreeMargin()) {
            Print("Not sufficient margin for grid purchase!");
            return;
         }

         if (!commerce.Purchase(newLotSize, _Symbol, currentAsk, 0, 0, "Grid Purchase")) {
            Print("Grid purchase error: ", GetLastError());
         }
      }
   }
}

Grid Logic Defined:

1. Finds the bottom current purchase place value
2. Calculates subsequent grid degree value (present lowest – grid step)
3. Checks if present ask value has reached the subsequent grid degree
4. Calculates new place dimension utilizing exponential development
5. Performs margin examine earlier than opening new place

5. Break-Even Exit Technique

void SetBreakEvenTP() {
   double totalBuyVolume = 0;
   double totalBuyCost = 0;

   for (int i = 0; i < PositionsTotal(); i++) {
      ulong ticket = PositionGetTicket(i);
      if (PositionSelectByTicket(ticket) && PositionGetString(POSITION_SYMBOL) == _Symbol) {
         if (PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY) {
            double quantity = PositionGetDouble(POSITION_VOLUME);
            double entryPrice = PositionGetDouble(POSITION_PRICE_OPEN);
            totalBuyVolume += quantity;
            totalBuyCost += entryPrice * quantity;
         }
      }
   }

   if (totalBuyVolume > 0) {
      double breakEvenBuyPrice = NormalizeDouble((totalBuyCost / totalBuyVolume) + breakEvenTP, digits_number);
      double currentBid = NormalizeDouble(SymbolInfoDouble(_Symbol, SYMBOL_BID), digits_number);

      if (currentBid >= breakEvenBuyPrice) {
         CloseAllBuyPositions();
      }
   }
}

Exit Logic:

• Calculates volume-weighted common entry value
• Provides the break-even TP distance to find out exit value
• Displays present bid value in opposition to goal exit value
• Closes all positions when goal is reached

6. Threat Administration and Enhancements

6.1. Present Security Options

• Margin checks earlier than every commerce
• Lot dimension normalization
• Break-even exit mechanism

6.2. Potential Enhancements

7. Conclusion

This Martingale grid technique implementation supplies a strong basis for automated grid buying and selling in MQL5. Whereas the method might be worthwhile in ranging markets, it carries important danger throughout sturdy developments. All the time:

• Totally backtest with historic information
• Implement strict danger administration guidelines
• Monitor efficiency in demo accounts earlier than stay buying and selling

In future articles, we’ll discover enhancements like:

• Promote-side grid implementation
• Multi-currency help
• Superior danger controls