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.
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 :
- Quelle valeur, pour chaque bougie ? Ici : la moyenne simple de
(plus haut - plus bas)sur N bougies, exprimée en points. - 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.
- 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 :
| Directive | Valeur | Rôle |
|---|---|---|
indicator_separate_window | (aucune) | Affichage dans une sous-fenêtre |
indicator_buffers | 2 | Nombre total de tableaux gérés par le terminal |
indicator_plots | 1 | Nombre de séries graphiques |
indicator_type1 | DRAW_LINE | Le premier tracé est une ligne |
indicator_color1, indicator_width1 | couleur, épaisseur | Apparence de la ligne |
indicator_label1 | texte | Nom 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, etIndicatorSetInteger(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 :
- Les valeurs : ouvrez la fenêtre de données et vérifiez à la main l’amplitude d’une ou deux bougies.
- 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.
- 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_buffersquand 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_calculatedrè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]etAvgBuffer[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 lesInpPeriod - 1premiè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.
- Handles d’indicateurs et CopyBuffer
- iMA : moyennes mobiles
- iRSI : Relative Strength Index
- iMACD
- iBands : bandes de Bollinger
- iATR : Average True Range
- iStochastic
- iADX
- iCCI
- iMomentum
- iIchimoku
- iSAR : Parabolic SAR
- iEnvelopes
- iWPR : Williams %R
- iAO : Awesome Oscillator
- iAC : Accelerator Oscillator
- iAlligator
- iFractals
- iOBV : On Balance Volume
- iMFI : Money Flow Index
- iVolumes
- iStdDev : écart-type
- iDeMarker
- iBearsPower et iBullsPower
- iForce
- iOsMA
- iRVI
- iAMA : moyenne mobile adaptative
- iDEMA et iTEMA
- iFrAMA
- iCustom : appeler un indicateur personnalisé
- Buffers et styles de tracé
- OnCalculate et prev_calculated
- Indicateur multi-timeframe
- Objets graphiques (ObjectCreate)
