Un démarrage rapide ou un petit guide pour les débutants
1 286
0
Introduction
Bonjour cher lecteur ! Dans cet article, je vais essayer de vous expliquer et de vous montrer comment maîtriser facilement et rapidement les principes de création d'Expert Advisors, de travail avec des indicateurs, etc. Il est destiné aux débutants et ne comportera pas d'exemples difficiles ou abstraits. L'article n'est donc probablement pas aussi inspirant et informatif pour ceux d'entre vous qui savent déjà comment programmer des Expert Advisors.
Expert Advisor et sa structure
Expert Advisor est un programme écrit dans le langage MQL qui spécifie les conditions pour pratiquer le trading ou faire des économies.
Fondamentalement, la structure d'un EA peut être constituée d'un grand nombre de blocs mais afin de faciliter sa compréhension, je vais donner un exemple très simple généré par défaut dans MetaEditor.
L'ensemble de l'EA peut être visuellement divisé en 4 parties dont chacune est responsable d'une certaine partie de travail à effectuer.
Fig. 1. Les principaux blocs EA
- Le bloc de paramètre contient des informations pour le terminal lui permettant de gérer correctement l'EA. Les paramètres les plus courants sont la version EA, le nom de la société de fabrication et une brève description.
- OnInit() Block prend le contrôle une fois que l'EA est chargé dans le terminal. Il peut contenir diverses données liées à l'initialisation de l'EA - déclaration de variables et de tableaux, obtention de descripteurs d'indicateur, etc. C'est-à-dire que ce bloc n'a aucune fonction qui serait directement associée au trading.
- OnDeinit() Block agit comme l'inverse du bloc OnInit(). Il est appelé lorsque l'EA arrête de fonctionner (Arrêt du Terminal/EA ou initialisation infructueuse d'un EA). L'une des fonctions principales de ce bloc est la désallocation de l'espace mémoire occupé par l'EA lorsqu'il n'est plus nécessaire. En d'autres termes, il décrit les processus de suppression de variables, de tableaux et de descripteurs d'indicateur, etc.
- OnTick() Block est appelé à chaque fois que de nouvelles informations sur le symbole (couple de devises) sont reçues du serveur. Il précise les conditions d'exercice du métier et les fonctions du métier lui-même.
Figure 2. Exemple d'un nouveau document généré par défaut dans MetaEditor
Permettez-moi de l'expliquer en utilisant l'exemple ci-dessus. Nous avons un code Expert Advisor « blanc », une sorte de modèle Expert Advisor qui devra être rempli par la suite.
Voici comment cela se présente :
- les cinq premières lignes (lignes 1 à 5) représentent des commentaires contenant le nom de l'EA (nom du fichier), le nom de l'entreprise de fabrication et son site Internet. Vous pouvez écrire ici tout ce que vous voulez. Ce texte ne sera visible nulle part et peut même être ignoré. Les informations qu'il contient ne ciblent que le développeur ;
- les 3 lignes suivantes (lignes 6 à 8) représentent le bloc de paramètres. Cette information peut être observée lors du démarrage de l'EA dans le terminal ;
- il est suivi de la fonction OnInit() (lignes 12 à 19). C'est le bloc OnInit(). Cette fonction n'obtient aucun paramètre mais retourne (bien qu'elle puisse aussi bien ne pas) le code d'initialisation ;
- la fonction OnDeinit(const int reason) passe à l’étape suivante (lignes 22 à 26). Il s’agit du bloc OnDeinit(). Il a un paramètre qui spécifie la raison de l'arrêt d'EA.
Si l'initialisation de l'EA échoue, cette fonction reçoit en paramètre un code correspondant ; - la dernière fonction est OnTick() (lignes 30 à 34). Il s'agit du bloc OnTick() décrit précédemment. Ce bloc peut être qualifié de « cerveau » de l'EA puisqu'il regroupe toutes les fonctions en charge des transactions de trading.
Comme je l'ai dit précédemment, la structure peut être beaucoup plus complexe et être constituée de beaucoup de blocs contrairement à cet exemple facile à comprendre. Lorsque vous sentez que cela ne suffit pas, vous pouvez ajouter vos propres blocs.
Indicateurs et comment les gérer
Indicators sont de petits programmes écrits en MQL qui sont affichés dans le tableau des prix ou dans une fenêtre séparée sous le tableau des prix et nous permettent d'effectuer une analyse technique du marché.
Tous les indicateurs peuvent être classés en deux types : les indicateurs de suivi de tendance et les oscillateurs.
Les indicateurs de suivi de tendance sont, en règle générale, dessinés dans le graphique des prix et sont utilisés pour identifier la direction de la tendance, tandis que les oscillateurs peuvent normalement être vus sous le graphique des prix et servent à identifier les points d'entrée.
La plupart des indicateurs ont au moins un tampon (tampon indicateur) qui contient ses données de lecture à un moment donné. Comme un EA, l'indicateur a son symbole et sa période de calcul.
Le tampon indicateur peut être considéré comme une file d'attente dont le dernier élément est une valeur en cours d'exécution.
Fig. 3. Exemple d'indicateur de moyenne mobile
Le tampon d'indicateur est un tableau où le premier élément (avec indice 0) transporte des données sur le chandelier le plus à droite et l'élément suivant (avec indice 1) transporte des données sur le deuxième chandelier à droite, etc. Un tel arrangement d'éléments est appelé série temporelle.
Jetez un oeil à l'exemple suivant :
Supposons que la paire de devises que nous ayons soit EUR/USD, le délai est de 1 heure.
Tout d'abord, nous devons ajouter l'indicateur à l'EA et obtenir son descripteur.
Le descripteur est un pointeur unique vers l'indicateur qui nous permet d'aborder cet indicateur n'importe où dans le programme.
int iMA_handle; iMA_handle=iMA("EURUSD",PERIOD_H1,10,0,MODE_SMA,PRICE_CLOSE);Regardons-le de plus près.
La première ligne définit une variable qui va stocker le descripteur de l'indicateur. La deuxième ligne fait appel à l'indicateur (ici, l'indicateur Moyenne mobile), spécifie ses paramètres et enregistre le descripteur dans la variable pour une utilisation ultérieure.
Figure 4. Exemple d'info-bulle pour les paramètres de l'indicateur de moyenne mobile
Nous pouvons voir les paramètres suivants répertoriés de gauche à droite :
- le nom de symbole (apparaît en caractères gras dans l'info-bulle) est un paramètre de texte, une paire de devises (symbole) ;
- Plage temporelle ;
- période d’indicateur (ici, la période de la moyenne) ;
- basculement du graphique de N barres vers l'avant/l'arrière. Un nombre positif indique le basculement du graphique de N barres vers l'avant, tandis qu'un nombre négatif indique son basculement de N barres vers l'arrière ;
- mode de la moyenne ;
- prix appliqué ou un descripteur d'un autre indicateur.
Il existe un ensemble unique de variables et leurs types pour chaque indicateur. Si vous rencontrez un indicateur inconnu, les informations le concernant peuvent toujours être trouvées dans l'aide contextuelle intégrée. Par exemple, une fois que vous avez tapé iMA et appuyé sur F1, une fenêtre d'aide s'ouvrira fournissant des informations sur cet indicateur spécifique et une description détaillée de toutes ses propriétés.
Fig. 5. Exemple d'appel de la fenêtre d'aide pour la description de l'indicateur en appuyant sur F1
Après avoir écrit le code et démarré l'EA dans le terminal, nous verrons (une fois que l'EA apparaît dans le coin supérieur droit du tableau des prix) que l'indicateur est absent du graphique. Ce n'est pas une erreur - c'était ainsi voulu. Pour qu'il apparaisse, nous devons ajouter une autre ligne :
ChartIndicatorAdd(ChartID(),0,iMA_handle);
Voyons maintenant ce qu'il fait. Placez le curseur sur la commande ChartIndicatorAdd et appuyez sur F1 pour lire les informations d'aide sur l'objectif de la commande. Il indique que cette commande :
Ajoute un indicateur avec le descripteur spécifié dans une fenêtre de graphique spécifiée.
Le deuxième paramètre égal à zéro est le numéro de la sous-fenêtre. Les sous-fenêtres contiennent généralement des oscillateurs, sous le tableau des prix. Vous en souvenez-vous ? Il peut y en avoir beaucoup. Pour afficher l'indicateur dans la sous-fenêtre, il suffit de préciser le numéro de la sous-fenêtre de manière à ce qu'il soit supérieur de 1 au numéro déjà existant, c'est-à-dire le numéro suivant le dernier existant.
Après avoir modifié la ligne de code comme suit :
ChartIndicatorAdd(ChartID(),1,iMA_handle);
notre indicateur apparaîtra dans la sous-fenêtre sous le tableau des prix.
Il est maintenant temps d'essayer d'obtenir des données de l'indicateur. À cette fin, nous déclarons un tableau dynamique, organisons l'indexation des tableaux sous forme de séries temporelles pour des raisons de commodité et copions les valeurs des indicateurs dans ce tableau.
double iMA_buf[]; ArraySetAsSeries(iMA_buf,true); CopyBuffer(iMA_handle,0,0,3,iMA_buf);
L'exemple ci-dessus montre que nous avons déclaré le tableau dynamique iMA_buf[] de type double car l'indicateur de moyenne mobile est basé sur les prix et les prix ont des fractions.
La ligne suivante définit l'indexation du tableau de sorte que les éléments avec des indices plus petits stockent des valeurs plus anciennes, tandis que les éléments avec des indices plus grands stockent des valeurs plus récentes. Ceci est utilisé pour plus de commodité afin d'éviter toute confusion car les tampons d'indicateurs dans tous les indicateurs sont indexés sous forme de séries chronologiques.
La dernière ligne sert à copier les valeurs de l'indicateur dans le tableau iMA_buf[]. Ces données sont maintenant prêtes à être utilisées.
Ordres, trades et positions
Commençons par les ordres.
- Les ordres sont des demandes trading acceptées par le serveur de trading. Si la demande est invalide, elle sera rejetée.
Pour éviter la difficulté de remplir la demande trading, je vous montrerai plus tard comment cela peut être fait en utilisant les bibliothèques standard, ce qui facilite grandement les choses.
Il existe 2 types d'ordres : marché (pour exécution immédiate) et en attente.
Les ordres de marché représentent des instructions de vente ou d'achat pour un certain montant d'un instrument financier spécifié au prix actuel du marché.
Les ordres en attente représentent des instructions pour exécuter la transaction sous certaines conditions. Les ordres en attente ont un certain délai d'expiration au bout duquel ils sont supprimés.
- Les trades représentent les résultats de l'exécution d'ordres (instructions pour exécuter une transaction). Chaque transaction est basée sur un certain ordre unique, alors qu'un seul ordre peut entraîner plusieurs transactions. Par exemple, un ordre d'achat de 10 lots peut être exécuté par une exécution partielle d'un certain nombre de transactions consécutives. Les transactions sont toujours stockées dans l'historique des transactions et ne peuvent pas être modifiées. Le terminal affiche les transactions dans l'onglet « Historique ».
- Les positions représentent le résultat des ordres en action. Une seule position, longue ou courte, peut être ouverte pour chaque symbole.
Pour que ce soit plus clair, permettez-moi de l'illustrer par un exemple : nous ouvrons une position longue de 1 lot, c'est-à-dire que nous passons un ordre au prix du marché actuel (par exemple) et à la taille de 1 lot. Si la demande est valide, elle sera envoyée au serveur pour traitement. Dès que le traitement est terminé, une position avec les paramètres de l’ordre apparaîtra dans l'onglet « Trade » du terminal. Supposons que nous décidions alors d'ouvrir une autre position longue, également dimensionnée à 1 lot. Suite au traitement de la commande, nous ne verrons pas deux commandes dans l'onglet « Trade », mais plutôt une position dimensionnée à 2 lots. C'est-à-dire que la position est le résultat de l'exécution d'un certain nombre d'ordres.
Passons maintenant à la pratique. Les champs de structure suivants doivent être remplis pour adresser une demande :
struct MqlTradeRequest { ENUM_TRADE_REQUEST_ACTIONS action; // Type of action ulong magic; // Expert Advisor ID (magic number) ulong order; // Order ticket string symbol; // Trade instrument double volume; // Requested trade size in lots double price; // Price double stoplimit; // StopLimit level of the order double sl; // Stop Loss level of the order double tp; // Take Profit level of the order ulong deviation; // Maximum allowed deviation from the requested price ENUM_ORDER_TYPE type; // Order type ENUM_ORDER_TYPE_FILLING type_filling; // Order type by execution ENUM_ORDER_TYPE_TIME type_time; // Order type by duration datetime expiration; // Order expiration time (for orders of the ORDER_TIME_SPECIFIED type) string comment; // Comment to the order };
Comme il existe plusieurs ordres, chaque type d’ordre possède son propre ensemble de paramètres obligatoires. Je n'aborderai pas ces domaines en détail. Le site Web offre de nombreuses informations à ce sujet. Si même l'un des paramètres obligatoires pour un certain type d’ordre n'est pas spécifié ou spécifié de manière incorrecte, la demande ne passera pas.
La structure ci-dessus n'est présentée ici que pour mieux montrer la difficulté qui se pose lors de son remplissage.
Stopper la perte et Tirer profit
Stopper la perte et Tirer profit sont des ordres spéciaux passés en tant que « stratégie de repli ». C'est-à-dire qu'en cas d'erreur ou d'une position ouverte par l'Expert Advisor qui affiche une perte, un ordre Stopper la perte peut limiter les pertes à un certain niveau prédéfini.
Tirer profit agit de manière similaire, ne limitant que le profit dans ce cas. Il peut devenir nécessaire d'arrêter de s'inquiéter de la fermeture d'une position. Il sera fermé une fois atteint un certain niveau de prix. En d'autres termes, ces ordres représentent notre « plan d'assurance », si le marché se retourne contre nous ou si nous voulons en tirer profit.
Ce type d'ordres ne peut pas être placé séparément - il ne peut que modifier des positions déjà existantes.
Utilisation des bibliothèques standard
Nous voilà finalement arrivés à la bibliothèque standard. Cette bibliothèque est associée au terminal, d'où son nom - Bibliothèque standard. Elle comprend des fonctions qui facilitent la programmation des EA et entreprend partiellement des processus complexes, par exemple la génération de demandes trading.
Les bibliothèques trading (voir aussi classes trading) ont leur emplacement dans le chemin suivant : Include\Trade\ et peut être ajouté à l'aide de la directive #include.
Exemple :
#include <Trade\Trade.mqh> #include <Trade\PositionInfo.mqh>
Les classes ci-dessus peuvent être considérées comme les classes de base car la majorité des Expert Advisors peuvent être programmés en utilisant uniquement ces deux classes (bibliothèques). Je les appelle des bibliothèques :
- La première est conçue pour placer et modifier des ordres.
- La seconde sert à obtenir des informations sur les positions déjà existantes.
Parfois, une autre bibliothèque peut s'avérer utile :
#include <Trade\OrderInfo.mqh> Elle contient des fonctions pour travailler avec des ordres, si, par exemple, notre stratégie nécessite l'utilisation des ordres en attente.Vous vous souvenez de la structure de demande de trade pleine de paramètres divers qui nécessitent des connaissances pour être correctement utilisées ?
Maintenant, je vais vous donner un exemple de demande de trade effectuée à l'aide de la bibliothèque :
CTrade m_Trade; m_Trade.Sell(lot,symbol_name,price,sl,tp,comment);
Il y a un total de 6 paramètres ici, dont un seul est obligatoire (le volume de l’ordre - c'est le premier paramètre).
Je vais maintenant préciser chacun d'eux :
- lot est le volume de l’ordre à placer ;
- symbol_name est le symbole (paire de devises) auquel l'ordre s'applique (si aucun n'est spécifié, le symbole actuel de l'Expert Advisor est utilisé) ;
- price est le prix d'ouverture (puisqu'il s'agit de la fonction d'ouverture d'un ordre actif, son prix peut être indéterminé, auquel cas il sera automatiquement obtenu directement à partir du tableau des prix) ;
- sl est le prix à la clôture de l’ordre, si le prix n'est pas à notre avantage (il peut être omis si la stratégie n'implique pas l'utilisation d'un ordre Stopper la perte) ;
- tp est le prix à la clôture de l’ordre, si le prix prend la direction voulue, c'est-à-dire qu'il tire profit (il peut être omis si la stratégie n'implique pas l'utilisation d’un ordre Tirer profit) ;
- comment est le commentaire sur l’ordre, par exemple en spécifiant la motivation de l’ordre.
Il existe plusieurs manières de clôturer une position :
- procéder à la clôture de toute la position
CPositionInfo m_Position; m_Position.Select(symbol_name); m_Trade.PositionClose(symbol_name);
- procéder à la clôture de la position en passant un ordre inverse du même volume
CTrade m_Trade; m_Trade.Buy(lot,symbol_name,price,sl,tp,comment);
- en utilisant une méthode plus compliquée dans laquelle toutes les positions ouvertes sont d'abord recherchées pour sélectionner celle qui répond aux paramètres requis (symbole, type, nombre magique, identifiant de position, etc.) pour une une clôture plus définitive.
Je ne vais pas donner d'exemple de ce qui précède en raison de sa difficulté pour les débutants.
Sommaire
Il est grand temps maintenant de mettre les connaissances nouvellement acquises dans un seul Expert Advisor.
//+------------------------------------------------------------------+ //| fast-start-example.mq5 | //| Copyright 2012, MetaQuotes Software Corp. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2012, MetaQuotes Software Corp." #property link "https://www.mql5.com" #property version "1.00" //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ #include <Trade\Trade.mqh> //include the library for execution of trades #include <Trade\PositionInfo.mqh> //include the library for obtaining information on positions int iMA_handle; //variable for storing the indicator handle double iMA_buf[]; //dynamic array for storing indicator values double Close_buf[]; //dynamic array for storing the closing price of each bar string my_symbol; //variable for storing the symbol ENUM_TIMEFRAMES my_timeframe; //variable for storing the time frame CTrade m_Trade; //structure for execution of trades CPositionInfo m_Position; //structure for obtaining information of positions //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ int OnInit() { my_symbol=Symbol(); //save the current chart symbol for further operation of the EA on this very symbol my_timeframe=PERIOD_CURRENT; //save the current time frame of the chart for further operation of the EA on this very time frame iMA_handle=iMA(my_symbol,my_timeframe,40,0,MODE_SMA,PRICE_CLOSE); //apply the indicator and get its handle if(iMA_handle==INVALID_HANDLE) //check the availability of the indicator handle { Print("Failed to get the indicator handle"); //if the handle is not obtained, print the relevant error message into the log file return(-1); //complete handling the error } ChartIndicatorAdd(ChartID(),0,iMA_handle); //add the indicator to the price chart ArraySetAsSeries(iMA_buf,true); //set iMA_buf array indexing as time series ArraySetAsSeries(Close_buf,true); //set Close_buf array indexing as time series return(0); //return 0, initialization complete } //+------------------------------------------------------------------+ //| Expert deinitialization function | //+------------------------------------------------------------------+ void OnDeinit(const int reason) { IndicatorRelease(iMA_handle); //deletes the indicator handle and deallocates the memory space it occupies ArrayFree(iMA_buf); //free the dynamic array iMA_buf of data ArrayFree(Close_buf); //free the dynamic array Close_buf of data } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { int err1=0; //variable for storing the results of working with the indicator buffer int err2=0; //variable for storing the results of working with the price chart err1=CopyBuffer(iMA_handle,0,1,2,iMA_buf); //copy data from the indicator array into the dynamic array iMA_buf for further work with them err2=CopyClose(my_symbol,my_timeframe,1,2,Close_buf); //copy the price chart data into the dynamic array Close_buf for further work with them if(err1<0 || err2<0) //in case of errors { Print("Failed to copy data from the indicator buffer or price chart buffer"); //then print the relevant error message into the log file return; //and exit the function } if(iMA_buf[1]>Close_buf[1] && iMA_buf[0]<Close_buf[0]) //if the indicator values were greater than the closing price and became smaller { if(m_Position.Select(my_symbol)) //if the position for this symbol already exists { if(m_Position.PositionType()==POSITION_TYPE_SELL) m_Trade.PositionClose(my_symbol); //and this is a Sell position, then close it if(m_Position.PositionType()==POSITION_TYPE_BUY) return; //or else, if this is a Buy position, then exit } m_Trade.Buy(0.1,my_symbol); //if we got here, it means there is no position; then we open it } if(iMA_buf[1]<Close_buf[1] && iMA_buf[0]>Close_buf[0]) //if the indicator values were less than the closing price and became greater { if(m_Position.Select(my_symbol)) //if the position for this symbol already exists { if(m_Position.PositionType()==POSITION_TYPE_BUY) m_Trade.PositionClose(my_symbol); //and this is a Buy position, then close it if(m_Position.PositionType()==POSITION_TYPE_SELL) return; //or else, if this is a Sell position, then exit } m_Trade.Sell(0.1,my_symbol); //if we got here, it means there is no position; then we open it } } //+------------------------------------------------------------------+
Testons notre Expert Advisor avec les paramètres suivants :
- symbole - EURUSD ;
- délai - H1 ;
- mode de trade « Prix à l'ouverture seulement ».
Étant donné que nous utilisons les valeurs des indicateurs et les cours de clôture en commençant par la première barre (la barre zéro est une barre courante et active), le graphique ne sera pas redessiné. Cela signifie que nous pouvons utiliser le mode de trade « Prix à l'ouverture seulement ». Cela n'affectera pas la qualité du test mais le rendra plus rapide.
Et voici les résultats des tests rapides utilisant des données historiques.
Figure 6. Les résultats des tests de notre Expert Advisor
Les encaissements ne peuvent certainement pas passer inaperçus. Cependant, cet article ne visait pas à programmer un « super Expert Advisor » qui aurait un grand potentiel de profit avec un encaissement minimal, mais plutôt à démontrer avec quelle facilité on peut programmer un Expert Advisor lorsqu'on est armé de connaissances de base.
Nous avons l'Expert Advisor composé de moins de cent lignes de code.
Conclusion
Cet article a couvert les grands principes à considérer lors de la programmation d'un Expert Advisor. Nous avons appris à utiliser l' aide contextuelle intégrée dans MetaEditor 5 pour obtenir des informations sur diverses fonctions, avons eu une idée générale des ordres et des positions et avons adopté l'utilisation des bibliothèques standard.
Traduit du russe par MetaQuotes Ltd.
Article original : https://www.mql5.com/ru/articles/496
Création d'un Expert Advisor semi-automatique interactif par glisser-déposer axé sur un risque et un ratio R/R prédéfinis
Stratégies d’ordres. Un Expert Advisor polyvalent
Concevoir et implémenter de nouveaux widgets GUI axés sur la classe CChartObject
Opérations trading en MQL5 - Combien facile
- Applications de trading gratuites
- Plus de 8 000 signaux à copier
- Actualités économiques pour explorer les marchés financiers
Vous acceptez la politique du site Web et les conditions d'utilisation