MQL4 · Ordres
OrderSend en MQL4 : ouvrir un ordre au marché ou en attente
Signature d’OrderSend, prix Bid et Ask, slippage, stop loss, take profit, magic number : comment ouvrir un ordre fiable en MQL4 et réagir aux erreurs 129, 130, 138 ou 148.
OrderSend() est la fonction MQL4 qui ouvre un ordre au marché (OP_BUY, OP_SELL) ou place un ordre en attente (OP_BUYLIMIT, OP_SELLLIMIT, OP_BUYSTOP, OP_SELLSTOP). Elle renvoie le numéro de ticket attribué par le serveur, ou -1 en cas d’échec ; le code de l’erreur se lit alors avec GetLastError(). Pour un ordre au marché, le prix envoyé doit être le dernier Ask (achat) ou le dernier Bid (vente), normalisé au nombre de décimales du symbole ; le stop loss et le take profit doivent respecter la distance minimale imposée par le serveur.
Cette page détaille chaque paramètre d’après la documentation officielle, puis propose une fonction d’ouverture complète et commentée. Elle fait partie de la rubrique Gérer les ordres en MQL4.
La signature
int OrderSend(
string symbol, // symbole
int cmd, // type d'opération (OP_BUY, OP_SELL...)
double volume, // volume en lots
double price, // prix d'ouverture
int slippage, // glissement maximal accepté, en points
double stoploss, // niveau du stop loss (0 = aucun)
double takeprofit, // niveau du take profit (0 = aucun)
string comment=NULL, // commentaire
int magic=0, // numéro magique
datetime expiration=0, // expiration (ordres en attente uniquement)
color arrow_color=clrNONE // couleur de la flèche sur le graphique
);
Les paramètres un par un
| Paramètre | Ce qu’il faut savoir |
|---|---|
symbol | Le nom exact du symbole chez votre courtier. Utilisez Symbol() pour le graphique courant ; les suffixes comme « .m » font partie du nom. |
cmd | L’une des six constantes OP_.... |
volume | En lots, compris entre le minimum et le maximum du courtier et multiple du pas de volume (valeurs lisibles avec MarketInfo()). |
price | Pour un ordre au marché : Ask à l’achat, Bid à la vente. Pour un ordre en attente : le niveau de déclenchement. |
slippage | L’écart maximal, en points, entre le prix demandé et le prix d’exécution. |
stoploss, takeprofit | Des niveaux de prix, pas des distances. 0 signifie « pas de niveau ». |
comment | Texte libre ; la documentation précise que le serveur peut en modifier la fin. |
magic | Identifiant de l’EA, indispensable pour retrouver ses ordres. |
expiration | Date d’expiration d’un ordre en attente. Certains serveurs la refusent (erreur 147). |
arrow_color | Couleur de la flèche dessinée ; clrNONE ou CLR_NONE pour ne rien dessiner. |
Les règles de prix fixées par la documentation
La documentation d’OrderSend() énonce plusieurs règles qui expliquent la majorité des refus :
- Prix d’un ordre au marché. Seul le dernier
Bid(vente) ouAsk(achat) peut servir de prix d’ouverture. Si l’opération porte sur un autre symbole que celui du graphique, il faut lire ses prix avecMarketInfo(). - Prix calculé ou non normalisé. Un prix qui n’existe pas dans le flux de cotations ou qui n’est pas normalisé au nombre de décimales produit l’erreur 129 (prix invalide).
- Prix dépassé. Si le prix demandé est totalement périmé, l’erreur 138 (requote) est renvoyée, quel que soit le glissement. S’il est périmé mais encore présent dans le flux, l’ordre est exécuté au prix courant, à condition que celui-ci se situe dans la fourchette prix ± glissement.
- Stops trop proches. Le stop loss et le take profit ne peuvent pas être trop près du marché. La distance minimale, en points, s’obtient avec
MarketInfo(symbole, MODE_STOPLEVEL). Un niveau erroné ou non normalisé produit l’erreur 130. Une valeur de stop level égale à zéro signifie soit l’absence de restriction, soit un contrôle dynamique côté serveur : dans ce second cas, l’erreur 130 reste possible. - Ordre en attente trop proche. Le prix d’un ordre en attente ne peut pas non plus être trop près du marché ; un prix incorrect produit également l’erreur 130.
- Limite du nombre d’ordres. Certains serveurs limitent le nombre total d’ordres ouverts et en attente ; au-delà, l’erreur 148 est renvoyée.
Les règles de distance sont détaillées, type d’ordre par type d’ordre, dans la page StopLevel et FreezeLevel.
Une fonction d’ouverture complète
Le code suivant ouvre un achat ou une vente au marché avec un stop et un objectif exprimés en points. Il vérifie le volume, le stop level et l’environnement, normalise les prix et journalise l’échec.
#property strict
input double InpLots = 0.10; // Volume (lots)
input int InpStopPoints = 300; // Stop loss (points)
input int InpTpPoints = 600; // Take profit (points)
input int InpSlippage = 10; // Glissement max (points)
input int InpMagic = 240201; // Numéro magique
//+------------------------------------------------------------------+
//| Arrondit un volume au pas du courtier et le borne |
//+------------------------------------------------------------------+
double NormaliserLot(double lots)
{
double minLot = MarketInfo(Symbol(), MODE_MINLOT);
double maxLot = MarketInfo(Symbol(), MODE_MAXLOT);
double pas = MarketInfo(Symbol(), MODE_LOTSTEP);
lots = MathFloor(lots / pas) * pas; // arrondi vers le bas au pas
lots = MathMax(minLot, MathMin(maxLot, lots));
return(NormalizeDouble(lots, 2));
}
//+------------------------------------------------------------------+
//| Ouvre un ordre au marché. type = OP_BUY ou OP_SELL |
//| Renvoie le ticket ou -1 |
//+------------------------------------------------------------------+
int OuvrirOrdre(int type)
{
if(!IsTradeAllowed() || IsTradeContextBusy())
return(-1);
RefreshRates(); // prix les plus récents
int stopLevel = (int)MarketInfo(Symbol(), MODE_STOPLEVEL);
int distSL = MathMax(InpStopPoints, stopLevel + 1);
int distTP = MathMax(InpTpPoints, stopLevel + 1);
double prix, sl, tp;
color couleur;
if(type == OP_BUY)
{
prix = Ask; // on achète au Ask
sl = prix - distSL * Point;
tp = prix + distTP * Point;
couleur = clrBlue;
}
else
{
prix = Bid; // on vend au Bid
sl = prix + distSL * Point;
tp = prix - distTP * Point;
couleur = clrRed;
}
prix = NormalizeDouble(prix, Digits);
sl = NormalizeDouble(sl, Digits);
tp = NormalizeDouble(tp, Digits);
ResetLastError();
int ticket = OrderSend(Symbol(), type, NormaliserLot(InpLots), prix,
InpSlippage, sl, tp, "OptiBot", InpMagic, 0, couleur);
if(ticket < 0)
{
int err = GetLastError();
PrintFormat("OrderSend %s échoué : erreur %d (prix %s, SL %s, TP %s)",
(type == OP_BUY ? "achat" : "vente"), err,
DoubleToString(prix, Digits), DoubleToString(sl, Digits),
DoubleToString(tp, Digits));
}
else
PrintFormat("Ordre %d ouvert", ticket);
return(ticket);
}
void OnTick()
{
// exemple minimal : ouvrir un achat s'il n'y a aucun ordre
if(OrdersTotal() == 0)
OuvrirOrdre(OP_BUY);
}
Remarquez que le stop d’un achat est calculé depuis Ask mais que le serveur le contrôle par rapport au Bid : avec un spread large, un stop calculé au minimum depuis Ask peut être refusé. Le + 1 ajouté au stop level et une marge plus confortable dans vos paramètres évitent ce cas limite. Ce point est développé dans la page consacrée aux distances minimales.
Le test OrdersTotal() == 0 de l’exemple est volontairement simpliste : il compte tous les ordres du compte, y compris ceux d’autres EA. Un vrai EA compte uniquement ses propres ordres, filtrés par symbole et numéro magique, comme le montre la page OrderSelect et boucles.
Après l’envoi : lire le résultat
Un ticket positif signifie que le serveur a accepté l’ordre. Pour connaître le prix réel d’exécution (qui peut différer du prix demandé dans la limite du glissement), sélectionnez l’ordre par son ticket et lisez OrderOpenPrice() :
if(ticket > 0 && OrderSelect(ticket, SELECT_BY_TICKET))
PrintFormat("Exécuté à %s", DoubleToString(OrderOpenPrice(), Digits));
En cas d’échec, le code d’erreur oriente la réaction : 129, 135, 136 ou 138 justifient une nouvelle tentative après RefreshRates() ; 130 impose de revoir les distances ; 131 de corriger le volume ; 134 signale une marge insuffisante ; 146 un contexte de trading occupé. Chaque code a sa page dans la rubrique erreurs, par exemple Erreur 130 : stops invalides.
Vérifier la marge avant d’envoyer
Avant un envoi, il est prudent de vérifier que le compte peut supporter le nouvel ordre. La fonction AccountFreeMarginCheck(symbole, cmd, volume) renvoie la marge libre qui resterait après l’ouverture de l’ordre envisagé. Si la valeur est négative ou nulle, l’envoi échouerait avec l’erreur 134 (fonds insuffisants) : autant ne pas solliciter le serveur. Ce contrôle est particulièrement utile pour les EA qui calculent leur volume dynamiquement, car une erreur de calcul peut produire un volume bien supérieur à ce que le compte autorise. Combinez-le avec le calcul du volume selon le risque décrit dans Taille de lot selon le risque, plutôt que de compter sur le refus du serveur pour vous protéger.
Pièges fréquents
- Passer une distance au lieu d’un prix.
stoploss = 300n’est pas un stop à 300 points, c’est un stop au prix 300. Calculez toujours un niveau de prix. - Inverser Bid et Ask. Acheter au
Bidou vendre auAskprovoque un refus de prix. - Oublier la normalisation.
Ask + 0.0015peut produire un nombre avec des décimales parasites. - Retenter sans limite. Une boucle qui renvoie l’ordre tant qu’il échoue peut produire plusieurs positions si la réponse du serveur s’est perdue. Limitez le nombre d’essais et recomptez vos ordres avant chaque tentative.
- Volume non conforme. Un volume de 0.015 sur un compte au pas de 0.01 est refusé : arrondissez au pas du courtier.
Et en MQL5 ?
En MQL5, OrderSend() existe toujours mais prend une structure MqlTradeRequest et remplit une structure MqlTradeResult : on renseigne l’action, le symbole, le volume, le type, le prix, le stop, l’objectif, le glissement et le mode de remplissage, puis on lit le retcode. La classe CTrade simplifie ces appels avec des méthodes comme Buy() et Sell(). La logique de position diffère aussi selon que le compte est en mode netting ou hedging : voyez Des ordres MQL4 aux positions MQL5.
FAQ
Que renvoie OrderSend en cas d’échec ?
La valeur -1. Le détail de l’erreur s’obtient immédiatement après avec GetLastError(), qui en MQL4 remet le code à zéro après lecture : stockez-le dans une variable.
Le slippage est-il exprimé en pips ou en points ?
En points. Sur une cotation à 5 décimales, un glissement de 10 correspond à 1 pip.
Peut-on ouvrir un ordre sur un autre symbole que celui du graphique ?
Oui, en passant son nom dans symbol et en utilisant ses prix lus par MarketInfo(symbole, MODE_ASK) ou MODE_BID, ainsi que ses propres MODE_POINT et MODE_DIGITS pour les calculs.
Pourquoi mon ordre est-il refusé avec stop loss mais accepté sans ?
Soit le stop est trop proche du marché (erreur 130), soit le serveur fonctionne en exécution au marché et refuse les stops à l’ouverture. Voyez la page sur les comptes ECN.
