Подходящий индюк.

<code>/* 
   Introduction:

   Draw ranges for "Simple Combined Breakout System for EUR/USD and GBP/USD" thread
   (see http://www.strategybuilderfx.com/forums/showthread.php?t=15439)

   LocalTimeZone: TimeZone for which MT4 shows your local time, 
                  e.g. 1 or 2 for Europe (GMT+1 or GMT+2 (daylight 
                  savings time).  Use zero for no adjustment.
                  
                  The MetaQuotes demo server uses GMT +2.   
   Enjoy  :-)
   Markus
*/
#property indicator_chart_window
#property indicator_buffers 5
#property indicator_color1 Red
#property indicator_color2 Red
#property indicator_color3 LightGray
#property indicator_color4 LightGray
#property indicator_color5 Blue
//----
extern int LocalTimeZone = 2;
extern int DestTimeZone  = 6;
extern int PipsForEntry  = 80;
//----
double Zone1Upper[];
double Zone2Upper[];
double Zone1Lower[];
double Zone2Lower[];
double SignalsBuffer[];
//+------------------------------------------------------------------+
int init()
{
      SetIndexStyle(0,DRAW_LINE);  SetIndexBuffer(0,Zone1Upper);    SetIndexEmptyValue(0, 0.0);
      SetIndexStyle(1,DRAW_LINE);  SetIndexBuffer(1,Zone1Lower);    SetIndexEmptyValue(1, 0.0);
      SetIndexStyle(2,DRAW_NONE);  SetIndexBuffer(2,Zone2Upper);    SetIndexEmptyValue(2, 0.0);
      SetIndexStyle(3,DRAW_NONE);  SetIndexBuffer(3,Zone2Lower);    SetIndexEmptyValue(3, 0.0);
      SetIndexStyle(4,DRAW_ARROW); SetIndexBuffer(4,SignalsBuffer); SetIndexArrow     (4, 156);      
   return(0);
}
//+------------------------------------------------------------------+
int deinit()
{
   return(0);
}
//+------------------------------------------------------------------+
int start()
{
   int counted_bars= IndicatorCounted(),lastbar;
//----
   if (Bars<=100)
      return(0);
   if (counted_bars>0)
      counted_bars--;
//----
   lastbar= Bars - counted_bars;
//----
   BreakoutRanges(0, lastbar, LocalTimeZone, DestTimeZone);
   return(0);
}
//+------------------------------------------------------------------+
//| Compute index of first/last bar of yesterday and today           |
//+------------------------------------------------------------------+
int BreakoutRanges(int offset, int lastbar, int tzlocal, int tzdest)
  {
   int i, j, k,
   tzdiff= tzlocal - tzdest,
   tzdiffsec= tzdiff*3600,
   tidxstart[2]= { 0, 0},
   tidxend[2]= { 0, 0 };
   double thigh[2]= { 0.0, 0.0 },
   tlow[2]= { 99999.9, 99999.9 };
   string tfrom[3]= { "04:00", "08:00" ,  /*rest of day: */ "12:00"},
          tto[3]=   { "08:00", "12:00",   /*rest of day: */ "24:00" },
   tday;
   bool inperiod= -1;
   datetime timet;
   // search back for the beginning of the day
   tday= TimeToStr(Time[lastbar]-tzdiffsec, TIME_DATE);
   
     for( ;lastbar<Bars; lastbar++) 
     {
        if (TimeToStr(Time[lastbar] - tzdiffsec, TIME_DATE)!=tday) 
        {
         lastbar--;
         break;
        }
     }
   // find the high/low for the two periods and carry them forward through the day
   tday= "XXX";
     for(i= lastbar; i>=offset; i--) 
     {
      timet= Time[i] - tzdiffsec;   // time of this bar
//----
      string timestr= TimeToStr(timet, TIME_MINUTES),    // current time HH:MM
      thisday= TimeToStr(timet, TIME_DATE);       // current date
      // for all three periods (first period, second period, rest of day)
      
        for(j= 0; j<3; j++) 
        {
           if (tfrom[j]<=timestr && timestr<tto[j]) 
           {   // Bar[i] in this period
              if (inperiod!=j) 
              { // entered new period, so last one is completed
                 if (j>0) 
                 {      // now draw high/low back over the recently completed period
                    for(k= tidxstart[j-1]; k>=tidxend[j-1]; k--) 
                    {
                       if (j-1==0) 
                       {
                        Zone1Upper[k]= thigh[j-1];
                        Zone1Lower[k]= tlow[j-1];
                       }
                       if (j-1==1) 
                       {
                        Zone2Upper[k]= thigh[j-1];
                        Zone2Lower[k]= tlow[j-1];
                       }
                    }
                 }
               inperiod= j;   // remember current period
              }
            if (inperiod==2)   // inperiod==2 (end of day) is just to check completion of zone 2
               break;
            // for the current period find idxstart, idxend and compute high/low
              if (tidxstart[j]==0) 
              {
               tidxstart[j]= i;
               tday= thisday;
              }
            tidxend[j]= i;
//----
            thigh[j]= MathMax(thigh[j], High[i]);
            tlow[j]= MathMin(tlow[j], Low[i]);
           }
        }
      // carry forward the periods for which we have definite high/lows
        if (inperiod>=1 && tday==thisday) 
        { // first time period completed
         Zone1Upper[i]= thigh[0] + PipsForEntry*Point;
         Zone1Lower[i]= tlow[0] - PipsForEntry*Point;
//----
           if (inperiod>=2) 
           {   // second period completed
            Zone2Upper[i]= thigh[1] + PipsForEntry*Point;
            Zone2Lower[i]= tlow[1] - PipsForEntry*Point;
           }
        }
        else 
        {   // none yet to carry forward (zero to clear old values, e.g. from switching timeframe)
         Zone1Upper[i]= 0;
         Zone1Lower[i]= 0;
         Zone2Upper[i]= 0;
         Zone2Lower[i]= 0;
        }
      // at the beginning of a new day reset everything
        if (tday!="XXX" && tday!=thisday) 
        {
         Print("#", i, "new day ", thisday, "/", tday);
//----
         tday= "XXX";
//----
         inperiod= -1;
//----
           for(j= 0; j<2; j++) 
           {
            tidxstart[j]= 0;
            tidxend[j]= 0;
            thigh[j]= 0;
            tlow[j]= 99999;
           }
        }
     }
   return(0);
  }
//+------------------------------------------------------------------+

</code>

Сделал сову чисто по барам.
Ссылка для скачивания кому интересно disk.yandex.ru/d/XzsD7COzDjC5Ug



Это за месяц. Сильно не настраивал, но видно, что советник проседает во флете.
Дальше займусь переходом к сигналам индюка и защитой от просадки.

3-я часть для склейки

for(int i=OrdersTotal()-1;i>=0;i--)
              if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
                if(OrderMagicNumber()==MagicNumber)
                   if(OrderSymbol()==Symbol())
                      {
                      op=OrderOpenPrice();
                      sl=OrderStopLoss();
                      tp=OrderTakeProfit();
                      lt=NL(OrderLots());
                      tk=OrderTicket();
                      double Price=op;
                           
                        //------------- ТР и SL ------------ 
                        if(tp==0 && TakeProfit!=0)
                           {
                           if(OrderType()==OP_BUY)                      
                              if(!OrderModify(tk,op,NSL(OP_BUY, op),NTP(OP_BUY, op),0,clrBlue))    // Устанавливаем ТР и SL
                                 Print("Order Modify 4b_tp error #",GetLastError());
                           //---
                           if(OrderType()==OP_SELL)
                              if(!OrderModify(tk,op,NSL(OP_SELL, op),NTP(OP_SELL, op),0,clrRed))   // Устанавливаем ТР и SL
                                 Print("Order Modify 4s_tp error #",GetLastError());
                           }
                                    
                        //------------------ Average ------------ 
                        if(Average)
                           {
                           if(OrderType()==OP_BUY && b>=2)
                             {
                             if(tk==BuyPriceMaxTic || tk==BuyPriceMinTic)                          // Крайние ордера
                                if(Bid<AwerageBuyPrice && tp!=AwerageBuyPrice)
                                   if(!OrderModify(tk,op,0,AwerageBuyPrice,0,clrBlue))             // Выставляем ТР в БУ+
                                      Print("Order Modify 5b_AverTP error #",GetLastError());
                                       
                             if((tk!=BuyPriceMaxTic || tk!=BuyPriceMinTic) && tp!=0 && sl==0)      // Стали не крайними ордера
                                if(!OrderModify(tk,op,NSL(OP_BUY, op),NTP(OP_BUY, op),0,clrBlue))  // Восстанавливаем ТР и SL
                                   Print("Order Modify 5b_!AverSL&TP error #",GetLastError());
                             }
                           //---
                           if(OrderType()==OP_SELL && s>=2)                                        // С продажами аналогично
                             {
                             if(tk==SelPriceMaxTic || tk==SelPriceMinTic)                          // Крайние ордера
                                if(Ask>AwerageSelPrice && tp!=AwerageSelPrice)
                                   if(!OrderModify(tk,op,0,AwerageSelPrice,0,clrRed))              // Выставляем ТР в БУ+
                                      Print("Order Modify 5s_AverTP error #",GetLastError());
            
                             if((tk!=SelPriceMaxTic || tk!=SelPriceMinTic) && tp!=0 && sl==0)      // Стали не крайними ордера
                                if(!OrderModify(tk,op,NSL(OP_SELL, op),NTP(OP_SELL, op),0,clrRed)) // Восстанавливаем ТР и SL
                                   Print("Order Modify 5s_!AverSL&TP errorerror #",GetLastError());
                             }
                           } 
                        }
            if(BU_ON) BU();
}
// --------------------------------------------------------
bool ValidLot(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);
}
//---------------------------------------------------------------   
double NL(double lot) // нормализация лота
{
	double LotStep=MarketInfo(Symbol(), MODE_LOTSTEP);
	int k=0;
	if (LotStep<=0.001) k=3; else if (LotStep<=0.01) k=2; else if (LotStep<=0.1) k=1;   // шаг лота

	double MinLot=MarketInfo(Symbol(), MODE_MINLOT);
	double MaxLot=MarketInfo(Symbol(), MODE_MAXLOT);
	return ND(MathMin(MaxLot, MathMax(MinLot, lot)), k); // венули нормализованный лот
}
//---------------------------------------------------------------   
double NTP(int dir, double _op) // Нормализация цены тейкпрофита
{
	if (TakeProfit==0) 
	   return 0;
	double StopLvl=MarketInfo(Symbol(), MODE_STOPLEVEL)*Point;
	double pr=NP((dir==OP_BUY)?Bid:Ask);
	if (dir==OP_BUY) 
	   { 
	   tp=_op+TakeProfit*Point; 
	   return NP(MathMax(tp, pr+StopLvl)); 
	   }
	if (dir==OP_SELL) 
	   { 
	   tp=_op-TakeProfit*Point; 
	   return NP(MathMin(tp, pr-StopLvl)); 
	   }
	return 0;
}
//---------------------------------------------------------------   
double NSL(int dir, double _op) // Нормализация цены стоплоса
{
	if (StopLoss==0) 
	   return 0;
	double StopLvl=MarketInfo(Symbol(), MODE_STOPLEVEL)*Point;
	double pr=NP((dir==OP_BUY)?Bid:Ask);
	if (dir==OP_BUY) 
	   { 
	   sl=_op-StopLoss*Point; 
	   return NP(MathMin(sl, pr-StopLvl)); 
	   }
	if (dir==OP_SELL) 
	   { 
	   sl=_op+StopLoss*Point; 
	   return NP(MathMax(sl, pr+StopLvl)); 
	   }
	return 0;
}
//---------------------------------------------------------------   
double ND(double d, int n=-1) 
   { 
   if (n<0) 
      return NormalizeDouble(d, Digits); 
   return NormalizeDouble(d, n); 
   }
//---------------------------------------------------------------   
double NP(double d) 
   { 
   double TickSize=MarketInfo(Symbol(), MODE_TICKSIZE); 
   if (TickSize==0) 
      TickSize=1; 
   return ND(MathRound(d/TickSize)*TickSize); 
   }
//-----------------------------------------------------------------
bool BU()
{ 
   for(int i=OrdersTotal()-1;i>=0;i--)
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
         if(OrderMagicNumber()==MagicNumber)
            if(OrderSymbol()==Symbol())
              {
              double  sl_min = MarketInfo(Symbol(), MODE_STOPLEVEL)*Point,
                      TP = OrderTakeProfit();
                      op = OrderOpenPrice();
                      lt = OrderLots();
              double _lt = NormalizeDouble(lt/2,2);
//              if (_lt==0) break;
              
              double LevelBU = MathAbs(op-TP);
                     
              if(OrderType()==OP_BUY && Ask >= op+LevelBU/2*Point)
                if(OrderModify(OrderTicket(),op,NormalizeDouble(Ask-sl_min,Digits),OrderTakeProfit(),0,clrNONE))
                  if(!OrderClose(OrderTicket(),_lt,Bid,Slippage))
                    Sleep(500);
              //---
              if(OrderType()==OP_SELL && Bid <= op-LevelBU/2*Point)
                if(OrderModify(OrderTicket(),op,NormalizeDouble(Bid+sl_min,Digits),OrderTakeProfit(),0,clrNONE))
                  if(!OrderClose(OrderTicket(),_lt,Ask,Slippage))
                    Sleep(500);
              }
   return true;
}
//-------------------------------------------------------------------------------

Нифига себе солянка. Тестирование мне на годы.

2-ая часть для склейки.

//--------------- Открытие последующих ордеров ----------------------------
         
         datetime CurTime = iTime(NULL, TF, 0); 
                                                             
         if(CountSL<=Count_SL || CurTime>=LastTimeSL+60*SleepMin)// Если число убыточных ордеров меньше выбранного 
            {                                                    // или уже прошло указанное время после мах. числа убыточных ордеров, 
            if(ModeFirstTrade != Candle)                         // то открываем ордера дальше.
               {
               if(LastCloseTP_SL=="TP" && s+b==0)
                  {
                  Lot = NL(StartLot);
                  if(!ValidLot(Lot)) return;  
                  
                  if(LastCloseType==OP_BUY)
                     {
                     if(!OrderSend(Symbol(),OP_BUY,Lot,Ask,Slippage,0,0," ",MagicNumber,0,clrBlue)) 
                        { 
                        Print("Order Send завершилась с ошибкой #",GetLastError());
                        return;
                        } 
                     }
                  if(LastCloseType==OP_SELL)
                     {
                     if(!OrderSend(Symbol(),OP_SELL,Lot,Bid,Slippage,0,0," ",MagicNumber,0,clrRed)) 
                        { 
                        Print("Order Send завершилась с ошибкой #",GetLastError());
                        return;
                        }    
                     }
                  }
               //----------------------------   
               if(LastCloseTP_SL=="SL" && s+b==0)
                  {
                  Lot = MathCeil((LastCloseLot * LotK)*100)/100;
                  if(Lot > MaximalLots)
                     Lot = MaximalLots;
                  Lot = NL(Lot);
                  if(!ValidLot(Lot)) return;  
                  
                  if(LastCloseType==OP_BUY)
                     {
                     if(!OrderSend(Symbol(),OP_SELL,Lot,Bid,Slippage,0,0," ",MagicNumber,0,clrRed)) 
                        { 
                        Print("Order Send завершилась с ошибкой #",GetLastError());
                        return;
                        }    
                     }
                  if(LastCloseType==OP_SELL)
                     {
                     if(!OrderSend(Symbol(),OP_BUY,Lot,Ask,Slippage,0,0," ",MagicNumber,0,clrBlue)) 
                        { 
                        Print("Order Send завершилась с ошибкой #",GetLastError());
                        return;
                        } 
                     }
                  }
               }
            //---------------------------------------------------------------------------------------   
            if(ModeFirstTrade == Candle)
               {
               
               
               if(LastCloseTP_SL=="TP" && s+b==0)  // Нет ордеров, а полследний закрылся с профитом
                  {
                  Lot = StartLot;
                  Lot = NL(Lot);
                  if(!ValidLot(Lot)) return;  
                  
                  if(LastCloseType==OP_BUY && Close[1]>Open[1])
                     {
                     if(!OrderSend(Symbol(),OP_BUY,Lot,Ask,Slippage,0,0," ",MagicNumber,0,clrBlue)) 
                        { 
                        Print("Order Send завершилась с ошибкой #",GetLastError());
                        return;
                        } 
                     }
                  if(LastCloseType==OP_SELL && Close[1]<Open[1])
                     {
                     if(!OrderSend(Symbol(),OP_SELL,Lot,Bid,Slippage,0,0," ",MagicNumber,0,clrRed)) 
                        { 
                        Print("Order Send завершилась с ошибкой #",GetLastError());
                        return;
                        }    
                     }
                  }
               //----------------------------   
               if(LastCloseTP_SL=="SL" && s+b==0)  // Нет ордеров, а полследний закрылся с убытком
                  {   
                  Lot = MathCeil((LastCloseLot * LotK)*100)/100;
                  if(Lot > MaximalLots)
                     Lot = MaximalLots;
                  Lot = NL(Lot);
                  if(!ValidLot(Lot)) return;  
                  
                  if(LastCloseType==OP_BUY && Close[1]<Open[1])
                     {
                     if(!OrderSend(Symbol(),OP_SELL,Lot,Bid,Slippage,0,0," ",MagicNumber,0,clrRed)) 
                        { 
                        Print("Order Send завершилась с ошибкой #",GetLastError());
                        return;
                        }    
                     }
                  if(LastCloseType==OP_SELL && Close[1]>Open[1])
                     {
                     if(!OrderSend(Symbol(),OP_BUY,Lot,Ask,Slippage,0,0," ",MagicNumber,0,clrBlue)) 
                        { 
                        Print("Order Send завершилась с ошибкой #",GetLastError());
                        return;
                        } 
                     }
                  }
                }
             }
         //---------------- Есть ордера - усредняем с шагом ----------------------   
         if(Average)
            {
            if(s > 0 && Close[1] < Open[1])
               if((Bid - SelPriceMax) >= (PointOrderStep * Point()))
                 {
                 Lot = MathCeil(SelLimPriceMaxLot*100*LotK/100);
                 if(Lot > MaximalLots)
                    Lot = MaximalLots;
                 Lot = NL(Lot);
                 if(!ValidLot(Lot)) return;  

                 if(!OrderSend(Symbol(), OP_SELL, NormalizeDouble(Lot, 2), Bid, Slippage, 0, 0, "", MagicNumber, 0, clrRed))
                    Print("OrderSend error #", GetLastError());
                 }
            //---
            if(b > 0 && Close[1] > Open[1])
               if((BuyPriceMin - Ask) >= (PointOrderStep * Point()))
                 {
                 Lot = MathCeil(BuyLimPriceMin*100*LotK/100);
                 if(Lot > MaximalLots)
                    Lot = MaximalLots;
                 Lot = NL(Lot);
               if(!ValidLot(Lot)) return;  
                    Lot = NormalizeDouble(MaximalLots,2);

                 if((!OrderSend(Symbol(),OP_BUY, NormalizeDouble(Lot, 2), Ask, Slippage, 0, 0, "",MagicNumber, 0, clrBlue))<=0)
                    Print("OrderSend error #", GetLastError());
                 }      
            } 
            //--------------- Расчет ТР и SL -------------------------------              
         	   double StopLvl = NormalizeDouble(MarketInfo(Symbol(), MODE_STOPLEVEL)*Point,Digits);
               double atr     = iATR(NULL,TF,Per_ATR,iB)*10000;  // ATR (in pips)
               
         	if(SL_k_ATR==0)
               sl = NormalizeDouble(StopLoss*Point,Digits);
            else
               sl = NormalizeDouble(atr*SL_k_ATR*Point,Digits);
               if(sl<StopLvl)
                  sl=StopLvl;
               //---
         	if(TP_k_ATR==0)
               tp = NormalizeDouble(TakeProfit*Point,Digits);
            else
               tp = NormalizeDouble(atr*TP_k_ATR*Point,Digits);
               if(tp<StopLvl)
                  tp=StopLvl;
            //--------------- Установка ТР, SL и Average price ----------------------------

1-ая часть для «склейки».

#property strict

// Ввёл усреднение на откатах Average=true, но сильно не тестировал.
// PointOrderStep и MinimalProfit работают только для Average=true.
// Если SL_k_ATR=0 или TP_k_ATR=0, то StopLoss или соответственно TakeProfit подбираются в пипсах.
// Вижу смысл в подборе SL с помощью SL_k_ATR, а ТР по фиксированному значению в пипсах при TP_k_ATR=0. Хотя...
// Поробовал ввести задержку в минутах SleepMin, после получения Count_SL подряд убыточных ордеров, но
// кажется не работает. В дефолте отключена (SleepMin=0<img src='http://opentraders.ru/templates/skin/g6h/images/smilies/017.gif' alt=' ;) '> .

//--- input parameters
enum MODE {
          Buy    = 0,  // Покупка
          Sell   = 1,  // Продажа
          Candle = 2   // По свече
          };
//---          
input MODE            ModeFirstTrade = Buy;       // ModeFirstTrade Тип первой сделки
input int             Count_SL       = 3;         // Счетчик SL подряд
input int             SleepMin       = 0;         // Задержка мин. при четчике SL== 
input bool            BU_ON          = true;      // BU ON          Включение режима Save
//---
input bool            Average        = false;     // Average        Включение усредняющих ордеров
input int             PointOrderStep = 390;       // Order step (in pips)
input int             MinimalProfit  = 20;        // Minimal Profit Для усреднения ордеров      
//---
input double          StartLot       = 0.01;      // Start Lot      Лот стартовый
input double          LotK           = 2.2;       // Коэф. увеличения лота
input double          MaximalLots    = 1.28;      // Maximal Lots
//--- 
input int             StopLoss       = 372;       // Stop Loss      Потери в пунктах
input int             TakeProfit     = 354;       // Take Profit    Прибыль в пунктах
input double          SL_k_ATR       = 5;         // SL_k_ATR       Коэффициент к ATR для SL      
input double          TP_k_ATR       = 77;        // TP_k_ATR       Коэффициент к ATR для TP 
//---      
input int             Per_ATR        = 9;         // Period ATR
input ENUM_TIMEFRAMES TF             = PERIOD_M5; // Тайм Фрейм для расчета входа//---
input int             Slippage       = 30;        // Slippage
input int             MagicNumber    = 1961;      // Magic Number
//---                                   
int      iB=1, LastCloseType, tk,CountSL=0; 
double   tp,sl,Lot,lt,op;
datetime LastTimeSL=0;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
   return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
      int b=0,s=0; 
      
      double
      SelPriceMin = 0, SelPriceMax = 0, SelPriceMinLot = 0, SelPriceMaxLot = 0,LastCloseLot=0,
      BuyPriceMax = 0, BuyPriceMin = 0, BuyPriceMaxLot = 0, BuyPriceMinLot = 0,
      SelLimPriceMin = 0, SelLimPriceMax = 0, SelLimPriceMinLot = 0, SelLimPriceMaxLot = 0,
      BuyLimPriceMax = 0,BuyLimPriceMin=0;
   
      int
      SelPriceMaxTic = 0, SelPriceMinTic = 0,
      BuyPriceMaxTic = 0, BuyPriceMinTic = 0,
      SelLimPriceMaxTic = 0, SelLimPriceMinTic = 0,
      BuyLimPriceMaxTic = 0, BuyLimPriceMinTic = 0;
      
      string   LastCloseTP_SL="0";

   
      for(int i=OrdersTotal()-1;i>=0;i--)
         if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
            if(OrderMagicNumber()==MagicNumber)
               if(OrderSymbol()==Symbol())
                  {
                  op = NormalizeDouble(OrderOpenPrice(), Digits());
                  lt = NormalizeDouble(OrderLots(), 2);
                  tk = OrderTicket();
    
                  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;
                       }
                    }
                  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;
                      }
                    }
                  }
         //-------------------- AVERAGE -------------------------------------
         double   AwerageBuyPrice=0,AwerageSelPrice=0;
      
         if(Average)
            {
            if(b>=2) 
               AwerageBuyPrice=NormalizeDouble((BuyPriceMax*BuyPriceMaxLot+BuyPriceMin*BuyPriceMinLot)/(BuyPriceMaxLot+BuyPriceMinLot)+MinimalProfit*Point(),Digits());
            if(s>=2) 
               AwerageSelPrice=NormalizeDouble((SelPriceMax*SelPriceMaxLot+SelPriceMin*SelPriceMinLot)/(SelPriceMaxLot+SelPriceMinLot)-MinimalProfit*Point(),Digits());
            }
         //-------------------- HISTORY -------------------------------------
      if(s+b==0)
         for (int i = OrdersHistoryTotal()-1; i >=0; i--)
            if(OrderSelect(i,SELECT_BY_POS,MODE_HISTORY))
               if (OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber && (OrderType()==OP_BUY || OrderType()==OP_SELL))
                  {
                  if (StringFind(OrderComment(),"[sl]")>-1 && iBarShift(NULL,TF,OrderCloseTime())==0)
                     {
                     LastCloseTP_SL = "SL";
                     LastCloseType  = OrderType();
                     LastCloseLot   = OrderLots();
                     LastTimeSL     = OrderCloseTime();
                     CountSL ++;
                     break;
                     }
                  if (StringFind(OrderComment(),"[tp]")>-1 && iBarShift(NULL,TF,OrderCloseTime())==0)
                     {
                     LastCloseTP_SL = "TP";
                     LastCloseType  = OrderType();
                     LastCloseLot   = OrderLots();
                     CountSL = 0;
                     break;
                     }
                  }
      //--------------- Открытие самого первого ордера --------------------------------
         if(s+b==0 && LastCloseLot==0)                // Нет и не открывались ордера
            {
            if(ModeFirstTrade == Buy)
               {
               if(!OrderSend(Symbol(),OP_BUY,StartLot,Ask,Slippage,0,0," ",MagicNumber,0,clrRed)) 
                  { 
                  Print("Order Send завершилась с ошибкой #",GetLastError());
                  return;
                  } 
               }
            //----------------------------------------------------------------- 
            if(ModeFirstTrade == Sell)
               {
               if(!OrderSend(Symbol(),OP_SELL,NL(StartLot),Bid,Slippage,0,0," ",MagicNumber,0,clrRed)) 
                  { 
                  Print("Order Send завершилась с ошибкой #",GetLastError());
                  return;
                  }    
               }
            //----------------------------------------------------------------- 
            if(ModeFirstTrade == Candle)
               {
               if(Close[iB] < Open[iB])
                  if(! OrderSend(Symbol(),OP_SELL,NL(StartLot),Bid,Slippage,0,0," ",MagicNumber,0,clrRed)) 
                     { 
                     Print("Order Send завершилась с ошибкой #",GetLastError());
                     return;
                     }    
               //-----------------
               if(Close[iB] > Open[iB])
                 if(!OrderSend(Symbol(),OP_BUY,NL(StartLot),Ask,Slippage,0,0," ",MagicNumber,0,clrRed)) 
                   { 
                   Print("Order Send завершилась с ошибкой #",GetLastError());
                   return;
                   } 
               }
            }
            //--------------- Открытие последующих ордеров ----------------------------

По просьбе preasto собрал сборную солянку.
Хотя далёк от мысли, что это даст результат.
Если бы тестирующие давали обратную связь, что такое хорошо, что такое плохо!!!
А лично моих мощностей не хватает, чтобы протестировать всё и сразу.
Не… пенсию просчитал быстро и без ошибок. Так что Надежда Ивановна есть.
Это последний открытый код. Далее ухожу в подполье. Там бочонок с вином.

А вообще-то, поковырявшись в неваляшке, я понял её главную идею.
С усреднителями-мартышками не работает. А с любым другим советником при SL торгуем по направлению алгоритма советника, но удваиваем лот от нормы.

Поле не паханное. К половине советников можно приложить.

Уважаемый preasto, видите ли я не считаю необходимым выкладывать сборник всего, включая то, что не оправдало себя.
Например, коэффициенты для SL и ТР от ATR в моих тестах показали плохие результаты. Но я ещё ТОТ тестер. Может надо было дойти до М1?
Советник этот выложен тут последним. Никто не написал ничего по этому поводу. Даже не пробовали тестировать. Все ждут когда я сломаюсь.

Да ради бога. Я это сделал. Теперь работаю исключительно для себя.
Буду по мере продвижения выкладывать здесь закрытые ограниченные файлы продвижения. Может ничего и не выйдет толкового.

Нет не пробовал. Пока что только цену для открытия тралил.

Нашел причину такого поведения ATR. Тестировать SL_k_ATR и ТР_k_ATR надо в большем диапазоне. От 0 до 100 и более. Особенно SL. Так что ATR скидывать со счетов пока рановато.



А пока кардинально повлиять на алгоритм не удалось.
Думаю надо
1. пробовать поработать по свечам.
2. привязаться к какому-то индюку.
Теперь точно спать.

Последние два варианта говорят против ATR. Не могу понять причину.
Видимо Значения SL и ТР часто меньше стоплевела и поэтому не отрабатывают, как задумывалось. Вижу только один вариант(последний) уйти в виртуальные SL-ТР.
Потом попробую. Пока спать.

График оптимизации с привязкой к ATR и с функцией Сейф.

#property strict

//--- input parameters
enum MODE {
          Buy    = 0,  // Покупка
          Sell   = 1,  // Продажа
          Candle = 2   // По свече
          };
//---          
input MODE            ModeFirstTrade      = Buy;       // Тип первой сделки
input bool            BU_ON               = true;
input double          StartLot            = 0.02;      // Лот базовый
input double          SL_k_ATR            = 0.9;       
input double          TP_k_ATR            = 1.9;       
input double   LotK                       = 2.2;       // Коэф. увеличения лота
input int             Per_ATR             = 9;
input ENUM_TIMEFRAMES TF                  = PERIOD_M5; // Тайм Фрейм для ATR
input ENUM_TIMEFRAMES TF_ATR              = PERIOD_H1; // Тайм Фрейм для расчета входа
input int             Slippage            = 30;        // Slippage
input int             MagicNumber         = 1961;      // Magic Number
//---                                          
int      LastCloseType, iB=1; 
double   LastCloseLot;
double   LastCloseProfit, LevelBU;
double   tp,sl,Lot;
bool     Trade = false;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
   return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
      int b=0,s=0;
   
      for(int i=OrdersTotal()-1;i>=0;i--)
         if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
            if(OrderMagicNumber()==MagicNumber)
               if(OrderSymbol()==Symbol())
                  {
                  if(OrderType()==OP_BUY)  b++;
                  if(OrderType()==OP_SELL) s++;
                  }
      //---
      LastCloseType=-1;
      datetime CloseTime=0;
      
      for(int i=OrdersHistoryTotal()-1;i>=0;i--)
         if(OrderSelect(i,SELECT_BY_POS,MODE_HISTORY))
            if(OrderMagicNumber()==MagicNumber)
               if(OrderSymbol()==Symbol())
                  if(OrderCloseTime()>CloseTime)
                     {
                     CloseTime       = OrderCloseTime();
                     LastCloseType   = OrderType();
                     LastCloseLot    = OrderLots();
                     LastCloseProfit = OrderProfit() + OrderCommission() + OrderSwap();
                     }
      //--------------- Открытие самого первого ордера --------------------------------
      if(Trade==false)                                  // Торговля советником не начата
         if(s+b==0 && LastCloseType==-1)                // Нет и не открывались ордера
            {
            if(ModeFirstTrade == Buy)
               {
               int ticket=OrderSend(Symbol(),OP_BUY,StartLot,Ask,Slippage,0,0," ",MagicNumber,0,clrRed); 
               if(ticket<0)
                  { 
                  Print("Order Send завершилась с ошибкой #",GetLastError());
                  return;
                  } 
               else
                  Trade = true;   
               }
            //--- 
            if(ModeFirstTrade == Sell)
               {
               int ticket=OrderSend(Symbol(),OP_SELL,StartLot,Bid,Slippage,0,0," ",MagicNumber,0,clrRed); 
               if(ticket<0)
                  { 
                  Print("Order Send завершилась с ошибкой #",GetLastError());
                  return;
                  }    
               else
                  Trade = true;   
               }
            //---
            if(ModeFirstTrade == Candle)
               {
               }
            } 
      //--------------- Открытие последующих ордеров ----------------------------
      if(LastCloseProfit>0 && s+b==0)
         {
         Lot = StartLot;
         
         if(LastCloseType==OP_BUY)
            {
            int ticket=OrderSend(Symbol(),OP_BUY,Lot,Ask,Slippage,0,0," ",MagicNumber,0,clrRed); 
            if(ticket<0)
               { 
               Print("Order Send завершилась с ошибкой #",GetLastError());
               return;
               } 
            }
         if(LastCloseType==OP_SELL)
            {
            int ticket=OrderSend(Symbol(),OP_SELL,Lot,Bid,Slippage,0,0," ",MagicNumber,0,clrRed); 
            if(ticket<0)
               { 
               Print("Order Send завершилась с ошибкой #",GetLastError());
               return;
               }    
            }
         }
      //----------------------------   
      if(LastCloseProfit<0 && s+b==0)
         {
         Lot = NormalizeDouble(MathCeil(LastCloseLot*100*LotK/100),2);
         
         if(LastCloseType==OP_BUY)
            {
            int ticket=OrderSend(Symbol(),OP_SELL,Lot,Bid,Slippage,0,0," ",MagicNumber,0,clrRed); 
            if(ticket<0)
               { 
               Print("Order Send завершилась с ошибкой #",GetLastError());
               return;
               }    
            }
         if(LastCloseType==OP_SELL)
            {
            int ticket=OrderSend(Symbol(),OP_BUY,Lot,Ask,Slippage,0,0," ",MagicNumber,0,clrRed); 
            if(ticket<0)
               { 
               Print("Order Send завершилась с ошибкой #",GetLastError());
               return;
               } 
            }
         }
      //--------------- Расчет ТР и SL -------------------------------              
      double atr     = iATR(NULL,TF_ATR,Per_ATR,iB)*10000;  // ATR (in pips)
	   double StopLvl = NormalizeDouble(MarketInfo(Symbol(), MODE_STOPLEVEL)*Point,Digits);
	   
      sl = NormalizeDouble(atr*SL_k_ATR*Point,Digits);
      if(sl<StopLvl)
         sl=StopLvl;
      tp = NormalizeDouble(atr*TP_k_ATR*Point,Digits);
      if(tp<StopLvl)
         tp=StopLvl;
         
      //--------------- Установка ТР и SL ----------------------------
      for(int i=OrdersTotal()-1;i>=0;i--)
         if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
            if(OrderMagicNumber()==MagicNumber)
               if(OrderSymbol()==Symbol())
                  {
                  double oop = OrderOpenPrice();
                  
                  if(OrderType()==OP_BUY)
                    if(OrderStopLoss()==0 || OrderTakeProfit()==0)
                      if(!OrderModify(OrderTicket(),oop,NormalizeDouble(oop-sl,Digits),NormalizeDouble(oop+tp,Digits),0,clrBlue))
                        Print("Order Modify error #",GetLastError());
                     
                  if(OrderType()==OP_SELL)
                    if(OrderStopLoss()==0 || OrderTakeProfit()==0)
                      if(!OrderModify(OrderTicket(),oop,NormalizeDouble(oop+sl,Digits),NormalizeDouble(oop-tp,Digits),0,clrBlue))
                        Print("Order Modify error #",GetLastError());
                  }
         if(BU_ON) BU();
}
//-------------------------------------------------------------------------------
bool BU()
{ 
   for(int i=OrdersTotal()-1;i>=0;i--)
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
         if(OrderMagicNumber()==MagicNumber)
            if(OrderSymbol()==Symbol())
              {
              double  sl_min = MarketInfo(Symbol(), MODE_STOPLEVEL)*Point,
                      TP = OrderTakeProfit(),
                      op = OrderOpenPrice(),
                      lt = OrderLots();
              double _lt = NormalizeDouble(lt/2,2);
//              if (_lt==0) break;
              
              LevelBU = MathAbs(op-TP);
                     
              if(OrderType()==OP_BUY && Ask >= op+LevelBU/2*Point)
                if(OrderModify(OrderTicket(),op,NormalizeDouble(Ask-sl_min,Digits),OrderTakeProfit(),0,clrNONE))
                  if(!OrderClose(OrderTicket(),_lt,Bid,Slippage))
                    Sleep(500);
              //---
              if(OrderType()==OP_SELL && Bid <= op-LevelBU/2*Point)
                if(OrderModify(OrderTicket(),op,NormalizeDouble(Bid+sl_min,Digits),OrderTakeProfit(),0,clrNONE))
                  if(!OrderClose(OrderTicket(),_lt,Ask,Slippage))
                    Sleep(500);
              }
   return true;
}
//-------------------------------------------------------------------------------

График оптимизации без привязки к ATR, но с функцией Сейф.

<code>#property strict

//--- input parameters
enum MODE {
          Buy    = 0,  // Покупка
          Sell   = 1,  // Продажа
          Candle = 2   // По свече
          };
//---          
input bool     BU_ON          = true;
input MODE     ModeFirstTrade = Buy;     // Тип первой сделки
input double   StartLot       = 0.02;    // Лот базовый
input int      StopLoss       = 372;     // Потери в пунктах
input int      TakeProfit     = 354;     // Прибыль в пунктах
input double   LotK           = 2.2;     // Коэф. увеличения лота
input int      Slippage       = 30;      // Slippage
input int      MagicNumber    = 1961;    // Magic Number
//---                                          
int      LastCloseType; 
double   LastCloseLot;
double   LastCloseProfit;
double   tp,sl,Lot;
bool     Trade = false;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
      tp = NormalizeDouble(TakeProfit*Point,Digits);
      sl = NormalizeDouble(StopLoss*Point,Digits);
   return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
      int b=0,s=0;
   
      for(int i=OrdersTotal()-1;i>=0;i--)
         if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
            if(OrderMagicNumber()==MagicNumber)
               if(OrderSymbol()==Symbol())
                  {
                  if(OrderType()==OP_BUY)  b++;
                  if(OrderType()==OP_SELL) s++;
                  }
      //---
      LastCloseType=-1;
      datetime CloseTime=0;
      
      for(int i=OrdersHistoryTotal()-1;i>=0;i--)
         if(OrderSelect(i,SELECT_BY_POS,MODE_HISTORY))
            if(OrderMagicNumber()==MagicNumber)
               if(OrderSymbol()==Symbol())
                  if(OrderCloseTime()>CloseTime)
                     {
                     CloseTime       = OrderCloseTime();
                     LastCloseType   = OrderType();
                     LastCloseLot    = OrderLots();
                     LastCloseProfit = OrderProfit() + OrderCommission() + OrderSwap();
                     }
      //--------------- Открытие самого первого ордера --------------------------------
      if(Trade==false)                                  // Торговля советником не начата
         if(s+b==0 && LastCloseType==-1)                // Нет и не открывались ордера
            {
            if(ModeFirstTrade == Buy)
               {
               int ticket=OrderSend(Symbol(),OP_BUY,StartLot,Ask,Slippage,0,0," ",MagicNumber,0,clrRed); 
               if(ticket<0)
                  { 
                  Print("Order Send завершилась с ошибкой #",GetLastError());
                  return;
                  } 
               else
                  Trade = true;   
               }
            //--- 
            if(ModeFirstTrade == Sell)
               {
               int ticket=OrderSend(Symbol(),OP_SELL,StartLot,Bid,Slippage,0,0," ",MagicNumber,0,clrRed); 
               if(ticket<0)
                  { 
                  Print("Order Send завершилась с ошибкой #",GetLastError());
                  return;
                  }    
               else
                  Trade = true;   
               }
            //---
            if(ModeFirstTrade == Candle)
               {
               }
            } 
      //--------------- Открытие последующих ордеров ----------------------------
      if(LastCloseProfit>0 && s+b==0)
         {
         Lot = StartLot;
         
         if(LastCloseType==OP_BUY)
            {
            int ticket=OrderSend(Symbol(),OP_BUY,Lot,Ask,Slippage,0,0," ",MagicNumber,0,clrRed); 
            if(ticket<0)
               { 
               Print("Order Send завершилась с ошибкой #",GetLastError());
               return;
               } 
            }
         if(LastCloseType==OP_SELL)
            {
            int ticket=OrderSend(Symbol(),OP_SELL,Lot,Bid,Slippage,0,0," ",MagicNumber,0,clrRed); 
            if(ticket<0)
               { 
               Print("Order Send завершилась с ошибкой #",GetLastError());
               return;
               }    
            }
         }
      //----------------------------   
      if(LastCloseProfit<0 && s+b==0)
         {
         Lot = NormalizeDouble(MathCeil(LastCloseLot*100*LotK/100),2);
         
         if(LastCloseType==OP_BUY)
            {
            int ticket=OrderSend(Symbol(),OP_SELL,Lot,Bid,Slippage,0,0," ",MagicNumber,0,clrRed); 
            if(ticket<0)
               { 
               Print("Order Send завершилась с ошибкой #",GetLastError());
               return;
               }    
            }
         if(LastCloseType==OP_SELL)
            {
            int ticket=OrderSend(Symbol(),OP_BUY,Lot,Ask,Slippage,0,0," ",MagicNumber,0,clrRed); 
            if(ticket<0)
               { 
               Print("Order Send завершилась с ошибкой #",GetLastError());
               return;
               } 
            }
         }	   
      //--------------- Расчет ТР и SL -------------------------------              
	   double StopLvl = NormalizeDouble(MarketInfo(Symbol(), MODE_STOPLEVEL)*Point,Digits);
	   
      sl = NormalizeDouble(StopLoss*Point,Digits);
      if(sl<StopLvl)
         sl=StopLvl;
      tp = NormalizeDouble(TakeProfit*Point,Digits);
      if(tp<StopLvl)
         tp=StopLvl;
      //--------------- Установка ТР и SL ----------------------------
      for(int i=OrdersTotal()-1;i>=0;i--)
         if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
            if(OrderMagicNumber()==MagicNumber)
               if(OrderSymbol()==Symbol())
                  {
                  double oop = OrderOpenPrice();
                  
                  if(OrderType()==OP_BUY)
                    if(OrderStopLoss()==0 || OrderTakeProfit()==0)
                      if(!OrderModify(OrderTicket(),oop,NormalizeDouble(oop-sl,Digits),NormalizeDouble(oop+tp,Digits),0,clrBlue))
                        Print("Order Modify error #",GetLastError());
                     
                  if(OrderType()==OP_SELL)
                    if(OrderStopLoss()==0 || OrderTakeProfit()==0)
                      if(!OrderModify(OrderTicket(),oop,NormalizeDouble(oop+sl,Digits),NormalizeDouble(oop-tp,Digits),0,clrBlue))
                        Print("Order Modify error #",GetLastError());
                  }
         if(BU_ON) BU();
}
//-------------------------------------------------------------------------------
bool BU()
{ 
   for(int i=OrdersTotal()-1;i>=0;i--)
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
         if(OrderMagicNumber()==MagicNumber)
            if(OrderSymbol()==Symbol())
              {
              double  sl_min = MarketInfo(Symbol(), MODE_STOPLEVEL)*Point,
                      TP = OrderTakeProfit(),
                      op = OrderOpenPrice(),
                      lt = OrderLots();
              double _lt = NormalizeDouble(lt/2,2);
//              if (_lt==0) break;
              
              double LevelBU = MathAbs(op-TP);
                     
              if(OrderType()==OP_BUY && Ask >= op+LevelBU/2*Point)
                if(OrderModify(OrderTicket(),op,NormalizeDouble(Ask-sl_min,Digits),OrderTakeProfit(),0,clrNONE))
                  if(!OrderClose(OrderTicket(),_lt,Bid,Slippage))
                    Sleep(500);
              //---
              if(OrderType()==OP_SELL && Bid <= op-LevelBU/2*Point)
                if(OrderModify(OrderTicket(),op,NormalizeDouble(Bid+sl_min,Digits),OrderTakeProfit(),0,clrNONE))
                  if(!OrderClose(OrderTicket(),_lt,Ask,Slippage))
                    Sleep(500);
              }
   return true;
}
//-------------------------------------------------------------------------------
</code>

График оптимизации советника без привязки к ATR выглядит так.


С привязкой выглядит хуже.

#property strict

//--- input parameters
enum MODE {
          Buy    = 0,  // Покупка
          Sell   = 1,  // Продажа
          Candle = 2   // По свече
          };
//---          
input MODE            ModeFirstTrade      = Buy;       // Тип первой сделки
input double          StartLot            = 0.02;      // Лот базовый
input double          SL_k_ATR            = 1.1;       
input double          TP_k_ATR            = 0.9;       
input double   LotK                       = 2.2;       // Коэф. увеличения лота
input int             Per_ATR             = 9;
input ENUM_TIMEFRAMES TF                  = PERIOD_M5; // Тайм Фрейм для ATR
input ENUM_TIMEFRAMES TF_ATR              = PERIOD_H1; // Тайм Фрейм для расчета входа
input int             Slippage            = 30;        // Slippage
input int             MagicNumber         = 1961;      // Magic Number
//---                                          
int      LastCloseType, iB=1; 
double   LastCloseLot;
double   LastCloseProfit;
double   tp,sl,Lot;
bool     Trade = false;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
   return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
      int b=0,s=0;
   
      for(int i=OrdersTotal()-1;i>=0;i--)
         if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
            if(OrderMagicNumber()==MagicNumber)
               if(OrderSymbol()==Symbol())
                  {
                  if(OrderType()==OP_BUY)  b++;
                  if(OrderType()==OP_SELL) s++;
                  }
      //---
      LastCloseType=-1;
      datetime CloseTime=0;
      
      for(int i=OrdersHistoryTotal()-1;i>=0;i--)
         if(OrderSelect(i,SELECT_BY_POS,MODE_HISTORY))
            if(OrderMagicNumber()==MagicNumber)
               if(OrderSymbol()==Symbol())
                  if(OrderCloseTime()>CloseTime)
                     {
                     CloseTime       = OrderCloseTime();
                     LastCloseType   = OrderType();
                     LastCloseLot    = OrderLots();
                     LastCloseProfit = OrderProfit() + OrderCommission() + OrderSwap();
                     }
      //--------------- Открытие самого первого ордера --------------------------------
      if(Trade==false)                                  // Торговля советником не начата
         if(s+b==0 && LastCloseType==-1)                // Нет и не открывались ордера
            {
            if(ModeFirstTrade == Buy)
               {
               int ticket=OrderSend(Symbol(),OP_BUY,StartLot,Ask,Slippage,0,0," ",MagicNumber,0,clrRed); 
               if(ticket<0)
                  { 
                  Print("Order Send завершилась с ошибкой #",GetLastError());
                  return;
                  } 
               else
                  Trade = true;   
               }
            //--- 
            if(ModeFirstTrade == Sell)
               {
               int ticket=OrderSend(Symbol(),OP_SELL,StartLot,Bid,Slippage,0,0," ",MagicNumber,0,clrRed); 
               if(ticket<0)
                  { 
                  Print("Order Send завершилась с ошибкой #",GetLastError());
                  return;
                  }    
               else
                  Trade = true;   
               }
            //---
            if(ModeFirstTrade == Candle)
               {
               }
            } 
      //--------------- Открытие последующих ордеров ----------------------------
      if(LastCloseProfit>0 && s+b==0)
         {
         Lot = StartLot;
         
         if(LastCloseType==OP_BUY)
            {
            int ticket=OrderSend(Symbol(),OP_BUY,Lot,Ask,Slippage,0,0," ",MagicNumber,0,clrRed); 
            if(ticket<0)
               { 
               Print("Order Send завершилась с ошибкой #",GetLastError());
               return;
               } 
            }
         if(LastCloseType==OP_SELL)
            {
            int ticket=OrderSend(Symbol(),OP_SELL,Lot,Bid,Slippage,0,0," ",MagicNumber,0,clrRed); 
            if(ticket<0)
               { 
               Print("Order Send завершилась с ошибкой #",GetLastError());
               return;
               }    
            }
         }
      //----------------------------   
      if(LastCloseProfit<0 && s+b==0)
         {
         Lot = NormalizeDouble(MathCeil(LastCloseLot*100*LotK/100),2);
         
         if(LastCloseType==OP_BUY)
            {
            int ticket=OrderSend(Symbol(),OP_SELL,Lot,Bid,Slippage,0,0," ",MagicNumber,0,clrRed); 
            if(ticket<0)
               { 
               Print("Order Send завершилась с ошибкой #",GetLastError());
               return;
               }    
            }
         if(LastCloseType==OP_SELL)
            {
            int ticket=OrderSend(Symbol(),OP_BUY,Lot,Ask,Slippage,0,0," ",MagicNumber,0,clrRed); 
            if(ticket<0)
               { 
               Print("Order Send завершилась с ошибкой #",GetLastError());
               return;
               } 
            }
         }
      //--------------- Расчет ТР и SL -------------------------------              
      double atr     = iATR(NULL,TF_ATR,Per_ATR,iB)*10000;  // ATR (in pips)
	   double StopLvl = NormalizeDouble(MarketInfo(Symbol(), MODE_STOPLEVEL)*Point,Digits);
	   
      sl = NormalizeDouble(atr*SL_k_ATR*Point,Digits);
      if(sl<StopLvl)
         sl=StopLvl;
      tp = NormalizeDouble(atr*TP_k_ATR*Point,Digits);
      if(tp<StopLvl)
         tp=StopLvl;
      //--------------- Установка ТР и SL ----------------------------
      for(int i=OrdersTotal()-1;i>=0;i--)
         if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
            if(OrderMagicNumber()==MagicNumber)
               if(OrderSymbol()==Symbol())
                  {
                  double oop = OrderOpenPrice();
                  
                  if(OrderType()==OP_BUY)
                    if(OrderStopLoss()==0 || OrderTakeProfit()==0)
                      if(!OrderModify(OrderTicket(),oop,NormalizeDouble(oop-sl,Digits),NormalizeDouble(oop+tp,Digits),0,clrBlue))
                        Print("Order Modify error #",GetLastError());
                     
                  if(OrderType()==OP_SELL)
                    if(OrderStopLoss()==0 || OrderTakeProfit()==0)
                      if(!OrderModify(OrderTicket(),oop,NormalizeDouble(oop+sl,Digits),NormalizeDouble(oop-tp,Digits),0,clrBlue))
                        Print("Order Modify error #",GetLastError());
                  }
}
//-------------------------------------------------------------------------------

Этот факт говорит о плохой повторяемости результатов.
Тобишь, сдвинув период времени тестирования хоть на неделю, с огромной вероятностью сова сольёт.

Попробую применить правило сейфа. А вдруг?

Первые мысли вслух.

SL и ТР как бы дают шаг сетки. С фиксированными шагами туда сюда.
1. Надо подбирать такой вариант, где бы SL был бы меньше ТР. Если научимся бороться с флетами, Это снизит просадку и даст прирост дэпо.
2. Видится вариант — SL и ТР брать коэффициентом от ATR какого-то периода.
При этом пункт №1 не теряет актуальность.
3. Ещё интересен на пробу вариант открывать сделки по какому ни будь индюку.

Пустой диалог, да ладно. Диалог же.
Список странный, однобокий. Кто-то очень старался.

Так и в карман соседу залезть недолго.
Не путайте государственные деньги с частными. Наворованными и немного честно заработанными. Бросаетесь тут фамилиями воров и переобувшихся воров.
Они смогли, а Вы, наверно как и все, не смогли. Обанкротить и прихватить.
Они строили себе виллы — яхты с тех средств, которых не хватало государству, на учителей, врачей, пенсионеров и… Кого надо было бы.

Бьюсь об заклад (головой), если бы у Вас спросили: "-Украли бы, если бы был предоставлен случай?" Вы бы возмущенно покачали головой. Своей. Не так ли?

Так что, разница в «смог-не смог».

Людям свойственно защищаться. Рубль начал обваливаться — понакупали баксов. Хватило ума. Даже и мысли не промелькнуло, что этим роняют рубль дальше. Байден же обещал. Обама тоже много чего обещал. В свою страну верить надо.
Рубль начал укрепляться — вовремя скинуть баксы уже ума не хватило. Вот и ищут крайних. Это на кухне. А вне этого замечательного помещения, поднакачавшись в интернете соответствующей подачей, льют воду на чужую мельницу. Типа дайте расти доллару. Доллар — наше всё.
Государству Россия доллар нужен постольку-поскольку. Тем более импорт упал.

Так вот государственники не дадут доллару вырасти. Сколько не кричите.
Начнёте сливать — ещё больше уроните доллар. Лучше в рамочку и на гвоздик.

Родину любить надо, а не себя в ней.

И вообще, сайт про трейдинг. А свои проблемы — на кухню.

Видится эффективно разумным подвязывать формирование диапазона ко времени.

Кто не обгадил штанишки при высоком курсе доллара (Бидон же обещал бакс за 200) и не понакупал доллары, тот сильно не парится за курс50-60. России сейчас баксы очень даром не нужны. Поэтому рубль обречен на укрепление. Хотя и сильно крепкий рубль не совсем и не всегда выгоден России.
Так что, надо отличать барыг от хозяйственников.

Да… и в приват я приглашаю тех, с кем интересно.

Код советника для моего уровня знакомства с программированием сложноват, по-этому я переписал его «своими словами». Дальше будем работать с ним.

<code>#property strict

//--- input parameters
enum MODE {
          Buy    = 0,  // Покупка
          Sell   = 1,  // Продажа
          Candle = 2   // По свече
          };
//---          
input MODE     ModeFirstTrade = Buy;     // Тип первой сделки
input double   StartLot       = 0.02;    // Лот базовый
input int      StopLoss       = 372;     // Потери в пунктах
input int      TakeProfit     = 354;     // Прибыль в пунктах
input double   LotK           = 2.2;     // Коэф. увеличения лота
input int      Slippage       = 30;      // Slippage
input int      MagicNumber    = 1961;    // Magic Number
//---                                          
int      LastCloseType; 
double   LastCloseLot;
double   LastCloseProfit;
double   tp,sl,Lot;
bool     Trade = false;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
      tp = NormalizeDouble(TakeProfit*Point,Digits);
      sl = NormalizeDouble(StopLoss*Point,Digits);
   return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
      int b=0,s=0;
   
      for(int i=OrdersTotal()-1;i>=0;i--)
         if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
            if(OrderMagicNumber()==MagicNumber)
               if(OrderSymbol()==Symbol())
                  {
                  if(OrderType()==OP_BUY)  b++;
                  if(OrderType()==OP_SELL) s++;
                  }
      //---
      LastCloseType=-1;
      datetime CloseTime=0;
      
      for(int i=OrdersHistoryTotal()-1;i>=0;i--)
         if(OrderSelect(i,SELECT_BY_POS,MODE_HISTORY))
            if(OrderMagicNumber()==MagicNumber)
               if(OrderSymbol()==Symbol())
                  if(OrderCloseTime()>CloseTime)
                     {
                     CloseTime       = OrderCloseTime();
                     LastCloseType   = OrderType();
                     LastCloseLot    = OrderLots();
                     LastCloseProfit = OrderProfit() + OrderCommission() + OrderSwap();
                     }
      //--------------- Открытие самого первого ордера --------------------------------
      if(Trade==false)                                  // Торговля советником не начата
         if(s+b==0 && LastCloseType==-1)                // Нет и не открывались ордера
            {
            if(ModeFirstTrade == Buy)
               {
               int ticket=OrderSend(Symbol(),OP_BUY,StartLot,Ask,Slippage,0,0," ",MagicNumber,0,clrRed); 
               if(ticket<0)
                  { 
                  Print("Order Send завершилась с ошибкой #",GetLastError());
                  return;
                  } 
               else
                  Trade = true;   
               }
            //--- 
            if(ModeFirstTrade == Sell)
               {
               int ticket=OrderSend(Symbol(),OP_SELL,StartLot,Bid,Slippage,0,0," ",MagicNumber,0,clrRed); 
               if(ticket<0)
                  { 
                  Print("Order Send завершилась с ошибкой #",GetLastError());
                  return;
                  }    
               else
                  Trade = true;   
               }
            //---
            if(ModeFirstTrade == Candle)
               {
               }
            } 
      //--------------- Открытие последующих ордеров ----------------------------
      if(LastCloseProfit>0 && s+b==0)
         {
         Lot = StartLot;
         
         if(LastCloseType==OP_BUY)
            {
            int ticket=OrderSend(Symbol(),OP_BUY,Lot,Ask,Slippage,0,0," ",MagicNumber,0,clrRed); 
            if(ticket<0)
               { 
               Print("Order Send завершилась с ошибкой #",GetLastError());
               return;
               } 
            }
         if(LastCloseType==OP_SELL)
            {
            int ticket=OrderSend(Symbol(),OP_SELL,Lot,Bid,Slippage,0,0," ",MagicNumber,0,clrRed); 
            if(ticket<0)
               { 
               Print("Order Send завершилась с ошибкой #",GetLastError());
               return;
               }    
            }
         }
      //----------------------------   
      if(LastCloseProfit<0 && s+b==0)
         {
         Lot = NormalizeDouble(MathCeil(LastCloseLot*100*LotK/100),2);
         
         if(LastCloseType==OP_BUY)
            {
            int ticket=OrderSend(Symbol(),OP_SELL,Lot,Bid,Slippage,0,0," ",MagicNumber,0,clrRed); 
            if(ticket<0)
               { 
               Print("Order Send завершилась с ошибкой #",GetLastError());
               return;
               }    
            }
         if(LastCloseType==OP_SELL)
            {
            int ticket=OrderSend(Symbol(),OP_BUY,Lot,Ask,Slippage,0,0," ",MagicNumber,0,clrRed); 
            if(ticket<0)
               { 
               Print("Order Send завершилась с ошибкой #",GetLastError());
               return;
               } 
            }
         }
      //--------------- Установка ТР и SL ----------------------------
      for(int i=OrdersTotal()-1;i>=0;i--)
         if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
            if(OrderMagicNumber()==MagicNumber)
               if(OrderSymbol()==Symbol())
                  {
                  double oop = OrderOpenPrice();
                  
                  if(OrderType()==OP_BUY)
                    if(OrderStopLoss()==0 || OrderTakeProfit()==0)
                      if(!OrderModify(OrderTicket(),oop,NormalizeDouble(oop-sl,Digits),NormalizeDouble(oop+tp,Digits),0,clrBlue))
                        Print("Order Modify error #",GetLastError());
                     
                  if(OrderType()==OP_SELL)
                    if(OrderStopLoss()==0 || OrderTakeProfit()==0)
                      if(!OrderModify(OrderTicket(),oop,NormalizeDouble(oop+sl,Digits),NormalizeDouble(oop-tp,Digits),0,clrBlue))
                        Print("Order Modify error #",GetLastError());
                  }
}
//-------------------------------------------------------------------------------
</code>