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

MQL5 · Expert Advisors

Coder un signal d’entrée dans un Expert Advisor MQL5

Écrire une fonction de signal fiable : lire des bougies clôturées, détecter un événement plutôt qu’un état, renvoyer une décision unique. Exemple complet sur un croisement de moyennes mobiles.

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

Coder un signal d’entrée en MQL5, c’est écrire une fonction qui lit des données stables (bougies clôturées, valeurs d’indicateurs obtenues par handle) et renvoie une décision unique : acheter, vendre ou ne rien faire. Le reste de l’EA (filtres, calcul du lot, envoi de l’ordre) se contente d’exploiter cette décision. Séparer ainsi le signal de l’exécution rend la stratégie lisible, testable et facile à remplacer.

Cette page de la rubrique Construire un Expert Advisor en MQL5 prend l’exemple d’un croisement de moyennes mobiles exponentielles, mais la méthode vaut pour n’importe quelle règle : cassure, retour à la moyenne, seuil de RSI.

Les trois règles d’un bon signal

1. Décider sur des bougies clôturées

La bougie d’index 0 est en formation : son prix de clôture change à chaque tick, et les indicateurs calculés dessus aussi. Un croisement visible à mi-bougie peut disparaître avant la clôture. On parle alors de signal qui « repeint ». Pour l’éviter, comparez la bougie 1 (dernière bougie terminée) à la bougie 2 (celle d’avant). Combinez cette lecture avec la détection d’une nouvelle barre décrite dans Détecter une nouvelle bougie : le signal est alors évalué une seule fois, au premier tick de chaque barre.

2. Détecter un événement, pas un état

« La moyenne rapide est au-dessus de la moyenne lente » est un état : il reste vrai pendant des dizaines de bougies. « La moyenne rapide vient de passer au-dessus » est un événement : il n’est vrai qu’une fois. Un signal d’entrée doit en général détecter l’événement, sinon l’EA cherche à entrer à chaque bougie de la tendance. La condition s’écrit donc avec deux points : fast[2] <= slow[2] (avant) et fast[1] > slow[1] (après).

3. Ne renvoyer qu’une décision

La fonction de signal ne doit ni envoyer d’ordre, ni calculer de lot, ni vérifier le spread. Elle renvoie une valeur d’énumération. Cette discipline permet de tester le signal seul, de l’afficher sur le graphique pour contrôle visuel, et de le combiner avec des filtres sans réécrire le code.

Lire les valeurs des indicateurs

En MQL5, un indicateur se crée une fois dans OnInit avec une fonction comme iMA, qui renvoie un handle (ou INVALID_HANDLE en cas d’échec). Ses valeurs se lisent ensuite avec CopyBuffer(handle, numéro_de_buffer, position_de_départ, nombre, tableau). La fonction renvoie le nombre d’éléments copiés, ou -1 en cas d’erreur, notamment quand les données ne sont pas encore calculées. Par défaut, l’élément le plus ancien est placé à l’index 0 du tableau ; en appelant ArraySetAsSeries(tableau, true), l’index 0 correspond à la valeur la plus récente demandée. Le fonctionnement des handles est détaillé dans Handles d’indicateurs et CopyBuffer.

Exemple complet : croisement de moyennes mobiles

L’EA ci-dessous évalue le signal à chaque nouvelle bougie, n’ouvre une position que si aucune position de l’EA n’existe déjà sur le symbole, et place un stop loss et un take profit fixes en points. Le volume est fixe pour rester centré sur le signal ; le dimensionnement selon le risque fait l’objet de la page Intégrer la gestion du risque.

#property version "1.00"
#include <Trade\Trade.mqh>

input int    InpFast   = 20;      // période EMA rapide
input int    InpSlow   = 50;      // période EMA lente
input int    InpSLPts  = 300;     // stop loss en points
input int    InpTPPts  = 600;     // take profit en points
input double InpLots   = 0.10;    // volume fixe
sinput ulong InpMagic  = 260102;  // magic number

enum ENUM_SIGNAL { SIGNAL_NONE = 0, SIGNAL_BUY = 1, SIGNAL_SELL = -1 };

CTrade   trade;
int      hFast = INVALID_HANDLE, hSlow = INVALID_HANDLE;
datetime g_lastBar = 0;

int OnInit()
  {
   if(InpFast >= InpSlow) return(INIT_PARAMETERS_INCORRECT);
   hFast = iMA(_Symbol, _Period, InpFast, 0, MODE_EMA, PRICE_CLOSE);
   hSlow = iMA(_Symbol, _Period, InpSlow, 0, MODE_EMA, PRICE_CLOSE);
   if(hFast == INVALID_HANDLE || hSlow == INVALID_HANDLE) return(INIT_FAILED);
   trade.SetExpertMagicNumber(InpMagic);
   g_lastBar = iTime(_Symbol, _Period, 0);   // attendre la prochaine bougie
   return(INIT_SUCCEEDED);
  }

void OnDeinit(const int reason)
  {
   IndicatorRelease(hFast);
   IndicatorRelease(hSlow);
  }

//--- signal : croisement détecté entre la bougie 2 et la bougie 1
ENUM_SIGNAL GetSignal()
  {
   double fast[], slow[];
   ArraySetAsSeries(fast, true);              // index 0 = valeur la plus récente
   ArraySetAsSeries(slow, true);
   //--- 2 valeurs à partir de la bougie 1 : fast[0] = bougie 1, fast[1] = bougie 2
   if(CopyBuffer(hFast, 0, 1, 2, fast) != 2) return(SIGNAL_NONE);
   if(CopyBuffer(hSlow, 0, 1, 2, slow) != 2) return(SIGNAL_NONE);
   if(fast[1] <= slow[1] && fast[0] > slow[0]) return(SIGNAL_BUY);
   if(fast[1] >= slow[1] && fast[0] < slow[0]) return(SIGNAL_SELL);
   return(SIGNAL_NONE);
  }

//--- l'EA a-t-il déjà une position sur ce symbole ?
bool HasOpenPosition()
  {
   for(int i = PositionsTotal() - 1; i >= 0; i--)
     {
      ulong ticket = PositionGetTicket(i);    // sélectionne la position
      if(ticket == 0) continue;
      if(PositionGetString(POSITION_SYMBOL) == _Symbol &&
         PositionGetInteger(POSITION_MAGIC) == (long)InpMagic)
         return(true);
     }
   return(false);
  }

void OnTick()
  {
   //--- une seule évaluation par bougie
   datetime t = iTime(_Symbol, _Period, 0);
   if(t == 0 || t == g_lastBar) return;
   g_lastBar = t;

   ENUM_SIGNAL sig = GetSignal();
   if(sig == SIGNAL_NONE || HasOpenPosition()) return;

   double pt  = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
   int    dg  = (int)SymbolInfoInteger(_Symbol, SYMBOL_DIGITS);
   if(sig == SIGNAL_BUY)
     {
      double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
      double sl  = NormalizeDouble(ask - InpSLPts * pt, dg);
      double tp  = NormalizeDouble(ask + InpTPPts * pt, dg);
      if(!trade.Buy(InpLots, _Symbol, 0.0, sl, tp, "EMA cross"))
         Print("Achat refusé : ", trade.ResultRetcode(), " ", trade.ResultRetcodeDescription());
     }
   else
     {
      double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
      double sl  = NormalizeDouble(bid + InpSLPts * pt, dg);
      double tp  = NormalizeDouble(bid - InpTPPts * pt, dg);
      if(!trade.Sell(InpLots, _Symbol, 0.0, sl, tp, "EMA cross"))
         Print("Vente refusée : ", trade.ResultRetcode(), " ", trade.ResultRetcodeDescription());
     }
  }

Lecture du code

  • GetSignal ne fait que lire et comparer. Elle renvoie SIGNAL_NONE si les données ne sont pas prêtes, ce qui est le comportement le plus sûr.
  • La boucle de HasOpenPosition parcourt les positions à l’envers et filtre par symbole et par magic number : une position manuelle sur le même symbole ne bloque pas l’EA, et l’EA ne confond pas ses positions avec celles d’un autre robot.
  • Le prix 0.0 passé à Buy et Sell laisse CTrade utiliser le prix courant du marché.
  • Le code de retour du serveur est journalisé en cas d’échec. La signification des codes est expliquée dans Codes de retour du serveur de trading.

Variantes de signaux et points d’attention

  • Signal sur seuil (RSI qui repasse au-dessus de 30) : même logique d’événement, comparez la bougie 2 et la bougie 1 au seuil.
  • Signal de cassure (clôture au-dessus du plus haut des N dernières bougies) : calculez le plus haut sur les bougies 2 à N+1, puis comparez la clôture de la bougie 1. Inclure la bougie 1 dans le calcul du plus haut rendrait la cassure impossible.
  • Signal en position inverse : décidez explicitement si un signal de vente doit fermer un achat existant, l’inverser ou être ignoré. Ce choix change profondément les statistiques de la stratégie.
  • Signaux multiples : quand plusieurs conditions doivent être réunies, gardez une fonction par condition et combinez-les dans GetSignal. Plus le nombre de conditions augmente, plus le risque de sur-ajustement au passé est élevé.

Pièges fréquents

  • Comparer des valeurs non normalisées. Deux moyennes peuvent être égales à la dixième décimale près et différer à la quinzième. Pour un croisement, cela n’a pas d’importance tant que vous utilisez des inégalités larges d’un côté (<=) et strictes de l’autre (>), comme dans l’exemple : un cas d’égalité exacte n’est ni compté deux fois, ni perdu.
  • Oublier ArraySetAsSeries. Sans cet appel, fast[0] contient la valeur la plus ancienne copiée, donc la bougie 2, et le sens du croisement est inversé. C’est une erreur silencieuse : le code compile et l’EA trade, mais à contresens.
  • Lire une position de départ 0. CopyBuffer(h, 0, 0, 2, buf) copie la bougie en formation et la bougie 1. Le signal devient instable, exactement ce que l’on voulait éviter.
  • Marquer la bougie comme traitée trop tôt. Dans l’exemple, la date est mémorisée avant la lecture des données. Si CopyBuffer échoue au premier tick de la barre, le signal de cette barre est perdu. Pour un EA en production, ne mémorisez la date qu’une fois la lecture réussie.
  • Ignorer le type de compte. Sur un compte netting, une seule position par symbole peut exister : un ordre de vente sur une position acheteuse réduit ou inverse la position au lieu d’en ouvrir une nouvelle. La page Comptes netting ou hedging explique les conséquences pour un EA.

Contrôler visuellement le signal

Avant de brancher le signal sur l’exécution, faites-le afficher. Une méthode simple consiste à remplacer l’envoi d’ordre par un Print qui indique l’heure de la bougie et le sens du signal, puis à lancer un test visuel dans le Strategy Tester avec les deux moyennes affichées sur le graphique. Vous vérifiez ainsi, bougie après bougie, que chaque message correspond bien à un croisement visible à la clôture. Ce contrôle prend quelques minutes et évite des heures de recherche d’un bug d’index.

Questions fréquentes

Pourquoi mon signal apparaît-il sur le graphique mais pas dans l’EA ?

Le plus souvent parce que l’indicateur affiché repeint sur la bougie en cours, ou parce que l’EA lit un index différent. Vérifiez que l’EA lit les bougies 1 et 2, que ArraySetAsSeries est appliqué avant la lecture et que les paramètres de l’indicateur sont identiques.

Faut-il vérifier le signal à chaque tick pour entrer plus tôt ?

Ce n’est pas interdit, mais le signal devient instable et le backtest dépend davantage de la modélisation des ticks. Pour la grande majorité des stratégies, décider à la clôture est plus fiable et plus facile à valider.

Comment tester uniquement le signal, sans les ordres ?

Faites afficher le signal (flèche ou message dans le journal) au lieu d’envoyer un ordre, puis lancez un test visuel dans le Strategy Tester pour contrôler chaque décision bougie par bougie.

Mon EA doit-il recalculer les moyennes lui-même ?

Non. Les fonctions d’indicateurs du terminal calculent les valeurs et les mettent en cache ; l’EA se contente de les lire avec CopyBuffer. Recalculer soi-même n’est utile que pour un indicateur qui n’existe pas dans le terminal.

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.