MQL5 · Ordres et positions
Coder un trailing stop en MQL5 : distance, déclenchement et pas
Un trailing stop codé dans l’EA suit le prix sans saturer le serveur : déclenchement, distance, pas minimal, contrôles StopsLevel et FreezeLevel, avec un module MQL5 complet.
Un trailing stop est un stop loss que l’Expert Advisor déplace dans le sens du gain à mesure que le prix progresse, sans jamais le reculer. En MQL5, il se code en parcourant les positions de l’EA, en calculant pour chacune un nouveau niveau à distance fixe du prix de clôture (Bid pour un achat, Ask pour une vente), puis en appelant CTrade::PositionModify(ticket, sl, tp) seulement si ce niveau améliore le stop actuel d’au moins un pas défini. Ce pas évite d’envoyer une requête à chaque tick.
MetaTrader 5 propose un trailing stop manuel dans le terminal, mais il est géré par le terminal et ne fonctionne que tant que celui-ci est ouvert. Le coder dans l’EA donne le contrôle total sur la logique : distance, déclenchement, pas, type de calcul. Cette page fait partie de la rubrique Ordres et positions en MQL5 et s’appuie sur la mécanique décrite dans Placer et modifier stop loss et take profit.
Les trois paramètres d’un trailing stop
Un trailing stop classique se décrit par trois valeurs, toutes exprimées en points :
- Le déclenchement (start) : le gain minimal, mesuré depuis le prix d’ouverture, à partir duquel le suivi commence. Avant ce seuil, le stop initial reste en place.
- La distance (trail) : l’écart maintenu entre le prix de clôture courant et le stop.
- Le pas (step) : l’amélioration minimale du stop qui justifie l’envoi d’une modification.
Le pas a un rôle technique important. Sans lui, chaque tick favorable produirait une requête, ce qui multiplie les allers-retours avec le serveur, encombre le journal et peut déclencher le refus TRADE_RETCODE_TOO_MANY_REQUESTS (10024). Un pas de quelques dizaines de points sur une paire de devises réduit drastiquement le nombre de requêtes sans changer sensiblement la protection.
La logique pour un achat et pour une vente
Pour une position acheteuse :
- le gain se mesure par
Bid − prix d'ouverture; - le nouveau stop vaut
Bid − distance; - il n’est envoyé que s’il dépasse le stop actuel d’au moins le pas (ou si aucun stop n’existe).
Pour une position vendeuse, tout est symétrique :
- le gain se mesure par
prix d'ouverture − Ask; - le nouveau stop vaut
Ask + distance; - il n’est envoyé que s’il est inférieur au stop actuel d’au moins le pas (ou si aucun stop n’existe).
Le nouveau stop doit en outre respecter la distance minimale SYMBOL_TRADE_STOPS_LEVEL : si la distance de trailing choisie est inférieure à cette valeur, le serveur refusera chaque modification avec le code 10016. Contrôlez ce point dans OnInit et refusez une configuration incohérente.
Exemple complet : trailing stop par points
Le module ci-dessous s’intègre dans n’importe quel Expert Advisor. Il ne traite que les positions du symbole courant portant le magic number de l’EA et fonctionne sur les comptes netting comme hedging.
//+------------------------------------------------------------------+
//| Module de trailing stop en points |
//+------------------------------------------------------------------+
#include <Trade\Trade.mqh>
input ulong InpMagic = 240509;
input int InpTrailStart = 300; // gain minimal avant suivi (points)
input int InpTrailDist = 200; // distance stop / prix (points)
input int InpTrailStep = 50; // amélioration minimale (points)
CTrade trade;
int OnInit()
{
trade.SetExpertMagicNumber(InpMagic);
long stops = SymbolInfoInteger(_Symbol, SYMBOL_TRADE_STOPS_LEVEL);
if(InpTrailDist <= stops)
{
PrintFormat("Distance %d <= StopsLevel %d : paramètre invalide", InpTrailDist, (int)stops);
return(INIT_PARAMETERS_INCORRECT);
}
return(INIT_SUCCEEDED);
}
void TrailPositions()
{
double point = _Point;
double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
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) continue;
if((ulong)PositionGetInteger(POSITION_MAGIC) != InpMagic) continue;
double open = PositionGetDouble(POSITION_PRICE_OPEN);
double sl = PositionGetDouble(POSITION_SL);
double tp = PositionGetDouble(POSITION_TP);
double new_sl;
if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY)
{
if(bid - open < InpTrailStart * point) continue; // pas encore
new_sl = NormalizeDouble(bid - InpTrailDist * point, _Digits);
if(sl > 0 && new_sl - sl < InpTrailStep * point) continue; // gain trop faible
}
else
{
if(open - ask < InpTrailStart * point) continue;
new_sl = NormalizeDouble(ask + InpTrailDist * point, _Digits);
if(sl > 0 && sl - new_sl < InpTrailStep * point) continue;
}
//--- le take profit est conservé tel quel
if(!trade.PositionModify(ticket, new_sl, tp))
Print("Requête non envoyée, erreur ", GetLastError());
else if(trade.ResultRetcode() != TRADE_RETCODE_DONE)
PrintFormat("Trailing refusé sur %I64u : %u %s", ticket,
trade.ResultRetcode(), trade.ResultRetcodeDescription());
}
}
void OnTick()
{
TrailPositions();
// ... reste de la logique de l'EA
}
Le module repasse le take profit actuel (tp) à chaque modification : un 0.0 le supprimerait. La boucle parcourt les positions à l’envers, une habitude utile dès qu’une opération peut modifier la liste ; la technique est détaillée dans Parcourir et filtrer les positions.
Où appeler le trailing dans l’EA
Le module est appelé au début d’OnTick, avant la logique d’entrée. Cet ordre a une raison : la gestion des positions existantes est prioritaire sur l’ouverture de nouvelles positions, et une modification de stop n’a pas à attendre l’évaluation d’un signal. Si votre EA ne réagit qu’à l’ouverture des bougies pour ses entrées, gardez malgré tout le trailing à distance fixe sur chaque tick : c’est lui qui protège le gain entre deux bougies.
Pour un EA multi-symboles, appelez la fonction pour chaque symbole géré en passant le symbole en paramètre, et lisez SYMBOL_POINT, SYMBOL_DIGITS et les prix de ce symbole au lieu des variables _Point et _Digits du graphique.
Vérifier son trailing avant le réel
Trois contrôles simples permettent de valider le module :
- en test visuel, suivez une position gagnante et vérifiez que le stop n’avance que par pas et ne recule jamais ;
- comptez dans le journal le nombre de modifications envoyées par position : quelques dizaines au plus sur une journée de forte tendance, pas des centaines ;
- vérifiez qu’aucun refus 10016, 10025 ou 10029 ne revient en série ; un refus isolé lors d’un mouvement rapide est normal, une répétition signale un paramètre incohérent.
Variantes courantes
Trailing par ATR
Au lieu d’une distance fixe, la distance devient un multiple de l’ATR, ce qui adapte le stop à la volatilité. La valeur se lit avec un handle iATR créé dans OnInit et CopyBuffer ; voir iATR : Average True Range. La logique d’envoi ne change pas : seul le calcul de new_sl diffère.
Trailing sur les extrêmes des bougies
Le stop suit le plus bas (achat) ou le plus haut (vente) des N dernières bougies clôturées. Cette variante ne bouge qu’une fois par bougie : déclenchez-la à l’ouverture de chaque nouvelle bougie plutôt qu’à chaque tick.
Trailing par paliers
Le stop avance par paliers fixes : à chaque fois que le gain progresse d’un palier, le stop avance d’un palier. C’est en pratique le comportement obtenu avec un pas égal à la distance.
Cas d’usage et pièges
Combiner avec le break-even. Beaucoup d’EA commencent par remonter le stop au prix d’entrée, puis activent le trailing plus loin. Les deux fonctions doivent alors se coordonner pour ne pas envoyer deux modifications contradictoires au même tick. La première étape est décrite dans Passer une position à break-even.
Niveau de gel. Quand le prix s’approche du stop actuel à moins de SYMBOL_TRADE_FREEZE_LEVEL points, la modification est refusée avec 10029. Cela se produit surtout lors d’un retournement brutal : acceptez l’échec et laissez le stop existant jouer son rôle.
Backtest optimiste. En modélisation sur prix d’ouverture ou sur ticks générés, le trailing stop peut sembler meilleur qu’en réalité, car le chemin du prix à l’intérieur de la bougie est approximé. Validez toujours un trailing en ticks réels ; les modes de modélisation sont comparés dans la page Modes de modélisation des ticks.
Spread variable. Pour une vente, le stop est comparé au Ask : un élargissement soudain du spread peut le déclencher sans que le Bid ait bougé. Une distance trop serrée rend le trailing sensible à ces écarts.
FAQ
Pourquoi mon trailing stop envoie-t-il une requête à chaque tick ?
Parce qu’il manque un pas minimal. Comparez le nouveau stop à l’actuel et n’envoyez la modification que si l’amélioration dépasse le pas choisi.
Le trailing stop du terminal MetaTrader 5 suffit-il ?
Il fonctionne côté terminal et s’arrête si le terminal est fermé. Il est aussi limité à une distance fixe. Un trailing codé dans l’EA a la même dépendance au terminal mais permet une logique sur mesure.
Faut-il appliquer le trailing à chaque tick ou à chaque bougie ?
Cela dépend de la variante. Un trailing à distance fixe réagit mieux à chaque tick, avec un pas pour limiter les requêtes ; un trailing sur extrêmes de bougies ne change qu’à la clôture et se calcule une fois par bougie.
Que se passe-t-il si la distance est inférieure au StopsLevel ?
Chaque modification est refusée avec TRADE_RETCODE_INVALID_STOPS (10016). Vérifiez ce paramètre à l’initialisation, comme dans l’exemple.
- Ordres, positions et transactions : le modèle de MT5
- Comptes netting ou hedging
- La classe CTrade
- OrderSend et MqlTradeRequest
- OrderCheck : vérifier un ordre avant envoi
- Ouvrir une position au marché
- Ordres limites et stop
- Placer et modifier stop loss et take profit
- Passer une position à break-even
- Fermer une position (totale ou partielle)
- Parcourir et filtrer les positions
- Le magic number
- Lire l’historique des ordres et transactions
- OnTradeTransaction : réagir aux événements de trading
- Modes de remplissage (FOK, IOC, Return)
- Gérer spread et slippage dans un EA
- Calculer et normaliser la taille de lot
