Het MT4 topic

...hier mq4..

//+------------------------------------------------------------------+
//|                              secret-forex-indicator-blogspot.mq4 |
//|                                Copyright © 2011, Tjipke de Vries |
//|                                                                  |
//| http://secret-forex-indicator.blogspot.com/                      |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2011, Tjipke de Vries"
#property link      ""

extern bool   ShowComment = true;     // false for backtesting
extern bool   PrefferedSett = true;    
extern string s1 = "== Test Settings ==";
extern double StopLoss = 240;
extern double TakeProfit = 250;
extern double TrailingStop = 110;
double        TrailingStep = 1;

extern string s2 = "== Money Management ==";
extern double Lots = 0.1;
extern bool   UseMM = true;
extern double PctToRisk = 2.0;

extern string s3 = "== Extra Settings ==";
extern string TradeComment = "secret-forex-indicator-blogspot";
extern int    Slippage = 3;
extern int    H1MagicNumber = 10060;
extern int    H4MagicNumber = 10240;
extern int    D1MagicNumber = 11440;

extern string s4 = "== Signal Settings ==";
extern string     Signal1                 = "====== Signal 1 ===================================";
extern bool       UseSignal1              = true;
extern string     Signal2                 = "====== Signal 2 ===================================";
extern bool       UseSignal2              = true;
extern string     Signal3                 = "====== Signal 3 ===================================";
extern bool       UseSignal3              = true;
extern string     Signal4                 = "====== Signal 4 =================================";
extern bool       UseSignal4              = true;
extern int        ServerTimeZone          = 0;
extern int        TradeFrom1              = 0;
extern int        TradeUntil1             = 24;
extern int        TradeFrom2              = 0;
extern int        TradeUntil2             = 0;
extern int        TradeFrom3              = 0;
extern int        TradeUntil3             = 0;
extern int        TradeFrom4              = 0;
extern int        TradeUntil4             = 0;

//extern string s5 = "== Signal Logic =="   for closing if trend change 
double MACDOpenLevel = 3;
double MACDCloseLevel = 2;
double MATrendPeriod = 24;

double MacdCurrent, MacdPrevious, SignalCurrent;
double SignalPrevious, MaCurrent, MaPrevious;
double neemwinst = 100;
int MagicNumber;
int total;
int checkorder=1;
int SlipPage;
double newLots,noLots;
double dLots;
double Points,SL,TP,FP,pBid,pAsk;
string strSymbol,spread;
double MinLots = 0;
double MaxLots = 0;
double LotStep = 0;
double MaxPctToRisk = 20;
int
					NumberOfTries		= 5, //Number of tries to set, close orders;
					RetryTime			= 1; 
string         filename="";


//+------------------------------------------------------------------+
//| expert initialization function                                   |
//+------------------------------------------------------------------+
int init()
  {
//----
   if(Period()==240)
      {
       MagicNumber=H4MagicNumber;
       if(PrefferedSett){
       StopLoss = 300;
       TakeProfit = 180;
       TrailingStop = 90;
       }
      }
   if(Period()==60)
      {
       MagicNumber=H1MagicNumber;
       if(PrefferedSett){
       StopLoss = 60;
       TakeProfit = 75;
       TrailingStop = 50;
       }
      }
   if(Period()==1440)
      {
       MagicNumber=D1MagicNumber;
//       StopLoss = 60;
//       TakeProfit = 75;
//       TrailingStop = 50;
      }   
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| expert deinitialization function                                 |
//+------------------------------------------------------------------+
int deinit()
  {
//----
   
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| expert start function                                            |
//+------------------------------------------------------------------+
int start()
  {
//----
   int Signal=0;
   int cnt, ticket;
   
   filename=Symbol() + TradeComment + "-" + Month() + "-" + Day() + ".log";
   strSymbol = Symbol();
   
   if (ShowComment) subPrintDetails();

   if(errorchek()!=""){Alert(errorchek());Sleep(4000);return(0);}
   HandleDigits();


   if(checkorder<1)
     {
      Signal = CheckSignal();
      if (Signal == 0) return(0);
      newLots=GetLots();
      if(noLots<MinLots)
        {
         Print("Only Higher risking if you want to trade minimum Lotsize. Free Margin = ", AccountFreeMargin());
         return(0);
        }      
      CheckOpenTrade(Signal);
      checkorder=checkorder+1;       
      return(0);
     } 
   // exit the trade correctly...
 if(checkorder>0)
  {
   total=OrdersTotal();
   checkorder=0;
   for(cnt=0;cnt<total;cnt++)
     {
      OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
      if( OrderSymbol()!=Symbol()||OrderMagicNumber()!=MagicNumber) continue;
        {
         if(OrderType()==OP_BUY) // go to long position
           {
            checkorder=checkorder+1;
            pBid = MarketInfo(strSymbol, MODE_BID); 
            if (StopLoss>0) {SL =(OrderOpenPrice() - (StopLoss*Points));}
            if (TakeProfit>0) 
                    {
                     TP =(OrderOpenPrice() + (TakeProfit*Points));
                     FP =(OrderOpenPrice() + (2*TakeProfit*Points)); //FakeProfit
                    }            
            // check for trailing stop
            if(TrailingStop>0)
              {
               if(pBid-OrderOpenPrice()>Points*TrailingStop)
                 {
                  if(OrderStopLoss()<pBid-Points*(TrailingStop+TrailingStep))
                    {
                     OrderModify(OrderTicket(),OrderOpenPrice(),pBid-Points*TrailingStop,FP,0,Green);
                     return(0);
                    }
                  if(pBid>TP)
                    {
                     OrderClose(OrderTicket(),OrderLots(),Bid,SlipPage,Violet); // close position
                     return(0);
                    }                    
                 }
              }
            // modify OrderStopLoss and OrderTakeProfit for Buy
            if(OrderStopLoss()==0 && OrderTakeProfit()==0 && (StopLoss>0||TakeProfit>0))
              {
               OrderModify(OrderTicket(),OrderOpenPrice(),SL,TP,0,Green);
               return(0);
              }
            if(pBid-OrderOpenPrice()>neemwinst*Points)  
               {
                // to simplify the coding and speed up access
                // data are put into internal variables
                  MacdCurrent=iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_MAIN,0);
                  MacdPrevious=iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_MAIN,1);
                  SignalCurrent=iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_SIGNAL,0);
                  SignalPrevious=iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_SIGNAL,1);
                  MaCurrent=iMA(NULL,0,MATrendPeriod,0,MODE_EMA,PRICE_CLOSE,0);
                  MaPrevious=iMA(NULL,0,MATrendPeriod,0,MODE_EMA,PRICE_CLOSE,1);               
                if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious && MacdCurrent>(MACDCloseLevel*Points))
                      {
                       OrderClose(OrderTicket(),OrderLots(),Bid,SlipPage,Violet); // close position                 
                       return(0); // exit                                  
                      }
               }              
            }   
         if(OrderType()==OP_SELL) // go to short position
           {
            checkorder=checkorder+1;
            pAsk = MarketInfo(strSymbol, MODE_ASK);
            if (StopLoss>0) {SL =(OrderOpenPrice() + (StopLoss*Points));}
            if (TakeProfit>0) 
                    {
                     TP =(OrderOpenPrice() - (TakeProfit*Points));
                     FP =(OrderOpenPrice() - (2*TakeProfit*Points));                     
                    }                           
            // check for trailing stop
            if(TrailingStop>0)
              {
               if((OrderOpenPrice()-pAsk)>(Points*TrailingStop))
                 {
                  if((OrderStopLoss()>(pAsk+Points*(TrailingStop+TrailingStep))) || (OrderStopLoss()==0))
                    {
                     OrderModify(OrderTicket(),OrderOpenPrice(),pAsk+Points*TrailingStop,FP,0,Red);
                     return(0);
                    }
                  if(pAsk<TP)
                    {
                     OrderClose(OrderTicket(),OrderLots(),Ask,SlipPage,Violet); // close position
                     return(0);
                    }                      
                 }
              }
            // modify OrderStopLoss and OrderTakeProfit for Sell
            if(OrderStopLoss()==0 && OrderTakeProfit()==0 && (StopLoss>0||TakeProfit>0))
              {
               OrderModify(OrderTicket(),OrderOpenPrice(),SL,TP,0,Red);
               return(0);
              }
            if(OrderOpenPrice()-pAsk>neemwinst*Points)
              {
               // to simplify the coding and speed up access
               // data are put into internal variables
                 MacdCurrent=iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_MAIN,0);
                 MacdPrevious=iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_MAIN,1);
                 SignalCurrent=iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_SIGNAL,0);
                 SignalPrevious=iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_SIGNAL,1);
                 MaCurrent=iMA(NULL,0,MATrendPeriod,0,MODE_EMA,PRICE_CLOSE,0);
                 MaPrevious=iMA(NULL,0,MATrendPeriod,0,MODE_EMA,PRICE_CLOSE,1);               
               if(MacdCurrent<0 && MacdCurrent>SignalCurrent && MacdPrevious<SignalPrevious && MathAbs(MacdCurrent)>(MACDCloseLevel*Points))
                    {
                     OrderClose(OrderTicket(),OrderLots(),Ask,SlipPage,Violet); // close position
                     return(0); // exit
                    }
              }        
           }
        }
     }
   }        
//----
   return(0);
  }
// the end.
//+-----------------------------------------------------------------------------------------------------------------------------------------+
//+------------------------------------------------------------------+
//|  4 or 5 Digit Broker Account Recognition                         |
//+------------------------------------------------------------------+
void HandleDigits()
 {
    // Automatically Adjusts to Full-Pip and Sub-Pip Accounts
   if (Digits == 4 || Digits == 2)
     {
       SlipPage = Slippage;
       Points = Point;
     } 
   if (Digits == 5 || Digits == 3)
     {
       SlipPage = Slippage*10;
       Points = Point*10;
     }
 }

// Lots Sizes and Automatic Money Management
double GetLots() 
 {
  dLots=Lots;
   MinLots = MarketInfo(Symbol(), MODE_MINLOT);
   MaxLots = MarketInfo(Symbol(), MODE_MAXLOT);
   LotStep = MarketInfo(Symbol(), MODE_LOTSTEP);
      //MM  Setup function to calculate Lots
      //    Tranform Lots to Integer Multiple of LotsStep, then set within Max/Min Limit
      //    This new MM will work with different MinLot and LotStep 
      //    such as Alpari UK Classic which have Minimum 0.1 then 0.11, 0.12, 0.13 etc
      //    The EA trades now trading XX% of your 	account balance. With a maximum of 20%.
      //         or it trades minimum lotsize if risking 20% is lower then minimum lotsize.
      double StopLossPoint;
      StopLossPoint = StopLoss;
      double RiskEquity = AccountEquity() * (PctToRisk/100);
      double eRiskEquity = AccountEquity() * (MaxPctToRisk/100);
      double PipValue = MarketInfo(Symbol(), MODE_TICKVALUE) * (Points / MarketInfo(Symbol(), MODE_TICKSIZE));
      double eLots = eRiskEquity / (StopLossPoint * PipValue);
  if(UseMM){dLots = RiskEquity / (StopLossPoint * PipValue);}
  if(eLots < dLots){dLots = eLots;}
  noLots = dLots;     
  if (dLots < MinLots){dLots = MinLots;}
  dLots = MinLots + NormalizeDouble(((dLots - MinLots) / LotStep),0) * LotStep;
  if (dLots > MaxLots){dLots = MaxLots;}
  return (dLots);
 } 
 

//----------------------- PRINT COMMENT FUNCTION
void subPrintDetails()
{
   string sComment   = "";
   string SP         = " ----------------------------------------\n";
   string NL         = "\n";
   string sDirection = "";


   sComment = "secret....v1.0" + NL;
   sComment = sComment + NL;
   sComment = sComment + "Magic Number " + DoubleToStr(MagicNumber,0)+ NL;
   sComment = sComment + "StopLoss " + DoubleToStr(StopLoss,0) + " | ";
   sComment = sComment + "TakeProfit " + DoubleToStr(TakeProfit,0) + " | ";
   sComment = sComment + "TrailingStop " + DoubleToStr(TrailingStop,0) + NL;
   sComment = sComment + "Date: " + Month() +"-"+Day()+"-"+Year()+NL;//  " Server Time: " + TimeToStr(TimeCurrent(), TIME_SECONDS) + NL;
   sComment = sComment + "GMT Time: " + TimeToStr((TimeCurrent()+ (( 0 - ServerTimeZone) * 3600)), TIME_SECONDS) + NL;
   sComment = sComment + "ServerTimeZone: " + ServerTimeZone + " (TimeZone)" + NL;
   sComment = sComment + SP;
   sComment = sComment + "Lot Size " + DoubleToStr(newLots,2) + NL;
   Comment(sComment);
}


//+------------------------------------------------------------------+
string errorchek()
{
if(Bars<100){return("bars less than 100");}
if(TakeProfit<10){return("TakeProfit less than 10");}
//if((Period() != 240) &&(Period() != 60)) {return("Wrong Timeframe choose M240 or M60");}
return("");
}
//+------------------------------------------------------------------+ 

//+------------------------------------------------------------------+
//| START Function Open Trade                                        |
//+------------------------------------------------------------------+
int CheckOpenTrade(int signal)
{      
int err = 0;
//Opening Sell
   if(signal==1)
      {
      if(OrderSend(Symbol(),OP_SELL,newLots,Bid,Slippage,0,0,"FirstTrade",MagicNumber,0,Coral) < 0)
         {
         err = GetLastError();
         Print("Error Ordersend(",err,"): ");
         return(-1);
         }
       return(0);
      }
//Opening Buy     
   if(signal==2)
      {
      if(OrderSend(Symbol(),OP_BUY,newLots,Ask,Slippage,0,0,"FirstTrade",MagicNumber,0,LightBlue) < 0)
         {
         err = GetLastError();
         Print("Error Ordersend(",err,"): ");
         return(-1);
         }
      return(0);
      }
}
//+------------------------------------------------------------------+
//| END Function Open Trade                                          |
//+------------------------------------------------------------------+


//===SIGNALS=========FOR===BUY==OR==SELL==============
int CheckSignal()
{
//=====================SIGNAL1========================
bool BuySignal1=false, SellSignal1=false;
//Smoothed ADX
if(UseSignal1)
{
int ADXPeriod =14;
double nowplusdi0 = iADX(NULL,0,ADXPeriod,PRICE_CLOSE,MODE_PLUSDI,0);
double nowplusdi1 = iADX(NULL,0,ADXPeriod,PRICE_CLOSE,MODE_PLUSDI,1);
double nowminusdi0 = iADX(NULL,0,ADXPeriod,PRICE_CLOSE,MODE_MINUSDI,0);
double nowminusdi1 = iADX(NULL,0,ADXPeriod,PRICE_CLOSE,MODE_MINUSDI,1);

 if(nowplusdi0>nowplusdi1){BuySignal1 = true;} //nowminusdi0>nowminusdi1 && 
 if(nowminusdi0<nowminusdi1){SellSignal1 = true;}//&& nowplusdi0<nowplusdi1

}
else {SellSignal1=true;BuySignal1=true;}
//=====================SIGNAL2========================
//SMA moving average period 20
bool BuySignal2=false, SellSignal2=false;
int SMAPeriod=20;

if(UseSignal2)
{
double SMA1=iMA(NULL,0,SMAPeriod,0,MODE_SMA,PRICE_CLOSE,0);//SMA-Current
double SMA2=iMA(NULL,0,SMAPeriod,0,MODE_SMA,PRICE_CLOSE,1);//SMA-Previous

  if((SMA2-SMA1>0) && (Close[0]<SMA1)) {SellSignal2  = true;}
  if((SMA1-SMA2>0) && (Close[0]>SMA1)) {BuySignal2  = true;}
}
else {SellSignal2=true;BuySignal2=true;}



//=====================SIGNAL3========================

bool BuySignal3=false, SellSignal3=false;

if(UseSignal3)
{
   if(High[1]>High[2]&&Low[1]<Low[2]&&Close[0]<Low[1])  {SellSignal3 = true;}
   if(High[1]>High[2]&&Low[1]<Low[2]&&Close[0]>High[1])  {BuySignal3  = true;}
}
else {SellSignal3=true;BuySignal3=true;}

//=====================SIGNAL4=======================  

bool BuySignal4=false, SellSignal4=false;

if(UseSignal4)
{
   int iHour=TimeHour(TimeCurrent()+ ((  0 - ServerTimeZone) * 3600));
   int ValidTradeTime = F_ValidTradeTime(iHour);
   if(ValidTradeTime==true)
    {
    BuySignal4=true;
    SellSignal4=true;
    }
}
else {SellSignal4=true;BuySignal4=true;}

if((SellSignal1==true) && (SellSignal2==true) && (SellSignal3==true) && (SellSignal4==true)) return(1);  
if((BuySignal1==true) && (BuySignal2==true) && (BuySignal3==true) && (BuySignal4==true)) return(2);
return (0);
}

      
//====================================================  


//+------------------------------------------------------------------+
//| START Function Valid Trade Time                                  |
//+------------------------------------------------------------------+

bool F_ValidTradeTime (int iHour)
   {
      if(((iHour >= TradeFrom1) && (iHour <= (TradeUntil1-1)))||((iHour>= TradeFrom2) && (iHour <= (TradeUntil2-1)))
        ||((iHour >= TradeFrom3)&& (iHour <= (TradeUntil3-1)))||((iHour >= TradeFrom4) && (iHour <=(TradeUntil4-1))))
      {
       return (true);
      }
      else
       return (false);
   }  

//+------------------------------------------------------------------+
//| END Function Valid Trade Time                                    |
//+------------------------------------------------------------------+