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

MQL5 · Indicateurs

Créer un indicateur personnalisé en MQL5, pas à pas

De la feuille blanche à l’indicateur compilé : directives #property, buffers, OnInit, OnCalculate, compilation et vérification, avec le code complet d’un indicateur d’amplitude moyenne.

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

Un indicateur personnalisé MQL5 est un programme qui calcule une ou plusieurs séries de valeurs à partir des prix et les dessine sur le graphique. Il repose sur quatre éléments : des directives #property qui décrivent la fenêtre et les tracés, des tableaux double liés au terminal par SetIndexBuffer(), une fonction OnInit() qui configure le tout, et une fonction OnCalculate() qui remplit les tableaux à chaque nouveau tick. Cette page vous guide de la feuille blanche à un indicateur compilé et utilisable, en construisant un exemple concret : RangeMoyen, qui affiche l’amplitude moyenne des bougies en points.

Avant d’écrire : définir ce que l’indicateur doit produire

Un indicateur bien conçu commence par trois réponses écrites noir sur blanc :

  1. Quelle valeur, pour chaque bougie ? Ici : la moyenne simple de (plus haut - plus bas) sur N bougies, exprimée en points.
  2. Où l’afficher ? Les valeurs en points n’ont pas la même échelle que le prix : elles vont dans une sous-fenêtre séparée.
  3. Quels calculs intermédiaires faut-il conserver ? L’amplitude brute de chaque bougie, réutilisée par la moyenne.

Ces réponses déterminent directement les directives : une fenêtre séparée, deux buffers (la moyenne affichée et l’amplitude brute de calcul), un seul tracé. Prendre cinq minutes pour ce cahier des charges évite de réécrire l’en-tête trois fois.

Étape 1 : créer le fichier

Dans MetaEditor, l’assistant MQL5 (menu Fichier, Nouveau) propose un modèle « Indicateur personnalisé » qui génère le squelette, avec les fonctions OnInit() et OnCalculate(). Enregistrez le fichier dans un sous-dossier dédié, par exemple MQL5\Indicators\MesIndicateurs\RangeMoyen.mq5. Regrouper vos indicateurs dans un dossier à vous facilite leur sauvegarde et leur appel depuis un Expert Advisor. Si vous découvrez l’environnement, la page Bien utiliser MetaEditor en présente les fonctions utiles.

Étape 2 : déclarer la fenêtre, les buffers et le tracé

L’en-tête de l’indicateur indique au terminal comment le préparer, avant même la première ligne de calcul. Les directives utilisées ici :

DirectiveValeurRôle
indicator_separate_window(aucune)Affichage dans une sous-fenêtre
indicator_buffers2Nombre total de tableaux gérés par le terminal
indicator_plots1Nombre de séries graphiques
indicator_type1DRAW_LINELe premier tracé est une ligne
indicator_color1, indicator_width1couleur, épaisseurApparence de la ligne
indicator_label1texteNom affiché dans la fenêtre de données

Notez que les directives de tracé sont numérotées à partir de 1, alors que les buffers et les tracés sont indexés à partir de 0 dans les fonctions. C’est une source de confusion fréquente. La différence entre buffers et tracés, et les nombreux styles disponibles, sont détaillés sur la page Buffers et styles de tracé.

Étape 3 : configurer dans OnInit

OnInit() fait quatre choses : valider les paramètres, lier les tableaux, régler le tracé, nommer l’indicateur.

  • SetIndexBuffer(0, AvgBuffer, INDICATOR_DATA) lie le tableau de la moyenne au buffer 0, qui sera dessiné.
  • SetIndexBuffer(1, RangeBuffer, INDICATOR_CALCULATIONS) lie l’amplitude brute au buffer 1, réservé aux calculs : il n’est pas dessiné.
  • PlotIndexSetInteger(0, PLOT_DRAW_BEGIN, InpPeriod - 1) indique que le tracé ne commence qu’à partir de la première bougie où la moyenne est définie.
  • IndicatorSetString(INDICATOR_SHORTNAME, ...) donne le nom affiché en haut de la sous-fenêtre, et IndicatorSetInteger(INDICATOR_DIGITS, 1) fixe le nombre de décimales affichées.

La documentation rappelle que les tableaux liés par SetIndexBuffer() ne doivent jamais être redimensionnés par votre code : c’est le terminal qui gère leur taille, qui suit automatiquement le nombre de bougies du graphique.

Étape 4 : calculer dans OnCalculate

OnCalculate() reçoit le nombre de bougies disponibles (rates_total), le nombre de bougies déjà calculées lors de l’appel précédent (prev_calculated) et les tableaux de prix. Le schéma minimal consiste à recalculer uniquement les bougies nouvelles, plus la dernière, qui évolue tant qu’elle n’est pas close, puis à renvoyer rates_total. Toutes les subtilités de ce mécanisme, y compris les remises à zéro de prev_calculated, sont traitées sur la page OnCalculate et prev_calculated ; ici, nous appliquons le schéma sans le détailler.

Le code complet

//+------------------------------------------------------------------+
//| RangeMoyen.mq5 - amplitude moyenne des bougies, en points        |
//+------------------------------------------------------------------+
#property indicator_separate_window
#property indicator_buffers 2
#property indicator_plots   1
#property indicator_type1   DRAW_LINE
#property indicator_color1  clrDodgerBlue
#property indicator_width1  2
#property indicator_label1  "Amplitude moyenne (pts)"

input int InpPeriod = 14;      // nombre de bougies de la moyenne

double AvgBuffer[];            // buffer 0 : moyenne affichée
double RangeBuffer[];          // buffer 1 : amplitude brute (calculs)

int OnInit()
  {
   if(InpPeriod < 1)
     {
      Print("RangeMoyen : la période doit être supérieure ou égale à 1");
      return(INIT_PARAMETERS_INCORRECT);
     }
   SetIndexBuffer(0, AvgBuffer,   INDICATOR_DATA);
   SetIndexBuffer(1, RangeBuffer, INDICATOR_CALCULATIONS);

   PlotIndexSetInteger(0, PLOT_DRAW_BEGIN, InpPeriod - 1);
   PlotIndexSetDouble(0, PLOT_EMPTY_VALUE, EMPTY_VALUE);

   IndicatorSetString(INDICATOR_SHORTNAME, StringFormat("RangeMoyen(%d)", InpPeriod));
   IndicatorSetInteger(INDICATOR_DIGITS, 1);
   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 < InpPeriod)
      return(0);                               // pas assez de bougies

   //--- indexation classique : 0 = bougie la plus ancienne
   ArraySetAsSeries(high, false);
   ArraySetAsSeries(low,  false);

   //--- premier appel : tout calculer ; ensuite : la dernière bougie et les nouvelles
   int start = (prev_calculated == 0) ? 0 : prev_calculated - 1;

   for(int i = start; i < rates_total; i++)
     {
      RangeBuffer[i] = (high[i] - low[i]) / _Point;

      if(i < InpPeriod - 1)
        {
         AvgBuffer[i] = EMPTY_VALUE;           // moyenne pas encore définie
         continue;
        }
      double sum = 0.0;
      for(int k = 0; k < InpPeriod; k++)
         sum += RangeBuffer[i - k];
      AvgBuffer[i] = sum / InpPeriod;
     }
   return(rates_total);                        // devient prev_calculated au prochain appel
  }

Étape 5 : compiler, attacher, vérifier

Compilez le fichier dans MetaEditor : le compilateur crée RangeMoyen.ex5 à côté du fichier source et affiche les éventuelles erreurs dans l’onglet de l’outil. Corrigez systématiquement les avertissements, même si l’indicateur fonctionne : ils signalent souvent une conversion de type implicite ou une variable non initialisée. Lisez chaque message en partant du premier : une seule erreur de syntaxe en provoque souvent plusieurs autres plus bas dans le fichier.

Dans MetaTrader 5, l’indicateur apparaît ensuite dans le navigateur, sous Indicateurs, dans le dossier où vous l’avez enregistré. Faites-le glisser sur un graphique, puis contrôlez trois points :

  1. Les valeurs : ouvrez la fenêtre de données et vérifiez à la main l’amplitude d’une ou deux bougies.
  2. Le début du tracé : la ligne ne doit pas commencer par un trait vertical partant de zéro, signe que les premières bougies n’ont pas été neutralisées.
  3. La mise à jour : sur un graphique M1, la dernière valeur doit évoluer avec la bougie en cours et se figer à sa clôture.

Étape 6 : faire évoluer l’indicateur

Un indicateur utile finit presque toujours par recevoir des améliorations. Deux exemples montrent comment procéder sans casser l’existant.

Ajouter un niveau de référence. Pour afficher une ligne horizontale à l’amplitude minimale que votre stratégie juge exploitable, déclarez un paramètre input double InpLevel = 80.0;, puis, dans OnInit(), appelez IndicatorSetInteger(INDICATOR_LEVELS, 1) et IndicatorSetDouble(INDICATOR_LEVELVALUE, 0, InpLevel). Les niveaux définis par programme sont numérotés à partir de 0, alors que la directive #property indicator_levelN commence à 1.

Ajouter un paramètre. Placez tout nouveau paramètre input après les paramètres existants. Les Expert Advisors qui appellent déjà l’indicateur avec iCustom() passent leurs valeurs dans l’ordre de déclaration : insérer un paramètre au début décalerait silencieusement tous les appels.

À chaque modification, recompilez et refaites les trois vérifications de l’étape 5.

Les erreurs de débutant les plus fréquentes

  • Oublier d’augmenter indicator_buffers quand on ajoute un tableau : SetIndexBuffer() échoue alors pour l’index qui dépasse le nombre déclaré.
  • Recalculer tout l’historique à chaque tick : l’indicateur fonctionne, mais ralentit le terminal et le testeur. Le schéma start / prev_calculated règle le problème.
  • Mélanger les sens d’indexation : si vous réglez certains tableaux en série et pas d’autres, high[i] et AvgBuffer[i] ne désignent plus la même bougie. Choisissez un sens et appliquez-le à tous les tableaux utilisés ; la page ArraySetAsSeries et indexation des séries détaille ce point.
  • Lire au-delà du début du tableau : dans la boucle de moyenne, RangeBuffer[i - k] serait hors limites si l’on ne sautait pas les InpPeriod - 1 premières bougies.

Une fois l’indicateur validé, vous pouvez l’utiliser dans un Expert Advisor avec iCustom : l’EA lira le buffer 0 pour obtenir l’amplitude moyenne. La rubrique Indicateurs en MQL5 présente les autres pages consacrées aux indicateurs personnalisés.

FAQ

Où enregistrer un indicateur personnalisé pour qu’il apparaisse dans MetaTrader 5 ?

Dans le dossier MQL5\Indicators du répertoire de données du terminal, ou dans un de ses sous-dossiers. Après compilation, l’indicateur apparaît dans le navigateur, dans le dossier correspondant.

Quelle différence entre INDICATOR_DATA et INDICATOR_CALCULATIONS ?

Un buffer INDICATOR_DATA contient des valeurs destinées à être tracées. Un buffer INDICATOR_CALCULATIONS sert aux calculs intermédiaires et n’est pas dessiné. Les deux comptent dans indicator_buffers.

Pourquoi ma ligne commence-t-elle par un trait partant de zéro ?

Parce que les premières bougies, où la moyenne n’est pas encore définie, contiennent 0 au lieu d’une valeur vide. Écrivez EMPTY_VALUE dans ces bougies et réglez PLOT_DRAW_BEGIN.

Faut-il redimensionner les buffers avec ArrayResize ?

Non. Les tableaux liés par SetIndexBuffer() sont dimensionnés automatiquement par le terminal ; la documentation précise que vous ne pouvez pas modifier leur taille.

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.