Besoin d'aide pour le codage - page 15

[Rumixtrade]

Bonjour j'ai fait un robot qui fait du micro trading mais le problème c'est que il ne faut aucun profit j'aimerais si possible que vous m'aidiez a l'améliorer svp 

Voici le code : 

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

//| PredictiveCandleEA.mq5 |

//| Prédiction et trading avant une nouvelle bougie M1 |

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

// Paramètres d'entrée personnalisés

input double LotSize = 0.01; // Taille du lot pour les trades

input double MaxProfit = 0.50; // Gain maximum par trade en euros (50 centimes)

input double MaxLoss = 0.20; // Perte maximum par trade en euros (20 centimes)

input int LookBackCandles = 5; // Nombre de bougies à analyser pour prédiction

input int Slippage = 2; // Slippage acceptable en points

// Variables globales

double pointValue; // Valeur d'un point pour le symbole courant

datetime lastCandleTime; // Heure de la dernière bougie traitée

bool tradeOpen = false; // Indique si un trade est ouvert

ulong openedTicket = 0; // Ticket de la position ouverte

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

//| Initialisation de l'Expert |

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

int OnInit()

{

    // Initialiser l'heure de la dernière bougie

    lastCandleTime = iTime(_Symbol, PERIOD_M1, 0);

    // Calcul de la valeur d'un point en fonction du symbole

    pointValue = SymbolInfoDouble(_Symbol, SYMBOL_POINT);

    Print("EA démarré avec les paramètres suivants : LotSize = ", DoubleToString(LotSize, 2), ", MaxProfit = ", DoubleToString(MaxProfit, 2), " euros, MaxLoss = ", DoubleToString(MaxLoss, 2), " euros, LookBackCandles = ", LookBackCandles);

    return(INIT_SUCCEEDED);

}

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

//| Fonction principale OnTick |

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

void OnTick()

{

    // Vérifier si la bougie en cours est différente de la dernière bougie traitée

    datetime currentCandleTime = iTime(_Symbol, PERIOD_M1, 0);

    if(currentCandleTime != lastCandleTime)

    {

        // Mettre à jour la dernière bougie traitée

        lastCandleTime = currentCandleTime;

        // Fermer le trade actuel s'il est ouvert et profitable

        if(tradeOpen && IsTradeProfitable())

        {

            CloseTrade();

        }

        // Prédire la direction de la prochaine bougie et ouvrir un trade

        PredictAndTrade();

    }

}

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

//| Fonction qui prédit la direction de la prochaine bougie |

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

void PredictAndTrade()

{

    double momentum = 0;

    // Analyser les dernières bougies pour calculer le momentum

    for(int i = 1; i <= LookBackCandles; i++)

    {

        double openPrice = iOpen(_Symbol, PERIOD_M1, i);

        double closePrice = iClose(_Symbol, PERIOD_M1, i);

        momentum += (closePrice - openPrice); // Calcul du momentum

    }

    // Ouvrir un trade en fonction de la prédiction du momentum

    if(momentum > 0)

    {

        // Prédiction : La prochaine bougie sera haussière, on ouvre un trade BUY

        OpenBuyTrade();

    }

    else if(momentum < 0)

    {

        // Prédiction : La prochaine bougie sera baissière, on ouvre un trade SELL

        OpenSellTrade();

    }

    else

    {

        Print("Momentum neutre, aucun trade ouvert.");

    }

}

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

//| Fonction qui ouvre un trade BUY |

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

void OpenBuyTrade()

{

    MqlTradeRequest request;

    MqlTradeResult result;

    ZeroMemory(request);

    ZeroMemory(result);

    // Calculer le TP et SL en fonction du profit maximal et de la perte maximale

    double tpPoints = (MaxProfit / (LotSize * pointValue));

    double slPoints = (MaxLoss / (LotSize * pointValue));

    double tpLevel = SymbolInfoDouble(_Symbol, SYMBOL_ASK) + tpPoints * pointValue;

    double slLevel = SymbolInfoDouble(_Symbol, SYMBOL_BID) - slPoints * pointValue;

    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 = LotSize;

    request.deviation = Slippage;

    request.type_filling = ORDER_FILLING_IOC;

    if(OrderSend(request, result))

    {

        tradeOpen = true;

        openedTicket = result.order;

        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 qui ouvre un trade SELL |

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

void OpenSellTrade()

{

    MqlTradeRequest request;

    MqlTradeResult result;

    ZeroMemory(request);

    ZeroMemory(result);

    // Calculer le TP et SL en fonction du profit maximal et de la perte maximale

    double tpPoints = (MaxProfit / (LotSize * pointValue));

    double slPoints = (MaxLoss / (LotSize * pointValue));

    double tpLevel = SymbolInfoDouble(_Symbol, SYMBOL_BID) - tpPoints * pointValue;

    double slLevel = SymbolInfoDouble(_Symbol, SYMBOL_ASK) + slPoints * pointValue;

    request.action = TRADE_ACTION_DEAL;

    request.type = ORDER_TYPE_SELL;

    request.price = SymbolInfoDouble(_Symbol, SYMBOL_BID);

    request.sl = slLevel;

    request.tp = tpLevel;

    request.symbol = _Symbol;

    request.volume = LotSize;

    request.deviation = Slippage;

    request.type_filling = ORDER_FILLING_IOC;

    if(OrderSend(request, result))

    {

        tradeOpen = true;

        openedTicket = result.order;

        Print("Trade SELL ouvert à ", request.price, " avec SL: ", request.sl, " et TP: ", request.tp);

    }

    else

    {

        Print("Erreur lors de l'ouverture du trade SELL : ", result.retcode);

    }

}

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

//| Fonction qui vérifie si le trade est profitable |

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

bool IsTradeProfitable()

{

    if(PositionSelectByTicket(openedTicket))

    {

        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(PositionSelectByTicket(openedTicket))

    {

        ulong ticket = PositionGetInteger(POSITION_TICKET);

        request.action = TRADE_ACTION_DEAL;

        request.position = ticket;

        request.symbol = _Symbol;

        request.volume = PositionGetDouble(POSITION_VOLUME);

        request.type = (PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY) ? ORDER_TYPE_SELL : ORDER_TYPE_BUY;

        request.price = (PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY) ? SymbolInfoDouble(_Symbol, SYMBOL_BID) : SymbolInfoDouble(_Symbol, SYMBOL_ASK);

        request.deviation = Slippage;

        request.type_filling = ORDER_FILLING_IOC;

        if(OrderSend(request, result))

        {

            Print("Position fermée avec succès : ", result.price);

            tradeOpen = false;

        }

        else

        {

            Print("Erreur lors de la fermeture de la position : ", result.retcode);

        }

    }

}

[Rumixtrade]

Bonjour,

J'ai un robot ici qui ne fonctionne pas comme je le voulais,

Je voulais qu'il trade avec les bougies,

En Analysant avec plusieurs indicateurs,si la bougie est verte alors il ouvre un achat..et arrête le trade avant un bougie rouge et ensuite il ouvre une vente et arrête le trade si il y a une bougie verte 

je arrête le trade pour garder le profit,

Rajouter pas mal d'indicateurs sur le robot mais j'ai l'impression que cela n'a pas aider dans ses trade ,

Si peut m'aider a le corriger svp 

Pour le rendre rentable 

[heddyApie3211]

Bonjour chers amis.

J'ai besoin d'aide pour m'aider à corriger les erreurs sur ce expert que j'essai de coder. je sis en novice en matière de codage et votre aide me permettra de tester le code. Merci d'avance.

Voici le code en question

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

//|                                             StochasticEA.mq5      |

//|                       Copyright 2024, Your Name                  |

//|                                        https://www.mql5.com       |

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

#include <Trade\Trade.mqh>

CTrade trade;  // Instance pour gérer les ordres

//--- Paramètres de l'EA

input double InitialLotSize = 0.1;  // Taille initiale des lots

input int StopLoss = 100;           // Stop loss en points

input int TakeProfit = 100;         // Take profit en points

input int MagicNumber = 123456;     // Numéro magique pour identifier les ordres

double LotSize;                     // Variable pour la taille actuelle des lots

double prevMainLine, prevSignalLine;  // Valeurs des barres précédentes

double mainLine, signalLine;          // Valeurs actuelles

// Variable pour mémoriser si la position précédente était en perte

bool LastTradeInLoss = false;

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

//| Fonction d'initialisation de l'EA                                |

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

int OnInit()

  {

   LotSize = InitialLotSize;  // Initialiser la taille des lots

   return(INIT_SUCCEEDED);

  }

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

//| Fonction principale exécutée à chaque tick                       |

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

void OnTick()

  {

   // Récupération des signaux de l'indicateur Stochastic (%K et %D)

   mainLine = iCustom(NULL, 0, "Stochastic", 5, 3, 3, 0, 0);  // Ligne principale %K

   signalLine = iCustom(NULL, 0, "Stochastic", 5, 3, 3, 1, 0); // Ligne de signal %D

   // Récupération des valeurs à la barre précédente (pour vérifier le croisement)

   prevMainLine = iCustom(NULL, 0, "Stochastic", 5, 3, 3, 0, 1);  // Ligne principale %K (barre précédente)

   prevSignalLine = iCustom(NULL, 0, "Stochastic", 5, 3, 3, 1, 1); // Ligne de signal %D (barre précédente)

   // Vérifier si une position est déjà ouverte

   if (PositionsTotal() > 0)

   {

      ulong ticket = PositionGetTicket();

      double currentProfit = PositionGetDouble(POSITION_PROFIT);

      // Si une position d'achat est ouverte

      if (PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY)

      {

         // Fermer l'achat et ouvrir une vente lorsque la ligne %K coupe à la baisse la ligne %D

         if (prevMainLine > prevSignalLine && mainLine < signalLine)

         {

            // Fermer la position

            trade.PositionClose(ticket);

            // Appliquer martingale en cas de perte

            if (currentProfit < 0)

            {

               LotSize *= 1.5;

               LastTradeInLoss = true;

            }

            else

            {

               LotSize = InitialLotSize;

               LastTradeInLoss = false;

            }

            // Ouvrir une nouvelle position de vente

            trade.Sell(LotSize, NULL, Bid, StopLoss * _Point, TakeProfit * _Point, "Stochastic Sell");

         }

      }

      // Si une position de vente est ouverte

      else if (PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL)

      {

         // Fermer la vente et ouvrir un achat lorsque la ligne %K coupe à la hausse la ligne %D

         if (prevMainLine < prevSignalLine && mainLine > signalLine)

         {

            // Fermer la position

            trade.PositionClose(ticket);

            // Appliquer martingale en cas de perte

            if (currentProfit < 0)

            {

               LotSize *= 1.5;

               LastTradeInLoss = true;

            }

            else

            {

               LotSize = InitialLotSize;

               LastTradeInLoss = false;

            }

            // Ouvrir une nouvelle position d'achat

            trade.Buy(LotSize, NULL, Ask, StopLoss * _Point, TakeProfit * _Point, "Stochastic Buy");

         }

      }

   }

   // Si aucune position n'est ouverte

   else

   {

      // Ouvrir une position d'achat lorsque la ligne %K coupe à la hausse la ligne %D

      if (prevMainLine < prevSignalLine && mainLine > signalLine)

      {

         trade.Buy(LotSize, NULL, Ask, StopLoss * _Point, TakeProfit * _Point, "Stochastic Buy");

      }

      // Ouvrir une position de vente lorsque la ligne %K coupe à la baisse la ligne %D

      else if (prevMainLine > prevSignalLine && mainLine < signalLine)

      {

         trade.Sell(LotSize, NULL, Bid, StopLoss * _Point, TakeProfit * _Point, "Stochastic Sell");

      }

   }

  }

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

//| Fonction de terminaison                                           |

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

void OnDeinit(const int reason)

  {

   // Code à exécuter lors de la fermeture de l'EA

  }