Паттерн поглощения в тренде - эксперт для MetaTrader 4

Введение

Постоянно: днями, неделями, месяцами все мы, трейдеры, наблюдаем за графиками, поведением цены на тот или иной сильный уровень, используем и находим множество стратегий, которые проверяем временем. В этой статье я хочу поделиться с вами идеей, в которой за основу были взяты линия тренда и свечная модель поглощения. В их комбинации можно наблюдать картину, которая даёт нам ясное понимание о том, куда будет двигаться рынок.

Построение тренда

Инструмент «линия тренда» очень важен для понимания движения цены на любом графике, ведь следуя за трендом, можно заработать куда больше, чем открыть позицию против него. Конечно же, каждый трейдер видит для себя свой тренд и строит линию по-своему воображению, и каждый будет по-своему прав.

• Строится линия тренда по двум локальным минимумам: второй должен быть выше первого - движение в лонг. Начертив такую линию, вы всегда можете заметить треугольник. Это ещё раз подтверждает о правильном нахождении тренда.

  

• Движение в шорт: линия тренда будет строиться по двум падающим локальным максимума, второй должен быть ниже первого.

  

Тренд можно определить на любом временном графике, но следует помнить, что на графиках с маленьким таймфреймом его сила менее устойчива к продолжению и, наоборот, на высоких таймфреймах - более устойчива.

Нахождение графического паттерна поглощения

Если вы когда-нибудь наблюдали за моделью поглощения на графиках, то наверняка замечали слом действующего и начало нового тренда (или его продолжение). Паттерн очень силён в сочетании с уровнями поддержки и сопротивления, а так же с фундаментальным анализом.

• Паттерн поглощения состоит из двух японских свечей, одна из которых поглощает тело другой полностью или частично, если произошёл разрыв цены (не берём во внимание тело свечей, так как данная модель изменена мной);
• Существует две модели поглощения: поглощение быков (лонг) и поглощение медведей (шорт).

1. Поглощение быков - тело медвежьего бара поглощается полностью или частично бычьим баром;
2. Поглощение медведей - тело бычьего бара поглощается полностью или частично медвежьим баром.

Комбинация тренд и паттерн

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

• Начнём с паттерна поглощения быков, который нужно будет найти 2 раза для построения линии тренда и нахождения точки входа;
• Линию тренда будем проводить только при растущих минимумах паттерна поглощения (лонг) по ценам открытия бычьего бара;
• Точка входа по сформировавшемуся второму поглощению, если второе поглощение - это повышающийся минимум (лонг).

• Аналогичная ситуация в шорт паттерна поглощения медведей, который нужно будет найти 2 раза для построения линии тренда и нахождения точки входа;
• Линию тренда будем проводить только при падающих максимумах паттерна поглощения(шорт) по ценам открытия медвежьего бара;
• Точка входа по сформировавшемуся второму поглощению, если второе поглощение - это понижающиеся максимумы (шорт).

Создание трендового эксперта

Зная правила нахождения линии тренда и правила паттерна поглощения, можно создать простого эксперта, в которого добавим следующее:

1. Анализатор графика total (количество свечей для анализа нахождения паттерна поглощения);
2. MaxRisk, который рассчитывает, сколько потеряет при срабатывании Stop loss (то есть, если риск 5%, депозит 1000 и Stop loss 20пп, он высчитывает 5% из 1000 = 50 и подбирает такой лот, чтобы при закрытии по Stop loss потери были равны 50). Если расчетный лот будет меньше минимального лота брокера, то откроет с минимальным лотом;
3. Закрытие позиции по противоположному сигналу, даже если Stop loss выставлен 0.

//+------------------------------------------------------------------+
//|                                                   absorption.mq4 |
//|                        Copyright 2016, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Avtor Sergey Ponomarev"
#property link      ""
#property version   "1.00"
#property strict

input int     Magic      = 1111;
input double  Lots1      = 0.01;    // Лот основного
input bool    add1       = true;    // Добавление ордеров вкл\выкл
input int     Total_Add  = 3;       // Количество добавочных ордеров, 0-без ограничений 
extern int    step       = 10;      // Шаг добавочных ордеров
input bool    add2       = true;    // Добавление противоположные вкл\выкл
input double  Lots2      = 0.01;    // Лот добавочного противоположного
input int     Slippage   = 3;
string symbol="0"; 

int Mas_Tip[6],Tick;
bool result;
int Tip=-1;
double TP,OP;
int   B5=0,B6=0,S5=0,S6=0;
int total_or=0;
bool gbDisabled=false;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---
   if(step<MarketInfo(Symbol(),MODE_STOPLEVEL))
      step=(int)MarketInfo(Symbol(),MODE_STOPLEVEL);
   result=CheckVolumeValue(Lots1);
   if(result==false)
     {
      gbDisabled=true;
      Print("the EA does not work !!");
      Alert("the EA does not work !!");
     }
   result=CheckVolumeValue(Lots2);
   if(result==false)
     {
      gbDisabled=true;
      Print("the EA does not work !!");
      Alert("the EA does not work !!");
     }
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---

  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   if(Symbol()!=symbol && symbol!="0")
      return;
   if(Bars<4 || gbDisabled)
      return;
//---
   for(int i=OrdersTotal()-1;i>=0;i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES) && OrderSymbol()==Symbol() && OrderType()>1 && OrderMagicNumber()==Magic)
        {
         if(OrderType()==4 || OrderType()==2)
           {
            if(AccountFreeMarginCheck(Symbol(),OP_BUY,OrderLots())<0)
              {
               Print("Not enough money for BuyStop  ",OrderLots()," ",Symbol()," Error code=",GetLastError());
               for(int e=OrdersTotal()-1;e>=0;e--)
                 {
                  if(OrderSelect(e,SELECT_BY_POS,MODE_TRADES) && OrderSymbol()==Symbol() && OrderType()>1 && OrderMagicNumber()==Magic)
                     DeleteOrders();
                  gbDisabled=true;
                  Print("the EA does not work !!");
                  Alert("the EA does not work !!");
                  return;
                 }
              }
           }
         if(OrderType()==5 || OrderType()==3)
           {
            if(AccountFreeMarginCheck(Symbol(),OP_SELL,OrderLots())<0)
              {
               Print("Not enough money for SellStop  ",OrderLots()," ",Symbol()," Error code=",GetLastError());
               for(int e=OrdersTotal()-1;e>=0;e--)
                 {
                  if(OrderSelect(e,SELECT_BY_POS,MODE_TRADES) && OrderSymbol()==Symbol() && OrderType()>1 && OrderMagicNumber()==Magic)
                     DeleteOrders();
                  gbDisabled=true;
                  Print("the EA does not work !!");
                  Alert("the EA does not work !!");
                  return;
                 }
              }
           }
        }
     }
   Terminal();
//+------------------------------------------------------------------+
   if(total_or==0)
     {
      int candles=0;
      int tip=-1;
      for(int i=2;i<50;i++)
        {
         if(High[i]>High[i+1] && Low[i]<Low[i+1])
           {
            candles=i;
            break;
           }
        }
      if(candles>2)
        {
         for(int i=2;i<candles;i++)
           {
            if(High[candles]<Close[i])
              {
               candles=0;
               break;
              }
            if(Low[candles]>Close[i])
              {
               candles=0;
               break;
              }
           }
        }
      if(candles!=0)
        {
         if(High[candles]<Close[1])
            tip=1;
         if(Low[candles]>Close[1])
            tip=0;
        }
      if(tip==0)
        {
         double Tp=NormalizeDouble(High[candles],Digits);
         if(NormalizeDouble(Tp-Bid,Digits)<SymbolInfoInteger(_Symbol,SYMBOL_TRADE_STOPS_LEVEL)*Point)
            Tp=NormalizeDouble(Bid+SymbolInfoInteger(_Symbol,SYMBOL_TRADE_STOPS_LEVEL)*Point,Digits);
         Tick=OpenPosition(NULL,OP_BUY,Lots1,0,Tp,"1",Magic);
         B5=0;
         B6=0;
        }
      if(tip==1)
        {
         double Tp=NormalizeDouble(Low[candles]+SymbolInfoInteger(_Symbol,SYMBOL_SPREAD)*Point,Digits);
         if(NormalizeDouble(Ask-Tp,Digits)<SymbolInfoInteger(_Symbol,SYMBOL_TRADE_STOPS_LEVEL)*Point)
            Tp=NormalizeDouble(Ask-SymbolInfoInteger(_Symbol,SYMBOL_TRADE_STOPS_LEVEL)*Point,Digits);
         Tick=OpenPosition(NULL,OP_SELL,Lots1,0,Tp,"1",Magic);
         S5=0;
         S6=0;
        }
     }
//+------------------------------------------------------------------+
   for(int i=0; i<OrdersTotal(); i++)
     {
      if(OrderSelect(i,SELECT_BY_POS)==true && OrderSymbol()==Symbol() && OrderMagicNumber()==Magic && OrderComment()=="1")
        {
         if(OrderType()==0)
           {
            Tip=0;
            TP = NormalizeDouble(OrderTakeProfit(),Digits);
            OP = NormalizeDouble(OrderOpenPrice(),Digits);
           }
         if(OrderType()==1)
           {
            Tip=1;
            TP = NormalizeDouble(OrderTakeProfit(),Digits);
            OP = NormalizeDouble(OrderOpenPrice(),Digits);
           }
        }
     }
   Terminal();
//+------------------------------------------------------------------+
   if(Mas_Tip[0]>0 && Tip==0 && add1 && Mas_Tip[2]==0 && ((Mas_Tip[0]<Total_Add+1 && Total_Add>0) || Total_Add<1))
     {
     Alert(findminprise(OP_BUY));
      double op_pr=NormalizeDouble(findminprise(OP_BUY)-step*Point,Digits);
     Alert(op_pr);
      SetOrder(OP_BUYLIMIT,Lots1,op_pr,0,TP,0);
     }

   Terminal();
   if(Mas_Tip[0]>0 && Tip==0 && add2 && Mas_Tip[5]==0)
     {
      double op_pr=OP;
      while(op_pr>NormalizeDouble(Ask-SymbolInfoInteger(_Symbol,SYMBOL_TRADE_STOPS_LEVEL)*Point,Digits))
         op_pr=NormalizeDouble(op_pr-step*Point,Digits);
      SetOrder(OP_SELLSTOP,Lots2,NormalizeDouble(op_pr-SymbolInfoInteger(_Symbol,SYMBOL_SPREAD)*Point,Digits),NormalizeDouble(TP-SymbolInfoInteger(_Symbol,SYMBOL_SPREAD)*Point,Digits),
               NormalizeDouble(op_pr-step*Point,Digits),0);
     }

   Terminal();
   if(Mas_Tip[1]>0 && Tip==1 && add1 && Mas_Tip[3]==0 && ((Mas_Tip[1]<Total_Add+1 && Total_Add>0) || Total_Add<1))
     {
      double op_pr=NormalizeDouble(findmaxprise(OP_SELL)+step*Point,Digits);
      SetOrder(OP_SELLLIMIT,Lots1,op_pr,0,TP,0);
     }

   Terminal();
   if(Mas_Tip[1]>0 && Tip==1 && add2 && Mas_Tip[4]==0)
     {
      double op_pr=OP;
      while(op_pr<NormalizeDouble(Bid+SymbolInfoInteger(_Symbol,SYMBOL_TRADE_STOPS_LEVEL)*Point,Digits))
         op_pr=NormalizeDouble(op_pr+step*Point,Digits);
      SetOrder(OP_BUYSTOP,Lots2,NormalizeDouble(op_pr+SymbolInfoInteger(_Symbol,SYMBOL_SPREAD)*Point,Digits),NormalizeDouble(TP+SymbolInfoInteger(_Symbol,SYMBOL_SPREAD)*Point,Digits),
               NormalizeDouble(op_pr+step*Point,Digits),0);
     }

//+------------------------------------------------------------------+
   if(Mas_Tip[0]+Mas_Tip[1]==0 && (Mas_Tip[2]>0 || Mas_Tip[3]>0 || Mas_Tip[4]>0 || Mas_Tip[5]>0))
     {
      for(int i=OrdersTotal()-1;i>=0;i--)
        {
         if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==true && OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
            if(OrderType()>1)
              {
               DeleteOrders();
              }
           }
        }
     }
   Terminal();
//+------------------------------------------------------------------+
   if(Mas_Tip[0]==6 && Tip==0 && B5==0)
     {
      for(int i=OrdersTotal()-1;i>=0;i--)
        {
         if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==true && OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
            if(OrderType()==0 || OrderType()==2 || OrderType()==4)
              {
               double Tp=NormalizeDouble(OrderTakeProfit()-step*Point,Digits);
               ModifyOrder(OrderStopLoss(),Tp);
              }
            if(OrderType()==1 || OrderType()==3 || OrderType()==5)
              {
               double Sl=NormalizeDouble(OrderStopLoss()-step*Point,Digits);
               ModifyOrder(Sl,OrderTakeProfit());
              }
           }
        }
      B5=1;
     }
   if(Mas_Tip[0]==7 && Tip==0 && B6==0)
     {
      for(int i=OrdersTotal()-1;i>=0;i--)
        {
         if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==true && OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
            if(OrderType()==0 || OrderType()==2 || OrderType()==4)
              {
               double Tp=NormalizeDouble(OrderTakeProfit()-step*Point,Digits);
               ModifyOrder(OrderStopLoss(),Tp);
              }
            if(OrderType()==1 || OrderType()==3 || OrderType()==5)
              {
               double Sl=NormalizeDouble(OrderStopLoss()-step*Point,Digits);
               ModifyOrder(Sl,OrderTakeProfit());
              }
           }
        }
      B6=1;
     }
//+------------------------------------------------------------------+
   if(Mas_Tip[1]==6 && Tip==1 && S5==0)
     {
      for(int i=OrdersTotal()-1;i>=0;i--)
        {
         if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==true && OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
            if(OrderType()==1 || OrderType()==3 || OrderType()==5)
              {
               double Tp=NormalizeDouble(OrderTakeProfit()+step*Point,Digits);
               ModifyOrder(OrderStopLoss(),Tp);
              }
            if(OrderType()==0 || OrderType()==2 || OrderType()==4)
              {
               double Sl=NormalizeDouble(OrderStopLoss()+step*Point,Digits);
               ModifyOrder(Sl,OrderTakeProfit());
              }
           }
        }
      S5=1;
     }
   if(Mas_Tip[1]==7 && Tip==1 && S6==0)
     {
      for(int i=OrdersTotal()-1;i>=0;i--)
        {
         if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==true && OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
            if(OrderType()==1 || OrderType()==3 || OrderType()==5)
              {
               double Tp=NormalizeDouble(OrderTakeProfit()+step*Point,Digits);
               ModifyOrder(OrderStopLoss(),Tp);
              }
            if(OrderType()==0 || OrderType()==2 || OrderType()==4)
              {
               double Sl=NormalizeDouble(OrderStopLoss()+step*Point,Digits);
               ModifyOrder(Sl,OrderTakeProfit());
              }
           }
        }
      S6=1;
     }
  }
//+------------------------------------------------------------------+
void Terminal()
  {
   ArrayInitialize(Mas_Tip,0);
   total_or=0;
   for(int i=0; i<OrdersTotal(); i++)
     {
      if(OrderSelect(i,SELECT_BY_POS)==true && OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
        {
         Mas_Tip[OrderType()]++;
         total_or++;
        }
     }
  }
//+------------------------------------------------------------------+
int OpenPosition(string sy,int op,double ll,double sl,double tp,string komeent="",int mn=0)
  {
   datetime ot;
   double   pp,pa,pb;
   int      dg,it,Ticket=0;
   if(AccountFreeMarginCheck(Symbol(),OP_BUY,ll)<0 && op==0)
     {
      Print("Not enough money for Buy  ",ll," ",Symbol()," Error code=",GetLastError());
      return(-1);
     }
   if(AccountFreeMarginCheck(Symbol(),OP_SELL,ll)<0 && op==1)
     {
      Print("Not enough money for Sell  ",ll," ",Symbol()," Error code=",GetLastError());
      return(-1);
     }
   for(it=1; it<=10; it++)
     {
      if(!IsTesting() && (!IsExpertEnabled() || IsStopped()))
        {
         Print("Stop function!");
         break;
        }
      while(!IsTradeAllowed())
         Sleep(5000);
      RefreshRates();
      dg=(int)MarketInfo(sy, MODE_DIGITS);
      pa=MarketInfo(sy, MODE_ASK);
      pb=MarketInfo(sy, MODE_BID);
      if(op==OP_BUY) pp=pa; else pp=pb;
      pp=NormalizeDouble(pp, dg);
      ot=TimeCurrent();
      Ticket=OrderSend(sy,op,ll,pp,Slippage,sl,tp,komeent,mn,0,CLR_NONE);
      if(Ticket>0)
        {
         break;
        }
      else
        {
         if(!Error(GetLastError(),it,"",5000))
            break;
        }
     }
   return(Ticket);
  }
//+------------------------------------------------------------------+
bool CheckVolumeValue(double volume)
  {
   double min_volume=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_MIN);
   if(volume<min_volume)
     {
      Print("The volume is less than the minimum :",min_volume);
      return(false);
     }
   double max_volume=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_MAX);
   if(volume>max_volume)
     {
      Print("The volume is greater than the maximum :",max_volume);
      return(false);
     }
   double volume_step=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_STEP);
   int ratio=0;
   if(volume_step>0)
      ratio=(int)MathRound(volume/volume_step);
   if(MathAbs(ratio*volume_step-volume)>0.0000001)
     {
      Print("The volume is not a multiple of the minimum gradation closest to the correct amount :",volume_step," ",ratio*volume_step);
      return(false);
     }
   return(true);
  }
//+------------------------------------------------------------------+
bool Error(int err,int j,string informer="",int pause=5000)
  {
   bool is_open=true;
   switch(err)
     {
      case ERR_NO_ERROR:
      case ERR_NO_RESULT:
      case ERR_COMMON_ERROR:{is_open=false; break;}
      case ERR_BROKER_BUSY: {Print("BROKER_BUSY, try №"+DoubleToStr(j,0)); Sleep(pause);} break;
      case ERR_SERVER_BUSY: {Print("SERVER_BUSY, try №"+DoubleToStr(j,0)); Sleep(pause);} break;
      case ERR_NO_CONNECTION: {Print("NO_CONNECTION, try №"+DoubleToStr(j,0)); Sleep(pause);} break;
      case ERR_TRADE_TIMEOUT: {Print("TRADE_TIMEOUT, try №"+DoubleToStr(j,0)); Sleep(pause);} break;
      case ERR_PRICE_CHANGED: {Print("PRICE_CHANGED, try №"+DoubleToStr(j,0)+" "+informer); Sleep(pause);} break;
      case ERR_REQUOTE: {Print("REQUOTE, try №"+DoubleToStr(j,0)+" "+informer); Sleep(pause);} break;
      case ERR_TOO_FREQUENT_REQUESTS: {Print("TOO_FREQUENT_REQUESTS, try №"+DoubleToStr(j,0)+" "+informer); Sleep(pause);} break;
      case ERR_ORDER_LOCKED: {is_open=false; Print("ORDER_LOCKED");} break;
      case ERR_INVALID_STOPS: {is_open=false; Print("INVALID_STOPS");} break;
      case ERR_INVALID_PRICE: {Print("INVALID_PRICE, try №"+DoubleToStr(j,0)+" "+informer);} break;
      case ERR_OFF_QUOTES: {Print("OFF_QUOTES, try №"+DoubleToStr(j,0)); Sleep(pause);} break;
      case ERR_INVALID_TRADE_VOLUME: {is_open=false; Print("INVALID_TRADE_VOLUME, "+informer);} break;
      case ERR_MARKET_CLOSED: {is_open=false; Print("MARKET_CLOSED");} break;
      case ERR_TRADE_DISABLED: {is_open=false; Print("TRADE_DISABLED");} break;
      case ERR_NOT_ENOUGH_MONEY: {is_open=false; Print("NOT_ENOUGH_MONEY, "+informer);} break;
      case ERR_LONG_POSITIONS_ONLY_ALLOWED: {is_open=false; Print("LONG_POSITIONS_ONLY_ALLOWED");} break;
      case ERR_TRADE_MODIFY_DENIED: {Print("TRADE_MODIFY_DENIED, try №"+DoubleToStr(j,0)+" "+informer); Sleep(pause);} break;
      case ERR_TRADE_EXPIRATION_DENIED: {is_open=false; Print("TRADE_EXPIRATION_DENIED");} break;
      case ERR_TRADE_TOO_MANY_ORDERS: {is_open=false; Print("TRADE_TOO_MANY_ORDERS.");} break;
      case ERR_TRADE_HEDGE_PROHIBITED: {is_open=false; Print("TRADE_HEDGE_PROHIBITED.");} break;
      case ERR_TRADE_PROHIBITED_BY_FIFO: {is_open=false; Print("TRADE_PROHIBITED_BY_FIFO.");} break;
      case ERR_ARRAY_INDEX_OUT_OF_RANGE: {is_open=false; break;}
      case ERR_LONGS_NOT_ALLOWED: {is_open=false; break;}
      case ERR_SHORTS_NOT_ALLOWED: {is_open=false; break;}
      case ERR_INVALID_TICKET: {is_open=false; break; }
      default: {is_open=false; Print("Unknown error: "+(string)err+" "+informer);} break;
     }

   return (is_open);
  }
//+--------------------------------------------------------+
double findminprise(int otype)
  {
   double prise=9999999;
   for(int i=OrdersTotal()-1; i>=0; i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==OrderSymbol() && OrderMagicNumber()==Magic && OrderType()==otype && prise>OrderOpenPrice())
            prise=OrderOpenPrice();
        }
     }
   return(prise);
  }
//+--------------------------------------------------------+
double findmaxprise(int otype)
  {
   double prise=0;
   for(int i=OrdersTotal()-1; i>=0; i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==OrderSymbol() && OrderMagicNumber()==Magic && OrderType()==otype && OrderOpenPrice()>prise)
            prise=OrderOpenPrice();
        }
     }
   return(prise);
  }
//+------------------------------------------------------------------+
int SetOrder(int op,double ll,double pp,double Sl=0,double Tp=0,datetime Exp=0)
  {
   int   ticket;
   if(result==false)
      return(-1);
   if(AccountFreeMarginCheck(Symbol(),OP_BUY,ll)<0 && op==0)
     {
      Print("Not enough money for Buy  ",ll," ",Symbol()," Error code=",GetLastError());
      return(-1);
     }
   if(AccountFreeMarginCheck(Symbol(),OP_SELL,ll)<0 && op==1)
     {
      Print("Not enough money for Sell  ",ll," ",Symbol()," Error code=",GetLastError());
      return(-1);
     }

   if(!IsTesting() && (!IsExpertEnabled() || IsStopped()))
      return(-1);
   ticket=OrderSend(Symbol(),op,ll,pp,0,Sl,Tp,"",Magic,Exp,CLR_NONE);
   if(ticket<0)
     {
      Print("Error(",GetLastError(),") open order ",Symbol()," ");
     }
   return(ticket);
  }
//+------------------------------------------------------------------+
void DeleteOrders()
  {
   bool fd;
   if(!IsTesting() && (!IsExpertEnabled() || IsStopped()))
      return;
   fd=OrderDelete(OrderTicket());
   if(!fd)
     {
      Print("Error(",GetLastError(),") delete order ",Symbol()," ");
     }
  }
//+------------------------------------------------------------------+
void ModifyOrder(double SLL=0,double TPP=0)
  {
   bool   fm;
   double os,ot;
   int    dg=(int)MarketInfo(OrderSymbol(),MODE_DIGITS);
   if(SLL<0 ) SLL=OrderStopLoss();
   if(TPP<0 ) TPP=OrderTakeProfit();
   SLL=NormalizeDouble(SLL, dg);
   TPP=NormalizeDouble(TPP, dg);
   os=NormalizeDouble(OrderStopLoss()  , dg);
   ot=NormalizeDouble(OrderTakeProfit(), dg);
   if(SLL!=os || TPP!=ot)
     {
      if(!IsTesting() && (!IsExpertEnabled() || IsStopped())) return;
      while(!IsTradeAllowed()) Sleep(5000);
      RefreshRates();
      fm=OrderModify(OrderTicket(),OrderOpenPrice(),SLL,TPP,0,CLR_NONE);
      if(!fm)
        {
         Print("Failed to modify ticket ",OrderTicket()," ",Symbol()," Error code=",GetLastError());
        }
     }

  }
//+------------------------------------------------------------------+

Тестирование советника

1. Нажимаем сочитаний клавиш Ctrl + R вызвав тестер стратегий;
2. Выбираем наш свежеиспечёный советник;
3. Выбираем на какой валютной паре будет работать советник;
4. Ставим модель тестирования все тики;
5. Выбираем дату начала и конца тестирования;
6. Отключаем визуализацию для быстроты тестирования и выбираем таймфрейм;
7. Нижимаем свойства эксперта и настраиваем входные параметры;
8. Нажимаем старт.

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

Результат тестирования

Заключение

1. Данная идея хороша при торговле и анализе графика самим трейдером;
2. Робот показал неплохие результаты, но требует доработки.