ForumSections

New MT4 validation error, NO TRADING OPERATIONS - page 3

New comment
fxduep2020:

yes of course, everything is there, I worked on this code for a month without problems, now I can no longer publish, the code is perfect, zero errors

  • Remove volume check function
  • Add checking account order limits 
  • Add lot digits
  • Add margin required available check

#property version "2.1"
#property strict
enum ENUM_ST
  {
   Awerage   = 0, // Awerage
   PartClose = 1  // Part Close
  };
 int          iTakeProfit         = 300;      // Take Profit (in pips)
 double       iStartLots          = 0.01;     // Start lot
 double       iMaximalLots        = 0.01;     // Maximal Lots
 ENUM_ST      iCloseOrder         = Awerage;  // Type close orders
 int          iPointOrderStep     = 50;       // Point order step (in pips)
int          iMinimalProfit      = 70;       // Minimal profit for close grid (in pips)
int          iMagicNumber        = 227;      // Magic Number (in number)
 int          iSlippage           = 3000;       // Slippage (in pips)

int OnInit()
  {
   Comment("");
   return(INIT_SUCCEEDED);
  }
//************************************************************************************************/
//*                                                                                              */
//************************************************************************************************/
void OnTick()
  {
   double
   BuyPriceMax = 0, BuyPriceMin = 0, BuyPriceMaxLot = 0, BuyPriceMinLot = 0,
   SelPriceMin = 0, SelPriceMax = 0, SelPriceMinLot = 0, SelPriceMaxLot = 0;

   int
   BuyPriceMaxTic = 0, BuyPriceMinTic = 0, SelPriceMaxTic = 0, SelPriceMinTic = 0;

   double
   op = 0, lt = 0, tp = 0;

   int
   tk = 0, b = 0, s = 0;

   for(int i = OrdersTotal() - 1; i >= 0; i--)
      if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
         if(OrderMagicNumber() == iMagicNumber)
            if(OrderSymbol() == Symbol())
              {
               op = NormalizeDouble(OrderOpenPrice(), Digits());
               lt = NormalizeDouble(OrderLots(), 2);
               tk = OrderTicket();
               if(OrderType() == OP_BUY)
                 {
                  b++;
                  if(op > BuyPriceMax || BuyPriceMax == 0)
                    {
                     BuyPriceMax    = op;
                     BuyPriceMaxLot = lt;
                     BuyPriceMaxTic = tk;
                    }
                  if(op < BuyPriceMin || BuyPriceMin == 0)
                    {
                     BuyPriceMin    = op;
                     BuyPriceMinLot = lt;
                     BuyPriceMinTic = tk;
                    }
                 }
               // ===
               if(OrderType() == OP_SELL)
                 {
                  s++;
                  if(op > SelPriceMax || SelPriceMax == 0)
                    {
                     SelPriceMax    = op;
                     SelPriceMaxLot = lt;
                     SelPriceMaxTic = tk;
                    }
                  if(op < SelPriceMin || SelPriceMin == 0)
                    {
                     SelPriceMin    = op;
                     SelPriceMinLot = lt;
                     SelPriceMinTic = tk;
                    }
                 }
              }
//*************************************************************//
   double   AwerageBuyPrice = 0, AwerageSelPrice = 0;

   if(iCloseOrder == Awerage)
     {
      if(b >= 2)
         AwerageBuyPrice = NormalizeDouble((BuyPriceMax * BuyPriceMaxLot + BuyPriceMin * BuyPriceMinLot) / (BuyPriceMaxLot + BuyPriceMinLot) + iMinimalProfit * Point(), Digits());
      if(s >= 2)
         AwerageSelPrice = NormalizeDouble((SelPriceMax * SelPriceMaxLot + SelPriceMin * SelPriceMinLot) / (SelPriceMaxLot + SelPriceMinLot) - iMinimalProfit * Point(), Digits());
     }

   if(iCloseOrder == PartClose)
     {
      if(b >= 2)
         AwerageBuyPrice = NormalizeDouble((BuyPriceMax * iStartLots + BuyPriceMin * BuyPriceMinLot) / (iStartLots + BuyPriceMinLot) + iMinimalProfit * Point(), Digits());
      if(s >= 2)
         AwerageSelPrice = NormalizeDouble((SelPriceMax * SelPriceMaxLot + SelPriceMin * iStartLots) / (SelPriceMaxLot + iStartLots) - iMinimalProfit * Point(), Digits());
     }
//*************************************************************//
   double BuyLot = 0, SelLot = 0;
   if(BuyPriceMinLot == 0)
      BuyLot = iStartLots;
   else
      BuyLot = BuyPriceMinLot * 2;
   if(SelPriceMaxLot == 0)
      SelLot = iStartLots;
   else
      SelLot = SelPriceMaxLot * 2;
//*************************************************************//
   if(iMaximalLots >0)
     {
      if(BuyLot > iMaximalLots)
         BuyLot = iMaximalLots;
      if(SelLot > iMaximalLots)
         SelLot = iMaximalLots;
     }
   //if(!CheckVolumeValue(BuyLot) || !CheckVolumeValue(SelLot))
   // return;
   int errors=0;
   ResetLastError();
   int mot=OrdersTotal();errors+=GetLastError();
   int cot=(int)AccountInfoInteger(ACCOUNT_LIMIT_ORDERS);errors+=GetLastError();
//*************************************************************//
//new orders 
  if(mot<cot&&errors==0)
  {
   if(Close[1] > Open[1])
   {
   if((b==0)||(b>0&&(BuyPriceMin-Ask)>(iPointOrderStep*Point())))
     {
     double get_lot=lot_me(BuyLot);
     ResetLastError();
     double fmc=AccountFreeMarginCheck(_Symbol,OP_BUY,get_lot);
     if(get_lot>0&&fmc>0&&GetLastError()==0)     
     {
     int ticket=OrderSend(Symbol(), OP_BUY,get_lot,Ask,iSlippage,0,0,"Test Buy",iMagicNumber,0,clrGreen);
     if(ticket!=-1){Sleep(545);}
     }
     }
   }
   if(Close[1] < Open[1])
   {
   if((s == 0) || (s > 0 && (Bid - SelPriceMax) > (iPointOrderStep * Point())))
   {
   double get_lot=lot_me(SelLot);
   ResetLastError();
   double fmc=AccountFreeMarginCheck(_Symbol,OP_SELL,get_lot);
   if(get_lot>0&&fmc>0&&GetLastError()==0)
   {
   int ticket=OrderSend(Symbol(), OP_SELL, get_lot,Bid, iSlippage, 0, 0, "Test Sell", iMagicNumber, 0, clrGreen);
   if(ticket!=-1){Sleep(545);}
   }
   }
   }
  }
//new orders block ends here
//*************************************************************//
   for(int i = OrdersTotal() - 1; i >= 0; i--)
      if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
         if(OrderMagicNumber() == iMagicNumber)
            if(OrderSymbol() == Symbol())
              {
               op = NormalizeDouble(OrderOpenPrice(), Digits());
               tp = NormalizeDouble(OrderTakeProfit(), Digits());
               lt = NormalizeDouble(OrderLots(), 2);
               tk = OrderTicket();

               if(OrderType() == OP_BUY && b == 1 && tp == 0)
                  if(!OrderModify(tk, op, OrderStopLoss(), NormalizeDouble(Ask + iTakeProfit * Point(), Digits()), 0, clrRed))
                     Print("OrderModify error #", GetLastError());

               if(OrderType() == OP_SELL && s == 1 && tp == 0)
                  if(!OrderModify(tk, op, OrderStopLoss(), NormalizeDouble(Bid - iTakeProfit * Point(), Digits()), 0, clrRed))
                     Print("OrderModify error #", GetLastError());

               if(iCloseOrder == Awerage)
                 {
                  if(OrderType() == OP_BUY && b >= 2)
                    {
                     if(tk == BuyPriceMaxTic || tk == BuyPriceMinTic)
                        if(Bid < AwerageBuyPrice && tp != AwerageBuyPrice)
                           if(!OrderModify(tk, op, OrderStopLoss(), AwerageBuyPrice, 0, clrRed))
                              Print("OrderModify error #", GetLastError());

                     if(tk != BuyPriceMaxTic && tk != BuyPriceMinTic && tp != 0)
                        if(!OrderModify(tk, op, 0, 0, 0, clrRed))
                           Print("OrderModify error #", GetLastError());
                    }
                  if(OrderType() == OP_SELL && s >= 2)
                    {
                     if(tk == SelPriceMaxTic || tk == SelPriceMinTic)
                        if(Ask > AwerageSelPrice && tp != AwerageSelPrice)
                           if(!OrderModify(tk, op, OrderStopLoss(), AwerageSelPrice, 0, clrRed))
                              Print("OrderModify error #", GetLastError());

                     if(tk != SelPriceMaxTic && tk != SelPriceMinTic && tp != 0)
                        if(!OrderModify(tk, op, 0, 0, 0, clrRed))
                           Print("OrderModify error #", GetLastError());
                    }
                 }

              }

   if(iCloseOrder == PartClose)
     {
      if(b >= 2)
         if(AwerageBuyPrice > 0 && Bid >= AwerageBuyPrice)
           {
            if(!OrderClose(BuyPriceMaxTic, iStartLots,Bid, iSlippage, clrRed))
               Print("OrderClose Error", GetLastError());
            if(!OrderClose(BuyPriceMinTic, BuyPriceMinLot,Bid, iSlippage, clrRed))
               Print("OrderClose Error #", GetLastError());
           }
      if(s >= 2)
         if(AwerageSelPrice > 0 && Ask <= AwerageSelPrice)
           {
            if(!OrderClose(SelPriceMinTic, iStartLots,Ask, iSlippage, clrRed))
               Print("OrderClose Error #", GetLastError());
            if(!OrderClose(SelPriceMaxTic, SelPriceMaxLot,Bid, iSlippage, clrRed))
               Print("OrderClose Error #", GetLastError());
           }
     }
  }
//************************************************************************************************/
//*                                                                                              */
//************************************************************************************************/
void OnDeinit(const int reason)
  {

  }
//************************************************************************************************/
//*                                                                                              */
//************************************************************************************************/
bool CheckVolumeValue(double volume)
  {

   double min_volume = SymbolInfoDouble(Symbol(), SYMBOL_VOLUME_MIN);
   if(volume < min_volume)
      return(false);


   double max_volume = SymbolInfoDouble(Symbol(), SYMBOL_VOLUME_MAX);
   if(volume > max_volume)
      return(false);


   double volume_step = SymbolInfoDouble(Symbol(), SYMBOL_VOLUME_STEP);

   int ratio = (int)MathRound(volume / volume_step);
   if(MathAbs(ratio * volume_step - volume) > 0.0000001)
      return(false);

   return(true);
  }
//************************************************************************************************/
//*                                                                                              */
//************************************************************************************************/

//wherever you send orders ,change the normalization in the order send to variable get_lot
//get lot should be before order send like this 
//double get_lot=lot_me(BuyLot);//or SellLot accordingly
//then perform one more check for sending the order ,if get_lot>0

double lot_me(double lot)
{
double send=-1;
   int errors=0;
   ResetLastError();
   double minlot=(double)MarketInfo(Symbol(),MODE_MINLOT);errors+=GetLastError();
   if(errors==0)
   {
   int digits_lot=LotDigits(minlot);
   send=NormalizeDouble(lot,digits_lot);
   if(send<minlot){send=minlot;send=NormalizeDouble(send,digits_lot);}
   }
return(send);
}
//Find Lot Digits 
int LotDigits(double lot)
{
int returnio=0;
double digitos=0;
double transfer=lot;
while(transfer<1)
{
digitos++;
transfer=transfer*10;
} 
returnio=(int)digitos;
//Print("Lot ("+lot+") Digits "+digitos+" Returnio "+returnio);
return(returnio);
}
Lorentzos Roussos:

  • Remove volume check function
  • Add checking account order limits 
  • Add lot digits
  • Add margin required available check

you are a champion thankssssssssssss XD

Lorentzos Roussos:

  • Remove volume check function
  • Add checking account order limits 
  • Add lot digits
  • Add margin required available check

then maybe you can help me on this too! I can't get it to run on a single time frame eg PERIOD_D1

123
New comment