Конечно не секрет. Пользуйтесь:

//+------------------------------------------------------------------+
//|                                             Mult2+stoporders.mq5 |
//|                                              Copyright 2021, AM2 |
//|                                      http://www.forexsystems.biz |
//+------------------------------------------------------------------+
#property copyright "Copyright 2021, AM2"
#property link      "http://www.forexsystems.biz"
#property version   "1.00"

#include <Trade\Trade.mqh>            // Подключаем торговый класс CTrade

//--- входные параметры группы 1
input double   Lots      = 0.1;       // лот
input double   KLot      = 2;         // множитель лота
input double   MaxLot    = 5;         // максимальный лот
input double   Loss      = 3000;      // Лось в валюте
input double   Profit    = 100;       // Профит в валюте

input string   Symb1     = "EURUSD";  // 1-й символ
input string   Symb2     = "GBPUSD";  // 2-й символ
input string   Symb3     = "EURGBP";  // 3-й символ

input int      Count     = 3;     // число ордеров
input int      Delta     = 200;   // расстояние от цены
input int      Slip      = 50;        // Проскальзывание

input string IndName     = "Examples\\Moving Average";
input int MA1            = 12;
input int MA2            = 36;

int bars=0;
CTrade trade;
int m1=0,m2=0;
double ma1[],ma2[];
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   m1=iMA(Symb1,0,MA1,0,0,0);
   m2=iMA(Symb1,0,MA2,0,0,0);

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

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CloseAll()
  {
   for(int i=PositionsTotal()-1; i>=0; i--)
     {
      if(PositionSelectByTicket(PositionGetTicket(i)))
        {
         trade.PositionClose(PositionGetTicket(i),Slip);
        }
     }
  }
//+------------------------------------------------------------------+
//|  Position Profit                                                 |
//+------------------------------------------------------------------+
double AllProfit()
  {
   double p=0;

   for(int i=PositionsTotal()-1; i>=0; i--)
     {
      if(PositionSelectByTicket(PositionGetTicket(i)))
        {
         p+=PositionGetDouble(POSITION_PROFIT)+PositionGetDouble(POSITION_SWAP);
        }
     }
   return(p);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CountTrades(string sm)
  {
   int count=0;

   for(int i=PositionsTotal()-1; i>=0; i--)
     {
      if(PositionSelectByTicket(PositionGetTicket(i)))
        {
         if(PositionGetString(POSITION_SYMBOL)==sm)
           {
            if(OrderGetInteger(ORDER_TYPE)<2)
               count++;
           }
        }
     }
   return(count);
  }
//+------------------------------------------------------------------+
//| Лот                                                              |
//+------------------------------------------------------------------+
double Lot(string sm)
  {
   double lots=Lots;

   lots=NormalizeDouble(Lots*MathPow(KLot,CountTrades(sm)),2);

   if(lots>MaxLot)
      lots=Lots;
   if(lots<0.1)
      lots=0.1;

   return(lots);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   double Ask1=SymbolInfoDouble(Symb1,SYMBOL_ASK);
   double Ask2=SymbolInfoDouble(Symb2,SYMBOL_ASK);
   double Ask3=SymbolInfoDouble(Symb3,SYMBOL_ASK);

   double Bid1=SymbolInfoDouble(Symb1,SYMBOL_BID);
   double Bid2=SymbolInfoDouble(Symb2,SYMBOL_BID);
   double Bid3=SymbolInfoDouble(Symb3,SYMBOL_BID);
   
   double Point1=SymbolInfoDouble(Symb1,SYMBOL_POINT);
   double Point2=SymbolInfoDouble(Symb2,SYMBOL_POINT);
   double Point3=SymbolInfoDouble(Symb3,SYMBOL_POINT);

   ArraySetAsSeries(ma1,true);
   ArraySetAsSeries(ma2,true);
   CopyBuffer(m1,0,0,2,ma1);
   CopyBuffer(m2,0,0,2,ma2);

   if(bars!=Bars(NULL,0))
     {
      if(AllProfit()>Profit || AllProfit()<-Loss)
         CloseAll();

      if(Symb1!="")
        {
         if(ma1[0]>ma2[0] && ma1[1]<ma2[1])
           {
            trade.PositionOpen(Symb1,1,Lot(Symb1),Bid1,0,0);
            for(int i=1;i<=Count;i++) trade.SellStop(Lots,Bid1-Delta*Point1*i,Symb1);
            trade.PositionOpen(Symb2,0,Lot(Symb2),Ask2,0,0);
            for(int i=1;i<=Count;i++) trade.BuyStop(Lots,Bid2+Delta*Point2*i,Symb2);
            trade.PositionOpen(Symb3,0,Lot(Symb3),Ask3,0,0);
            for(int i=1;i<=Count;i++) trade.BuyStop(Lots,Bid3+Delta*Point3*i,Symb3);
           }
         if(ma1[0]<ma2[0] && ma1[1]>ma2[1])
           {
            trade.PositionOpen(Symb1,0,Lot(Symb1),Ask1,0,0);
            for(int i=1;i<=Count;i++) trade.BuyStop(Lots,Bid1+Delta*Point1*i,Symb1);
            trade.PositionOpen(Symb2,1,Lot(Symb2),Bid2,0,0);
            for(int i=1;i<=Count;i++) trade.SellStop(Lots,Bid2-Delta*Point2*i,Symb2);
            trade.PositionOpen(Symb3,1,Lot(Symb3),Bid3,0,0);
            for(int i=1;i<=Count;i++) trade.SellStop(Lots,Bid3-Delta*Point3*i,Symb3);
           }
        }
      bars=Bars(NULL,0);
     }

   Comment("\n Lot : ",Lot(_Symbol),
           "\n Profit : ",AllProfit());
  }
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+

Спасибо, заказ снимается.Переделал сам по аналогии с другими советниками из базы.
В замен прошу переписать советник zakaz.opentraders.ru/56747.html www.opentraders.ru/downloads/2879/ с mql4 на mql5
И добавить обязательно проверку на исполнение приказов.

В функции нет выбора позиций по идентификатору советника.Нужно записать так:

<code>//+------------------------------------------------------------------+
//| Закрытие позиции по типу ордера                                  |
//+------------------------------------------------------------------+
void CloseAll(int ot=-1)
  {
   bool cl;
   int dig=0;
   double bid=0,ask=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();
            bid=MarketInfo(OrderSymbol(),MODE_BID);
            dig=(int)MarketInfo(OrderSymbol(),MODE_DIGITS);
            cl=OrderClose(OrderTicket(),OrderLots(),NormalizeDouble(bid,dig),33,White);
           }
         if(OrderType()==1 && (ot==1 || ot==-1))
           {
            RefreshRates();
            ask=MarketInfo(OrderSymbol(),MODE_ASK);
            dig=(int)MarketInfo(OrderSymbol(),MODE_DIGITS);
            cl=OrderClose(OrderTicket(),OrderLots(),NormalizeDouble(ask,dig),33,White);
           }
        }
     }
  }
}
Сейчас функция должна закрывать позиции только со своим магиком.
На разных парах должны быть разные магики.
</code>

У Вас функция закрытия позиции не разделяет позиции не по символу не по магику.
Замените:

<code>
//+------------------------------------------------------------------+
//| Закрывает ордера по указанному символу с указанным магиком       |
//+------------------------------------------------------------------+
void CloseAll(string symb,string symb, int op=-1, int magic=-1)
  {
   bool cl,sel;
   for(int i=0; i<OrdersTotal(); i++)
     {
      sel=OrderSelect(i,SELECT_BY_POS,MODE_TRADES);
      if(OrderSymbol()==symb && OrderMagicNumber()==magic)
        {
         RefreshRates();
         double bid=MarketInfo(symb,MODE_BID);
         double ask=MarketInfo(symb,MODE_ASK);
         if(OrderType()==OP_BUY) cl=OrderClose(OrderTicket(),OrderLots(),bid,Slippage,Blue);
         if(OrderType()==OP_SELL) cl=OrderClose(OrderTicket(),OrderLots(),ask,Slippage,Red);
        }
      Sleep(1000);
     }
  }</code>

Дальше записываете:

<code>
void OnTick(){

if(TimeCurrent()-OrderOpenTime()>=Exit)
{
CloseAll("EURUSD",0,Magic);
}

if(TimeCurrent()-OrderOpenTime()>=Exit)
{
CloseAll("EURUSD",1,Magic);
}
}
</code>

Только и в функции открытия позиции надо прописать нужную пару.

По коду:
if(TimeCurrent()-OrderOpenTime()>=Exit)// в секундах
//if(TimeCurrent()-OrderOpenTime()>=Exit*60*60)// в часах
//если разница между текущем временем TimeCurrent()и временем открытия 
//позиции OrderOpenTime() в секундах больше заданного Exit в секундах
//тогда закрываем позицию.
     {
      
      CloseAll();
     }

extern int Exit = 14400;

4 часа * 3600 секунд = 14400 секунд

Вы полагаете, что Андрей помнит каждую строчку кода каждого советника каждому заказчику???
Дайте ссылку на советник или прикрепите код, конечно если хотите получить возможность помощи.

В настоящий момент советник только открывает позиции:

if(Symb1!="")
        {
         if(ZZPrice(0)>ZZPrice(1) && b)
           {
            trade.PositionOpen(Symb1,1,Lot(Symb1),Bid1,0,0);
            trade.PositionOpen(Symb2,0,Lot(Symb2),Ask2,0,0);
            trade.PositionOpen(Symb3,0,Lot(Symb3),Ask3,0,0);
            b=0;
            s=1;
           }
         if(ZZPrice(0)<ZZPrice(1) && s)
           {
            trade.PositionOpen(Symb1,0,Lot(Symb1),Ask1,0,0);
            trade.PositionOpen(Symb2,1,Lot(Symb2),Bid2,0,0);
            trade.PositionOpen(Symb3,1,Lot(Symb3),Bid3,0,0);
            s=0;
            b=1;
           }
        }
      bars=Bars(NULL,0);
     }

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

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void DollarTrail()
  {
   double delta=AccountEquity()-AccountBalance();// 5050-5000=50

   if(delta>Profit && AccountEquity()-Profit>dollar)
     {
      dollar=AccountEquity()-Profit; // запоминаем эквити безубытка
     }
   if(AccountEquity()<dollar && AccountEquity()-AccountBalance()>0)
     {
      CloseAll();
      DelOrder();
     }
  }

Возможно Вы путаете торговлю одной парой у разных брокеров (используя задержку в их котировках) и торговлю одновременно двумя (тремя и ...) коррелирующими между собой парами у одного брокера.

Какой советник использовали?

//+------------------------------------------------------------------+
//| Установка ордера |
//| Параметры: |
//| op — операция |
//| pp — цена |
//| ldStop — уровень стоп |
//| ldTake — уровень тейк |
//+------------------------------------------------------------------+
void OpenPos(string symbol,int op, double pp, double ldStop, double ldTake, int mn=-1)
{
color clOpen;
int rez;
if (op==OP_BUY) clOpen=clOpenBuy;
else clOpen=clOpenSell;
rez=OrderSend(symbol,op,Lots,pp,Slippage,ldStop,ldTake,"",mn,0,clOpen);
if (UseSound) PlaySound(NameFileSound);
}
//+----------------------------------------------------------------------------+
//| Автор: Ким Игорь В. aka KimIV, www.kimiv.ru |
//+----------------------------------------------------------------------------+
//| Версия: 19.02.2008 |
//| Описание: Возвращает количество позиций. |
//+----------------------------------------------------------------------------+
//| Параметры: |
//| sy — наименование инструмента ("" — любой символ, |
//| NULL — текущий символ) |
//| op — операция (-1 — любая позиция) |
//| mn — MagicNumber (-1 — любой магик) |
//+----------------------------------------------------------------------------+
int NumberOfPositions(string sy="", int op=-1, int mn=-1) {
int i, k=OrdersTotal(), kp=0;

for (i=0; i<k; i++) {
if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) {
if (OrderSymbol()==sy || sy=="") {
if (OrderType()==OP_BUY || OrderType()==OP_SELL) {
if (op<0 || OrderType()==op) {
if (mn<0 || OrderMagicNumber()==mn) kp++;
}
}
}
}
}
return(kp);
}
//+----------------------------------------------------------------------------+
//| Автор: Ким Игорь В. aka KimIV, www.kimiv.ru |
//+----------------------------------------------------------------------------+
//| Версия: 19.02.2008 |
//| Описание: Возвращает суммарный профит открытых позиций в валюте депозита |
//+----------------------------------------------------------------------------+
//| Параметры: |
//| sy — наименование инструмента ("" — любой символ, |
//| NULL — текущий символ) |
//| op — операция (-1 — любая позиция) |
//| mn — MagicNumber (-1 — любой магик) |
//+----------------------------------------------------------------------------+
double ProfitOpenPos(string sy="", int op=-1, int mn=-1) {
double p=0;
int i, k=OrdersTotal();

for (i=0; i<k; i++) {
if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) {
if ((OrderSymbol()==sy || sy=="") && (op<0 || OrderType()==op)) {
if (OrderType()==OP_BUY || OrderType()==OP_SELL) {
if (mn<0 || OrderMagicNumber()==mn) {
p+=OrderProfit()+OrderCommission()+OrderSwap();
}
}
}
}
}
return(p);
}
//+----------------------------------------------------------------------------+
//| Автор: Ким Игорь В. aka KimIV, www.kimiv.ru |
//+----------------------------------------------------------------------------+
//| Закрытие позиций по рыночной цене |
//| Параметры: |
//| sym — наименование инструмента ("" — текущий символ) |
//| op — операция (-1 — любая позиция) |
//| mn — MagicNumber (-1 — любой магик) |
//+----------------------------------------------------------------------------+
void ClosePositions(string sym="", int op=-1, int mn=-1) {
int i, k=OrdersTotal();
int rez=0;
if (sym=="") sym=Symbol();
for (i=k-1; i>=0; i--) {
if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) {
if (OrderSymbol()==sym && (op<0 || OrderType()==op)) {
if (mn<0 || OrderMagicNumber()==mn) {
if (OrderType()==OP_BUY) {
rez=OrderClose(OrderTicket(), OrderLots(), Bid, Slippage, clrBlue);
}
if (OrderType()==OP_SELL) {
rez=OrderClose(OrderTicket(), OrderLots(), Ask, Slippage, clrRed);
}
}
}
}
}
}
//+------------------------------------------------------------------+

Смотрите.Выкладываю в таком виде, что-бы не скачивать «кота в мешке»:

//+------------------------------------------------------------------+
//|                                           Выбор треугольники.mq4 |
//|                        Copyright 2013, MetaQuotes Software Corp. |
//|                                          http://www.mункцql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2013, MetaQuotes Software Corp."
#property link      "http://www.mункцql5.com"
#property version   "1.00"
#property strict


extern string Trade = "Параметры торговли";
extern double Lots          = 0.1;       // Размер торгуемого лота
extern int    StopLoss      = 400;       // Размер фиксированного стопа
extern int    TakeProfit    = 100;       // Размер фиксированного тэйка
extern double ProfitClose   = 10;        // Pакрывать все ордера при получении профита
extern bool   Buy           = true;      // Направление торговли true - покупка , false - продажа
extern string a             = "Покупаем треугольник";
extern string SymbolBUY     = "EURUSD";
extern string SymbolSELL1   = "GBPUSD";
extern string SymbolSELL2   = "EURGBP";
extern string a1            = "Продаем треугольник";
extern string SymbolSell    = "EURUSD";
extern string SymbolBuy1    = "GBPUSD";
extern string SymbolBuy2    = "EURGBP";
extern int    Magic         = 0;       // Идентификатор
extern int    Slippage      = 3;       // Проскальзывание цены

string Name_Expert   = "Выбор треугольники";
bool   UseSound      = True;         // Использовать звуковой сигнал
string NameFileSound = "expert.wav"; // Наименование звукового файла
color  clOpenBuy     = Gold;         // Цвет ордера BuyStop
color  clOpenSell    = DodgerBlue;   // Цвет ордера SellStop
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---
   
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---
   
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- 
   if(Buy){
          MenegerBuy();
          }
      else{
          MenegerSell();
          }
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void MenegerBuy()
  {
//---
   double Bid1   =MarketInfo(SymbolBUY,MODE_BID);
   double Ask1   =MarketInfo(SymbolBUY,MODE_ASK);
   double Bid2   =MarketInfo(SymbolSELL1,MODE_BID);
   double Ask2   =MarketInfo(SymbolSELL1,MODE_ASK);
   double Bid3   =MarketInfo(SymbolSELL2,MODE_BID);
   double Ask3   =MarketInfo(SymbolSELL2,MODE_ASK);

  double ldStop=0, ldTake=0;
  
   double Profit = ProfitOpenPos(SymbolBUY,OP_BUY,Magic)+ProfitOpenPos(SymbolSELL1,OP_SELL,Magic)+ProfitOpenPos(SymbolSELL2,OP_SELL,Magic);
   if(Profit>ProfitClose)
     {
       ClosePositions(SymbolBUY,OP_BUY,Magic);
       ClosePositions(SymbolSELL1,OP_SELL,Magic);
       ClosePositions(SymbolSELL2,OP_SELL,Magic);
     }

if(NumberOfPositions(SymbolBUY)<1 && NumberOfPositions(SymbolSELL1)<1 && NumberOfPositions(SymbolSELL2)<1)
 {
  if (StopLoss!=0) ldStop=Ask1-StopLoss*Point;
  if (TakeProfit!=0) ldTake=Ask1+TakeProfit*Point;
  OpenPos(SymbolBUY,OP_BUY, Ask1, ldStop, ldTake, Magic);

  if (StopLoss!=0) ldStop=Bid2+StopLoss*Point;
  if (TakeProfit!=0) ldTake=Bid2-TakeProfit*Point;
  OpenPos(SymbolSELL1,OP_SELL, Bid2, ldStop, ldTake, Magic);
  
  if (StopLoss!=0) ldStop=Bid3+StopLoss*Point;
  if (TakeProfit!=0) ldTake=Bid3-TakeProfit*Point;
  OpenPos(SymbolSELL2,OP_SELL, Bid3, ldStop, ldTake, Magic);
   }
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void MenegerSell()
  {
//---
   double Bid1   =MarketInfo(SymbolSell,MODE_BID);
   double Ask1   =MarketInfo(SymbolSell,MODE_ASK);
   double Bid2   =MarketInfo(SymbolBuy1,MODE_BID);
   double Ask2   =MarketInfo(SymbolBuy1,MODE_ASK);
   double Bid3   =MarketInfo(SymbolBuy2,MODE_BID);
   double Ask3   =MarketInfo(SymbolBuy2,MODE_ASK);

  double ldStop=0, ldTake=0;
  
   double Profit = ProfitOpenPos(SymbolSell,OP_SELL,Magic)+ProfitOpenPos(SymbolBuy1,OP_BUY,Magic)+ProfitOpenPos(SymbolBuy2,OP_BUY,Magic);
   if(Profit>ProfitClose)
     {
       ClosePositions(SymbolSell,OP_SELL,Magic);
       ClosePositions(SymbolBuy1,OP_BUY,Magic);
       ClosePositions(SymbolBuy2,OP_BUY,Magic);
     }

if(NumberOfPositions(SymbolBUY)<1 && NumberOfPositions(SymbolSELL1)<1 && NumberOfPositions(SymbolSELL2)<1)
 {
  if (StopLoss!=0) ldStop=Ask1+StopLoss*Point;
  if (TakeProfit!=0) ldTake=Bid1-TakeProfit*Point;
  OpenPos(SymbolSell,OP_SELL, Bid1, ldStop, ldTake, Magic);

  if (StopLoss!=0) ldStop=Bid2-StopLoss*Point;
  if (TakeProfit!=0) ldTake=Ask2+TakeProfit*Point;
  OpenPos(SymbolBuy1,OP_BUY, Ask2, ldStop, ldTake, Magic);
  
  if (StopLoss!=0) ldStop=Bid3-StopLoss*Point;
  if (TakeProfit!=0) ldTake=Ask3+TakeProfit*Point;
  OpenPos(SymbolBuy2,OP_BUY, Ask3, ldStop, ldTake, Magic);
   }
   
  }

Попробуйте так:

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   double blu = iCustom(NULL,0,IndName,Fast,Slow,Price,0,0);
   double red = iCustom(NULL,0,IndName,Fast,Slow,Price,1,0);

   double blu2 = iCustom(NULL,0,IndName,Fast2,Slow2,Price2,0,0);
   double red2 = iCustom(NULL,0,IndName,Fast2,Slow2,Price2,1,0);

   bool buy = blu!=EMPTY_VALUE && blu2!=EMPTY_VALUE;
   bool sell = red!=EMPTY_VALUE && red2!=EMPTY_VALUE;


      if(AllProfit()>=Profit && Profit>0)
         CloseAll();

      if(AllProfit(0)>=BuyProfit && BuyProfit>0)
         CloseAll(0);

      if(AllProfit(1)>=SellProfit && SellProfit>0)
         CloseAll(1);
         
   if(t!=Time[0])
     {
      if(CloseSig>0)
        {
         if(buy)
           {
            CloseAll(1);
           }
         if(sell)
           {
            CloseAll(0);
           }
        }

      if(Hour()>=StartHour && Hour()<=EndHour)
        {
         if(buy && (CountTradeS(0)<1 || (LastOrderType()==1 && CountTradeS(0)<Count)))
           {
            PutOrder(0,Ask);
           }
         if(sell && (CountTradeS(0)<1 || (LastOrderType()==1 && CountTradeS(1)<Count)))
           {
            PutOrder(1,Bid);
           }
        }
      t=Time[0];
     }

   Comment("\n Trades: ",CountTradeS(0),
           "\n Trades: ",CountTradeS(1),
           "\n Profit : ",AllProfit(),
           "\n Buy Profit : ",AllProfit(0),
           "\n Sell Profit : ",AllProfit(1),
           "\n Blu: ",blu,
           "\n Red: ",red,
           "\n Blu2: ",blu2,
           "\n Red2: ",red2);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CountTradeS(int ot=-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()<2)
               count++;
           }
        }
     }
   return(count);
  }
//+------------------------------------------------------------------+
//| Тип последней сделки                                             |
//+------------------------------------------------------------------+
int LastOrderType(){
   int type=8;
   for(int i=OrdersTotal()-1; i>=0; i--){
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)){
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
            if(OrderType()==0)
              {
               type=0;//buy
               break;
              }
            if(OrderType()==1)
              {
               type=1;//sell
               break;
              }
           }
        }
     }
   return(type);
  }
//+------------------------------------------------------------------+

www.mql5.com/ru/forum/107476/page32

Когда то делал для своего советника

//+------------------------------------------------------------------+
//|                                                      Avr mtf.mq4 |
//|                        Copyright 2013, MetaQuotes Software Corp. |
//|                                          http://www.mункцql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2013, MetaQuotes Software Corp."
#property link      "http://www.mункцql5.com"
#property version   "1.00"
#property strict
#property indicator_chart_window
extern string s1 = "";
input ENUM_TIMEFRAMES TF_Trade=PERIOD_D1;
extern int    Hist = 30;                
extern bool   D1 = TRUE;
extern string FontName = "Arial Black"; // Название шрифта
extern int    FontSize = 10;            // Размер шрифта
extern int    x = 2;                    // Отступ по оси х
extern int    y = 5;                    // Отступ по оси y
extern int    Corner = 2;               // Угол привязки 0 - верхний левый угол, 1 - верхний правый, 2 - нижний левый, 3 - нижний правый

int ATR_h_l,ATR_h,ATR_l,ATR_b, day;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
    if(s1=="")s1=Symbol();
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---
   ObjectDelete("ATR_h");
   ObjectDelete("ATR_l");
   ObjectDelete("ATR_b");
   ObjectDelete("ATR_h_l");
   ObjectsDeleteAll();
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
//---
   int finish, summ_body = 0, summ_h = 0, summ_l = 0, summ_h_l = 0, clr_h_l, clr_h, clr_l, clr_b, toDay_h_l, toDay_h, toDay_l, toDay_body;
   
   if (day != TimeDay(TimeCurrent())) // Что бы не пересчитывать каждый тик
   {
      day = TimeDay(TimeCurrent());
      if (D1) finish = iBarShift(NULL, PERIOD_D1, iTime(NULL, PERIOD_W1, 0), false) + 1;
      else finish = 1;
      for (int i = Hist - 1 + finish; i >= finish; i--)
      {
         summ_h_l += (iHigh(s1, TF_Trade, i) - iLow(s1, TF_Trade, i)) / MarketInfo(s1,MODE_POINT);
         summ_body +=MathAbs((iOpen(s1, TF_Trade, i) - iClose(s1, TF_Trade, i))) / MarketInfo(s1,MODE_POINT);
         
        if ((iOpen(s1, TF_Trade, i) < iClose(s1, TF_Trade, i))) {summ_h +=(iHigh(s1, TF_Trade, i) - iClose(s1, TF_Trade, i)) / MarketInfo(s1,MODE_POINT);}
        if ((iOpen(s1, TF_Trade, i) > iClose(s1, TF_Trade, i))) {summ_h +=(iHigh(s1, TF_Trade, i) - iOpen(s1, TF_Trade, i)) / MarketInfo(s1,MODE_POINT);}
        
        if ((iOpen(s1, TF_Trade, i) < iClose(s1, TF_Trade, i))) {summ_l +=(iOpen(s1, TF_Trade, i) - iLow(s1, TF_Trade, i)) / MarketInfo(s1,MODE_POINT);}
        if ((iOpen(s1, TF_Trade, i) > iClose(s1, TF_Trade, i))) {summ_l +=(iClose(s1, TF_Trade, i) - iLow(s1, TF_Trade, i)) / MarketInfo(s1,MODE_POINT);}
        
      } 
      ATR_h_l = summ_h_l / Hist;
      ATR_h = summ_h / Hist;
      ATR_l = summ_l / Hist;
      ATR_b = summ_body / Hist;
   }

    toDay_h_l = (iHigh(s1, TF_Trade, 0) - iLow(s1 , TF_Trade, 0)) / MarketInfo(s1,MODE_POINT);
    if (toDay_h_l > ATR_h_l) clr_h_l = Red; else clr_h_l = Lime;
   
    if ((iOpen(s1, TF_Trade, 0) < iClose(s1, TF_Trade, 0))) {toDay_h +=(iHigh(s1, TF_Trade, 0) - iClose(s1, TF_Trade, 0)) / MarketInfo(s1,MODE_POINT);}
    if ((iOpen(s1, TF_Trade, 0) > iClose(s1, TF_Trade, 0))) {toDay_h +=(iHigh(s1, TF_Trade, 0) - iOpen(s1, TF_Trade, 0)) / MarketInfo(s1,MODE_POINT);}
    if (toDay_h > ATR_h)  clr_h = Red; else clr_h = Lime;
   
    toDay_body =MathAbs((iOpen(s1, TF_Trade, 0) - iClose(s1, TF_Trade, 0))) / MarketInfo(s1,MODE_POINT);
    if (toDay_body > ATR_b)  clr_b = Red; else clr_b = Lime;
   
    if ((iOpen(s1, TF_Trade, 0) < iClose(s1, TF_Trade, 0))) {toDay_l +=(iOpen(s1, TF_Trade, 0) - iLow(s1, TF_Trade, 0)) / MarketInfo(s1,MODE_POINT);}
    if ((iOpen(s1, TF_Trade, 0) > iClose(s1, TF_Trade, 0))) {toDay_l +=(iClose(s1, TF_Trade, 0) - iLow(s1, TF_Trade, 0)) / MarketInfo(s1,MODE_POINT);}
    if (toDay_l > ATR_l)  clr_l = Red; else clr_l = Lime;  
   
   ObjectCreate("ATR", OBJ_LABEL, 0, 0, 0);
   ObjectSet("ATR", OBJPROP_CORNER, Corner);
   ObjectSet("ATR", OBJPROP_YDISTANCE,y+80);
   ObjectSet("ATR", OBJPROP_XDISTANCE, x); 
   ObjectSetText("ATR", "Текущий спред "+s1+"  сейчас : " + DoubleToStr(MarketInfo(s1,MODE_SPREAD), 0) + " " , FontSize, FontName, clrLime);
   ObjectSet("ATR", OBJPROP_SELECTABLE, false); 
   
   
   ObjectCreate("ATR_h_l", OBJ_LABEL, 0, 0, 0);
   ObjectSet("ATR_h_l", OBJPROP_CORNER, Corner);
   ObjectSet("ATR_h_l", OBJPROP_YDISTANCE,y+60);
   ObjectSet("ATR_h_l", OBJPROP_XDISTANCE, x); 
   ObjectSetText("ATR_h_l", "Среднее значение ATR за "+Hist+" свечей по "+s1+": " + DoubleToStr(ATR_h_l, 0) + "  сегодня: " + toDay_h_l, FontSize, FontName, clr_h_l);
   ObjectSet("ATR_h_l", OBJPROP_SELECTABLE, false); 
   
   ObjectCreate("ATR_h", OBJ_LABEL, 0, 0, 0);
   ObjectSet("ATR_h", OBJPROP_CORNER, Corner);
   ObjectSet("ATR_h", OBJPROP_YDISTANCE, y+40);
   ObjectSet("ATR_h", OBJPROP_XDISTANCE, x); 
   ObjectSetText("ATR_h", "Среднее значение ATR_h за "+Hist+" свечей по "+s1+": " + DoubleToStr(ATR_h, 0) + "  сегодня: " + toDay_h, FontSize, FontName, clr_h);
   ObjectSet("ATR_h", OBJPROP_SELECTABLE, false); 
   
   ObjectCreate("ATR_body", OBJ_LABEL, 0, 0, 0);
   ObjectSet("ATR_body", OBJPROP_CORNER, Corner);
   ObjectSet("ATR_body", OBJPROP_YDISTANCE, y+20);
   ObjectSet("ATR_body", OBJPROP_XDISTANCE, x); 
   ObjectSetText("ATR_body", "Среднее значение ATR_b за "+Hist+" свечей по "+s1+": " + DoubleToStr(ATR_b, 0) + "  сегодня: " + toDay_body, FontSize, FontName, clr_b);
   ObjectSet("ATR_body", OBJPROP_SELECTABLE, false); 
   
   ObjectCreate("ATR_l", OBJ_LABEL, 0, 0, 0);
   ObjectSet("ATR_l", OBJPROP_CORNER, Corner);
   ObjectSet("ATR_l", OBJPROP_YDISTANCE, y);
   ObjectSet("ATR_l", OBJPROP_XDISTANCE, x); 
   ObjectSetText("ATR_l", "Среднее значение ATR_l за "+Hist+" свечей по "+s1+": " + DoubleToStr(ATR_l, 0) + "  сегодня: " + toDay_l, FontSize, FontName, clr_l);
   ObjectSet("ATR_l", OBJPROP_SELECTABLE, false); 
//------------------------------
   double dn=Low[iLowest(s1,TF_Trade,MODE_LOW,Hist,1)];
   double up=High[iHighest(s1,TF_Trade,MODE_HIGH,Hist,1)];
   double midl=(up+dn)/2;
   double delta=(up-dn)/MarketInfo(s1,MODE_POINT);
   
   PutHLine("Максимальная цена по "+s1+" за "+Hist+" свечей : ",up, clrLime);  
   PutHLine("Минимальная цена за "+Hist+" свечей по "+s1+": ",dn, clrRed);
   PutHLine("Средняя цена за "+Hist+" свечей по "+s1+": ",midl, clrWhite);
   
   ObjectCreate("Canal", OBJ_LABEL, 0, 0, 0);
   ObjectSet("Canal", OBJPROP_CORNER, Corner);
   ObjectSet("Canal", OBJPROP_YDISTANCE,y+100);
   ObjectSet("Canal", OBJPROP_XDISTANCE, x); 
   ObjectSetText("Canal", "Ширина канала  за "+Hist+" свечей по "+s1+": " + DoubleToStr(delta,0)+" пунктов" , FontSize, FontName, clrLime);
   ObjectSet("Canal", OBJPROP_SELECTABLE, false);   
//--- return value of prev_calculated for next call
   return(rates_total);
  }
//+------------------------------------------------------------------+
//| Горизонтальная линия                                             |
//+------------------------------------------------------------------+
void PutHLine(string name,double price, color cl)
  {
   ObjectCreate(0,name,OBJ_HLINE,0,0,price);
//--- установим цвет линии
   ObjectSetInteger(0,name,OBJPROP_COLOR,cl);
//--- установим толщину линии
   ObjectSetInteger(0,name,OBJPROP_WIDTH,1);
  }

//+------------------------------------------------------------------+

ATR_h среднее значение верхней тени
ATR_b среднее значение тела свечи
ATR_l среднее значение нижней тени

Андрей, спасибо.
Сейчас вроде бы с логикой все в порядке.

Нет.Собрался, но увидел Ваш вариант. Остановился. Решил с Вашим советником разобраться.

Я же привел скрин :forexsystemsru.com/attachments/2020-07-18_16-51-36-png.390247/

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

Андрей, спасибо.
Но есть две недоработки(проблемы):
1.Уровни первых и последующих ордеров одного направления не совпадают;
2.Советник на каждом тике выставляет и сразу удаляет вторичные ордера, грузится сервер и проблемы будут с брокером.
Прошу доработать советник.