MQL4 · Bases
RefreshRates en MQL4 : rafraîchir Bid, Ask et les séries
RefreshRates recharge Bid, Ask et les tableaux de séries pendant l’exécution d’un EA MQL4. Quand l’appeler, comment l’intégrer à une boucle de tentatives et ce qu’elle ne corrige pas.
RefreshRates() met à jour les variables prédéfinies (Bid, Ask, Close[], Time[]…) et les tableaux de séries d’un programme MQL4 pendant son exécution. Sa signature est bool RefreshRates() : elle renvoie true si les données ont effectivement été rafraîchies, false sinon, c’est-à-dire lorsque aucune nouvelle cotation n’est arrivée depuis la dernière mise à jour. On l’appelle quand l’EA a attendu ou calculé longtemps et s’apprête à utiliser un prix, typiquement juste avant un nouvel essai d’OrderSend() ou d’OrderClose().
Cette page explique pourquoi la fonction existe, où la placer, et comment l’intégrer dans une boucle de tentatives robuste. Pour le contenu des variables elles-mêmes, voyez Variables prédéfinies (Bid, Ask, Point, Digits) ; pour la rubrique complète, Les bases du MQL4.
Pourquoi les prix deviennent obsolètes
Quand une cotation arrive, le terminal copie les derniers prix dans les variables prédéfinies, puis appelle OnTick(). Pendant toute l’exécution de la fonction, ces variables gardent la valeur de ce moment précis. Le marché, lui, continue d’évoluer. Si votre fonction dure quelques millisecondes, peu importe. Mais plusieurs situations allongent fortement ce délai :
- un
Sleep()destiné à attendre la libération du contexte de trading ; - un échec d’envoi d’ordre suivi d’une nouvelle tentative ;
- une boucle qui ferme une à une plusieurs dizaines d’ordres, chaque fermeture prenant un aller-retour avec le serveur ;
- un calcul lourd sur l’historique.
Dans ces cas, un ordre envoyé avec l’ancien Ask sera refusé. La documentation d’OrderSend() est explicite : pour un ordre au marché, seul le dernier prix Bid (vente) ou Ask (achat) peut servir de prix d’ouverture ; un prix totalement dépassé produit l’erreur 138 (requote), un prix absent du flux ou mal normalisé l’erreur 129 (prix invalide).
Où appeler RefreshRates
La règle pratique : juste avant de lire un prix que vous allez envoyer au serveur, si du temps s’est écoulé depuis le début de la fonction. Inutile de l’appeler au tout début de OnTick() : les variables viennent d’être mises à jour.
| Situation | RefreshRates utile ? |
|---|---|
Premier OrderSend() au début de OnTick() | Non, les prix sont frais |
Nouvelle tentative après un échec et un Sleep() | Oui, systématiquement |
| Boucle de fermeture de plusieurs ordres | Oui, avant chaque OrderClose() |
| Après un calcul long sur l’historique | Oui |
| Ordre sur un autre symbole que celui du graphique | Non : RefreshRates() ne concerne pas ce symbole, lisez MarketInfo() |
Le dernier point mérite attention. RefreshRates() agit sur les variables prédéfinies, qui décrivent le symbole du graphique. Pour un autre symbole, MarketInfo(symbole, MODE_ASK) interroge directement le terminal et renvoie la dernière valeur connue.
Exemple : envoi d’ordre avec nouvelles tentatives
Le code suivant ouvre un achat en essayant jusqu’à trois fois. Il attend que le contexte de trading soit libre, rafraîchit les prix avant chaque essai et ne retente que pour les erreurs transitoires.
#property strict
input double InpLots = 0.10; // Volume
input int InpSlip = 10; // Glissement toléré en points
input int InpMagic = 240102; // Numéro magique
//+------------------------------------------------------------------+
//| Ouvre un achat, jusqu'à 3 tentatives |
//+------------------------------------------------------------------+
int OuvrirAchat()
{
for(int essai = 1; essai <= 3; essai++)
{
// attendre (au plus 5 s) que le contexte de trading se libère
int attente = 0;
while(IsTradeContextBusy() && attente < 5000)
{
Sleep(100);
attente += 100;
}
// les prix ont pu changer pendant l'attente : on les recharge
RefreshRates();
double prix = NormalizeDouble(Ask, Digits);
ResetLastError();
int ticket = OrderSend(Symbol(), OP_BUY, InpLots, prix, InpSlip,
0, 0, "achat", InpMagic, 0, clrBlue);
if(ticket > 0)
return(ticket); // succès
int err = GetLastError();
PrintFormat("Essai %d échoué, erreur %d", essai, err);
// ne retenter que si l'erreur est liée au prix ou au contexte
if(err != 129 && err != 135 && err != 136 && err != 138 && err != 146)
break;
Sleep(500); // petite pause avant l'essai suivant
}
return(-1);
}
void OnTick()
{
if(OrdersTotal() == 0)
OuvrirAchat();
}
Trois détails comptent dans cet exemple. D’abord, RefreshRates() est appelé après l’attente et avant la lecture de Ask, jamais l’inverse. Ensuite, le prix est normalisé au nombre de décimales du symbole. Enfin, seules les erreurs liées au prix (129, 135, 136, 138) ou au contexte occupé (146) déclenchent une nouvelle tentative : retenter sur une erreur de volume (131) ou de fonds insuffisants (134) ne sert à rien et peut saturer le serveur de requêtes.
Le cas des boucles de fermeture
Fermer tous les ordres d’un EA est l’autre situation typique. Chaque OrderClose() attend la réponse du serveur ; au cinquième ordre, le Bid lu au début de la fonction peut être dépassé. On rafraîchit donc avant chaque fermeture, et on utilise le prix adapté au sens de l’ordre :
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; // ignorer les ordres en attente
RefreshRates(); // prix frais pour cet ordre
double prix = (OrderType() == OP_BUY) ? Bid : Ask;
if(!OrderClose(OrderTicket(), OrderLots(), NormalizeDouble(prix, Digits), 10, clrRed))
PrintFormat("Fermeture de %d impossible, erreur %d", OrderTicket(), GetLastError());
}
La boucle descendante et les filtres sont expliqués dans la page OrderSelect et boucles.
Interpréter la valeur de retour
RefreshRates() renvoie false lorsqu’il n’y a rien de nouveau. Ce n’est pas une erreur : cela signifie simplement que les prix en mémoire sont déjà les derniers reçus. Ne bloquez donc pas l’envoi d’un ordre parce que la fonction a renvoyé false. En revanche, si vous attendez explicitement un mouvement de prix, vous pouvez boucler sur RefreshRates() avec un court Sleep(), en limitant toujours le nombre d’itérations et en testant IsStopped().
Mesurer le temps réellement écoulé
Pour savoir si un rafraîchissement est nécessaire, il est utile de mesurer la durée de votre traitement. La fonction GetTickCount() renvoie le nombre de millisecondes écoulées depuis le démarrage du système : en relevant sa valeur au début de OnTick() puis juste avant l’envoi d’un ordre, vous obtenez la durée exacte de vos calculs. Si elle dépasse quelques centaines de millisecondes en conditions normales, c’est le signe qu’une partie du code mérite d’être optimisée, ou déplacée dans une fonction appelée moins souvent, par exemple une fois par bougie.
Cette mesure a aussi un intérêt de diagnostic. Lorsque le journal montre des requotes répétées, comparer la durée de la fonction au rythme des cotations permet de distinguer deux causes très différentes : un code trop lent, que vous pouvez corriger, ou un marché très rapide, où le glissement toléré (paramètre slippage d’OrderSend()) est simplement trop faible pour les conditions du moment. Dans le second cas, augmenter le glissement accepté est un choix de gestion du risque, pas une correction technique : il signifie accepter d’être exécuté à un prix moins favorable.
Erreurs fréquentes
- Appeler RefreshRates sans relire les prix. La fonction met à jour
Ask, mais si votre code a copiéAskdans une variable locale avant l’appel, cette copie reste ancienne. Relisez la variable prédéfinie après le rafraîchissement. - L’appeler à chaque ligne. Ce n’est ni utile ni gratuit. Un appel juste avant l’utilisation du prix suffit.
- Croire qu’elle corrige toutes les erreurs de prix. Un prix non normalisé, un stop trop proche (erreur 130) ou un volume mal arrondi ne seront pas réglés par un rafraîchissement.
- Boucler sans limite. Une boucle de tentatives infinie sur un marché fermé bloque l’EA. Fixez un nombre maximal d’essais.
Et en MQL5 ?
RefreshRates() n’existe pas en MQL5. Comme il n’y a pas de variables Bid et Ask prédéfinies, chaque appel à SymbolInfoDouble() ou SymbolInfoTick() lit la dernière cotation connue du terminal : il suffit de relire le prix avant chaque nouvelle tentative. La classe CTrade le fait d’ailleurs pour vous lorsqu’on lui passe un prix nul sur un ordre au marché. Voir Migration de MQL4 vers MQL5 pour les autres équivalences.
FAQ
RefreshRates est-il nécessaire dans le testeur de stratégie ?
Dans le testeur, le temps est simulé et les prix n’évoluent pas pendant l’exécution de votre fonction. L’appel ne gêne pas, et conserver le même code pour le test et le réel est la pratique la plus sûre.
RefreshRates renvoie false, mon ordre va-t-il échouer ?
Non. false signifie qu’aucune nouvelle cotation n’est arrivée : les prix en mémoire sont déjà les plus récents et peuvent être utilisés.
Faut-il appeler RefreshRates avant OrderModify ?
Si du temps s’est écoulé et que votre calcul de stop dépend de Bid ou Ask (trailing stop, break-even), oui. Un stop calculé sur un prix périmé peut se retrouver trop proche du marché réel et être refusé.
