Nouveau : la formation trading algorithmique MQL5, MQL4 et ProRealTimeDécouvrir →

MQL4 · Expert Advisors

Premier EA en MQL4 : un robot complet, commenté ligne par ligne

Construire pas à pas un Expert Advisor MQL4 fonctionnel : paramètres, détection de nouvelle bougie, signal, contrôle des ordres existants, taille de position selon le risque et gestion des erreurs.

Mis à jour le 23 octobre 2026Lecture : 9 minPar Alix, OptiBot Trading

Un premier Expert Advisor MQL4 doit faire peu de choses, mais les faire correctement : lire un signal sur des bougies clôturées, vérifier qu’il n’a pas déjà une position, calculer un volume cohérent avec le risque accepté, envoyer l’ordre avec un stop loss et signaler clairement toute erreur. Cette page construit un tel robot, un croisement de moyennes filtré par une moyenne longue, et explique chaque bloc. La stratégie est volontairement simple : l’objectif est une structure solide que vous pourrez réutiliser pour vos propres idées, pas une méthode de trading clé en main.

L’architecture du robot

Le code est organisé en blocs qui ont chacun une seule responsabilité :

  1. les paramètres (input), modifiables sans recompiler ;
  2. OnInit(), qui vérifie la cohérence des paramètres avant que le robot ne démarre ;
  3. OnTick(), qui orchestre le travail : nouvelle bougie, signal, contrôle, ordre ;
  4. des fonctions utilitaires : détection de nouvelle bougie, comptage des positions, calcul du volume, envoi d’ordre.

Garder OnTick() court et lisible est la meilleure protection contre les erreurs : quand une fonction fait trois lignes, on voit immédiatement ce qu’elle fait. Le rôle de chaque fonction d’événement est détaillé dans Structure d’un EA MQL4.

Le code complet

//+------------------------------------------------------------------+
//| PremierEA.mq4 : croisement EMA filtré par une SMA longue          |
//+------------------------------------------------------------------+
#property strict

//--- Paramètres
input int    EMARapide   = 20;      // période de l'EMA rapide
input int    EMALente    = 50;      // période de l'EMA lente
input int    SMAFiltre   = 200;     // filtre de tendance
input double RisquePct   = 1.0;     // risque par trade, en % du solde
input int    StopPoints  = 400;     // stop loss, en points
input double RatioGain   = 2.0;     // take profit = RatioGain x stop
input int    Slippage    = 5;       // glissement toléré, en points
input int    Magic       = 42001;   // identifiant des ordres de ce robot

//+------------------------------------------------------------------+
int OnInit()
{
   if(EMARapide >= EMALente || EMALente >= SMAFiltre)
   {
      Print("Paramètres incohérents : il faut EMARapide < EMALente < SMAFiltre");
      return(INIT_PARAMETERS_INCORRECT);
   }
   if(RisquePct <= 0 || RisquePct > 5 || StopPoints <= 0)
      return(INIT_PARAMETERS_INCORRECT);
   return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
void OnTick()
{
   if(!NouvelleBougie()) return;                 // une décision par bougie
   if(Bars < SMAFiltre + 2) return;              // historique insuffisant
   if(PositionsDuRobot() > 0) return;            // une seule position à la fois

   int signal = LireSignal();
   if(signal == OP_BUY || signal == OP_SELL) Ouvrir(signal);
}

//+------------------------------------------------------------------+
//| Vrai une seule fois au début de chaque bougie                     |
//+------------------------------------------------------------------+
bool NouvelleBougie()
{
   static datetime derniere = 0;
   if(Time[0] == derniere) return(false);
   derniere = Time[0];
   return(true);
}

//+------------------------------------------------------------------+
//| Renvoie OP_BUY, OP_SELL ou -1, à partir des bougies clôturées     |
//+------------------------------------------------------------------+
int LireSignal()
{
   double r1 = iMA(NULL, 0, EMARapide, 0, MODE_EMA, PRICE_CLOSE, 1);
   double r2 = iMA(NULL, 0, EMARapide, 0, MODE_EMA, PRICE_CLOSE, 2);
   double l1 = iMA(NULL, 0, EMALente,  0, MODE_EMA, PRICE_CLOSE, 1);
   double l2 = iMA(NULL, 0, EMALente,  0, MODE_EMA, PRICE_CLOSE, 2);
   double f1 = iMA(NULL, 0, SMAFiltre, 0, MODE_SMA, PRICE_CLOSE, 1);

   if(r2 <= l2 && r1 > l1 && Close[1] > f1) return(OP_BUY);
   if(r2 >= l2 && r1 < l1 && Close[1] < f1) return(OP_SELL);
   return(-1);
}

//+------------------------------------------------------------------+
//| Nombre d'ordres au marché ouverts par ce robot sur ce symbole     |
//+------------------------------------------------------------------+
int PositionsDuRobot()
{
   int n = 0;
   for(int i = OrdersTotal() - 1; i >= 0; i--)
   {
      if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) continue;
      if(OrderSymbol() != Symbol() || OrderMagicNumber() != Magic) continue;
      if(OrderType() == OP_BUY || OrderType() == OP_SELL) n++;
   }
   return(n);
}

//+------------------------------------------------------------------+
//| Volume tel que la perte au stop = RisquePct % du solde            |
//+------------------------------------------------------------------+
double VolumeSelonRisque()
{
   double tickValue = MarketInfo(Symbol(), MODE_TICKVALUE);
   double tickSize  = MarketInfo(Symbol(), MODE_TICKSIZE);
   double pas       = MarketInfo(Symbol(), MODE_LOTSTEP);
   double minLot    = MarketInfo(Symbol(), MODE_MINLOT);
   double maxLot    = MarketInfo(Symbol(), MODE_MAXLOT);
   if(tickValue <= 0 || tickSize <= 0 || pas <= 0) return(0);

   double risque      = AccountBalance() * RisquePct / 100.0;
   double perteParLot = (StopPoints * Point) / tickSize * tickValue;
   double lots        = MathFloor(risque / perteParLot / pas) * pas;
   if(lots < minLot) return(0);                  // on ne dépasse pas le risque prévu
   return(MathMin(lots, maxLot));
}

//+------------------------------------------------------------------+
//| Envoi de l'ordre avec stop loss et take profit                    |
//+------------------------------------------------------------------+
void Ouvrir(int sens)
{
   double lots = VolumeSelonRisque();
   if(lots <= 0) { Print("Volume calculé trop faible, ordre annulé"); return; }

   RefreshRates();                               // Bid et Ask à jour
   double prix = (sens == OP_BUY) ? Ask : Bid;
   double dist = StopPoints * Point;
   double sl   = (sens == OP_BUY) ? prix - dist : prix + dist;
   double tp   = (sens == OP_BUY) ? prix + dist * RatioGain : prix - dist * RatioGain;

   int ticket = OrderSend(Symbol(), sens, lots, prix, Slippage,
                          NormalizeDouble(sl, Digits), NormalizeDouble(tp, Digits),
                          "PremierEA", Magic, 0, (sens == OP_BUY) ? clrBlue : clrRed);
   if(ticket < 0)
      Print("OrderSend refusé (", (sens == OP_BUY ? "achat" : "vente"), ") : erreur ", GetLastError());
   else
      Print("Ordre ", ticket, " ouvert : ", DoubleToString(lots, 2), " lot(s)");
}

Les choix expliqués

Une décision par bougie

NouvelleBougie() compare l’heure d’ouverture de la bougie en cours, Time[0], à celle mémorisée lors de l’appel précédent. La variable static conserve sa valeur d’un appel à l’autre. Résultat : le robot ne réfléchit qu’au premier tick de chaque bougie, et lit des indicateurs sur les bougies 1 et 2, déjà terminées. Ce choix évite les signaux qui apparaissent puis disparaissent en cours de bougie, et rend le backtest cohérent avec le comportement en temps réel.

Le magic number

Chaque ordre est marqué par le paramètre Magic. C’est ce qui permet à PositionsDuRobot() de ne compter que les ordres de ce robot, même si vous tradez manuellement sur le même compte ou si d’autres EA tournent sur d’autres graphiques. Surtout, c’est ce qui permet au robot de retrouver ses positions après un redémarrage du terminal : il ne garde aucun ticket en mémoire, il relit la liste des ordres à chaque décision. Le sujet est approfondi dans Magic number en MQL4.

Le volume calculé selon le risque

Plutôt qu’un volume fixe, le robot calcule le nombre de lots pour que la perte au stop représente un pourcentage fixe du solde. MODE_TICKVALUE donne la valeur d’un tick pour un lot dans la devise du compte, MODE_TICKSIZE la taille de ce tick en prix. Le résultat est arrondi vers le bas au pas de volume autorisé, et l’ordre est annulé si le volume minimal ferait dépasser le risque prévu. La page Taille de lot selon le risque détaille les cas particuliers, notamment les comptes dont la devise diffère de celle de la paire.

RefreshRates avant l’envoi

RefreshRates() met à jour les variables Bid et Ask. Dans ce robot, l’appel est presque immédiat après le début du tick, mais prendre l’habitude de rafraîchir les prix avant chaque envoi évite des erreurs de prix périmé lorsque le code effectue des calculs plus longs.

Les messages d’erreur

Chaque refus d’ordre est consigné avec le code renvoyé par GetLastError(). Les codes les plus fréquents au premier essai sont 130 (stops invalides, souvent trop proches du prix) et 131 (volume invalide). Ils sont expliqués dans la rubrique consacrée aux erreurs MQL4, à commencer par GetLastError en MQL4.

Journaliser pour comprendre

Un robot qui fonctionne mal sans rien dire est le cas le plus difficile à corriger. Les appels à Print() placés dans Ouvrir() donnent déjà l’essentiel : volume calculé, ticket obtenu ou code d’erreur. Pendant la phase de mise au point, ajoutez temporairement un message dans LireSignal() qui affiche les valeurs des moyennes à chaque nouvelle bougie. Vous pourrez ainsi comparer, bougie par bougie, ce que le robot a lu avec ce que montre la fenêtre des données du graphique. Une fois le comportement validé, supprimez ces messages de diagnostic ou conditionnez-les à un paramètre input bool Debug, pour ne pas remplir le journal en production. Les techniques de débogage sont présentées plus en détail dans la rubrique consacrée aux bases du langage.

Compiler et lancer

Enregistrez le fichier dans MQL4\Experts, compilez avec F7, puis faites glisser le robot sur un graphique depuis le Navigateur. Dans la fenêtre de propriétés, onglet Commun, cochez l’autorisation de trading automatique, et vérifiez que le bouton AutoTrading de la barre d’outils est actif. Un sourire dans le coin supérieur droit du graphique indique que le robot fonctionne ; l’onglet Experts du terminal affiche ses messages.

Avant tout essai sur un compte, lancez le robot dans le testeur : la page Le Strategy Tester de MT4 explique les réglages à utiliser.

Ce que ce robot ne fait pas encore

Ce premier EA est une base, pas un produit fini. Avant tout usage sérieux, il faudrait au minimum :

  • gérer les sorties autrement que par le stop et l’objectif : stop suiveur, mise à break-even ou sortie sur signal inverse ;
  • traiter les comptes qui refusent les stops à l’ouverture, en les ajoutant après coup avec OrderModify() ;
  • réessayer intelligemment après certaines erreurs temporaires comme un contexte de trading occupé ;
  • limiter l’activité pendant certaines heures, par exemple autour de l’ouverture de la session ou des annonces économiques.

Chacun de ces points correspond à une page des rubriques d’ordres et d’erreurs. Retrouvez la suite du parcours dans la rubrique Construire et tester un EA MQL4.

Ce robot est un exemple pédagogique, pas une stratégie validée. Les croisements de moyennes produisent de nombreux faux signaux en marché sans tendance. Testez-le, modifiez-le, puis validez toute version sur compte de démonstration avant d’envisager un compte réel.

FAQ

Pourquoi mon EA ne passe aucun ordre ?

Vérifiez dans l’ordre : le bouton AutoTrading et l’autorisation dans les propriétés du robot, les messages de l’onglet Experts, la présence d’un historique suffisant (le filtre SMA 200 exige au moins 200 bougies), et le volume calculé, qui peut être inférieur au lot minimal si le risque est faible ou le stop large.

Pourquoi utiliser une variable static dans NouvelleBougie() ?

Une variable locale déclarée static conserve sa valeur entre deux appels de la fonction. Elle mémorise ici l’heure de la dernière bougie traitée sans encombrer l’espace global du programme.

Le robot retrouve-t-il ses positions après un redémarrage ?

Oui. Il ne garde aucun ticket en mémoire : à chaque nouvelle bougie, il parcourt les ordres ouverts et ne retient que ceux qui portent son magic number et son symbole.

Pourquoi le take profit est-il exprimé en multiple du stop ?

Le paramètre RatioGain fixe directement le rapport entre gain visé et perte acceptée. Cela rend le réglage plus lisible qu’un objectif en points indépendant du stop, et garde ce rapport constant si vous modifiez la distance du stop.

Puis-je lancer ce robot sur plusieurs graphiques ?

Oui, à condition de lui donner un magic number différent sur chaque graphique ou de vous assurer que les symboles diffèrent. Le comptage des positions filtre à la fois sur le symbole et sur le magic number.

A

Alix · fondateur d’OptiBot Trading

Développeur MQL5 et ProBuilder, spécialiste du backtest et de l’optimisation de stratégies automatiques. Chaque contenu est vérifié sur la documentation officielle (MQL5.com, manuels ProRealTime) et testé avant publication. Notre méthode éditoriale.