Comment faire appel aux indicateurs dans MQL5

Introduction

Dans MQL5, il existe plusieurs manières de faire appel aux indicateurs, et elles sont principalement accomplies à l'aide des fonctions IndicatorCreate() et iCustom(). De plus, ces fonctions ne renvoient que le descripteur d'indicateur, et d'autres travaux sur les indicateurs sont effectués par son intermédiaire. Alors, qu'est-ce qu'un descripteur ? Comment gérer les fonctions IndicatorCreate() et iCustom() ? Et comment votre expert obtiendra-t-il les données des indicateurs ? Toutes ces questions sont abordées dans cet article.

Création d'un fichier source

Pour commencer avec notre expert, créons son fichier source. Nous ferons cela à peu près comme dans MetaEditor4 en appelant l'assistant MQL5 à partir du menu File -> New. À la première étape, sélectionnez l'Expert Advisor et appuyez sur Next.

Lors de la deuxième étape, il nous est proposé de saisir le nom, les coordonnées de l'auteur et les paramètres de saisie de l'Expert Advisor. Saisissez uniquement le Nom de l’Expert Advisor (champ obligatoire) et l'Auteur. Vous pouvez ajouter des paramètres d'entrée plus tard directement dans le code du programme, si nécessaire.

Après avoir cliqué sur Terminer, l'Assistant créera le code source suivant :

//+------------------------------------------------------------------+
//|                                                   SampleMQL5.mq5 |
//|                                             Copyright KlimMalgin |
//|                                                                  |
//+------------------------------------------------------------------+
#property copyright "KlimMalgin"
#property link      ""
#property version   "1.00"
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---
   
//---
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---
   
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//---
   
  }
//+------------------------------------------------------------------+

Structure du fichier source

Examinons brièvement la structure du fichier source d'un Expert et progressons plus loin.

Le code du programme commence par un en-tête. C'est un commentaire, contenant le nom du fichier et son auteur. Après le titre viennent les propriétés du programme (#property) d'un expert. Ici, la version du programme est automatiquement indiquée, ainsi que le nom de l'auteur et le lien vers votre page, si vous les avez saisis. Après avoir décrit les propriétés, les paramètres d'entrée sont spécifiés (nous ne les avons pas encore spécifiés), puis les variables globales sont déclarées.

Je tiens à noter que les propriétés doivent être définies dans le fichier mql5 principal. Toutes les propriétés des fichiers inclus seront ignorées !

Viennent ensuite trois fonctions qui traitent les événements :

• OnInit() - S'exécute une fois au démarrage de l'expert, au changement de caractère ou au changement de période, sur lequel l'expert est défini.
• OnDeinit(const int reason) - S'exécute également une fois, lorsque l'expert termine son travail ou lorsque la réinitialisation est effectuée. Le paramètre reason contient le code du motif de la désinitialisation.
• OnTick() - Commence à chaque fois que vous recevez une nouvelle coche sur le graphique, où l'expert est attaché.

Indicateurs de connexion

Dans MQL5, les méthodes de travail avec les indicateurs ont changé ! Dans MQL4, pour obtenir la valeur de l'indicateur à une barre particulière, l'indice de cette barre transmis à la fonction iCustom () comme paramètre. Maintenant, nous n'obtenons pas la valeur tampon de l'indicateur, mais nous obtenons son descripteur.  Et en utilisant ce descripteur, nous pouvons obtenir les valeurs de l'indicateur sur un intervalle donné en utilisant une fonction spéciale appelée CopyBuffer(). Alors, qu'est-ce qu'un descripteur ?

Un Handle est un identifiant unique, créé pour être utilisé avec certains indicateurs. Il est représenté en nombres entiers et est stocké dans le type int de la variable. Il existe 2 modes d'obtenir le descripteur d'indicateur dans MQL5 :\

• Appel de la fonction IndicatorCreate() qui renverra le descripteur de l'indicateur en cas de succès, et -1 en cas d'échec.
• Appel de l'une des fonctions des indicateurs techniques. Le résultat de leur exécution est similaire.
  

Les deux méthodes sont également valables, et c'est à vous de décider laquelle utiliser. Considérons les deux modes dans les détails.

Acquisition du descripteur de l'indicateur à l'aide de la fonction IndicatorCreate()

Ainsi, à la suite d'une exécution réussie de la fonction IndicatorCreate(), nous obtiendrons le descripteur de l'indicateur, et en cas d'échec, la fonction renverra une valeur INVALID_HANDLE égale à -1. Si l'indicateur appelé a des paramètres, alors avant d'appeler la fonction nous devons remplir un tableau de paramètres de type MqlParam. Chaque élément de ce tableau est représenté comme une structure de type MqlParam, contenant 4 champs. Le premier champ de cette structure indique lequel des trois champs restants est utilisé comme paramètre pour l'indicateur.

Écrivons le code qui créera les descripteurs des indicateurs de moyenne mobile et de ParabolicSAR. Nous commencerons par la déclaration des variables globales, qui stockeront les descripteurs, et déclarerons un tableau de type MqlParam pour définir les paramètres des indicateurs :

int MA1 = 0,            // Declaring variable to store fast MA handle
    MA2 = 0,            // Declaring variable to store slow MA handle
    SAR = 0;            // Declaring variable to store SAR handle
    
MqlParam params[];      // Array for storing indicators parameters

Ce code doit être placé immédiatement après la définition des propriétés d’expert.

Maintenant, lorsque les variables sont déclarées, vous pouvez remplir le tableau des paramètres et appeler la fonction IndicatorCreate(). Il est préférable de le faire dans la fonction OnInit(), car l'indicateur sera créé une fois en début de programme, et non sur chaque trait !

Remplissons le tableau des paramètres et appelons le premier indicateur :

int OnInit()
{
//---
   // Setting the params size equal to number of called indicator parameters
   ArrayResize(params,4);

   // Setting the period of fast MA
   params[0].type         =TYPE_INT;
   params[0].integer_value=5;
   // Offset
   params[1].type         =TYPE_INT;
   params[1].integer_value=0;
   // Calculation method: simple averaging
   params[2].type         =TYPE_INT;
   params[2].integer_value=MODE_SMA;
   // Price type for calculation: the Close prices
   params[3].type         =TYPE_INT;
   params[3].integer_value=PRICE_CLOSE;
   
   MA1 = IndicatorCreate(Symbol(), // Symbol used to calculate the indicator
                         0,        // Timeframe. 0 means current
                         IND_MA,   // Indicator type from the ENUM_INDICATOR enumeration
                         4,        // Number of parameters passed in the params array
                         params    // Parameters array
                         );   
//---
return(0);
}

Comme le tableau params a été déclaré comme un tableau dynamique, c'est-à-dire que la taille du tableau n'a pas été définie entre parenthèses, alors avant de l'utiliser, nous devons définir sa taille. En utilisant la fonction ArrayResize(), nous définirons la taille égale au nombre de paramètres, que nous transférerons dans le tableau. Pour la moyenne mobile, quatre paramètres sont nécessaires.

Le premier paramètre est la période MA. Il est défini comme un nombre entier. Par conséquent, pour le champ type du premier paramètre, nous allons définir la valeur TYPE_INT, ainsi notre fonction IndicatorCreate() « comprendra » que cette valeur doit être prise dans le champ integer_value. Étant donné que tous les paramètres de la moyenne mobile sont de type int, ils seront définis en conséquence.

Une fois le tableau rempli, vous pouvez appeler la fonction IndicatorCreate(). Sa sortie sera stockée dans la variable MA1. Il ne devrait y avoir aucune difficulté à appeler la fonction, et seulement cinq paramètres doivent y être transférés :

• Le premier est le nom de l'outil de travail. La fonction Symbol() retournera le nom de l'outil courant, sur lequel l'expert s'exécute. 
• Le deuxième paramètre spécifie la durée de temps sur laquelle les valeurs de l'indicateur sont comptées.
  
• Le troisième paramètre spécifie le type d’indicateur qui sera appelé.
  
• Le quatrième paramètre spécifie le nombre de paramètres à transmettre dans le tableau params.
• Et, enfin, le cinquième paramètre est le tableau des paramètres d'entrée de l'indicateur.

Et voilà ! Nous avons le descripteur MA rapide et devons obtenir les descripteurs des indicateurs MA et SAR lents. En conséquence, la fonction OnInit() ressemblera à ce qui suit :

int OnInit()
  {
//---

   // Setting the params size equal to number of called indicator's parameters
   ArrayResize(params,4);

//*    Calling indicators   *
//***************************
   // Setting the period of fast MA
   params[0].type         =TYPE_INT;
   params[0].integer_value=5;
   // Offset
   params[1].type         =TYPE_INT;
   params[1].integer_value=0;
   // Calculation method: simple averaging
   params[2].type         =TYPE_INT;
   params[2].integer_value=MODE_SMA;
   // Price type for calculation: the Close prices
   params[3].type         =TYPE_INT;
   params[3].integer_value=PRICE_CLOSE;
   
   MA1 = IndicatorCreate(Symbol(), 0, IND_MA, 4, params);
   
   // Setting the period of slow MA
   params[0].type         =TYPE_INT;
   params[0].integer_value=21;
   // Offset   
   params[1].type         =TYPE_INT;
   params[1].integer_value=0;
   // Calculation method: simple averaging
   params[2].type         =TYPE_INT;
   params[2].integer_value=MODE_SMA;
   // Price type for calculation: the Close prices
   params[3].type         =TYPE_INT;
   params[3].integer_value=PRICE_CLOSE;
   
   MA2 = IndicatorCreate(Symbol(), 0, IND_MA, 4, params);
   
   
   // Changing array size to store the SAR indicator parameters
   ArrayResize(params,2);
   // Step
   params[0].type         =TYPE_DOUBLE;
   params[0].double_value = 0.02;
   // Maximum
   params[1].type         =TYPE_DOUBLE;
   params[1].double_value = 0.2;
   
   SAR = IndicatorCreate(Symbol(), 0, IND_SAR, 2, params);
   
//---
   return(0);
  }

Pour obtenir le descripteur MA lent, vous ne pouvez modifier la période que de 5 à 21. Et lorsque le ParabolicSAR est appelé, les nombres en virgule flottante (double) sont transférés en tant que paramètres. Lors du remplissage du tableau, vous devez en tenir compte et mettre respectivement le TYPE_DOUBLE dans le champ type et le paramètre lui-même dans le champ double_value. De plus, le SAR ne nécessite que deux paramètres, la taille du tableau passe donc à 2 à l'aide de ArrayResize().

Pour l'instant, la fonction IndicatorCreate() prend fin. À mon avis, cette méthode d'appel d'indicateurs est la plus pratique dans une approche orientée objet, lorsque la bibliothèque de classes est créée pour fonctionner avec des indicateurs. Cette bibliothèque facilitera davantage le traitement des projets de grande envergure. Et pour écrire et tester des experts rapides, il est préférable d'utiliser la méthode suivante.

Acquisition de descripteur à l'aide des fonctions des indicateurs techniques

La deuxième méthode, qui vous permet d'obtenir le descripteur d'indicateur, consiste à appeler l'une des fonctions d'indicateurs techniques. Chacune de ces fonctions est destinée à obtenir le descripteur de l'un des indicateurs standard, livrés avec MetaTrader 5. Ils ont tous un certain ensemble de paramètres, en fonction de l'indicateur auquel ils sont destinés. Par exemple, pour l'indicateur CCI, la fonction iCCI() est appelée et se présente comme suit :

   CCI = iCCI(
              Symbol(),            // symbol name
              PERIOD_CURRENT,      // period
              20,                  // averaging period
              PRICE_CLOSE          // price type or handle
              );

Le descripteur d'un autre indicateur peut être soumis en tant que dernier paramètre dans la fonction des indicateurs techniques au lieu du type de prix. Ensuite, l'indicateur, appelé de cette manière, sera calculé en utilisant non pas les données de prix, mais les données d'un autre indicateur.

La fonction iCustom() suscite un intérêt particulier parmi les autres fonctions d'indicateurs techniques, car elle peut appeler n'importe quel indicateur, y compris les indicateurs personnalisés. Écrivons le code similaire à ce qui précède, mais en utilisant la fonction iCustom() :

int OnInit()
  {
//---

   MA1 = iCustom(NULL,0,"Custom Moving Average",
                          5,          // Period
                          0,          // Offset
                          MODE_SMA,   // Calculation method
                          PRICE_CLOSE // Calculating on Close prices
                 );

   MA2 = iCustom(NULL,0,"Custom Moving Average",
                          21,         // Period
                          0,          // Offset
                          MODE_SMA,   // Calculation method
                          PRICE_CLOSE // Calculating on Close prices
                 );

   SAR = iCustom(NULL,0,"ParabolicSAR",
                          0.02,        // Step
                          0.2          // Maximum
                 );

//---
   return(0);
  }

Gardez à l'esprit qu'il est préférable d’obtenir le descripteur une seule fois que l’expert démarre pour permettre donc de faire appel à la fonction OnInit().

La fonction iCustom() contient les paramètres suivants :

1. Nom de l’outil de travail, dont les données sont utilisées pour calculer l'indicateur. NULL - signifie l'outil actuel. Vous pouvez utiliser Symbol() au lieu de NULL, pas beaucoup de différence. Dans le cas du Symbol(), le nom d'un instrument est transféré à iCustom(), mais dans le cas de NULL, iCustom() trouve l'instrument financier lui-même.
2. Période d’édition. Pour spécifier la période, vous pouvez utiliser des périodes d’édition prédéfinies, ainsi que 0 - pour faire référence à la durée actuelle dans le temps.
3. Nom de l’indicateur. L'indicateur appelé doit être compilé et doit se trouver dans le dossier « MQL5\Indicators\ » ou dans l'un de ses sous-dossiers.
4. Paramètres restants. Ces valeurs seront utilisées comme paramètres d'entrée pour l'indicateur appelé, leur type et la séquence doivent donc correspondre. Si elles ne sont pas spécifiées, les valeurs par défaut seront utilisées.

Comme il a été dit - cette méthode est plus pratique à utiliser avec des indicateurs, si vous n'avez pas de bibliothèque avec laquelle vous avez l'habitude de travailler. Maintenant, lorsque les descripteurs sont reçus, vous pouvez commencer à travailler avec les valeurs des indicateurs !

Collecte des données de l'indicateur

L'avantage génial de travailler avec les données de l'indicateur dans MQL5 est d'avoir désormais la possibilité d'obtenir des données uniquement à l'intervalle dont nous avons besoin. Vous pouvez définir l'intervalle de différentes manières :

• Obtention du nombre de barres spécifié par rapport à la barre sélectionnée.
• Obtention du nombre de barres spécifié par rapport à la date sélectionnée.
• Obtention des données de l'indicateur à un intervalle de temps donné, c'est-à-dire en précisant les dates de début et de fin.

Pour lire la date de l'indicateur, la fonction CopyBuffer() est utilisée. La méthode d'obtention des données qui sera utilisée dépend des paramètres d'entrée qui seront transférés à cette fonction.

Écrivons le code qui copie les données des indicateurs (nous avons déjà obtenu leurs descripteurs plus tôt) dans les tableaux :

void OnTick()
  {
//---

// Dynamic arrays to store indicators values
double _ma1[],
       _ma2[],
       _sar[];

// Setting the indexing in arrays the same as in timeseries, i.e. array element with zero
// index will store the values of the last bar, with 1th index - the last but one, etc.
   ArraySetAsSeries(_ma1, true);
   ArraySetAsSeries(_ma2, true);
   ArraySetAsSeries(_sar, true);

// Using indicators handles, let's copy the values of indicator
// buffers to arrays, specially prepared for this purpose
   if (CopyBuffer(MA1,0,0,20,_ma1) < 0){Print("CopyBufferMA1 error =",GetLastError());}
   if (CopyBuffer(MA2,0,0,20,_ma2) < 0){Print("CopyBufferMA2 error =",GetLastError());}
   if (CopyBuffer(SAR,0,0,20,_sar) < 0){Print("CopyBufferSAR error =",GetLastError());}


//---
  }

Maintenant, tout notre travail se concentrera sur la fonction OnTick(), car à chaque trait les indicateurs changent et doivent être mis à jour.

Tout d'abord, déclarons des tableaux dynamiques pour chaque tampon d'indicateur. À mon avis, il est plus pratique de travailler avec des données d'indicateur, si l'indexation du tableau sera la même que dans les séries temporelles, c'est-à-dire que dans l'élément de tableau 0, il y aura des données de la dernière barre, dans l'élément numéro 1 - l'avant-dernier , etc. La méthode d'indexation est définie à l'aide de la fonction ArraySetAsSeries().

Une fois la méthode d'indexation définie, nous pouvons commencer à remplir les tableaux. Pour calculer chaque indicateur, nous appellerons la fonction CopyBuffer() avec l'ensemble de paramètres suivant :

1. Indicateur de descripteur, savoir quelles données vous souhaitez obtenir.
2. nombre de tampon de l’indicateur. Comme les indicateurs MA et SAR ont un tampon, nous les définirons sur 0. S'il y a plus d'un tampon, le second sera le numéro 1, le troisième sera le numéro 2, etc.
3. Barre initiale, à partir de laquelle le comptage commence.
4. Le nombre de barres que vous souhaitez copier.
5. Le tableau{/0} dans lequel les données sont copiées.

En cas d'appel réussi, la fonction CopyBuffer() renverra le nombre d'éléments copiés, en cas d'échec, elle renverra -1. En cas d'échec, l'erreur doit être suivie, donc si la valeur renvoyée est inférieure à 0 - nous écrirons l'erreur dans le journal d’experts en utilisant la fonction Print().

Conclusion

Pour l'instant, notre travail avec les indicateurs est loin d'être terminé. Cet article ne couvre que les méthodes de base pour accéder à leurs données. Et pour plus de commodité, il est préférable d'utiliser une approche orientée objet, qui est implémentée dans MQL5 de manière assez satisfaisante !