Programmer un robot Forex : créez votre robot de trading

Quels types de programmes peut-on développer en MQL4 et MQL5 ?

Les explications présentées ici s'appuient sur les langages de programmation MQL4 et MQL5. Il existe trois grandes catégories de programmes que l'on peut concevoir dans ces environnements :

• Les Expert Advisors (robots Forex)
• Les indicateurs personnalisés
• Les scripts

1. L'Expert Advisor (EA)

Il correspond à l'automatisation d'un système de trading manuel rattaché au graphique d'un actif financier donné. En d'autres termes, tout code rédigé pour un EA doit être pensé en fonction des spécificités du graphique de l'actif concerné.

Certains de ces événements ne s'exécutent qu'une seule fois, tandis que d'autres tournent en boucle jusqu'à réception d'un ordre d'arrêt. Un EA commence à fonctionner dès que la séquence d'initialisation (code init) est déclenchée.

Ces événements incluent l'apparition d'un nouveau tick ou niveau de prix, un changement sur le graphique ou des événements personnalisés. Dès qu'ils se produisent, l'EA transmet un ordre au serveur du broker afin d'ouvrir ou de clôturer une position. Les fichiers des EA sont stockés dans le dossier MQL4/Experts du terminal MT4.

2. Le script

Il s'agit d'un programme conçu pour exécuter ponctuellement une tâche unique, comme l'événement Start. Les fichiers de scripts sont stockés dans le dossier MQL4/scripts du terminal MT4.

3. L'indicateur personnalisé

Il s'agit d'un indicateur technique sur mesure qui ne fait pas partie des outils intégrés par défaut dans MT4. Les indicateurs personnalisés ne passent pas d'ordres directement ; ils servent à repérer des configurations graphiques précises qui déclencheront ensuite une prise de position manuelle ou automatique par un EA. Les fichiers correspondants sont enregistrés dans le répertoire MQL4/indicators du terminal MT4.

Comment créer un robot Forex avec MQL4 ou MQL5

Le code source d'un robot de trading Forex, d'un indicateur ou d'un script en MQL4/MQL5 repose sur quatre éléments fondamentaux : la syntaxe, les variables, les expressions et les structures conditionnelles. Voyons comment les articuler pour concevoir votre robot :

Dans la suite de cet article, nous ferons principalement référence à MQL4, mais les concepts présentés s'appliquent tout aussi bien à MQL5.

1. Se familiariser avec la syntaxe

La syntaxe de programmation désigne l'ensemble des règles régissant la rédaction et la structure du code au sein d'un langage donné.

Pour compiler et exécuter correctement le programme d'un robot Forex, le développeur doit écrire un code rigoureux, sans erreur et conforme aux exigences du langage utilisé pour développer l'Expert Advisor, le script ou l'indicateur.

Voici les principales composantes de la syntaxe MQL4 :

• Commentaires : lignes de texte ignorées par le compilateur. Elles permettent aux programmeurs d'expliquer le fonctionnement du code afin de faciliter sa relecture. Les commentaires multilignes sont encadrés par /* et */, tandis que les commentaires sur une seule ligne débutent par //.
• Variables : emplacements nommés dans la mémoire de l'ordinateur servant à stocker des données. La valeur d'une variable peut changer au fil de l'exécution du programme.
• Types de données : catégories déterminant la nature des données qu'une variable peut contenir. On retrouve notamment int (nombres entiers), double (nombres à virgule flottante pour les prix), bool (valeurs booléennes vrai/faux), string (chaînes de texte), datetime (date et heure) et color (couleurs d'affichage).
• Identificateurs : noms attribués aux différents éléments du programme (variables, fonctions, classes ou modules). Ils doivent commencer par une lettre ou un trait de soulignement (_), peuvent contenir des lettres, des chiffres et des traits de soulignement, et ne doivent pas dépasser 63 caractères. Il ne peut pas s'agir de mots réservés du langage MQL4.
• Opérateurs : symboles effectuant des opérations sur une ou plusieurs opérandes (valeurs ou variables). Ils servent aux opérations arithmétiques, de comparaison, logiques ou d'affectation. Exemples : +, -, =, !=, || et &&.
• Structures conditionnelles : instructions orientant le déroulement du programme en exécutant différents blocs de code selon qu'une condition est vraie ou fausse (instructions « if », « else if » et « else »).
• Boucles : structures de contrôle permettant de répéter un bloc d'instructions tant qu'une condition donnée reste vérifiée. Elles sont indispensables pour parcourir des séries de données ou réaliser des tâches répétitives. Les structures courantes sont « for », « while » et « do-while ».
• Fonctions : blocs de code autonomes exécutant une tâche précise. Elles permettent de structurer le programme en modules plus courts, améliorant la lisibilité et évitant les répétitions.

L'environnement de développement MQL4 offre tous les outils syntaxiques nécessaires pour concevoir des robots de trading et des indicateurs Forex complets et robustes.

2. Déclarer et initialiser ses variables

Les variables constituent la base de tout programme. Avant de pouvoir utiliser une variable, vous devez obligatoirement la créer : cette étape s'appelle la déclaration. Déclarer une variable revient à indiquer au compilateur de lui allouer un espace mémoire en lui attribuant un type de données précis.

Pour déclarer une variable :

• indiquez le type de données, suivi d'un espace ;
• saisissez le nom de la variable ;
• terminez la ligne par un point-virgule (;).

Voici comment déclarer une variable de type entier (int) :

• Le type de données est int (entier).
• Le nom de la variable est hi.
• L'instruction se termine par un point-virgule.

Les variables sont définies par leur type de données (comme int pour un entier ou double pour un nombre décimal), suivi de leur identificateur. Parmi les types de données les plus courants, citons :

1. Integer (int) : représente un nombre entier compris entre -2 milliards et +2 milliards. Le type int ne prend pas en charge les décimales.
2. Double : représente les nombres à virgule flottante compris entre -1,79 × 10³⁰⁸ et +1,79 × 10³⁰⁸. C'est le type utilisé pour stocker les cours financiers.
3. Boolean (bool) : représente un état logique : vrai (true) ou faux (false).
4. Color : stocke une information de couleur pour l'affichage graphique.
5. String : représente une chaîne de texte.
6. DateTime : enregistre une date et une heure.

Imaginons trois variables x, y et z contenant respectivement les entiers 10, 7 et 5. Vous pouvez définir une nouvelle variable a telle que a = y + z. Les valeurs de y et z étant définies, a vaudra automatiquement 12.

Pour déclarer une variable entière appelée « myVar », on utilise la syntaxe suivante :

int myVar

Il est également possible d'assigner une valeur à une variable dès sa déclaration (initialisation). Si nous voulons lui attribuer la valeur 10, la syntaxe sera la suivante :

int myVar = 10;

Une fois déclarée, la variable peut être exploitée dans le code MQL pour stocker des données ou exécuter des calculs. Pour reprendre l'exemple de l'addition de deux variables, voici comment formuler le code :

int var1 = 10;
int var2 = 7;
Int var3 = 5

int result = var2 + var3; // result = 12

Dans cet exemple, trois variables entières nommées var1, var2 et var3 sont initialisées avec les valeurs 10, 7 et 5. Pour additionner var2 et var3, nous utilisons l'opérateur + et stockons le résultat dans une nouvelle variable appelée result. Sa valeur sera de 12.

Dans le cadre du trading algorithmique, déclarer des variables sert principalement à conserver des valeurs qui évoluent constamment, telles que le cours d'un actif. Les cotations monétaires changeant à chaque instant, une variable permet de stocker et d'actualiser le cours à chaque nouveau tick :

double price;

price = SymbolInfoDouble(_Symbol, SYMBOL_BID); // get the current bid price

ol, SYMBOL_BID); // get the current bid price

Sur un marché aussi dynamique que le Forex, l'utilisation de variables au sein de votre stratégie de trading automatisée est indispensable pour s'adapter en temps réel aux fluctuations des cours.

3. Les expressions

Les opérations courantes s'appuient sur des calculs arithmétiques élémentaires (addition, soustraction, multiplication, division). Ces calculs sont exécutés à l'aide d'opérateurs. Combinés à des variables au sein d'une même ligne d'instruction, ils constituent des expressions.

Voici les principaux opérateurs utilisés en MQL4 :

a) Opérateurs arithmétiques : addition, soustraction, modulo, division, multiplication (+ – % / *)

b) Opérateurs logiques : && ||

c) Opérateurs d'affectation : égal, affectation après addition, affectation après multiplication (= += *=)

Toute expression se terminant par un point-virgule (;) forme une instruction. Voyons comment les opérateurs arithmétiques fonctionnent en pratique.

Les opérateurs arithmétiques effectuent des calculs sur des valeurs numériques :

L'opérateur ++ incrémente la valeur de b de 1 à la ligne 27 : si b vaut 70, l'expression b++ lui attribuera la valeur 71. De même, l'opérateur – – décrémente la valeur de b de 1 à la ligne 28, assignant la valeur 69 lorsque b– – est exécuté.

Voici un autre exemple d'expression utilisant des fonctions mathématiques :

La directive « #include <math.mqh> » charge la bibliothèque de fonctions mathématiques standard afin d'éviter toute erreur lors de la compilation. On y retrouve par exemple les fonctions MathPow() et MathSqrt().

Voici le rôle de chaque opérateur arithmétique :

• Addition (+) : additionne les valeurs situées de part et d'autre de l'opérateur.
• Soustraction (-) : soustrait la valeur de droite de la valeur de gauche.
• Multiplication (*) : multiplie les deux valeurs.
• Division (/) : divise la valeur de gauche par celle de droite.
• Modulo (%) : renvoie le reste de la division entière de la valeur de gauche par celle de droite.

Voici leur intégration dans l'environnement MQL4 :

Puisque 10 est divisible par 5 sans reste, l'expression 10 % 5 renvoie 0 à la ligne 23.

Les opérateurs d'affectation attribuent une valeur à une variable (= += -= *=) :

• Affectation simple (=) : assigne la valeur située à droite à la variable située à gauche.
• Affectation après addition (+=) : ajoute la valeur de droite à la variable de gauche et enregistre le résultat dans cette dernière.
• Affectation après soustraction (-=) : soustrait la valeur de droite de la variable de gauche et enregistre le résultat dans cette dernière.
• Affectation après multiplication (*=) : multiplie la variable de gauche par la valeur de droite et enregistre le résultat dans la variable de gauche.
• Affectation après division (/=) : divise la variable de gauche par la valeur de droite et enregistre le résultat dans la variable de gauche.
• Affectation après modulo (%=) : calcule le modulo entre la variable de gauche et la valeur de droite, puis enregistre le reste dans la variable de gauche.

Exemples d'utilisation des opérateurs d'affectation en MQL4 :

4. Les structures conditionnelles (if/else, switch)

Les structures conditionnelles permettent d'exécuter des blocs de code spécifiques uniquement lorsque certains critères sont remplis. Elles permettent donc de déclencher une action si une condition préalable s'avère vraie.

Dans MT4, les instructions conditionnelles les plus utilisées sont « if-else » et « switch ». Toutes deux permettent d'orienter le flux d'exécution en fonction de scénarios précis.

L'instruction if-else

L'instruction « if-else » s'utilise généralement lorsque plusieurs conditions doivent être testées successivement :

Si ce script est compilé et exécuté, il affichera la valeur 10 dans le journal car la condition est vraie. Lorsque le bloc d'instructions contient plusieurs lignes, on l'encadre d'accolades { }.

En trading, l'instruction if-else sert très souvent à réagir aux variations de cours.

Voici un exemple concret d'utilisation : la variable « price » récupère le cours acheteur (Ask) par défaut. Le bloc « if » vérifie si le cours est supérieur à 1.0. Si oui, seul le code situé entre les premières accolades est exécuté. Sinon, d'autres tests sont effectués (« else if » puis « else ») :

//+--------------------------------------------------------+
//| Script program start function                          |
//+--------------------------------------------------------+
void OnStart(){
    double price = Bid;
    if (price > 1.0) {
        // Execute this code if price is greater than 1.0
        Alert("Price is above 1.0");
    }else if (price < 0.5) {
        // Execute this code if price is less than 0.5
        Alert("Price is below 0.5");
    }else {
        // Execute this code if price is between 0.5 and 1.0
        Alert("Price is between 0.5 and 1.0");
    }
}

Il est également possible d'imbriquer une structure « if-else » à l'intérieur d'un bloc if ou else existant. On parle alors de conditions imbriquées :

Cette condition imbriquée vérifie si le prix est inférieur à 0,8 ou s'il se situe entre 0,8 et l'objectif fixé. Si le cours est sous 0,8, le code du if interne s'exécute ; dans le cas contraire, c'est la branche else interne qui prend le relais.

Les conditions s'avèrent indispensables pour gérer les ordres différés et les ordres de sortie : ordres Buy Limit/Sell Limit, Buy Stop/Sell Stop, ainsi que les niveaux de Take Profit et de Stop Loss. Ces ordres ne s'exécutent en effet que si le marché atteint un niveau de cours défini à l'avance. Voici comment formuler ces ordres conditionnels en MQL4 :

Buy Stop

Pour placer un ordre Buy Stop à un niveau spécifique, on utilise le code ci-dessous. Le programme demande au robot de trading Forex d'accomplir les tâches suivantes :

– placer un ordre BUY STOP à une distance de 10 pips au-dessus du cours actuel, avec une limite à 20 pips ;

– appliquer un volume d'un lot standard (1.0 lot) ;

– afficher une ligne verte sur le graphique au niveau du prix d'entrée pour un suivi visuel direct ;

– attribuer un identifiant unique (MagicNumber) à cet ordre.

//+------------------------------------------------------------------+
//| Expert tick function                                           |
//+------------------------------------------------------------------+
void OnTick()
{
    //---
    double StopDistance = 10.0;     // Stop distance in pips
    double LimitDistance = 20.0;    // Limit distance in pips
    double Lots = 1.0;              // Lot size
    int Slippage = 3;               // Maximum price deviation
    int MagicNumber = 12345;        // Unique identifier
    color Green = Lime;             // Order line color

    // Get the current ask price
    double price = Ask;

    // Calculate the stop and limit prices
    double stopPrice = NormalizeDouble(price + StopDistance * Point, Digits);
    double limitPrice = NormalizeDouble(price + LimitDistance * Point, Digits);

    // Place the buy stop order
    int ticket = OrderSend(Symbol(), OP_BUYSTOP, Lots, stopPrice, Slippage, limitPrice, 0, "", MagicNumber, 0, Green);

    if(ticket > 0)
    {
        Print("Buy stop order placed successfully with ticket #", ticket);
    }
    else
    {
        Print("Error placing buy stop order. Error code:", GetLastError());
    }
}

Le code déclare les variables suivantes :

• StopDistance
• LimitDistance
• Lots
• Slippage
• MagicNumber
• Green

Une fois la requête transmise, le programme vérifie la bonne transmission de l'ordre en analysant la valeur de retour (ticket) de la fonction OrderSend(). Si l'ordre Buy Stop est accepté, un message de confirmation s'affiche dans l'onglet Journal de MT4. Dans le cas contraire, un code d'erreur détaillé est renvoyé.

Sell Limit

Pour positionner un ordre Sell Limit sur un niveau donné, le code suivant peut être utilisé :

// Define order parameters

double lotSize = 0.1;  // Lot size
double limitPrice = 1.2000;  // Limit price
double stopLoss = 1.2100;  // Stop loss
double takeProfit = 1.1900;  // Take profit
int slippage = 3;  // Maximum deviation in pips from the requested price

// Place sell limit order
bool sellLimitOrderPlaced = false;
int ticket = 0;

while (!sellLimitOrderPlaced) {    
      ticket = OrderSend(Symbol(), OP_SELLLIMIT, lotSize, limitPrice, slippage, stopLoss, takeProfit, "Sell Limit", MagicNumber, 0, Red);    
      if (ticket > 0) {        
         sellLimitOrderPlaced = true;    
      } else {
         Print("Sell limit order failed with error code ", GetLastError());
         Sleep(5000);  // Wait for 5 seconds before retrying
      }
}

// Check if the order is still open
while (OrderSelect(ticket, SELECT_BY_TICKET)){    
      if (OrderCloseTime() > 0) {
         // Order has been closed        
         break;   
      }    

      // Wait for 1 second before checking again    
      Sleep(1000);
}

Stop Loss

Voici comment paramétrer un Stop Loss via votre robot de trading Forex. La mise en place d'un Stop Loss peut se faire dès l'ouverture ou après exécution de l'ordre. Certains développeurs préfèrent attendre que l'ordre soit actif sur le marché pour ensuite modifier son niveau de protection.

Dans cet exemple, l'EA place d'abord un ordre différé, puis modifie son Stop Loss une fois l'ordre exécuté :

// Define order parameters
double lotSize = 0.1;  // Lot size
double limitPrice = 1.2000;  // Limit price
double stopLoss = 1.2100;  // Stop loss
double takeProfit = 1.1900;  // Take profit

// Place the pending order
int ticket = OrderSend(Symbol(), OP_SELLLIMIT, lotSize, limitPrice, 0, stopLoss, takeProfit, "Sell Limit", MagicNumber, 0, Red);
if (ticket <= 0) {
    Print("Failed to place pending order with error code ", GetLastError());
} else {
    Print("Pending order placed with ticket number ", ticket);
}

// Modify the stop loss for the pending order
if (OrderSelect(ticket, SELECT_BY_TICKET, MODE_TRADES)) {
    double newStopLoss = 1.2050;  // New stop loss value    
    if (!OrderModify(ticket, OrderOpenPrice(), newStopLoss, OrderTakeProfit(), 0, Green)) {
        Print("Failed to set stop loss for pending order with error code ", GetLastError());
    } else {
        Print("Stop loss set for pending order with ticket number ", ticket);
    }
} else {
    Print("Failed to select pending order with ticket number ", ticket, " with error code ", GetLastError());
}

Les paramètres du trade apparaissent clairement dans le code :

• taille de position : 1 mini-lot (0.1 lot) ;
• prix limite : 1.2000 ;
• Stop Loss : 1.2100 ;
• Take Profit : 1.1900.

Le programme prévoit également d'enregistrer les éventuels codes d'erreur dans le journal si la modification du Stop Loss échoue. L'ordre en attente est transmis via la fonction OrderSend en lui fournissant ces variables comme paramètres.

Dès que l'ordre est validé, le robot utilise la fonction OrderSelect (qui s'appuie sur le numéro de ticket) pour sélectionner l'ordre. Le paramètre MODE_TRADES indique au robot de cibler les ordres ouverts et en attente.

La fonction OrderModify permet ensuite de mettre à jour les paramètres de l'ordre en y intégrant la nouvelle valeur du Stop Loss.

Veillez à vérifier les conditions imposées par votre broker concernant la fréquence et la distance minimale de modification des ordres avant de définir ces variables.

Take Profit

Vous pouvez également choisir de définir votre ordre Take Profit séparément, plutôt que de l'inclure lors de la configuration initiale du Stop Loss. Voici comment structurer cette instruction :

void OnTick()  {

// Set take profit level
double takeProfit = 1.5; // Take profit level as a multiple of the trade's open price
double stopLoss = 1.0; // Stop loss level as a multiple of the trade's open price

// Place trade with take profit and stop loss levels
int ticket = OrderSend(Symbol(), OP_BUY, 1.0, Ask, 3, Bid - stopLoss * Point, Bid + takeProfit * Point, "My Order", MagicNumber, 0, Blue);
}

Cet exemple applique un ratio risque/rendement de 1:1,5 pour définir les niveaux de Stop Loss et de Take Profit. L'objectif de gain représente ainsi 1,5 fois la distance d'entrée. L'ordre est transmis par la fonction OrderSend après définition des variables stopLoss et takeProfit.

Switch

L'instruction « switch » est quant à elle privilégiée lorsqu'une même variable doit être comparée à plusieurs valeurs possibles. Voici comment articuler les instructions « if-else » et « switch » sur MT4 :

double price = Bid;
int tradeType = 2; // 0 = buy, 1 = sell, 2 = do nothing

// if-else statement
if (price > 1.0) {
    tradeType = 0;
}else if (price < 0.5) {
    tradeType = 1;
}

// switch statement
switch (tradeType) {
    case 0:
        // Execute this code if tradeType is 0 (buy)
        OrderSend(Symbol(), OP_BUY, 0.1, price, 0, 0, 0, "Buy order", 0, 0, Green);
        break;
    case 1:
        // Execute this code if tradeType is 1 (sell)
        OrderSend(Symbol(), OP_SELL, 0.1, price, 0, 0, 0, "Sell order", 0, 0, Red);
        break;
    default:
        // Execute this code if tradeType is not 0 or 1 (do nothing)
        break;
}

La structure if/else évalue la situation par rapport au niveau du cours :

• si le cours est > 1.0, la variable tradeType passe à 0 -> ACHAT ;
• si le cours est < 0.5, la variable tradeType passe à 1 -> VENTE ;
• si le cours est au niveau du cours vendeur actuel (valeur par défaut), tradeType = 2 -> AUCUNE ACTION.

Avec l'instruction switch, la logique s'articule directement autour de la valeur prise par tradeType :

• si tradeType = 0 -> ordre d'ACHAT au cours spécifié ;
• si tradeType = 1 -> ordre de VENTE au cours spécifié ;
• si tradeType = 2 -> AUCUNE ACTION.

Consultez ces guides pour installer votre robot Forex sur votre terminal de trading :
Comment installer un robot de trading Forex sur MT4
Comment installer un robot de trading Forex sur MT5

Conclusion

Nous avons passé en revue les composants essentiels d'un robot Forex et les principes de conception d'un système de trading algorithmique. Vous avez découvert les différents programmes réalisables en MQL4 (robots de trading Forex, indicateurs et scripts), ainsi que les éléments de syntaxe indispensables (variables, expressions, conditions et opérateurs). Ces bases vous permettront de mieux appréhender la structure d'un code de trading automatisé.

Maîtriser la programmation MQL demande de la pratique et un travail régulier. Nous espérons que ce tour d'horizon vous aidera à aborder plus sereinement le développement de vos propres robots de trading Forex.