Советник 9-9-9

Стол заказов MQL

Здравствуйте *hi*

Не знаю кто сейчас программирует, обращаюсь за помощью к программистам.

Нужен многофункциональный советник.

Условие для открытия ордера.

Одна или несколько свечей совпадают по размеру в пунктах.

Первая настройка — размер свечи в пунктах.

Вторая настройка — количество свечей одинакового размера идущие подряд.

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

Четвертая настройка — выбор цвета свечей, быки или медведи идут подряд, или чередование.

С этим все.

Какие должны открываться ордера при совпадении условий выше.

Нужно выбор всех возможных ордеров, начиная с рыночных и заканчивая лимитных.

Все.

советники

+3
Просмотров: 3180
30 августа 2016, 18:18
beton2011

Понравилcя материал? Не забудьте поставить плюс и поделиться в социальной сети!

Вступите в группу "Стол заказов MQL", чтобы следить за обновлениями
ПРИСОЕДИНИТЬСЯ К ГРУППЕ

Предыдущая запись в группе дополнительные индикаторы к теме 5Min_Binary_Strategy	Следующая запись в группе Просьба написать советник
29 августа 2016	30 августа 2016

Завтра уже буду этой штукой заниматься.

34 AM2 Сообщений: 15879 - Андрей

30 августа 2016, 18:21
↓

Ок

14 beton2011 Автор Сообщений: 895

30 августа 2016, 19:01
↑
↓

Cложный не берусь. Все функции уникальные, нужно писать и отлаживать с нуля, а у меня потолок по оплачиваеммым заказам. Делаю только то что можно быстро сделать.

34 AM2 Сообщений: 15879 - Андрей

31 августа 2016, 09:23
↓

Можно наверно упростить задачу.

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

выбор цвета свечей, быки или медведи идут подряд, или чередование, это не надо.

Какие должны открываться ордера при совпадении условий выше.

Можно только бай или сэлл.

Все

14 beton2011 Автор Сообщений: 895

31 августа 2016, 19:42
↑
↓

Вы можете программировать, потратьте определенное количество времени и усилий и сделайте все самостоятельно. Может мой набросок вам поможет:


//+------------------------------------------------------------------+
//|                                                      Candler.mq4 |
//|                        Copyright 2015, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2015, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property strict

input int Points = 100;
input int Delta  = 30;
input int Count  = 5;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---

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

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int Candles(int type)
  {
   int count=0;
   for(int i=1;i<=Count;i++)
     {
      if(Close[i]>Open[i] && type==1 && MathAbs(Close[i]-Open[i])>=Points*Point && MathAbs(Close[i]-Open[i])<=(Points+Delta)*Point)//bulls
        {
         count++;
        }

      if(Close[i]<Open[i] && type==2 && MathAbs(Close[i]-Open[i])>=Points*Point && MathAbs(Close[i]-Open[i])<=(Points+Delta)*Point)//bear
        {
         count++;
        }
     }
   return(count);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   Comment("\n Bulls Candles: ",Candles(1),
           "\n Bears Candles: ",Candles(2));
  }
//+------------------------------------------------------------------+

34 AM2 Сообщений: 15879 - Андрей

1 сентября 2016, 09:21
↓

Я уже давно за компом не сидел, для меня сейчас терминал в новинку, заново изучаю все кнопочки

О коком программирование может быть речь.

Если все таки у вас получится сделать советника по моей просьбе, буду благодарен.

14 beton2011 Автор Сообщений: 895

1 сентября 2016, 16:19
↑
↓

Пытался написать вам в приват спросить детали, промежуточная версия(возможны ошибки).


//+------------------------------------------------------------------+
//|                                                      Candler.mq4 |
//|                        Copyright 2015, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2015, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property strict

input int slippage  = 20;
input int sl  = 100;
input int tp  = 100;
input double lot = 0.1;
input int Points = 30;
input int Delta  = 15;
input int Count  = 3;
input int HighCandle  = 1; // 1 - Close/Open, 2 High/Low длина свечи

extern int Magic = 999;
enum _TypeOrders{ 
   market,
   limit,
   stop
};
extern _TypeOrders TypeOrder = market;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---

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

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int Candles(int type)
  {
   int count=0;
   for(int i=1;i<=Count;i++)
     {     
        double dl = 0;
        
        if(HighCandle == 2) dl = High[i]-Low[i];
        else dl = MathAbs(Close[i]-Open[i]);
        
      if(Close[i]>Open[i] && type==1 && dl>=Points*Point && dl<=(Points+Delta)*Point)//bulls
        {
         count++;
        }

      if(Close[i]<Open[i] && type==2 && dl>=Points*Point && dl<=(Points+Delta)*Point)//bear
        {
         count++;
        }
     }
   return(count);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
      if(Candles(1) == Count && CountOrders(0) < 1 && CountOrders(2) < 1 && CountOrders(4) < 1)
      {        
         PutOrder(OrderPlace(1), Ask);
      }
      if(Candles(2) == Count && CountOrders(1) < 1 && CountOrders(3) < 1 && CountOrders(5) < 1)
      {
         PutOrder(OrderPlace(2), Bid);
      }
  
   Comment("\n Bulls Candles: ",Candles(1),
           "\n Bears Candles: ",Candles(2));
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CountOrders(int type)
  {
   int count=0;
   for(int i=OrdersTotal()-1;i>=0;i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
            if(OrderType()==type) count++;
           }
        }
     }
   return(count);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int OrderPlace(int bs) 
  {  
   string OrdType = EnumToString(TypeOrder);
   if (OrdType == "market") 
   {
      if(bs == 1) return 0;
      if(bs == 2) return 1;
   } 
   if (OrdType == "limit") 
   {
      if(bs == 1) return 2;
      if(bs == 2) return 3;
   } 
   if (OrdType == "stop") 
   {
      if(bs == 1) return 4;
      if(bs == 2) return 5;
   }
   return -1;  
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void PutOrder(int type, double price)
  {
   int r=0;
   color clr=Green;
   double s=0,t=0;

   if(type==-1) return;

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

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

   r=OrderSend(NULL,type,lot,NormalizeDouble(price,Digits),slippage,s,t,"",Magic,0,clr);
   return;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+

17 vis Сообщений: 199 - ♫♪♫♪

1 сентября 2016, 16:41
↑
↓

Выглядит все красиво, будто вы читаете мысли. Сейчас пока тестирую.

14 beton2011 Автор Сообщений: 895

1 сентября 2016, 17:45
↑
↓

Все впорядке. Только объясните как работает параметр Delta.

14 beton2011 Автор Сообщений: 895

2 сентября 2016, 15:34
↑
↓

Все в порядке. Только объясните как работает параметр Delta.

Points и Points + Delta в этот промежуток должен попасть размер свечи, когда вычисляем размер.

34 AM2 Сообщений: 15879 - Андрей

2 сентября 2016, 16:01
↑
↓

Я так и думал. Спасибо

14 beton2011 Автор Сообщений: 895

2 сентября 2016, 17:05
↑
↓

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

14 beton2011 Автор Сообщений: 895

2 сентября 2016, 20:00
↑
↓

Набросок
Похоже все равно нужен параметр средняя длина свечи, а то открывает ночью на флэте слишком много


//+------------------------------------------------------------------+
//|                                                      Candler.mq4 |
//|                        Copyright 2015, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2015, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property strict

input int slippage  = 20;
input int sl  = 200;
input int tp  = 300;
input double lot = 0.1;
input double Delta  = 25;
input int Count  = 3;
datetime New_Time=0;

extern int Magic = 999;
enum _TypeOrders{ 
   market,
   limit,
   stop
};
extern _TypeOrders TypeOrder = market;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---

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

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int Candles(int type)
  {
   int count = 0;
   double CandleHigh = 0, CandleLow = 0;
   
   for(int i=1;i<=Count;i++)
     {
     
      if(i == 1)
		  {
		      CandleHigh = High[1];
		      CandleLow = Low[1];
		  }     
     
		if(MathAbs(CandleHigh-High[i])/Point<=Delta && MathAbs(CandleLow-Low[i])/Point<=Delta)
		{		  
		  if(Close[i]>Open[i] && type==1)//bulls
			{
			  count++;
			}

		  if(Close[i]<Open[i] && type==2)//bear
			{
			 count++;
			}
		}
		CandleHigh = High[i];
		CandleLow = Low[i];
     }
	
   return(count);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
      if(New_Time!=Time[0])
       {
         if(Candles(1) == Count && CountOrders(0) < 1 && CountOrders(2) < 1 && CountOrders(4) < 1)
         {
               PutOrder(OrderPlace(1), Ask);
               New_Time=Time[0];
         }
         if(Candles(2) == Count && CountOrders(1) < 1 && CountOrders(3) < 1 && CountOrders(5) < 1)
         {
               PutOrder(OrderPlace(2), Bid);
               New_Time=Time[0];        
         }
      }
  
   Comment("\n Bulls Candles: ",Candles(1),
           "\n Bears Candles: ",Candles(2));
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CountOrders(int type)
  {
   int count=0;
   for(int i=OrdersTotal()-1;i>=0;i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
            if(OrderType()==type) count++;
           }
        }
     }
   return(count);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int OrderPlace(int bs) 
  {  
   string OrdType = EnumToString(TypeOrder);
   if (OrdType == "market") 
   {
      if(bs == 1) return 0;
      if(bs == 2) return 1;
   } 
   if (OrdType == "limit") 
   {
      if(bs == 1) return 2;
      if(bs == 2) return 3;
   } 
   if (OrdType == "stop") 
   {
      if(bs == 1) return 4;
      if(bs == 2) return 5;
   }
   return -1;  
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void PutOrder(int type, double price)
  {
   int r=0;
   color clr=Green;
   double s=0,t=0;   

   if(type==-1) return;

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

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

   r=OrderSend(NULL,type,lot,NormalizeDouble(price,Digits),slippage,s,t,"",Magic,0,clr);
   return;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+

Редактирован: 3 сентября 2016, 00:49

17 vis Сообщений: 199 - ♫♪♫♪

2 сентября 2016, 22:48
↑
↓

Да надо параметр средние значение, потом дальше будем смотреть.

14 beton2011 Автор Сообщений: 895

3 сентября 2016, 07:21
↑
↓

//+------------------------------------------------------------------+
//|                                                      Candler.mq4 |
//|                        Copyright 2015, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2015, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property strict

input int slippage  = 20;
input int sl  = 200;
input int tp  = 500;
input double lot = 0.1;
input double AvgBar  = 80;
input double Delta  = 25;
input int Count  = 3;
datetime New_Time=0;

extern int Magic = 999;
enum _TypeOrders{ 
   market,
   limit,
   stop
};
extern _TypeOrders TypeOrder = market;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---

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

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int Candles(int type)
  {
   int count = 0;
   double CandleHigh = 0, CandleLow = 0;
   
   for(int i=1;i<=Count;i++)
     {
     
      if(i == 1)
		  {
		      CandleHigh = High[1];
		      CandleLow = Low[1];
		  }     
     
		if(MathAbs(CandleHigh-High[i])/Point<=Delta && MathAbs(CandleLow-Low[i])/Point<=Delta && MathAbs(High[i]-Low[i])/Point>=(AvgBar-Delta) && MathAbs(High[i]-Low[i])/Point<=(AvgBar+Delta))
		{		  
		  if(Close[i]>Open[i] && type==1)//bulls
			{
			  count++;
			}

		  if(Close[i]<Open[i] && type==2)//bear
			{
			 count++;
			}
		}
		CandleHigh = High[i];
		CandleLow = Low[i];
     }
	
   return(count);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
      if(New_Time!=Time[0])
       {
         if(Candles(1) == Count && CountOrders(0) < 1 && CountOrders(2) < 1 && CountOrders(4) < 1)
         {
               PutOrder(OrderPlace(1), Ask);
               New_Time=Time[0];
         }
         if(Candles(2) == Count && CountOrders(1) < 1 && CountOrders(3) < 1 && CountOrders(5) < 1)
         {
               PutOrder(OrderPlace(2), Bid);
               New_Time=Time[0];        
         }
      }
  
   Comment("\n Bulls Candles: ",Candles(1),
           "\n Bears Candles: ",Candles(2));

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CountOrders(int type)
  {
   int count=0;
   for(int i=OrdersTotal()-1;i>=0;i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
            if(OrderType()==type) count++;
           }
        }
     }
   return(count);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int OrderPlace(int bs) 
  {  
   string OrdType = EnumToString(TypeOrder);
   if (OrdType == "market") 
   {
      if(bs == 1) return 0;
      if(bs == 2) return 1;
   } 
   if (OrdType == "limit") 
   {
      if(bs == 1) return 2;
      if(bs == 2) return 3;
   } 
   if (OrdType == "stop") 
   {
      if(bs == 1) return 4;
      if(bs == 2) return 5;
   }
   return -1;  
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void PutOrder(int type, double price)
  {
   int r=0;
   color clr=Green;
   double s=0,t=0;   

   if(type==-1) return;

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

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

   r=OrderSend(NULL,type,lot,NormalizeDouble(price,Digits),slippage,s,t,"",Magic,0,clr);
   return;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+

17 vis Сообщений: 199 - ♫♪♫♪

3 сентября 2016, 13:58
↑
↓

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

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

Да и я заметил что советник, если надо больше двух свечей, он ищет одинаковые по цвету свечи. Надо чтоб искал и разные по цвету баров совпадения, ордер открывается по последнему цвету бара.
Редактирован: 3 сентября 2016, 18:29

14 beton2011 Автор Сообщений: 895

3 сентября 2016, 18:20
↑
↓

А вот если бы ТЗ сразу целиком и полностью *think*

17 vis Сообщений: 199 - ♫♪♫♪

3 сентября 2016, 20:32
↑
↓

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

14 beton2011 Автор Сообщений: 895

3 сентября 2016, 22:54
↑
↓

//+------------------------------------------------------------------+
//|                                                      Candler.mq4 |
//|                        Copyright 2015, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2015, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property strict

input int slippage  = 20;
input int sl  = 200;
input int tp  = 500;
input double lot = 0.1;
input double AvgBar  = 70;
input double Delta  = 35;
extern bool IsShadow  = false; // true - по high/low, false - по open/close
input int Count  = 3;
datetime New_Time=0;
int res=0;

extern int Magic = 999;
enum _TypeOrders{ 
   market,
   limit,
   stop
};
extern _TypeOrders TypeOrder = market;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---

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

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int Candles()
  {
   int count = 0;
   double CandleHigh = 0, CandleLow = 0, dl = 0, high = 0, low = 0, open = 0, close = 0, lastopen = 0, lastclose = 0;
   
   for(int i=1;i<=Count;i++)
     {  	 
         open = Open[i];
   		close = Close[i]; 
   		lastopen = Open[1];
   		lastclose = Close[1];
		      if(IsShadow)
		      {
   		      high = High[i];
   		      low = Low[i];
   		      if(i == 1)
         		  {
         		      CandleHigh = High[1];
      		         CandleLow = Low[1];
         		  }
		      }
		      else
		      {
		         if(i == 1)
         		  {
         		      CandleHigh = lastopen;
         		      CandleLow = lastclose;
         		      
         		      if(lastclose > lastopen)
      		         {
      		            CandleHigh = lastclose;
         		         CandleLow = lastopen;
      		         }
         		  }
         		  
         		   high = open;
      		      low = close;
      		         if(close > open)
      		         {
      		            high = close;
         		         low = open;
      		         }
		      }   
     
		if(MathAbs(CandleHigh-high)/Point<=Delta && MathAbs(CandleLow-low)/Point<=Delta && MathAbs(high-low)/Point>=(AvgBar-Delta) && MathAbs(high-low)/Point<=(AvgBar+Delta))
		{
			 count++;
		}
   		CandleHigh = high;
   		CandleLow = low;
      }
      
   if(count == Count && lastopen > 0 && lastclose > 0)
   {
      if(lastclose > lastopen) return 1;
      else return 2;
   }
	
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
      if(New_Time!=Time[0])
       {
         res = Candles();
         if(res > 0 && CountOrders(-1) == 0)
         {
               if(res == 1) PutOrder(OrderPlace(1), Ask);
               if(res == 2) PutOrder(OrderPlace(2), Bid);
               New_Time=Time[0];
         }
      }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CountOrders(int type)
  {
   int count=0;
   for(int i=OrdersTotal()-1;i>=0;i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
            if(OrderType()==type) count++;
            if(type == -1) count++;
           }
        }
     }
   return(count);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int OrderPlace(int bs) 
  {  
   string OrdType = EnumToString(TypeOrder);
   if (OrdType == "market") 
   {
      if(bs == 1) return 0;
      if(bs == 2) return 1;
   } 
   if (OrdType == "limit") 
   {
      if(bs == 1) return 2;
      if(bs == 2) return 3;
   } 
   if (OrdType == "stop") 
   {
      if(bs == 1) return 4;
      if(bs == 2) return 5;
   }
   return -1;  
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void PutOrder(int type, double price)
  {
   int r=0;
   color clr=Green;
   double s=0,t=0;   

   if(type==-1) return;

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

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

   r=OrderSend(NULL,type,lot,NormalizeDouble(price,Digits),slippage,s,t,"",Magic,0,clr);
   return;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+

Редактирован: 4 сентября 2016, 01:59

17 vis Сообщений: 199 - ♫♪♫♪

4 сентября 2016, 01:24
↑
↓

Спасибо, все так как я и хотел

14 beton2011 Автор Сообщений: 895

4 сентября 2016, 15:56
↑
↓

Захотелось создать индикатор по условию, чтобы стрелку выводил, но что то совпадений не находит.

//+------------------------------------------------------------------+
//|                                                         3bar.mq4 |
//|                        Copyright 2016, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2016, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property strict
#property indicator_chart_window

input int Count=1000; // баров для расчета
input double Delta  = 25;
input double AvgBar  = 70;
extern bool IsShadow  = false; // true - по high/low, false - по open/close
//input int Count  = 3;
datetime New_Time=0;
int res=0;
//int res=0;
//int time=0;
//int low=0;
//int high=0;


//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- indicator buffers mapping
   
//---
   return(INIT_SUCCEEDED);
  }
  
  //+------------------------------------------------------------------+
void PutArrow(string name,int code,double p,datetime time,color clr)
  {
//--- создадим стрелку
   ObjectDelete(0,name);
   ObjectCreate(0,name,OBJ_ARROW,0,time,p);
//--- установим код стрелки
   ObjectSetInteger(0,name,OBJPROP_ARROWCODE,code);
//--- установим способ привязки
   ObjectSetInteger(0,name,OBJPROP_ANCHOR,ANCHOR_CENTER);
//--- установим цвет стрелки
   ObjectSetInteger(0,name,OBJPROP_COLOR,clr);
//--- установим размер стрелки
   ObjectSetInteger(0,name,OBJPROP_WIDTH,1);
  }
  
  
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| 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[])
  {
//---
//+----------------------------- вывод стрелки при найденой трехбарной формаций-------------------------------------+   
      if(New_Time!=Time[0])
       {
         res = Candles();
         if(res > 0 && (-1) == 0)
           {
               if(res == 1) PutArrow("Arrow"+(string)time[0],233,low[1],time[1],Blue);
               if(res == 2) PutArrow("Arrow"+(string)time[0],234,high[1],time[1],Red);
               New_Time=Time[0];
           }
        }
//--- return value of prev_calculated for next call
   return(rates_total);
  }
  
  
//+--------------------------- Поиск трехбарных формаций ------------+
//+------------------------------------------------------------------+
int Candles()
  {
   int count = 0;
   double CandleHigh = 0, CandleLow = 0, dl = 0, high = 0, low = 0, open = 0, close = 0, lastopen = 0, lastclose = 0;
   
   Comment
   (
   //(MathAbs(CandleHigh-high)/Point<=Delta && MathAbs(CandleLow-low)/Point<=Delta && MathAbs(high-low)/Point>=(AvgBar-Delta) && MathAbs(high-low)/Point<=(AvgBar+Delta))
   "\n  Candle: ", (MathAbs(CandleHigh-high)/Point<=Delta && MathAbs(CandleLow-low)/Point<=Delta && MathAbs(high-low)/Point>=(AvgBar-Delta) && MathAbs(high-low)/Point<=(AvgBar+Delta)) 
    //"\n  CandleHigh: ", (MathAbs(CandleHigh-high)/Point<=Delta && MathAbs(CandleLow-low)/Point<=Delta && MathAbs(high-low)/Point>=(AvgBar-Delta))
    //"\n  CandleLow:",(MathAbs(CandleHigh-high)/Point<=Delta && MathAbs(CandleLow-low)/Point<=Delta &&  MathAbs(high-low)/Point<=(AvgBar+Delta)) 
                                                                                                                                               );      
                
                
                {
   for(int i=1;i<=Count;i++)
     {           
         open = Open[i];
                close = Close[i]; 
                lastopen = Open[1];
                lastclose = Close[1];
                      if(IsShadow)
                      {
                      high = High[i];
                      low = Low[i];
                      if(i == 1)
                          {
                              CandleHigh = High[1];
                         CandleLow = Low[1];
                          }
                      }
                      else
                      {
                         if(i == 1)
                          {
                              CandleHigh = lastopen;
                              CandleLow = lastclose;
                              
                              if(lastclose > lastopen)
                         {
                            CandleHigh = lastclose;
                                 CandleLow = lastopen;
                         }
                          }
                          
                           high = open;
                      low = close;
                         if(close > open)
                         {
                            high = close;
                                 low = open;
                         }
                      }   
     
                if(MathAbs(CandleHigh-high)/Point<=Delta && MathAbs(CandleLow-low)/Point<=Delta && MathAbs(high-low)/Point>=(AvgBar-Delta) && MathAbs(high-low)/Point<=(AvgBar+Delta))
                {
                         count++;
                }
                CandleHigh = high;
                CandleLow = low;
      }
      
   if(count == Count && lastopen > 0 && lastclose > 0)
    {
      if(lastclose > lastopen) return 1;
      else return 2;
    }
        
       return(0);
  }
  }
//+-------------------End-----------------------------------------------+
//|                                            |
//+------------------------------------------------------------------+

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

16 cerber04 Сообщений: 409

23 октября 2016, 15:26
↓

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

14 beton2011 Автор Сообщений: 895

23 октября 2016, 18:00
↑
↓

Зарегистрируйтесь или авторизуйтесь, чтобы оставить комментарий

Моя торговля

Группа "Стол заказов MQL"

Свыше 1000 заказов уже выполнено бесплатно!

РЕКОМЕНДУЮ

Лучшее от beton2011

Советник 9-9-9

Комментарии (22)

ЧАТ ТРЕЙДЕРОВ

Быстрое соединение

Текущие конкурсы и акции

Из недавнего:

	beton2011 Уровень 14

Авторизация

Моя торговля

Группа "Стол заказов MQL"

Свыше 1000 заказов уже выполнено бесплатно!

РЕКОМЕНДУЮ

Лучшее от beton2011

Советник 9-9-9

Вставка изображения

СМАЙЛИКИ

Позитив

Негатив

Роли

Еще

Плакаты, знаки

Комментарии (22)

ЧАТ ТРЕЙДЕРОВ

Быстрое соединение

Текущие конкурсы и акции

Из недавнего: