/+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 07.10.2006                                                     |
//|  Описание : Возвращает экстремум ЗигЗага по его номеру.                    |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   (NULL или "" - текущий символ)          |
//|    tf - таймфрейм                  (      0     - текущий ТФ)              |
//|    ne - номер экстремума           (      0     - последний)               |
//|    dp - ExtDepth                                                           |
//|    dv - ExtDeviation                                                       |
//|    bs - ExtBackstep                                                        |
//+----------------------------------------------------------------------------+
double GetExtremumZZPrice(string sy="", int tf=0, int ne=0, int dp=12, int dv=5, int bs=3) {
  if (sy=="" || sy=="0") sy=Symbol();
  double zz;
  int    i, k=iBars(sy, tf), ke=0;

  for (i=1; i<k; i++) {
    zz=iCustom(sy, tf, "ZigZag", dp, dv, bs, 0, i);
    if (zz!=0) {
      ke++;
      if (ke>ne) return(zz);
    }
  }
  Print("GetExtremumZZPrice(): Экстремум ЗигЗага номер ",ne," не найден");
  return(0);
}

<code>
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 07.10.2006                                                     |
//|  Описание : Поиск ближайшего фрактала. Возвращает ценовой уровень.         |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy   - наименование инструмента      ("" или NULL - текущий символ)     |
//|    tf   - таймфрейм                     (    0       - текущий ТФ)         |
//|    mode - тип фрактала                  (MODE_LOWER|MODE_UPPER)            |
//+----------------------------------------------------------------------------+
double FindNearFractal(string sy="0", int tf=0, int mode=MODE_LOWER) {
  if (sy=="" || sy=="0") sy=Symbol();
  double f=0;
  int    d=MarketInfo(sy, MODE_DIGITS), s;
  if (d==0) if (StringFind(sy, "JPY")<0) d=4; else d=2;

  for (s=2; s<100; s++) {
    f=iFractals(sy, tf, mode, s);
    if (f!=0) return(NormalizeDouble(f, d));
  }
  Print("FindNearFractal(): Фрактал не найден");
  return(0);
}
//+----------------------------------------------------------------------------+  
</code>

<code>
//+------------------------------------------------------------------+
//|                                                          ASC.mq4 |
//|                                            Copyright © 2015, AM2 |
//|                                      http://www.forexsystems.biz |
//+------------------------------------------------------------------+

#property copyright "Copyright © 2015, AM2"
#property link      "http://www.forexsystems.biz"
#property description "Forex expert advisor"

//--- Inputs
extern int StopLoss      = 2000;  // стоплосс ордера
extern int TakeProfit    = 2000;  // тейкпрофит ордера
extern int Expiration    = 14;   // время истечения ордера
extern int Delta         = 100;  // расстояние от вершин
extern double Lots       = 0.1;  // объем позиции
extern int MAGIC         = 333;  // магик

double ASCBuy,ASCSell,FUP,FDN,price;
//+------------------------------------------------------------------+
//| Check for open order conditions                                  |
//+------------------------------------------------------------------+
void PutOrder()
  {
   int    res,b,s;
   datetime expiration = TimeCurrent()+3600*Expiration;
    ASCBuy=iCustom(Symbol(),0,"ASCtrend",1,1);
    ASCSell=iCustom(Symbol(),0,"ASCtrend",0,1);
    FUP=iFractals(Symbol(),0,MODE_UPPER,2);
    FDN=iFractals(Symbol(),0,MODE_LOWER,2);   
      
   for(int i=OrdersTotal()-1;i>=0;i--)
    {
     if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
      {
       if(OrderSymbol()==Symbol() && OrderMagicNumber()==MAGIC)
        {
         if(OrderType()==OP_BUYSTOP)b++;
         if(OrderType()==OP_SELLSTOP)s++; 
        }
      }
    }
    
   //--- buy
   if(ASCSell<2 && b<1)
    {   
     price=FDN+Delta*Point;
     res=OrderSend(Symbol(),OP_BUYSTOP,Lots,fND(price),3,fND(price-StopLoss*Point),fND(price+TakeProfit*Point),"",MAGIC,expiration,Blue);
    }             
                    
   //--- sell 
   if(ASCBuy<2 && s<1)
    {
     price=FUP-Delta*Point;
     res=OrderSend(Symbol(),OP_SELLSTOP,Lots,fND(price),3,fND(price+StopLoss*Point),fND(price-TakeProfit*Point),"",MAGIC,expiration,Red);
    } 
    
   Comment("\nBuy Price ",ASCBuy,"\nSell Price  ",ASCSell,
           "\nFUP ",FindNearFractal(NULL,0,MODE_UPPER),"\nFDN  ",FindNearFractal(NULL,0,MODE_LOWER));  
  }
//+------------------------------------------------------------------+
void DelOrder()
  {
   bool del; 
   for (int i=OrdersTotal()-1; i>=0; i--) 
    {
     if (OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==false) break; 
     if (OrderType()==OP_BUYSTOP)  del=OrderDelete(OrderTicket()); 
     if (OrderType()==OP_SELLSTOP) del=OrderDelete(OrderTicket());       
    }    
  }
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 07.10.2006                                                     |
//|  Описание : Поиск ближайшего фрактала. Возвращает ценовой уровень.         |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy   - наименование инструмента      ("" или NULL - текущий символ)     |
//|    tf   - таймфрейм                     (    0       - текущий ТФ)         |
//|    mode - тип фрактала                  (MODE_LOWER|MODE_UPPER)            |
//+----------------------------------------------------------------------------+
double FindNearFractal(string sy="0", int tf=0, int mode=MODE_LOWER) {
  if (sy=="" || sy=="0") sy=Symbol();
  double f=0;
  int    d=MarketInfo(sy, MODE_DIGITS), s;
  if (d==0) if (StringFind(sy, "JPY")<0) d=4; else d=2;

  for (s=2; s<100; s++) {
    f=iFractals(sy, tf, mode, s);
    if (f!=0) return(NormalizeDouble(f, d));
  }
  Print("FindNearFractal(): Фрактал не найден");
  return(0);
}
//+----------------------------------------------------------------------------+  
//+------------------------------------------------------------------+
bool NewBar()
  {
   static datetime lastbar = 0;
   datetime curbar = Time[0];
   if(lastbar!=curbar)
   {
      lastbar=curbar;
      return (true);
   }
   else
   {
      return(false);
   }
  }
//+------------------------------------------------------------------+

int CountTrades()
  {
   int count=0;
   for(int i=OrdersTotal()-1;i>=0;i--)
    {
     if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
      {
       if(OrderSymbol()==Symbol() && OrderMagicNumber()==MAGIC)
        {
         if(OrderType()==OP_BUY || OrderType()==OP_SELL)
          count++;
        }
      }
    }
    return(count);
  }
//+------------------------------------------------------------------+
double fND(double d,int n=-1)
  {
   if(n<0) return(NormalizeDouble(d, Digits));
   return(NormalizeDouble(d, n));
  }  
//+------------------------------------------------------------------+
//| OnTick function                                                  |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- check for history and trading
   if(Bars<100 || IsTradeAllowed()==false)
      return;
   
   if(CountTrades()<1)PutOrder();
   if(CountTrades()>0)DelOrder();  
//---
  }
//+------------------------------------------------------------------+

</code>

//+------------------------------------------------------------------+
//|                                        ASCTrend1sig_noSound.mq4  |
//|                                       Ramdass - Conversion only  |
//+------------------------------------------------------------------+

#property indicator_chart_window
#property indicator_buffers 2
#property indicator_color1 Red
#property indicator_color2 Blue
//---- input parameters
extern int RISK = 3;
extern int CountBars = 300;
//---- buffers
double val1[];
double val2[];


//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
    //---- indicator line
    IndicatorBuffers(2);
    SetIndexStyle(0, DRAW_ARROW, 0, 1);
    SetIndexArrow(0, 234);
    SetIndexStyle(1, DRAW_ARROW, 0, 1);
    SetIndexArrow(1, 233);
    SetIndexBuffer(0, val1);
    SetIndexBuffer(1, val2);
    if(CountBars >= 1000) 
        CountBars=950;
    SetIndexDrawBegin(0, Bars - CountBars + 11 + 1);
    SetIndexDrawBegin(1, Bars - CountBars + 11 + 1);
    //----
    return(0);
  }
//+------------------------------------------------------------------+
//| ASCTrend1sig                                                     |
//+------------------------------------------------------------------+
int start()
  {
    int i, shift, counted_bars = IndicatorCounted();
    int Counter, i1, value10, value11;
    double value1, x1, x2;
    double value2, value3;
    double TrueCount, Range, AvgRange, MRO1, MRO2;
    double Table_value2[1000];
    //----
    value10 = 3 + RISK*2;
    x1 = 67 + RISK;
    x2 = 33 - RISK;
    value11 = value10;
    //----
    if(Bars <= 11 + 1) 
        return(0);
    //---- initial zero
    if(counted_bars < 11 + 1)
      {
        for(i = 1; i <= 0; i++) 
            val1[CountBars-i] = 0.0;
        for(i = 1; i <= 0; i++) 
            val2[CountBars-i] = 0.0;
      }
    //----
    shift = CountBars - 11 - 1;
    while(shift >= 0)
      {
        Counter = shift;
	       Range = 0.0;
	       AvgRange = 0.0;
	       //----
        for(Counter = shift; Counter <= shift + 9; Counter++) 
	           AvgRange=AvgRange + MathAbs(High[Counter] - Low[Counter]);
	       //----
        Range = AvgRange / 10;
	       Counter = shift;
	       TrueCount = 0;
	       //----
        while(Counter < shift + 9 && TrueCount < 1)
		        {
		          if(MathAbs(Open[Counter] - Close[Counter+1]) >= Range*2.0) 
		              TrueCount = TrueCount + 1;
		          Counter=Counter+1;
		        }
	       //----
        if(TrueCount >= 1) 
	         {
	           MRO1 = Counter;
	         } 
	       else 
	         {
	           MRO1 = -1;
	         }
	       //----
        Counter = shift;
	       TrueCount = 0;
	       //----
        while(Counter < shift + 6 && TrueCount < 1)
		        {
		          if (MathAbs(Close[Counter+3] - Close[Counter]) >= Range*4.6) 
		              TrueCount = TrueCount + 1;
		          Counter = Counter + 1;
		        }
	       //----
        if(TrueCount >= 1) 
	         {
	           MRO2 = Counter;
	         } 
	       else 
	         {
	           MRO2 = -1;
	         }
	       //----
        if(MRO1 > -1) 
	         {
	           value11 = 3;
	         } 
	       else 
	         {
	           value11 = value10;
	         }
	       //----
        if(MRO2 > -1) 
	         {
	           value11 = 4;
	         } 
	       else 
	         {
	           value11 = value10;
	         }
	       //----
        value2 = 100 - MathAbs(iWPR(NULL, 0, value11, shift)); // PercentR(value11=9)
	       Table_value2[shift] = value2;
	       val1[shift] = 0;
	       val2[shift] = 0;
	       value3 = 0;
	       //----
        if(value2 < x2)
		        {
		          i1 = 1;
		          while(Table_value2[shift + i1] >= x2 && Table_value2[shift+i1] <= x1)
		            {
		              i1++;
		            }
		          //----
            if(Table_value2[shift+i1] > x1) 
			           {
			             value3 = High[shift] + Range*0.5;
			             val1[shift] = value3;
			           } 
		        }
	       if(value2 > x1)
		        {
		          i1=1;
		          while(Table_value2[shift+i1] >= x2 && Table_value2[shift+i1] <= x1)
		            {
		              i1++;
		            }
		          if(Table_value2[shift+i1] < x2) 
			           {
			             value3 = Low[shift] - Range*0.5;
			             val2[shift] = value3;
			           }
		        }
      
        shift--;
      }
    return(0);
  }
//+------------------------------------------------------------------+