Navigation:Home > Content >

RS_2_karlosslim.mq4

Time: 2018-10-28 | Download file:RS_2_karlosslim.mq4

//+------------------------------------------------------------------+
//|                             Сенчаков Михаил.  Русская система.   |
//+------------------------------------------------------------------+
extern string __lot="Настройки лота";
//------------>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
extern int    typeMM            =0;
extern double percent_lot       =1;
extern double percent_lot_limit =1;
extern string __close="Настройки закрытия";
extern double percent_profit    =2;
extern double процент_профита_БУ=0.5;
extern double stop_loss         =50;//%
extern string __orders="Настройки ордеров";
extern int    Step              =14;
extern int    indent            =29;
extern int    kol               =5;
extern string __martin="Настройки откатного мартина (0, 1 или 2)";
extern int    martin_step_limit =14;
extern int    martin_ind_limit  =0; 
extern int после_лимит_орд_вкл_БУ =2;
extern string _friday="Регулировка работы советника в пятницу";
extern bool Закрыть_в_пятницу   =false;
extern bool Стоп_торги_в_пятницу=false;
extern int  Стоп_торги_час      =18;
extern int  Стоп_торги_минут    =30;
extern int  Закрыть_в_час       =21;
extern int  Закрыть_в_минут     =5;
extern string __magics="Уникальные номера";
extern int    magic             =1;
extern int    magic_limit       =2;
//----------->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

double pp;
int Ticket=-1;
int now_long=0;
int now_short=0;
int now_limit=0;
int kol_limit=0;
bool flag_error=false;

double sum_lot_buy=0;
double sum_lot_sell=0;
double ord_price_long=-1;
double ord_price_short=-1;

int init()
  {    
      if (Digits < 4) 
      {
      pp = 0.01;
      } else 
      {
      pp = 0.0001;
      } 
   return(0);
  }
  
double MoneyManagement (double risk)
{
   double Lotsi;
	    
   if (MarketInfo(Symbol(),MODE_MINLOT)==0.1){   
    Lotsi=NormalizeDouble(MathSqrt(MathAbs(AccountFreeMargin())*risk/1000),1);   
    //if ( !flag ) Lotsi=NormalizeDouble(MathAbs(AccountFreeMargin()*risk/1000),1);  
    if (Lotsi<0.1) Lotsi=0.1;
   }  
   if (MarketInfo(Symbol(),MODE_MINLOT)==0.01){
    Lotsi=NormalizeDouble(MathSqrt(MathAbs(AccountFreeMargin())*risk/1000),2);    
    //if ( !flag ) Lotsi=NormalizeDouble(MathAbs(AccountFreeMargin()*risk/1000),2); 
    if (Lotsi<0.01) Lotsi=0.01;
   }  
   return(Lotsi);
} 
//+------------------------------------------------------------------+
//| Расчет начального лота.                                          |
//+------------------------------------------------------------------+  
double lots(double percent_lot)
{
 double Lot;
 
 if (typeMM==0)
 {
  Lot = NormalizeDouble(AccountEquity()*0.01*percent_lot / MarketInfo(Symbol(), MODE_MARGINREQUIRED),2);
 }else
 if (typeMM==1)
 {
  double Free_margin = AccountFreeMargin();
  double One_Lot_cost = MarketInfo(Symbol(),MODE_MARGINREQUIRED);
  double Step_lot = MarketInfo(Symbol(),MODE_LOTSTEP);
  Lot = MathFloor((Free_margin)*percent_lot/100/One_Lot_cost/Step_lot)*Step_lot;
 }else
 if (typeMM==2)
 {
   Lot = MoneyManagement (percent_lot);
 }
 
 return (Lot);
}

//+------------------------------------------------------------------+
//| Считает общее количество ордеров                                 |
//+------------------------------------------------------------------+  
int check()
{
 int kol=0;
 now_long=0;
 now_short=0;
 now_limit=0;
 kol_limit=0;

 sum_lot_buy=0;
 sum_lot_sell=0; 
 
 int min=10000000000;
 double min1= 100;
 double max1= -1;
  
  int total = OrdersTotal() - 1;   
  for (int i = total; i >= 0; i--) 
  { //--- Счетчик открытых ордеров
    if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) 
    {
      if ((OrderMagicNumber() == magic || OrderMagicNumber() == magic_limit) && (OrderType()!=OP_BUY && OrderType()!=OP_SELL))
      {
          kol++;
      }   
      if (OrderMagicNumber() == magic && (OrderType()==OP_BUY || OrderType()==OP_BUYSTOP))
      {
        if (OrderOpenPrice()max1)
        {
          max1=OrderOpenPrice(); ord_price_short=OrderOpenPrice(); 
        }
      }  
      
      if ((OrderMagicNumber() == magic || OrderMagicNumber() == magic_limit))
      {
        if (OrderType()==OP_BUY)
          sum_lot_buy+=OrderLots();
           
        if (OrderType()==OP_SELL)
          sum_lot_sell+=OrderLots();
      }  
            
      if (OrderMagicNumber() == magic && OrderType()==OP_BUY) now_long++;
      if (OrderMagicNumber() == magic && OrderType()==OP_SELL) now_short++;  
      if (OrderMagicNumber() == magic_limit && (OrderType()==OP_BUY || OrderType()==OP_SELL)) now_limit++;
      if (OrderMagicNumber() == magic_limit && (OrderType()!=OP_BUY && OrderType()!=OP_SELL)) kol_limit++;  
    }
  }   
return(kol);
}  

//+------------------------------------------------------------------+
//| Объединение закрывающих функций и обнуление параметров.          |
//+------------------------------------------------------------------+
void close_()
{  
  double tmp=MathAbs(sum_lot_buy-sum_lot_sell);//разница активных лотов
  
  int type=-1;
//OP_BUY	   0	Покупка
//OP_SELL	1	Продажа  
  if (sum_lot_buy>sum_lot_sell)
  type=1; else
  if (sum_lot_buy=0)
  {
    if (GetLastError()==131) {flg=true; break;}
    Ticket=OrderSend(Symbol(),type,tmp,NormalizeDouble(type_price,Digits),3,0,0,"lock :"+TimeToStr(TimeCurrent(),TIME_MINUTES),magic,0,Yellow);
  }
   
  while (flg==false && flag_error==false && close_reserve()==0){}
  if (flg){CloseAll(); CloseAll2();} else CloseAll();
  while (flg==true && flag_error==false && close_reserve()==0){}
}
void CloseAll2()
{
  int total = OrdersTotal() - 1;   
  for (int i = total; i >= 0; i--) 
  { //--- Счетчик открытых ордеров
    if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) 
    {
        if (OrderMagicNumber() == magic || OrderMagicNumber() == magic_limit)
        {
            while (IsTradeAllowed()==false) Sleep(1000);
        
            if (OrderType() == OP_SELL)
            OrderClose(OrderTicket(), OrderLots(), MarketInfo(OrderSymbol(), MODE_ASK), 20, Yellow);
            else
            if (OrderType() == OP_BUY)
            OrderClose(OrderTicket(), OrderLots(), MarketInfo(OrderSymbol(), MODE_BID), 20, Yellow);
            
        }    
    }    
  }
}
//+------------------------------------------------------------------+
//| Удаление отложек по magic номеру.                                |
//+------------------------------------------------------------------+
int close_reserve()
{
  while (check()>0)
  {
    if (GetLastError()==145) {flag_error=true; return(0);}
    
  for (int i=1; i<=OrdersTotal(); i++) 
  { //--- Счетчик открытых ордеров
    if (OrderSelect(i-1, SELECT_BY_POS, MODE_TRADES)) 
    {
        if (OrderMagicNumber() == magic || OrderMagicNumber() == magic_limit)
        {
            while (IsTradeAllowed()==false) Sleep(1000);
            if (OrderType() == OP_BUYLIMIT) OrderDelete(OrderTicket());
            if (OrderType() == OP_BUYSTOP)  OrderDelete(OrderTicket());
            if (OrderType() == OP_SELLLIMIT)OrderDelete(OrderTicket());
            if (OrderType() == OP_SELLSTOP) OrderDelete(OrderTicket());           
        }    
    }    
  }
  } 
  return (1);
}
//+------------------------------------------------------------------+
//| Суммарный профит по всем активным ордерам.                       |
//+------------------------------------------------------------------+
double value_profit()
{
   double ld_0 = 0;
   int l_ord_total_8 = OrdersTotal();
   if (l_ord_total_8 > 0) 
   {
      for (int l_pos_12 = l_ord_total_8 - 1; l_pos_12 >= 0; l_pos_12--) 
      {
         if (OrderSelect(l_pos_12, SELECT_BY_POS, MODE_TRADES))
         {
          if (OrderMagicNumber() == magic || OrderMagicNumber() == magic_limit)
          ld_0 += OrderProfit() + OrderSwap()+OrderCommission();
         } 
      }
   }
  return(ld_0);
}
//+------------------------------------------------------------------+
//| Закрытие всех активных ордеров.                                  |
//+------------------------------------------------------------------+
void CloseAll()
{
 int i;
 while(true) 
 { 
  double Lot_Buy = -1.0; 
  double Lot_Sell = -1.0;  
  for (i=1; i<=OrdersTotal(); i++)
  { 
    if (OrderSelect(i-1,SELECT_BY_POS))
    {
     if (OrderMagicNumber() == magic || OrderMagicNumber() == magic_limit)
     {   
     int Type = OrderType();
     if (Type>1) continue; 
     if (Type==OP_BUY && OrderLots()>Lot_Buy) 
     {
       Lot_Buy=OrderLots(); 
       int OrderTicket_Buy=OrderTicket();
     }
     if (Type==OP_SELL && OrderLots()>Lot_Sell) 
     {
       Lot_Sell=OrderLots(); 
       int OrderTicket_Sell=OrderTicket();
     }
     } 
    }
  }
  if (Lot_Buy<0 || Lot_Sell<0) return; //?
  while (true) 
  {
    while (IsTradeAllowed()==false) Sleep(1000);
    if (OrderCloseBy(OrderTicket_Buy,OrderTicket_Sell)) break; 
    int Error=GetLastError(); 
    switch(Error) 
    {
     case 4: Print("Торговый сервер занят. Ещё одна попытка...",Error);
     Sleep(3000); 
     continue; 
     case 137: Print("Брокер занят. Ещё одна попытка...",Error);
     Sleep(3000); 
     continue; 
     case 146: Print("Подсистема торговли занята. Ещё одна попытка...",Error);
     Sleep(500); 
     continue; 
     default: Print("Возникла критическая ошибка ",Error); 
    }
    return; 
  } 
} 
//<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>
}
//+------------------------------------------------------------------+
//| Установка блока.                                                 |
//+------------------------------------------------------------------+
int Block_()
{  
  int Step_stop;
  int n;
  double sizelot_main=0;
  double ask=Ask;
  double bid=Bid;
  
  double Lot_main   =lots(percent_lot);

  for (int i=1;i<=kol;i++)
  {
    if (i==1)
    { 
      sizelot_main  =0; Step_stop=-1*Step;
    }
      sizelot_main+=Lot_main; Step_stop=Step_stop+Step;
    //-----
      while (IsTradeAllowed()==false) Sleep(1000);
      n=3;
      Ticket=-1;
      while (Ticket<0 && n>0)
      {
        Ticket=OrderSend(Symbol(),OP_BUYSTOP,sizelot_main,NormalizeDouble(ask+indent*pp+Step_stop*pp,Digits),3,0,0,"buy RS :"+TimeToStr(TimeCurrent(),TIME_MINUTES),magic,0,Blue);
        n--;
      }
      while (IsTradeAllowed()==false) Sleep(1000);

      n=3;
      Ticket=-1;
      while (Ticket<0 && n>0)
      {
        Ticket=OrderSend(Symbol(),OP_SELLSTOP,sizelot_main,NormalizeDouble(bid-indent*pp-Step_stop*pp,Digits),3,0,0,"sell RS :"+TimeToStr(TimeCurrent(),TIME_MINUTES),magic,0,Red);
        n--;
      }           
  }    
}
//<<<<---------------------->>>>
int limits(int type)//<<<<<-------- 0 - мартин-сетку вверх, 1 - мартин-сетку вниз
{     
  double sizelot_limit=lots(percent_lot_limit);
  double lot_limit=sizelot_limit;
    
  int step_limit=martin_step_limit;
  int n;
  
    if (type==0) 
    {
      while ((ord_price_short+martin_ind_limit*pp+step_limit*pp)0)
       {
         Ticket=OrderSend(Symbol(),OP_SELLLIMIT,sizelot_limit,NormalizeDouble(ord_price_short+martin_ind_limit*pp+step_limit*pp,Digits),3,0,0,"sell RS :"+TimeToStr(TimeCurrent(),TIME_MINUTES),magic_limit,0,Red);
         n--;
       }
       step_limit+=martin_step_limit; 
       sizelot_limit+=lot_limit;
      }
    } else
    if (type==1) 
    {
      while ((ord_price_long-martin_ind_limit*pp-step_limit*pp)>ord_price_short)
      {while (IsTradeAllowed()==false) Sleep(1000);
       n=3;
       Ticket=-1;
       while (Ticket<0 && n>0)
       {
         Ticket=OrderSend(Symbol(),OP_BUYLIMIT,sizelot_limit,NormalizeDouble(ord_price_long-martin_ind_limit*pp-step_limit*pp,Digits),3,0,0,"buy RS :"+TimeToStr(TimeCurrent(),TIME_MINUTES),magic_limit,0,Blue);
         n--;
       }
       step_limit+=martin_step_limit; 
       sizelot_limit+=lot_limit;
      }
    }  
}
//<<<<---------------------->>>>
int start()
  {  
  if (check()>0 && flag_error==true) close_reserve();
  
  if (Закрыть_в_пятницу)
    if (DayOfWeek()==5 && Hour()>=Закрыть_в_час && Minute()>=Закрыть_в_минут) close_();
    
   if (check()>0)
   {    
        //<<<<---------------------->>>>
        if (now_short>0 && now_long==0 && now_limit==0 && kol_limit==0)// if "buy"
        {
          limits(0);
        }else
        if (now_short==0 && now_long>0 && now_limit==0 && kol_limit==0)// if "sell"
        {
          limits(1);
        }
        //<<<<---------------------->>>> 
        double loss=0;
        if (value_profit()<0)
        loss=(-1*value_profit()*100)/AccountBalance();//%  
    
        if (loss>=stop_loss) {close_();}
        //<<<<---------------------->>>>    
        double profit=0;
        if (value_profit()>0)
        profit=(value_profit()*100)/AccountBalance();//%  
        
        if (now_limit>=после_лимит_орд_вкл_БУ)
        {
          if (profit>=процент_профита_БУ) {close_();}
        }else
        {
          if (profit>=percent_profit) {close_();}//закрываем все и всё при достижении заданного профита.  
        }       
   }
    
   if (check()==0)
   {//start
    if (Стоп_торги_в_пятницу)
     if (DayOfWeek()==5 && Hour()>=Стоп_торги_час && Minute()>=Стоп_торги_минут) return(0);
     flag_error=false;
     while (IsTradeAllowed()==false) Sleep(1000);  
     //Устанавливаем сетку.
       Block_();
   }
  }
//END  

Recommend