avis sur mon robot

Nouveau commentaire
 

j'ai créé un robot et j'aimerais avoir vos avis


//+------------------------------------------------------------------+

//| BougieTrader.mq5|
//| Copyright 2024, MetaTrader 5 |
//| |
//+------------------------------------------------------------------+
#include <Trade/Trade.mqh>
CTrade trade;

// Paramètres de l'expert
input double Lots = 0.1; // Taille du lot
input int StopLoss = 50; // Stop Loss en points
input int TakeProfit = 100; // Take Profit en points
input int Slippage = 2; // Slippage en points
input int RSI_Period = 14; // Période de calcul du RSI
input int MACD_FastEMA = 12; // Période de l'EMA rapide du MACD
input int MACD_SlowEMA = 26; // Période de l'EMA lente du MACD
input int MACD_SignalSMA = 9; // Période de la ligne de signal du MACD

// Variables globales
double rsiValue, macdValue, signalValue, macdHist;
datetime lastCandleTime; // Heure de la dernière bougie traitée
bool potentialBuySignal = false; // Indique s'il y a un signal d'achat potentiel

// Fonction d'initialisation
int OnInit()
{
   // Initialiser l'heure de la dernière bougie
   lastCandleTime = iTime(Symbol(), PERIOD_M1, 0);

   // Initialisation réussie
   return(INIT_SUCCEEDED);
}

// Fonction principale de l'expert
void OnTick()
{
   // Obtenir les prix de la bougie actuelle
   double openCurrent = iOpen(Symbol(), PERIOD_M1, 0);
   double closeCurrent = iClose(Symbol(), PERIOD_M1, 0);
   double currentPrice = SymbolInfoDouble(Symbol(), SYMBOL_BID);
   datetime currentCandleTime = iTime(Symbol(), PERIOD_M1, 0);

   // Calculer les indicateurs techniques
   rsiValue = iRSI(Symbol(), PERIOD_M1, RSI_Period, 0);

   // Gestion de MACD
   int macdHandle = iMACD(Symbol(), PERIOD_M1, MACD_FastEMA, MACD_SlowEMA, MACD_SignalSMA, PRICE_CLOSE);
   double macdBuffer[], signalBuffer[];
   CopyBuffer(macdHandle, 0, 0, 1, macdBuffer); // 0 pour la ligne MACD
   CopyBuffer(macdHandle, 1, 0, 1, signalBuffer); // 1 pour la ligne de signal

   macdValue = macdBuffer[0];
   signalValue = signalBuffer[0];
   macdHist = macdValue - signalValue;

   // Si la bougie actuelle est différente de la dernière bougie traitée
   if (currentCandleTime != lastCandleTime)
   {
       lastCandleTime = currentCandleTime;

       // Réinitialiser le signal d'achat potentiel pour la nouvelle bougie
       potentialBuySignal = false;

       // Fermer le trade actuel s'il est ouvert et profitable
       if (PositionSelect(Symbol()) && IsTradeProfitable())
       {
           CloseTrade();
       }
   }

   // Vérifier si une position est ouverte
   bool hasPosition = PositionSelect(Symbol());

   // Analyse en temps réel : si la bougie tend au vert et que les indicateurs sont favorables, préparer un signal d'achat
   if (!hasPosition && !potentialBuySignal && PredictGreenCandle())
   {
       potentialBuySignal = true;
       Print("Signal d'achat potentiel détecté.");
   }

   // Si le signal d'achat est confirmé par la tendance haussière de la bougie actuelle, ouvrir un trade
   if (potentialBuySignal && closeCurrent > openCurrent)
   {
       OpenBuyTrade();
       potentialBuySignal = false;  // Réinitialiser le signal après l'achat
   }

   // Stratégie de vente si la bougie est rouge ou si on prédit une bougie rouge
   if (hasPosition && (closeCurrent < openCurrent || PredictRedCandle()))
   {
       Print("La bougie actuelle tourne au rouge, fermeture de la position.");
       CloseTrade();
   }
}

// Fonction qui ouvre un trade BUY
void OpenBuyTrade()
{
   MqlTradeRequest request;
   MqlTradeResult result;
   ZeroMemory(request);
   ZeroMemory(result);

   double tpPoints = (TakeProfit * _Point);
   double slPoints = (StopLoss * _Point);

   double tpLevel = SymbolInfoDouble(Symbol(), SYMBOL_ASK) + tpPoints;
   double slLevel = SymbolInfoDouble(Symbol(), SYMBOL_BID) - slPoints;

   request.action = TRADE_ACTION_DEAL;
   request.type = ORDER_TYPE_BUY;
   request.price = SymbolInfoDouble(Symbol(), SYMBOL_ASK);
   request.sl = slLevel;
   request.tp = tpLevel;
   request.symbol = Symbol();
   request.volume = Lots;
   request.deviation = Slippage;
   request.type_filling = ORDER_FILLING_IOC;

   if (OrderSend(request, result))
   {
       Print("Trade BUY ouvert à ", request.price, " avec SL: ", request.sl, " et TP: ", request.tp);
   }
   else
   {
       Print("Erreur lors de l'ouverture du trade BUY : ", result.retcode);
   }
}

// Fonction pour vérifier si le trade est profitable
bool IsTradeProfitable()
{
   if (PositionSelect(Symbol()))
   {
       double profit = PositionGetDouble(POSITION_PROFIT);
       return profit > 0;
   }
   return false;
}

// Fonction pour fermer un trade
void CloseTrade()
{
   MqlTradeRequest request;
   MqlTradeResult result;
   ZeroMemory(request);
   ZeroMemory(result);

   if (PositionSelect(Symbol()))
   {
       ulong ticket = PositionGetInteger(POSITION_TICKET);

       request.action = TRADE_ACTION_DEAL;
       request.position = ticket;
       request.symbol = Symbol();
       request.volume = PositionGetDouble(POSITION_VOLUME);
       request.type = ORDER_TYPE_SELL;
       request.price = SymbolInfoDouble(Symbol(), SYMBOL_BID);
       request.deviation = Slippage;
       request.type_filling = ORDER_FILLING_IOC;

       if (OrderSend(request, result))
       {
           Print("Position fermée avec succès : ", result.price);
       }
       else
       {
           Print("Erreur lors de la fermeture de la position : ", result.retcode);
       }
   }
}

// Fonction de prédiction pour une bougie verte
bool PredictGreenCandle()
{
   if (rsiValue > 30 && macdHist > 0)
   {
       return true;
   }
   return false;
}

// Fonction de prédiction pour une bougie rouge
bool PredictRedCandle()
{
   if (rsiValue < 70 && macdHist < 0)
   {
       return true;
   }
   return false;
}

// Fonction de déinitialisation
void OnDeinit(const int reason)
{
   // Nettoyage
}
 

Salut, je débute mais en lisant en diagonale pourquoi ne charges-tu pas ton indicateur dans init ? c'est-à-dire ton handle MACD.

Cela me semble très curieux que tu le charge au tick.

Vérifie bien ce que tu ne dois charger qu'une fois et le mettre dans init.

 

En fait le standard c'est variables handle et buffer déclarées en global

handle chargés dans init

buffer chargés sur chaque évènement tick

utiliser MACD et RSI je ne suis pas trop fan, un filtre (sur un indicateur) et un signal.

Il faut voir dans ton cas si c'est vraiment utilise d'avoir MACD et RSI par contre MACD et ATR ou RSI et ATR

mais tes arguments m'interessent, je n'ai que moins de 18 mois de trading à mon actif.

 
olivierjfra #:

En fait le standard c'est variables handle et buffer déclarées en global

handle chargés dans init

buffer chargés sur chaque évènement tick

utiliser MACD et RSI je ne suis pas trop fan, un filtre (sur un indicateur) et un signal.

Il faut voir dans ton cas si c'est vraiment utilise d'avoir MACD et RSI par contre MACD et ATR ou RSI et ATR

mais tes arguments m'interessent, je n'ai que moins de 18 mois de trading à mon actif.

binjour, je n'aivais eu ce point de vu et je pensais le miens plus judicieux mais après reflexion le tiens est pas mal je te remercie
Nouveau commentaire