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

MQL4 · Indicateurs

Créer un indicateur en MQL4 : structure, OnCalculate et premier tracé

Écrire un indicateur personnalisé MQL4 de A à Z : directives #property, déclaration des buffers dans OnInit, calcul incrémental dans OnCalculate, compilation et vérification sur le graphique.

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

Un indicateur personnalisé MQL4 est un programme qui calcule une ou plusieurs séries de valeurs, les buffers, et que le terminal dessine sur le graphique. Il se compose de trois éléments : des directives #property qui décrivent l’affichage, une fonction OnInit() qui associe les tableaux aux buffers, et une fonction OnCalculate() appelée à chaque tick pour calculer les valeurs. Cette page construit un indicateur complet, un canal de prix basé sur les plus hauts et plus bas récents avec sa ligne médiane, en expliquant chaque étape et les erreurs que l’on rencontre au premier essai. Les détails des buffers et du recalcul incrémental sont approfondis dans deux pages dédiées de la rubrique.

Créer le fichier

Dans MetaEditor, l’assistant (Fichier > Nouveau > Indicateur personnalisé) génère un squelette dans le dossier MQL4\Indicators. Vous pouvez aussi partir d’un fichier vide portant l’extension .mq4. L’assistant propose d’ajouter des paramètres et des tracés ; pour un premier indicateur, il est plus formateur d’écrire ces éléments vous-même. Cette page fait partie de la rubrique Indicateurs en MQL4, qui présente aussi les indicateurs intégrés que vous pourrez appeler depuis votre propre code.

Les directives #property

Les directives placées en tête de fichier indiquent au terminal où et comment dessiner l’indicateur :

  • #property strict active le mode de compilation strict, recommandé pour tout nouveau code ;
  • #property indicator_chart_window dessine l’indicateur sur le graphique des prix, #property indicator_separate_window dans une sous-fenêtre, comme un oscillateur ;
  • #property indicator_buffers 3 déclare le nombre de buffers affichés ;
  • #property indicator_color1 clrDodgerBlue et #property indicator_width1 2 fixent la couleur et l’épaisseur du premier tracé, et ainsi de suite pour les suivants.

Les tracés sont numérotés à partir de 1 dans les directives, mais les buffers sont numérotés à partir de 0 dans le code : indicator_color1 s’applique au buffer 0. Cette différence d’indexation est une source fréquente de confusion.

OnInit : relier les tableaux aux buffers

Chaque buffer est un tableau dynamique de double déclaré au niveau global, que SetIndexBuffer() associe à un index. Le terminal se charge ensuite de dimensionner ce tableau au nombre de bougies du graphique. Dans OnInit(), on configure aussi le style de chaque tracé, son étiquette dans la fenêtre des données et le nom court de l’indicateur :

double BufHaut[], BufBas[], BufMilieu[];

int OnInit()
{
   SetIndexBuffer(0, BufHaut);
   SetIndexBuffer(1, BufBas);
   SetIndexBuffer(2, BufMilieu);

   SetIndexStyle(0, DRAW_LINE);
   SetIndexStyle(1, DRAW_LINE);
   SetIndexStyle(2, DRAW_LINE, STYLE_DOT);

   SetIndexLabel(0, "Canal haut");
   SetIndexLabel(1, "Canal bas");
   SetIndexLabel(2, "Milieu");

   IndicatorShortName("Canal(" + IntegerToString(Periode) + ")");
   return(INIT_SUCCEEDED);
}

En MQL4, les buffers d’indicateur sont indexés comme les séries de prix : l’indice 0 correspond à la bougie la plus récente, comme pour Close[0]. Le calcul peut donc s’écrire avec les mêmes indices que les tableaux High[], Low[] et Close[], ce qui facilite la lecture.

OnCalculate : calculer seulement ce qui est nécessaire

OnCalculate() reçoit notamment rates_total, le nombre de bougies disponibles, et prev_calculated, la valeur que la fonction a renvoyée lors de l’appel précédent. Au premier appel, prev_calculated vaut 0 et il faut tout calculer ; aux appels suivants, seules la dernière bougie et les éventuelles nouvelles bougies doivent l’être. C’est ce mécanisme qui rend un indicateur léger, et il est détaillé dans IndicatorCounted et prev_calculated.

L’indicateur complet

//+------------------------------------------------------------------+
//| Canal.mq4 : plus haut et plus bas des N dernières bougies         |
//+------------------------------------------------------------------+
#property strict
#property indicator_chart_window
#property indicator_buffers 3
#property indicator_color1  clrDodgerBlue
#property indicator_color2  clrOrangeRed
#property indicator_color3  clrGray
#property indicator_width1  2
#property indicator_width2  2

input int Periode = 20;            // nombre de bougies du canal

double BufHaut[], BufBas[], BufMilieu[];

int OnInit()
{
   if(Periode < 2) return(INIT_PARAMETERS_INCORRECT);

   SetIndexBuffer(0, BufHaut);
   SetIndexBuffer(1, BufBas);
   SetIndexBuffer(2, BufMilieu);
   SetIndexStyle(0, DRAW_LINE);
   SetIndexStyle(1, DRAW_LINE);
   SetIndexStyle(2, DRAW_LINE, STYLE_DOT);
   SetIndexLabel(0, "Canal haut");
   SetIndexLabel(1, "Canal bas");
   SetIndexLabel(2, "Milieu");
   for(int b = 0; b < 3; b++) SetIndexDrawBegin(b, Periode);   // pas de tracé avant N bougies

   IndicatorShortName("Canal(" + IntegerToString(Periode) + ")");
   return(INIT_SUCCEEDED);
}

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[])
{
   if(rates_total <= Periode) return(0);           // pas assez de bougies

   // Nombre de bougies à (re)calculer
   int limite;
   if(prev_calculated == 0) limite = rates_total - Periode;      // premier calcul
   else                     limite = rates_total - prev_calculated + 1;

   for(int i = limite - 1; i >= 0; i--)
   {
      // Plus haut et plus bas des 'Periode' bougies se terminant à la bougie i
      int iHaut = iHighest(NULL, 0, MODE_HIGH, Periode, i);
      int iBas  = iLowest(NULL, 0, MODE_LOW, Periode, i);
      BufHaut[i]   = High[iHaut];
      BufBas[i]    = Low[iBas];
      BufMilieu[i] = (BufHaut[i] + BufBas[i]) / 2.0;
   }
   return(rates_total);                            // devient prev_calculated au prochain appel
}

iHighest() et iLowest() renvoient l’index de la bougie la plus haute ou la plus basse sur une plage donnée, à partir d’un index de départ. Elles évitent d’écrire une boucle imbriquée. Au premier calcul, la boucle commence à rates_total - Periode - 1, de façon que la plage de chaque bougie reste à l’intérieur de l’historique disponible.

Ajouter des paramètres

Les variables déclarées avec input en tête de fichier deviennent les paramètres de l’indicateur, modifiables dans l’onglet Paramètres de la fenêtre de propriétés. Leur ordre de déclaration est important : c’est celui que devra respecter un Expert Advisor qui appellera l’indicateur avec iCustom(). Prenez donc l’habitude de placer en premier les paramètres de calcul (périodes, coefficients) et à la fin les paramètres d’affichage ou d’alerte, qu’un robot n’aura généralement pas besoin de transmettre.

Validez aussi les valeurs reçues dans OnInit(). Dans l’exemple, une période inférieure à 2 n’a pas de sens : la fonction renvoie INIT_PARAMETERS_INCORRECT et le terminal refuse de lancer l’indicateur, ce qui vaut mieux qu’un tracé absurde ou une erreur d’accès hors des limites d’un tableau. Les différences entre extern et input, et la manière dont chacun se comporte dans le code, sont détaillées dans extern et input.

Pourquoi recalculer la bougie 0 à chaque tick

Tant que la bougie en cours n’est pas terminée, son plus haut, son plus bas et sa clôture changent. Un indicateur qui calculerait la bougie 0 une seule fois, à son ouverture, afficherait une valeur fausse jusqu’à la bougie suivante, et l’historique ne correspondrait plus à ce que vous avez vu en temps réel. C’est pourquoi la formule de limite recalcule toujours au moins une bougie, même quand aucune nouvelle bougie n’est apparue. À l’ouverture d’une nouvelle bougie, elle en recalcule deux : la bougie qui vient de se terminer, pour figer sa valeur définitive, et la nouvelle bougie 0.

Compiler, attacher, vérifier

Compilez avec F7 : l’onglet Erreurs de MetaEditor doit afficher « 0 errors ». Faites ensuite glisser l’indicateur depuis le Navigateur sur un graphique. Trois vérifications s’imposent :

  1. la fenêtre des données (Ctrl+D) doit afficher les trois étiquettes avec des valeurs cohérentes pour la bougie survolée ;
  2. la bougie en cours doit faire évoluer le canal si le prix dépasse le plus haut récent, ce qui confirme que la bougie 0 est bien recalculée à chaque tick ;
  3. l’arrivée d’une nouvelle bougie ne doit pas laisser de « trou » dans les lignes, signe que la bougie précédente a été finalisée.

Erreurs fréquentes au premier indicateur

  • Rien ne s’affiche : vérifiez la directive indicator_buffers et les appels à SetIndexBuffer(). Un buffer déclaré mais jamais relié reste vide.
  • Erreur « array out of range » : la boucle lit au-delà de l’historique, typiquement High[i + Periode] quand i est proche de rates_total. Le calcul de limite au premier passage doit laisser assez de bougies.
  • L’indicateur ralentit le terminal : il recalcule tout l’historique à chaque tick parce qu’il ignore prev_calculated.
  • Valeurs différentes en temps réel et en historique : la bougie 0 n’est pas recalculée, ou le calcul utilise des données futures, par exemple High[i - 1]. Un indicateur ne doit utiliser que les bougies d’index supérieur ou égal à i.

Utiliser l’indicateur dans un EA

Une fois compilé, l’indicateur se lit depuis un robot avec iCustom(NULL, 0, "Canal", 20, 0, 1) pour la ligne haute de la dernière bougie clôturée. Les règles d’appel sont détaillées dans iCustom en MQL4. Pour aller plus loin dans l’affichage (flèches, histogrammes, buffers cachés), consultez Buffers d’indicateur en MQL4, et pour l’équivalent sur MetaTrader 5, Créer un indicateur personnalisé en MQL5.

FAQ

Quelle différence entre OnCalculate et start() ?

start() est l’ancienne fonction de calcul des indicateurs MQL4, utilisée avec IndicatorCounted(). Les versions récentes du langage proposent OnCalculate(), qui reçoit directement rates_total et prev_calculated. Pour un nouvel indicateur, utilisez OnCalculate().

Pourquoi indicator_color1 s’applique-t-il au buffer 0 ?

Les directives #property numérotent les tracés à partir de 1, alors que SetIndexBuffer et les autres fonctions numérotent les buffers à partir de 0. indicator_color1 correspond donc au buffer d’index 0.

Un indicateur peut-il passer des ordres ?

Non. Les fonctions de trading comme OrderSend ne sont pas autorisées dans un indicateur. La logique de trading doit se trouver dans un Expert Advisor, qui lit l’indicateur avec iCustom.

Combien de buffers puis-je déclarer ?

La documentation de iCustom indique des numéros de buffer de 0 à 7 pour la lecture depuis un EA. Pour un indicateur destiné à être appelé par iCustom, restez dans cette plage pour les buffers que l’EA doit lire.

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.