Rumixtrade / Profil

bonjour lors de l'instalation j'ai un warring est ce que quelqu'un pourrait me dire comment l'enlever ??

voici le robot:
//+------------------------------------------------------------------+
//| MicroTradeEA |
//| Copyright 2024, Votre Nom |
//| http://www.votresite.com |
//+------------------------------------------------------------------+
#include

input double LotSize = 0.02; // Taille du lot
input int BollingerPeriod = 20; // Période des Bandes de Bollinger
input double BollingerDeviation = 2.0; // Déviation des Bandes de Bollinger
input double MinCandleLength = 10; // Longueur minimale de la bougie en points
input int MagicNumber = 123456; // Numéro magique pour identifier les ordres

CTrade trade;

//+------------------------------------------------------------------+
//| Fonction d'initialisation de l'expert |
//+------------------------------------------------------------------+
int OnInit()
{
// Code d'initialisation ici
return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Fonction de désinitialisation de l'expert |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
// Code de désinitialisation ici
}
//+------------------------------------------------------------------+
//| Fonction de gestion des ticks de l'expert |
//+------------------------------------------------------------------+
void OnTick()
{
static datetime lastCandleTime = 0;

// Vérifier si une nouvelle bougie s'est formée
if (lastCandleTime != iTime(_Symbol, PERIOD_M1, 0))
{
lastCandleTime = iTime(_Symbol, PERIOD_M1, 0);

// Fermer tous les trades ouverts lors de la nouvelle bougie
for (int i = PositionsTotal() - 1; i >= 0; i--)
{
ulong ticket = PositionGetTicket(i);
if (PositionSelectByTicket(ticket))
{
trade.PositionClose(ticket);
}
}
}

// Calculer les Bandes de Bollinger
int bollingerHandle = iBands(_Symbol, PERIOD_M1, BollingerPeriod, BollingerDeviation, 0, PRICE_CLOSE);

// Vérifier si le handle est valide
if (bollingerHandle == INVALID_HANDLE)
{
Print("Erreur lors de la création du handle des bandes de Bollinger");
return;
}

// Définir les tableaux pour les bandes supérieure et inférieure
double upperBand[1], lowerBand[1];

// Copier les données des bandes de Bollinger dans les tableaux
long copiedUpper = CopyBuffer(bollingerHandle, 1, 0, 1, upperBand);
long copiedLower = CopyBuffer(bollingerHandle, 2, 0, 1, lowerBand);

// Vérifier si les données ont été correctement copiées
if (copiedUpper <= 0 || copiedLower <= 0)
{
Print("Erreur lors du calcul des bandes de Bollinger");
return;
}

// Déterminer les caractéristiques de la bougie actuelle
double currentClose = iClose(_Symbol, PERIOD_M1, 0);
double currentOpen = iOpen(_Symbol, PERIOD_M1, 0);
double currentHigh = iHigh(_Symbol, PERIOD_M1, 0);
double currentLow = iLow(_Symbol, PERIOD_M1, 0);
double candleLength = MathAbs(currentHigh - currentLow) / _Point;

// Ne trader que si la bougie actuelle est suffisamment longue
if (candleLength < MinCandleLength)
return;

// Ouvrir des ordres tant que les conditions des bandes de Bollinger sont remplies
if (currentClose < lowerBand[0])
{
// Le prix est sous la bande inférieure, ouvrir un ordre d'achat
trade.Buy(LotSize, NULL, 0, 0, MagicNumber, "Achat sur bande de Bollinger inférieure");
}
else if (currentClose > upperBand[0])
{
// Le prix est au-dessus de la bande supérieure, ouvrir un ordre de vente
trade.Sell(LotSize, NULL, 0, 0, MagicNumber, "Vente sur bande de Bollinger supérieure");
}
}
//+------------------------------------------------------------------+

j'ai fait un robot mais j'ai trop de perte j'aimerais savoir si vous pouvez m'aider a l'améliorer et quels son vos avis

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

// Paramètres de l'expert
input double Lots = 0.01; // Taille du lot minimale
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
input int ATR_Period = 14; // Période de l'ATR pour gestion du SL/TP
input double RiskPercentage = 1.0; // Pourcentage du capital à risquer par trade (1% recommandé)
input int TrailingStopPoints = 10; // Points pour le Trailing Stop
input int ADX_Period = 14; // Période de l'ADX

// Variables globales
double rsiValue, macdValue, signalValue, macdHist, atrValue, adxValue;
double accountEquity;
datetime lastCandleTime; // Heure de la dernière bougie traitée

// Fonction d'initialisation
int OnInit()
{
lastCandleTime = iTime(Symbol(), PERIOD_CURRENT, 0);
accountEquity = AccountInfoDouble(ACCOUNT_EQUITY);
Print("EA initialisé, prêt à trader.");
return(INIT_SUCCEEDED);
}

// Fonction principale de l'expert
void OnTick()
{
datetime currentCandleTime = iTime(Symbol(), PERIOD_CURRENT, 0);

// Appliquer le trailing stop si une position est ouverte
if (PositionSelect(Symbol()))
{
ApplyTrailingStop();
}

// Vérifier si la position actuelle est profitable et la fermer si c'est le cas
bool hasPosition = PositionSelect(Symbol());
if (hasPosition && IsTradeProfitable())
{
Print("Position profitable détectée, fermeture pour sécuriser le profit.");
CloseTrade();
}

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

int macdHandle = iMACD(Symbol(), PERIOD_CURRENT, 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;

int atrHandle = iATR(Symbol(), PERIOD_CURRENT, ATR_Period);
double atrBuffer[];
if (CopyBuffer(atrHandle, 0, 0, 1, atrBuffer) > 0)
{
atrValue = atrBuffer[0];
}

// Calcul de l'ADX
int adxHandle = iADX(Symbol(), PERIOD_CURRENT, ADX_Period);
double adxBuffer[];
if (CopyBuffer(adxHandle, 0, 0, 1, adxBuffer) > 0)
{
adxValue = adxBuffer[0];
}

// Filtrer les trades basés sur l'ADX (vérifier que la tendance est suffisamment forte)
if (adxValue > 20)
{
// Prédiction d'une hausse (BUY)
if (PredictGreenCandle())
{
Print("Prédiction de hausse détectée avec confirmation ADX.");

// Fermer la position actuelle si elle existe et est une position SELL
if (hasPosition && PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL)
{
CloseTrade();
}

// Ouvrir une position d'achat
if (!hasPosition)
{
Buy();
}
}

// Prédiction d'une baisse (SELL)
else if (PredictRedCandle())
{
Print("Prédiction de baisse détectée avec confirmation ADX.");

// Fermer la position actuelle si elle existe et est une position BUY
if (hasPosition && PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY)
{
CloseTrade();
}

// Ouvrir une position de vente
if (!hasPosition)
{
Sell();
}
}
}
}

// Fonction pour ajuster dynamiquement les niveaux de SL et TP
void AdjustStopLossAndTakeProfit(double &slPoints, double &tpPoints)
{
// Exemple d'ajustement basé sur la volatilité (ATR)
// Si l'ADX est élevé (tendance forte), on peut viser un TP plus éloigné et un SL plus serré
if (adxValue > 30)
{
slPoints = atrValue * 0.75; // Réduire le SL si la tendance est forte
tpPoints = atrValue * 4; // Augmenter le TP si la tendance est forte
}
// Si l'ADX est faible (tendance faible), on prend un SL plus large et un TP plus proche
else if (adxValue < 20)
{
slPoints = atrValue * 1.5; // Augmenter le SL si la tendance est faible
tpPoints = atrValue * 2; // Réduire le TP si la tendance est faible
}
// Conditions normales
else
{
slPoints = atrValue * 1; // Valeur standard du SL
tpPoints = atrValue * 3; // Valeur standard du TP
}
}

// Fonction qui ouvre un trade d'achat (BUY)
void Buy()
{
MqlTradeRequest request;
MqlTradeResult result;
ZeroMemory(request);
ZeroMemory(result);

// Calculer le volume basé sur le risque
double riskAmount = (RiskPercentage / 100) * accountEquity;
double lotSize = riskAmount / (atrValue * 2);

// Définir SL et TP de manière dynamique
double tpPoints, slPoints;
AdjustStopLossAndTakeProfit(slPoints, tpPoints);

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 = MathMin(lotSize, Lots); // Utiliser le plus petit entre le calcul basé sur le risque et le lot fixé
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 qui ouvre un trade de vente (SELL)
void Sell()
{
MqlTradeRequest request;
MqlTradeResult result;
ZeroMemory(request);
ZeroMemory(result);

// Calculer le volume basé sur le risque
double riskAmount = (RiskPercentage / 100) * accountEquity;
double lotSize = riskAmount / (atrValue * 2);

// Définir SL et TP de manière dynamique
double tpPoints, slPoints;
AdjustStopLossAndTakeProfit(slPoints, tpPoints);

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

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 = MathMin(lotSize, Lots); // Utiliser le plus petit entre le calcul basé sur le risque et le lot fixé
request.deviation = Slippage;
request.type_filling = ORDER_FILLING_IOC;

if (OrderSend(request, result))
{
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 pour appliquer le Trailing Stop
void ApplyTrailingStop()
{
double stopLevel, currentPrice;

// Pour les positions d'achat (BUY)
if (PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY)
{
currentPrice = SymbolInfoDouble(Symbol(), SYMBOL_BID);
stopLevel = currentPrice - TrailingStopPoints * _Point;

if (stopLevel > PositionGetDouble(POSITION_SL))
{
if (!trade.PositionModify(PositionGetInteger(POSITION_TICKET), stopLevel, PositionGetDouble(POSITION_TP)))
{
Print("Erreur lors de la modification du Trailing Stop BUY : ", GetLastError());
}
}
}

// Pour les positions de vente (SELL)
else if (PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL)
{
currentPrice = SymbolInfoDouble(Symbol(), SYMBOL_ASK);
stopLevel = currentPrice + TrailingStopPoints * _Point;

if (stopLevel < PositionGetDouble(POSITION_SL))
{
if (!trade.PositionModify(PositionGetInteger(POSITION_TICKET), stopLevel, PositionGetDouble(POSITION_TP)))
{
Print("Erreur lors de la modification du Trailing Stop SELL : ", GetLastError());
}
}
}
}

// 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 = 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);
}
else
{
Print("Erreur lors de la fermeture de la position : ", result.retcode);
}
}
}

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

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

// Fonction de déinitialisation
void OnDeinit(const int reason)
{
Print("EA déinitialisé.");
}
n'hésiter pas à m'ecrire je reste disponible

Sujet ajouté avis sur mon robot

Bonjour, j'ai programmer une robot pour trader selon les bougie mais celui ci ne me fait que des perte quelqu'un pourrais m'aider pour savoir pourquoi

Sujet ajouté proble de robot de trading