Introduction : pourquoi la gestion des erreurs est cruciale en MQL5

Dans le trading algorithmique, chaque milliseconde compte, mais une seule erreur non gérée peut ruiner des semaines d’optimisation. Sur MetaTrader 5, les ordres échouent pour des raisons variées : slippage excessif, volatilité soudaine, ou simple indisponibilité du serveur. Ignorer ces échecs, c’est risquer des positions manquées ou, pire, des trades fantômes qui désynchronisent votre stratégie.

Une gestion erreurs MQL5 codes trade efficace ne se limite pas à afficher un message dans le journal. Elle implique de comprendre chaque code d’erreur, d’anticiper les causes racines, et de mettre en place des mécanismes de retry automatique intelligents. Cet article vous offre une méthodologie complète, des bases théoriques aux implémentations concrètes, pour que vos Expert Advisors (EA) deviennent résilients face aux aléas du marché.

Promesse : à la fin de cette lecture, vous saurez interpréter les codes d’erreur de trading MQL5, construire une boucle de retry avec backoff exponentiel, et éviter les pièges courants qui paralysent les EA novices.

1. Décoder les codes d’erreur trade MQL5

Avant de penser au retry, il faut comprendre ce que le terminal vous dit. Les codes d’erreur de trading MQL5 sont renvoyés par les fonctions comme OrderSend() ou PositionOpen(). Voici les plus critiques à connaître :

1. TRADE_RETCODE_NO_ERROR (10004) : Succès. L’ordre a été exécuté sans problème. Votre gestion des erreurs doit simplement confirmer et passer à la suite.
2. TRADE_RETCODE_REJECT (10006) : Rejet général. Le courtier a refusé l’ordre pour une raison non spécifiée. Cause fréquente : paramètres invalides ou problème de liquidité.
3. TRADE_RETCODE_INVALID_PRICE (10015) : Prix invalide. Le prix demandé n’est plus dans le marché. Ce code est votre allié pour détecter le slippage ou les gaps.
4. TRADE_RETCODE_INVALID_STOPS (10016) : Stop Loss/Take Profit invalides. Souvent dû à des niveaux trop proches du marché ou hors des limites du courtier.
5. TRADE_RETCODE_MARKET_CLOSED (10019) : Marché fermé. Inutile de retenter immédiatement, attendez la prochaine session.
6. TRADE_RETCODE_TOO_MANY_REQUESTS (10026) : Trop de requêtes. Le serveur vous limite. Un retry immédiat aggraverait la situation.

Pour intercepter ces erreurs, utilisez GetLastError() après chaque tentative d’ordre. Exemple basique :

// Exemple de vérification d'erreur après un ordre
MqlTradeRequest request = {0};
MqlTradeResult result = {0};
request.action = TRADE_ACTION_DEAL;
request.symbol = _Symbol;
request.volume = 0.1;
request.type = ORDER_TYPE_BUY;
request.price = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
request.deviation = 10;

if(OrderSend(request, result))
{
   if(result.retcode == TRADE_RETCODE_DONE)
      Print("Ordre exécuté avec succès");
   else
      Print("Erreur trade : ", result.retcode, " - ", result.comment);
}
else
{
   Print("Erreur d'envoi : ", GetLastError());
}

Ce décodage est la première étape d’une gestion erreurs MQL5 codes trade professionnelle. Sans lui, votre EA navigue à l’aveugle.

2. Implémenter un système de retry automatique intelligent

Un retry automatique ne signifie pas spammer le serveur. Au contraire, il doit être “intelligent” : adaptatif, limité dans le temps, et conscient des causes d’échec. Voici comment construire une boucle de retry robuste en MQL5 :

1. Définir un nombre maximum de tentatives : 3 à 5 tentatives suffisent généralement. Au-delà, le problème est probablement persistant (marché fermé, compte bloqué).
2. Utiliser un délai progressif (backoff exponentiel) : Attendre 500ms, puis 1s, puis 2s… Cela évite de surcharger le serveur et de déclencher le code d’erreur TOO_MANY_REQUESTS.
3. Analyser le code d’erreur pour décider : Un INVALID_PRICE mérite une mise à jour du prix avant retry. Un MARKET_CLOSED doit stopper la boucle.

Exemple de fonction de retry avec backoff :

// Fonction de retry avec backoff exponentiel
bool PlaceOrderWithRetry(MqlTradeRequest &request, int maxAttempts = 5)
{
   MqlTradeResult result;
   int attempts = 0;
   int delay = 500; // millisecondes

   while(attempts < maxAttempts)
   {
      if(OrderSend(request, result))
      {
         if(result.retcode == TRADE_RETCODE_DONE)
            return true;
         else
         {
            Print("Tentative ", attempts+1, " échouée. Code : ", result.retcode);
            // Arrêt immédiat pour certains codes
            if(result.retcode == TRADE_RETCODE_MARKET_CLOSED ||
               result.retcode == TRADE_RETCODE_TOO_MANY_REQUESTS)
               break;
            // Mise à jour du prix pour INVALID_PRICE
            if(result.retcode == TRADE_RETCODE_INVALID_PRICE)
               request.price = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
         }
      }
      else
      {
         Print("Erreur système : ", GetLastError());
         if(GetLastError() == 4109) // Trade context busy
            Sleep(delay);
      }

      attempts++;
      Sleep(delay);
      delay *= 2; // backoff exponentiel
   }
   return false;
}

Cette approche garantit que votre EA ne gaspille pas de ressources et s’adapte aux conditions changeantes du marché. C’est le cœur d’une gestion erreurs MQL5 codes trade efficace.

3. Gérer les erreurs spécifiques aux ordres en attente et aux positions

La gestion des erreurs ne se limite pas à l’ouverture d’ordres. Les modifications et fermetures de positions sont tout aussi sujettes aux échecs. Voici comment étendre votre système de retry à ces cas :

1. Modification d’ordre (SL/TP) : L’erreur INVALID_STOPS (10016) est fréquente. Avant de retenter, recalculer les niveaux avec les nouvelles conditions de marché. Utilisez SymbolInfoInteger(_Symbol, SYMBOL_TRADE_STOPS_LEVEL) pour connaître la distance minimale autorisée.
2. Fermeture de position : L’erreur TRADE_RETCODE_POSITION_CLOSED (10025) indique que la position n’existe plus (fermeture manuelle ou stop loss déclenché). Dans ce cas, pas de retry : la position est déjà fermée.
3. Ordres en attente (pending orders) : Les codes INVALID_PRICE ou INVALID_VOLUME sont courants. Assurez-vous que le volume respecte les limites du courtier via SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN) et SYMBOL_VOLUME_STEP.

Exemple de gestion pour la fermeture :

// Fonction de fermeture avec retry
bool ClosePositionWithRetry(ulong ticket, int maxAttempts = 3)
{
   MqlTradeRequest request = {0};
   MqlTradeResult result;
   int delay = 300;

   for(int i = 0; i < maxAttempts; i++)
   {
      if(PositionSelectByTicket(ticket))
      {
         request.action = TRADE_ACTION_DEAL;
         request.position = ticket;
         request.symbol = PositionGetString(POSITION_SYMBOL);
         request.volume = PositionGetDouble(POSITION_VOLUME);
         request.type = (PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY) ? ORDER_TYPE_SELL : ORDER_TYPE_BUY;
         request.price = (request.type == ORDER_TYPE_SELL) ? SymbolInfoDouble(_Symbol, SYMBOL_BID) : SymbolInfoDouble(_Symbol, SYMBOL_ASK);
         request.deviation = 50;

         if(OrderSend(request, result))
         {
            if(result.retcode == TRADE_RETCODE_DONE)
               return true;
            else if(result.retcode == TRADE_RETCODE_POSITION_CLOSED)
               return true; // déjà fermée
            else
               Print("Échec fermeture : ", result.retcode);
         }
      }
      else
         return false; // ticket invalide

      Sleep(delay);
      delay *= 2;
   }
   return false;
}

En adaptant votre logique de retry au type d’opération, vous couvrez tous les scénarios de votre EA. C’est une gestion erreurs MQL5 codes trade complète et professionnelle.

4. Journalisation avancée et monitoring des erreurs

Un EA qui retente sans journaliser est un EA qui cache ses faiblesses. Pour améliorer votre gestion erreurs MQL5 codes trade sur le long terme, mettez en place un système de logging structuré :

1. Enregistrer chaque tentative : Timestamp, symbole, action, code d’erreur, commentaire du serveur. Utilisez un fichier CSV ou une base de données SQLite via FileOpen().
2. Catégoriser les erreurs : Séparez les erreurs “récupérables” (INVALID_PRICE, TOO_MANY_REQUESTS) des erreurs “fatales” (MARKET_CLOSED, REJECT). Cela permet d’ajuster dynamiquement le nombre de retry.
3. Analyser les patterns : Si une erreur INVALID_STOPS survient systématiquement sur un symbole, votre EA a probablement un bug de calcul des niveaux. Le logging vous le révélera.

Exemple de fonction de logging :

// Fonction de logging des erreurs
void LogTradeError(string symbol, int retcode, string comment, int attempt)
{
   string filename = "TradeErrors_" + _Symbol + ".csv";
   int handle = FileOpen(filename, FILE_WRITE|FILE_CSV|FILE_READ, ",");
   if(handle != INVALID_HANDLE)
   {
      FileSeek(handle, 0, SEEK_END);
      FileWrite(handle, TimeToString(TimeCurrent()), symbol, retcode, comment, attempt);
      FileClose(handle);
   }
}

Ce niveau de détail transforme votre gestion des erreurs en outil d’optimisation continue. Vous pourrez même détecter des problèmes de courtier ou de connectivité avant qu’ils n’impactent vos performances.

Besoin d’un EA sur-mesure ? Demander un devis gratuit