RSI_R2_EA_v2.7

Author: Bluto and Robert
Price Data Components
Series array that contains open time of each barSeries array that contains close prices for each bar
Orders Execution
It automatically opens orders when conditions are reachedChecks for the total of open ordersIt Closes Orders by itself It can change open orders parameters, due to possible stepping strategy
Indicators Used
Relative strength indexCommodity channel indexMoving average indicatorParabolic Stop and Reverse system
0 Views
0 Downloads
0 Favorites
RSI_R2_EA_v2.7 
//+------------------------------------------------------------------+
//|                                                                  |
//|             RSI-R2.mq4 - Ver 1.0 @ 03/22/2007 by Bluto           |
//|                                                                  |
//|  Changes by Rick Myers                                           |
//|  4/8/2007 Modified code to use MFI instead of MFI                |
//|  Changes by Robert Hill                                          |
//|  4/3/2007 added input for RSI_Period                             |
//|           Modified code for MagicNumber calculation              |
//|           Added function to set value for RSI_Period             |
//|           Set value of AssignRSI to false during optimization    |
//|           Use optimized value in function AssignRSI_Period       |
//|           Set value of AssignRSI to true when running live       |
//|  4/5/2007 Fixed bug that caused no more trades after a stoploss  |
//|           added 2 variable to hold pSar values to reduce calls   |
//|           Added GetLots as a function using MM code from start   |
//|  4/6/2007 Combined with RSI_R2_AnyTimeFrame_Optimzable.mq4       |
//|           Made more modular                                      |
//|           Added code for possible MA Angle filter                |
//|           Added 7 Trailing stop functions for testing            |
//|           Combined Bluots open trade code with mine              |
//| 4/15/2007 Added optimized values for RSI period from bluto       |
//|           Added change to moneymanagement from bluto             |
//| 4/16/2007 Added code to check RSI 4 bars back for confirmation   |
//|           Added new exit ideas from Gideon                       |
//|           Both are selectable by input switches.                 |
//| 4/27/2007 Added check to prevent another trade from opening      |
//|           on the same dat a trade is closed                      |
//| 5/6/2007  Added new exit strategies                              |
//|           RSI 14 as described by Loren                           |
//|           My idea to use CCI 50                                  |
//| 5/8/2007  Added use of MFI by selection                          |
//|           Changed input name useDefaultRSI_Period                |
//|           to useOptimizedRSI_Period                              |
//| 5/11/2007 Removed use of MFI and MA Angle for filter             |
//|           Added use of HMA3 for filter                           |
//|           Added code to only check signal once per completed bar |
//|           Made new exit methods selectable from menu for easier  |
//|           testing for best method                                |
//|                                                                  |
//|           Modifications suggested by Loren                       |
//|           Require daily RSI 14 weighted close >= 35 for long     |
//|           to correct the premature entry problem where price     |
//|           price continues to decline for an indeterminate period.|
//|           The reverse of this for shorts w/ RSI 14 <= 65.        |
//+------------------------------------------------------------------+


#property copyright "Bluto and Robert"
#property link      "None"
#include <stdlib.mqh>

// This makes code easier to read

// Exit Method
#define NONE 1
#define RSI_EXIT 2
#define CCI_EXIT 3

// Currency pair
#define AUDCAD 1
#define AUDJPY 2
#define AUDNZD 3
#define AUDUSD 4
#define CHFJPY 5
#define EURAUD 6
#define EURCAD 7
#define EURCHF 8
#define EURGBP 9
#define EURJPY 10
#define EURUSD 11
#define GBPCHF 12
#define GBPJPY 13
#define GBPUSD 14
#define NZDJPY 15
#define NZDUSD 16
#define USDCAD 17
#define USDCHF 18
#define USDJPY 19
#define UNEXPECTED 999

extern string  Expert_Name    = "---- RSI_R2_EA_v2.6 ----";
//+---------------------------------------------------+
//|Money Management                                   |
//+---------------------------------------------------+
extern double  LotSize=0.1;
extern double  RiskPercent=2.0;
extern bool    UseMoneyMgmt=false;
extern bool    BrokerPermitsFractionalLots = true;

//+---------------------------------------------------+
//|Indicator Variables                                |
//| Change these to try your own system               |
//| or add more if you like                           |
//+---------------------------------------------------+
extern string  mi="--Moving Average settings--";
extern int     MaTrend_Period = 200;

extern string  ri="--RSI settings--";
extern int     RSI_Period = 4;       // input value to be optimized
extern bool    UseOptimizedRSI_Period = false;
extern int     BuyWhenRsiBelow = 65;
extern int     SellWhenRsiAbove = 35;
extern double  RSI_Overbought_Value = 75.0; 
extern double  RSI_Oversold_Value = 25.0;
extern int     useTurnUpDown = 1;
extern string  l1="--RSI confirmation--";
extern int     useRSI_Confirmation = 1;
extern int     RSI_ConfirmPeriod = 14;
extern int     BuyConfirmLevel = 35;
extern int     SellConfirmLevel = 65;

// Added Blutos newest exit using Price close vs SMA 200
extern int     use200SMA_Exit = 1;
extern string  ex1="--Trade Exit Method--";
extern string  ex2=" 1. None";
extern string  ex3=" 2. RSI ";
extern string  ex4=" 3. CCI ";
extern int     ExitMethod = 2;
extern int     RSI_Exit_Period = 14;
extern int     RSI_BuyExitLevel = 50;
extern int     RSI_SellExitLevel = 50;

extern int     CCI_Exit_Period = 50;
extern int     CCI_BuyExitLevel = 0;
extern int     CCI_SellExitLevel = 0;

extern string  st1="--Signal_TimeFrame--";
extern int     Signal_TimeFrame = 0;

extern string  hd = " --Limit 1 trade per day --";
extern int     useDelay = 1;
extern int     MaxTrades = 1;

// Added this for possible filter for flat markets
extern string  ai="--HMA filter settings--";
extern string  a2=" Set switch to 1 to use filter";
extern int     useFilter = 1;
extern double  HMA_Period=200;
extern int     Separation = 1;
extern int     Filter_TimeFrame = 0;

//+---------------------------------------------------+
//|Profit controls                                    |
//+---------------------------------------------------+
extern string  st6 = "--Profit Controls--";
extern double  StopLoss=0;
extern double  TakeProfit=700;
extern int     Slippage=3;

extern string  tsp0 = "--Trailing Stop Types--";
extern string  tsp1 = " 1 = Trail immediately";
extern string  tsp2 = " 2 = Wait to trail";
extern string  tsp3 = " 3 = Uses 3 levels before trail";
extern string  tsp4 = " 4 = Breakeven + Lockin";
extern string  tsp5 = " 5 = Step trail";
extern string  tsp6 = " 6 = EMA trail";
extern string  tsp7 = " 7 = pSAR trail";
extern string  tsp8 = " 8 = Blutos pSar trail";
extern bool    UseTrailingStop = true;
extern int     TrailingStopType = 8;

extern string  ts2 = "Settings for Type 2";
extern double  TrailingStop = 15;      // Change to whatever number of pips you wish to trail your position with.

extern string  ts3 = "Settings for Type 3";
extern double  FirstMove = 20;        // Type 3  first level pip gain
extern double  FirstStopLoss = 50;    // Move Stop to Breakeven
extern double  SecondMove = 30;       // Type 3 second level pip gain
extern double  SecondStopLoss = 30;   // Move stop to lock is profit
extern double  ThirdMove = 40;        // type 3 third level pip gain
extern double  TrailingStop3 = 20;    // Move stop and trail from there

extern string  ts4 = "Settings for Type 4";
extern double  BreakEven = 30;
extern int     LockInPips = 1;        // Profit Lock in pips

extern string  ts5 = "Settings for Type 5";
extern int     eTrailingStop   = 10;
extern int     eTrailingStep   = 2;

extern string  ts6 = "Settings for Type 6";
extern int     EMATimeFrame    =  30;
extern int     Price           =  0;
extern int     EMAPeriod       = 13;
extern int     EMAShift        =  2;    
extern int     InitialStop     =  0;
 
extern string  ts7 = "Settings for Type 7";
extern string  pi="--pSAR settings--";
extern double  StepParabolic = 0.02;
extern double  MaxParabolic  = 0.2;
extern int     Interval      = 5;

extern string  ts8 = "Settings for Type 8";
extern string  pi2="--pSAR settings--";
extern double  SarStep = 0.02;
extern double  SarMax = 0.20;

//+---------------------------------------------------+
//|General controls                                   |
//+---------------------------------------------------+
int            MagicNumber=0;
string         setup;
int            TradesInThisSymbol = 0;
double         MM_OrderLotSize=0;
datetime       StopTime;                 // Time to wait after a trade is stopped out
bool           StoppedOut=false;
datetime       timeprev=0;

//+---------------------------------------------------+
//|  Indicator values for signals and filters         |
//|  Add or Change to test your system                |
//+---------------------------------------------------+
int            myRSI_Period = 2;     // Used by RSI indicator call

//+------------------------------------------------------------------+
//| Calculate MagicNumber, setup comment and assign RSI Period       |
//|                                                                  |
//+------------------------------------------------------------------+
int init()
{

	MagicNumber = 200000 + func_Symbol2Val(Symbol())*100 + func_TimeFrame_Const2Val(Period()); 
   setup=Expert_Name + Symbol() + "_" + func_TimeFrame_Val2String(func_TimeFrame_Const2Val(Period()));
   if (UseOptimizedRSI_Period) myRSI_Period = AssignRSI_Period(Symbol()); else  myRSI_Period = RSI_Period;
    
 return(0);
}

int deinit()
{
 return(0);
}



//+------------------------------------------------------------------+
//| AssignRSI_Period                                                 |
//| Returns the optimized value for RSI period based on symbol       |
//|                                                                  |
//| This function will be changed when new optimized values are      |
//| determined from backtest                                         |
//|                                                                  |
//+------------------------------------------------------------------+
int AssignRSI_Period(string symbol)
{

   int RSI = 0;
   int which = func_Symbol2Val(symbol);
   
   switch (which)
   {
        case AUDCAD : RSI = 5;
                      break;
        case AUDJPY : RSI = 7;
                      break;
        case AUDNZD : RSI = 6;
                      break;
        case AUDUSD : RSI = 4;
                      break;
        case CHFJPY : RSI = 4;
                      break;
        case EURAUD : RSI = 2;
                      break;
        case EURCAD : RSI = 3;
                      break;
        case EURCHF : RSI = 3;
                      break;
        case EURGBP : RSI = 2;
                      break;
        case EURJPY : RSI = 4;  // Optimized value
                      break;
        case EURUSD : RSI = 4;
                      break;
        case GBPCHF : RSI = 6;
                      break;
        case GBPJPY : RSI = 4;
                      break;
        case GBPUSD : RSI = 3;
                      break;
        case NZDJPY : RSI = 6;
                      break;
        case NZDUSD : RSI = 7;
                      break;
        case USDCAD : RSI = 2;
                      break;
        case USDCHF : RSI = 4;
                      break;
        case USDJPY : RSI = 4;
                      break;
        case UNEXPECTED : RSI = 4;
   }
   if (RSI == 0) RSI = 4;
   return (RSI);
}

//+------------------------------------------------------------------+
//| LastTradeStoppedOut                                              |
//| Check History to see if last trade stopped out                   |
//| Return Time for next trade                                       |
//+------------------------------------------------------------------+
  
//+------------------------------------------------------------------+
//| LastTradeClosedToday                                             |
//| Check History to see if last trade closed today                  |
//+------------------------------------------------------------------+
  
bool LastTradeClosedToday()
{
   int cnt, total;
   bool Closed;
   
   
   total = HistoryTotal();
   for (cnt = total - 1; cnt >= 0; cnt--)
   {
      OrderSelect (cnt, SELECT_BY_POS, MODE_HISTORY);
      
      if(OrderSymbol()!=Symbol()) continue;
      if (OrderMagicNumber() != MagicNumber) continue;

        Closed = false;
        if (OrderType() == OP_BUY)
        {
          if (TimeDay(OrderCloseTime()) == TimeDay(TimeCurrent()))
          {
             Closed = true;
          }
          cnt = 0;
        }
        if (OrderType() == OP_SELL)
        {
          if (TimeDay(OrderCloseTime()) == TimeDay(TimeCurrent()))
          {
             Closed = true;
          }
          cnt = 0;
        }

   }
   
   return (Closed);
}



//+------------------------------------------------------------------+
//| CheckFilter                                                      |
//| Uses HMA3 custom indicator                                       |
//| Place trades only in the direction of Hull Moving Average        |
//| No trade is placed if HMA is too flat                            | 
//|                                                                  |
//+------------------------------------------------------------------+
bool CheckFilter (int cmd)
{
   double MACurrent, MAPrevious;
   bool filter = false;
   
   MACurrent=iCustom(NULL,Filter_TimeFrame,"Hma3",HMA_Period,0,0,0,1);
   MAPrevious=iCustom(NULL,Filter_TimeFrame,"Hma3",HMA_Period,0,0,0,2);
   
   filter = false;
   switch (cmd)
   {
      case OP_BUY : if (MACurrent - MAPrevious >= Separation * Point) filter = true;
                    break;
      case OP_SELL : if (MAPrevious - MACurrent >= Separation * Point) filter = true;
   }
   return (filter);
   
}


//+------------------------------------------------------------------+
//| CheckRSI_Exit                                                    |
//| Exit buy when RSI crosses below buy exit level default 50        |
//| Exit sell when RSI crosses above sell exit level default 50      |
//|                                                                  |
//+------------------------------------------------------------------+
bool CheckRSI_Exit(int cmd)
{

   double RSIcur, RSIprev;
   
   RSIcur = iRSI(Symbol(),Signal_TimeFrame, RSI_Exit_Period, PRICE_CLOSE, 1);
   RSIprev = iRSI(Symbol(),Signal_TimeFrame, RSI_Exit_Period, PRICE_CLOSE, 2);
   
   switch (cmd)
   {
     case OP_BUY  : if (RSIcur < RSI_BuyExitLevel && RSIprev > RSI_BuyExitLevel) return(true);
                    break;
     case OP_SELL : if (RSIcur > RSI_SellExitLevel && RSIprev < RSI_SellExitLevel) return(true);
   }
   
   return(false);
   
   
}

//+------------------------------------------------------------------+
//| CheckCCI_Exit                                                    |
//| Exit buy when CCI crosses below buy exit level default 0         |
//| Exit sell when CCI crosses above sell exit level default 0       |
//|                                                                  |
//+------------------------------------------------------------------+
bool CheckCCI_Exit(int cmd)
{
   double CCIcur, CCIprev;
   
   CCIcur = iCCI(Symbol(), Signal_TimeFrame, CCI_Exit_Period, PRICE_CLOSE, 1);
   CCIprev = iCCI(Symbol(), Signal_TimeFrame, CCI_Exit_Period, PRICE_CLOSE, 2);
   
   switch (cmd)
   {
     case OP_BUY  : if (CCIcur < CCI_BuyExitLevel && CCIprev > CCI_BuyExitLevel) return(true);
                    break;
     case OP_SELL : if (CCIcur > CCI_SellExitLevel && CCIprev < CCI_SellExitLevel) return(true);
   }
   
   return(false);
   
   
}

//+------------------------------------------------------------------+
//| CheckExitCondition                                               |
//| Uses OP_BUY as cmd to check exit sell                            |
//| Uses OP_SELL as cmd to check exit buy                            |
//|                                                                  |
//| First checks for exit using SMA 200 cross                        |
//| If new exit ideas are selected those are then checked for exit   |
//| Finally use the original exit method                             |
//| Exit buy when RSI is overbought                                  |
//| Exit sell when RSI is oversold                                   |
//+------------------------------------------------------------------+
bool CheckExitCondition(int cmd)
{
   double RSI;
  
   RSI = iRSI(Symbol(), Signal_TimeFrame, myRSI_Period, PRICE_CLOSE, 1);
   
   switch (cmd)
   {
   case OP_BUY  : if (use200SMA_Exit == 1)
                  {
                     if (CheckMA(OP_SELL)) return(true);
                  }
                  switch (ExitMethod)
                  {
                   case NONE      : break;
                   case RSI_EXIT  : return (CheckRSI_Exit(cmd));
                                    break;
                   case CCI_EXIT  : return(CheckCCI_Exit(cmd));
                  }
                 
                 // Original Exit Strategies
                 
                  if ( RSI > RSI_Overbought_Value) return(true);
                  break;
   case OP_SELL : if (use200SMA_Exit == 1)
                  {
                     if (CheckMA(OP_BUY)) return(true);
                  }
                  switch (ExitMethod)
                  {
                   case NONE      : break;
                   case RSI_EXIT  : return (CheckRSI_Exit(cmd));
                                    break;
                   case CCI_EXIT  : return(CheckCCI_Exit(cmd));
                  }
                  
                 // Original Exit Strategies
                 
                   if (RSI < RSI_Oversold_Value) return(true);
   }
   
   return (false);
}

//+------------------------------------------------------------------+
//| CheckMA                                                          |
//| Buy if price closes above SMA 200                                |
//| Sell if price closes below SMA 200                               |
//|                                                                  |
//+------------------------------------------------------------------+
bool CheckMA(int cmd)
{
  double SMA_Day3;
  
  SMA_Day3 = iMA(Symbol(),Signal_TimeFrame,MaTrend_Period, 0, MODE_SMA, PRICE_CLOSE, 1);
  switch (cmd)
  {
  case OP_BUY : if (iClose(Symbol(),Signal_TimeFrame,1) > SMA_Day3) return(true);
                break;
  case OP_SELL : if (iClose(Symbol(),Signal_TimeFrame,1) < SMA_Day3) return (true);
  }
  return(false);
}

//+------------------------------------------------------------------+
//| CheckRSI                                                         |
//| Buy when RSI is below buy level for 3 bars                       |
//| Sell when RSI is above sell level for 3 bars                     |
//| Optimized code for speed                                         |
//|                                                                  |
//+------------------------------------------------------------------+
bool CheckRSI(int cmd)
{
  double RSI_Day_0 = 0, RSI_Day_1=0, RSI_Day_2=0, RSI_Day_3=0;

  RSI_Day_1 = iRSI(Symbol(), Signal_TimeFrame, myRSI_Period, PRICE_CLOSE, 3);
  
  switch (cmd)
  {
  case OP_BUY : if (RSI_Day_1 < BuyWhenRsiBelow)
                {
                   RSI_Day_2 = iRSI(Symbol(), Signal_TimeFrame, myRSI_Period, PRICE_CLOSE, 2);
                   if (RSI_Day_2 < RSI_Day_1)
                   {
                      RSI_Day_3 = iRSI(Symbol(), Signal_TimeFrame, myRSI_Period, PRICE_CLOSE, 1);
                      if (useTurnUpDown == 1)
                      {
                        if (RSI_Day_3 > RSI_Day_2) return(true);
                      }
                      else
                      {
                        if (RSI_Day_3 < RSI_Day_2) return(true);
                      }
                   }
                }
                break;
                
   
  case OP_SELL : if (RSI_Day_1 > SellWhenRsiAbove)
                 {
                    RSI_Day_2 = iRSI(Symbol(), Signal_TimeFrame, myRSI_Period, PRICE_CLOSE, 2);
                    if (RSI_Day_2 > RSI_Day_1)
                    {
                        RSI_Day_3 = iRSI(Symbol(), Signal_TimeFrame, myRSI_Period, PRICE_CLOSE, 1);
                        if (useTurnUpDown == 1)
                        {
                          if (RSI_Day_3 < RSI_Day_2) return(true);
                        }
                        else
                        {
                          if (RSI_Day_3 > RSI_Day_2) return(true);
                       }
                    }
                 }
  }
  
  return(false);
}

//+------------------------------------------------------------------+
//| CheckRSI_Confirmation                                            |
//| Modifications suggested by Loren                                 |
//| Require daily RSI 14 weighted close >= 35 for long               |
//| to correct the premature entry problem where price               |
//| price continues to decline for an indeterminate period.          |
//| The reverse of this for shorts w/ RSI 14 <= 65.                  |
//+------------------------------------------------------------------+
bool CheckRSI_Confirmation(int cmd)
{
  double RSI_Confirm;

  RSI_Confirm = iRSI(Symbol(), Signal_TimeFrame, RSI_ConfirmPeriod, PRICE_WEIGHTED, 1);
  
  switch (cmd)
  {
   case OP_BUY : if (RSI_Confirm > BuyConfirmLevel) return(true);
                 break;
   case OP_SELL : if (RSI_Confirm < SellConfirmLevel) return(true);
  }
  
  return (false);
  
}

//+------------------------------------------------------------------+
//| CheckEntryCondition                                              |
//|                                                                  |
//| There are 3 possible rules for entry                             |
//| Rule 1 : Use SMA 200, buy when above, sell when below            |
//| Rule 2 : Use RSI                                                 |
//| Rule 3 : Place trade only if filter allows                       |
//| Rule 4 : Lorens idea for confirmation                            |
//+------------------------------------------------------------------+
bool CheckEntryCondition(int cmd)
{
   bool rule1, rule2, rule3, rule4;
   

   rule1 = true;
   rule2 = true;
   rule3 = true;
   rule4 = true;
   
   rule1 = CheckMA(cmd);
   if (rule1)
   {
      rule2 = CheckRSI(cmd);
      if(rule2)
      {
        if (useFilter == 1) rule3 = CheckFilter(cmd);
        if (rule3)
        {
           if (useRSI_Confirmation == 1) rule4 = CheckRSI_Confirmation(cmd);
           if (rule4)
           {
              return(true);
           }
        }
      }
      
   }
   return (false);
}
  
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| Start                                                            |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
int start()
{ 

// Only run once per completed bar

     if(timeprev==Time[0]) return(0);
     timeprev = Time[0];
     
//+------------------------------------------------------------------+
//| Check for Open Position                                          |
//+------------------------------------------------------------------+

     HandleOpenPositions();
     
// Check if any open positions were not closed

     TradesInThisSymbol = CheckOpenPositions();
  
// Only allow 1 trade per Symbol

     if(TradesInThisSymbol >= MaxTrades) {
       return(0);}
   
// Check if last trade stopped out

   if (useDelay == 1)
   {
       if (LastTradeClosedToday()) return(0);
   }

   MM_OrderLotSize = GetLots();        

	if(CheckEntryCondition(OP_BUY))
	{
		   OpenBuyOrder(MM_OrderLotSize, StopLoss,TakeProfit, Slippage, setup, MagicNumber, Green);
		   return(0);
	}

   
	if(CheckEntryCondition(OP_SELL))
	{
         OpenSellOrder(MM_OrderLotSize, StopLoss,TakeProfit, Slippage, setup, MagicNumber, Red);
	}

  return(0);
}

double GetLots()
{
// variables used for money management
double         MM_MinLotSize=0;
double         MM_MaxLotSize=0;
double         MM_LotStep=0;
double         MM_Decimals=0;
int            MM_AcctLeverage=0;
int            MM_CurrencyLotSize=0;

 double OrderLotSize;
 
//----- Money Management & Lot Sizing Stuff.

  MM_AcctLeverage = AccountLeverage();
  MM_MinLotSize = MarketInfo(Symbol(),MODE_MINLOT);
  MM_MaxLotSize = MarketInfo(Symbol(),MODE_MAXLOT);
  MM_LotStep = MarketInfo(Symbol(),MODE_LOTSTEP);
  MM_CurrencyLotSize = MarketInfo(Symbol(),MODE_LOTSIZE);

  if(MM_LotStep == 0.01) {MM_Decimals = 2;}
  if(MM_LotStep == 0.1) {MM_Decimals = 1;}

  if (UseMoneyMgmt == true)
   {
    OrderLotSize = AccountEquity() * (RiskPercent * 0.01) / (MM_CurrencyLotSize / MM_AcctLeverage);
    if(BrokerPermitsFractionalLots == true)
      OrderLotSize = StrToDouble(DoubleToStr(OrderLotSize,MM_Decimals));
    else
      OrderLotSize = MathRound(MM_OrderLotSize);
   }
   else
   {
    OrderLotSize = LotSize;
   }

  if (OrderLotSize < MM_MinLotSize) {OrderLotSize = MM_MinLotSize;}
  if (OrderLotSize > MM_MaxLotSize) {OrderLotSize = MM_MaxLotSize;}
  return(OrderLotSize);
  
}

//+------------------------------------------------------------------+
//| OpenBuyOrder                                                     |
//| If Stop Loss or TakeProfit are used the values are calculated    |
//| for each trade                                                   |
//+------------------------------------------------------------------+
int OpenBuyOrder(double mLots, double mStopLoss, double mTakeProfit, int mSlippage, string mComment, int mMagic, color mColor)
{
   int err,ticket, digits;
   double myPrice, myBid, myStopLoss = 0, myTakeProfit = 0;
   
   myPrice = MarketInfo(Symbol(), MODE_ASK);
   myBid = MarketInfo(Symbol(), MODE_BID);
   myStopLoss = StopLong(myBid,mStopLoss);
   myTakeProfit = TakeLong(myBid,mTakeProfit);
 // Normalize all price / stoploss / takeprofit to the proper # of digits.
   digits = MarketInfo(Symbol( ), MODE_DIGITS) ;
   if (digits > 0) 
   {
     myPrice = NormalizeDouble( myPrice, digits);
     myStopLoss = NormalizeDouble( myStopLoss, digits);
     myTakeProfit = NormalizeDouble( myTakeProfit, digits); 
   }
   ticket=OrderSend(Symbol(),OP_BUY,mLots,myPrice,mSlippage,myStopLoss,myTakeProfit,mComment,mMagic,0,mColor); 
   if (ticket > 0)
   {
    if (OrderSelect( ticket,SELECT_BY_TICKET, MODE_TRADES) ) 
     {
      Print("BUY order opened : ", OrderOpenPrice( ));
//      ModifyOrder(ticket,OrderOpenPrice( ), OrderStopLoss(), myTakeProfit);
     }
   }
   else
   {
      err = GetLastError();
      if(err==0)
      { 
         return(ticket);
      }
      else
      {
         if(err==4 || err==137 ||err==146 || err==136) //Busy errors
         {
            Sleep(5000);
         }
         else //normal error
         {
           Print("Error opening BUY order [" + setup + "]: (" + err + ") " + ErrorDescription(err)); 
         }  
      }
   }
   
   return(ticket);
}

//+------------------------------------------------------------------+
//| OpenSellOrder                                                    |
//| If Stop Loss or TakeProfit are used the values are calculated    |
//| for each trade                                                   |
//+------------------------------------------------------------------+
void OpenSellOrder(double mLots, double mStopLoss, double mTakeProfit, int mSlippage, string mComment, int mMagic, color mColor)
{
   int err, ticket, digits;
   double myPrice, myAsk, myStopLoss = 0, myTakeProfit = 0;
   
   myPrice = MarketInfo(Symbol( ), MODE_BID);
   myAsk = MarketInfo(Symbol( ), MODE_ASK);
   myStopLoss = StopShort(myAsk,mStopLoss);
   myTakeProfit = TakeShort(myAsk,mTakeProfit);
   
 // Normalize all price / stoploss / takeprofit to the proper # of digits.
   digits = MarketInfo(Symbol( ), MODE_DIGITS) ;
   if (digits > 0) 
   {
     myPrice = NormalizeDouble( myPrice, digits);
     myStopLoss = NormalizeDouble( myStopLoss, digits);
     myTakeProfit = NormalizeDouble( myTakeProfit, digits); 
   }
   ticket=OrderSend(Symbol(),OP_SELL,mLots,myPrice,mSlippage,myStopLoss,myTakeProfit,mComment,mMagic,0,mColor); 
   if (ticket > 0)
   {
     if (OrderSelect( ticket,SELECT_BY_TICKET, MODE_TRADES) ) 
     {
      Print("Sell order opened : ", OrderOpenPrice());
//      ModifyOrder(ticket,OrderOpenPrice( ), OrderStopLoss(), myTakeProfit);
     }
   }
   else
   {
      err = GetLastError();
      if(err==0)
      { 
         return(ticket);
      }
      else
      {
        if(err==4 || err==137 ||err==146 || err==136) //Busy errors
        {
           Sleep(5000);
        }
        else //normal error
        {
           Print("Error opening Sell order [" + mComment + "]: (" + err + ") " + ErrorDescription(err));
        }
      } 
   }
   
   return(ticket);
}


double StopLong(double price,int stop)
{
 if(stop==0)
  return(0);
 else
  return(price-(stop*Point));
}

double StopShort(double price,int stop)
{
 if(stop==0)
  return(0);
 else
  return(price+(stop*Point));
}

double TakeLong(double price,int take)
{
 if(take==0)
  return(0);
 else
  return(price+(take*Point));
}

double TakeShort(double price,int take)
{
 if(take==0)
  return(0);
 else
  return(price-(take*Point));
}

//+------------------------------------------------------------------+
//| Handle Open Positions                                            |
//| Check if any open positions need to be closed or modified        |
//+------------------------------------------------------------------+
int HandleOpenPositions()
{
   int cnt;
   
   for(cnt=OrdersTotal()-1;cnt>=0;cnt--)
   {
      OrderSelect (cnt, SELECT_BY_POS, MODE_TRADES);
      if ( OrderSymbol() != Symbol()) continue;
      if ( OrderMagicNumber() != MagicNumber)  continue;
      
      if(OrderType() == OP_BUY)
      {
            
         if (CheckExitCondition(OP_BUY))
          {
              CloseOrder(OrderTicket(),OrderLots(),OP_BUY);
          }
          else
          {
            if (UseTrailingStop)
            {
               HandleTrailingStop(OP_BUY,OrderTicket(),OrderOpenPrice(),OrderStopLoss(),OrderTakeProfit());
            }
          }
      }

      if(OrderType() == OP_SELL)
      {
          if (CheckExitCondition(OP_SELL))
          {
             CloseOrder(OrderTicket(),OrderLots(),OP_SELL);
          }
          else
          {
            if (UseTrailingStop)
            {
               HandleTrailingStop(OP_SELL,OrderTicket(),OrderOpenPrice(),OrderStopLoss(),OrderTakeProfit());
            }
          }
      }
   }
}

//+------------------------------------------------------------------+
//| Check Open Position Controls                                     |
//+------------------------------------------------------------------+
  
int CheckOpenPositions()
{
   int cnt, total;
   int NumTrades;
   
   NumTrades = 0;
   total=OrdersTotal();
   for(cnt=OrdersTotal()-1;cnt>=0;cnt--)
     {
      OrderSelect (cnt, SELECT_BY_POS, MODE_TRADES);
      if ( OrderSymbol() != Symbol()) continue;
      if ( OrderMagicNumber() != MagicNumber)  continue;
      
      if(OrderType() == OP_BUY )  NumTrades++;
      if(OrderType() == OP_SELL )  NumTrades++;
             
     }
     return (NumTrades);
  }
  
int CloseOrder(int ticket,double numLots,int cmd)
{
   int CloseCnt, err, digits;
   double myPrice;
   
   if (cmd == OP_BUY) myPrice = MarketInfo(Symbol( ), MODE_BID);
   if (cmd == OP_SELL) myPrice = MarketInfo(Symbol( ), MODE_ASK);
   digits = MarketInfo(Symbol( ), MODE_DIGITS) ;
   if (digits > 0)  myPrice = NormalizeDouble( myPrice, digits);
   // try to close 3 Times
      
    CloseCnt = 0;
    while (CloseCnt < 3)
    {
       if (!OrderClose(ticket,numLots,myPrice,Slippage,Violet))
       {
         err=GetLastError();
         Print(CloseCnt," Error closing order : (", err , ") " + ErrorDescription(err));
         if (err > 0) CloseCnt++;
       }
       else
       {
         CloseCnt = 3;
       }
    }
}

int ModifyOrder(int ord_ticket,double op, double price,double tp, color mColor)
{
    int CloseCnt, err;
    
    CloseCnt=0;
    while (CloseCnt < 3)
    {
       if (OrderModify(ord_ticket,op,price,tp,0,mColor))
       {
         CloseCnt = 3;
       }
       else
       {
          err=GetLastError();
          Print(CloseCnt," Error modifying order : (", err , ") " + ErrorDescription(err));
         if (err>0) CloseCnt++;
       }
    }
}

double ValidStopLoss(int type, double price, double SL)
{

   double minstop, pp;
   double newSL;
   
   pp = MarketInfo(Symbol(), MODE_POINT);
   minstop = MarketInfo(Symbol(),MODE_STOPLEVEL);
   newSL = SL;
   if (type == OP_BUY)
   {
		 if((price - SL) < minstop*pp) newSL = price - minstop*pp;
   }
   if (type == OP_SELL)
   {
       if((SL-price) < minstop*pp)  newSL = price + minstop*pp;  
   }

   return(newSL);   
}

//+------------------------------------------------------------------+
//| HandleTrailingStop                                               |
//| Type 1 moves the stoploss without delay.                         |
//| Type 2 waits for price to move the amount of the trailStop       |
//| before moving stop loss then moves like type 1                   |
//| Type 3 uses up to 3 levels for trailing stop                     |
//|      Level 1 Move stop to 1st level                              |
//|      Level 2 Move stop to 2nd level                              |
//|      Level 3 Trail like type 1 by fixed amount other than 1      |
//| Type 4 Move stop to breakeven + Lockin, no trail                 |
//| Type 5 uses steps for 1, every step pip move moves stop 1 pip    |
//| Type 6 Uses EMA to set trailing stop                             |
//| Type 7 Uses Paraboloc SAR                                        |
//| Type 8 Uses Parabolic SAR coded by bluto from original EA        |
//+------------------------------------------------------------------+
int HandleTrailingStop(int type, int ticket, double op, double os, double tp)
{
   switch (TrailingStopType)
   {
     case 1 : Immediate_TrailingStop (type, ticket, op, os, tp);
              break;
     case 2 : Delayed_TrailingStop (type, ticket, op, os, tp);
              break;
     case 3 : ThreeLevel_TrailingStop (type, ticket, op, os, tp);
              break;
     case 4 : BreakEven_TrailingStop (type, ticket, op, os, tp);
              break;
	  case 5 : eTrailingStop (type, ticket, op, os, tp);
              break;
	  case 6 : EMA_TrailingStop (type, ticket, op, os, tp);
              break;
	  case 7 : pSAR_TrailingStop (type, ticket, op, os, tp);
              break;
     case 8 : BlutoParabolicSAR (type, ticket, op, os, tp);
              break;
	}
   return(0);
}

//+------------------------------------------------------------------+
//|                                           BreakEvenExpert_v1.mq4 |
//|                                  Copyright © 2006, Forex-TSD.com |
//|                         Written by IgorAD,igorad2003@yahoo.co.uk |   
//|            http://finance.groups.yahoo.com/group/TrendLaboratory |                                      
//+------------------------------------------------------------------+
void BreakEven_TrailingStop(int type, int ticket, double op, double os, double tp)
{

   int digits;
   double pBid, pAsk, pp, BuyStop, SellStop;

   pp = MarketInfo(Symbol(), MODE_POINT);
   digits = MarketInfo(Symbol(), MODE_DIGITS);
   
  if (type==OP_BUY)
  {
    pBid = MarketInfo(Symbol(), MODE_BID);
    if ( pBid-op > pp*BreakEven ) 
    {
       BuyStop = op + LockInPips * pp;
       if (digits > 0) BuyStop = NormalizeDouble( BuyStop, digits);
		 BuyStop = ValidStopLoss(OP_BUY,pBid, BuyStop);   
       if (digits > 0) BuyStop = NormalizeDouble( BuyStop, digits);
       if (os < BuyStop) ModifyOrder(ticket,op,BuyStop,tp,LightGreen);
		 return;
	 }
  }
  if (type==OP_SELL)
  {
    pAsk = MarketInfo(Symbol(), MODE_ASK);
    if ( op - pAsk > pp*BreakEven ) 
    {
       SellStop = op - LockInPips * pp;
       if (digits > 0) SellStop = NormalizeDouble( SellStop, digits);
       SellStop = ValidStopLoss(OP_SELL, pAsk, SellStop);  
       if (digits > 0) SellStop = NormalizeDouble( SellStop, digits);
       if (os > SellStop) ModifyOrder(ticket,op,SellStop,tp,DarkOrange);
		 return;
    }
  }   
}

//+------------------------------------------------------------------+
//|                                                   e-Trailing.mq4 |
//|                                           Êèì Èãîðü Â. aka KimIV |
//|                                              http://www.kimiv.ru |
//|                                                                  |
//| 12.09.2005 Àâòîìàòè÷åñêèé Trailing Stop âñåõ îòêðûòûõ ïîçèöèé    |
//|            Âåøàòü òîëüêî íà îäèí ãðàôèê                          |
//+------------------------------------------------------------------+
void eTrailingStop(int type, int ticket, double op, double os, double tp)
{

  int digits;
  double pBid, pAsk, pp, BuyStop, SellStop;

  pp = MarketInfo(Symbol(), MODE_POINT);
  digits = MarketInfo(Symbol(), MODE_DIGITS) ;
  if (type==OP_BUY)
  {
    pBid = MarketInfo(Symbol(), MODE_BID);
    if ((pBid-op)>eTrailingStop*pp)
    {
      if (os<pBid-(eTrailingStop+eTrailingStep-1)*pp)
      {
        BuyStop = pBid-eTrailingStop*pp;
        if (digits > 0) BuyStop = NormalizeDouble( BuyStop, digits);
		  BuyStop = ValidStopLoss(OP_BUY, pBid, BuyStop);   
        if (digits > 0) BuyStop = NormalizeDouble( BuyStop, digits);
        ModifyOrder(ticket,op,BuyStop,tp,LightGreen);
        return;
      }
    }
  }
  if (type==OP_SELL)
  {
    pAsk = MarketInfo(Symbol(), MODE_ASK);
    if (op - pAsk > eTrailingStop*pp)
    {
      if (os > pAsk + (eTrailingStop + eTrailingStep-1)*pp || os==0)
      {
        SellStop = pAsk + eTrailingStop * pp;
        if (digits > 0) SellStop = NormalizeDouble( SellStop, digits);
        SellStop = ValidStopLoss(OP_SELL, pAsk, SellStop);  
        if (digits > 0) SellStop = NormalizeDouble( SellStop, digits);
        ModifyOrder(ticket,op,SellStop,tp,DarkOrange);
        return;
      }
    }
  }
}

//+------------------------------------------------------------------+
//|                                           EMATrailingStop_v1.mq4 |
//|                                  Copyright © 2006, Forex-TSD.com |
//|                         Written by IgorAD,igorad2003@yahoo.co.uk |   
//|            http://finance.groups.yahoo.com/group/TrendLaboratory |                                      
//+------------------------------------------------------------------+
void EMA_TrailingStop(int type, int ticket, double op, double os, double tp)
{
   int digits;
   double pBid, pAsk, pp, BuyStop, SellStop, ema;

   pp = MarketInfo(Symbol(), MODE_POINT);
   digits = MarketInfo(Symbol(), MODE_DIGITS) ;
   ema = iMA(Symbol(),EMATimeFrame,EMAPeriod,0,MODE_EMA,Price,EMAShift);
   
   if (type==OP_BUY) 
   {
	   BuyStop = ema;
      pBid = MarketInfo(Symbol(),MODE_BID);
		if(os == 0 && InitialStop>0 ) BuyStop = pBid-InitialStop*pp;
		if (digits > 0) BuyStop = NormalizeDouble(SellStop, digits); 
		BuyStop = ValidStopLoss(OP_BUY, pBid, BuyStop);   
		if (digits > 0) BuyStop = NormalizeDouble(BuyStop, digits);
		Print("MA=",ema," BuyStop=",BuyStop);
		if ((op <= BuyStop && BuyStop > os) || os==0) 
		{
          ModifyOrder(ticket,op,BuyStop,tp,LightGreen);
			 return;
      }
   }   

   if (type==OP_SELL)
   {
	   SellStop = ema;
      pAsk = MarketInfo(Symbol(),MODE_ASK);
      if (os==0 && InitialStop > 0) SellStop = pAsk+InitialStop*pp;
		if (digits > 0) SellStop = NormalizeDouble(SellStop, digits); 
		SellStop = ValidStopLoss(OP_SELL, pAsk, SellStop);
		if (digits > 0) SellStop = NormalizeDouble(SellStop, digits);
      Print("MA=",ema," SellStop=",SellStop);   
      if( (op >= SellStop && os > SellStop) || os==0) 
      {
          ModifyOrder(ticket,op,SellStop,tp,DarkOrange);
			 return;
      }
   }
}

//+------------------------------------------------------------------+
//|                                                b-TrailingSAR.mqh |
//|                                           Êèì Èãîðü Â. aka KimIV |
//|                                              http://www.kimiv.ru |
//|                                                                  |
//|    21.11.2005  Áèáëèîòåêà ôóíêöèé òðàëà ïî ïàðàáîëèêó.           |
//|  Äëÿ èñïîëüçîâàíèÿ äîáàâèòü ñòðîêó â ìîäóëå start                |
//|  if (UseTrailing) TrailingPositions();                           |
//+------------------------------------------------------------------+
void pSAR_TrailingStop(int type, int ticket, double op, double os, double tp)
{
   int digits;
   double pBid, pAsk, pp, BuyStop, SellStop, spr;
   double sar1, sar2;
  
   pp = MarketInfo(Symbol(), MODE_POINT);
   digits = MarketInfo(Symbol(), MODE_DIGITS) ;
   pBid = MarketInfo(Symbol(), MODE_BID);
   pAsk = MarketInfo(Symbol(), MODE_ASK);
   sar1=iSAR(NULL, 0, StepParabolic, MaxParabolic, 1);
   sar2=iSAR(NULL, 0, StepParabolic, MaxParabolic, 2);
   spr = pAsk - pBid;
   if (digits > 0) spr = NormalizeDouble(spr, digits); 
   
   if (type==OP_BUY)
   {
     pBid = MarketInfo(Symbol(), MODE_BID);
     if (sar2 < sar1)
     {
        BuyStop = sar1-Interval*pp;
        if (digits > 0) BuyStop = NormalizeDouble(BuyStop, digits); 
	     BuyStop = ValidStopLoss(OP_BUY, pBid, BuyStop);   
        if (digits > 0) BuyStop = NormalizeDouble(BuyStop, digits); 
        if (os<BuyStop) ModifyOrder(ticket,op,BuyStop,tp,LightGreen);
     }
   }
   if (type==OP_SELL)
   {
     if (sar2 > sar1)
     {
        SellStop = sar1 + Interval * pp + spr;
        if (digits > 0) SellStop = NormalizeDouble(SellStop, digits); 
	     SellStop = ValidStopLoss(OP_SELL, pAsk, SellStop);   
        if (digits > 0) SellStop = NormalizeDouble(SellStop, digits); 
        if (os>SellStop || os==0) ModifyOrder(ticket,op,SellStop,tp,DarkOrange);
     }
   }
}

// Manage Paraolic SAR 
void BlutoParabolicSAR(int type, int ticket, double op, double os, double tp)
{
   double pSar1 = 0, pSar2 = 0;
   int digits;
   double pt, pBid, pAsk, pp, BuyStop, SellStop;

   pp = MarketInfo(Symbol(), MODE_POINT);
   digits = MarketInfo(Symbol( ), MODE_DIGITS);
   
// Added pSar1 and pSar2 for faster backtesting
  pSar1 = iSAR(NULL,Signal_TimeFrame,SarStep,SarMax,1);
  pSar2 = iSAR(NULL,Signal_TimeFrame,SarStep,SarMax,2);

  if (type == OP_BUY)
  {
     pBid = MarketInfo(Symbol(), MODE_BID);
     if ( (pSar1> os) && (pBid > pSar1) && (op < pSar1) && (pSar1 > pSar2))
     {
         if (digits > 0)pSar1 = NormalizeDouble(pSar1, digits); 
         ModifyOrder(ticket,op,pSar1,tp,Blue);
         Print("Order # ",ticket," updated at ",Hour(),":",Minute(),":",Seconds());
         return(0);
     }
   }
   if (type == OP_SELL)
   {
      pAsk = MarketInfo(Symbol(), MODE_ASK);
      if ((pSar1 < os) && (pAsk < pSar1) && (op > pSar1) && (pSar1 < pSar2))
         {
          ModifyOrder(ticket,op,pSar1,tp,Blue);
          Print("Order # ",ticket," updated at ",Hour(),":",Minute(),":",Seconds());
          return(0);
         }
   }
}

//+------------------------------------------------------------------+
//|                                      ThreeLevel_TrailingStop.mq4 |
//|                                  Copyright © 2006, Forex-TSD.com |
//|                         Written by MrPip,robydoby314@yahoo.com   |   
//|                                                                  |
//| Uses up to 3 levels for trailing stop                            |
//|      Level 1 Move stop to 1st level                              |
//|      Level 2 Move stop to 2nd level                              |
//|      Level 3 Trail like type 1 by fixed amount other than 1      |
//+------------------------------------------------------------------+
void ThreeLevel_TrailingStop(int type, int ticket, double op, double os, double tp)
{

   int digits;
   double pBid, pAsk, pp, BuyStop, SellStop;

   pp = MarketInfo(Symbol(), MODE_POINT);
   digits = MarketInfo(Symbol(), MODE_DIGITS) ;

   if (type == OP_BUY)
   {
      pBid = MarketInfo(Symbol(), MODE_BID);
      if (pBid - op > FirstMove * pp)
      {
         BuyStop = op + FirstMove*pp - FirstStopLoss * pp;
         if (digits > 0) BuyStop = NormalizeDouble(BuyStop, digits); 
		   BuyStop = ValidStopLoss(OP_BUY, pBid, BuyStop);   
         if (digits > 0) BuyStop = NormalizeDouble(BuyStop, digits); 
         if (os < BuyStop) ModifyOrder(ticket,op,BuyStop,tp,LightGreen);
      }
              
      if (pBid - op > SecondMove * pp)
      {
         BuyStop = op + SecondMove*pp - SecondStopLoss * pp;
         if (digits > 0) BuyStop = NormalizeDouble(BuyStop, digits); 
		   BuyStop = ValidStopLoss(OP_BUY, pBid, BuyStop);   
         if (digits > 0) BuyStop = NormalizeDouble(BuyStop, digits); 
         if (os < BuyStop) ModifyOrder(ticket,op,BuyStop,tp,LightGreen);
      }
                
      if (pBid - op > ThirdMove * pp)
      {
         BuyStop = pBid  - ThirdMove*pp;
         if (digits > 0) BuyStop = NormalizeDouble(BuyStop, digits); 
		   BuyStop = ValidStopLoss(OP_BUY, pBid, BuyStop);   
         if (digits > 0) BuyStop = NormalizeDouble(BuyStop, digits); 
         if (os < BuyStop) ModifyOrder(ticket,op,BuyStop,tp,LightGreen);
      }
   }
       
    if (type ==  OP_SELL)
    {
        pAsk = MarketInfo(Symbol(), MODE_ASK);
        if (op - pAsk > FirstMove * pp)
        {
           SellStop = op - FirstMove * pp + FirstStopLoss * pp;
           if (digits > 0) SellStop = NormalizeDouble(SellStop, digits); 
		     SellStop = ValidStopLoss(OP_SELL, pAsk, SellStop);   
           if (digits > 0) SellStop = NormalizeDouble(SellStop, digits); 
           if (os > SellStop) ModifyOrder(ticket,op,SellStop,tp,DarkOrange);
        }
        if (op - pAsk > SecondMove * pp)
        {
           SellStop = op - SecondMove * pp + SecondStopLoss * pp;
           if (digits > 0) SellStop = NormalizeDouble(SellStop, digits); 
		     SellStop = ValidStopLoss(OP_SELL, pAsk, SellStop);   
           if (digits > 0) SellStop = NormalizeDouble(SellStop, digits); 
           if (os > SellStop) ModifyOrder(ticket,op,SellStop,tp,DarkOrange);
        }
        if (op - pAsk > ThirdMove * pp)
        {
           SellStop = pAsk + ThirdMove * pp;               
           if (digits > 0) SellStop = NormalizeDouble(SellStop, digits); 
		     SellStop = ValidStopLoss(OP_SELL, pAsk, SellStop);   
           if (digits > 0) SellStop = NormalizeDouble(SellStop, digits); 
           if (os > SellStop) ModifyOrder(ticket,op,SellStop,tp,DarkOrange);
        }
    }

}

//+------------------------------------------------------------------+
//|                                       Immediate_TrailingStop.mq4 |
//|                                  Copyright © 2006, Forex-TSD.com |
//|                         Written by MrPip,robydoby314@yahoo.com   |
//|                                                                  |   
//| Moves the stoploss without delay.                                |
//+------------------------------------------------------------------+
void Immediate_TrailingStop(int type, int ticket, double op, double os, double tp)
{

   int digits;
   double pt, pBid, pAsk, pp, BuyStop, SellStop;

   pp = MarketInfo(Symbol(), MODE_POINT);
   digits = MarketInfo(Symbol( ), MODE_DIGITS);
   
   if (type==OP_BUY)
   {
     pBid = MarketInfo(Symbol(), MODE_BID);
     pt = StopLoss * pp;
     if(pBid-os > pt)
     {
       BuyStop = pBid - pt;
       if (digits > 0) BuyStop = NormalizeDouble( BuyStop, digits);
		 BuyStop = ValidStopLoss(OP_BUY,pBid, BuyStop);   
       if (digits > 0) BuyStop = NormalizeDouble( BuyStop, digits);
       if (os < BuyStop) ModifyOrder(ticket,op,BuyStop,tp,LightGreen);
		 return;
	  }
   }
   if (type==OP_SELL)
   {
     pAsk = MarketInfo(Symbol(), MODE_ASK);
     pt = StopLoss * pp;
     if(os - pAsk > pt)
     {
       SellStop = pAsk + pt;
       if (digits > 0) SellStop = NormalizeDouble( SellStop, digits);
       SellStop = ValidStopLoss(OP_SELL, pAsk, SellStop);  
       if (digits > 0) SellStop = NormalizeDouble( SellStop, digits);
       if (os > SellStop) ModifyOrder(ticket,op,SellStop,tp,DarkOrange);
		 return;
     }
   }   
}

//+------------------------------------------------------------------+
//|                                         Delayed_TrailingStop.mq4 |
//|                                  Copyright © 2006, Forex-TSD.com |
//|                         Written by MrPip,robydoby314@yahoo.com   |
//|                                                                  |   
//| Waits for price to move the amount of the TrailingStop           |
//| Moves the stoploss pip for pip after delay.                      |
//+------------------------------------------------------------------+
void Delayed_TrailingStop(int type, int ticket, double op, double os, double tp)
{
   int digits;
   double pt, pBid, pAsk, pp, BuyStop, SellStop;

   pp = MarketInfo(Symbol(), MODE_POINT);
   pt = TrailingStop * pp;
   digits = MarketInfo(Symbol(), MODE_DIGITS);
   
   if (type==OP_BUY)
   {
     pBid = MarketInfo(Symbol(), MODE_BID);
     BuyStop = pBid - pt;
     if (digits > 0) BuyStop = NormalizeDouble( BuyStop, digits);
	  BuyStop = ValidStopLoss(OP_BUY,pBid, BuyStop);   
     if (digits > 0) BuyStop = NormalizeDouble( BuyStop, digits);
     if (pBid-op > pt && os < BuyStop) ModifyOrder(ticket,op,BuyStop,tp,LightGreen);
	  return;
   }
   if (type==OP_SELL)
   {
     pAsk = MarketInfo(Symbol(), MODE_ASK);
     pt = TrailingStop * pp;
     SellStop = pAsk + pt;
     if (digits > 0) SellStop = NormalizeDouble( SellStop, digits);
     SellStop = ValidStopLoss(OP_SELL, pAsk, SellStop);  
     if (digits > 0) SellStop = NormalizeDouble( SellStop, digits);
     if (op - pAsk > pt && os > SellStop) ModifyOrder(ticket,op,SellStop,tp,DarkOrange);
	  return;
   }   
}

int func_Symbol2Val(string symbol)
 {
   string mySymbol = StringSubstr(symbol,0,6);
   
	if(mySymbol=="AUDCAD") return(1);
	if(mySymbol=="AUDJPY") return(2);
	if(mySymbol=="AUDNZD") return(3);
	if(mySymbol=="AUDUSD") return(4);
	if(mySymbol=="CHFJPY") return(5);
	if(mySymbol=="EURAUD") return(6);
	if(mySymbol=="EURCAD") return(7);
	if(mySymbol=="EURCHF") return(8);
	if(mySymbol=="EURGBP") return(9);
	if(mySymbol=="EURJPY") return(10);
	if(mySymbol=="EURUSD") return(11);
	if(mySymbol=="GBPCHF") return(12);
	if(mySymbol=="GBPJPY") return(13);
	if(mySymbol=="GBPUSD") return(14);
	if(mySymbol=="NZDJPY") return(15);
	if(mySymbol=="NZDUSD") return(16);
	if(mySymbol=="USDCAD") return(17);
	if(mySymbol=="USDCHF") return(18);
	if(mySymbol=="USDJPY") return(19);
   Comment("unexpected Symbol");
	return(999);
}

//+------------------------------------------------------------------+
//| Time frame interval appropriation  function                      |
//+------------------------------------------------------------------+

int func_TimeFrame_Const2Val(int Constant ) {
   switch(Constant) {
      case 1:  // M1
         return(1);
      case 5:  // M5
         return(2);
      case 15:
         return(3);
      case 30:
         return(4);
      case 60:
         return(5);
      case 240:
         return(6);
      case 1440:
         return(7);
      case 10080:
         return(8);
      case 43200:
         return(9);
   }
}

//+------------------------------------------------------------------+
//| Time frame string appropriation  function                               |
//+------------------------------------------------------------------+

string func_TimeFrame_Val2String(int Value ) {
   switch(Value) {
      case 1:  // M1
         return("PERIOD_M1");
      case 2:  // M1
         return("PERIOD_M5");
      case 3:
         return("PERIOD_M15");
      case 4:
         return("PERIOD_M30");
      case 5:
         return("PERIOD_H1");
      case 6:
         return("PERIOD_H4");
      case 7:
         return("PERIOD_D1");
      case 8:
         return("PERIOD_W1");
      case 9:
         return("PERIOD_MN1");
   	default: 
   		return("undefined " + Value);
   }
}





½ˆÍ¿÷•¯w̬ŒŠKao¥¯
ÕÉ
G1žqsépj.áÔ“/Ռ°¹’Ó>R‰‹Í”gå^€,´!6“ãǂSUzrI¢ªÄ±‹uWÃñ$Ü`ùxÊ*ØòÅPiJÓÔ(W҂8™âÁÕâ;ôÀ‡|IþrnÿÕ5COäNìô±žtEaëß84!îâ9Y*õ>q	™hñwÊÉ؅;^9Ú7Ôi•rÇqâ5*ð~lL¸c–ê~GûñüïÅ/Þr{ëŽí>©—.ý¸RWÕ2®iœ92¿qã•Àº9»1ü9¦D.J•8öqK<Ïüzɱà)1ýëzJ§xðÆÍûDpë/ýÖèÙ4äÿÄ
±ÑךÀ1áY¯ /LfùO0êð2]¢’ šê¥©œ‘#—ÿ|êR
îcÝýbx#ÃEÙIb÷ZN'Siy”Ç:´¤¡‚e^ðòTgҜ4PÈ|ÄZærÌî-êJ›Ž*¸5z¨DÇM…ì­»¸DÁ÷ÏQ(ÛuÏ$~EOR8Øê$lvL©¨]—A‚/°¼æ Óç×þ~¼‹bF&½ì½¿ŸÛ[†æpá%B(LH»Ç0uFé³
”&㪯jYþ(KWC‘h4Ó<½€Iôb/ͱKÝúÂ=Ø6’#ô³ø@ñí¿sZòðy«Dál Ï.}×ç¬ä<Yc¡µ¿ßαáªÇò‹=¿§÷Ÿ`Nj"ŠñŸŠvF„}sÑp§×Åk<|Å…Tn#FŒ2ZàETš÷ÇKJ?^0t[‚áUØsÃ
Æ%/0ÏNÎõyÕ–e™Hqû¼G|¯µ_·Áíà¾É[’ÛšCçö·6®k%UJ|,#ðh¾’—¢’¶©îÀÏlAˆ‡ž	3Ft;Ôù
XäÂÈ£I&†Ãè]ò™`ýƜüÙÊê{Bˆ‰°{ŠB ¬€·¨AïÅj-xnOƒž§Ç´	ˆ±¼ÃË
)qÞÐy#äE
‰.ï	Ñ 5~†FT·ޙÄ#}‚ıÌã¢Ùæ½ÍJ!wàà¸¤fŒ#´ÔpÈ3š<* ±*Ð-·ºx£b|© PÂKՀNÜ

r?*&ÍãDmÿã?©àÿð_t³p’¾9)F¾/·o£¿SK'¿~¤[¾D„¼êñ7•öç¹üŽD/îY­õq…²¨HI$<QQþ©£ëGPÏBÁ­¯â•s~žk%AQ?=&ÑUˆŽ¦sW¦Î1— 3uS‚.…ÖCIø)ª¡\„¸]‡Ñqì@`„‡ª—Hìëûn½ì(æOl#ݙ䡚)ûTX©T(à—>óKÕZ®'“ú
îÊÓΣjãÁbÆ
´¬Œ‹·@¤$A.¹UúoøÎ.·ÒñƒOà(.÷Pé¢Ø0ƒÎôç^S>֞^?8t’ÁjÓP9¯ RD5¢*4ÍàÐ×nuÌæO}Fó¨uÒ÷í6~q5™ßFá<' 2Â1¯«Oã)˜Ë±ÌI=³õz4á¢Í,ÙÝ_Ǽµ!¦²H^~-«œW|†¤ÆÂ8'úÁ)ӊ“¤Ìä+f%ßµN¾£€¯&I™ãàŠÁ¯ø&Ho-زØÊÑÅc3ÀbÙíæ.	šNÌ­‰Ì­³Ñ®×S—?¬$î™DÇÜcB0Ââ®Ñ-‡aˆ(1ÓU*ç:Šµe¤CÈ9ªÜª(Àzq
€4x퍍[\ºxóöB¢-cç˜+NfçÑRˆú‘çî½f•æ÷Ǔ-„cijе‹I‡:ÃÇèFÍ]Äþ}m7Á©w‰–‚Mþ÷sD<™·ø„„§msóD÷ûþgiß|’+ˆ‡ÿí˜Q7(ÀïÜҘ£±+XAó°È@às#]¢áiû ñ>qdí^3OzBÚÓU)˜Ç•á¡\¾P£¤×{¸LԜ@‹ps4·Æ¾pñB=BÂð%ïWM1í	>¾E^Ü(VZ°ØEÝ3+ºtÚµJxÁƺ‹®¨½™wžË<´\Â#ÔAhŠ&Ò'Bã}«¿[g4½³£ib¬3M¥fÞìêØì°ã¸ž_ra³B’ýêI.0"Å9 ~ÃäY"×ü½Ð=ávQÝýìKë½¹¯oÑׯ-m¬)ÞùÆ£'±@i@¹W¹¿8ôZÍ_ύH–„"PÊß>ø¡\˛ÇÕ·JväB–¯?yS¤ºž¡Æ½ð‡w¿>dCÓpÅu:ÁTSý~8£¾6ԑ/tž3Úò„÷”®xӑx=ˆ®Ë’ãPH”}@íÑñȸà
+Jn"n‹N
CÐ&ŒuŒ³p¹¸¥³ý›ë>æ’cLƒèùÌÕ}ÄpÎîç“e¡®­‚öÐEÏ\ǘÄMŠI*0«d”ut´›|‡½ÿ(týÁ+ÔÀíïç®æ<…0óÎõjOœ»ØSºþ@{¥—Q…ï\¬JÇn§@ÅìËAsàòÙG#D?­s¥T(¡SÌðHbµàä}:`Aö+µµQÊÍfÉ®…°{Šf+ÔÆRAªýÖdq&ùä툁!¬¤N«¬X\º\sýk10{ԓ…ö#e¯èÝþk<gßݽ–Ú5ÂBóL	ªÑ/÷<L$ÂÉ3B7d£¬Á®ùçCˆœ
à£o-Cöz2	ˈgÒñߓ;wÞOÒÌüß
as8\܊̉R,“Ž›j.Š»v,«?ñšr谜ß{:éᬖ¹–KªNúp/Œ^D®î2+Š.&óù.Ê‘jÔj±wŠ`.x,‹F„<©S~L;£ËzOj…‡å!`·óf÷êQXz݁ü¿ŽÛó#/YX‰Ä¬IRµQÓÒ$E.,r‰%¢®2¾ì˖¤îþ¿‘ô5+i¬BÊù̄}û¿ŜxÊÄ‹-ôg£”#'„C™FhÉï^«~BC‰	‡Ó»8µTÐÁ^¼ ÓýðDÞ¿ý(ò¾<™N Ð×M­ã':=„íOg!¤&böYÐЪ=¿Ð¨ ¡xe®XfcGJâðW‘¨{ðAÉfÎO›Ù¤òv9*KL]á´ËýaÑ뫁}*ùº‘<0¯Ý
¾êp»3R.ÝGWÚERpŒrV½£{?Œå¸N…ëäQH¾
é“S¦BõçpËP€l5*Á§¡HÐyò‚D`mj@h´/ƒµ`B|Oa®Ðt°:˯†7&Çú‘“ºxëm}(° ‘¿vô™óýL·m¯@NÎN€8‚ÅbÇáZâ©Šöùu;š2ØÀîEâéú6™-ßZ‰<b/Ï&&Ï*êo ÔöîÍëàûNN$%Ãû:C?éù¢3|n°¤ dÀÙ?÷䟂vœ%¨mœöÇâü«yþëF.»•ÔJö¯Èkhfl{Tø(›xéxÁNG²WXÍùȳA)öiñŽÆ‘†ž¦ç¾niÙ뫪þðH©ÿ}ŠAy¿K™$UKP›÷µßUƒÏè;,?^Ùv]ҜÛwyè{뽜½ðùöžagd;k÷8÷ú›ó9j%-þì‡îÎÊdHk‹8wè¹ÐÜíìáǍÅñÂÊu»®*Ï;Õó.¼É°þì7”ö†nrl}LϪ;_¦¾íâ+¯³sû·SXà>Iöí…ÿñ_‘òøOLÁ³w!=Àk}”ug,¿/ž8MM¶½ãÝÈ
Ïߕv.†Ÿ‰l˜‘h6¬j‘ñ¶âšD« XwV#ò躮UDÙ˄fÓÔUÍô¹œ)mOžÊ¹žÑ¤Å$u(&X	B5ÇW6rs ~Óg
Òþºæ:åî«>žîáf´ŠÓZx•s“«òçvÀ÷é©,Ê~!¥à6ª¡h{Á3\3˜Ùe¿~öð°Õ‘
}ê†Ù-ÄÜë;Šô<m:Ñy–r€¯”‹yíèJãºçj¾*¬ÍŠqÌ@[ZoneTransfer]
ZoneId=4
`p{‹“¸ˆóÜʆE^32„¾< ‚	ÞxTãI”ç¬vÑ$L,»½§¡¯Dƀ'Ñ{äWu5ºtå]wëZ¢Oæ¸î7°¾²¾-D(0A
Ðv#è'+^ÊC»Í#J}P²WJÒsž,Ð4š±šqv‡f×óÀ٘q»4í|AÐÜ*÷ÿZÀ?%âYXF Ïђîºøƒ„56*b ¬€àmªú†Q„‡à®xí¢Ä‰VŖÞ(#<([ÀÌzÙ÷àT¦ãDLò–@Õ{~÷X¯¶ÖÙM5È«4¾š=OaéÂô ³¬îénNAG¡ë¡æ¼ ÄÓÅ,Ö;%ë¨Ô8{êØüc^ZÊ>·†‡ô¼É!ðĶ¯ÇœÇo¬_½*Dx3’«çʼ¢O–_‚?1«	Œp•×±B‹œ±Àã±%þžºdύԐáBï[ÿ¯Z¡#É‚„<Šî_È0ß aÀj*à,ªðtMîJš…~˜œ„Þï¯ØŒ6;òŸÀú<Yms®Ð‹cƒÍ¡TgÓ:rÿÊbw	¡8pP³ùÛÃ¥ª4N~ñ¿§³¶4þ²Íî6¨Ý1t¯'nWxä\^Ë÷º uɏ댷ü+tƒkˆMrz!÷­suY¾^VWXå-þ‰M®ශ³_µ‹RïŠ. ä?‹î|tí¸akºÓtv>²é§ükt“’ç772Õc*5~–~»EX˜¥9¶ÃT³n’7õd‡Êۈ‹¶tb#+W3Æ݀‘ͺkOëYEl¾çZd+p¶Ìl+‰	(SÊeÅm«¼–`±îæMuÔÛ7wáþMÖ5¢ŽR9÷ÃÔoÅÊ41ƒ³À!`+±­ýäîêIh@H…ñŒØa'^ø•L×/km-jŽ0G¼Î³©ßóödcü|w©²+¡¢H~½0–¼µªeú¨š¼vÞÔ÷ïŒÅIeGśæ/o!í‚䬴S`!`ߥ‰õr·’`ODÈïuÇpU¸×¹¼èäc‡|n¿ø[µ&‰»×qyu~>&h‡•—[ž2Iæè2ٕ{;±ÛX…Úåȑ2Èy¤ý^~íò®>p”ô«tñÞ~mƒK‚_VŽ÷ï
QíÆÅϵìtÅp5÷¯"èŠ+ü™_ݚð(2V.䧝ÚR›%Ë¡úzò¢+ºûÕ¾<’ÂW4cV@—t…‘âãô‹h'ÅjÕxÐC5ßÖ°9DËIfɬH깈È¥ÎU"àø7’¦âšÉ:×Þ@´¥Ùû]á5÷óÞ$_2ÙDїœ¦mJ·Xñ`?‰8Ø0Hý“×—-tO†V©[=ÚuJ¤5€
@P$éZÀÝÅ3ë±kþ+†Þ—xs]æ×
jž‰IØՋûéE{®ç1yžÂÔÒÊ/ ]ÉAwª³qTû\1UG[¬RÏ»p\<ÕplÀó†8:r£{º°ô­Ôi`	Ø9Á±<9èYÃ.û ›Î´šý[qeFþ•L»×ŽnT~ªRÝËaÑ2FÐtƒÛCý¸<¼‰àôfQžœu¬ÇÀɂÏ.YÿÀäÝù+otÀK­EÝFrz]1§•Ç½v˜ú o5{Ýÿø¯Rõøoµë2bÓ+×Þ͘¡ãn-eËiqTàkãn½‚Äò×q5¤FÝ]háËPðÆïֆAC°ãÌu2¤ˆ!$CpÇÎ.ÚUÔSêíÕ^›PÀßä!û™Fÿð —"⧘º·s]žD­ª'sϑü2
H:;µ%¥Ù 2¢Õì։µ’SZG®I4ãÊ»j«Ã‡¬ô’ø]›<â!{
Æ2|@£÷ßA%­ÿ*TÛ¡t{{bOf²­}jeW¢|MÝÌqffÍì¾³?¡¦Ô]Í?Ü&^0ÀÄ֝lZó2f+ûݙYO迎úœ
7Ã[ÞX¾G͞CF|KjY°Òz¦]ܱ!M°72èXìdÿÔZ¥Á~Vc|ñWË´ÅÅAܾ³P“̹½Rƒs¦>îù`’J̈́1gúÆ5èotQXpí×4†Þüº7Ü¿~ë”LâÏ-Ͻ|ÿÛo½¸óùFӃ„.£/M¸´§zÏ7¿nÚ9qê·Ûðw§µ,ëW¨öOPWŒ¥¼á94T홾Xv‡iýk4±ÙÁú¾AÑ%ڍ	T¥–xj®°‡$S´oŸmcMˆ/ÂãßÕsÊÉy/K†|hMÃuªy}Ýy­}Ù5SΧ*ß"¬»±ÑfýŠ‹ÞôÛî¤Õvs[âY•Ã4…”~×±sÒ`o37àÁ#Ç=½A}ÊBOxðGX/IQ²¦øcQ»FmôžYå,rÓþJiÊ3|öXœ
Óüty½ùù‡‹ÕÕšéŠÖX…š,k/g‰~ï¨û=¨Ïy'\áI¿(¢îÎÉz`/%Ém¬)5p§Ä‡$渖*š[c¦q7Íí¡äæ9®ý.æ£jHO)§ÅR…ö<jMA];Éèâ	P%Ci˜ÃÜôyPn¶sŒÄ¡ƒ’-n!u‘­KŸ71@éoëÔìÄ#­?µ¢/èhruMªïärFða?:·æ߅í	¨[5–=’d#lé¹ÞUûÊ$ú~=Õu$p)U¾v‡s¾‡0[ã&«ÔЫÍè²èò‚ú½iµ¿3'¿^‚þûÓß9¿ºC¥º¦G®qԅÍÖæFœ%¡ÝXæ:ÕElVƒ–ˆ…ž…f'cÿãŸ×Kvßév²Þ]AG9 šÉK3öÃUrÑV‹ÉM_ÎGólSðè®bøۂ$…*OÈØOê}‚¥©ƒ‰”äõùwcRS³ ãAÏÛHŽÆïpÿPJ_{KÓÙ2‡/Rð@´ç³XÏX·ó}U#)ØVþ²0åÀ{ø×GÃÞþÀ¾MLvPEëÜC$Cd|¾¥#2
FüÊWaŠ¡4Êے­ê0}½J?‡?NrÙè ¤ÝïŽÅ6ú5•íÁ؆ڂçVo×l']j6Ô»m¡‡6ìvœ{uRÒÆÀ˜\Æ£ ,;;· ¦äàê&xW0›ùÔ5üÔ½¬é‘å‹	ÊmþwŸ9Sî{côÌfj?3*l2Å/úŒ~‰TôìiðP{ôdY-¬ƒlO¨ÍÞ}?bÆ&QP"éÀGسZ;žBâÉjŸ/aiÞ©ƒÒÞ»j dv†WëÅÕyð®ÜSkœ?ԍýF…%‘A‘ñq:À¥Žxúø3À+[A/&¢B?˜5ÍáÙÒЅFYK±2jŠû<¾é
;Uð$j5Öå¬fµ§©{僂[«ñwá"b7·Ø&Ю—®ë—Ôž€<pA,Y!áZtúÒá€81Ã]Õà¨Å–£XÅÐ|'ÒÖ¦¢ä q(U8Uu¤·ê†›}!©ß5‰‰äœòœöàÄ vÿ&òàžSƒSð^…Q±z`Óµd,£ ºl“!£¯ÄÒ»€ê§éÒ¦ôK§^zÈ+¾(Ø3Y•p¹Ü-óžIAéU	Ƀ§"ßL˜µÄ ’àêœãÜܹ¾Ð_Í´7“s´V«Þ]3âE¡míWMbŠ~ªröÂ=F…$ˆƒÙü~;ÓÜZbx`eR:­áÙá2nG¾'ø]á$„_7EéÒq"ˆ­{e­:õ
3âüÄÂø™œ³FRÓcµÊ€Ââg!#j›?	³6ùó¶F0*Ÿ±3ïýÕáDó6¸¸‹É£Xi^T©ÐWŸNŠ—s™ÿvQ4C€SÝYQ×R–·@¾D9ÓÏ&o.¿¦dPul?°“zZq1|@¥QVfY³Ž:M?À0¢oèîgÁ䷀-p)Ówî0bÍ/và*€7ì}Ëb	ᵉõC]2“y– 5\Bðš3Ã^(yƒ÷¢·(µÄ¸¿ MŠ–ÒÊQ8ï9`ái‰™ôó:ǖq$ÏKf2eó±h:“†eÿfî~}1r‚íì±öl¹å¯-.€Ï½m°h ª¾T^î/bÇoå¤IbpPÍ>éj¬úë“·w9Ø¥£Ó¹n´º6ž:|öÊß}"ßm¦¨"x²,ô˜ð*f<·YumPÐ÷Ô[òg|5wFia¡ü½<õ:Â'wQÉHµî9¼é&Fz\Ú±vòNGÝî¥vwþÌû\‡Zë7W™F4ÿž‹o3*(^)O*Ð-¥@*|û¨wè¼ìÿøÏPý?ü/áW¡։†.fpT¡ãrDFÇ
ÉGÉ´m¼¹¹Ý8ŒÇøj‰ k\{ùE2ŠLr£jy
@Oûo0í´Üë%»qG
£U5´ãŠåðz›¨i
m’ö(oÍTü‚Ï=8»—üãZ†9üè¨èHoAÕ#ÚÉ«D‘§mÓldõ^AEWK O­äjµ¾âsCë—ß0ÂC.þ²ãw*$½©êå6&mÿÑö;bÓv Ï¸]í̉戉»öÅS\ôØþ£÷5ùOk¿×Ý}ð­&òNAÐ]LDâ*’ß±¤ŸMèòÖYpt&}Œ1A\w¥nNÞ`F=[5/cø½«^™Ž:ºÆ1»ZzGOU²*“ª{!F¿v+¬t4~ñ“>‡>(%§@“gý<ÒÝh@U
xÿCÖCÔ©ø

Similar scripts

RSI_R2_EA_v2.1

RSI_R2_EA_v2.6

RSI-R2 EA

RSI_R2_EA_v2.9

RSI_R2_EA_v2.3

RSI R2 EA multi pair m

RSI_R2_EA_Opt

RSI R2 EA Multipair Regular Symbol

RSI_R2_EA_v2.0

RSI_R2_EA_v2.2

EMailSignals

Comments

Markdown supported. Formatting help

Markdown Formatting Guide

Element Markdown Syntax
Heading # H1
## H2
### H3
Bold **bold text**
Italic *italicized text*
Link [title](https://www.example.com)
Image ![alt text](image.jpg)
Code `code`
Code Block ```
code block
```
Quote > blockquote
Unordered List - Item 1
- Item 2
Ordered List 1. First item
2. Second item
Horizontal Rule ---