Apprenez Pourquoi et Comment Concevoir Votre Système de Trading Algorithmique
Mohamed Abdelmaaboud | 4 mai, 2022
Introduction
Nous pouvons dire sans aucun doute que l'importance de la programmation ou du codage augmente chaque jour dans tous les domaines de notre monde. Ainsi, nous pouvons observer comment la programmation ou le codage peuvent contribuer à nous faciliter la vie et non seulement nous faciliter la vie mais garantir des sorties précises en fonction de ce que vous voulez et de ce que vous avez déterminé auparavant.
En ce qui concerne le monde du trading - ce domaine et cette carrière magnifiques - nous pouvons dire que la programmation ou le codage rend notre trading facile et systématique grâce à des programmes créés qui contribuent à nous donner cette facilité et cette automatisation une fois que nous avons terminé un programme précis et bon avec quoi nous attendons et voulons obtenir de ce programme. Ainsi, le monde du codage peut nous apporter de nombreux avantages, mais à mon avis, l'avantage le plus important du codage pour le trading est de vous aider à être discipliné, comme nous le savons tous en tant que traders, il est toujours difficile d'être discipliné avec nos décisions de trading. La discipline est un trait formidable et important qui affecte nos résultats de trading et d'investissement, il n'est donc pas envisageable de ne pas être discipliné dans votre trading. Comme j'aime toujours le dire, la discipline est la clé de votre succès dans le trading et dans la vie entière. Pour identifier la discipline de manière simple, cela signifie faire ce que vous avez à faire au bon moment, quelles que soient les circonstances environnantes. Ainsi, lorsque nous trouvons un outil qui aide à y parvenir, nous devons être attentifs et apprendre de quoi il s'agit. Et le bon outil pour cela est le codage.
Comme nous le savons tous, la chose la plus populaire qui nous empêche d'être discipliné pendant le trading, ce sont les émotions, et nous devons éviter ces émotions ou éviter l'effet négatif de ces émotions sur nos décisions de trading. Et je veux que vous imaginiez si vous aviez un système qui fonctionne pour vous avec vos paramètres prédéterminés sans intervention humaine. Ainsi, dans ce cas, l'effet négatif des émotions sur nos décisions de trading sera évité. La bonne nouvelle est que nous avons un outil qui nous aide à le faire. Ici, je vais écrire sur MQL (MetaQuotes Language) pour la plateforme MetaTrader. Ce langage ou outil de programmation nous aidera à concevoir notre système de trading avec nos paramètres spécifiques qui garantiront des actions spécifiques ou des décisions de trading spécifiques.
Si vous voulez en savoir plus sur ce concept, mentionnons cet exemple. Si nous avons deux investisseurs (A & B) et que leur stratégie de trading est la même, il s'agit d'acheter et de conserver pendant une tendance haussière et de vendre lors de l'inversion de la tendance, mais chacun d'eux se comporte différemment - l'investisseur A est discipliné mais l'investisseur B ne l'est pas. Regardez les chiffres ci-dessous :
Ainsi, selon les chiffres précédents, il est évident que la discipline est essentielle pour un bon résultat, mais le manque de discipline conduira à de mauvais résultats.
Et à travers cet article, je partagerai avec vous un système de trading simple, un croisement de moyennes mobiles simples pour apprendre à concevoir le vôtre en partageant certaines des bases du codage MQL5 avec des exemples pour pratiquer ces bases et les comprendre en profondeur. Le but est de vous donner un aperçu de ce que vous pouvez faire en utilisant ce magnifique outil.
L'objectif principal de cet article est de guider les débutants pour apprendre à concevoir leur système de trading algorithmique en MQL5, en apprenant certaines des bases de MQL5 pour une idée de système de trading simple qui sera codée étape par étape. Nous les coderons par des scripts puis nous présenterons le résultat après exécution du code. Pour améliorer votre compréhension, je vous conseille d'appliquer et de coder vous-même ce que vous lirez ici, car cela vous aidera à comprendre en profondeur les concepts des codes mentionnés. Et notez que tous les codes, programmes et stratégies de trading créés dans cet article sont conçus à des fins éducatives uniquement, et non pour autre chose. Et notez que nous utiliserons MQL5 pour écrire du code.
Ce dont nous avons besoin pour concevoir notre trading algorithmique
Dans cette partie, je vais mentionner ce que nous devons avoir comme outils et ce que nous voulons savoir dessus :
- La plateforme MetaTrader 5, alias Terminal MetaTrader 5. Pour exécuter des ordres et tester nos codes via le terminal. Et MetaTrader est la plateforme de trading la plus populaire.
Un compte de démo. Vous pouvez ouvrir un compte démo auprès de votre courtier pour avoir de l'argent virtuel afin de tester vos stratégies de trading sans risque mais dans le même environnement de marché. Assurez-vous d'utiliser ce compte de démonstration et non votre compte réel pour le codage, car vous devrez créer et exécuter des programmes qui effectueront des transactions sur votre compte.
MetaQuotes Language Editor, où nous écrirons nos codes ou programmes. Les captures d'écran suivantes montreront comment l'ouvrir tel qu'il est installé avec MetaTrader. Il y a trois façons de l'ouvrir.
- Cliquez sur le menu Outils puis Éditeur de langage MetaQuotes :
Ou cliquez sur l'icône de l'éditeur MetaQuotes :
Ou appuyez sur le bouton F4 du clavier dans le terminal ouvert.
La capture d'écran suivante montre à quoi cela ressemble, et voici l'essentiel de notre travail pour écrire nos programmes et concevoir nos systèmes de trading.
Nous devons maintenant utiliser cet éditeur pour écrire notre premier code, alors suivez les étapes suivantes pour savoir comment procéder.
Cliquez sur Nouveau, puis vous trouverez plus d'un type de programmes parmi lesquels choisir :
Ce que nous devons mentionner ici dans cet article sont : Expert Advisor, Indicateur Personnalisé et Script.
- Expert Advisor : l'EA est un programme dans le terminal qui est développé et utilisé pour l'automatisation des processus d'analyse et de trading en fonction des paramètres que vous avez définis.
- Indicateur personnalisé : est un programme codé ; il est essentiellement destiné à l'affichage graphique des dépendances préalablement calculées.
- Script : est un programme destiné à une seule exécution de n'importe quelle action, il peut remplir à la fois des fonctions d'analyse et de trading, et contrairement aux Expert Advisors, il est exécuté sur demande, pas par ticks.
Le programme Hello World !
Dans cette partie, nous allons apprendre à écrire notre premier programme et notre premier code en MQL5. Tous les débutants en programmation ou en codage commencent leur voyage en codant le code "Hello World". Nous allons donc commencer par écrire un programme qui imprime sur l'écran du terminal "Hello World". Faisons le…
Ouvrez le MetaEditor comme indiqué ci-dessus, puis cliquez sur nouveau, puis sélectionnez parmi les options (Script), puis cliquez sur suivant.
Après avoir cliqué sur suivant, la fenêtre suivante apparaîtra. Remplissez les données du script que vous voulez :
- Nom est le nom du script
- Auteur est le créateur du script
- Lien est votre lien
- Paramètre est les paramètres que vous devez définir pour le script, mais nous ne définirons aucun paramètre pour ce script, nous allons donc l'ignorer.
Après avoir cliqué sur Terminer, la fenêtre suivante s'ouvrira. Et dans cette fenêtre, notre programme sera codé. Ici, comme je l'ai mentionné, nous devons concevoir un programme qui affiche "Hello World !" dans le terminal. Nous allons donc commencer à écrire notre code entre les deux accolades.
Ici nous utiliserons :
- Alert : imprime ce que je détermine ou affiche un message prédéterminé dans le programme qui est ici dans notre exemple "Hello World !"
- ( “ ”) : pour écrire le message prédéterminé "Hello World !" ou quoi que ce soit d'autre.
- ; - pour séparer les lignes.
Notre code sera le même que :
//+----------------------------------------------------------+ //| Hello World!.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+----------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" //+----------------------------------------------------------+ //| Script program start function | //+----------------------------------------------------------+ void OnStart() { Alert("Hello World!"); } //+----------------------------------------------------------+
Après avoir écrit notre code, cliquez sur Compiler, puis assurez-vous qu'il n'y a pas d'erreurs et d'avertissements. L'onglet Erreurs doit être sans erreur après la compilation de votre code pour vous assurer que votre programme fonctionnera de la même manière que ce que je mentionne dans l'image suivante. Rendez-vous ensuite dans le terminal en appuyant sur F4 pour tester notre code.
Idée de stratégie de trading (croisement de deux moyennes mobiles simples)
Dans cette partie, je vais présenter une idée de stratégie de trading à des fins éducatives uniquement. Elle vise à vous aider à apprendre les bases de MQL5 et à programmer en MQL5.
Avertissement
Toute information est fournie "telle quelle" uniquement à des fins d'information et n'est pas destinée à des fins de trading ou de conseil. Les performances passées ne préjugent pas des résultats futurs. Si vous choisissez d'utiliser ces documents sur des comptes de trading, vous le faites à vos propres risques.
Ici, l'idée de stratégie est d'essayer de trader avec la tendance en utilisant une confirmation du signal de deux moyennes mobiles simples :
- La moyenne mobile simple est un indicateur technique retardé qui calcule le prix de clôture moyen d'une période spécifique, et c'est en retard car son signal vient après le signal de l'action des prix.
- La Stratégie est la suivante :
- Si une moyenne mobile simple plus courte (sa période est de 20) croise la moyenne mobile simple plus longue (sa période est de 50) pour être au-dessus, alors le signal est Achat.
- Si une moyenne mobile simple plus courte (sa période est de 20) croise la moyenne mobile simple plus longue (sa période est de 50) pour être en dessous, le signal est Vendre.
Ici, nous devons concevoir un programme pour le faire.
Schéma directeur du système de trading algorithmique
Dans cette partie, je vais parler d'une étape très importante que vous devez faire si vous voulez coder votre système facilement et en douceur. Cette étape consiste à créer un plan pour votre stratégie et votre idée de trading sous la forme d'une séquence d'étapes de ce que vous voulez que votre système fasse exactement, et vous pouvez le faire à travers un diagramme par exemple qui vous donnera un plan clair. Et voici un exemple pour notre modèle de système (Two Simple Moving Average Crossover) pour voir de manière claire ce que nous devons coder et ce que nous attendons de ce système.
Maintenant, commençons par comprendre certaines des bases de MQL5, puis utilisons ce dont nous avons besoin pour concevoir.
Variables et leurs types et comment nous pouvons les utiliser
Dans cette partie, nous allons identifier et comprendre :
- Qu'est-ce qu'une variable ?
- Types de variables.
- Comment pouvons-nous les utiliser ?
De manière générale, dans un programme, une valeur de donnée peut être constante ou variable. Si les valeurs sont variables, elles peuvent être modifiées par le programme et l'utilisateur. Une variable est un emplacement mémoire. Il a un nom qui est associé à cet emplacement. Ainsi, l'emplacement de mémoire est utilisé pour stocker des données. Un programme en MQL5 peut contenir des dizaines et des centaines de variables. Une propriété très importante de chaque variable est la possibilité d'utiliser sa valeur dans un programme. La limitation de cette possibilité est liée à la portée de la variable qui est un emplacement dans un programme où la valeur de la variable est disponible. Chaque variable a sa portée.
Ainsi, selon la portée, il existe deux types de variables dans MQL5, locales et globales. Une variable locale est une variable déclarée dans une fonction. La portée des variables locales est le corps de la fonction, dans lequel la variable est déclarée. Une variable locale peut être initialisée par une constante ou une expression correspondant à son type. Les variables globales sont déclarées au-delà de toutes les fonctions. La portée des variables globales est l'ensemble du programme. Une variable globale ne peut être initialisée que par une constante correspondant à son type (et non expression). Les variables globales ne sont initialisées qu'une seule fois avant de déclarer l'exécution de fonctions spéciales.
Quelle que soit la portée des variables, nous allons maintenant examiner les types de variables suivants :
- int est un type numérique ; il existe différents types d'entiers pour stocker des valeurs numériques de différentes longueurs.
- double. Construire un programme qui gérera les nombres utilisés dans le trading nécessite un type de données capable de gérer les nombres à virgule flottante. MetaTrader propose donc les types de données suivants pour traiter ces données : float et double. La différence entre eux est le nombre d'octets alloués en mémoire, 4 pour float et 8 pour double, ce qui donne les valeurs minimales et maximales suivantes :
- float - minimum 1.175494351e-38, maximum 3.402823466e+38
- double - minimum 2,2250738585072014e-308, maximum 1,7976931348623158e+308
Pour déclarer ces types de données, utilisez des mots-clés float et double. - string est un type de données très important, qui est également largement utilisé dans le codage MQL5. String permet de stocker et de manipuler n'importe quelle séquence alphanumérique de caractères.
- bool – Boolean est un type logique qui peut prendre la valeur true ou false.
Prenons un exemple d'utilisation de variable :
//+------------------------------------------------------------------+ //| Variables.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" //+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ void OnStart() { int myInteger = 5; double myDouble = 10.56; string myString = "My name is Mohamed"; bool myBoolean = true; Alert(myInteger); Alert(myDouble); Alert(myString); Alert(myBoolean); } //+------------------------------------------------------------------+
Après avoir compilé le code précédent si vous écrivez comme ce que je mentionne ci-dessus, vous ne trouverez aucune erreur ni avertissement et vous devez voir la fenêtre d'alerte comme ci-dessous.
Un autre exemple d'utilisation de variables.
- La valeur équivalente de message1
- La valeur équivalente de C
- La valeur équivalente du result
- La valeur équivalente de message2
//+------------------------------------------------------------------+ //| Variables 2.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" //+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ void OnStart() { int A = 10; int B = 5; int C; double var1 = 2.5; double var2 = 4; double result = var1 / var2; string greeting = "Hello"; string space = " "; string name = "Mohamed"; string message1; string message2; C = A + B; message1 = greeting + space + name; message2 = "Value of A is: " + string(A); Alert(message1); Alert(C); Alert(result); Alert(message2); } //+------------------------------------------------------------------+
Opérations booléennes
Booléen : il renvoie simplement vrai ou faux pour une opération logique.
- == signifie égal
- != signifie différent
- < signifie inférieur à
- <= signifie inférieur ou égal
- > signifie supérieur à
- >= signifie supérieur ou égal
//+------------------------------------------------------------------+ //| Boolean Operations.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" //+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ void OnStart() { bool result = 4 < 5; Alert (result); //true } //+------------------------------------------------------------------+
Ici, il doit renvoyer vrai au message d'alerte comme 4 < 5.
La boucle While
L'opérateur while se compose d'une expression vérifiée et de l'opérateur, qui doit être rempli. Si l'expression est vraie, l'opérateur est exécuté jusqu'à ce que l'expression devienne fausse. Dans l'exemple suivant, on peut comprendre qu'en alertant d'abord au début pour connaître le début et la fin de la boucle puis le programme va vérifier la valeur du compteur et afficher sa valeur si elle est inférieure à 3. Ensuite, il ajoutera un au résultat précédent jusqu'à ce qu'il devienne faux dans ce cas = ou > 3, puis donnera la dernière alerte lorsque la boucle sera terminée. Ainsi, nous verrons les messages suivants de ce code dans le message d'alerte : Début du script, 1, 2, La boucle est terminée.//+------------------------------------------------------------------+ //| While Loop.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" //+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ void OnStart() { //While (Loop) Alert("Start of script"); int counter = 1; while(counter < 3) //true? { Alert(counter); counter = counter + 1; } Alert("Loop has finished"); }
La boucle For
L'opérateur for se compose de trois expressions et d'un opérateur exécutable :
for(expression1; expression2; expression3)
operator;
Expression1 décrit l'initialisation de la boucle. Expression2 vérifie les conditions de la terminaison de boucle. Si c'est vrai, le corps de la boucle pour est exécuté. La boucle répète expression2 jusqu'à ce qu'elle devienne fausse. Si elle est fausse, la boucle est terminée et le contrôle est donné à l'opérateur suivant. L'expression3 est calculée après chaque itération.
Donc, selon l'exemple de boucle for suivant, on peut s'attendre à ce que l'exécution du code entraîne cinq messages de Hello, (I =0, I = 2, …………,I = 4), puis l = 5, donc la boucle sera terminée.
//+------------------------------------------------------------------+ //| For Loop.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" //+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ void OnStart() { for(int i=0; i<5 ; i++) { Alert("Hello"); } } //+------------------------------------------------------------------+
L'instruction If, Else
L'opérateur IF - ELSE est utilisé lorsqu'un choix doit être fait. Formellement, la syntaxe est la suivante :
if (expression)
operator1
else
operator2
Si l'expression est vraie, l'opérateur1 est exécuté et le contrôle est donné à l'opérateur qui suit l'opérateur2 (l'opérateur2 n'est pas exécuté). Si l'expression est fausse, operator2 est exécuté.
Exemple : selon l'exemple suivant, nous devons d'abord recevoir une alerte avec la valeur de l'offre, puis nous déterminons si la valeur de l'offre > 1,146600, puis nous serons alertés avec "Le prix est supérieur à 1,146600 -> ACHETER". Si ce n'est pas le cas, nous serons alertés par "Le prix est inférieur à 1,146600 -> VENDRE". Et voici le code et son résultat d'exécution.
//+------------------------------------------------------------------+ //| If-else statement.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" //+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ void OnStart() { double level = 1.146600; double Bid = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_BID),_Digits); Alert("Bid Price = " + string(Bid)); if(Bid > level) { Alert ("The price is above " + string(level) + " -> BUY"); } // Que se passe-t-il si la condition est fausse et que nous devons prendre une action également ici, nous pouvons utiliser la fonction else au lieu d'écrire un autre code if else { Alert ("The price is below " + string(level) + " -> SELL"); } } //+------------------------------------------------------------------+
Paramètres des traders
Dans cette partie, nous apprendrons comment déterminer nos entrées ou paramètres préférés pour le programme au lieu d'ajuster le code.
Propriétés (#property) : Chaque programme MQL5 permet de spécifier des paramètres spécifiques supplémentaires nommés #property qui aident le terminal client à gérer correctement les programmes sans qu'il soit nécessaire de les lancer explicitement.
script_show_inputs : affichez une fenêtre avec les propriétés avant d'exécuter le script et désactivez cette fenêtre de confirmation
Variables d'entrée : La classe de stockage input définit la variable externe. Le modificateur input est indiqué avant le type de données.
//+------------------------------------------------------------------+ //| Trader Inputs.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" #property script_show_inputs //+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ input int TakeProfit = 10; input int StopLoss = 10; void OnStart() { double Bid = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_BID),_Digits); double TakeProfitLevel = Bid + TakeProfit * 0.00001; // 0.00001 (5 digits broker, so multiplied by 10) double StopLossLevel = Bid - StopLoss * 0.00001; Alert("Price now = " + string(Bid)); Alert ("TakeProfitLevel = ", TakeProfitLevel); Alert ("StopLossLevel = ", StopLossLevel); } //+------------------------------------------------------------------+
Ordres d'ouverture
Dans cette partie, je vais vous présenter comment écrire votre code pour ouvrir un ordre :
//+------------------------------------------------------------------+ //| TEST.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" #property script_show_inputs #include <Trade\Trade.mqh> CTrade trade; //+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ input int TakeProfit = 150; input int StopLoss = 100; void OnStart() { double Ask = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_ASK),_Digits); double Bid = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_BID),_Digits); double Balance = AccountInfoDouble(ACCOUNT_BALANCE); double Equity = AccountInfoDouble(ACCOUNT_EQUITY); double TakeProfitLevel = (Ask+TakeProfit*0.00001); double StopLossLevel = (Ask-StopLoss*0.00001); if(Equity >= Balance) trade.Buy(0.01,NULL,Ask,StopLossLevel,TakeProfitLevel,NULL); for (int i=PositionsTotal()-1; i>=0; i--) { ulong ticket = PositionGetTicket(i); ENUM_POSITION_TYPE position = ENUM_POSITION_TYPE(PositionGetInteger(POSITION_TYPE)); Alert (" Order Ticket # ", ticket); Alert("TakeProfit = ", TakeProfitLevel); Alert("StopLoss = ", StopLossLevel); } } //+------------------------------------------------------------------+
Technique de gestion des erreurs
Lorsque le programme s'exécute, n'importe qui peut trouver des plantages et quelque chose s'est mal passé. Nous devons donc inclure cette technique dans notre code pour vérifier chaque ordre ou code exécuté et avertir en cas de problème. En d'autres termes, il s'agit d'une technique de protection du trader pour le protéger lui et ses fonds de toute situation inappropriée.
//+------------------------------------------------------------------+ //| TEST.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" #property script_show_inputs #include <Trade\Trade.mqh> CTrade trade; //+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ input int TakeProfit = 150; input int StopLoss = 100; void OnStart() { double Ask = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_ASK),_Digits); double Bid = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_BID),_Digits); double Balance = AccountInfoDouble(ACCOUNT_BALANCE); double Equity = AccountInfoDouble(ACCOUNT_EQUITY); double TakeProfitLevel = (Ask+TakeProfit*0.00001); double StopLossLevel = (Ask-StopLoss*0.00001); if(Equity >= Balance) trade.Buy(0.01,NULL,Ask,StopLossLevel,TakeProfitLevel,NULL); for (int i=PositionsTotal()-1; i>=0; i--) { ulong ticket = PositionGetTicket(i); ENUM_POSITION_TYPE position = ENUM_POSITION_TYPE(PositionGetInteger(POSITION_TYPE)); if (ticket <= 0) { Alert("Error!"); //in Case of error and the order did not open, appears "Error!" } else { Alert("Your ticket # is: " + string(ticket)); Alert("TakeProfit = ", TakeProfitLevel); Alert("StopLoss = ", StopLossLevel); } } } //+------------------------------------------------------------------+
Ordres de clôture
Dans cette partie, nous allons créer du code pour ouvrir et fermer un ordre afin d'apprendre à fermer un ordre.//+------------------------------------------------------------------+ //| TEST.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" #property script_show_inputs #include <Trade\Trade.mqh> CTrade trade; //+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ input int TakeProfit = 150; input int StopLoss = 100; void OnStart() { double Ask = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_ASK),_Digits); double Bid = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_BID),_Digits); double Balance = AccountInfoDouble(ACCOUNT_BALANCE); double Equity = AccountInfoDouble(ACCOUNT_EQUITY); double TakeProfitLevel = (Ask+TakeProfit*0.00001); double StopLossLevel = (Ask-StopLoss*0.00001); trade.Buy(0.01,NULL,Ask,StopLossLevel,TakeProfitLevel,NULL); for (int i=PositionsTotal()-1; i>=0; i--) { ulong ticket = PositionGetTicket(i); ENUM_POSITION_TYPE position = ENUM_POSITION_TYPE(PositionGetInteger(POSITION_TYPE)); Alert (" Order Ticket # ", ticket); Alert("TakeProfit = ", TakeProfitLevel); Alert("StopLoss = ", StopLossLevel); Sleep(2000); trade.PositionClose(ticket,-1); Alert("Order Closed..."); } } //+------------------------------------------------------------------+
Modifier des ordres avec OrderModify
Dans cette partie, nous allons apprendre à créer du code qui aide à modifier l'ordre. Il modifiera les caractéristiques des ordres précédemment ouverts ou en attente.
//+------------------------------------------------------------------+ //| TEST.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" #property script_show_inputs #include <Trade\Trade.mqh> CTrade trade; //+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ input int TakeProfit = 150; input int StopLoss = 100; void OnStart() { double Ask = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_ASK),_Digits); double Bid = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_BID),_Digits); double Balance = AccountInfoDouble(ACCOUNT_BALANCE); double Equity = AccountInfoDouble(ACCOUNT_EQUITY); double TakeProfitLevel = (Ask+TakeProfit*0.00001); double StopLossLevel = (Ask-StopLoss*0.00001); double TakeProfitLevel2 = (TakeProfitLevel+0.00100); double StopLossLevel2 = (StopLossLevel-0.00050); trade.Buy(0.01,NULL,Ask,StopLossLevel,TakeProfitLevel,NULL); for (int i=PositionsTotal()-1; i>=0; i--) { ulong ticket = PositionGetTicket(i); ENUM_POSITION_TYPE position = ENUM_POSITION_TYPE(PositionGetInteger(POSITION_TYPE)); Alert (" Order Ticket # ", ticket); Alert("TakeProfit = ", TakeProfitLevel); Alert("StopLoss = ", StopLossLevel); Sleep(5000); trade.PositionModify(ticket,StopLossLevel2,TakeProfitLevel2); Alert("Order Modified..."); Alert("Modified TakeProfit = ", TakeProfitLevel2); Alert("Modified StopLoss = ", StopLossLevel2); } } //+------------------------------------------------------------------+
Le système de croisement de deux moyennes mobiles simples
Dans cette partie, nous allons tout mettre ensemble pour coder le croisement de deux moyennes mobiles simples. Nous ferons tout ce qui est nécessaire selon le plan mentionné ci-dessus.
Ici, nous choisirons un Expert Advisor lors du démarrage d'un nouveau projet en cliquant sur nouveau dans MetaEditor.
Pour vous souvenir de tout, voici notre schéma directeur détaillé du système de trading :
- Si la moyenne mobile simple la plus courte (sa période est de 20) croise la moyenne mobile simple la plus longue (sa période est de 50) pour être au-dessus, le le signal est Acheter.
- Si la moyenne mobile simple la plus courte (sa période est de 20) croise la moyenne mobile simple la plus longue (sa période est de 50) pour être en dessous, le signal est de vente.
//+------------------------------------------------------------------+ //| SMA crossover.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { // crée un tableau pour plusieurs prix double myMovingAverageArray1[], myMovingAverageArray2[]; // définit les propriétés des MA - simple MA, 1ere 20 / 2eme 50 int movingAverage1 = iMA(_Symbol, _Period, 20, 0, MODE_SMA, PRICE_CLOSE); int movingAverage2 = iMA(_Symbol,_Period,50,0,MODE_SMA,PRICE_CLOSE); // trie les tableaux de prix 1, 2 à partir de la bougie actuelle ArraySetAsSeries(myMovingAverageArray1,true); ArraySetAsSeries(myMovingAverageArray2,true); // Définit MA1, MA2 - une ligne - bougie actuelle, 3 bougies - stocke le résultat CopyBuffer(movingAverage1,0,0,3,myMovingAverageArray1); CopyBuffer(movingAverage2,0,0,3,myMovingAverageArray2); // Vérifie si nous avons un signal d'entrée d'achat if ( (myMovingAverageArray1[0]>myMovingAverageArray2[0]) && (myMovingAverageArray1[1]<myMovingAverageArray2[1]) ) { Comment("BUY"); } // Vérifie si nous avons un signal d'entrée de vente if ( (myMovingAverageArray1[0]<myMovingAverageArray2[0]) && (myMovingAverageArray1[1]>myMovingAverageArray2[1]) ) { Comment("SELL"); } } //+------------------------------------------------------------------+
Après l'exécution du programme, il affichera des commentaires sur le graphique avec le signal actuel (achat ou vente) selon cette stratégie. Ceci est montré dans l'image suivante :
Activez l'option "Autoriser le trading Algo", puis cliquez sur OK. Après cela, l'Expert Advisor sera attaché au graphique et un message apparaîtra dans l'onglet Journal lorsqu'il sera chargé avec succès :
Nous avons donc créé et exécuté notre programme d'automatisation Two Simple Moving Averages Crossover. Et ce que je veux mentionner ici, c'est qu'il s'agit d'un exemple simple de ce que nous pouvons coder pour notre trading. Cependant, nous pouvons coder et automatiser toute autre stratégie de trading à l'aide de ce magnifique outil MQL5.
Encore une fois, l'objectif principal de cet article n'est pas d'utiliser cette stratégie mais l'objectif principal est d'apprendre certaines des bases de MQL5 et d'apprendre ce que nous pouvons créer pour imaginer ce que nous pouvons faire et rendre notre trading plus facile et rentable. Donc, cette stratégie a besoin de beaucoup d'améliorations et si vous l'utilisez, ce sera votre seule responsabilité.
Conclusion
MQL5 est un bon et magnifique outil pour nous aider à rendre notre trading plus facile et rentable en concevant de bons et rentables systèmes de trading algorithmique. Ainsi, votre investissement dans l'apprentissage et l'utilisation de ce magnifique outil sera un investissement très rentable.