Как то все:

//+------------------------------------------------------------------+
//|                                                       Grider.mq4 |
//|                                              Copyright 2016, AM2 |
//|                                      http://www.forexsystems.biz |
//+------------------------------------------------------------------+
#property copyright "Copyright 2016, AM2."
#property link      "http://www.forexsystems.biz"
#property version   "1.00"
#property description "Semi grid EA <<Universal Grider>>." 
#property description "This EA can be used as a Supplement to your trading strategy,"  
#property description "if you trade manually and use it as a standard grid EA."    
#property icon        "\\Images\\drawing.ico";                                   
#property strict

//--- Inputs
extern double Lot          = 0.1;      // Trade volume
extern double KLot         = 1.3;      // Lot increase
extern double MaxLot       = 5;        // Maximum lot
extern int StopLoss        = 0;        // Order sroploss
extern int TakeProfit      = 0;        // Order takeprofit
extern int TrailingStop    = 0;        // Trailing stop
extern int TrailingStep    = 0;        // Trailing step
extern int Count           = 5;        // Orders count
extern int Expiration      = 55;       // The expiry of the order in hours
extern int Step            = 100;      // Order step
extern int Delta           = 100;      // Distance from the price
extern int Slip            = 3;        // Slippage
extern int RSIPer          = 14;       // Period of RSI indicator
extern int UpLevel         = 55;       // Up level of RSI indicator
extern int DnLevel         = 45;       // Dn level of RSI indicator
extern int Magic           = 123;      // Magic number
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   if(!IsTradeAllowed())Alert("Allow the EA to trade!");
   if(!IsLibrariesAllowed())Alert("Allow DLL import!");
   if(!IsExpertEnabled()) Alert("Allow startup advisors!");

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

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

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

   r=OrderSend(NULL,type,Lots(type),NormalizeDouble(price,Digits),Slip,sl,tp,"",Magic,TimeCurrent()+Expiration*3600,clr);
   return;
  }
//+------------------------------------------------------------------+
//| Ступенчатый трал               if(TrailingStop>0) Trailing();    |
//+------------------------------------------------------------------+
void Trailing()
  {
   bool mod;
   for(int i=OrdersTotal()-1;i>=0;i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
            if(OrderType()==OP_BUY)
              {
               if(Bid-OrderOpenPrice()>TrailingStop*Point)
                 {
                  if(OrderStopLoss()<Bid-(TrailingStop+TrailingStep-1)*Point)
                    {
                     mod=OrderModify(OrderTicket(),OrderOpenPrice(),NormalizeDouble(Bid-TrailingStop*Point,Digits),OrderTakeProfit(),0,Yellow);
                    }
                 }
              }

            if(OrderType()==OP_SELL)
              {
               if((OrderOpenPrice()-Ask)>TrailingStop*Point)
                 {
                  if(OrderStopLoss()>Ask+(TrailingStop+TrailingStep-1)*Point || OrderStopLoss()==0)
                    {
                     mod=OrderModify(OrderTicket(),OrderOpenPrice(),NormalizeDouble(Ask+TrailingStop*Point,Digits),OrderTakeProfit(),0,Yellow);
                    }
                 }
              }
           }
        }
     }
  }
//+------------------------------------------------------------------+
//| Закрытие позиции по типу ордера                                  |
//+------------------------------------------------------------------+
void CloseAll(int ot=-1)
  {
   bool cl;
   int err=0;
   for(int i=OrdersTotal()-1;i>=0;i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
            if(OrderType()==0 && (ot==0 || ot==-1))
              {
               RefreshRates();
               cl=OrderClose(OrderTicket(),OrderLots(),NormalizeDouble(Bid,Digits),Slip,White);
              }
            if(OrderType()==1 && (ot==1 || ot==-1))
              {
               RefreshRates();
               cl=OrderClose(OrderTicket(),OrderLots(),NormalizeDouble(Ask,Digits),Slip,White);
              }
           }
        }
     }
  }
//+------------------------------------------------------------------+
//| Подсчет ордеров по типу                                          |
//+------------------------------------------------------------------+
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(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
            if(OrderType()==type || (OrderType()>=0 && type==-1)) count++;
           }
        }
     }
   return(count);
  }
//+------------------------------------------------------------------+
//| Профит всех ордеров по типу ордера                               |
//+------------------------------------------------------------------+
double AllProfit(int ot=-1)
  {
   double pr=0;
   for(int i=OrdersTotal()-1;i>=0;i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
            if(OrderType()==0 && (ot==0 || ot==-1))
              {
               pr+=OrderProfit()+OrderCommission()+OrderSwap();
              }

            if(OrderType()==1 && (ot==1 || ot==-1))
              {
               pr+=OrderProfit()+OrderCommission()+OrderSwap();
              }
           }
        }
     }
   return(pr);
  }
//+------------------------------------------------------------------+
//| Лот для усреднителя                                              |
//+------------------------------------------------------------------+
double Lots(int type)
  {
   double lots=Lot;
   lots=NormalizeDouble(Lot*MathPow(KLot,CountOrders(type)),2);
   if(lots>MaxLot)lots=Lot;
   return(lots);
  }
//+------------------------------------------------------------------+
//| Удаление отложенных ордеров                                      |
//+------------------------------------------------------------------+
void DelOrder(int type)
  {
   bool del;
   for(int i=OrdersTotal()-1;i>=0;i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
            if(OrderType()==type) del=OrderDelete(OrderTicket());
           }
        }
     }
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   double rsi1=iRSI(NULL,0,RSIPer,PRICE_CLOSE,1);
   double rsi2=iRSI(NULL,0,RSIPer,PRICE_CLOSE,2);

   if(TrailingStop>0) Trailing();

   if(CountOrders(-1)<1)
     {
      for(int i=0; i<Count;i++)
        {         
         if(rsi2<DnLevel && rsi1>DnLevel) {DelOrder(5); PutOrder(4,Bid+Delta*Point+Step*Point*i);}//buystop
         if(rsi2>UpLevel && rsi1<UpLevel) {DelOrder(4); PutOrder(5,Bid-Delta*Point-Step*Point*i);}//sellstop  
        }
     }

   Comment("\n All Profit: ",AllProfit(-1),
           "\n Buy Profit:  ",AllProfit(0),
           "\n Sell Profit: ",AllProfit(1),
           "\n Buy Positions:  ",CountOrders(0),
           "\n Sell Positions: ",CountOrders(1),
           "\n All Positions:  ",CountOrders(0)+CountOrders(1));
  }
//+------------------------------------------------------------------+

Вечером буду делать.

Это опять индивидуальная штука, много работы и тем более мультивалютник. Если сложный я предупреждаю заранее и шансы довести до конца уменьшаются пропорционально затраченному времени.

Можно переделать, но еще проще из него сделать доливатор. Через шаг будет доливаться, почти тоже что и с отложками будет.

После установки отложки, советник можно перезапустить и он выставит заново.

Далее добавляем строку с названием «Открытие текущей» где значение индикатора будет фиксированное а цвет в зависимости от того больше, меньше или равно это значение по отношению к значению указанному в строке «На предыдущей»,

Значения на открытии текущей и предыдущей будут равны, если только сравнивать с предпредыдушей  

Я даже когда-то советник программировала, основанный на скорости движения цены

С низкими спредами и подсказкой от саксо или лмакс надеюсь будет работать  
Но недолго  

На примере функции открытия ордеров добавляю еще 3 бороды   Это без проверки стоплевела и я еще только учусь  
У тебя как выглядит в расширенном варианте?

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void PutOrder(int type,double price)
  {
   int r=0,err=0;
   color clr=Green;

   if(type==1 || type==3 || type==5)
     {
      clr=Red;
     }

   if(type==0 || type==2 || type==4)
     {
      clr=Blue;
     }

   if(AccountFreeMarginCheck(Symbol(),type,Lot())<=0 || GetLastError()==134)
     {
      Print("No enough money!");
      Trade=false;
      return;
     }

   for(int i=1; i<=10; i++)
     {
      if(!IsTesting() && (!IsExpertEnabled() || IsStopped()))
        {
         break;
        }

      while(!IsTradeAllowed()) Sleep(5000);
      RefreshRates();

      r=OrderSend(NULL,type,Lot(),NormalizeDouble(price,Digits),Slip,0,0,"",Magic,0,clr);
      if(r>0) break;
      else
        {
         err=GetLastError();
         // Вывод сообщения об ошибке
         Print("Error(",err,") opening position: ",ErrorDescription(err));

         // Блокировка работы советника
         if(ErrorsAction(err)==2)
           {
            Trade=false;
            Print("Stop the Advisor!");
            return;
           }
         // Длительная пауза
         if(ErrorsAction(err)==1)
           {
            Sleep(1000*300); return;
           }
         if(ErrorsAction(err)==0)
           {
            Sleep(1000*10);
           }
        }
     }
   return;
  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int ErrorsAction(int error_code)
  {
   int act=0;
//----
   switch(error_code)
     {
      // ---- Error codes returned from trade server:
      case 0: Print("No error"); break;
      case 1: Print("No error, but the result is unknown"); return(0);
      case 2: Print("Common error"); return(2);
      case 3: Print("Wrong parameters"); return(0);
      case 4: Print("Trade server is busy"); return(1);
      case 5: Print("Old version of client terminal"); return(2);
      case 6: Print("No connection with trade server"); return(0);
 ..................................................................................
      case 148: Print("Amount of open and pending orders has reached the limit set by the broker"); return(0);
      case 149: Print("An attempt to open an order opposite to the existing one when hedging is disabled"); return(2);
      case 150: Print("An attempt to close an order contravening the FIFO rule"); return(2);

      // ---- Error codes run MQL4 programs:

      case 4000: Print("No error"); return(1);
      case 4001: Print("Wrong function pointer"); return(0);
      case 4002: Print("array Index is out of range"); return(0);
      case 4003: Print("No memory to stack functions"); return(0);
      case 4004: Print("stack Overflow after recursive call"); return(0);
   ..............................................................................................
      case 4203: Print("Unknown object type"); return(0);
      case 4204: Print("No object name"); return(0);
      case 4205: Print("Error coordinates object"); return(0);
      case 4206: Print("Not found specified subwindow"); return(0);
      default: Print("Error when working with object");
     }
//----
   return(0);
  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
string ErrorDescription(int error_code)
  {
   string error_string;
//----
   switch(error_code)
     {
      // ---- Error codes returned from trade server:
      case 0: error_string="No error"; break;
      case 1: error_string="No error, but the result is unknown"; break;
      case 2: error_string="Common error"; break;
      case 3: error_string="Wrong parameters"; break;
      case 4: error_string="Trade server is busy"; break;
      case 5: error_string="Old version of client terminal"; break;
      case 6: error_string="No connection with trade server"; break;
........................................................................................................................
      case 147: error_string="Using the expiration date of the warrant is prohibited broker"; break;
      case 148: error_string="Amount of open and pending orders has reached the limit set by the broker";break;
      case 149: error_string="An attempt to open an order opposite to the existing one when hedging is disabled"; break;
      case 150: error_string="An attempt to close an order contravening the FIFO rule";break;

      // ---- Error codes run MQL4 programs:

      case 4000: error_string="No error"; break;
      case 4001: error_string="Wrong function pointer"; break;
      case 4002: error_string="array Index is out of range"; break;
      case 4003: error_string="No memory to stack functions"; break;
 ............................................................................................
      case 4206: error_string="Not found specified subwindow"; break;
      default: error_string="Error when working with object";
     }
//----
   return(error_string);
  }

Советник непростой, сделал в упрощенном виде.

Можно, но в отдельном заказе.

Готово: www.opentraders.ru/downloads/1202/

Сейчас буду смотреть.

По каким критическим ошибкам обычно вырубаешь советник? У меня сейчас в функции: 2,4,7,9,64,65,133,140,147,150,4110,4111.

if(BU_Step_Move!=0 && (BU_Step_Move<1 || BU_PointStep-BU_Step_Move<_mi_lv))

Здесь грамотно, заодно проверяешь чтобы BU_Step_Move не был больше BU_PointStep

Это как раз та версия которая работала на скрине:

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

//--- Inputs
extern double Lot        = 0.1;      // лот рыночного
extern double Lots       = 0.1;      // лот отложенного
extern int Loss          = 333;      // лось рыночного
extern int Profit        = 333;      // язь  рыночного
extern int StopLoss      = 333;      // лось отложенного
extern int TakeProfit    = 333;      // язь  отложенного
extern int Slip          = 30;       // реквот
extern int Shift         = 1;        // на каком баре сигнал индикатора
extern int Delta         = 300;      // расстояние от цены
extern int Magic         = 123;      // магик
extern string IndName    = "Trix";

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

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

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

   r=OrderSend(NULL,type,lot,NormalizeDouble(price,Digits),Slip,sl,tp,"",Magic,0,clr);
   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()<2) count++;
           }
        }
     }
   return(count);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void OpenPos()
  {
   double lime = iCustom(NULL,0,IndName,2,Shift);
   double red  = iCustom(NULL,0,IndName,3,Shift);
   double lime1 = iCustom(NULL,0,IndName,2,Shift+1);
   double red1  = iCustom(NULL,0,IndName,3,Shift+1);

   if(lime<1000 && red1<1000)
     {
      PutOrder(0,Ask,Lot,Loss,Profit);
      if(CountOrders(2)<1 && CountOrders(3)<1) PutOrder(2,Ask-Delta*Point,Lots,StopLoss,TakeProfit);
     }

   if(red<1000 && lime1<1000)
     {
      PutOrder(1,Bid,Lot,Loss,Profit);
      if(CountOrders(3)<1 && CountOrders(3)<1) PutOrder(3,Bid+Delta*Point,Lots,StopLoss,TakeProfit);
     }
  }
//+------------------------------------------------------------------+
//| Подсчет ордеров по типу                                          |
//+------------------------------------------------------------------+
int CountOrders(int type)
  {
   int count=0;
   for(int i=OrdersTotal()-1;i>=0;i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
            if(OrderType()==type) count++;
           }
        }
     }
   return(count);
  }
//+------------------------------------------------------------------+
//| Удаление отложенных ордеров                                      |
//+------------------------------------------------------------------+
void DelOrder()
  {
   bool del;
   for(int i=OrdersTotal()-1;i>=0;i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
            if(OrderType()>1) del=OrderDelete(OrderTicket());
           }
        }
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CloseAll()
  {
   bool cl;
   for(int i=OrdersTotal()-1;i>=0;i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
            if(OrderType()==OP_BUY)
              {
               RefreshRates();
               cl=OrderClose(OrderTicket(),OrderLots(),NormalizeDouble(Bid,Digits),Slip,White);
              }
            if(OrderType()==OP_SELL)
              {
               RefreshRates();
               cl=OrderClose(OrderTicket(),OrderLots(),NormalizeDouble(Ask,Digits),Slip,White);
              }
           }
        }
     }
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   double lime= iCustom(NULL,0,IndName,2,Shift);
   double red = iCustom(NULL,0,IndName,3,Shift);
   
   if(CountTrades()==0) counts = 0;  
   if(CountTrades()==2) counts = 2;
   
   if(CountTrades()<1 && t!=Time[0])
     {
      DelOrder();
      OpenPos();
      t=Time[0];
     }
     

    
   if(CountTrades()==1 && counts==2)
     {
      CloseAll();
     }
     
   Comment("\n lime: ",lime,
           "\n red: ",red);
  }
//+------------------------------------------------------------------+

Мультивалютный не ко мне.

extern double Lots       = 0.1;      // лот
extern double DeltaLots  = 0.3;      // разница в лотах
extern int StopLoss      = 0;        // лось
extern int TakeProfit    = 0;        // язь
extern int BULevel       = 0;        // уровень БУ
extern int BUPoint       = 30;       // пункты БУ
extern int TrailingStop  = 0;        // трал
extern int TrailingStep  = 20;       // шаг трала
extern int Procent       = 100;      // процент
extern int Delta         = 300;      // расстояние от цены
extern int Slip          = 30;       // реквот
extern int Magic         = 0;        // магик

На экране сумма лотов BuyLots и SellLots, когда разница между ними достигнет величины DeltaLots, советник выставит отложку на расстоянии Delta от цены, лотом DeltaLots*Procent.

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

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

Вы в личке просили основу, пожалуйста, дорабатывайте.

Все есть: www.opentraders.ru/downloads/1200/

Там растояние от цены и между ордерами ставится 200 пунктов, хотя я ставлю 30 и лоты не меняются, стоят по умолчанию 0,1.

Это для тестера. Мне же нужно смоделировать ситуацию в рынке чтобы проверить работу советника.

Проветрить не могу так как нет двух разных ордеров и с разницей в лотах, так как растояние большое и не срабатывают ордера.

проверить можно. Для этого на скрине и показал разницу в лоте ордеров и выставление противоположной отложки.