MQL4 · Ordres
Trailing stop en MQL4 : coder un stop suiveur fiable
Activation, distance et pas : comment programmer un trailing stop en MQL4 avec OrderModify, éviter les erreurs 1, 130 et 145 et adapter la distance à la volatilité avec l’ATR.
Un trailing stop en MQL4 est un stop loss que l’EA rapproche du prix à mesure que la position devient gagnante, sans jamais l’éloigner. Il se programme avec OrderModify() : à chaque tick (ou à chaque bougie), l’EA parcourt ses positions, calcule le nouveau stop (par exemple Bid - distance pour un achat) et ne l’envoie que s’il est plus protecteur que le stop actuel d’au moins un pas minimal. Contrairement au trailing stop manuel du terminal MetaTrader 4, celui-ci est entièrement sous le contrôle de votre code et peut suivre des règles plus riches : distance fixe, distance basée sur l’ATR, ou activation après un gain minimal.
Cette page propose une fonction de trailing stop complète, explique chaque paramètre et liste les erreurs qui font échouer la plupart des implémentations. Elle fait partie de la rubrique Gérer les ordres en MQL4.
Le principe en trois paramètres
Un trailing stop bien conçu repose sur trois réglages distincts :
| Paramètre | Rôle | Exemple |
|---|---|---|
| Activation | Gain minimal avant que le suivi ne commence | 300 points |
| Distance | Écart maintenu entre le prix et le stop | 200 points |
| Pas | Amélioration minimale pour envoyer une modification | 50 points |
L’activation évite de resserrer le stop trop tôt, quand la position n’a pas encore pris de marge. La distance définit la tolérance au bruit du marché : trop courte, elle vous fait sortir sur une respiration normale ; trop longue, elle rend une grande partie du gain. Le pas limite le nombre de modifications : sans lui, l’EA enverrait un OrderModify() à chaque point de progression, ce qui sature le serveur et produit des refus.
Une fonction de trailing stop complète
#property strict
input int InpActivation = 300; // Gain avant activation (points)
input int InpDistance = 200; // Distance du trailing (points)
input int InpPas = 50; // Pas minimal de déplacement (points)
input int InpMagic = 240207; // Numéro magique
//+------------------------------------------------------------------+
//| Applique le trailing stop à toutes les positions de l'EA |
//+------------------------------------------------------------------+
void TrailingStop()
{
for(int i = OrdersTotal() - 1; i >= 0; i--)
{
if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) continue;
if(OrderSymbol() != Symbol() || OrderMagicNumber() != InpMagic) continue;
if(OrderType() > OP_SELL) continue; // positions uniquement
RefreshRates();
double stopLevel = MarketInfo(Symbol(), MODE_STOPLEVEL) * Point;
double distance = MathMax(InpDistance * Point, stopLevel + Point);
double ancienSL = OrderStopLoss();
double nouveauSL = 0.0;
if(OrderType() == OP_BUY)
{
// gain courant mesuré au Bid (prix de clôture d'un achat)
if(Bid - OrderOpenPrice() < InpActivation * Point) continue;
nouveauSL = NormalizeDouble(Bid - distance, Digits);
// le nouveau stop doit être plus haut que l'ancien d'au moins un pas
if(ancienSL != 0 && nouveauSL < ancienSL + InpPas * Point) continue;
}
else // OP_SELL
{
// gain courant mesuré au Ask (prix de clôture d'une vente)
if(OrderOpenPrice() - Ask < InpActivation * Point) continue;
nouveauSL = NormalizeDouble(Ask + distance, Digits);
// le nouveau stop doit être plus bas que l'ancien d'au moins un pas
if(ancienSL != 0 && nouveauSL > ancienSL - InpPas * Point) continue;
}
ResetLastError();
if(!OrderModify(OrderTicket(), OrderOpenPrice(), nouveauSL,
OrderTakeProfit(), 0, clrNONE))
PrintFormat("Trailing %d refusé : erreur %d (SL %s)", OrderTicket(),
GetLastError(), DoubleToString(nouveauSL, Digits));
}
}
void OnTick()
{
TrailingStop();
// ... reste de la logique de l'EA
}
Plusieurs détails rendent ce code fiable. Le gain est mesuré au prix de clôture de la position (Bid pour un achat, Ask pour une vente), qui est aussi le prix auquel le serveur contrôle le stop. La distance effective n’est jamais inférieure au stop level du courtier plus un point, ce qui évite l’erreur 130. La condition de pas garantit que le stop ne recule jamais et qu’aucune modification identique n’est envoyée, ce qui évite l’erreur 1 décrite dans la page OrderModify. Enfin, le take profit existant est repassé tel quel : passer 0 le supprimerait.
Variante : une distance basée sur la volatilité
Une distance fixe en points convient mal à des marchés dont la volatilité change. Une alternative courante consiste à exprimer la distance en multiple de l’ATR, calculé sur la dernière bougie clôturée :
input int InpPeriodeATR = 14; // Période de l'ATR
input double InpMultATR = 2.0; // Multiplicateur de l'ATR
double DistanceATR()
{
double atr = iATR(Symbol(), Period(), InpPeriodeATR, 1); // bougie clôturée
return(atr * InpMultATR);
}
Il suffit alors de remplacer InpDistance * Point par DistanceATR() dans la fonction principale, en gardant le plancher du stop level. La page iATR en MQL4 détaille la fonction et ses paramètres.
Tick par tick ou bougie par bougie
Appeler le trailing à chaque tick le rend réactif, mais multiplie les calculs et, sans pas minimal, les requêtes. L’appeler une fois par bougie, sur la base des prix de clôture, le rend plus stable et plus fidèle entre backtest et réel, au prix d’une réaction plus lente. Il n’y a pas de bon choix universel : un trailing serré sur M1 n’a de sens qu’au tick, un trailing large sur H4 fonctionne très bien à la bougie. Dans les deux cas, le paramètre de pas reste indispensable.
Notez aussi que le trailing stop logiciel ne fonctionne que si l’EA tourne. Le stop déjà posé sur le serveur reste actif si le terminal s’arrête, mais il cesse alors de suivre le prix. Pour un EA qui en dépend, une exécution sur une machine allumée en permanence est nécessaire.
Les erreurs fréquentes
- Mesurer le gain au mauvais prix. Calculer le gain d’un achat avec
Asksurestime la progression de la valeur du spread. - Laisser le stop reculer. Sans comparaison avec l’ancien stop, un repli du prix ferait redescendre le stop d’un achat. Un trailing stop ne doit que se resserrer.
- Oublier le cas d’un stop nul. Une position ouverte sans stop a
OrderStopLoss() == 0. Pour une vente, la comparaisonnouveauSL > ancienSLserait toujours vraie et bloquerait le premier placement ; d’où le testancienSL != 0. - Ignorer la zone de gel. Quand le prix est très proche du stop actuel, le serveur peut refuser la modification (erreur 145). Ce n’est pas grave : le stop existant reste en place, et l’EA réessaiera au tick suivant.
- Modifier les ordres des autres EA. Le filtre sur le numéro magique est indispensable.
Valider le trailing dans le testeur
Le comportement d’un trailing stop dépend fortement du mode de modélisation du testeur. Avec une modélisation à l’ouverture des bougies, l’EA ne voit qu’un prix par bougie et le trailing se déplace par paliers ; avec une modélisation tick par tick, il suit les variations intra-bougie et se rapproche du comportement réel. Testez donc toujours un trailing appelé au tick avec la modélisation la plus fine disponible, et vérifiez dans le mode visuel que le stop avance comme prévu et ne recule jamais.
Comparez ensuite deux ou trois combinaisons de distance et de pas plutôt que de chercher la valeur optimale au point près : un trailing dont les résultats s’effondrent quand la distance varie de 20 % est le signe d’un réglage trop ajusté à l’historique testé. Le journal du testeur doit aussi rester propre : des refus de modification répétés signalent un pas trop faible ou une distance inférieure au stop level du symbole.
Trailing stop et break-even
Le trailing stop et le break-even sont souvent combinés : le break-even protège le capital dès qu’un premier seuil est atteint, puis le trailing prend le relais pour suivre la tendance. Si vous utilisez les deux, assurez-vous qu’ils ne se contredisent pas : le trailing ne doit jamais placer le stop en dessous du niveau de break-even déjà posé. La page Break-even en MQL4 propose une fonction compatible avec celle-ci.
Et en MQL5 ?
Le principe est identique en MQL5. On parcourt les positions avec PositionsTotal() et PositionGetTicket(), on lit le stop actuel avec PositionGetDouble(POSITION_SL) et on modifie avec CTrade::PositionModify(). La bibliothèque standard de MQL5 propose aussi des classes de trailing pour l’assistant de création d’EA. La rubrique Migration de MQL4 vers MQL5 détaille ces correspondances.
FAQ
Quelle distance choisir pour un trailing stop ?
Elle dépend de la volatilité du symbole et de l’unité de temps. Une distance inférieure au mouvement habituel d’une bougie vous fera sortir sur le bruit. Une approche fondée sur un multiple de l’ATR s’adapte automatiquement, mais doit être validée par des tests sur plusieurs périodes.
Pourquoi mon trailing stop produit-il l’erreur 1 ?
Parce qu’il envoie une modification avec un stop identique à l’actuel. Ajoutez un pas minimal et comparez le nouveau stop à l’ancien avant d’appeler OrderModify().
Le trailing stop fonctionne-t-il si je ferme MetaTrader 4 ?
Le dernier stop envoyé reste sur le serveur et protège la position, mais il ne bouge plus. Le suivi reprend au redémarrage de l’EA.
Faut-il un trailing stop à chaque tick ?
Pas nécessairement. À la bougie, le comportement est plus stable et plus proche du backtest ; au tick, il est plus réactif. Dans tous les cas, utilisez un pas minimal.
