Scalp_8_12_v1_2(ICEedition)





//+------------------------------------------------------------------+
//|                                              Scalp_8_12_v1_1.mq4 |
//|                                          Copyright © 2006, Magex |
//|                                        http://www.metaquotes.net |
//+------------------------------------------------------------------+
#property copyright "Dan"
#property link      "3172552@gmail.com"
#include <stdlib.mqh>
#define  MN_8   8
#define  MN_12  12

//---- input parameters


extern int       Hours2Check=     8;   //êîëè÷åñòâî ÷àñîâ äëÿ èçìåðåíèÿ ïðîáèâàåìîãî äèàïàçîíà     
extern int       CloseHour=       9;    //âðåìÿ çàêðûòèÿ âñåõ ïîçèöèé    
extern int       EarliestOpenHour=14;   //ðàíüøå ýòîãî ÷àñà íå îòêðûâàåìñÿ
extern int       Days2Check=      10;    //êîëè÷åñòâî ñóòîê äëÿ èçìåðåíèÿ ñðåäíåãî ñóòî÷íîãî äèàïàçîíà
extern double    ChannelK=        1.5;  //êîýôôèöèåíò ðàññ÷¸òà êàíàëà   

extern int       CheckHour_8=     8;    //âðåìÿ èçìåðåíèÿ ïðîáèâàåìîãî äèàïàçîíà   
extern double    ProfitK_8=       2;    //êîýôôèöèåíò ðàññ÷¸òà ïðîôèòà
extern double    LossK_8=         2;    //êîýôôèöèåíò ðàññ÷¸òà ëîññà  
extern double    OffsetK_8=       2;  //êîýôôèöèåíò ðàññ÷¸òà ðàññòîÿíèÿ ïðîáîÿ     

extern int       CheckHour_12=    12;   //âðåìÿ èçìåðåíèÿ ïðîáèâàåìîãî äèàïàçîíà    
extern double    ProfitK_12=      2;  //êîýôôèöèåíò ðàññ÷¸òà ïðîôèòà
extern double    LossK_12=        1.5;    //êîýôôèöèåíò ðàññ÷¸òà ëîññà     
extern double    OffsetK_12=      2.5;  //êîýôôèöèåíò ðàññ÷¸òà ðàññòîÿíèÿ ïðîáîÿ   

extern int       FilterDay=       4;    //â ýòîò äåíü íåäåëè íå òîðãóåì
extern int       DoubleDay=       5;    //â ýòîò äåíü íåäåëè óäâàèâàåì ëîò
extern bool      UseMM=           false;
extern int TradesPerDayAllowed=   2;    //êîëè÷åñòâî ñäåëîê ðàçðåø¸ííûõ â ñóòêè
//////////////////////////////////////////////////////////////////////////
 
//////////////////////////////////////////////////////////// 
//Ïàðàìåòðû äëÿ èñïîëüçîâàíèÿ ÌÌ
int MaxSystemDD=240; //ñþäà ïèñÀòü ìàêñ. äðîóäàóí ñèñòåìû áåç èñïîëüçîâàíèÿ ìì
int SystemTrustK=1;//êîýôôèöèåíò äîâåðèÿ ê ñèñòåìå-
int MaxDD_Allowed=20;// ðàçðåø¸ííûé äðîóäàóí ñèñòåìû â ïðîöåíòàõ îò äåïî
///////////////////////
double Lots=1.0;
int LatestOpenHour=22;//ïîñëå ýòîãî ÷àñà íå îòêðûâàåìñÿ

int PointPrice=10;//öåíà ïóíêòà ïðè ðàáîòå 1-ì ëîòîì, äëÿ åâðî- 10 äîëëàðîâ
/////////////////////////////////////////////////////
//Ïàðàìåòðû îáðàáîòêè îøèáîê ñåðâåðîì
int MaxTries=5;//êîëè÷åñòâî ïîïûòîê îòêðûòü ïîçó
int Pause=1000;//ïåðâîå çíà÷åíèå ïàóçû ïåðåä íîâîé ïîïûòêîé îòêðûòü-çàêðûòü îðäåð
int err;//îøèáêà
int try;//èòåðàöèÿ ïîïûòêè îòêðûòèÿ-çàêðûòèÿ
int ticket;//ðåçóëüòàò îòêðûòèÿ
bool close;//ðåçóëüòàò çàêðûòèÿ
///////////////////////////////////////
int i;//èòåðàöèÿ âûáîðà îðäåðà
int BarsPerDay;//ñâå÷é â ñóòêè
int InsuranceStop;//ñòðàõîâî÷íûé ñòîï, íà ñëó÷àé ñèëüíîãî äâèæåíèÿ ïðîòèâ íàøåé ïîçèöèè
double ISK=1.5;//êîýôôèöèåíò äëÿ ðàññ÷¸òà ñòðàõîâî÷íîãî ñòîïà, êîòîðûé óñòàíàâëèâàåòñÿ â OrderSend()

int bars;//èñïîëüçóåòñÿ äëå òîãî, ÷òîáû ýêñïåðò ðàáîòàë òîëüêî 1 ðàç íà ñâå÷ó

//ìàññèâû 
int OpenDay[2];
int Bars2Check[2];
int profit[2];
int loss[2];
int offset[2];
int avrange[2];



double sellprice[2];
double buyprice[2];
double daj[2];
double hh[2];
double ll[2];
double totalrange[2];
double channel[2];
int    CheckHour[2];
double    ProfitK[2];
double     LossK[2];
double     OffsetK[2];
int     MN[2];
bool  first_start;
//////////////////////////////////////////////////////////// 
//+------------------------------------------------------------------+
//| expert initialization function                                   |
//+------------------------------------------------------------------+
int init()
  {
first_start=true;
CheckHour[0] = CheckHour_8; 
ProfitK [0] = ProfitK_8; 
LossK [0] = LossK_8; 
OffsetK [0] = OffsetK_8; 
MN [0] = MN_8; 

CheckHour[1] = CheckHour_12; 
ProfitK [1] = ProfitK_12; 
LossK [1] = LossK_12; 
OffsetK [1] = OffsetK_12; 
MN [1] = MN_12; 
} 
//+------------------------------------------------------------------+
//| expert deinitialization function                                 |
//+------------------------------------------------------------------+
int deinit()
  {
//----
   
//----
   return(0);
  }
/////////////////////////////////////////////////////////////////////
void Levels_Defining(int n)
{  //èíèöèàëèçàöèÿ ìàññèâîâ
//    CheckHour[0]=CheckHour_8;
//    ProfitK[0]=ProfitK_8;
//    LossK[0]=LossK_8;
//    OffsetK[0]=OffsetK_8;
//    MN[0]=MN_8;
  
//    CheckHour[1]=CheckHour_12;
//    ProfitK[1]=ProfitK_12;
//    LossK[1]=LossK_12;
//    OffsetK[1]=OffsetK_12;
//    MN[1]=MN_12;
  
    if ( n==0 ) {Bars2Check[n]=((Hours2Check*60)/Period()); }
    else { Bars2Check[n]=(((CheckHour[1]-CheckHour[0])*60)/Period()); }
    
    hh[n]=High[Highest(NULL,0,MODE_HIGH,Bars2Check[n],((Hour()-CheckHour[n])*60)/Period()+1)];
    ll[n]=Low[Lowest(NULL,0,MODE_LOW,Bars2Check[n],((Hour()-CheckHour[n])*60)/Period()+1)];
    BarsPerDay=((24*60)/Period());
    totalrange[n]=0; 
    channel[n]=hh[n]-ll[n];

    for(i=1;i<=Days2Check;i++)
      {
      daj[n]=(High[Highest(NULL,0,MODE_HIGH,BarsPerDay,BarsPerDay*(i-1)+((Hour()-CheckHour[n])*60)/Period()+1)]
             -Low[Lowest(NULL,0,MODE_LOW,BarsPerDay,BarsPerDay*(i-1)+((Hour()-CheckHour[n])*60)/Period()+1)]);
      totalrange[n]=totalrange[n]+daj[n];  

      }
    avrange[n]=MathRound((totalrange[n]/Days2Check)/Point);
    offset[n]=MathRound(avrange[n]/OffsetK[n]);
    sellprice[n]=NormalizeDouble(ll[n]-offset[n]*Point,4);
    buyprice[n]=NormalizeDouble(hh[n]+offset[n]*Point,4); 
    profit[n]=MathRound(avrange[n]/ProfitK[n]);
    loss[n]=MathRound(avrange[n]/LossK[n]);
    return;
} 
//*/*
///////////////////////////////////////////////////////////// 

/////////////////////////////////////////////////////////////_8     
void Close_by_Closetime(int n)    
{
    for(i=0;i<OrdersTotal();i++)
   {
    if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==false)  break;
    if((OrderMagicNumber()!=MN[n] && OrderMagicNumber()!=MN[n]) || OrderSymbol()!=Symbol() ) continue;
          

    if (OrderType()==OP_BUY)
      {
      for(int try=1;try<=MaxTries;try++)
        {
        while (!IsTradeAllowed()) Sleep(1000);
        close=false;
        RefreshRates();
        close=OrderClose(OrderTicket(),OrderLots(),NormalizeDouble(Bid,4),3,White);
        Sleep(Pause);
        
        if (close){Pause=1000; break;} 
        else
          {
          err=GetLastError(); 
          Print("OrderClose failed with error #",err," : ",ErrorDescription(err),"Trying Again #",try);
          Pause=Pause*2;
          if (try==MaxTries) 
            {
            Pause=1000;
            Print("Warning!!!Last try failed!");
            SendMail("Warning!!!Last try failed!  ",OrderType()+" by "+OrderClosePrice()+" Cloing Failed!");
            break;
            }
          }
        }
      }  
      
    
      
  if (OrderType()==OP_SELL)
    {
    for(try=1;try<=MaxTries;try++)
      {
      while (!IsTradeAllowed()) Sleep(1000);
      close=false;
      RefreshRates();
      close=OrderClose(OrderTicket(),OrderLots(),NormalizeDouble(Ask,4),3,White);
      Sleep(Pause);
   
      if (close){Pause=1000; break;}
      else
        {
        err=GetLastError(); 
        Print("OrderClose failed with error #",err," : ",ErrorDescription(err),"Trying Again #",try);
        Pause=Pause*2;
        if (try==MaxTries) 
          {
          Pause=1000;
          Print("Warning!!!Last try failed!");
          SendMail("Warning!!!Last try failed!  ",OrderType()+" by "+OrderClosePrice()+" Cloing Failed!");
          break;
          }
        }
      }  
    }    

  }

}
///////////////////////////////////////////////////////////////*/    

///////////////////////////////////////////////////////////////
void Close_by_Stops(int n)  
{
  for(i=0;i<OrdersTotal();i++)
    {
    if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==false)  break;
    if(OrderMagicNumber()!=MN[n] || OrderSymbol()!=Symbol()) continue;
          
    if ((OrderType()==OP_BUY)
    && (((Close[1]-NormalizeDouble(OrderOpenPrice(),4))>=profit[n]*Point)
    || ((NormalizeDouble(OrderOpenPrice(),4)-Close[1])>=loss[n]*Point))) 
      {
      for(int try=1;try<=MaxTries;try++)
        {
        while (!IsTradeAllowed()) Sleep(5000);
        close=false;
        RefreshRates();
        close=OrderClose(OrderTicket(),OrderLots(),NormalizeDouble(Bid,4),3,White);
        Sleep(Pause);
        
        if (close){Pause=1000;break;}
        else
          {
          err=GetLastError(); 
          Print("OrderClose failed with error #",err," : ",ErrorDescription(err),"Trying Again #",try);
          Pause=Pause*2;
          if (try==MaxTries) 
            {
            Pause=1000;
            Print("Warning!!!Last try failed!");
            SendMail("Warning!!!Last try failed!  ",OrderType()+" by "+OrderClosePrice()+" Cloing Failed!");
            break;
            }
          }
        }
      }  
    
  if ((OrderType()==OP_SELL)
  && (((Close[1]-NormalizeDouble(OrderOpenPrice(),4))>=loss[n]*Point)
  || ((NormalizeDouble(OrderOpenPrice(),4)-Close[1])>=profit[n]*Point))) 

   {
    for(try=1;try<=MaxTries;try++)
      {
      while (!IsTradeAllowed()) Sleep(5000);
      close=false;
      RefreshRates();
      close=OrderClose(OrderTicket(),OrderLots(),NormalizeDouble(Ask,4),3,White);
      Sleep(Pause);
       
      if (close){Pause=1000;break;}
      else
        {
        err=GetLastError();
        Print("OrderClose failed with error #",err," : ",ErrorDescription(err),"Trying Again #",try);
        Pause=Pause*2;
        if (try==MaxTries) 
          {
          Pause=1000;
          Print("Warning!!!Last try failed!");
          SendMail("Warning!!!Last try failed!  ",OrderType()+" by "+OrderClosePrice()+" Cloing Failed!");
          break;
          }
        }
      }  
    }    
        
    
  }
}
//////////////////////////////////////////////////*/

double LotSizeCounting(int OpTime)
{
if (UseMM==true)
  {
  if (OpTime==8)
   {
//   Lots=NormalizeDouble(((AccountFreeMargin( )/100000)*MarginPercent),1);Print(Lots);
//   Lots=NormalizeDouble(MathSqrt(100*channel_8),1);
//  Lots=NormalizeDouble(((AccountFreeMargin( )/100)*MaxDD_Allowed )/((loss)*SystemTrustK*PointPrice),1);
  Lots=NormalizeDouble(((AccountFreeMargin( )/100)*MaxDD_Allowed )/(MaxSystemDD*SystemTrustK*PointPrice),1);
//  Print(Lots);
   }
  if (OpTime==12)
   {
//   Lots=NormalizeDouble((AccountFreeMargin( )/100000)*MarginPercent,1);
//   Lots=NormalizeDouble(MathSqrt(100*channel_12),1);
//  Lots=NormalizeDouble(((AccountFreeMargin( )/100)*MaxDD_Allowed )/((loss)*SystemTrustK*PointPrice),1);
  Lots=NormalizeDouble(((AccountFreeMargin( )/100)*MaxDD_Allowed )/(MaxSystemDD*SystemTrustK*PointPrice),1);

   }
  if (Lots<0.1) 
    {
    Print("Too risky Trade! Add some money to account");
    SendMail("Too risky Trade! Add some money to account","Too risky Trade! Add some money to account");
    Lots=0.1;
    }
  }
else Lots=0.1;
if (DayOfWeek()==DoubleDay ){Lots=Lots*2;}  

return(Lots);
}

////////////////////////////////////////////////////////////////////////////////  
void Opening(int n)

{ 
  InsuranceStop=MathRound(loss[n]*ISK);
  
  
  Lots=LotSizeCounting(8);
 
  if (Close[1]>=buyprice[n]) 
  {
    for (int try=1;try<=MaxTries;try++)
       {
       while (!IsTradeAllowed()) Sleep(5000);
       RefreshRates();
       
       ticket=OrderSend(Symbol(),OP_BUY,Lots,NormalizeDouble(Ask,4),3,NormalizeDouble(Ask-InsuranceStop*Point,4),1.5,"Order 8-series Open",MN[n],Blue);
       Sleep(Pause);
       
       if (ticket>0){OpenDay[n]=Day();Pause=1000;break;}
       else
          {
          err=GetLastError();
          Print("OrderSend failed with error #",err," : ",ErrorDescription(err),"Trying again #",try);
          Pause=Pause*2;
          if (try==MaxTries) 
            {
            Pause=1000;
            Print("Warning!!!Last try failed!");
            SendMail("Warning!!!Last try failed!",OrderType()+" by "+OrderOpenPrice()+" Opening failed!");
            break;
            }
          }
       }
  }   
  
  if (sellprice[n]>=Close[1])
  {
    for (try=1;try<=MaxTries;try++)
       {
       while (!IsTradeAllowed()) Sleep(5000);
       RefreshRates();
       ticket=OrderSend(Symbol(),OP_SELL,Lots,NormalizeDouble(Bid,4),3,NormalizeDouble(Bid+InsuranceStop*Point,4),0.5,"Order 8-series Open",MN[n],Red);
       Sleep(Pause);
       
       if (ticket>0){OpenDay[n]=Day();Pause=1000;break;}
       else
          {
          err=GetLastError();
          Print("OrderSend failed with error #",err," : ",ErrorDescription(err),"Trying again #",try);
          Pause=Pause*2;
          if (try==MaxTries) 
            {
            Pause=1000;
            Print("Warning!!!Last try failed!");
            SendMail("Warning!!!Last try failed!",OrderType()+" by "+OrderOpenPrice()+" Opening failed!");
            break;
            }
          }
        }
    }    
         
    
}    

/////////////////////////////////////////////////////////////////////     

   
////////////////////////////////////////////////////////////////////
 
void start()
   
{    
   if ( Period()!=60 || Bars==bars ) return; 
   bars=Bars;
 
   if (first_start)
   {
    first_start=false;
    
    for(i=0;i<OrdersTotal();i++)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==false)  continue;
      if(OrderMagicNumber()==MN[0] && OrderSymbol()==Symbol()) OpenDay[0]=TimeDay(OrderOpenTime());
      if(OrderMagicNumber()==MN[1] && OrderSymbol()==Symbol()) OpenDay[1]=TimeDay(OrderOpenTime());
     }
 //   Levels_Defining(0);
 //   Levels_Defining(1);
    
   }
 // Comment("p(0)",profit[0], " l(0) ", loss[0],"p(1)", profit[1], "l(1)", loss[1]);
int i;int n;
//----
 
      if  (OrdersTotal()>0)
      {
       Levels_Defining(0);
       Close_by_Stops(0);
       
       Levels_Defining(1);
       Close_by_Stops(1);
      
       if ((Hour()>=CloseHour) && (Day()!=OpenDay[0]))
          Close_by_Closetime(0);
       if ((Hour()>=CloseHour) && (Day()!=OpenDay[1]))
          Close_by_Closetime(1);    
      }

 
      if  (Hour()>LatestOpenHour || Hour()<EarliestOpenHour) return;
      {
       if  ( DayOfWeek()!=FilterDay )
         {
        
         Levels_Defining(0);//Print(offset[1],"--",loss[1],"--",channel[1]);
         if ( channel[0]<(avrange[0]/ChannelK)*Point && Day()!=OpenDay[0])
            { Opening(0); }
         if  (OrdersTotal()==TradesPerDayAllowed) return;
         Levels_Defining(1);
         if ( channel[1]<(avrange[1]/ChannelK)*Point && Day()!=OpenDay[1])
            { Opening(1); }
         }
      
      }

 

} 

/////////////////////////////////////////////////////////





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:



Custom Indicators Used:

Order Management characteristics:
Checks for the total of open orders

It Closes Orders by itself
It automatically opens orders when conditions are reached

Other Features:

It sends emails

BackTest : EURUSD on H1

From 2009-08-01 to 2009-10-01 Profit Factor:1.93 Total Net Profit:232.35

BackTest : EURUSD on H1

From 2009-12-01 to 2010-01-17 Profit Factor:0.90 Total Net Profit:-63.15

BackTest : EURUSD on H1

From 2010-04-01 to 2010-04-30 Profit Factor:0.00 Total Net Profit:0.00

BackTest : EURUSD on H1

From 2010-05-01 to 2010-05-31 Profit Factor:0.00 Total Net Profit:0.00

BackTest : EURUSD on H1

From 2010-06-01 to 2010-06-30 Profit Factor:0.00 Total Net Profit:0.00

BackTest : GBPUSD on H1

From 2010-01-01 to 2010-02-27 Profit Factor:1.35 Total Net Profit:96.71

BackTest : USDCAD on H1

From 2009-12-01 to 2010-01-01 Profit Factor:0.03 Total Net Profit:-626.47

BackTest : USDCHF on H1

From 2009-12-01 to 2010-01-01 Profit Factor:1.33 Total Net Profit:83.09

BackTest : USDJPY on H1

From 2009-11-01 to 2009-11-30 Profit Factor:0.89 Total Net Profit:-8.99

Request Backtest for Scalp_8_12_v1_2(ICEedition)


From : (yyyy/mm/dd) To: (yyyy/mm/dd)

Pair: Period: