MQL4 · Ordres
OrderModify en MQL4 : modifier stop loss, take profit et ordres en attente
OrderModify change le stop loss, le take profit, le prix et l’expiration d’un ordre MQL4. Signature, erreurs 1, 130 et 145, et une fonction de modification sûre prête à l’emploi.
OrderModify() modifie un ordre existant identifié par son ticket : son stop loss et son take profit pour une position ouverte, et en plus son prix d’entrée et sa date d’expiration pour un ordre en attente. Sa signature est bool OrderModify(int ticket, double price, double stoploss, double takeprofit, datetime expiration, color arrow_color). Elle renvoie true en cas de succès, false sinon, le détail se lisant avec GetLastError(). Deux règles de la documentation officielle sont à retenir d’emblée : le prix d’ouverture d’un ordre au marché ne peut pas être modifié, et passer des valeurs inchangées produit l’erreur 1 (ERR_NO_RESULT).
Cette page explique comment appeler OrderModify() sans erreur, comment éviter les modifications inutiles et comment respecter les contraintes de distance du serveur. Elle fait partie de la rubrique Gérer les ordres en MQL4.
Les paramètres
| Paramètre | Ordre au marché | Ordre en attente |
|---|---|---|
ticket | Ticket de l’ordre | Ticket de l’ordre |
price | Ignoré en pratique : passez OrderOpenPrice() | Nouveau prix de déclenchement |
stoploss | Nouveau niveau de stop (0 pour aucun) | Nouveau niveau de stop |
takeprofit | Nouveau niveau d’objectif (0 pour aucun) | Nouveau niveau d’objectif |
expiration | Passez OrderExpiration() (sans effet) | Nouvelle date d’expiration (0 pour aucune) |
arrow_color | Couleur de la flèche, clrNONE pour ne rien dessiner | Idem |
Tous les paramètres doivent être fournis, même ceux que vous ne voulez pas changer. La méthode sûre consiste donc à sélectionner l’ordre, puis à reprendre ses valeurs actuelles (OrderOpenPrice(), OrderStopLoss(), OrderTakeProfit(), OrderExpiration()) pour tous les champs que vous laissez intacts. Passer 0 par erreur dans takeprofit supprime l’objectif existant.
Les erreurs typiques d’OrderModify
- Erreur 1 (
ERR_NO_RESULT) : les valeurs envoyées sont identiques aux valeurs actuelles. C’est la plus fréquente dans les trailing stops écrits trop vite, qui envoient une modification à chaque tick même quand le stop n’a pas bougé. - Erreur 130 (
ERR_INVALID_STOPS) : le nouveau stop ou objectif est trop proche du marché, ou n’est pas normalisé. - Erreur 145 : modification refusée parce que l’ordre est trop proche du marché, dans la zone de gel (voir StopLevel et FreezeLevel).
- Erreur 147 : le serveur n’accepte pas de date d’expiration pour les ordres en attente.
- Erreur 4108 : ticket invalide, par exemple parce que l’ordre a déjà été fermé.
Une fonction de modification sûre
Le code suivant modifie le stop et l’objectif d’un ordre en contrôlant tout ce qui peut provoquer un refus : sélection, changement réel, normalisation et distance minimale.
#property strict
//+------------------------------------------------------------------+
//| Vrai si deux prix diffèrent d'au moins un demi-point |
//+------------------------------------------------------------------+
bool PrixDifferent(double a, double b, double point)
{
return(MathAbs(a - b) >= point / 2.0);
}
//+------------------------------------------------------------------+
//| Modifie SL et TP d'un ordre au marché. 0 = garder la valeur |
//| actuelle. Renvoie true si l'ordre est à jour. |
//+------------------------------------------------------------------+
bool ModifierStops(int ticket, double nouveauSL, double nouveauTP)
{
if(!OrderSelect(ticket, SELECT_BY_TICKET, MODE_TRADES))
return(false);
if(OrderCloseTime() != 0) // déjà fermé
return(false);
string sym = OrderSymbol();
double point = MarketInfo(sym, MODE_POINT);
int digits = (int)MarketInfo(sym, MODE_DIGITS);
double sl = (nouveauSL > 0) ? NormalizeDouble(nouveauSL, digits) : OrderStopLoss();
double tp = (nouveauTP > 0) ? NormalizeDouble(nouveauTP, digits) : OrderTakeProfit();
// 1. rien à changer : on n'envoie rien (évite l'erreur 1)
if(!PrixDifferent(sl, OrderStopLoss(), point) &&
!PrixDifferent(tp, OrderTakeProfit(), point))
return(true);
// 2. distance minimale par rapport au prix de clôture courant
double stopLevel = MarketInfo(sym, MODE_STOPLEVEL) * point;
bool achat = (OrderType() == OP_BUY);
double prixRef = achat ? MarketInfo(sym, MODE_BID) : MarketInfo(sym, MODE_ASK);
if(sl > 0 && MathAbs(prixRef - sl) < stopLevel) return(false);
if(tp > 0 && MathAbs(tp - prixRef) < stopLevel) return(false);
// 3. envoi
ResetLastError();
if(!OrderModify(ticket, OrderOpenPrice(), sl, tp, OrderExpiration(), clrNONE))
{
int err = GetLastError();
PrintFormat("OrderModify %d échoué : erreur %d (SL %s, TP %s)",
ticket, err, DoubleToString(sl, digits), DoubleToString(tp, digits));
return(false);
}
return(true);
}
Trois choix méritent explication. La comparaison des prix se fait avec une tolérance d’un demi-point, car deux double qui représentent le même prix peuvent différer au-delà de la dixième décimale. Les prix de référence pour la distance minimale sont le Bid pour un achat et le Ask pour une vente, conformément aux règles du serveur. Enfin, la fonction lit les propriétés du symbole de l’ordre, et non celles du graphique, ce qui la rend utilisable par un EA multi-symboles.
Modifier un ordre en attente
Pour un ordre en attente, OrderModify() permet aussi de déplacer le prix de déclenchement. Les mêmes contraintes s’appliquent, avec deux différences : le prix d’entrée doit lui-même respecter la distance minimale par rapport au marché, et le stop et l’objectif se mesurent depuis ce prix d’entrée, non depuis le prix courant. De plus, un ordre en attente dont le prix est entré dans la zone de gel ne peut plus être modifié. La page Ordres en attente détaille ces règles.
Quand vous déplacez un ordre en attente, recalculez le stop et l’objectif à partir du nouveau prix d’entrée : un stop conservé à son ancienne valeur peut se retrouver trop proche, voire du mauvais côté du nouveau prix.
Cas d’usage
OrderModify() est la brique de toutes les techniques de gestion de position :
- Le trailing stop, qui rapproche le stop du prix à mesure que la position progresse : voir Trailing stop en MQL4.
- Le break-even, qui ramène le stop au prix d’entrée une fois un gain atteint : voir Break-even en MQL4.
- La pose différée des stops sur les comptes en exécution au marché, où l’on ouvre sans stop puis on le pose immédiatement après.
- L’ajustement à la volatilité, par exemple un stop recalculé à chaque bougie à partir de l’ATR.
Dans tous ces cas, la règle est la même : ne modifier que si la nouvelle valeur est différente et meilleure (plus protectrice) que l’actuelle, et ne le faire qu’à une fréquence raisonnable. Un serveur qui reçoit des dizaines de modifications par seconde peut répondre par des refus, et certains courtiers surveillent ce comportement.
À quelle fréquence modifier
Le nombre de modifications envoyées est un vrai sujet sur un compte réel. Chaque appel à OrderModify() est une requête au serveur, avec un aller-retour réseau et une occupation du contexte de trading pendant lequel aucune autre opération n’est possible pour l’EA. Trois règles simples limitent ce volume : ne modifier que lorsque la nouvelle valeur améliore la précédente d’au moins un pas significatif (par exemple 10 points), regrouper les calculs dans le bloc exécuté une fois par bougie lorsque la stratégie le permet, et ne jamais envoyer de modification pendant qu’une autre opération de l’EA est en cours. Une modification refusée doit aussi être journalisée avec son code, pour repérer un éventuel problème de distance récurrent.
Pièges fréquents
- Oublier de sélectionner l’ordre avant de lire ses propriétés.
OrderStopLoss()renvoie la valeur de l’ordre sélectionné en dernier, qui n’est peut-être pas celui que vous modifiez. - Passer 0 pour « ne pas changer ». Pour
OrderModify(), 0 signifie « supprimer le stop » ou « supprimer l’objectif », pas « garder la valeur ». - Modifier pendant une boucle sans rafraîchir les prix. Après plusieurs modifications, appelez
RefreshRates()avant de calculer les nouveaux niveaux. - Comparer avec
==. Deux prix égaux à l’affichage peuvent être différents en mémoire ; utilisez une tolérance.
Enfin, souvenez-vous qu’une modification réussie ne se voit pas forcément tout de suite dans vos variables : si vous aviez sélectionné l’ordre avant l’appel, les valeurs copiées sont celles d’avant la modification. Resélectionnez l’ordre par son ticket pour relire le nouveau stop, par exemple pour l’afficher dans le journal ou sur le graphique. Cette précaution évite de croire qu’une modification a échoué alors qu’elle a bien été prise en compte par le serveur.
Et en MQL5 ?
En MQL5, on distingue la modification d’une position (action TRADE_ACTION_SLTP, ou CTrade::PositionModify()) de celle d’un ordre en attente (action TRADE_ACTION_MODIFY, ou CTrade::OrderModify()). Le principe de ne pas envoyer de valeurs inchangées reste valable. La correspondance complète est décrite dans Des ordres MQL4 aux positions MQL5.
FAQ
Pourquoi OrderModify renvoie-t-il l’erreur 1 ?
Parce que les valeurs envoyées sont identiques à celles de l’ordre. Comparez les nouveaux niveaux aux actuels, avec une tolérance d’un demi-point, avant d’appeler la fonction.
Peut-on modifier le prix d’ouverture d’une position ouverte ?
Non. La documentation précise que le prix d’ouverture et l’expiration ne peuvent être modifiés que pour les ordres en attente.
Comment supprimer un take profit existant ?
Appelez OrderModify() avec 0 dans le paramètre takeprofit et le stop loss actuel dans stoploss.
Faut-il appeler OrderSelect avant OrderModify ?
La fonction elle-même n’en a pas besoin puisqu’elle reçoit le ticket, mais vous en avez besoin pour lire les valeurs actuelles que vous devez repasser. Sélectionnez toujours l’ordre par son ticket juste avant.
