SessionTrade_Expert

//+-------------------------------------------------------------------------------------+
//|                                                             SessionTrade_Expert.mq4 |
//|                                                                           Scriptong |
//|                                                                   scriptong@mail.ru |
//+-------------------------------------------------------------------------------------+
#property copyright "Scriptong"
#property link      "scriptong@mail.ru"

//---- input parameters
extern double    Lots              = 0.1;
extern int       Delta             = 1;
extern int       AzianFlatStart    = 0;
extern int       AzianFlatEnd      = 8;
extern int       EuropeanFlatStart = 8;
extern int       EuropeanFlatEnd   = 16;
extern int       AmericanFlatStart = 16;
extern int       AmericanFlatEnd   = 24;
extern string    OpenOrderSound    = "ok.wav";
extern int       MagicNumber       = 47589;

bool Activate, FreeMarginAlert, FatalError;
double Tick, Spread, StopLevel, MinLot, MaxLot, LotStep, LastLots, 
       LowV, HighV, SessionLow, SessionHigh;
datetime LastBar, NowDay, LastOpen[3];
int Start[3], Finish[3], CurSession;

//+-------------------------------------------------------------------------------------+
//| expert initialization function                                                      |
//+-------------------------------------------------------------------------------------+
int init()
  {
//----
   Activate = False;
   FatalError = False;

// - 1 - == Ñáîð èíôîðìàöèè îá óñëîâèÿõ òîðãîâëè ========================================   
   Tick = MarketInfo(Symbol(), MODE_TICKSIZE);                         // ìèíèìàëüíûé òèê    
   Spread = ND(MarketInfo(Symbol(), MODE_SPREAD)*Point);                 // òåêóùèé ñïðýä
   StopLevel = ND(MarketInfo(Symbol(), MODE_STOPLEVEL)*Point);  // òåêóùèé óðîâåíü ñòîïîâ 
   MinLot = MarketInfo(Symbol(), MODE_MINLOT);    // ìèíèìàëüíûé ðàçðåøåííûé îáúåì ñäåëêè
   MaxLot = MarketInfo(Symbol(), MODE_MAXLOT);   // ìàêñèìàëüíûé ðàçðåøåííûé îáúåì ñäåëêè
   LotStep = MarketInfo(Symbol(), MODE_LOTSTEP);          // øàã ïðèðàùåíèÿ îáúåìà ñäåëêè
// - 1 - == Îêîí÷àíèå áëîêà =============================================================

// - 2 - == Ïðèâåäåíèå îáúåìà ñäåëêè ê äîïóñòèìîìó è ïðîâåðêà êîððåêòíîñòè îáúåìà =======   
   Lots = MathRound(Lots/LotStep)*LotStep; // îêðóãëåíèå îáúåìà äî áëèæàéøåãî äîïóñòèìîãî
   if(Lots < MinLot || Lots > MaxLot) // îáúåì ñäåëêè íå ìåíüøå MinLot è íå áîëüøå MaxLot
     {
      Comment("Ïàðàìåòðîì Lots áûë çàäàí íåïðàâèëüíûé îáúåì ñäåëêè! Ñîâåòíèê îòêëþ÷åí!");
      return(0);
     }
// - 2 - == Îêîí÷àíèå áëîêà =============================================================
    
// - 3 - === Ïåðåêîìïîíîâêà âðåìåíè ñåññèé â ìàññèâû è ïðîâåðêà êîððåêòíîñòè äàííûõ =====
   if (!ToArray(0, AzianFlatStart, AzianFlatEnd) || 
       !ToArray(1, EuropeanFlatStart, EuropeanFlatEnd) ||
       !ToArray(2, AmericanFlatStart, AmericanFlatEnd))
     return(0);  
// - 3 - === Îêîí÷àíèå áëîêà ============================================================

   ArrayInitialize(LastOpen, 0);

// - 4 - === Âîññòàíîâëåíèå çíà÷åíèé ýëåìåíòîâ ìàññèâà LastOpen =========================
   for (int i = OrdersHistoryTotal() - 1; i >= 0; i--)    
     if (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))            // ïîèñê â èñòîðèè ñ÷åòà
       if (OrderSymbol() == Symbol() && MathFloor(OrderMagicNumber()/10) == MagicNumber)
         {
          int ID = MathMod(OrderMagicNumber(), 10);
          LastOpen[ID] = MathMax(LastOpen[ID], OrderOpenTime());
         }
         
   for (i = OrdersTotal() - 1; i >= 0; i--)    
     if (OrderSelect(i, SELECT_BY_POS))                         // ïîèñê â îêíå òåðìèíàëà
       if (OrderSymbol() == Symbol() && MathFloor(OrderMagicNumber()/10) == MagicNumber)
         {
          ID = MathMod(OrderMagicNumber(), 10);
          LastOpen[ID] = MathMax(LastOpen[ID], OrderOpenTime());
         }
// - 4 - === Îêîí÷àíèå áëîêà ============================================================

   LastBar = 0;
   Activate = True;
   
//----
   return(0);
  }
//+-------------------------------------------------------------------------------------+
//| expert deinitialization function                                                    |
//+-------------------------------------------------------------------------------------+
int deinit()
  {
//----
   Comment("");   
//----
   return(0);
  }

//+-------------------------------------------------------------------------------------+
//| Ïåðåêîìïîíîâêà âõîäíûõ ïàðàìåòðîâ â ìàññèâ                                          |
//+-------------------------------------------------------------------------------------+
bool ToArray(int Num, int St, int End)
{
 if (St < 0 || End < 0 || St > 24 || End > 24 || St >= End)
     {
      Comment("Çíà÷åíèÿ âðåìåíè Start è End äîëæíû ëåæàòü â äèàïàçîíå îò 0 äî 24 è Start < End.");
      Print("Çíà÷åíèÿ âðåìåíè Start è End äîëæíû ëåæàòü â äèàïàçîíå îò 0 äî 24 è Start < End.");
      return(False);
     } 
 int i = Num-1;    
 while (i >= 0)
   {
    if (Start[i] >= St || Finish[i] >= End || Finish[i] > St)
      {
       Comment("Îáíàðóæåíî ïåðåñå÷åíèå ñåññèé. Ñîâåòíèê îòêëþ÷åí.");
       Print("Îáíàðóæåíî ïåðåñå÷åíèå ñåññèé. Ñîâåòíèê îòêëþ÷åí.");
       return(False);
      }
    i--;
   }    
   
 Start[Num] = St;
 Finish[Num] = End;
 return(True);  
}


//+------------------------------------------------------------------------------------+
//| Ïðèâåäåíèå çíà÷åíèé ê òî÷íîñòè îäíîãî òèêà                                         |
//+------------------------------------------------------------------------------------+
double ND(double A)
{
 return(NormalizeDouble(A, Digits));
}  

//+-------------------------------------------------------------------------------------+
//| Ðàñ÷åò ãðàíèö êàíàëà                                                                |
//+-------------------------------------------------------------------------------------+
void GetSignal()
{
// - 1 - ==== Åñëè êàíàë íå áóäåò ðàññ÷èòàí, òî âñå çíà÷åíèÿ îñòàíóòñÿ íóëåâûìè =========
 LowV = 0;
 HighV = 0;
 CurSession = -1;
 int DayBar = 0; 
 int k = 0;
// - 1 - ============================= Îêîí÷àíèå áëîêà ==================================

// - 2 - ==== Îïðåäåëåíèå òåêóùåé òîðãîâîé ñåñèèè =======================================
 for (k = 0; k < 3; k++)
   if (Hour() >= Start[k] && Hour() < Finish[k])
     {
      if (k == 0)
        {
         DayBar++;
         int j = 2;
        } 
       else
        j = k - 1; 
// - 2 - ============================= Îêîí÷àíèå áëîêà ==================================

// - 3 - ==== Ðàñ÷åò óðîâíåé ============================================================
      datetime BeginDay = iTime(Symbol(), PERIOD_D1, DayBar);         // Âðåìÿ íà÷àëà äíÿ
      if (!(TimeDayOfWeek(BeginDay) == 5 && k == 0))        // Èñêëþ÷àåì àçèàòñêóþ ñåññèþ
        {                                                                 // ïîíåäåëüíèêà
         // Áàð, ñîîòâåòñòâóþùèé íà÷àëó ïðåäûäóùåé ñåñèè
         int StartBar = iBarShift(Symbol(), 0, BeginDay+Start[j]*3600);
         // Áàð, ñîîòâåòñòâóþùèé îêîí÷àíèþ ïðåäûäóùåé ñåñèè
         int FinishBar = iBarShift(Symbol(), 0, BeginDay+Finish[j]*3600)+1; 
         // Íèæíÿÿ ãðàíèöà
         LowV = Low[iLowest(Symbol(), 0, MODE_LOW, StartBar-FinishBar+1, FinishBar)];
         // Âåðõíÿÿ ãðàíèöà  
         HighV = High[iHighest(Symbol(), 0, MODE_HIGH, StartBar-FinishBar+1, FinishBar)]; 
         // Ìèíèìóì òåêóùåé ñåññèè
         SessionLow =  Low[iLowest(Symbol(), 0, MODE_LOW, FinishBar+1)]; 
         // Ìàêñèìóì òåêóùåé ñåññèè
         SessionHigh = High[iHighest(Symbol(), 0, MODE_HIGH, FinishBar+1)];
        }
      CurSession = k;// íîìåð òåêóùåé ñåññèè (0-àçèàòñêàÿ, 1-åâðîïåéñêàÿ, 2-àìåðèêàíñêàÿ)
      break;
     } 
// - 3 - ============================= Îêîí÷àíèå áëîêà ==================================
}  

//+-------------------------------------------------------------------------------------+
//| Ðàñøèôðîâêà ñîîáùåíèÿ îá îøèáêå                                                     |
//+-------------------------------------------------------------------------------------+
string ErrorToString(int Error)
{
 switch(Error)
   {
    case 2: return("çàôèêñèðîâàíà îáùàÿ îøèáêà, îáðàòèòåñü â òåõïîääåðæêó."); 
    case 5: return("ó âàñ ñòàðàÿ âåðñèÿ òåðìèíàëà, îáíîâèòå åå."); 
    case 6: return("íåò ñâÿçè ñ ñåðâåðîì, ïîïðîáóéòå ïåðåçàãðóçèòü òåðìèíàë."); 
    case 64: return("ñ÷åò çàáëîêèðîâàí, îáðàòèòåñü â òåõïîääåðæêó.");
    case 132: return("ðûíîê çàêðûò."); 
    case 133: return("òîðãîâëÿ çàïðåùåíà."); 
    case 149: return("çàïðåùåíî ëîêèðîâàíèå."); 
   }
}
  
//+-------------------------------------------------------------------------------------+
//| "Ïðàâèëüíîå" îòêðûòèå ïîçèöèè                                                       |
//|  îòëè÷èå îò OpenOrder ïðîâåðÿåò ñîîòíîøåíèå òåêóùèõ óðîâíåé è óñòàíàâëèâàåìûõ      |
//| Âîçâðàùàåò:                                                                         |
//|   0 - íåò îøèáîê                                                                    |
//|   1 - Îøèáêà îòêðûòèÿ                                                               |
//|   2 - Îøèáêà çíà÷åíèÿ Price                                                         |
//|   3 - Îøèáêà çíà÷åíèÿ SL                                                            |
//|   4 - Îøèáêà çíà÷åíèÿ TP                                                            |
//|   5 - Îøèáêà çíà÷åíèÿ Lot                                                           |
//+-------------------------------------------------------------------------------------+
int OpenOrderCorrect(int Type, double Lot, double Price, double SL, double TP,
                     bool Redefinition = True)
// Redefinition - ïðè True äîîïðåäåëÿòü ïàðàìåòðû äî ìèíèìàëüíî äîïóñòèìûõ
//                ïðè False - âîçâðàùàòü îøèáêó
{
// - 1 - == Ïðîâåðêà äîñòàòî÷íîñòè ñâîáîäíûõ ñðåäñòâ ====================================
 if(AccountFreeMarginCheck(Symbol(), OP_BUY, Lot) <= 0 || GetLastError() == 134) 
  {
   if(!FreeMarginAlert)
    {
     Print("Íåäîñòàòî÷íî ñðåäñòâ äëÿ îòêðûòèÿ ïîçèöèè. Free Margin = ", 
           AccountFreeMargin());
     FreeMarginAlert = True;
    } 
   return(5);  
  }
 FreeMarginAlert = False;  
// - 1 - == Îêîí÷àíèå áëîêà =============================================================

// - 2 - == Êîððåêòèðîâêà çíà÷åíèé Price, SL è TP èëè âîçâðàò îøèáêè ====================   

 RefreshRates();
 switch (Type)
   {
    case OP_BUY: 
                string S = "BUY"; 
                if (MathAbs(Price-Ask)/Point > 3)
                  if (Redefinition) Price = ND(Ask);
                  else              return(2);
                if (ND(TP-Bid) <= StopLevel && TP != 0)
                  if (Redefinition) TP = ND(Bid+StopLevel+Tick);
                  else              return(4);
                if (ND(Bid-SL) <= StopLevel)
                  if (Redefinition) SL = ND(Bid-StopLevel-Tick);
                  else              return(3);
                break;
    case OP_SELL: 
                 S = "SELL"; 
                 if (MathAbs(Price-Bid)/Point > 3)
                   if (Redefinition) Price = ND(Bid);
                   else              return(2);
                 if (ND(Ask-TP) <= StopLevel) 
                   if (Redefinition) TP = ND(Ask-StopLevel-Tick);
                   else              return(4);
                 if (ND(SL-Ask) <= StopLevel && SL != 0)
                   if (Redefinition) SL = ND(Ask+StopLevel+Tick);
                   else              return(3);
                 break;
    case OP_BUYSTOP: 
                    S = "BUYSTOP";
                    if (ND(Price-Ask) <= StopLevel)
                      if (Redefinition) Price = ND(Ask+StopLevel+Tick);
                      else              return(2);
                    if (ND(TP-Price) <= StopLevel && TP != 0)
                      if (Redefinition) TP = ND(Price+StopLevel+Tick);
                      else              return(4);
                    if (ND(Price-SL) <= StopLevel)
                      if (Redefinition) SL = ND(Price-StopLevel-Tick);
                      else              return(3);
                    break;
    case OP_SELLSTOP: 
                     S = "SELLSTOP";
                     if (ND(Bid-Price) <= StopLevel)
                       if (Redefinition) Price = ND(Bid-StopLevel-Tick);
                       else              return(2);
                     if (ND(Price-TP) <= StopLevel)
                       if (Redefinition) TP = ND(Price-StopLevel-Tick);
                       else              return(4);
                     if (ND(SL-Price) <= StopLevel && SL != 0)
                       if (Redefinition) SL = ND(Price+StopLevel+Tick);
                       else              return(3);
                     break;
    case OP_BUYLIMIT: 
                     S = "BUYLIMIT";
                     if (ND(Ask-Price) <= StopLevel)
                      if (Redefinition) Price = ND(Ask-StopLevel-Tick);
                      else              return(2);
                     if (ND(TP-Price) <= StopLevel && TP != 0)
                       if (Redefinition) TP = ND(Price+StopLevel+Tick);
                       else              return(4);
                     if (ND(Price-SL) <= StopLevel)
                       if (Redefinition) SL = ND(Price-StopLevel-Tick);
                       else              return(3);
                     break;
    case OP_SELLLIMIT: 
                     S = "SELLLIMIT";
                     if (ND(Price - Bid) <= StopLevel) 
                       if (Redefinition) Price = ND(Bid+StopLevel+Tick);
                       else              return(2);
                     if (ND(Price-TP) <= StopLevel)
                       if (Redefinition) TP = ND(Price-StopLevel-Tick);
                       else              return(4);
                     if (ND(SL-Price) <= StopLevel && SL != 0)
                       if (Redefinition) SL = ND(Price+StopLevel+Tick);
                       else              return(3);
                     break;
   }
// - 2 - == Îêîí÷àíèå áëîêà =============================================================
 
// - 3 - == Îòêðûòèå îðäåðà ñ îæèäàíèå òîðãîâîãî ïîòîêà =================================   
 if(WaitForTradeContext())  // îæèäàíèå îñâîáîæäåíèÿ òîðãîâîãî ïîòîêà
   {  
    Comment("Îòïðàâëåí çàïðîñ íà îòêðûòèå îðäåðà ", S, " ...");
    datetime Exp = NowDay + Finish[CurSession]*3600;
    if (Exp - TimeCurrent() <= 600)
      Exp = TimeCurrent() + 660;  
    int ticket=OrderSend(Symbol(), Type, Lot, Price, 3, 
               SL, TP, NULL, MagicNumber*10+CurSession, Exp);// îòêðûòèå ïîçèöèè
    // Ïîïûòêà îòêðûòèÿ ïîçèöèè çàâåðøèëàñü íåóäà÷åé
    if(ticket<0)
      {
       int Error = GetLastError();
       if(Error == 2 || Error == 5 || Error == 6 || Error == 64 
          || Error == 132 || Error == 133 || Error == 149)     // ñïèñîê ôàòàëüíûõ îøèáîê
         {
          Comment("Ôàòàëüíàÿ îøèáêà ïðè îòêðûòèè ïîçèöèè ò. ê. "+
                   ErrorToString(Error)+" Ñîâåòíèê îòêëþ÷åí!");
          FatalError = True;
         }
        else 
         Comment("Îøèáêà îòêðûòèÿ ïîçèöèè ", S, ": ", Error);       // íåôàòàëüíàÿ îøèáêà
       return(1);
      }
    // ---------------------------------------------
    
    // Óäà÷íîå îòêðûòèå ïîçèöèè   
    Comment("Ïîçèöèÿ ", S, " îòêðûòà óñïåøíî!"); 
    PlaySound(OpenOrderSound); 
    return(0); 
    // ------------------------
   }
  else
   {
    Comment("Âðåìÿ îæèäàíèÿ îñâîáîæäåíèÿ òîðãîâîãî ïîòîêà èñòåêëî!");
    return(1);  
   } 
// - 3 - == Îêîí÷àíèå áëîêà =============================================================  
}

//+-----------------------------------------------------------------------------------+
//| Îæèäàíèå òîðãîâîãî ïîòîêà. Åñëè ïîòîê ñâîáîäåí, òî ðåçóëüòàò True, èíà÷å - False  |
//+-----------------------------------------------------------------------------------+  
bool WaitForTradeContext()
{
 int P = 0;
 // öèêë "ïîêà"
 while(IsTradeContextBusy() && P < 5)
   {
    P++;
    Sleep(1000);
   }
 // -------------  
 if(P == 5)
   return(False);
 return(True);    
}

//+-------------------------------------------------------------------------------------+
//| Óñòàíîâêà îòëîæåííûõ îðäåðîâ                                                        |
//+-------------------------------------------------------------------------------------+
void DoTransactions()
{
// - 1 - == Óñòàíîâêà îðäåðà Buy Stop ===================================================
 if (LastOpen[CurSession] < NowDay)   // Óñòàíàâëèâàëñÿ ëè îðäåð çà âðåìÿ òåêóùåé ñåññèè?
   if (Close[1] < LowV && Open[1] < LowV)   // Öåíà çàêðåïèëàñü çà íèæíåé ãðàíèöåé êàíàëà
     {
      RefreshRates();
      double Price = ND(LowV + Spread + Delta*Tick);   // Öåíà îòêðûòèÿ Buy Stop - íèæíÿÿ
                                                                        // ãðàíèöà êàíàëà
      double SL = ND(SessionLow - (HighV - LowV) - Tick);            // Ñòîï äëÿ Buy Stop
      double TP = ND(HighV);      // ïðîôèò äëÿ Buy Stop - ïðîòèâîïîëîæíàÿ ãðàíèöà êàíàëà
      if (OpenOrderCorrect(OP_BUYSTOP, Lots, Price, SL, TP, False) == 0)
        LastOpen[CurSession] = TimeCurrent();   // Îðäåð óñïåøíî îòêðûò, çàïèñûâàåì âðåìÿ
       else 
        return;
     }    
// - 1 - === Îêîí÷àíèå áëîêà ============================================================

// - 2 - === Óñòàíîâêà îðäåðà Sell Stop =================================================
 if (LastOpen[CurSession] < NowDay)   // Óñòàíàâëèâàëñÿ ëè îðäåð çà âðåìÿ òåêóùåé ñåññèè?
   if (Close[1] > HighV && Open[1] > HighV)// Öåíà çàêðåïèëàñü çà âåðõíåé ãðàíèöåé êàíàëà
     {
      RefreshRates();
      Price = ND(HighV);              // Öåíà îòêðûòèÿ Sell Stop - âåðõíÿÿ ãðàíèöà êàíàëà
      SL = ND(SessionHigh + (HighV - LowV) + Spread + Tick);        // Ñòîï äëÿ Sell Stop
      TP = ND(LowV + Spread);    // ïðîôèò äëÿ Sell Stop - ïðîòèâîïîëîæíàÿ ãðàíèöà êàíàëà
      if (OpenOrderCorrect(OP_SELLSTOP, Lots, Price, SL, TP, False) == 0)
        LastOpen[CurSession] = TimeCurrent();   // Îðäåð óñïåøíî îòêðûò, çàïèñûâàåì âðåìÿ
       else 
        return;
     }    
// - 2 - === Îêîí÷àíèå áëîêà ============================================================
   
 LastBar = Time[0];                                 // Áîëüøå íà òåêóùåì áàðå íå ðàáîòàåì
}
  
//+-------------------------------------------------------------------------------------+
//| Ôóíêöèÿ START ýêñïåðòà                                                              |
//+-------------------------------------------------------------------------------------+
int start()
  {
// - 1 - === Ðàçðåøåíî ëè ñîâåòíèêó ðàáîòàòü? ===========================================
   if (!Activate || FatalError)             // Îòêëþ÷àåòñÿ ðàáîòà ñîâåòíèêà, åñëè ôóíêöèÿ
     return(0);          //  init çàâåðøèëàñü ñ îøèáêîé  èëè èìåëà ìåñòî ôàòàëüíàÿ îøèáêà
// - 1 - === Îêîí÷àíèå áëîêà ============================================================

// - 2 - == Êîíòðîëü îáðàçîâàíèÿ íîâîãî áàðà äëÿ óñêîðåíèÿ ðàáîòû ýêñïåðòà ==============
   if (LastBar == Time[0])
     return(0);
// - 2 - === Îêîí÷àíèå áëîêà ============================================================
     
// - 3 - == Ñáîð èíôîðìàöèè îá óñëîâèÿõ òîðãîâëè ========================================
   Spread = ND(MarketInfo(Symbol(), MODE_SPREAD)*Point);                 // òåêóùèé ñïðýä
   StopLevel = ND(MarketInfo(Symbol(), MODE_STOPLEVEL)*Point);  // òåêóùèé óðîâåíü ñòîïîâ 
// - 3 - === Îêîí÷àíèå áëîêà ============================================================
   
// - 4 - == Îïðåäåëåíèå âðåìåíè íà÷àëà òåêóùåãî äíÿ è ðàñ÷åò óðîâíåé ====================
   NowDay = iTime(Symbol(), PERIOD_D1, 0);
   GetSignal();
// - 4 - === Îêîí÷àíèå áëîêà ============================================================

// - 5 - == Óñòàíîâêà îòëîæåííîãî îðäåðà, åñëè îïðåäåëåíû óðîâíè ========================
   if (LowV != 0 && HighV != 0 && CurSession != -1)
      DoTransactions();
// - 5 - === Îêîí÷àíèå áëîêà ============================================================

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