Разница может быть здесь:

<code>
enum b
  {
   day=0,     //Дневной
   wen=1,     //Недельный
   mn=2,     //Месяц
  };
input       b        bar         = 2;   // Выбор периода 
</code>

А вообще то индикатор написан на пятерке, а советник на четверке.Но не в этом суть.
В индикаторе соответственно нет буферов.Можно перенести все функции из индикатора в советник. Только в чем смысл, если математика одна? Так что это просто «хотелки» для красоты.Тогда уже просите советник на пятерке для прогонов в тестере.
Мой вариант полностью соответствует поставленной задаче, даже чуть-чуть больше. Несколько вариантов закрытия. Можно еще и закрытие в конце торговых суток добавить.Допишите сами взяв функцию Андрея из любого его советника.

Ребята-вам «шашечки» или «ехать»?
Расчет в индикаторе:

 if(bar==0)
     {
      if(CopyRates(eu,PERIOD_D1,0,2,DailyBar)==2)
        {
         euChange=((DailyBar[0].close/DailyBar[1].close)-1.0)*100.0;
        }

      if(CopyRates(gu,PERIOD_D1,0,2,DailyBar)==2)
        {
         guChange=((DailyBar[0].close/DailyBar[1].close)-1.0)*100.0;
        }
     }

У меня в советнике:

 
   double delta1=(iClose(Symb1,PERIOD_D1,0)/iClose(Symb1,PERIOD_D1,1)-1)*100;
   double delta2=(iClose(Symb2,PERIOD_D1,0)/iClose(Symb2,PERIOD_D1,1)-1)*100;

Уберите

<code>в самой первой строке  и </code>

— это самая последняя строка.
Должно быть
//+------------------------------------------------------------------+
//| Corel6 hetmap.mq4 |
//| Copyright 2013, MetaQuotes Software Corp. |
//| www.mункцql5.com |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| Corel6.mq4 |
//| Copyright 2021, AM2 |
//| www.forexsystems.biz |
//+------------------------------------------------------------------+
#property copyright «Copyright 2021, AM2»
#property link «www.forexsystems.biz»
#property version «1.00»
#property strict

extern string Symb1 = «EURUSD»;
extern string Symb2 = «USDCHF»;
extern double Delta_open = 0.5;
extern double Delta_close= 0.2;

extern double Lot = 1; // лот
extern double Loss = 2000; // убыток
extern double Profit = 100; // профит
extern int Slip = 111; // реквот
extern int Magic = 123; // магик

и
Comment(
"\n",Symb1," ",DoubleToStr(delta1,2),"%",
"\n",Symb2," ",DoubleToStr(delta2,2),"%",
"\nDelta ",DoubleToStr(Delta,2),"%",
"\nDelta_open ",Delta_open,"%",
"\nDelta_close ",Delta_close,"%",
"\n Profit: ",AllProfit());
}
//+------------------------------------------------------------------+

Проверьте у себя

extern string Symb1      = "EURUSD";
extern string Symb2      = "USDCHF";

У меня ошибок нет.Переведите сами что означает эта строка при компеляции.
Причем у Вас ошибка с самой первой строки кода.Повнимательнее копируйте.

Немного дополнил советник Андрея согласно пожеланию.Надеюсь не обидеться.

<code>//+------------------------------------------------------------------+
//|                                                Corel6 hetmap.mq4 |
//|                        Copyright 2013, MetaQuotes Software Corp. |
//|                                          http://www.mункцql5.com |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//|                                                       Corel6.mq4 |
//|                                              Copyright 2021, AM2 |
//|                                      http://www.forexsystems.biz |
//+------------------------------------------------------------------+
#property copyright "Copyright 2021, AM2"
#property link      "http://www.forexsystems.biz"
#property version   "1.00"
#property strict

extern string Symb1      = "EURUSD";
extern string Symb2      = "USDCHF";
extern double Delta_open =  0.5;  
extern double Delta_close=  0.2;

extern double Lot        = 1;        // лот
extern double Loss       = 2000;     // убыток
extern double Profit     = 100;      // профит
extern int Slip          = 111;      // реквот
extern int Magic         = 123;      // магик

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---
   Comment("");
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   Comment("");
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void PutOrder(string symb,int type,double price)
  {
   int r=0;
   int dg=(int)SymbolInfoInteger(symb,SYMBOL_DIGITS);

   color clr=Green;

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

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

   r=OrderSend(symb,type,Lot,NormalizeDouble(price,dg),Slip,0,0,"",Magic,0,clr);
   return;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CloseAll()
  {
   bool cl;
   int dig=0;
   string symb="";
   double bid=0,ask=0;

   for(int i=OrdersTotal()-1; i>=0; i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderMagicNumber()==Magic && (OrderSymbol()==Symb1 || OrderSymbol()==Symb2))
           {
            if(OrderType()==0)
              {
               symb=OrderSymbol();
               bid=MarketInfo(symb,MODE_BID);
               dig=(int)MarketInfo(symb,MODE_DIGITS);
               RefreshRates();
               cl=OrderClose(OrderTicket(),OrderLots(),NormalizeDouble(bid,dig),Slip,White);
              }
            if(OrderType()==1)
              {
               symb=OrderSymbol();
               ask=MarketInfo(symb,MODE_ASK);
               dig=(int)MarketInfo(symb,MODE_DIGITS);
               RefreshRates();
               cl=OrderClose(OrderTicket(),OrderLots(),NormalizeDouble(ask,dig),Slip,White);
              }
           }
        }
     }
  }
//+------------------------------------------------------------------+
//| Профит всех ордеров по типу ордера                               |
//+------------------------------------------------------------------+
double AllProfit()
  {
   double pr=0;
   for(int i=OrdersTotal()-1; i>=0; i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderMagicNumber()==Magic && (OrderSymbol()==Symb1 || OrderSymbol()==Symb2))
           {
            pr+=OrderProfit()+OrderCommission()+OrderSwap();
           }
        }
     }
   return(pr);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CountTrades()
  {
   int count=0;
   for(int i=OrdersTotal()-1; i>=0; i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderMagicNumber()==Magic && (OrderSymbol()==Symb1 || OrderSymbol()==Symb2))
           {
            if(OrderType()<2)
               count++;
           }
        }
     }
   return(count);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   double ask1=MarketInfo(Symb1,MODE_ASK);
   double ask2=MarketInfo(Symb2,MODE_ASK);

   double bid1=MarketInfo(Symb1,MODE_BID);
   double bid2=MarketInfo(Symb2,MODE_BID);
   
   double delta1=(iClose(Symb1,PERIOD_D1,0)/iClose(Symb1,PERIOD_D1,1)-1)*100;
   double delta2=(iClose(Symb2,PERIOD_D1,0)/iClose(Symb2,PERIOD_D1,1)-1)*100;
   double Delta=MathAbs(delta1-delta2);

   if(AllProfit()>Profit && Profit>0){
      CloseAll();
      Alert("Позиции закрыты по достижению советником прибыли :",Profit);
      }

   if(AllProfit()<-Loss && Loss>0){
      CloseAll();
     Alert("Позиции закрыты по достижению советником убытка :",Loss);
      }
         
   if(CountTrades()>=1 && Delta<Delta_close){
      CloseAll();
      Alert("Позиции закрыты по достижению советником минимального расхождения  :",Delta_close,"%");
      }
  
  
   if(CountTrades()<1)
     {
      if(Delta>Delta_open && delta1>delta2){
         PutOrder(Symb1,1,bid1);
         PutOrder(Symb2,0,ask2);
         Alert("Позиции открыты по достижению советником необходимого расхождения  :",Delta_open,"%");
         }
     if(Delta>Delta_open && delta1<delta2){ 
         PutOrder(Symb1,0,ask1);
         PutOrder(Symb2,1,bid2);
         Alert("Позиции открыты по достижению советником необходимого расхождения  :",Delta_open,"%");
         }
     }

   Comment(
   "\n",Symb1," ",DoubleToStr(delta1,2),"%",
   "\n",Symb2," ",DoubleToStr(delta2,2),"%",
   "\nDelta ",DoubleToStr(Delta,2),"%",
   "\nDelta_open ",Delta_open,"%",
   "\nDelta_close ",Delta_close,"%",
   "\n Profit : ",AllProfit());
  }
//+------------------------------------------------------------------+
</code>

//+----------------------------------------------------------------------------+
//|  Управление позициями                                                      |
//+----------------------------------------------------------------------------+
void ManagePositions(string sym="") {
  double sl=0, tp=0;
  int    bs=GetTradeSignal(sym);
  double  pa=MarketInfo(sym, MODE_ASK);
  double  pb=MarketInfo(sym, MODE_BID);
  int spread = MarketInfo(sym, MODE_SPREAD);
  int  ticket;
  
  if(UseBU) MovingInWL(sym);
  if (UseTrailing) TrailingPositions(sym);
  
 if(DayOfWeek()==1 && Hour()==HourOpenPos && Minute()>=MinuteOpenPos && Minute()<=MinuteOpenPos+5){
  if (bs>0 && spread < MaxSpread) {
    if (ExistPositions(sym, OP_SELL,MAGIC)) ClosePositions(sym, OP_SELL,MAGIC);
    if (!ExistPositions(sym, OP_BUY,MAGIC)) {
      if (StopLoss!=0) sl=pb-StopLoss*Point;
      if (TakeProfit!=0) tp=pa+TakeProfit*Point;
      ticket=OrderSend(sym, OP_BUY, Lots, pa, Slippage, sl, tp, "", MAGIC, 0, clrBlue);
      }
    }
  if (bs<0 && spread < MaxSpread) {
    if (ExistPositions(sym, OP_BUY,MAGIC)) ClosePositions(sym, OP_BUY,MAGIC);
    if (!ExistPositions(sym, OP_SELL,MAGIC)) {
      if (StopLoss!=0) sl=pa+StopLoss*Point;
      if (TakeProfit!=0) tp=pb-TakeProfit*Point;
      ticket=OrderSend(sym, OP_SELL, Lots, pb, Slippage, sl, tp, "", MAGIC, 0, clrRed);
      }
    }
 }
}
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 23.04.2009                                                     |
//|  Описание : Перенос уровня стопа в безубыток                               |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   ( ""  - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    op - операция                   ( -1  - любая позиция)                  |
//|    mn - MagicNumber                ( -1  - любой магик)                    |
//+----------------------------------------------------------------------------+
void MovingInWL(string sym="", int op=-1, int mn=-1) {
  double po, pp;
  int    i, k=OrdersTotal();
  bool   fm;
  if (sym=="0") sym=Symbol();
  for (i=0; i<k; i++) {
    if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) {
      if ((OrderSymbol()==sym || sym=="") && (op<0 || OrderType()==op)) {
        if (mn<0 || OrderMagicNumber()==mn) {
          po=MarketInfo(OrderSymbol(), MODE_POINT);
          if (OrderType()==OP_BUY) {
            if (OrderStopLoss()-OrderOpenPrice()<LevelWLoss*po) {
              pp=MarketInfo(OrderSymbol(), MODE_BID);
              if (pp-OrderOpenPrice()>LevelProfit*po) {
               // ModifyOrder(-1, OrderOpenPrice()+LevelWLoss*po, -1);
                fm=OrderModify(OrderTicket(),OrderOpenPrice(),OrderOpenPrice()+LevelWLoss*pp,OrderTakeProfit(),CLR_NONE);        
              }
            }
          }
          if (OrderType()==OP_SELL) {
            if (OrderStopLoss()==0 || OrderOpenPrice()-OrderStopLoss()<LevelWLoss*po) {
              pp=MarketInfo(OrderSymbol(), MODE_ASK);
              if (OrderOpenPrice()-pp>LevelProfit*po) {
               // ModifyOrder(-1, OrderOpenPrice()-LevelWLoss*po, -1);
                fm=OrderModify(OrderTicket(),OrderOpenPrice(),OrderOpenPrice()-LevelWLoss*pp,OrderTakeProfit(),CLR_NONE);
         
              }
            }
          }
        }
      }
    }
  }
}
//+------------------------------------------------------------------+
//| Сопровождение позиции простым тралом                             |
//+------------------------------------------------------------------+
void TrailingPositions(string sym="", int op=-1, int mn=-1) {
  double po, pp;
  int    i, k=OrdersTotal();
  if (sym=="0") sym=Symbol();
  for (i=0; i<k; i++) {
    if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) {
    if ((OrderSymbol()==sym || sym=="") && (op<0 || OrderType()==op)) {
        if (mn<0 || OrderMagicNumber()==mn) {
        po=MarketInfo(OrderSymbol(), MODE_POINT);
         if (OrderType()==OP_BUY) {
         pp=MarketInfo(OrderSymbol(), MODE_BID);
          if (!ProfitTrailing || (pp-OrderOpenPrice())>TrailingStop*Point) {
            if (OrderStopLoss()<pp-(TrailingStop+TrailingStep-1)*Point) {
              ModifyStopLoss(pp-TrailingStop*Point, clModifyBuy);
             }
           }
         }
        if (OrderType()==OP_SELL) {
        pp=MarketInfo(OrderSymbol(), MODE_ASK);
          if (!ProfitTrailing || OrderOpenPrice()-Ask>TrailingStop*Point) {
            if (OrderStopLoss()>Ask+(TrailingStop+TrailingStep-1)*Point || OrderStopLoss()==0) {
              ModifyStopLoss(Ask+TrailingStop*Point, clModifySell);
              }
            }
          }
        }
      }
    }
  }
}
//+---------------------------------------------------------------------------+
//| Перенос уровня StopLoss                                                   |
//| Параметры:                                                                |
//|   ldStopLoss - уровень StopLoss                                           |
//|   clModify   - цвет модификации                                           |
//+---------------------------------------------------------------------------+
void ModifyStopLoss(double ldStop, color clModify) {
  bool   fm;
  double ldOpen=OrderOpenPrice();
  double ldTake=OrderTakeProfit();

  fm=OrderModify(OrderTicket(), ldOpen, ldStop, ldTake, 0, clModify);
  if (fm && UseSound) PlaySound(NameFileSound);
}
//+----------------------------------------------------------------------------+

<code>
//+------------------------------------------------------------------+
//|                                              Недельный откат.mq4 |
//|                        Copyright 2013, MetaQuotes Software Corp. |
//|                                              http://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2013, MetaQuotes Software Corp."
#property link      "http://www.mql5.com"
#property version   "1.00"
#property strict

//------- Внешние параметры советника ------------------------------------------
extern string _P_Trade = "---------- Параметры торговли";
extern ENUM_TIMEFRAMES Tf = PERIOD_W1; 
extern double Lots        = 0.1;       // Лот
extern bool   revers      = false;     // Использовать опцию реверс
extern int    HourOpenPos = 0;         // Час открытия позиции
extern int    MinuteOpenPos  = 15;     // Минуты открытия позиции
extern int    StopLoss    = 0;         // Стоп
extern int    TakeProfit  = 0;         // Тейк
extern int    Razmah      = 1000;      // Диапазон свечи 
                                        //после тестирования и подбора величены Razmah для каждой пары отдельно 
                                        //записать это значение в функцию bool InitParameters() для соответсвующей пары
                                       // и эту переменную за комментировать вот так: //extern int    Razmah      = 1000;      // Диапазон свечи 

//int Razmah; //после тестирования и подбора величены Razmah для каждой пары отдельно эту переменную раскомментировать вот так: int Razmah;
extern int    MaxSpread   = 30;        // Максимально допустимый спред пары
extern int    MAGIC       = 1000;      // Идентификатор позиций
extern string _P_BU = "---------- Параметры функции безубытка";
extern bool   UseBU       = True;      // Использовать безубыток
extern int    LevelProfit = 25;        // Уровень профита в пунктах
extern int    LevelWLoss  = 1;         // Уровень безубытка в пунктах
extern bool   ShowComment = True;      // Показывать комментарий
extern string _P_Trailing = "---------- Параметры функции трала";
extern bool   UseTrailing     = True;   // Использовать трал
extern bool   ProfitTrailing  = True;   // Тралить только профит
extern int    TrailingStop    = 60;     // Фиксированный размер трала
extern int    TrailingStep    = 5;      // Шаг трала
//------- Глобальные переменные советника --------------------------------------
extern bool   UseSound      = True;         // Использовать звуковой сигнал
extern string NameFileSound = "expert.wav"; // Наименование звукового файла
int    Slippage     = 30;                   // Проскальзывание
color  clOpenBuy    = LightBlue;            // Цвет открытия покупки
color  clOpenSell   = LightCoral;           // Цвет открытия продажи
color  clModifyBuy  = Aqua;                 // Цвет модификации покупки
color  clModifySell = Tomato;               // Цвет модификации продажи
color  clCloseBuy   = Blue;                 // Цвет закрытия покупки
color  clCloseSell  = Red;                  // Цвет закрытия продажи
string Symbol_array[] = {"EURUSD","GBPUSD","USDJPY","USDCHF"};
int countSymbol;       //=== количество торгуемых инструментов (массив Symbol_array[])
bool  bTradeBuy;
//------- Подключение внешних модулей ------------------------------------------

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

//+------------------------------------------------------------------+
//| Expert InitParameters function                                   |
//+------------------------------------------------------------------+   
  bool InitParameters() {
  if (Symbol()=="EURUSD") {
    bTradeBuy=False;
    switch (DayOfWeek()) {
      case 1:
        Razmah=1000;
        return(True);
    }
  } else if (Symbol()=="GBPUSD") {
    bTradeBuy=False;
    switch (DayOfWeek()) {
      case 1:
        Razmah=1200;
        return(True);
    }
  } else if (Symbol()=="USDCHF") {
    bTradeBuy=True;
    switch (DayOfWeek()) {
      case 1:
        Razmah=950;
        return(True);
    }
  } else if (Symbol()=="USDJPY") {
    bTradeBuy=True;
    switch (DayOfWeek()) {
      case 1:
        Razmah=1300;
        return(True);
    }
  } else {
    Comment("Советник НЕ поддерживает работу с "+Symbol());
    return(False);
  }
//---
    return(0);
  }  
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//---
     int i;
     for(i=0; i<ArraySize(Symbol_array); i++)//=== перебор инструментов
       { 
        string symbols = Symbol_array[i];
        ManagePositions (symbols);
       } 
//---
  }
//+----------------------------------------------------------------------------+
//|  Закрытие позиций по рыночной цене                                         |
//|  Параметры:                                                                |
//|    sym - наименование инструмента ("" - текущий символ)                    |
//|    op  - операция                 (-1 - любая позиция)                     |
//|    mn  - MagicNumber              (-1 - любой магик)                       |
//+----------------------------------------------------------------------------+
void ClosePositions(string sym="", int op=-1, int mn=-1) {
  int i, k=OrdersTotal();
  int rez;
  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, clCloseBuy);
          }
          if (OrderType()==OP_SELL) {
            rez=OrderClose(OrderTicket(), OrderLots(), Ask, Slippage, clCloseSell);
          }
        }
      }
    }
  }
}
//+----------------------------------------------------------------------------+
//|  Возвращает флаг существования позиций                                     |
//|  Параметры:                                                                |
//|    sym - наименование инструмента ("" - текущий символ)                    |
//|    op  - операция                 (-1 - любая позиция)                     |
//|    mn  - MagicNumber              (-1 - любой магик)                       |
//+----------------------------------------------------------------------------+
bool ExistPositions(string sym="", int op=-1, int mn=-1) {
  int i, k=OrdersTotal();
  if (sym=="") sym=Symbol();
  for (i=0; i<k; i++) {
    if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) {
      if (OrderSymbol()==sym) {
        if (OrderType()==OP_BUY || OrderType()==OP_SELL) {
          if (op<0 || OrderType()==op) {
            if (mn<0 || OrderMagicNumber()==mn) return(True);
          }
        }
      }
    }
  }
  return(False);
}
//+----------------------------------------------------------------------------+
//|  Возвращает торговый сигнал:                                               |
//|     1 - покупай                                                            |
//|     0 - сиди, кури бамбук                                                  |
//|    -1 - продавай                                                           |
//|  Параметры:                                                                |
//|    sym - наименование инструмента ("" - текущий символ)                    |
//|    tf  - таймфрейм                ( 0 - текущий таймфрейм)                 |
//+----------------------------------------------------------------------------+
int GetTradeSignal(string sym="", int tf=0) {
  int bs=0;
  int  pp=MarketInfo(sym, MODE_POINT);
  double op1=iOpen(sym,Tf,1);         
  double cl1=iClose(sym,Tf,1);        
  double l1=iLow(sym,Tf,1);             
  double h1=iHigh(sym,Tf,1);           

  // Блок анализа с присвоением значения переменной bs
  if (InitParameters()) {
  if(!revers){
        if(op1-cl1>=Razmah*pp)bs=1;
        if(cl1-op1>=Razmah*pp)bs=-1;
      }
  else{
      if(op1-cl1>=Razmah*pp)bs=-1;
      if(cl1-op1>=Razmah*pp)bs=1;
      }
  }
  return(bs);
}
</code>

Вспомнил о своем старинном мультивалютном советнике с очень схожей стратегией. советника.
Суть стратегии ясна из названия
Немного подчистил код.
Советник почти полностью написан с использованием функция Игоря Кима. Правда функции упращёном варианте.
Пары торгуются независимо друг от друга.
Направление торговли определяется минимальным размером тела свечи (переменная Razmah) и бычья или медвежья свеча.
Переменная Razmah подбирается для каждой пары индивидуально и прописывается в функции

<code>//+------------------------------------------------------------------+
//| Expert InitParameters function                                   |
//+------------------------------------------------------------------+   
  bool InitParameters() {
  if (Symbol()=="EURUSD") {
    bTradeBuy=False;
    switch (DayOfWeek()) {
      case 1:
        Razmah=1000;</code>

Внимательно прочитайте действия с переменной Razmah в настройках.
Там все прописано, разжёвывать не буду.
Кол-во пар не ограниченно.Записывается в

<code>string Symbol_array[] = {"EURUSD","GBPUSD","USDJPY","USDCHF"};</code>

Если увеличиваете кол-во пар — дополняйте эти пары в bool InitParameters() {
Аналогично там же можно прописать тейки и стопы для каждой пары отдельно.
Закрытие либо по тейку, либо по стопу.
Если на начало новой недели закрытия не произошло, то при смене сигнала по паре произойдет закрытие позиции.
Так же есть трал и безубыток для каждой пары отдельно.
Открытия раз в неделю в понедельник.
Есть проверка на максимальный спред.
В свое время советник торговал на реальном счете успешно, но я выставлял минимальный лот и прибыль была не большая.
Выкладываю код не файлом, что бы каждый мог посмотреть код не скачивая «кота в мешке».

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {     
    if(AllProfit()>Profit && Profit>0 && CountTrades()>0)
     {
      CloseAll();
     }
//-------------------------------------------------------------
   if(t!=Time[0])
     {
     if(CountTrades()<1)
       {
        if(Sig()==0)
          {
           PutOrder(0,Ask);
          } 
         if(Sig()==1)
           {     
            PutOrder(1,Bid);
           }
         }
     if(CountTrades()>0)
       {
         if(FindOrderType()==0 && (FindLastBuyPrice()-Ask)/_Point>=SizeCanle/**_Point*/)
           {
            PutOrder(0,Ask);
           }        
         if(FindOrderType()==1 && (Bid-FindLastSellPrice())/_Point>=SizeCanle/**_Point*/)
           {   
            PutOrder(1,Bid);
           }
        }   
     t=Time[0];
     }
   Comment("\n Trades: ",CountTrades(),
           "\n Profit: ",AllProfit());
  }
//+------------------------------------------------------------------+

Понятно, спасибо за ответ.Буду думать дальше.

Спасибо! Не проверил.

Набросал на скорую руку для проверки в первый попавшийся советник.Все работает. Вставьте в свой советник

#property copyright "Copyright 2013, MetaQuotes Software Corp."
#property link      "http://www.mункцql5.com"
#property version   "1.00"
#property strict

extern int depo = 10000;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---
   
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---
   
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//---
   if(AccountEquity()<=depo){Comment("Торговля  запрещена.Ограничение по депозиту.");return;}
  }
//+------------------------------------------------------------------+

Машина через программу оперирует битами и цифрами.
«Если визуально видно что точки на одном уровне ....» она не поймет.

У вас в заголовке нет ни слова о размере лота.Тогда так

//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 16.06.2008                                                     |
//|  Описание : Возвращает размер лота последней закрытой позиции или -1       |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   (""   - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    op - операция                   (-1   - любая позиция)                  |
//|    mn - MagicNumber                (-1   - любой магик)                    |
//+----------------------------------------------------------------------------+
double GetLotLastClosePos(string sy="", int op=-1, int mn=-1) {
  datetime o;
  double   l=-1;
  int      i, k=OrdersHistoryTotal();

  if (sy=="0") sy=Symbol();
  for (i=0; i<k; i++) {
    if (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY)) {
      if (OrderSymbol()==sy || sy=="") {
        if (OrderType()==OP_BUY || OrderType()==OP_SELL) {
          if (op<0 || OrderType()==op) {
            if (mn<0 || OrderMagicNumber()==mn) {
              if (o<OrderCloseTime()) {
                o=OrderCloseTime();
                l=OrderLots();
              }
            }
          }
        }
      }
    }
  }
  return(l);
}

//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 19.02.2008                                                     |
//|  Описание : Возвращает размер лота последней открытой позиции или -1       |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   (""   - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    op - операция                   (-1   - любая позиция)                  |
//|    mn - MagicNumber                (-1   - любой магик)                    |
//+----------------------------------------------------------------------------+
double GetLotLastPos(string sy="", int op=-1, int mn=-1) {
  datetime o;
  double   l=-1;
  int      i, k=OrdersTotal();

  if (sy=="0") sy=Symbol();
  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) {
              if (o<OrderOpenTime()) {
                o=OrderOpenTime();
                l=OrderLots();
              }
            }
          }
        }
      }
    }
  }
  return(l);
}

Маловероятно что обе точки будут иметь одинаковое значение.Всё таки наверное нужно задавать некоторое допустимое отклонение MathAbs(а-б)<=c.

//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 19.02.2008                                                     |
//|  Описание : Возвращает тикет последней открытой позиции или -1             |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   (""   - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    op - операция                   (-1   - любая позиция)                  |
//|    mn - MagicNumber                (-1   - любой магик)                    |
//+----------------------------------------------------------------------------+
int GetTicketLastPos(string sy="", int op=-1, int mn=-1) {
  datetime o;
  int      i, k=OrdersTotal(), r=-1;

  if (sy=="0") sy=Symbol();
  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) {
              if (o<OrderOpenTime()) {
                o=OrderOpenTime();
                r=OrderTicket();
              }
            }
          }
        }
      }
    }
  }
  return®;
}

//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 19.02.2008                                                     |
//|  Описание : Возвращает тип последней закрытой позиции или -1               |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   (""   - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    mn - MagicNumber                (-1   - любой магик)                    |
//+----------------------------------------------------------------------------+
int GetTypeLastClosePos(string sy="", int mn=-1) {
  datetime t;
  int      i, k=OrdersHistoryTotal(), r=-1;

  if (sy=="0") sy=Symbol();
  for (i=0; i<k; i++) {
    if (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY)) {
      if ((OrderSymbol()==sy || sy=="") && (mn<0 || OrderMagicNumber()==mn)) {
        if (OrderType()==OP_BUY || OrderType()==OP_SELL) {
          if (t<OrderCloseTime()) {
            t=OrderCloseTime();
            r=OrderType();
          }
        }
      }
    }
  }
  return®;
}

//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 19.02.2008                                                     |
//|  Описание : Возвращает тип последней открытой позиции или -1               |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   (""   - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    mn - MagicNumber                (-1   - любой магик)                    |
//+----------------------------------------------------------------------------+
int GetTypeLastOpenPos(string sy="", int mn=-1) {
  datetime t;
  int      i, k=OrdersTotal(), r=-1;

  if (sy=="0") sy=Symbol();
  for (i=0; i<k; i++) {
    if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) {
      if ((OrderSymbol()==sy || sy=="") && (mn<0 || OrderMagicNumber()==mn)) {
        if (OrderType()==OP_BUY || OrderType()==OP_SELL) {
          if (t<OrderOpenTime()) {
            t=OrderOpenTime();
            r=OrderType();
          }
        }
      }
    }
  }
  return®;
}

Спасибо Андрей!

Ничего не понял без скринов и логов. Из того что я понял — такого не может быть.
Можно попробовать принудительно прописывать во всех функциях вызов конкретной пары.

А магики разные?

Странная ситуация.Первый раз вижу такое.По коду

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   if(CountTrades()>1)
      ModifyOrders();

   if(CountTrades()<1)
      DelOrder();

   if(CountTrades()==1)
     {
      if(CountOrders(2)<1 && LastOrderType()==0)
         for(int i=1; i<=Count; i++)
           {
            PutOrder(2,Bid-Delta*_Point*i);
           }
      if(CountOrders(3)<1 && LastOrderType()==1)
         for(int i=1; i<=Count; i++)
           {
            PutOrder(3,Bid+Delta*_Point*i);
           }
     }

   if(ObjectGetInteger(0,"B",OBJPROP_STATE)==1)
     {
      PutOrder(0,Ask);
      ObjectSetInteger(0,"B",OBJPROP_STATE,false);
     }

   if(ObjectGetInteger(0,"S",OBJPROP_STATE)==1)
     {
      PutOrder(1,Bid);
      ObjectSetInteger(0,"S",OBJPROP_STATE,false);
     }

   if(OrdersTotal()>0 && ObjectGetInteger(0,"C",OBJPROP_STATE)==1)
     {
      CloseAll();
      ObjectSetInteger(0,"C",OBJPROP_STATE,false);
     }

   Comment("Profit: ",(int)AllProfit());
  }
//+------------------------------------------------------------------+

При открытии позиции советник запрашивает цену того символа на котором установлен.
Как советник поставленный на фунт/ена с ценой 149.650 выставить ордер на евро/бакс с ценой 1.16100 и не сообщить о ошибке???
Можно посмотреть логи, журнал?