StepMAExpert_v1.42_usdjpy





//+------------------------------------------------------------------+
//|                                           StepMAExpert_v1.42.mq4 |
//|                           Copyright © 2005, TrendLaboratory Ltd. |
//|            http://finance.groups.yahoo.com/group/TrendLaboratory |
//|                                       E-mail: igorad2004@list.ru |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2005, TrendLaboratory Ltd."
#property link      "http://finance.groups.yahoo.com/group/TrendLaboratory"

#include <stdlib.mqh>
//#include <Tracert.mqh>

//---- input parameters
extern string     Expert_Name = "---- StepMAExpert_v1.42 ----";

extern int        Magic=1007;
extern int        Slippage=6;
extern bool       Trace = false;          // Trace Switch

extern string     Main_Parameters = " Trade Volume & Trade Method";
extern double     Lots = 0.2;
extern double     InitialStop = 91;        // Initial Stop Value
extern double     TakeProfit = 0;         // Take Profit Value
extern int        TrailingStopMode = 1;   // Trailing Stop Mode Switch   
extern double     TrailingStop=0;         // Classic Trailing Stop Value
extern bool       SwingTrade = true;     // Swing Trade Switch
extern bool       PendingOrder=false;     // PendingOrder/InstantExecution Switch
extern double     PendOrdGap=10;          // Gap from High/Low for Pending Orders
extern double     BreakEven=50;            // BreakEven Level in points
extern double     BreakEvenGap=25;         // BreakEven Gap in points

extern string     Calc_Parameters = " StepMA Parameters ";
extern int        Length=10;              // ATR Period	
extern double     Kv=1.0;                 // Sensivity Factor
extern double     StepSize=28;             // Constant Step Size (if need)
extern bool       HighLow=false;          // High/Low Mode Switch (more sensitive)
extern double     DeltaLong =1;           // Breakout Depth for Long in points
extern double     DeltaShort=6;           // Breakout Depth for Short in points
extern double     Ks=2.2;                 // StopLoss Factor
extern double     Kp=7.5;                 // TakeProfit Factor
extern int        FilterPeriod=34;        // Filter Period (EMA Period)
extern int        Nbars=1000;             // Bars Number for calculation during initialization

extern string     MM_Parameters = " MoneyManagement by L.Williams ";
extern bool       MM=false;               // ÌÌ Switch
extern double     Risk=0.15;              // Risk Factor
extern double     LossMax=1000;           // Maximum Loss by 1 Lot


int      trend=0,TradeSignal=0,ExitSignal=0,prevtrend=0,matrend=0,Kz=0,mode=0,Type=0, numords;
double   Smin0=0,Smax0=0,Smin1=0,Smax1=0,Price=0,PriceStop=0, BuyProfit=0, SellProfit=0;
double   line0=0,line1=0,bsmin1=0,bsmax1=0, Step=0, point=0;
double   BuyStop=0,SellStop=0,ATRmin=10000,ATRmax=0,bsmax2=0,bsmin2=0;
int      b=0,cnt=0, digit=0;
bool     FirstTime = false;
//+------------------------------------------------------------------+
//| expert initialization function                                   |
//+------------------------------------------------------------------+
int init()
  {
//---- 
FirstTime = true;   
//----
   return(0);
  }
  
// ---- Scan Trades
int ScanTrades()
{   
   int total = OrdersTotal();
   int numords = 0;
      
   for(int cnt=0; cnt<total; cnt++) 
   {        
   OrderSelect(cnt, SELECT_BY_POS);            
   if(OrderSymbol() == Symbol() && OrderType()<=OP_SELLSTOP && OrderMagicNumber() == Magic) 
   numords++;
   }
   return(numords);
}      

void TrailProfit()
{        
    int total=OrdersTotal();
    for (cnt=0;cnt<total;cnt++)
    { 
     OrderSelect(cnt, SELECT_BY_POS);   
     mode=OrderType();    
        if ( OrderSymbol()==Symbol() && OrderMagicNumber()==Magic ) 
        {
            if ( mode==OP_BUY )
            {
            if (Kp > 0) BuyProfit = line0 + Kp*Step/Kv; else BuyProfit = OrderTakeProfit();
            //Print("BuyProfit=",BuyProfit," lin0=",line0," Step=",Step," Kp,Kv=", Kp,",",Kv);  
              if( BuyProfit > OrderTakeProfit())
              { 
              OrderModify(OrderTicket(),OrderOpenPrice(),
                          OrderStopLoss(),
                          NormalizeDouble(BuyProfit,digit),0,LightGreen);
			     return(0);
			     }
            }
            if ( mode==OP_SELL )
            {
            if (Kp > 0) SellProfit = line0 - Kp*Step/Kv; else SellProfit = OrderTakeProfit();
            //Print("SellProfit=",SellProfit," lin0=",line0," Step=",Step," Kp,Kv=", Kp,",",Kv); 
              if( SellProfit < OrderTakeProfit())
              {  
   		     OrderModify(OrderTicket(),OrderOpenPrice(),
   		                 OrderStopLoss(),
   		                 NormalizeDouble(SellProfit, digit),0,Yellow);	    
              return(0);
              }
            }    
        }
    }   
}   
//+------------------------------------------------------------------+
//| expert deinitialization function                                 |
//+------------------------------------------------------------------+
int deinit()
  {
//---- 
   
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| expert start function                                            |
//+------------------------------------------------------------------+
int start()
  {
   int total,ticket;
//---- 
   
   //if ( Trace ) SetTrace();
   if (Bars>b)
   {      
   b=Bars;
   digit  = MarketInfo(Symbol(),MODE_DIGITS);
   point  = MarketInfo(Symbol(),MODE_POINT);  
   
   double Lotsi=Lots;     
      
   if ( MM ) Lotsi=NormalizeDouble(Lots*AccountFreeMargin()*Risk/LossMax,1);   
   if (Lotsi<0.1) Lotsi=0.1;
       
   if ( Nbars == 0 ) int NBars = Bars-Length-1; else NBars = Nbars-Length-1;
   if ( !FirstTime ) NBars = 1;
   
   int MA_Mode = 0;
   
   for ( int i=NBars; i>=1;i--)
   {
     
      if(StepSize>0) 
      {
      Step=Kv*StepSize*point; 
      }
      else
      {
      double AvgRange=0;
	     for (int j=Length-1;j>=0;j--)
	     { 
            if(MA_Mode==0) double alfa= 1.0; else alfa= 1.0+1.0*(Length-i)/Length; 
            AvgRange+= alfa*(High[j+i]-Low[j+i]);
        }
	   double ATR0 = AvgRange/Length;
   
	   if (ATR0>ATRmax) ATRmax=ATR0;
	   if (ATR0<ATRmin) ATRmin=ATR0;
	
	   Step=MathRound(0.5*Kv*(ATRmax+ATRmin)/point)*point;
	   
	   }  
	  	
	Smin1=Smin0;
	Smax1=Smax0;
	  
	   if(HighLow)
	   {	  
	   Smax0=Low[i]+2.0*Step;
	   Smin0=High[i]-2.0*Step;
	   }
	   else
	   {	  
	   Smax0=Close[i]+2.0*Step;
	   Smin0=Close[i]-2.0*Step;
	   }
	  	  
	prevtrend = matrend;
	
	if(Close[1]>Smax1) matrend=1; 
	if(Close[1]<Smin1) matrend=-1;
	  
	line1=line0; 
	  
	   if(matrend>0)
	   {
	   if(Smin0<Smin1) Smin0=Smin1;
	   line0=Smin0+Step;
	   }
	   else
	   if (matrend<0)
	   {
	   if(Smax0>Smax1) Smax0=Smax1;
	   line0=Smax0-Step;
	   }	  
   bsmin2=bsmin1;
	bsmax2=bsmax1;
	  
	bsmin1=Smin0;
	bsmax1=Smax0; 
      
   if ( i==1 ){ FirstTime = false;}
   }

// Trade Signal area	
      if(!SwingTrade) TradeSignal=0; 	
// - BUY      
      if 
      (
      Close[1]>iMA(NULL,0,FilterPeriod,0,MODE_EMA,0,1)
      &&
      line0-line1>DeltaLong*point
      &&
      line1>0
      && 
      prevtrend<0
      )  TradeSignal= 1;
// - SELL      
      if 
      (
      Close[1]<iMA(NULL,0,FilterPeriod,0,MODE_EMA,0,1)
      &&
      line1-line0>DeltaShort*point
      &&
      line1>0
      && 
      prevtrend>0
      )  TradeSignal= -1;

// Exit Signal area	
       	
// - BUY Orders      
      if 
      (
      //Close[1]<iMA(NULL,0,50,0,MODE_EMA,0,1)
      //||
      line1-line0>0
      )  ExitSignal= -1;
// - SELL Orders      
      if 
      (
      //Close[1]>iMA(NULL,0,50,0,MODE_EMA,0,1)
      //||
      line0-line1>0
      )  ExitSignal= 1;
      
      if(SwingTrade) ExitSignal=TradeSignal;
         
      TrailProfit();       
//-----------------------------
      total=OrdersTotal();
	   for (cnt=0;cnt<total;cnt++)
      { 
       OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);   
       mode=OrderType();
       if ( OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
       { 
// Orders Close area  : 
// - BUY Orders         
         if ( ExitSignal<0 )
         {
            if (mode==OP_BUY)
                  {
			         OrderClose(OrderTicket(),OrderLots(),Bid,Slippage,Yellow);
			         }
         }
// - SELL Orders          
         if ( ExitSignal>0 )
	      {
            if (mode==OP_SELL)
			         {
   			      OrderClose(OrderTicket(),OrderLots(),Ask,Slippage,White);
                  }
         }    
      
          if (BreakEven > 0)
          {
             if (mode==OP_BUY)
                  {
			         BuyStop = OrderStopLoss();
			         if (Bid-OrderOpenPrice() > Kz*BreakEven*point) 
			            {
			            BuyStop=OrderOpenPrice()+((Kz-1)*BreakEven+BreakEvenGap)*point;
			            OrderModify(OrderTicket(),OrderOpenPrice(),
			                        NormalizeDouble(BuyStop, digit),
			                        OrderTakeProfit(),0,LightBlue);
			            Kz=Kz+1;
			            return(0);
			            }
			         }
               if (mode==OP_SELL)
                  {
                  SellStop = OrderStopLoss();
                  if (OrderOpenPrice()-Ask > Kz*BreakEven*point) 
			            {
			            SellStop=OrderOpenPrice()-((Kz-1)*BreakEven+BreakEvenGap)*point;
			            OrderModify(OrderTicket(),OrderOpenPrice(),
			                        NormalizeDouble(SellStop, digit),
			                        OrderTakeProfit(),0,Orange);
			            Kz=Kz+1;
			            return(0);
			            }
			         }
           }
    
// Orders Modify Area 
           if (TrailingStopMode > 0) 
           {
              if (mode==OP_BUY) 
              {
			     if (TrailingStop > 0)
			     BuyStop = Bid - TrailingStop*point;
			     else 
			     if ( Ks > 0) BuyStop = line0 - Ks*Step/Kv; else BuyStop = OrderStopLoss();
			        if ( BuyStop > OrderStopLoss() || OrderStopLoss()==0) 
			        {
			        OrderModify(OrderTicket(),OrderOpenPrice(),
			                    NormalizeDouble(BuyStop, digit),
			                    OrderTakeProfit(),0,LightGreen);
			        return(0);
                 }
              }
// - SELL Orders          
              if (mode==OP_SELL)
              {
              if (TrailingStop > 0)
			     BuyStop = Ask + TrailingStop*point;
			     else 
              if ( Ks > 0) SellStop = line0 + Ks*Step/Kv; else SellStop = OrderStopLoss(); 
                 if( SellStop < OrderStopLoss() || OrderStopLoss()==0) 
                 {
                 OrderModify(OrderTicket(),OrderOpenPrice(),
   			                 NormalizeDouble(SellStop, digit),
   			                 OrderTakeProfit(),0,Yellow);	    
                 return(0);
                 }
              }
           }    
      }
            
// Closing of Pending Orders      
      if(Close[1]<MathMin(iMA(NULL,0,50,0,MODE_EMA,0,1),line0))int PendClose=1; 
      if(Close[1]>MathMax(iMA(NULL,0,50,0,MODE_EMA,0,1),line0))    PendClose=-1;  
      
      if (mode==OP_BUYSTOP && PendClose>0 && OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
      {
	 	OrderDelete(OrderTicket());
	   return(0);
	   }
	    
      if (mode==OP_SELLSTOP && PendClose<0 && OrderSymbol()==Symbol() && OrderMagicNumber()==Magic) 
	 	{
	 	OrderDelete(OrderTicket());
	   return(0);
	   }      
      }//for (cnt=0;cnt<total;cnt++)
// Orders open area :
// - SELL Orders  		     
		
		
		if (ScanTrades()<1)
      {     
		   if ( trend>=0 && TradeSignal<0 ) 
         {  
            if(PendingOrder)
		  	   {
		    	   Type=OP_SELLSTOP;
		    	   Price=Low[1]-PendOrdGap*point;
		 	      PriceStop=Price;  
		 	   }
		 	   else
		  	   {
		   	   Type=OP_SELL;
		    	   Price=Bid;
		  	      PriceStop=Ask; 
		  	   }
		  	   
		  	   if (InitialStop > 0)
            SellStop = PriceStop + InitialStop*point; 
            else
            if( Ks > 0) SellStop= line0 + Ks*Step/Kv; else SellStop=0;
            
            if (TakeProfit > 0)
            SellProfit = Price - TakeProfit*point;
            else 
            if (Kp > 0) SellProfit = line0 - Kp*Step/Kv; else SellProfit=0;
            
            ticket=OrderSend(Symbol(),Type,Lotsi,
		                       NormalizeDouble(Price, digit),
		                       Slippage,
		                       NormalizeDouble(SellStop, digit),
		                       NormalizeDouble(SellProfit, digit),
		                       "sell",Magic,0,Red);
            Kz=1;
            if(SwingTrade) trend=-1; else {trend=0;}
            if(ticket<0)
            {
            Print("OrderSend failed with error #",GetLastError());
            return(0);
            }
		      return(0);
		   }
// - BUY Orders         
	      if (trend <=0 &&  TradeSignal>0)
	      {
            if(PendingOrder)
		    	{
		    	   Type=OP_BUYSTOP;
		    	   Price=High[1]+PendOrdGap*point;
		    	   PriceStop = Price;  
		    	}
		    	else
		    	{
		    	   Type=OP_BUY;
		    	   Price=Ask;
		    	   PriceStop = Bid;
		    	}
		    	
		    	if (InitialStop > 0)
            BuyStop = PriceStop - InitialStop*point; 
            else
            if ( Ks > 0) BuyStop=line0-Ks*Step/Kv; else BuyStop=0;
            
            if (TakeProfit > 0)
            BuyProfit = Price + TakeProfit*point;
            else 
            if (Kp > 0) BuyProfit = line0 + Kp*Step/Kv; else BuyProfit=0;
            
		    	ticket=OrderSend(Symbol(),Type,Lotsi,
		    	                 NormalizeDouble(Price, digit),
		    	                 Slippage,
		    	                 NormalizeDouble(BuyStop, digit),
		    	                 NormalizeDouble(BuyProfit, digit),
		    	                 "buy",Magic,0,Blue);
                  
            Kz=1;
            if(SwingTrade) trend=1; else {trend=0;}
            if(ticket<0)
            {
            Print("OrderSend failed with error #",GetLastError());
            return(0);
            }
			   return(0);
         }
      }
   }//if (Bars>b)
//----                          
 

//----
   return(0);
  }
//+------------------------------------------------------------------+



Sample





Analysis



Market Information Used:

Series array that contains the highest prices of each bar
Series array that contains the lowest prices of each bar
Series array that contains close prices for each bar


Indicator Curves created:


Indicators Used:

Moving average indicator


Custom Indicators Used:

Order Management characteristics:
Checks for the total of open orders

It can change open orders parameters, due to possible stepping strategy
It Closes Orders by itself

Other Features: