Задачка нахождение последнего ордера по типу

Стол заказов MQL

Доброго всем времени суток.
Нужна помощь в коррекции функций советника.
Идея такова: поступил сигнал Sell > открылся ордер, поступил сигнал Buy > открылся ордер.
В рынке одновременно и Buy и Sell.
Сетка через 35 пунктов с увеличением лота отдельно для Sell ордеров и отдельно для Buy ордеров.

НО! В какой-то момент раздельное увеличение лота дает сбой.
Грешу на две функции: FindLastOrderLot() и Lot()
Подскажите пожалуйста, где я «дал маху»?


//--- Inputs
extern double Lots       = 0.1;      // торговый объем ордера
extern double Risk       =3000;        // Risk
extern double KLot       = 2;        // увеличение лота
extern int StopLoss      = 0;     // лось
extern int TakeProfit    = 100;      // язь
extern int TrailingStop  = 0;        // трал
extern int TrailingStep  = 0;        // трал степ
extern double Profit     = 0.29;       // Profit-Recovery
extern int Slip          = 10;       // реквот
extern int CloseSig      = 0;        // 1-закрытие по сигналу
extern int Magic         = 123;      // магик
extern int StepOrder     =350;
extern int Count         =9;        //кол-во ореров
extern int Shift         = 1;        // бар индикатора
extern int BBPeriod      = 35;
extern double BBDev      = 2.2;

datetime t=0;
double MINLOT,MAXLOT;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---
  MINLOT = MarketInfo(Symbol(),MODE_MINLOT);
  MAXLOT = MarketInfo(Symbol(),MODE_MAXLOT);
   Comment("");
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   Comment("");
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void PutOrder(int type,double price)
  {
   int r=0;
   color clr=Green;
   double sl=0,tp=0;

   if(type==1 || type==3 || type==5)
     {
      clr=Red;
      if(StopLoss>0)
         sl=NormalizeDouble(price+StopLoss*Point,Digits);
      if(TakeProfit>0)
         tp=NormalizeDouble(price-TakeProfit*Point,Digits);
     }

   if(type==0 || type==2 || type==4)
     {
      clr=Blue;
      if(StopLoss>0)
         sl=NormalizeDouble(price-StopLoss*Point,Digits);
      if(TakeProfit>0)
         tp=NormalizeDouble(price+TakeProfit*Point,Digits);
     }

   r=OrderSend(NULL,type,Lot(),NormalizeDouble(price,Digits),Slip,sl,tp,"",Magic,0,clr);
   return;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double Lot()
  {
   double lot=Lots;
   if(Risk>0)
      lot=AccountBalance()/(Risk*100);
//-----------------------------------
   if(CountOrders(1)>=2 && CountOrders(1)<6)
     lot=NormalizeDouble(KLot*FindLastOrderLot(1),2);
   if(CountOrders(1)>=6)  
     lot=NormalizeDouble((KLot*0.75)*FindLastOrderLot(1),2); 
   if(CountOrders(0)>=2 && CountOrders(0)<6)
     lot=NormalizeDouble(KLot*FindLastOrderLot(0),2);
   if(CountOrders(0)>=6)  
     lot=NormalizeDouble((KLot*0.75)*FindLastOrderLot(0),2);     
//--------------------------------
  
   if (lot>MAXLOT) lot = MAXLOT;
   if (lot<MINLOT) lot = MINLOT;
   return(lot);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void Trailing()
  {
   bool mod;
   double all=0,count=0,sl=0;

   for(int i=OrdersTotal()-1; i>=0; i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
            if(OrderType()<2)
              {
               all+=OrderOpenPrice()*OrderLots();
               count+=OrderLots();
              }
           }
        }
     }

   if(count>0)
      all=NormalizeDouble(all/count,_Digits);

   for(int i=OrdersTotal()-1; i>=0; i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
            if(OrderType()==OP_BUY)
              {
               if(Bid-all>(TrailingStop+TrailingStep)*_Point)
                 {
                  if(OrderStopLoss()<Bid-(TrailingStop+TrailingStep)*_Point)
                    {
                     sl=NormalizeDouble(Bid-TrailingStop*_Point,_Digits);
                     if(OrderStopLoss()!=sl)
                        mod=OrderModify(OrderTicket(),OrderOpenPrice(),sl,OrderTakeProfit(),0,Yellow);
                    }
                 }
              }

            if(OrderType()==OP_SELL)
              {
               if(all-Ask>(TrailingStop+TrailingStep)*_Point)
                 {
                  if((OrderStopLoss()>(Ask+(TrailingStop+TrailingStep)*_Point)) || (OrderStopLoss()==0))
                    {
                     sl=NormalizeDouble(Bid+TrailingStop*_Point,_Digits);
                     if(OrderStopLoss()!=sl)
                        mod=OrderModify(OrderTicket(),OrderOpenPrice(),sl,OrderTakeProfit(),0,Yellow);
                    }
                 }
              }
           }
        }
     }
  }
//+------------------------------------------------------------------+
//| Подсчет ордеров по типу                                          |
//+------------------------------------------------------------------+
int CountOrders(int type)
  {
   int count=0;
   for(int i=OrdersTotal()-1; i>=0; i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
            if(OrderType()==type)
               count++;
           }
        }
     }
   return(count);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int FindOrderType()
  {
   int oticket,ticketNumber=0,type=0;
   for(int i=OrdersTotal()-1; i>=0; i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
            oticket=OrderTicket();
            if(oticket>ticketNumber)
              {
               ticketNumber=oticket;
               type=OrderType();
              }
           }
        }
     }
   return(type);
  }
//+------------------------------------------------------------------+
//|                послекдний ордер по типу                          |
//+------------------------------------------------------------------+
double FindLastOrderLot(int type)
  {
   double OLot=0;
   for(int i=OrdersTotal()-1; i>=0; i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
            if(OrderType()==type)
              {
               if(OLot<OrderLots())
                 OLot=OrderLots();
              }
           }
        }
     }
   return(OLot);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double FindLastBuyPrice()
  {
   int oticket,ticketNumber=0;
   double oprice=0;
   for(int i=OrdersTotal()-1; i>=0; i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderType()==OP_BUY && OrderMagicNumber()==Magic)
           {
            oticket=OrderTicket();
            if(oticket>ticketNumber)
              {
               ticketNumber=oticket;
               oprice=OrderOpenPrice();
              }
           }
        }
     }
   return(oprice);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double FindLastSellPrice()
  {
   int oticket,ticketNumber=0;
   double oprice=0;
   for(int i=OrdersTotal()-1; i>=0; i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderType()==OP_SELL && OrderMagicNumber()==Magic)
           {
            oticket=OrderTicket();
            if(oticket>ticketNumber)
              {
               ticketNumber=oticket;
               oprice=OrderOpenPrice();
              }
           }
        }
     }
   return(oprice);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CloseAll(int ot=-1)
  {
   bool cl;
   for(int i=OrdersTotal()-1; i>=0; i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
            if(OrderType()==0 && (ot==0 || ot==-1))
              {
               RefreshRates();
               cl=OrderClose(OrderTicket(),OrderLots(),NormalizeDouble(Bid,Digits),Slip,White);
              }
            if(OrderType()==1 && (ot==1 || ot==-1))
              {
               RefreshRates();
               cl=OrderClose(OrderTicket(),OrderLots(),NormalizeDouble(Ask,Digits),Slip,White);
              }
           }
        }
     }
  }
//+------------------------------------------------------------------+
//| Профит всех ордеров по типу ордера                               |
//+------------------------------------------------------------------+
double AllProfit(int ot=-1)
  {
   double pr=0;
   for(int i=OrdersTotal()-1; i>=0; i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
            if(OrderType()==0  && (ot==0 || ot==-1))
              {
               pr+=OrderProfit()+OrderCommission()+OrderSwap();
              }

            if(OrderType()==1 && (ot==1 || ot==-1))
              {
               pr+=OrderProfit()+OrderCommission()+OrderSwap();
              }
           }
        }
     }
   return(pr);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double Prof()
  {
  double pr=Profit;
  pr=NormalizeDouble((AccountBalance()/100)*Profit,4);
  return (pr);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int Sig()
   {
   int sig=3;
   double up=iBands(NULL,0,BBPeriod,BBDev,0,0,1,Shift);
   double dn=iBands(NULL,0,BBPeriod,BBDev,0,0,2,Shift);
  
   double rsi2=iRSI(NULL,0,20,0,2);
   double rsi1=iRSI(NULL,0,20,0,1);
  
   bool BuyRsi=(rsi1<35);
   bool SellRsi=(rsi1>65);
  
      if(SellRsi)
        {
         if(Close[Shift]>up)
           sig=1;
        }
      if(BuyRsi)
        {
         if(Close[Shift]<dn)
           sig=0;
       }
   return(sig);
   }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void ModifyOrders()
  {
   double allb=0,alls=0;
   double countb=0,counts=0,tp=0,sl=0;

   for(int i=OrdersTotal()-1; i>=0; i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
            if(OrderType()==0)
              {
               allb+=OrderOpenPrice()*OrderLots();
               countb+=OrderLots();
              }

            if(OrderType()==1)
              {
               alls+=OrderOpenPrice()*OrderLots();
               counts+=OrderLots();
              }
           }
        }
     }
   if(countb>0)
      allb=NormalizeDouble(allb/countb,Digits);
   if(counts>0)
      alls=NormalizeDouble(alls/counts,Digits);

   for(int i=OrdersTotal()-1; i>=0; i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
            if(OrderType()==0)
              {
               if(TakeProfit>0)
                  tp=NormalizeDouble(allb+TakeProfit*Point,Digits);
               if(StopLoss>0)
                  sl=NormalizeDouble(allb-StopLoss*Point,Digits);
               if(OrderTakeProfit()!=tp || OrderStopLoss()!=sl)
                  bool mod=OrderModify(OrderTicket(),OrderOpenPrice(),sl,tp,0,Yellow);
              }
            else
               if(OrderType()==1)
                 {
                  if(TakeProfit>0)
                     tp=NormalizeDouble(alls-TakeProfit*Point,Digits);
                  if(StopLoss>0)
                     sl=NormalizeDouble(alls+StopLoss*Point,Digits);
                  if(OrderTakeProfit()!=tp || OrderStopLoss()!=sl)
                     bool mod=OrderModify(OrderTicket(),OrderOpenPrice(),sl,tp,0,Yellow);
                 }
           }
        }
     }
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {   
   double mn=iBands(NULL,0,BBPeriod,BBDev,0,0,0,Shift); //Main
   double mn2=iBands(NULL,0,BBPeriod,BBDev,0,0,0,Shift+1); //Main
   
   if(CloseSig>0)
     {
      if(Bid<mn2 && Bid>mn)
        {
         CloseAll(0);
        }

      if(Bid>mn2 && Bid<mn)
        {
         CloseAll(1);
        }
     }
    if(TrailingStop>0)
     {
         Trailing();     
     }    
//------------------ 
      if(AllProfit(0)>=Prof() && Profit>0 && CountOrders(0)>1)
       {
        CloseAll(0);
       }
      if(AllProfit(1)>=Prof() && Profit>0 && CountOrders(1)>1)
       {
        CloseAll(1);
       }
   if(t!=Time[0])
     {
       if(CountOrders(1)<1 && Sig()==1)
        {
         PutOrder(1,Ask);
         ModifyOrders();
        }  
       if(CountOrders(0)<1 && Sig()==0)
        {   
         PutOrder(0,Bid);
         ModifyOrders();
        }
        
 //-------------------------------------------
     if(CountOrders(0)<Count)
      {
     if(FindOrderType()==0 && (FindLastBuyPrice()-Ask)/_Point>=StepOrder)
        {
        if(Sig()==0)
          {  
           PutOrder(0,Ask);
           ModifyOrders();
          }
        }
        }
    if(CountOrders(1)<Count)
      {
    if(FindOrderType()==1 && (Bid-FindLastSellPrice())/_Point>=StepOrder)
       {
       if(Sig()==1)
        {
         PutOrder(1,Bid);
         ModifyOrders();
        }
       }  
       }
      t=Time[0];
     }

   Comment("\n Prof(): ",Prof());   
  }

разное

0
Просмотров: 1415
4 октября 2021, 18:07
verta81

Понравилcя материал? Не забудьте поставить плюс и поделиться в социальной сети!

Вступите в группу "Стол заказов MQL", чтобы следить за обновлениями
ПРИСОЕДИНИТЬСЯ К ГРУППЕ

Предыдущая запись в группе Переделать советник под другой индикатор	Следующая запись в группе На индикаторе !_MTF_shi_channel_1.mq4
04 октября 2021	04 октября 2021

Брокер для ваших роботов, 15 лет на рынке

Так же буду благодарен за любую рекомендацию по оптимизации кода советника.

14 verta81 Автор Сообщений: 454

4 октября 2021, 18:09
↓

//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 19.02.2008                                                     |
//|  Описание : Возвращает тикет последней открытой позиции или -1             |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   (""   - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    op - операция                   (-1   - любая позиция)                  |
//|    mn - MagicNumber                (-1   - любой магик)                    |
//+----------------------------------------------------------------------------+
int GetTicketLastPos(string sy="", int op=-1, int mn=-1) {
  datetime o;
  int      i, k=OrdersTotal(), r=-1;

  if (sy=="0") sy=Symbol();
  for (i=0; i<k; i++) {
    if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) {
      if (OrderSymbol()==sy || sy=="") {
        if (OrderType()==OP_BUY || OrderType()==OP_SELL) {
          if (op<0 || OrderType()==op) {
            if (mn<0 || OrderMagicNumber()==mn) {
              if (o<OrderOpenTime()) {
                o=OrderOpenTime();
                r=OrderTicket();
              }
            }
          }
        }
      }
    }
  }
  return®;
}

//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 19.02.2008                                                     |
//|  Описание : Возвращает тип последней закрытой позиции или -1               |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   (""   - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    mn - MagicNumber                (-1   - любой магик)                    |
//+----------------------------------------------------------------------------+
int GetTypeLastClosePos(string sy="", int mn=-1) {
  datetime t;
  int      i, k=OrdersHistoryTotal(), r=-1;

  if (sy=="0") sy=Symbol();
  for (i=0; i<k; i++) {
    if (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY)) {
      if ((OrderSymbol()==sy || sy=="") && (mn<0 || OrderMagicNumber()==mn)) {
        if (OrderType()==OP_BUY || OrderType()==OP_SELL) {
          if (t<OrderCloseTime()) {
            t=OrderCloseTime();
            r=OrderType();
          }
        }
      }
    }
  }
  return®;
}

//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 19.02.2008                                                     |
//|  Описание : Возвращает тип последней открытой позиции или -1               |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   (""   - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    mn - MagicNumber                (-1   - любой магик)                    |
//+----------------------------------------------------------------------------+
int GetTypeLastOpenPos(string sy="", int mn=-1) {
  datetime t;
  int      i, k=OrdersTotal(), r=-1;

  if (sy=="0") sy=Symbol();
  for (i=0; i<k; i++) {
    if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) {
      if ((OrderSymbol()==sy || sy=="") && (mn<0 || OrderMagicNumber()==mn)) {
        if (OrderType()==OP_BUY || OrderType()==OP_SELL) {
          if (t<OrderOpenTime()) {
            t=OrderOpenTime();
            r=OrderType();
          }
        }
      }
    }
  }
  return®;
}

16 ssg Сообщений: 817

4 октября 2021, 18:18
↓

Спасибо, но это не то.
В вашем примере функция находит тикет последнего ордера, последнего закрытого и тип последней открытой.
Мне нужно найти лот последнего Buy или Sell

//+------------------------------------------------------------------+
//|                послекдний ордер по типу                          |
//+------------------------------------------------------------------+
double FindLastOrderLot(int type)
  {
   double OLot=0;
   for(int i=OrdersTotal()-1; i>=0; i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
            if(OrderType()==type)
              {
               if(OLot<OrderLots())
                 OLot=OrderLots();
              }
           }
        }
     }
   return(OLot);
  }

и потом же умножить его на кеф для следующего ордера Buy или Sell

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double Lot()
  {
   double lot=Lots;
   if(Risk>0)
      lot=AccountBalance()/(Risk*100);
//-----------------------------------
   if(CountOrders(1)>=2 && CountOrders(1)<6)
     lot=NormalizeDouble(KLot*FindLastOrderLot(1),2);
   if(CountOrders(1)>=6)  
     lot=NormalizeDouble((KLot*0.75)*FindLastOrderLot(1),2); 
   if(CountOrders(0)>=2 && CountOrders(0)<6)
     lot=NormalizeDouble(KLot*FindLastOrderLot(0),2);
   if(CountOrders(0)>=6)  
     lot=NormalizeDouble((KLot*0.75)*FindLastOrderLot(0),2);     
//--------------------------------
  
   if (lot>MAXLOT) lot = MAXLOT;
   if (lot<MINLOT) lot = MINLOT;
   return(lot);
  }

14 verta81 Автор Сообщений: 454

4 октября 2021, 18:45
↓

У вас в заголовке нет ни слова о размере лота.Тогда так

//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 16.06.2008                                                     |
//|  Описание : Возвращает размер лота последней закрытой позиции или -1       |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   (""   - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    op - операция                   (-1   - любая позиция)                  |
//|    mn - MagicNumber                (-1   - любой магик)                    |
//+----------------------------------------------------------------------------+
double GetLotLastClosePos(string sy="", int op=-1, int mn=-1) {
  datetime o;
  double   l=-1;
  int      i, k=OrdersHistoryTotal();

  if (sy=="0") sy=Symbol();
  for (i=0; i<k; i++) {
    if (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY)) {
      if (OrderSymbol()==sy || sy=="") {
        if (OrderType()==OP_BUY || OrderType()==OP_SELL) {
          if (op<0 || OrderType()==op) {
            if (mn<0 || OrderMagicNumber()==mn) {
              if (o<OrderCloseTime()) {
                o=OrderCloseTime();
                l=OrderLots();
              }
            }
          }
        }
      }
    }
  }
  return(l);
}

//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 19.02.2008                                                     |
//|  Описание : Возвращает размер лота последней открытой позиции или -1       |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   (""   - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    op - операция                   (-1   - любая позиция)                  |
//|    mn - MagicNumber                (-1   - любой магик)                    |
//+----------------------------------------------------------------------------+
double GetLotLastPos(string sy="", int op=-1, int mn=-1) {
  datetime o;
  double   l=-1;
  int      i, k=OrdersTotal();

  if (sy=="0") sy=Symbol();
  for (i=0; i<k; i++) {
    if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) {
      if (OrderSymbol()==sy || sy=="") {
        if (OrderType()==OP_BUY || OrderType()==OP_SELL) {
          if (op<0 || OrderType()==op) {
            if (mn<0 || OrderMagicNumber()==mn) {
              if (o<OrderOpenTime()) {
                o=OrderOpenTime();
                l=OrderLots();
              }
            }
          }
        }
      }
    }
  }
  return(l);
}

16 ssg Сообщений: 817

4 октября 2021, 19:20
↑
↓

в чужие дебри я не полезу, но вот так обе сетки нормально ставит:


//+------------------------------------------------------------------+
//|                                                  Usrednitel2.mq4 |
//|                                              Copyright 2021, AM2 |
//|                                      http://www.forexsystems.biz |
//+------------------------------------------------------------------+
#property copyright "Copyright 2021, AM2"
#property link      "http://www.forexsystems.biz"
#property version   "1.00"
#property strict

//--- Inputs
extern double Lots       = 0.01;     // торговый объем ордера
extern double MaxLot     = 5;        // максимальный торговый объем
extern double KLot       = 1.3;      // увеличение лота
extern int StopLoss      = 0;        // лось
extern int TakeProfit    = 100;      // язь
extern int Step          = 200;      // шаг
extern int Slip          = 30;       // реквот
extern int Magic         = 123;      // магик

datetime t=0;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   Comment("");
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void PutOrder(int type,double price)
  {
   int r=0;
   color clr=Green;
   double sl=0,tp=0;

   if(type==1 || type==3 || type==5)
     {
      clr=Red;
      if(StopLoss>0)
         sl=NormalizeDouble(price+StopLoss*_Point,_Digits);
      if(TakeProfit>0)
         tp=NormalizeDouble(price-TakeProfit*_Point,_Digits);
     }

   if(type==0 || type==2 || type==4)
     {
      clr=Blue;
      if(StopLoss>0)
         sl=NormalizeDouble(price-StopLoss*_Point,_Digits);
      if(TakeProfit>0)
         tp=NormalizeDouble(price+TakeProfit*_Point,_Digits);
     }

   r=OrderSend(NULL,type,Lot(type),NormalizeDouble(price,_Digits),Slip,sl,tp,"",Magic,0,clr);
   return;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CountTrades(int type=-1)
  {
   int count=0;

   for(int i=OrdersTotal()-1; i>=0; i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
            if(OrderType()==type || type==-1)
               count++;
           }
        }
     }
   return(count);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void ModifyOrders()
  {
   double allb=0,alls=0;
   double countb=0,counts=0,tp=0,sl=0;

   for(int i=OrdersTotal()-1; i>=0; i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
            if(OrderType()==0)
              {
               allb+=OrderOpenPrice()*OrderLots();
               countb+=OrderLots();
              }

            if(OrderType()==1)
              {
               alls+=OrderOpenPrice()*OrderLots();
               counts+=OrderLots();
              }
           }
        }
     }
   if(countb>0)
      allb=NormalizeDouble(allb/countb,_Digits);
   if(counts>0)
      alls=NormalizeDouble(alls/counts,_Digits);

   for(int i=OrdersTotal()-1; i>=0; i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol())
           {
            if(OrderType()==OP_BUY)
              {
               if(TakeProfit>0)
                  tp=NormalizeDouble(allb+TakeProfit*_Point,_Digits);
               if(StopLoss>0)
                  sl=NormalizeDouble(allb-StopLoss*_Point,_Digits);
               if(OrderTakeProfit()!=tp || OrderStopLoss()!=sl)
                  bool mod=OrderModify(OrderTicket(),OrderOpenPrice(),sl,tp,0,Yellow);
              }
            else
               if(OrderType()==OP_SELL)
                 {
                  if(TakeProfit>0)
                     tp=NormalizeDouble(alls-TakeProfit*_Point,_Digits);
                  if(StopLoss>0)
                     sl=NormalizeDouble(alls+StopLoss*_Point,_Digits);
                  if(OrderTakeProfit()!=tp || OrderStopLoss()!=sl)
                     bool mod=OrderModify(OrderTicket(),OrderOpenPrice(),sl,tp,0,Yellow);
                 }
           }
        }
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double Lot(int type)
  {
   double lot=Lots;
   if(CountTrades(type)>0)
      lot=NormalizeDouble(Lots*MathPow(KLot,CountTrades(type)),2);
   if(lot>MaxLot)
      lot=Lots;
   return(lot);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double FindLastPrice(int type)
  {
   double pr=0;
   for(int i=OrdersTotal()-1; i>=0; i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
            if(OrderType()==type)
              {
               pr=OrderOpenPrice();
               break;
              }
           }
        }
     }
   return(pr);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   if(t!=Time[0])
     {
      if(Close[1]>Open[1] && CountTrades(0)<1)
        {
         PutOrder(0,Ask);
         ModifyOrders();
        }
      if(Close[1]<Open[1] && CountTrades(1)<1)
        {
         PutOrder(1,Bid);
         ModifyOrders();
        }

      if(CountTrades(0)>0 && (FindLastPrice(0)-Ask)/_Point>=Step)
        {
         PutOrder(0,Ask);
         ModifyOrders();
        }

      if(CountTrades(1)>0 && (Bid-FindLastPrice(1))/_Point>=Step)
        {
         PutOrder(1,Bid);
         ModifyOrders();
        }

      t=Time[0];
     }

   Comment("\n Buy Lot: ",Lot(0),
           "\n Sell Lot: ",Lot(1),
           "\n Trades: ",CountTrades());
  }
//+------------------------------------------------------------------+

35 AM2 Сообщений: 16425 - Андрей

4 октября 2021, 18:48
↓

как на данный момент советник устанавливает размер лота:
sell 0.1
sell 0.1
sell 0.2
sell 0.4
buy 0.8
sell 0.16
сбой пошел же на buy, лот которого должен быть начальный 0.1
Вот ищу где ощибка

14 verta81 Автор Сообщений: 454

4 октября 2021, 18:49
↓

Огромное всем спасибо за помощь.
Нашел решение своей проблемы по примеру кода Андрея.
Благодарочка!!!

14 verta81 Автор Сообщений: 454

5 октября 2021, 14:35
↓

Зарегистрируйтесь или авторизуйтесь, чтобы оставить комментарий

Группа "Стол заказов MQL"

Свыше 4000 заказов уже выполнено бесплатно!

РЕКОМЕНДУЮ

Лучшее от verta81

Задачка нахождение последнего ордера по типу

Комментарии (7)

Рейтинг брокеров FOREX

Из недавнего:

	verta81 Уровень 14

Авторизация

Группа "Стол заказов MQL"

Свыше 4000 заказов уже выполнено бесплатно!

РЕКОМЕНДУЮ

Лучшее от verta81

Задачка нахождение последнего ордера по типу

Вставка изображения

СМАЙЛИКИ

Позитив

Негатив

Роли

Еще

Плакаты, знаки

Комментарии (7)

Рейтинг брокеров FOREX

Из недавнего: