Nouveau : la formation trading algorithmique MQL5, MQL4 et ProRealTimeDécouvrir →

MQL5 · Indicateurs

Indicateur multi-timeframe en MQL5 : afficher une unité de temps supérieure

Afficher une moyenne H4 sur un graphique M15 : handle sur l’autre unité, iBarShift, données pas prêtes, bougie supérieure en cours et biais d’historique, avec un code complet.

Mis à jour le 23 octobre 2026Lecture : 10 minPar Alix, OptiBot Trading

Un indicateur multi-timeframe affiche sur un graphique les valeurs calculées sur une autre unité de temps, en général supérieure : la moyenne mobile H4 sur un graphique M15, le RSI journalier sur un graphique H1. En MQL5, la méthode est toujours la même : créer dans OnInit() un handle sur l’unité de temps visée, copier ses valeurs avec CopyBuffer() et CopyTime(), puis associer chaque bougie du graphique à la bougie de l’unité supérieure qui la contient. Les difficultés sont ailleurs : les données de l’autre unité de temps peuvent ne pas être prêtes, la bougie supérieure en cours change à chaque tick, et un affichage historique trop « parfait » peut tromper vos backtests. Cette page traite ces trois points avec un indicateur complet.

Le principe de correspondance

Chaque bougie M15 appartient à une bougie H4 : celle dont l’heure d’ouverture est la plus récente parmi celles qui ne dépassent pas l’heure de la bougie M15. La fonction iBarShift() fait exactement cette recherche :

int iBarShift(const string symbol, ENUM_TIMEFRAMES timeframe, datetime time, bool exact = false);

Avec exact = false, elle renvoie l’index (en indexation série, 0 = bougie en cours) de la dernière bougie de l’unité demandée qui s’ouvre avant ou à l’heure donnée, ou -1 si l’historique ne remonte pas jusque-là. Avec exact = true, elle renvoie -1 dès qu’aucune bougie ne s’ouvre exactement à cette heure.

Appeler iBarShift() puis CopyBuffer() pour chacune des dizaines de milliers de bougies du graphique serait correct mais lent. L’exemple de cette page utilise iBarShift() une seule fois pour savoir combien de bougies supérieures copier, puis parcourt les deux séries en parallèle.

Premier piège : les données ne sont pas encore là

Quand un indicateur demande les données d’une autre unité de temps, celles-ci peuvent ne pas être construites. La documentation de CopyBuffer() et de CopyTime() est claire : appelées depuis un indicateur, ces fonctions renvoient -1 immédiatement si les données ne sont pas prêtes, tout en lançant leur chargement ou leur construction en arrière-plan. Un indicateur ne doit jamais attendre (pas de boucle avec Sleep()) : il bloquerait le fil de calcul de tous les indicateurs du symbole.

La bonne réaction consiste à renvoyer 0 depuis OnCalculate(). Au tick suivant, prev_calculated vaudra 0 et l’indicateur retentera un calcul complet ; entre-temps, les données auront été préparées. La fonction BarsCalculated(handle) permet aussi de vérifier, avant toute copie, que l’indicateur source a déjà calculé des valeurs. Le mécanisme de prev_calculated est détaillé sur la page OnCalculate et prev_calculated.

Deuxième piège : la bougie supérieure en cours

Tant que la bougie H4 n’est pas close, la moyenne H4 change à chaque tick. Or toutes les bougies M15 qui appartiennent à cette bougie H4 affichent sa valeur. Si l’indicateur ne recalcule que la dernière bougie M15, comme le ferait un indicateur classique, les bougies M15 précédentes de la même période H4 gardent des valeurs périmées, et la courbe affiche des « marches » incohérentes. Il faut donc faire remonter le point de départ du calcul jusqu’à la première bougie M15 de la bougie H4 en cours.

Troisième piège : l’avantage indu dans l’historique

Sur l’historique, une bougie M15 de 9 h 15 affiche la valeur finale de la bougie H4 de 8 h, calculée avec la clôture de 11 h 59. En temps réel, à 9 h 15, cette valeur n’existait pas encore : seule une valeur provisoire était connue. Un Expert Advisor qui lirait cet indicateur sur les bougies passées, ou une analyse visuelle de l’historique, bénéficierait donc d’une information future. C’est une source classique de backtests trop beaux.

La solution la plus sûre consiste à n’afficher que la valeur de la dernière bougie supérieure close : à 9 h 15, la bougie M15 reçoit la valeur H4 de la bougie de 4 h, qui était définitive à ce moment-là. L’indicateur ci-dessous propose ce mode par un paramètre.

Exemple complet : une moyenne mobile d’unité supérieure

//+------------------------------------------------------------------+
//| MaHigherTF.mq5 - moyenne mobile d'une unité de temps supérieure  |
//+------------------------------------------------------------------+
#property indicator_chart_window
#property indicator_buffers 1
#property indicator_plots   1
#property indicator_type1   DRAW_LINE
#property indicator_color1  clrMediumPurple
#property indicator_width1  2
#property indicator_label1  "MA unité supérieure"

input ENUM_TIMEFRAMES InpTF         = PERIOD_H4;  // unité de temps de calcul
input int             InpPeriod     = 50;         // période de la moyenne
input ENUM_MA_METHOD  InpMethod     = MODE_EMA;   // méthode
input bool            InpClosedOnly = true;       // n'afficher que les bougies closes

double MaBuffer[];
int    hMa = INVALID_HANDLE;

int OnInit()
  {
   if(PeriodSeconds(InpTF) < PeriodSeconds(_Period))
     {
      Print("Choisissez une unité de temps supérieure ou égale à celle du graphique");
      return(INIT_PARAMETERS_INCORRECT);
     }
   SetIndexBuffer(0, MaBuffer, INDICATOR_DATA);
   PlotIndexSetDouble(0, PLOT_EMPTY_VALUE, EMPTY_VALUE);
   IndicatorSetString(INDICATOR_SHORTNAME,
                      StringFormat("MA %s(%d)", EnumToString(InpTF), InpPeriod));

   hMa = iMA(_Symbol, InpTF, InpPeriod, 0, InpMethod, PRICE_CLOSE);
   if(hMa == INVALID_HANDLE)
     {
      PrintFormat("iMA : échec, erreur %d", GetLastError());
      return(INIT_FAILED);
     }
   return(INIT_SUCCEEDED);
  }

void OnDeinit(const int reason)
  {
   if(hMa != INVALID_HANDLE)
      IndicatorRelease(hMa);
  }

int OnCalculate(const int rates_total, const int prev_calculated,
                const datetime &time[], const double &open[], const double &high[],
                const double &low[], const double &close[], const long &tick_volume[],
                const long &volume[], const int &spread[])
  {
   ArraySetAsSeries(time, false);                 // 0 = bougie la plus ancienne
   if(BarsCalculated(hMa) <= 0)
      return(0);                                  // indicateur source pas prêt

   int start = (prev_calculated == 0) ? 0 : prev_calculated - 1;

   //--- remonter au début de la bougie supérieure en cours
   datetime htfOpen = iTime(_Symbol, InpTF, 0);
   if(htfOpen == 0)
      return(0);                                  // série supérieure pas prête
   while(start > 0 && time[start - 1] >= htfOpen)
      start--;

   //--- nombre de bougies supérieures à copier
   int shift = iBarShift(_Symbol, InpTF, time[start], false);
   if(shift < 0)
      return(0);
   int count = shift + 2;                         // +1 pour le mode « bougies closes »

   double   val[];
   datetime t[];
   ArraySetAsSeries(val, true);                   // val[0] = bougie supérieure en cours
   ArraySetAsSeries(t, true);
   if(CopyBuffer(hMa, 0, 0, count, val) != count) return(0);
   if(CopyTime(_Symbol, InpTF, 0, count, t) != count) return(0);

   //--- parcours parallèle : k avance vers les bougies supérieures plus récentes
   int k = count - 1;
   for(int i = start; i < rates_total; i++)
     {
      while(k > 0 && t[k - 1] <= time[i])
         k--;                                     // bougie supérieure contenant time[i]
      int idx = InpClosedOnly ? k + 1 : k;        // k + 1 = bougie supérieure précédente, close
      MaBuffer[i] = (idx < count && t[k] <= time[i]) ? val[idx] : EMPTY_VALUE;
     }
   return(rates_total);
  }

Plusieurs choix méritent un commentaire. Le contrôle de PeriodSeconds() dans OnInit() refuse une unité inférieure à celle du graphique, cas pour lequel cette correspondance n’a pas de sens. Le tableau time[] est explicitement réglé en indexation classique, alors que val[] et t[] sont en indexation série : c’est volontaire, car il est naturel de copier les données supérieures depuis la bougie en cours, mais il faut garder ce mélange en tête en lisant la boucle. Enfin, les deux échecs de copie renvoient 0, ce qui provoquera un recalcul complet au prochain tick, une fois les données disponibles.

Utiliser ces valeurs dans un Expert Advisor

Un Expert Advisor n’a généralement pas besoin d’un indicateur multi-timeframe : il peut créer directement un handle iMA(_Symbol, PERIOD_H4, ...) et lire CopyBuffer(h, 0, 1, 1, v) pour obtenir la dernière bougie H4 close. C’est plus simple et sans ambiguïté sur le moment où la valeur était connue. L’indicateur multi-timeframe sert surtout à visualiser ce que fait le robot. Si vous l’appelez malgré tout depuis un EA avec iCustom, activez le mode « bougies closes » pour que les valeurs lues sur l’historique correspondent à ce qui était réellement connu. Pour structurer un robot qui combine plusieurs unités de temps et plusieurs instruments, voyez EA multi-symboles.

Autres précautions

  • Les week-ends et jours fériés. Les bougies D1 et H4 n’existent pas pendant les fermetures : iBarShift() avec exact = false renvoie alors la dernière bougie disponible, ce qui est le comportement souhaité.
  • Le testeur de stratégie. Il construit les séries des autres unités de temps à partir de l’historique du symbole ; prévoyez assez d’historique avant la date de début pour que la moyenne supérieure soit significative dès le premier jour.
  • Les décalages horaires. Une bougie D1 commence à minuit heure du serveur, pas à minuit chez vous ; la correspondance se fait toujours sur l’heure du serveur.
  • Les unités non multiples. Associer du H4 à un graphique H3 fonctionne, mais une bougie H3 peut chevaucher deux bougies H4 : elle reçoit la valeur de celle qui s’ouvre avant elle.

La rubrique Indicateurs en MQL5 présente les autres techniques de construction d’indicateurs.

Une moyenne d’unité supérieure lue sur la bougie en cours change jusqu’à sa clôture. Dans un backtest, vérifiez que votre robot n’utilise que des valeurs réellement connues au moment de la décision, faute de quoi les résultats seront surestimés.

FAQ

Pourquoi mon indicateur multi-timeframe reste-t-il vide au premier chargement ?

Les données de l’unité supérieure n’étaient pas encore construites : CopyBuffer() et CopyTime() renvoient alors -1 depuis un indicateur. En renvoyant 0 depuis OnCalculate(), l’indicateur réessaie au tick suivant, une fois les données prêtes.

Peut-on utiliser Sleep() pour attendre les données dans un indicateur ?

Non. Les indicateurs d’un même symbole partagent un fil de calcul : attendre bloquerait tous les autres. Renvoyez 0 et laissez le terminal rappeler la fonction.

Pourquoi la courbe semble-t-elle meilleure sur l’historique qu’en temps réel ?

Parce que l’historique affiche les valeurs finales des bougies supérieures, alors qu’en temps réel seule une valeur provisoire existait. Le mode « bougies closes » supprime cet écart.

Un EA a-t-il besoin d’un indicateur multi-timeframe ?

Rarement. Il peut créer un handle sur l’unité supérieure et lire directement la dernière bougie close avec CopyBuffer().

A

Alix · fondateur d’OptiBot Trading

Développeur MQL5 et ProBuilder, spécialiste du backtest et de l’optimisation de stratégies automatiques. Chaque contenu est vérifié sur la documentation officielle (MQL5.com, manuels ProRealTime) et testé avant publication. Notre méthode éditoriale.