Why are the lines of my MT5 EA not starting at exactly at the opening session?

Centre de 2025.07.18 19:21
Hi everyone,
I coded an EA that uses an ORB strategy. You're also a trading expert, so you're familiar with this OPEN RANGE BREAKOUT strategy.
My EA is supposed to plot high and low lines for the first 15 minutes at the London and NYC openings. I've set a lot of parameters to customize this MT5 Expert Adviser. I'm practicing on an MT5 demo account. The server is a few hours behind NYC. The London session starts at 10:00 AM on MT5 and 4:30 PM on NYC.
My problem is this: the high and low lines don't start at 4:30 PM or 10:00 AM. They start at 9:57 AM and 4:27 PM. There's a difference of a few minutes, so the timeframe to analyze isn't correct, and the first candlestick in my 15-minute range isn't correct.
Some screenshots :
Here's my code:
//+------------------------------------------------------------------+
//|                                                  MY_ORB_EA.mq5 |
//|            ORB EA with session lines, breakout/retest/entry     |
//+------------------------------------------------------------------+
#property copyright "Gauthier"
#property version   "1.06"
#property strict
#property description "ORB EA with session high/low, breakout, retest, entry & configurable stop - Candle Time Control"

//--- inputs
input bool   UseUSSession       = true;
input bool   CloseTradeEndUSSession = true;
input string US_SessionStart    = "16:30";
input string US_SessionEnd      = "23:00";
input string US_workingsession  = 180;
input color  US_HighColor       = clrLime;
input color  US_LowColor        = clrRed;

input bool   UseEUSession       = true;
input bool   CloseTradeEndEUSession = true;
input string EU_SessionStart    = "10:00";
input string EU_SessionEnd      = "18:00";
input string EU_workingsession  = 180;
input color  EU_HighColor       = clrGreen;
input color  EU_LowColor        = clrDarkRed;

input int    AnalysisMinutes    = 15;
input int    SessionLineWidth   = 2;

input bool   EnableBreakout     = true;
input ENUM_APPLIED_PRICE PriceType = PRICE_CLOSE;
input bool   ShowBreakoutLabels = true;
input bool   ShowRetestLabels   = true;
input bool   ShowEntryLabels    = true;
input color  BreakoutLabelColor = clrYellow;
input color  RetestLabelColor   = clrOrange;
input color  EntryLabelColor    = clrBlue;

enum EntryBar { ABOVE_ALL_PREVIOUS=1, ABOVE_RETEST=2};
enum StopChoice { STOP_RETEST=1, STOP_MIDPOINT=2, STOP_OPPOSITE=3 };

input StopChoice StopLevel      = STOP_RETEST;
input color     StopColor       = clrRed;
input int       StopLineWidth   = 1;


// Ajouter en input
input int ServerTimeOffset = 0; // Décalage en heures entre serveur et NYC

// Modifier TimeTradeServer() partout où c'est utilisé :
datetime GetAdjustedTime()
{
   return TimeTradeServer() + ServerTimeOffset * 3600;
}


struct Session
{
   bool     enabled;
   bool     active;
   bool     initialized;
   datetime open, close, analysisEnd;
   double   high, low;
   bool     broken, retested, triggered;
   int      breakDir;
   datetime breakTime, retestTime;
   double   retestPrice;
   string   suffix;
   int      sessionDay;
   datetime firstCandleTime;
   int      analyzedBars;
};

Session US, EU;

//+------------------------------------------------------------------+
int OnInit()
{
   US.enabled = UseUSSession;
   EU.enabled = UseEUSession;
   
   US.initialized = false;
   EU.initialized = false;
   US.sessionDay = -1;
   EU.sessionDay = -1;
   US.analyzedBars = 0;
   EU.analyzedBars = 0;
   
   EventSetTimer(30);
   return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   EventKillTimer();
   ObjectsDeleteAll(0, "ORB_");
   ObjectsDeleteAll(0, "Label_");
   ObjectsDeleteAll(0, "Stop_");
}

//+------------------------------------------------------------------+
void OnTimer()
{
   if(US.enabled) HandleSessionByCandle(US, "US", US_SessionStart, US_SessionEnd, US_HighColor, US_LowColor);
   if(EU.enabled) HandleSessionByCandle(EU, "EU", EU_SessionStart, EU_SessionEnd, EU_HighColor, EU_LowColor);
}

//+------------------------------------------------------------------+
void OnTick()
{
   if(!EnableBreakout) return;
   if(US.enabled && US.active) CheckBreakout(US, "US");
   if(EU.enabled && EU.active) CheckBreakout(EU, "EU");
}

//+------------------------------------------------------------------+
//| Fonction pour trouver la première bougie d'une session |
//+------------------------------------------------------------------+
datetime FindFirstCandleOfSession(const string sessionStart)
{
   
   int targetHour = StringToInteger(StringSubstr(sessionStart, 0, 2));
   int targetMin = StringToInteger(StringSubstr(sessionStart, 3, 2));
   
   // Obtenir l'heure actuelle du serveur
   datetime now = TimeTradeServer();
   
   
      
   MqlDateTime dtNow;
   TimeToStruct(now, dtNow);
   
   // Créer le timestamp de début de session attendu
   MqlDateTime dtSession;
   dtSession.year = dtNow.year;
   dtSession.mon = dtNow.mon;
   dtSession.day = dtNow.day;
   dtSession.hour = targetHour;
   dtSession.min = targetMin;
   dtSession.sec = 0;
   datetime sessionTime = StructToTime(dtSession);
   
   Print("Recherche session ", sessionStart, " - Heure actuelle: ", TimeToString(now), 
      " - Heure session: ", TimeToString(sessionTime));
      
   
   // Vérifier si nous sommes déjà dans la session
   if(now >= sessionTime)
   {
      // Chercher la bougie exacte
      MqlRates rates[];
      if(CopyRates(_Symbol, _Period, sessionTime, 1, rates) == 1)
      {
         if(rates[0].time == sessionTime)
         {
            Print("Bougie exacte trouvée pour session ", sessionStart, " à ", TimeToString(rates[0].time));
            return rates[0].time;
         }
      }
      
      // Si pas trouvé exactement, chercher la première bougie après l'heure de session
      int totalBars = Bars(_Symbol, _Period);
      if(totalBars > 0)
      {
         if(CopyRates(_Symbol, _Period, 0, totalBars, rates) == totalBars)
         {
            for(int i = 0; i < totalBars; i++)
            {
               if(rates[i].time >= sessionTime)
               {
                  Print("Première bougie après session ", sessionStart, " trouvée à ", TimeToString(rates[i].time));
                  return rates[i].time;
               }
            }
         }
      }
   }
   
   Print("Aucune bougie trouvée pour session ", sessionStart);
   return 0;
}

//+------------------------------------------------------------------+
//| Gestion de session basée sur l'heure des bougies |
//+------------------------------------------------------------------+
void HandleSessionByCandle(Session &S, const string sess, const string tstart, const string tend, color colHigh, color colLow)
{
   datetime now = TimeTradeServer();
   MqlDateTime dtNow;
   TimeToStruct(now, dtNow);
   int currentDay = dtNow.day_of_year;
   
   // Reset pour nouvelle session si c'est un nouveau jour
   if(S.sessionDay != currentDay)
   {
      S.active = false;
      S.initialized = false;
      S.broken = false;
      S.retested = false;
      S.triggered = false;
      S.sessionDay = currentDay;
      S.analyzedBars = 0;
      
      // Nettoyer les objets précédents
      ObjectsDeleteAll(0, "ORB_" + sess);
      ObjectsDeleteAll(0, "Label_" + sess);
      ObjectsDeleteAll(0, "Stop_" + sess);
   }
   
   // Chercher la première bougie de la session
   if(!S.initialized)
   {
      datetime firstCandle = FindFirstCandleOfSession(tstart);
      if(firstCandle > 0)
      {
         // Obtenir les données de la première bougie
         MqlRates rates[];
         int copied = CopyRates(_Symbol, _Period, 0, 1, rates);
         if(copied <= 0) return;
         
         // Vérifier que nous avons bien la bonne bougie
         if(rates[0].time >= firstCandle)
         {
            S.active = true;
            S.initialized = true;
            S.firstCandleTime = firstCandle;
            S.open = firstCandle;
            S.close = CalculateSessionEnd(tend);
            S.analysisEnd = S.open + AnalysisMinutes * 60;
            S.high = rates[0].high;
            S.low = rates[0].low;
            S.suffix = TimeToString(S.open, TIME_DATE|TIME_MINUTES);
            S.analyzedBars = 1;
            
            // Création des lignes ORB
            CreateORBLines(S, sess, colHigh, colLow);
            
            Print("Session ", sess, " INITIALISÉE avec la première bougie à ", 
                  TimeToString(firstCandle), " - High: ", S.high, " Low: ", S.low);
         }
      }
      return;
   }
   
   // Pendant la période d'analyse - analyser les bougies suivantes
   if(S.active && S.initialized && now < S.analysisEnd)
   {
      UpdateORBWithNextCandles(S, sess, colHigh, colLow);
      return;
   }
   
   // Fin de session
   if(S.active && now >= S.close)
   {
      S.active = false;
      Print("Session ", sess, " terminée à ", TimeToString(S.close));
      return;
   }
}

//+------------------------------------------------------------------+
//| Mise à jour ORB avec les bougies suivantes |
//+------------------------------------------------------------------+
void UpdateORBWithNextCandles(Session &S, const string sess, color colHigh, color colLow)
{
   int barsToAnalyze = (AnalysisMinutes / PeriodSeconds(_Period)) * 60;
   if(barsToAnalyze <= 0) barsToAnalyze = AnalysisMinutes; // Fallback
   
   if(S.analyzedBars >= barsToAnalyze) return; // Analyse terminée
   
   MqlRates rates[];
   int copied = CopyRates(_Symbol, _Period, 0, barsToAnalyze + 5, rates);
   if(copied <= 0) return;
   
   bool updated = false;
   
   // Analyser les bougies depuis la première bougie de session
   for(int i = copied - 1; i >= 0; i--)
   {
      if(rates[i].time >= S.firstCandleTime && rates[i].time < S.analysisEnd)
      {
         // Mise à jour des high/low
         if(rates[i].high > S.high)
         {
            S.high = rates[i].high;
            updated = true;
         }
         if(rates[i].low < S.low)
         {
            S.low = rates[i].low;
            updated = true;
         }
      }
   }
   
   // Mise à jour des lignes si nécessaire
   if(updated)
   {
      string h = "ORB_" + sess + "_HIGH_" + S.suffix;
      string l = "ORB_" + sess + "_LOW_" + S.suffix;
      
      ObjectSetDouble(0, h, OBJPROP_PRICE, 0, S.high);
      ObjectSetDouble(0, h, OBJPROP_PRICE, 1, S.high);
      ObjectSetDouble(0, l, OBJPROP_PRICE, 0, S.low);
      ObjectSetDouble(0, l, OBJPROP_PRICE, 1, S.low);
      
      Print("ORB ", sess, " mis à jour - High: ", S.high, " Low: ", S.low);
   }
}

//+------------------------------------------------------------------+
//| Calculer la fin de session |
//+------------------------------------------------------------------+
datetime CalculateSessionEnd(const string tend)
{
   int hh = StringToInteger(StringSubstr(tend, 0, 2));
   int mm = StringToInteger(StringSubstr(tend, 3, 2));
   
   MqlDateTime dt;
   TimeToStruct(TimeTradeServer(), dt);
   dt.hour = hh;
   dt.min = mm;
   dt.sec = 0;
   
   return StructToTime(dt);
}

//+------------------------------------------------------------------+
void CreateORBLines(Session &S, const string sess, color colHigh, color colLow)
{
   string h = "ORB_" + sess + "_HIGH_" + S.suffix;
   string l = "ORB_" + sess + "_LOW_" + S.suffix;
   
   ObjectCreate(0, h, OBJ_TREND, 0, S.open, S.high, S.close, S.high);
   ObjectSetInteger(0, h, OBJPROP_COLOR, colHigh);
   ObjectSetInteger(0, h, OBJPROP_WIDTH, SessionLineWidth);
   ObjectSetInteger(0, h, OBJPROP_RAY_RIGHT, true);
   ObjectSetString(0, h, OBJPROP_TEXT, sess + " High (" + TimeToString(S.open, TIME_MINUTES) + ")");
   
   ObjectCreate(0, l, OBJ_TREND, 0, S.open, S.low, S.close, S.low);
   ObjectSetInteger(0, l, OBJPROP_COLOR, colLow);
   ObjectSetInteger(0, l, OBJPROP_WIDTH, SessionLineWidth);
   ObjectSetInteger(0, l, OBJPROP_RAY_RIGHT, true);
   ObjectSetString(0, l, OBJPROP_TEXT, sess + " Low (" + TimeToString(S.open, TIME_MINUTES) + ")");
}

//+------------------------------------------------------------------+
void CheckBreakout(Session &S, const string sess)
{
   if(TimeTradeServer() < S.analysisEnd) return;
   
   MqlRates bars[2];
   if(CopyRates(_Symbol, _Period, 1, 2, bars) < 2) return;
   
   MqlRates b0 = bars[0];
   datetime t0 = b0.time;
   double p0 = (PriceType == PRICE_CLOSE ? b0.close : 
                (PriceType == PRICE_HIGH ? b0.high : b0.low));
   
   // Breakout
   if(!S.broken)
   {
      if(p0 > S.high || p0 < S.low)
      {
         S.broken = true;
         S.breakDir = (p0 > S.high ? 1 : -1);
         S.breakTime = t0;
         
         if(ShowBreakoutLabels)
            LabelBar(t0, (S.breakDir == 1 ? b0.high : b0.low), sess, "BO", BreakoutLabelColor);
         
         Print("Breakout détecté pour ", sess, " - Direction: ", (S.breakDir == 1 ? "UP" : "DOWN"), 
               " Prix: ", p0, " vs Level: ", (S.breakDir == 1 ? S.high : S.low));
      }
      return;
   }
   
   // Retest
   MqlRates b1 = bars[1];
   datetime t1 = b1.time;
   
   if(S.broken && !S.retested && t1 > S.breakTime)
   {
      if((S.breakDir == 1 && b1.low <= S.high) || (S.breakDir == -1 && b1.high >= S.low))
      {
         S.retested = true;
         S.retestTime = t1;
         S.retestPrice = (S.breakDir == 1 ? b1.low : b1.high);
         
         if(ShowRetestLabels)
            LabelBar(t1, S.retestPrice, sess, "RT", RetestLabelColor);
         
         Print("Retest détecté pour ", sess, " au prix: ", S.retestPrice);
      }
      return;
   }
   
   // Entry trigger
   if(S.retested && !S.triggered && t1 > S.retestTime &&
      ((S.breakDir == 1 && bars[1].close > S.retestPrice) ||
       (S.breakDir == -1 && bars[1].close < S.retestPrice)))
   {
      S.triggered = true;
      
      if(ShowEntryLabels)
         LabelBar(t1, bars[1].close, sess, "TR", EntryLabelColor);
      
      DrawStop(S, sess);
      Print("Signal d'entrée déclenché pour ", sess, " au prix: ", bars[1].close);
   }
}

//+------------------------------------------------------------------+
void DrawStop(const Session &S, const string sess)
{
   double level = 0;
   switch(StopLevel)
   {
      case STOP_RETEST:   level = S.retestPrice; break;
      case STOP_MIDPOINT: level = (S.high + S.low) / 2.0; break;
      case STOP_OPPOSITE: level = (S.breakDir == 1 ? S.low : S.high); break;
   }
   
   string tag = "Stop_" + sess + "_" + S.suffix;
   ObjectCreate(0, tag, OBJ_HLINE, 0, 0, level);
   ObjectSetInteger(0, tag, OBJPROP_COLOR, StopColor);
   ObjectSetInteger(0, tag, OBJPROP_WIDTH, StopLineWidth);
   ObjectSetString(0, tag, OBJPROP_TEXT, sess + " Stop");
}

//+------------------------------------------------------------------+
void LabelBar(datetime tm, double price, string sess, string txt, color clr)
{
   string tag = "Label_" + txt + "_" + sess + "_" + IntegerToString((int)tm);
   if(ObjectCreate(0, tag, OBJ_TEXT, 0, tm, price))
   {
      ObjectSetInteger(0, tag, OBJPROP_COLOR, clr);
      ObjectSetString(0, tag, OBJPROP_TEXT, txt);
      ObjectSetInteger(0, tag, OBJPROP_FONTSIZE, 8);
   }
}
Michael Charles Schefe 2025.07.18 21:18 #1
Centre de:
you may find the solution at the first link below your post.
New comment