Besoin d'aide pour le codage - page 15

Nouveau commentaire
 
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);
        }
    }
}
1...89101112131415
Nouveau commentaire