Bonjour à tous,

Je voudrai adapté cet EA à 5 décimales, est ce que quelqu'un pourrai m'aider ? il marche bien à 4 décimales.

merci d'avance.

voivci le code :

#include <stdlib.mqh>
#include <stderror.mqh>

extern string s1 = "====Basic settings====";
extern double Risk = 0.3;
extern double Lots = 0.01;
extern bool LotCalcOverBal = False;
extern double StopLoss = 100.0;
extern double TakeProfit = 45.0;
extern int Trailingstop = 5;
extern bool TickByTickTrailing = true;
extern bool RecoveryMode = true;
extern int RecoveryModeMulti = 2;
extern int SlipPage = 3;
extern int Magic = 4985;


extern string s2 = "====Time based filters====";
extern bool DayFilter = true;
extern int Day1 = 6;
extern int Day2 = 0;
extern int StartDayMonth = 1;
extern int StopDayMonth = 31;
extern bool HourFilter = False;
extern int GMTOffset = 3;
extern int Session1 = 1;
extern int Session2 = 0;
extern int Session3 = 0;
extern int Session1OpenHour = 0;
extern int Session1CloseHour = 0;
extern int Session2OpenHour = 0;
extern int Session2CloseHour = 0;
extern int Session3OpenHour = 0;
extern int Session3CloseHour = 0;


extern string s3 = "===Indicators logic and orders===";
extern int MaxOrders = 5;
extern int PipDifMin = 10;
extern double PerCCI1 = 14.0;
extern double CCIRange = 136.0;
extern double PerIMA1 = 80.0;
extern double PerIMA2 = 295.0;
extern double PerIMA3 = 588.0;
extern double IMATrendRate1 = 0.57;
extern double IMATrendRate2 = 0.13;
extern int PipsFromIMA2 = 1;
extern int PipsFromIMA = 12;
extern string s4 = "==== Extras ====";
extern string Comentario = " ";
extern color ColorTXT = Red;
extern bool showInfo = False;

datetime GMT;
int time;
int bandTiempo = 0;
double maxdd,maxpercentdd;
int banderaBalance=0;
bool BanderaRecover = true;
int SumaBeneficios = 0;
int cantidadOrdenesHistorial = 0;

double myPoint;

int deinit() {
Print("MaxDD: ",maxdd);
Print("MaxPercDD: ",maxpercentdd);
return(0);
}
int init() {
if (!IsTesting()) BanderaRecover = True;
myPoint = SetPoint(Symbol());
if (Digits == 5) {
StopLoss=StopLoss*10;
TakeProfit=TakeProfit*10;
SlipPage=SlipPage*10;
PipDifMin=PipDifMin*10;
IMATrendRate1=IMATrendRate1*10;
IMATrendRate2=IMATrendRate2*10;
PipsFromIMA=PipsFromIMA*10;
PipsFromIMA2=PipsFromIMA2*10;}
return (0);
}

int start() {

SumaBeneficios = 0;
if (BanderaRecover) {
BanderaRecover = false;
cantidadOrdenesHistorial = RecuperarOrdenes();
banderaBalance = SumaBeneficios;
Print("Ordenes en el historial: ", cantidadOrdenesHistorial, " beneficios: ", DoubleToStr(SumaBeneficios, 2));
}

while (Session1OpenHour<0) Session1OpenHour+=24;
while (Session1OpenHour>24) Session1OpenHour-=24;
if (Session1CloseHour<0) Session1CloseHour=Session1OpenHour-Session1CloseHour;
while (Session1CloseHour>24) Session1CloseHour-=24;
if (Session1CloseHour == 0) Session1CloseHour = 24;

while (Session2OpenHour<0) Session2OpenHour+=24;
while (Session2OpenHour>24) Session2OpenHour-=24;
if (Session2CloseHour<0) Session2CloseHour=Session2OpenHour-Session2CloseHour;
while (Session2CloseHour>24) Session2CloseHour-=24;
if (Session2CloseHour == 0) Session2CloseHour = 24;

while (Session3OpenHour<0) Session3OpenHour+=24;
while (Session3OpenHour>24) Session3OpenHour-=24;
if (Session3CloseHour<0) Session3CloseHour=Session3OpenHour-Session3CloseHour;
while (Session3CloseHour>24) Session3CloseHour-=24;
if (Session3CloseHour == 0) Session3CloseHour = 24;
GMT = TimeCurrent() - (GMTOffset * 3600);
time = GMT;


if (TickByTickTrailing){
//&&&&& TRAILING &&&&&&&&&&&&&&&&&&&&&&&&&
if(Trailingstop>0){Trailing();}
//&&&&& TRAILING &&&&&&&&&&&&&&&&&&&&&&&&&
}

double OpenProfit = AccountEquity()-AccountBalance();

if (OpenProfit<maxdd){ maxdd = OpenProfit;}
if ((OpenProfit/AccountBalance()*100)<maxpercentdd)
{ maxpercentdd = (OpenProfit/AccountBalance()*100);}


int ticket1;
if (Time[0] == bandTiempo) return (0);
bandTiempo = Time[0];
double puntos = Point;
bool Trading=true;
if (TimeDay(TimeCurrent())==Day1 && DayFilter) Trading=false;
if (TimeDay(TimeCurrent())==Day2 && DayFilter) Trading=false;

if (!TickByTickTrailing){
//&&&&& TRAILING &&&&&&&&&&&&&&&&&&&&&&&&&
if(Trailingstop>0){Trailing();}
//&&&&& TRAILING &&&&&&&&&&&&&&&&&&&&&&&&&
}


double Lots2=0;Lots=0;
Lots=MMLots(Risk, AccountFreeMargin());
if (LotCalcOverBal) Lots=MMLots(Risk, AccountBalance());
if (RecoveryMode){Lots=RecoveryLot(Lots);Lots2=Recove ryLot(Lots);}

//################################################## ############################################
//##########CONTROLO LA PERDIDA MAXIMA Y EL PORCENTAJE DE PERDIDA###############################

if (showInfo){
ObjectCreate( "B/E", OBJ_LABEL,0,0,0,0,0,0);
ObjectSet( "B/E", OBJPROP_CORNER,3);
ObjectSet( "B/E", OBJPROP_XDISTANCE, 3);
ObjectSet( "B/E", OBJPROP_YDISTANCE, 30);
ObjectSetText("B/E", "B/E: $"+DoubleToStr(NormalizeDouble(AccountBalance(),2) ,1)+"/"+DoubleToStr(NormalizeDouble(AccountEquity(),2),1 ),24,"Impact",ColorTXT);

ObjectCreate( "MaxDD", OBJ_LABEL,0,0,0,0,0,0);
ObjectSet( "MaxDD", OBJPROP_CORNER,3);
ObjectSet( "MaxDD", OBJPROP_XDISTANCE, 3);
ObjectSet( "MaxDD", OBJPROP_YDISTANCE, 2);
ObjectSetText("MaxDD", "RDD Máx: $"+DoubleToStr(NormalizeDouble(maxdd,2),1)+"/"+DoubleToStr(NormalizeDouble(maxpercentdd,2),1)+" %",24,"Impact",ColorTXT);
}

if (showInfo && Lots<Lots2 && RecoveryMode){
ObjectCreate( "Recover", OBJ_LABEL,0,0,0,0,0,0);
ObjectSet( "Recover", OBJPROP_CORNER,1);
ObjectSet( "Recover", OBJPROP_XDISTANCE, 3);
ObjectSet( "Recover", OBJPROP_YDISTANCE, 2);
ObjectSetText("Recover", "Recovery Mode Activated",24,"Impact",ColorTXT);
}
if (showInfo && (Lots>=Lots2 || !RecoveryMode) && ObjectFind("Recover")!=-1) ObjectDelete("Recover");


if (HourFilter && showInfo){
if (((IsTradeTime(1)!=1 || IsTradeTime(2)!=1 || IsTradeTime(3)!=1))) {

ObjectCreate( "Notrade", OBJ_LABEL,0,0,0,0,0,0);
ObjectSet( "Notrade", OBJPROP_CORNER,0);
ObjectSet( "Notrade", OBJPROP_XDISTANCE, 15);
ObjectSet( "Notrade", OBJPROP_YDISTANCE, 2);
ObjectSetText("Notrade", "No trading session, its "+TimeHour(TimeCurrent())+":"+TimeMinute(TimeCurre nt()),24,"Impact",ColorTXT);
}
if (((IsTradeTime(1) || IsTradeTime(2) || IsTradeTime(3)))) ObjectDelete("Notrade");
//}
}
//------------------------------------------------------------------------------------------------------
//================================================== ================================================== ==





double CCI1 = iCCI(NULL, 0, PerCCI1, PRICE_CLOSE, 0);
double CCI2 = iCCI(NULL, 0, PerCCI1, PRICE_CLOSE, 1);
double IMA11 = iMA(NULL, 0, PerIMA1, 0, MODE_SMA, PRICE_MEDIAN, 0);
double IMA12 = iMA(NULL, 0, PerIMA1, 0, MODE_SMA, PRICE_MEDIAN, 1);
double IMA21 = iMA(NULL, 0, PerIMA2, 0, MODE_SMA, PRICE_MEDIAN, 0);
double IMA22 = iMA(NULL, 0, PerIMA2, 0, MODE_SMA, PRICE_MEDIAN, 1);
double IMA31 = iMA(NULL, 0, PerIMA3, 0, MODE_SMA, PRICE_MEDIAN, 0);
double IMA32 = iMA(NULL, 0, PerIMA3, 0, MODE_SMA, PRICE_MEDIAN, 1);
int OpenOrders = 0;
double OrderOpenPrice1 = 0;
for (int i = 0; i < OrdersTotal(); i++) {
if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) {
if (OrderMagicNumber() == Magic) {
if (StringFind(OrderSymbol(), Symbol(), 0) != -1) {
OpenOrders++;
OrderOpenPrice1 = OrderOpenPrice();
if (OrderType() == OP_BUY && CCI2 > CCIRange && CCI1 < CCI2 && Bid - IMA11 > PipsFromIMA * myPoint) {
waitForContext();
OrderClose(OrderTicket(), OrderLots(), NormalizeDouble(Bid,Digits), SlipPage, Violet);
return (0);
}
if (OrderType() == OP_SELL && CCI2 < (-CCIRange) && CCI1 > CCI2 && Ask - IMA11 < (-PipsFromIMA) * myPoint) {
waitForContext();
OrderClose(OrderTicket(), OrderLots(), NormalizeDouble(Ask,Digits), SlipPage, Violet);
return (0);
}
}
}
}
}
if (OpenOrders < MaxOrders && TimeDay(TimeCurrent())<StopDayMonth && TimeDay(TimeCurrent())>StartDayMonth && (!HourFilter || IsTradeTime(1) || IsTradeTime(2) || IsTradeTime(3))) {


ticket1 = -10;
if (IMA21 - IMA22 > IMATrendRate1 * myPoint && IMA31 - IMA32 > IMATrendRate2 * myPoint && IMA11 > IMA21 && CCI2 < (-CCIRange) && CCI1 > CCI2 && Ask - IMA11 < (-PipsFromIMA2) * myPoint &&
OrderOpenPrice1 == 0.0 || Ask - OrderOpenPrice1 < (-PipDifMin) * myPoint && Trading) {
ticket1 = OpenTrade(OP_BUY, Lots, StopLoss, TakeProfit, Symbol() + " " + "BUY " + Comentario, Magic);
if (ticket1 > 0) Alert(Symbol() + "-" + "comprando");
}
if (IMA21 - IMA22 < (-IMATrendRate1) * myPoint && IMA31 - IMA32 < (-IMATrendRate2) * myPoint && IMA11 < IMA21 && CCI2 > CCIRange && CCI1 < CCI2 && Bid - IMA11 > PipsFromIMA2 * myPoint &&
OrderOpenPrice1 == 0.0 || Bid - OrderOpenPrice1 > PipDifMin * myPoint && Trading) {
ticket1 = OpenTrade(OP_SELL, Lots, StopLoss , TakeProfit , Symbol() + " " + "SELL " + Comentario, Magic);
if (ticket1 > 0) Alert(Symbol() + "-" + "vendiendo");
}
}

return (0);
}

int IsTradeTime(int Session) {
if (Session == 1 && Session1==1){
if (Session1OpenHour < Session1CloseHour && TimeHour(time) < Session1OpenHour || TimeHour(time) >= Session1CloseHour) return (0);
if (Session1OpenHour > Session1CloseHour && (TimeHour(time) < Session1OpenHour && TimeHour(time) >= Session1CloseHour)) return (0);
if (Session1CloseHour == 0) Session1CloseHour = 24;
if (TimeHour(time) == Session1CloseHour - 1 && TimeMinute(time) >= 55) return (0);
return (1);
}
if (Session == 2 && Session2==1){
if (Session2OpenHour < Session2CloseHour && TimeHour(time) < Session2OpenHour || TimeHour(time) >= Session2CloseHour) return (0);
if (Session2OpenHour > Session2CloseHour && (TimeHour(time) < Session2OpenHour && TimeHour(time) >= Session2CloseHour)) return (0);
if (Session2CloseHour == 0) Session2CloseHour = 24;
if (TimeHour(time) == Session2CloseHour - 1 && TimeMinute(time) >= 55) return (0);
return (1);
}
if (Session == 3 && Session3==1){
if (Session3OpenHour < Session3CloseHour && TimeHour(time) < Session3OpenHour || TimeHour(time) >= Session3CloseHour) return (0);
if (Session3OpenHour > Session3CloseHour && (TimeHour(time) < Session3OpenHour && TimeHour(time) >= Session3CloseHour)) return (0);
if (Session3CloseHour == 0) Session3CloseHour = 24;
if (TimeHour(time) == Session3CloseHour - 1 && TimeMinute(time) >= 55) return (0);
return (1);
}

}

void Trailing() {

double Ask1 = GetAsk() + Trailingstop * Point;
double Bid1 = GetBid() - Trailingstop * Point;
if (OrdersTotal() > 0) {
for (int i = 0; i < OrdersTotal(); i++) {
OrderSelect(i, SELECT_BY_POS, MODE_TRADES);
if (OrderType() == OP_SELL && OrderSymbol() == Symbol() && OrderMagicNumber() == Magic) {
if (GetAsk() < OrderOpenPrice() - Trailingstop * Point && Ask1 < OrderStopLoss()) {
waitForContext();
OrderModify(OrderTicket(), OrderOpenPrice(), Ask1, OrderTakeProfit(), 0, Green);
return (0);
}
}
if (OrderType() == OP_BUY && OrderSymbol() == Symbol() && OrderMagicNumber() == Magic) {
if (GetBid() > OrderOpenPrice() + Trailingstop * Point && Bid1 > OrderStopLoss()) {
waitForContext();
OrderModify(OrderTicket(), OrderOpenPrice(), Bid1, OrderTakeProfit(), 0, Green);
return (0);
}
}
}
}}

double GetBid() {
return (NormalizeDouble(MarketInfo(Symbol(), MODE_BID), Digits));
}

double GetAsk() {
return (NormalizeDouble(MarketInfo(Symbol(), MODE_ASK), Digits));
}




double SetPoint(string mySymbol)
{
double mPoint, myDigits;

myDigits = MarketInfo (mySymbol, MODE_DIGITS);
if (myDigits < 4) mPoint = 0.01;
if (myDigits == 4) mPoint = 0.0001;
if (myDigits == 5) mPoint = 0.00001;

return(mPoint);
}

int OpenTrade(int signal, double mLots, double StopLoss, double TakeProfit, string msg, int MagicNumber)
{
int ticket, err;
double TPprice,STprice;

RefreshRates();

if (signal==OP_BUY)
{
double Ask1=NormalizeDouble(Ask,Digits);
waitForContext();
ticket=OrderSend(Symbol(),OP_BUY,mLots,Ask1,SlipPa ge,0,0,msg,MagicNumber,0,Green);
if (ticket > 0)
{
if (OrderSelect( ticket,SELECT_BY_TICKET, MODE_TRADES) )
{
if (StopLoss != 0 || TakeProfit != 0)
{
TPprice = 0;
if (TakeProfit > 0)
{
TPprice = Ask + TakeProfit * myPoint;
TPprice = ValidTakeProfit(OP_BUY,Ask, TPprice);
}
STprice = 0;
if (StopLoss > 0)
{
STprice = Ask - StopLoss * myPoint;
STprice = ValidStopLoss(OP_BUY,Bid, STprice);
}
// Normalize stoploss / takeprofit to the proper # of digits.
if (Digits > 0)
{
STprice = NormalizeDouble( STprice, Digits);
TPprice = NormalizeDouble( TPprice, Digits);
}
waitForContext();
OrderModify(ticket, OrderOpenPrice(), STprice, TPprice, 0, LightGreen);
}

}

}
}
else if (signal==OP_SELL)
{
double Bid1=NormalizeDouble(Bid,Digits);
waitForContext();
ticket=OrderSend(Symbol(),OP_SELL,mLots,Bid1,SlipP age,0,0,msg,MagicNumber,0,Red);
if (ticket > 0)
{
if (OrderSelect( ticket,SELECT_BY_TICKET, MODE_TRADES) )
{
if (StopLoss != 0 || TakeProfit != 0)
{
TPprice = 0;
if (TakeProfit > 0)
{
TPprice=Bid - TakeProfit * myPoint;
TPprice = ValidTakeProfit(OP_SELL,Bid, TPprice);

}
STprice = 0;
if (StopLoss > 0)
{
STprice = Bid + StopLoss * myPoint;
STprice = ValidStopLoss(OP_SELL,Ask, STprice);
}
// Normalize stoploss / takeprofit to the proper # of digits.
if (Digits > 0)
{
STprice = NormalizeDouble( STprice, Digits);
TPprice = NormalizeDouble( TPprice, Digits);
}
waitForContext();
OrderModify(ticket, OrderOpenPrice(), STprice, TPprice, 0, LightGreen);
}
}
}
}

if(ticket<0)
{
err = GetLastError();
Print("Error opening SELL order : ",err, " ", ErrorDescription(err));
}
return(ticket);
}

double ValidStopLoss(int type, double price, double SL)
{

double newSL, temp;

if (SL < 0.1) return(SL);

temp = MarketInfo(Symbol(), MODE_STOPLEVEL) * myPoint;
newSL = SL;
if (type == OP_BUY)
{
if((price - SL) < temp) newSL = price - temp;
}
if (type == OP_SELL)
{
if((SL-price) < temp) newSL = price + temp;
}
newSL = NormalizeDouble(newSL,Digits);

return(newSL);
}

double ValidTakeProfit(int type, double price, double TP)
{

double newTP, temp;

temp = MarketInfo(Symbol(), MODE_STOPLEVEL) * myPoint;
newTP = TP;
if (type == OP_BUY)
{
if((TP - price) < temp) newTP = price + temp;
}
if (type == OP_SELL)
{
if((price - TP) < temp) newTP = price - temp;
}
newTP = NormalizeDouble(newTP,Digits);

return(newTP);
}

int RecuperarOrdenes() {
int contador = 0;
for (int i = OrdersHistoryTotal() - 1; i >= 0; i--) {
if (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY)) {
if (OrderMagicNumber() != Magic || OrderSymbol()!=Symbol()) continue;
ContarBalance(OrderProfit());
contador++;
}
}
return (contador);
}

void ContarBalance(double aux1) {
SumaBeneficios += aux1;
}

double RecoveryLot(double PreLot) {
RecuperarOrdenes();
if (banderaBalance < SumaBeneficios) banderaBalance = SumaBeneficios;
if (banderaBalance > SumaBeneficios) return (NormalizeLots(RecoveryModeMulti * PreLot));
return (PreLot);
}

double NormalizeLots(double PreLot) {
double LotStep = MarketInfo(Symbol(), MODE_LOTSTEP);
double MinLot = MarketInfo(Symbol(), MODE_MINLOT);
double MaxLot = MarketInfo(Symbol(), MODE_MAXLOT);
double valor = MathCeil(PreLot / LotStep) * LotStep;
if (valor < MinLot) {
valor = MinLot;
}
if (valor > MaxLot) {
valor = MaxLot;
}
return (valor);
}
double MMLots(double risk, double margin) {
return(NormalizeLots(risk * margin / MarketInfo(Symbol(), MODE_MARGINREQUIRED) / (AccountLeverage() / 10.0)));
}

int waitForContext() {
for (int contador = 0; IsTradeContextBusy() && contador < 20; contador++) Sleep(15);
if (contador >= 20) Print("El contexto de trading estuvo ocupado por mas de ", DoubleToStr(15 * contador / 1000, 2), " segundos");
else
if (contador > 0) Print("El contexto de trading estuvo ocupado por ", DoubleToStr(15 * contador / 1000, 2), " segundos");
return (contador);
}