Zeit-Enumeration über 0Uhr Problem optimieren (EA mit 2 Zeitfenstern (Signal&Trading) Wie zeiteffizient gestalten?? - Seite 2

Neuer Kommentar
 

@Carl Schreiber

Ist das So richtig eingesetzt? (+ Hast du ne idee, wie ich die DayChanged() Funktion abändern kann, sodass der "Tag" bei checkTimeBegin "beginnt und aufhöhrt"?

enum ENUM_T30
{
   H00M00 =     0, // 00:00
   H00M30 =  1800, // 00:30
   H01M00 =  3600, // 01:00
   H01M30 =  5400, // 01:30
   H02M00 =  7200, // 02:00
   H02M30 =  9000, // 02:30
   H03M00 = 10800, // 03:00
   H03M30 = 12600, // 03:30
   H04M00 = 14400, // 04:00
   H04M30 = 16200, // 04:30
   H05M00 = 18000, // 05:00
   H05M30 = 19800, // 05:30
   H06M00 = 21600, // 06:00
   H06M30 = 23400, // 06:30
   H07M00 = 25200, // 07:00
   H07M30 = 27000, // 07:30
   H08M00 = 28800, // 08:00
   H08M30 = 30600, // 08:30
   H09M00 = 32400, // 09:00
   H09M30 = 34200, // 09:30
   H10M00 = 36000, // 10:00
   H10M30 = 37800, // 10:30
   H11M00 = 39600, // 11:00
   H11M30 = 41400, // 11:30
   H12M00 = 43200, // 12:00
   H12M30 = 45000, // 12:30
   H13M00 = 46800, // 13:00
   H13M30 = 48600, // 13:30
   H14M00 = 50400, // 14:00
   H14M30 = 52200, // 14:30
   H15M00 = 54000, // 15:00
   H15M30 = 55800, // 15:30
   H16M00 = 57600, // 16:00
   H16M30 = 59400, // 16:30
   H17M00 = 61200, // 17:00
   H17M30 = 63000, // 17:30
   H18M00 = 64800, // 18:00
   H18M30 = 66600, // 18:30
   H19M00 = 68400, // 19:00
   H19M30 = 70200, // 19:30
   H20M00 = 72000, // 20:00
   H20M30 = 73800, // 20:30
   H21M00 = 75600, // 21:00
   H21M30 = 77400, // 21:30
   H22M00 = 79200, // 22:00
   H22M30 = 81000, // 22:30
   H23M00 = 82800, // 23:00
   H23M30 = 84600  // 23:30
};

#ifdef __MQL5__

   int Hour()
   {
      MqlDateTime tm;
      TimeCurrent(tm);
      return(tm.hour);
   }

   int Day()
   {
      MqlDateTime tm;
      TimeCurrent(tm);
      return(tm.day);
   }

#endif

bool DayChanged()
{
   static int oldDay=Day();
   int newDay=Day();
   if(oldDay!=newDay)
      {
         oldDay=newDay;
         return(true);
      }
   return(false);
}

datetime EnumToDateTime(ENUM_T15 value)
{
   return(StringToTime(TimeToString(TimeCurrent(), TIME_DATE))+value);
}

datetime EnumToDateTime(ENUM_T30 value)
{
   return(StringToTime(TimeToString(TimeCurrent(), TIME_DATE))+value);
}

void NormalizeRange(datetime &rStart, datetime rEnd)
{
   if(rStart>rEnd)
      rStart-=86400;
}

bool InTimeRange(datetime aDateTime, datetime rStart, datetime rEnd)
{
   bool result=(aDateTime>=rStart) && (aDateTime<=rEnd);
   return(result);
}


//+------------------------------------------------------------------+
input ENUM_T30 inp_CheckTimeBegin = H00M00;  // Zeitspanne check High/Low Begin
input ENUM_T30 inp_CheckTimeEnd   = H08M00;  // Zeitspanne check High/Low Ende
input ENUM_T30 inp_TradeTimeBegin = H09M00;  // Handelszeit Begin
input ENUM_T30 inp_TradeTimeEnd   = H22M00;  // Handelszeit Ende
input ENUM_T30 inp_MinimaleCheckDauer =H05M00; //Minimale Zeitdauer des checkfensters
input int      inp_OffsetPending  =      3;  // Offset pending Orders (points)
input double   inp_Lotsize        =   0.01;  // Lots
input int      inp_SLLong             =    145;  // SL (points)
input int      inp_TPLong             =    250;  // TP (points)
input int      inp_SLShort             =    145;  // SL (points)
input int      inp_TPShort             =    250;  // TP (points)
input int      MagicNummer             =  77777;



//+------------------------------------------------------------------+

int BuyStop,SellStop;
bool SL_Setzen,TP_Setzen,SL_Setzen2,TP_Setzen2;
double StopLossShort,StopLossLong,TakeProfitShort,TakeProfitLong,NewTP;
static bool siglong,sigshort;
static datetime lastOrderLong,lastOrderShort,lastSigLong,lastSigShort;

double   higestHI,
         lowestLO;

double   offset=inp_OffsetPending*_Point,
         slDistLong=inp_SLLong*_Point,
         tpDistLong=inp_TPLong*_Point,
         slDistShort=inp_SLShort*_Point,
         tpDistShort=inp_TPShort*_Point;

datetime checkTimeBegin,
         checkTimeEnd,
         tradeTimeBegin,
         tradeTimeEnd;
         
         checkTimeBegin = (HoD(TimeCurrent() >= HoD(checkTimeEnd) ? HoD(TimeCurrent()) : HoD(TimeCurrent())+ 24)); //ist diese ergänzung richtig??
         checkTimeEnd =   (HoD(TimeCurrent() >= HoD(checkTimeBegin) ? HoD(TimeCurrent()) : HoD(TimeCurrent())+ 24)); 

                                                                                                   //Was ist mit tradeTimeBegin & tradeTimeEnd, auch umrechnen?

         



bool     calculated,
         setpending;

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
#define  HoD(t) ((int)(((t)%86400)/3600))                // Hour of Day 2018.02.03 17:55:56 => (int) 17
int OnInit()
{
   checkTimeBegin=EnumToDateTime(inp_CheckTimeBegin);
   checkTimeEnd  =EnumToDateTime(inp_CheckTimeEnd  );
   tradeTimeBegin=EnumToDateTime(inp_TradeTimeBegin);
   tradeTimeEnd  =EnumToDateTime(inp_TradeTimeEnd  );

   NormalizeRange(checkTimeBegin,checkTimeEnd);
   NormalizeRange(tradeTimeBegin,tradeTimeEnd);

   calculated=false;
   setpending=false;

   DeleteAllPendingOrders();

   return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void OnTick()
        {
         if(DayChanged())
            OnInit();
         
         
         if (InTimeRange(HoD(TimeCurrent()),checkTimeBegin, checkTimeEnd))
            {
            if(!calculated)
               {
               calculated=Calculate();
               }
             }  
       

        if (InTimeRange(HoD(TimeCurrent()),tradeTimeBegin, tradeTimeEnd))
           {
            if(!setpending)
              {
               setpending=SetPending();
              }
           }
        }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool Calculate()
{
   double values[];

   if(CopyHigh(_Symbol,_Period,checkTimeBegin,checkTimeEnd,values)==WRONG_VALUE) return(false);
   higestHI=values[ArrayMaximum(values)];

   if(CopyLow (_Symbol,_Period,checkTimeBegin,checkTimeEnd,values)==WRONG_VALUE) return(false);
   lowestLO=values[ArrayMinimum(values)];

   return(true);
}
 
Bayne:

ich meine in der onInit(),

oder habe ich es Flasch verstanden, dass sobald sich der Tag ändert (also nicht die Range von checkTimeBegin zu checkTimeEnd, sondern das reale Tagesdatum), die OnInit() durchgeführt wird -> welche dann unabhängig von der InTimeRange() bools =false setzt & PendingOrders löscht

Dir ist schon bewußt, daß bei einem Wechsel des Timeframes OnDeInit() und OnInit() ausgeführt werden?

Also alle Orders futsch sind-

Deshalb würde ich 

DeleteAllPendingOrders();

nicht in die OnInit() schreiben.

 
Otto Pauser:

Dir ist schon bewußt, daß bei einem Wechsel des Timeframes OnDeInit() und OnInit() ausgeführt werden?

Also alle Orders futsch sind-

Deshalb würde ich

nicht in die OnInit() schreiben.

Ist ursprünglich dein Code ;)


1.habe ich Oben der Code richtig eingesetzt?

2.Wie muss ich denn nun die Daychanged() umändern, damit der Tag bei checkTimeBegin endet und aufhört? (das ist das Ziel)

3.Die DeleteAllPendingOrders() war ja vorher schon da, wo soll sie stattdessen am besten hin? (so?)

if(InTimeRange(TimeCurrent(),checkTimeBegin,checkTimeEnd)){
      DeleteAllPendingOrders();
      if(!calculated)
         calculated=Calculate();}

(+4. Wieso wird denn der Timeframe gewechselt? (soll weiterhin alles im 30Min passieren) + Wieso würden die Orders denn geschlossen, das passiert ja auch nicht wenn ich im Metatrader einen EA einfach rausnehme oder?

 

Lies doch mal die Artikel hier:

https://www.mql5.com/de/articles/4534

https://www.mql5.com/en/articles/59

Beide beschreiben, wie sie zu bestimmten Zeiten handeln...

Vergleichende Analyse von 10 Handelsstrategien für Seitwärtsbewegungen
Vergleichende Analyse von 10 Handelsstrategien für Seitwärtsbewegungen
  • www.mql5.com
Trendfolgende Strategien sind vor allem für Anfänger sehr beliebt und einfach zu handhaben. Allerdings sind die aktuellen Märkte dynamischer geworden, während die Trendbewegungen weniger ausgeprägt sind (sowohl hinsichtlich der Reichweite als auch der Dauer). Indem wir die Möglichkeit des Handels in flachen oder seitwärts gerichteten Märkten...
 
Carl Schreiber:

Lies doch mal die Artikel hier:

https://www.mql5.com/de/articles/4534

https://www.mql5.com/en/articles/59

Beide beschreiben, wie sie zu bestimmten Zeiten handeln...

Der zweite hat mich auf eine Idee gebracht:

Die Phasen werde als bool genutzt und genau einmal bestätigt (wenn die eine True gesetzt wird, wird die andere false gesetzt)

Die OnTick wurde dementsprechend angepasst... ==> So funktioniert es rein theoretisch => ich würde es ja testen jedoch ist es extrem langsam...


Ich finde einfach keinen weg, wie ich die CheckPhase übernacht laufen lassen kann und genau deshalb habe ich eigentlich diesen Thread eröffnet


bool CheckSession()
{
//Wenn richtige Reihenfolge

if (inp_CheckTimeBegin<inp_CheckTimeEnd){

      if(TimeCurrent()>=checkTimeBegin && TimeCurrent()<=checkTimeEnd)
         {
         CheckSessionChecked=true;
         TradeSessionChecked=false;
         return(true);
         }
      return(false);}

//Wenn CheckPhase über Nacht geht

else if (inp_CheckTimeBegin>inp_CheckTimeEnd){

      if(TimeCurrent()>=checkTimeBegin || TimeCurrent()<=checkTimeEnd)
         {
         CheckSessionChecked=true;
         TradeSessionChecked=false;
         return(true);
         }
      }
 return(false);
 }
         
bool TradeSession()
  {
  //Wenn richtige Reihenfolge

  if (inp_CheckTimeBegin<inp_CheckTimeEnd){

      if(TimeCurrent()>=checkTimeBegin && TimeCurrent()<=checkTimeEnd)
         {
         TradeSessionChecked=true;
         CheckSessionChecked=false;
         return(true);
         }
      return(false);}

//Wenn CheckPhase über Nacht geht

else if (inp_CheckTimeBegin>inp_CheckTimeEnd){

      if(TimeCurrent()>=checkTimeBegin||TimeCurrent()<=checkTimeEnd)
         {
         TradeSessionChecked=true;
         CheckSessionChecked=false;
         return(true);
         }
      }
return(false);
}




void OnTick()
        {
         if(!CheckSessionChecked && TimeCurrent()>=checkTimeBegin ){
            if(CheckSession()){OnInit();}

         if(!TradeSessionChecked && TimeCurrent()>=tradeTimeBegin){
            if(TradeSession()==false)
            }

   if(InTimeRange(TimeCurrent(),checkTimeBegin,checkTimeEnd))
      if(!calculated)
         calculated=Calculate();

   if(InTimeRange(TimeCurrent(),tradeTimeBegin,tradeTimeEnd)){
      if(!setpending){
         setpending=SetPending();}
         }
        }
 

Ich denke ich habe den Fehler gefunden

void NormalizeRange(datetime &rStart, datetime rEnd)
{
   if(rStart>rEnd)
      rStart-=86400;
}

Verschiebt den Start um einen Tag nach hinten (in die Vergangenheit).

Richtig ist:

void NormalizeRange(datetime &rStart, datetime rEnd)
{
   if(rStart>rEnd)
      rEnd+=86400;
}

Das Ende muss einen Tag in die Zukunft verschoben werden.

Bei der Vorstellung der Zeitgeraden ist mir das klar geworden.

 
Warum zählst eigentlich nicht die bars am M1. Das gilt immer und überall
 
Bayne:

Der zweite hat mich auf eine Idee gebracht:

Die Phasen werde als bool genutzt und genau einmal bestätigt (wenn die eine True gesetzt wird, wird die andere false gesetzt)

Die OnTick wurde dementsprechend angepasst... ==> So funktioniert es rein theoretisch => ich würde es ja testen jedoch ist es extrem langsam...


Ich finde einfach keinen weg, wie ich die CheckPhase übernacht laufen lassen kann und genau deshalb habe ich eigentlich diesen Thread eröffnet


In den Eingabevariablen legst Du die Stunden von Anfang und Ende fest, zB. anf = 23, end = 04;

In OnInit(() machst Du aus 04 => 28: if (anf > end) end += 24; // jetzt 23 .. 28

In OnTick() machst Du gleich am Anfang:

void OnTick() {   
   int hTC = HoD(TimeCurrent());
   if (hTC < anf) hTC += 24;
   if ( hTC < anf || hTC > end) {
      if (..) deletePendOrd();  //event. offene PendingOrders löschen
      return;
   }
   ...
 

Ich komme gar nicht mehr mit,weiß gar nicht wo was jetzt rein soll... kannst du das bitte mal alles in den Code einsetzten?

Das wäre der Code vor der Threaderstellung, Wäre dir echt sehr dankbar, denn ich weiß nicht was ich bisher richtig und was falsch eingesetzt habe...

//+------------------------------------------------------------------+
//| https://www.mql5.com/de/forum/300700
//| https://www.deutschefxbroker.de/daily-breakout-strategie-einfaches-konzept-grosse-wirkung/
//+------------------------------------------------------------------+

// all values are seconds


enum ENUM_T30
{
   H00M00 =     0, // 00:00
   H00M30 =  1800, // 00:30
   H01M00 =  3600, // 01:00
   H01M30 =  5400, // 01:30
   H02M00 =  7200, // 02:00
   H02M30 =  9000, // 02:30
   H03M00 = 10800, // 03:00
   H03M30 = 12600, // 03:30
   H04M00 = 14400, // 04:00
   H04M30 = 16200, // 04:30
   H05M00 = 18000, // 05:00
   H05M30 = 19800, // 05:30
   H06M00 = 21600, // 06:00
   H06M30 = 23400, // 06:30
   H07M00 = 25200, // 07:00
   H07M30 = 27000, // 07:30
   H08M00 = 28800, // 08:00
   H08M30 = 30600, // 08:30
   H09M00 = 32400, // 09:00
   H09M30 = 34200, // 09:30
   H10M00 = 36000, // 10:00
   H10M30 = 37800, // 10:30
   H11M00 = 39600, // 11:00
   H11M30 = 41400, // 11:30
   H12M00 = 43200, // 12:00
   H12M30 = 45000, // 12:30
   H13M00 = 46800, // 13:00
   H13M30 = 48600, // 13:30
   H14M00 = 50400, // 14:00
   H14M30 = 52200, // 14:30
   H15M00 = 54000, // 15:00
   H15M30 = 55800, // 15:30
   H16M00 = 57600, // 16:00
   H16M30 = 59400, // 16:30
   H17M00 = 61200, // 17:00
   H17M30 = 63000, // 17:30
   H18M00 = 64800, // 18:00
   H18M30 = 66600, // 18:30
   H19M00 = 68400, // 19:00
   H19M30 = 70200, // 19:30
   H20M00 = 72000, // 20:00
   H20M30 = 73800, // 20:30
   H21M00 = 75600, // 21:00
   H21M30 = 77400, // 21:30
   H22M00 = 79200, // 22:00
   H22M30 = 81000, // 22:30
   H23M00 = 82800, // 23:00
   H23M30 = 84600  // 23:30
};

#ifdef __MQL5__

   int Hour()
   {
      MqlDateTime tm;
      TimeCurrent(tm);
      return(tm.hour);
   }

   int Day()
   {
      MqlDateTime tm;
      TimeCurrent(tm);
      return(tm.day);
   }

#endif

bool DayChanged()
{
   static int oldDay=Day();
   int newDay=Day();
   if(oldDay!=newDay)
      {
         oldDay=newDay;
         return(true);
      }
   return(false);
}

datetime EnumToDateTime(ENUM_T15 value)
{
   return(StringToTime(TimeToString(TimeCurrent(), TIME_DATE))+value);
}

datetime EnumToDateTime(ENUM_T30 value)
{
   return(StringToTime(TimeToString(TimeCurrent(), TIME_DATE))+value);
}

void NormalizeRange(datetime &rStart, datetime rEnd)
{
   if(rStart>rEnd)
      rStart-=86400;
}

bool InTimeRange(datetime aDateTime, datetime rStart, datetime rEnd)
{
   bool result=(aDateTime>=rStart) && (aDateTime<=rEnd);
   return(result);
}


//+------------------------------------------------------------------+
input ENUM_T30 inp_CheckTimeBegin = H00M00;  // Zeitspanne check High/Low Begin
input ENUM_T30 inp_CheckTimeEnd   = H08M00;  // Zeitspanne check High/Low Ende
input ENUM_T30 inp_TradeTimeBegin = H09M00;  // Handelszeit Begin
input ENUM_T30 inp_TradeTimeEnd   = H22M00;  // Handelszeit Ende
input ENUM_T30 inp_MinimaleCheckDauer =H05M00; //Minimale Zeitdauer des checkfensters
input int      inp_OffsetPending  =      3;  // Offset pending Orders (points)
input double   inp_Lotsize        =   0.01;  // Lots
input int      inp_SLLong             =    145;  // SL (points)
input int      inp_TPLong             =    250;  // TP (points)
input int      inp_SLShort             =    145;  // SL (points)
input int      inp_TPShort             =    250;  // TP (points)
input int      MagicNummer             =  77777;



//+------------------------------------------------------------------+

int BuyStop,SellStop;
bool SL_Setzen,TP_Setzen,SL_Setzen2,TP_Setzen2;
double StopLossShort,StopLossLong,TakeProfitShort,TakeProfitLong,NewTP;
static bool siglong,sigshort;
static datetime lastOrderLong,lastOrderShort,lastSigLong,lastSigShort;

double   higestHI,
         lowestLO;

double   offset=inp_OffsetPending*_Point,
         slDistLong=inp_SLLong*_Point,
         tpDistLong=inp_TPLong*_Point,
         slDistShort=inp_SLShort*_Point,
         tpDistShort=inp_TPShort*_Point;

datetime checkTimeBegin,
         checkTimeEnd,
         tradeTimeBegin,
         tradeTimeEnd;

bool     calculated,
         setpending;

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int OnInit()
{


   checkTimeBegin=EnumToDateTime(inp_CheckTimeBegin);
   checkTimeEnd  =EnumToDateTime(inp_CheckTimeEnd  );
   tradeTimeBegin=EnumToDateTime(inp_TradeTimeBegin);
   tradeTimeEnd  =EnumToDateTime(inp_TradeTimeEnd  );

   NormalizeRange(checkTimeBegin,checkTimeEnd);
   NormalizeRange(tradeTimeBegin,tradeTimeEnd);

   calculated=false;
   setpending=false;

   DeleteAllPendingOrders();

   return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void OnTick()
{
   if(DayChanged())
      OnInit();

   if(!InTimeRange(TimeCurrent(),checkTimeBegin,checkTimeEnd))
      if(!calculated)
         calculated=Calculate();

   if(InTimeRange(TimeCurrent(),tradeTimeBegin,tradeTimeEnd)){
      if(!setpending){
         setpending=SetPending();}
         }
}

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool Calculate()
{
   double values[];

   if(CopyHigh(_Symbol,_Period,checkTimeBegin,checkTimeEnd,values)==WRONG_VALUE) return(false);
   higestHI=values[ArrayMaximum(values)];

   if(CopyLow (_Symbol,_Period,checkTimeBegin,checkTimeEnd,values)==WRONG_VALUE) return(false);
   lowestLO=values[ArrayMinimum(values)];

   return(true);
}

bool SetPending()
{
   double price;

   price=higestHI+offset;
   //Trade.BuyStop (inp_Lotsize,price,_Symbol,price-slDist,price+tpDist);
   BuyStop =OrderSend(NULL,OP_BUYSTOP,inp_Lotsize,price,inp_OffsetPending,price-slDistLong,price+tpDistLong,"BUYSTOP",MagicNummer,0,clrBlue);

   price=lowestLO-offset;
   //Trade.SellStop(inp_Lotsize,price,_Symbol,price+slDist,price-tpDist);
   SellStop =OrderSend(NULL,OP_SELLSTOP,inp_Lotsize,price,inp_OffsetPending,price+slDistShort,price-tpDistShort,"BUYSTOP",MagicNummer,0,clrRed);
   return(true);
}
/*
void DeleteAllOrders(string sym)
{
   for(int i=OrdersTotal()-1; i>=0; i--)                 // do not confuse with PositionsTotal()
      {
      OrderSelect(i,SELECT_BY_TICKET)
         ulong   Ticket=OrderTicket(i);               // do not confuse with PositionGetTicket()
         string  Symbol=OrderGetString(ORDER_SYMBOL);    // do not confuse with PositionGetString
         if(Symbol==sym)
            OrderDelete(Ticket);                   // do not confuse with PositionClose()
      }
}*/
void DeleteAllPendingOrders(){
   for(int i=0;i<OrdersTotal();i++){
     if (OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==true){
     if(OrderSymbol()==Symbol() && OrderMagicNumber()==MagicNummer && ((OrderType()==OP_BUYSTOP) || (OrderType()==OP_SELLSTOP) || (OrderType()==OP_BUYLIMIT) || (OrderType()==OP_SELLLIMIT)) &&OrderOpenTime()<=0){
       int Ticket = OrderTicket();
       OrderDelete(Ticket);
       if (OrderDelete(Ticket)==false){GetLastError();}
       }}
}}
 
Bayne:

Ich komme gar nicht mehr mit,weiß gar nicht wo was jetzt rein soll... kannst du das bitte mal alles in den Code einsetzten?

Das wäre der Code vor der Threaderstellung, Wäre dir echt sehr dankbar, denn ich weiß nicht was ich bisher richtig und was falsch eingesetzt habe...

Schau wie klein er geworden ist Dein EA (UNGETESTET!):

//+------------------------------------------------------------------+
//| https://www.mql5.com/de/forum/300700
//| https://www.deutschefxbroker.de/daily-breakout-strategie-einfaches-konzept-grosse-wirkung/
//+------------------------------------------------------------------+

// 
#define  HoD(t) ((int)(((t)%86400)/3600))   // Hour of Day 2018.02.03 17:55:56 => (int) 17

//+------------------------------------------------------------------+
input int inp_CheckTimeBegin     = 00;  // Zeit (Stunde) check High/Low Beginn
input int inp_CheckTimeEnd       = 08;  // Zeit (Stunde) check High/Low Ende
input int inp_TradeTimeBegin     = 09;  // Handelszeit Beginn (Stunde)
input int inp_TradeTimeEnd       = 22;  // Handelszeit Ende   (Stunde)
int CheckBeg,CheckEnd,TradeBeg,TradeEnd;

input int      inp_OffsetPending =      3;  // Offset pending Orders (points)
input double   inp_Lotsize       =   0.01;  // Lots
input int      inp_SLLong        =    145;  // SL (points)
input int      inp_TPLong        =    250;  // TP (points)
input int      inp_SLShort       =    145;  // SL (points)
input int      inp_TPShort       =    250;  // TP (points)
input int      MagicNummer       =  77777;




//+------------------------------------------------------------------+

int BuyStop,SellStop;
bool SL_Setzen,TP_Setzen,SL_Setzen2,TP_Setzen2;
double StopLossShort,StopLossLong,TakeProfitShort,TakeProfitLong,NewTP;
static bool siglong,sigshort;
static datetime lastOrderLong,lastOrderShort,lastSigLong,lastSigShort;

double   higestHI,
         lowestLO;

double   offset=inp_OffsetPending*_Point,
         slDistLong=inp_SLLong*_Point,
         tpDistLong=inp_TPLong*_Point,
         slDistShort=inp_SLShort*_Point,
         tpDistShort=inp_TPShort*_Point;

datetime checkTimeBegin,
         checkTimeEnd,
         tradeTimeBegin,
         tradeTimeEnd;

bool     calculated,
         setpending;

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int OnInit()
{


   CheckBeg = inp_CheckTimeBegin;
   CheckEnd = inp_CheckTimeEnd<inp_CheckTimeBegin ? inp_CheckTimeEnd+24 : inp_CheckTimeEnd;
   TradeBeg = inp_TradeTimeBegin;
   TradeEnd = inp_TradeTimeEnd<inp_TradeTimeBegin ? inp_TradeTimeEnd+24 : inp_TradeTimeEnd;

   //NormalizeRange(checkTimeBegin,checkTimeEnd);
   //NormalizeRange(tradeTimeBegin,tradeTimeEnd);

   calculated=false;
   setpending=false;

   DeleteAllPendingOrders();

   return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void OnTick() {

   int hTC_Trade, hTC_Check = HoD(TimeCurrent());
   hTC_Trade = (hTC_Check < TradeBeg) ? hTC_Check+24 : hTC_Check; // hTC_Checkist bis hier eine temp-variable
   if (hTC_Check < CheckBeg) hTC_Check += 24;
   
   // first check if it's time to check
   if      ( hTC_Check >= CheckBeg && hTC_Check <= CheckEnd )
                  if(!calculated) calculated=Calculate();
   // then trade if it's time to trade
   else if ( hTC_Trade >= TradeBeg && hTC_Trade <= TradeEnd )
                  if(!setpending) setpending=SetPending();
   // else delete orders if prev. done OrdersTotal() returns 0 0< correct?
   else 
                  DeleteAllPendingOrders();  //event. offene PendingOrders löschen
}

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool Calculate()
{
   double values[];

   if(CopyHigh(_Symbol,_Period,checkTimeBegin,checkTimeEnd,values)==WRONG_VALUE) return(false);
   higestHI=values[ArrayMaximum(values)];

   if(CopyLow (_Symbol,_Period,checkTimeBegin,checkTimeEnd,values)==WRONG_VALUE) return(false);
   lowestLO=values[ArrayMinimum(values)];

   return(true);
}

bool SetPending()
{
   double price;

   price=higestHI+offset;
   //Trade.BuyStop (inp_Lotsize,price,_Symbol,price-slDist,price+tpDist);
   BuyStop =OrderSend(NULL,OP_BUYSTOP,inp_Lotsize,price,inp_OffsetPending,price-slDistLong,price+tpDistLong,"BUYSTOP",MagicNummer,0,clrBlue);

   price=lowestLO-offset;
   //Trade.SellStop(inp_Lotsize,price,_Symbol,price+slDist,price-tpDist);
   SellStop =OrderSend(NULL,OP_SELLSTOP,inp_Lotsize,price,inp_OffsetPending,price+slDistShort,price-tpDistShort,"BUYSTOP",MagicNummer,0,clrRed);
   return(true);
}
/*
void DeleteAllOrders(string sym)
{
   for(int i=OrdersTotal()-1; i>=0; i--)                 // do not confuse with PositionsTotal()
      {
      OrderSelect(i,SELECT_BY_TICKET)
         ulong   Ticket=OrderTicket(i);               // do not confuse with PositionGetTicket()
         string  Symbol=OrderGetString(ORDER_SYMBOL);    // do not confuse with PositionGetString
         if(Symbol==sym)
            OrderDelete(Ticket);                   // do not confuse with PositionClose()
      }
}*/
void DeleteAllPendingOrders(){
   for(int i=0;i<OrdersTotal();i++){
     if (OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==true){
     if(OrderSymbol()==Symbol() && OrderMagicNumber()==MagicNummer && ((OrderType()==OP_BUYSTOP) || (OrderType()==OP_SELLSTOP) || (OrderType()==OP_BUYLIMIT) || (OrderType()==OP_SELLLIMIT)) &&OrderOpenTime()<=0){
       int Ticket = OrderTicket();
       OrderDelete(Ticket);
       if (OrderDelete(Ticket)==false){GetLastError();}
       }}
}}
1234
Neuer Kommentar
Grund der Beschwerde: