LeonidPetr

 
Уровень 2

  Торгую в компаниях:


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

Рейтинг 2089



РЕКОМЕНДУЮ



Доработка советника

Помогите пожалуйста!!!
Не могу добиться, чтобы ордера открывались только один раз.
Сначала все идет нормально, до тех пор, пока в цикле из четырех ордеров не закроется хотя бы один.
Нужно, чтобы до окончания цикла больше ничего не открывалось.
Я не смог
того добиться сам, поэтому вынужден обратиться сюда.

код:


//--- Inputs
extern double Lot1       = 0.1;      // лот 1
extern double Lot2       = 0.6;      // лот 2
extern double Lot3       = 0.9;
extern double S;
extern double m;
extern double m1;
extern double ma=0;
extern double ma1=0;
extern double ma2=0;
extern double Signal1=0;
extern double Main=0;
extern double Main1=0;
extern double Main2 =0;
extern double Signal2=0;

extern int Magic = 1720;

extern int StochK=48;                   //Стохастик K период, по умолчанию 5.StochK=48;StochD=12;
extern int StochD=24;

extern int StochK1=72;                   //Стохастик D период, по умолчанию 3
extern int StochD1=12;
extern int StochSlowing=1;

extern double DSM;
extern double DSM1;
extern double DMS;

extern double BuyProfit=0;
extern double SellProfit=0;

extern double Bstoploss=0;
extern double Sstoploss=0;
extern double OrderOpenPrice1;
extern   double PriceBuy=0;
extern   double PriceSell=0;

extern   double BuyStopLoss=0;
extern   double SellStopLoss=0;
//==================================первая волна
extern   double BstopOpen =0;
extern   double SstopOpen =0;
//==================================вторая волна
extern   double PriceBuy2 =0;
extern   double PriceSell2 =0;
extern   double PriceBuy3 =0;
extern   double PriceSell3 =0;
extern   double PriceBuy4 =0;
extern   double PriceSell4 =0;

extern   double BuyStopLoss2=0;
extern   double SellStopLoss2=0;

extern   double BstopProfit2 = 0;
extern   double SstopProfit2 = 0;
extern   double BstopProfit3 = 0;
extern   double SstopProfit3 = 0;
extern   double BstopProfit4 = 0;
extern   double SstopProfit4 = 0;

//=======================================

extern   double BstopOpenLoss = 0;
extern   double SstopOpenLoss = 0;
extern   double BstopClose = 0;
extern   double SstopClose = 0;
extern int StopLoss      = 70;
extern int TakeProfit    = 5;

extern int r    = 0;
extern int r1   = 0;
extern int r2   = 0;
extern int r3   = 0;
extern int r4   = 0;
extern int r5   = 0;

extern int buystop2=0;
extern int total=0;

extern int Slip          = 300;       // реквот
extern int Shift         = 1;        // на каком баре сигнал индикатора

extern int T             =3;
extern int X             =1;
extern int n             =5;
extern int spr             =0;
extern int N_bs2=0;


extern double ss=0;
extern double s=0;
extern double s2=0;
extern double sa=0;
extern double ss1=0;
extern double SS=0;
extern datetime t=0;
extern int buy,buy1,sell1,buystop1,sellstop1;
extern int sell;
extern int buystop;
extern int sellstop;

extern double bs=0;
extern double bs1=0;
extern double bs2=0;
extern double Val=0;
extern double Val1=0;
extern double Val2=0;
extern double VL=0;
extern double VL1=0;
extern double VL2=0;
extern double VL3=0;

extern double Close1=0;
extern double Close2=0;
extern double Close3=0;

extern double Open1=0;
extern double Open2=0;
extern double Open3=0;
extern double TR=0;
extern double TR1=0;
extern double TR2=0;
extern double TR3=0;
extern string OrdersList;
int ArrayOrders[20];
int ArrayTickets[20];

//......
int buy_tickets[];
int buy_stop_tickets[];
int sell_tickets[];
int sell_stop_tickets[];
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   for(int i=0; i<ArraySize(ArrayOrders); i++)
     {ArrayOrders[i]=-1;}

   for(int i=0; i<ArraySize(ArrayOrders); i++)
     {Print(ArrayOrders[i]);}

   for(int i=0; i<ArraySize(ArrayTickets); i++)
     {ArrayTickets[i]=-1;}

   for(int i=0; i<ArraySize(ArrayTickets); i++)
     {Print(ArrayTickets[i]);}

   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//Comment("");

  }
//+------------------------------------------------------------------+
//| Удаление отложенных ордеров                                      |
//+------------------------------------------------------------------+
void DelOrder(int dell=0)//(int type=-1)
  {
   if(OrderMagicNumber()==Magic)
      for(int i=OrdersTotal()-1; i>=0; i--)
         if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
           {
            if(OrderType()==OP_BUYSTOP && OrderSymbol()==Symbol()&&OrderMagicNumber())
               dell=OrderDelete(OrderTicket());

            if(OrderType()==OP_SELLSTOP && OrderSymbol()==Symbol()&&OrderMagicNumber())
               dell=OrderDelete(OrderTicket());
           }
  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void DelOrder1(int del1=0)
  {
//bool del1=0;
   if(OrderMagicNumber()==Magic)
     {
      for(int j=OrdersTotal()-1; j>=0; j--)
         if(OrderSelect(j,SELECT_BY_POS,MODE_TRADES))
           {
            if(OrderType()==OP_BUYSTOP && OrderMagicNumber()==Magic)
              {
               RefreshRates();
               del1=OrderDelete(OrderTicket());
              }
            if(OrderType()==OP_SELLSTOP && OrderMagicNumber()==Magic)
              {
               RefreshRates();
               del1=OrderDelete(OrderTicket());
              }
           }

     }
   return;
  }
//+------------------------------------------------------------------+
//| Подсчет ордеров по типу                                          |
//+------------------------------------------------------------------+
int Last()
  {
   bool last=0;
   for(int i=OrdersTotal()-1; i>=0; i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderMagicNumber()==Magic)
           {
            if(OrderType()==0)
              {last=0; break;}
            if(OrderType()==1)
              {last=1; break;}
           }
        }
     }
   return(last);
  }
//+------------------------------------------------------------------+
int Last1()
  {
   bool last1=0;
   for(int i=OrdersTotal()-1; i>=0; i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderMagicNumber()==Magic)
           {
            if(OrderType()==4)
              {last1=0; break; }
            if(OrderType()==5)
              {last1=1; break;}
           }
        }
     }
   return(last1);
  }

//==========================================================================
void Case2()
  {
   if(sell==1)
     {
      if(ArrayOrders[OP_SELL]<1&&ArrayOrders[OP_BUYSTOP]<1)
        {
         PutOrder(1,Bid,Lot1,0,0);
         PutOrder1(4,BstopOpen,Lot2,0,0);
        }
     }
   return;
  }



//===============================================================================
int CountTrades()
  {
   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()<4)
              {count++;}
           }
        }
     }
   return(count);
  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CountOrders(int type=-1)
  {
   int count=0;
   for(int i=OrdersTotal()-1; i>=0; i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderMagicNumber()==Magic)
           {
            if(OrderType()==type || type==-1)
               count++;
           }
        }
     }
   return(count);
  }

//+------------------------------------------------------------------+
//|      Функции параметров ордеров открытия цикла                                                           |
//+------------------------------------------------------------------+
void PutOrder(int type,double price,double lot,double sl,double tp)
  {
   r=0;
   color clr=Green;
   sl=0;
   tp=0;
   if(type==1) //SELL
     {
      clr=Green;
      if(StopLoss>0)
         sl=NormalizeDouble(Ask+90*Point,Digits);
      if(TakeProfit>0)
         tp=NormalizeDouble(Bid-T*Point,Digits);
     }
   if(type==0) //BUY
     {
      clr=Green;
      if(StopLoss>0)
         sl=NormalizeDouble(Bid-90*Point,Digits);
      if(TakeProfit>0)
         tp=NormalizeDouble(Ask+T*Point,Digits);
     }
   r=OrderSend(NULL,type,lot,NormalizeDouble(price,Digits),Slip,sl,tp,"",Magic,0,clr);
  }

//+----------------------------------------------------------------------------------+
//| Функции параметров ордеров отработки убытков до стоп-лосса 1-я волна                                                          |
//+----------------------------------------------------------------------------------+
void PutOrder1(int type,double price,double lot,double sl1,double tp1)
  {
   r1=0;
   color clr=Red;
   sl1=0;
   tp1=0;
   if(type==5)//SELLSTOP
     {
      if(StopLoss>0)
         sl1=NormalizeDouble(SstopOpenLoss,Digits);
      if(TakeProfit>0)
         tp1=NormalizeDouble(SstopClose,Digits);
     }
   if(type==4) //BUYSTOP
     {
      clr=Red;
      if(StopLoss>0)
         sl1=NormalizeDouble(BstopOpenLoss,Digits);
      if(TakeProfit>0)
         tp1=NormalizeDouble(BstopClose,Digits);
     }
   r1=OrderSend(NULL,type,lot,NormalizeDouble(price,Digits),Slip,sl1,tp1,"",Magic,0,clr);
  }
//+----------------------------------------------------------------------------------+
//| Функции параметров ордеров отработки убытков до стоп-лосса 2-я волна                                                          |
//+----------------------------------------------------------------------------------+
void PutOrder2(int type,double price,double lot,double sl2,double tp2)
  {
   r2=0;
   color clr=Blue;
   sl2=0;
   tp2=0;
   if(type==5)//SELLSTOP
     {
      clr=Blue;
      if(TakeProfit>0)
         tp2=NormalizeDouble(SstopProfit2,Digits);
      if(StopLoss>0)
         sl2=NormalizeDouble(Ask+100*Point,Digits);
     }
   if(type==4) //BUYSTOP
     {
      clr=Blue;
      if(TakeProfit>0)
         tp2=NormalizeDouble(BstopProfit2,Digits);
      if(StopLoss>0)
         sl2=NormalizeDouble(Bid-100*Point,Digits);
     }
   r2=OrderSend(NULL,type,lot,NormalizeDouble(price,Digits),Slip,sl2,tp2,"",Magic,0,clr);
  }
//+----------------------------------------------------------------------------------+
//| Функции параметров ордеров хеджирование                                                          |
//+----------------------------------------------------------------------------------+
void PutOrder3(int type,double price,double lot,double sl3,double tp3)
  {
   r3=0;
   color clr=Magenta;
   sl3=0;
   tp3=0;
   if(type==5)//SELLSTOP
     {
      clr=Magenta;
      if(StopLoss>0)
         sl3=NormalizeDouble(Ask+100*Point,Digits);
      if(TakeProfit>0)
         tp3=NormalizeDouble(SstopProfit3,Digits);
     }
   if(type==4) //BUYSTOP
     {
      clr=Magenta;
      if(StopLoss>0)
         sl3=NormalizeDouble(Bid-100*Point,Digits);
      if(TakeProfit>0)
         tp3=NormalizeDouble(BstopProfit3,Digits);
     }
   r4=OrderSend(NULL,type,lot,NormalizeDouble(price,Digits),Slip,sl3,tp3,"",Magic,0,clr);
  }

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void Trade()
  {
   RefreshRates();
   buy=0;
   sell=0;
   ss=0;
   ss1=0;
   S=(AccountBalance()+  AccountFreeMargin())/2;
   Lot1=S* 0.00006;
//------------------------------------------------------------
   Main=iStochastic(Symbol(),0,StochK,StochD,StochSlowing,MODE_SMA,STO_LOWHIGH,MODE_MAIN,1);
   Signal2=iStochastic(Symbol(),0,StochK,StochD,StochSlowing,MODE_SMA,STO_LOWHIGH,MODE_SIGNAL,1);
//========================================================

//1
   if(Main<Signal2&&Main<50)
      buy=1;
   else
      sell=1;

//==================================================================================
   Lot2=Lot1*6;
   Lot3=Lot1*20;
   spr=3;
   T=3;
   ss=90;
   ss1=90;
   s=ss/4;//отработка 1 волна
   s2=ss1*7/16;//отработка 2 волна

   Bstoploss=Bid-90*Point;
   Sstoploss=Ask+90*Point;
   PriceBuy=67;
   PriceSell=67;
   BstopOpen =Ask+ 67*Point;
   SstopOpen =Bid- 67*Point;

   BuyProfit=Ask+T*Point;
   SellProfit=Bid-T*Point;

   BuyStopLoss=SellProfit-5*Point;
   SellStopLoss=BuyProfit+5*Point;

   BstopOpenLoss = SellProfit-0*Point;
   SstopOpenLoss = BuyProfit+spr*Point;
   BstopClose = Sstoploss-(5)*Point;
   SstopClose = Bstoploss+(5)*Point;
//==============================   Вторaя волна    ====================================
   PriceBuy2  =Ask+(40)*Point;
   PriceSell2 =Bid-(40)*Point;

   BstopProfit2 = PriceBuy2+(25)*Point;
   SstopProfit2 = PriceSell2-(25)*Point;

//--------------------------------  Третья волна  -------------------------------------------
   PriceBuy3  =Ask+(45)*Point;
   PriceSell3 =Bid-(45)*Point;

   BstopProfit3 = PriceBuy3+(60)*Point;
   SstopProfit3 = PriceSell3-(60)*Point;
  }
//==========================================================================
void Case1()
  {
   if(buy==1)
     {
      if(ArrayOrders[OP_SELL]<1&&ArrayOrders[OP_SELL]<1)
        {
         PutOrder(0,Ask,Lot1,0,0);
         PutOrder1(5,SstopOpen,Lot2,0,0);
        }
      return;
     }
  }
//============================================================================================================
//                   OrdersCounter
//==============================================================================
void OrdersCounter(int &array[])
  {
   ArrayInitialize(array,0);
   for(int i=0; i < OrdersTotal(); i++)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderType()==OP_BUY && OrderMagicNumber()==Magic)
           {array[OP_BUY]++; continue;}
         if(OrderType()==OP_SELL&& OrderMagicNumber()==Magic)
           {array[OP_SELL]++; continue;}
         if(OrderType()==OP_BUYSTOP&& OrderMagicNumber()==Magic)
           {array[OP_BUYSTOP]++; continue;}
         if(OrderType()==OP_SELLSTOP&& OrderMagicNumber()==Magic)
           {array[OP_SELLSTOP]++; continue;}
        }
      return;
     }
   return;
  }

//================================================================================
void OnTick()
  {
   Trade();
   if(CountTrades()<1 && t!=Time[0])
     {
      DelOrder();
      Case1();//buy
      //Case2();//sell
      t=Time[0];
      return;
     }
   OrdersCounter(ArrayOrders);
   if(CountTrades()==2)
     {
      if(Last()==0)
        {
         if(CountOrders(1)>0&&CountOrders(5)<1)
            PutOrder2(5,PriceSell2,Lot3,0,0);
         return;
        }
     }

   if(CountTrades()==2)
     {
      if(Last()==1)
        {
         if(CountOrders(0)>0&&CountOrders(4)<1)
            //if(ArrayOrders[OP_BUY]>0&&ArrayOrders[OP_BUYSTOP]<1)
            //{if(ArrayOrders[OP_BUY]<2||ArrayOrders[OP_BUY]>3)
            //{
            PutOrder2(4,PriceBuy2,Lot3,0,0);
         return;
        }
     }
//}}
//============================== третья волна =============================================================
   if(CountTrades()==3)
     {
      if(Last1()==0)
        {
         if(ArrayOrders[OP_BUY]==1&&ArrayOrders[OP_BUYSTOP]<1&&ArrayOrders[OP_SELL]>0)
           {PutOrder3(4,PriceBuy3,Lot3,0,0);}
        }
      if(Last1()==0)
        {
         if(ArrayOrders[OP_SELL]==1&&ArrayOrders[OP_SELLSTOP]<1&&ArrayOrders[OP_BUY]>0)

           {PutOrder3(5,PriceSell3,Lot3,0,0);}
        }
     }

  
   if((OrderMagicNumber()==Magic&&(CountOrders(0)>0&&CountOrders(4)>0&&CountOrders(1)==0))
      ||((CountOrders(0)==0&&CountOrders(5)>0&&CountOrders(1)>0)))
      DelOrder1();
  • 0
  • Просмотров: 725
  • 5 октября 2022, 19:25
  • LeonidPetr
Понравилcя материал? Не забудьте поставить плюс и поделиться в социальной сети!

Вступите в группу "Стол заказов MQL", чтобы следить за обновлениями
ПРИСОЕДИНИТЬСЯ К ГРУППЕ
присоединиться
  Предыдущая запись в группе
доработка индикатора
Следующая запись в группе  
Информационный индикатор на базе 4 TF HA
05 октября 2022
07 октября 2022

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

+
0
мало кто берется править чужой код. простое тз можно рассмотреть
avatar

  34  AM2 Сообщений: 15891 - Андрей

  • 6 октября 2022, 20:24
+
0
Хорошо
Входим в рынок по индикатору стохастик
Если Сигнал выше Buy, иначе — Sell (Ордер — А)
лот 0.1 стоп лосс 90 п. ТейкПрофит 5п.
С ордером А выставляем (ордер В) buystop или sellstop в противоположную сторону через 70п. (ТП — 27 п., стоп лосс 90п. лот 0.5.
при срабатывании ордера В выставляется ордер С с лотом 1.5 buystop или sellstop в противоположную сторону через 50п. ТП — 22 п.
при срабатывании ордера С выставляется ордер D с лотом 1.5 buystop или sellstop в противоположную сторону через 60п. ТП — 60 п.

ТЗ: Написать код, чтобы больше не открывалось ордеров. Когда закрывается один из ABCD — ордеров.
Алгоритм открытия ордеров уже есть. Только этой детали не хватает.
avatar

  2  LeonidPetr Автор Сообщений: 22

  • 7 октября 2022, 00:14

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