// string PFX="OSCVolDir";
// string GPFX=PFX+"_"+_Symbol+"_";

void DeleteGlobals()
{
   ResetLastError();
   Print(" total Glob vars=",IntegerToString( GlobalVariablesTotal() ),
         " StringLen(",GPFX,")=",IntegerToString( StringLen(GPFX) )    );
   for(int i=0; i<GlobalVariablesTotal(); i++ )
   {
      string glob_name=GlobalVariableName(i);
      if(StringSubstr(glob_name,0,StringLen(GPFX))==GPFX)
      {
         Print(" i=",IntegerToString(i),
               " GlobalVariableName=",GlobalVariableName(i) );
         if( GlobalVariableDel(GlobalVariableName(i)) )
              Print(" i=",IntegerToString(i)," deleted: ",GlobalVariableName(i));
         else Print(" i=",IntegerToString(i)," delete error, code: ",IntegerToString(_LastError));
      }
   }
}

Uhrzeit = TimeHour(TimeCurrent())

if (Uhrzeit >= 10:00 Uhr) 
     if (Flagvariable = 1)
     then (Flagvariable = 0),
else (Mache nichts)

if (Uhrzeit = 10 Uhr) Flagvariable = 0.

void OnStart()
  {
   test();
  }


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


void test()
  {
   Print("TEST");
  }

void OnStart()
  {
   Print("test2");
  }

order_id = OrderSend(Symbol(),OP_SELL,l_lots,Bid,5,l_sl,l_tp,"short start",MAGICMA,0,Blue);

EventSetTimer(60);

return(INIT_SUCCEEDED);

int OnInit()

//+------------------------------------------------------------------+
//|                                                     10 20 EA.mq4 |
//|                        Copyright 2020, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2020, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property strict

input int pipsStopLoss=18;
input double takemulti=2.5;
input double lotsize=0.01;
int BuyTrade;
int SellTrade;

#include <Allerlei 1.mqh>

datetime LastActiontime;
//used to determine if a new bar has been formed



void InitializeVariables(){
  BuyTrade=0;
  SellTrade=0;
}


//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit(){
//---
  Print("Start Time is= ",TimeCurrent());
  LastActiontime=Time[1];
  //Print("die Zahl ",1.23456789," gerundet auf die ",_Digits,"te Nachkommastelle ergibt ", roundD(1.23456789));
  //Print("");
  //Print( DoubleToString(Wert, _Digits) );
  
  InitializeVariables();
  
   
//---
   return(INIT_SUCCEEDED);
}
  
  

  
  
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick() {
  RefreshRates();
  //only allows action if a new bar has formed
  if(LastActiontime==Time[1]){
    ActionsOncePerTick();
    return;
  }
  else
  {
    ActionsOncePerTick();
    ActionsOncePerBar();
    LastActiontime=Time[1];
    return;
  }  
//+------------------------------------------------------------------+
}


void ActionsOncePerBar(){

  //Print("Last Bar Time is= ",Time[1], "and last Close Price is= ",DoubleToString(Close[1],_Digits));
  Print("At the previous Bar, are the Bollinger Bands contracting? ", BBcontract() );
  Print("by how much compared to the previous bar? ", DoubleToString(BBContpercent(),2));
  Print("");
  


}

void ActionsOncePerTick(){
  RefreshRates();

  CheckTrades();
  return;
}

void CheckTrades(){
  RefreshRates();
  if(OrdersTotal()==0){
    InitializeVariables();
    OpenTrades();
  }
  else{
    UpdateTrades();
  }
}

void OpenTrades(){
 OpenBuyTrade();
 OpenSellTrade();
  
}


void OpenBuyTrade(){
  RefreshRates();
  double stoploss=NormalizeDouble(Bid-Point*pipsStopLoss,Digits);
  double takeprofit=NormalizeDouble(Bid+Point*takemulti*pipsStopLoss,Digits); 
  RefreshRates();
  BuyTrade=OrderSend(Symbol(),OP_BUY,lotsize,Bid,3,stoploss,takeprofit);

}


void OpenSellTrade(){
  RefreshRates();

  double stoploss=NormalizeDouble(Bid+Point*pipsStopLoss,Digits);
  double takeprofit=NormalizeDouble(Bid-Point*takemulti*pipsStopLoss,Digits); 
  RefreshRates();c
  SellTrade=OrderSend(Symbol(),OP_BUY,lotsize,Bid,3,stoploss,takeprofit);

}

void UpdateTrades(){
  RefreshRates();

  //Buy Trade
  OrderSelect(BuyTrade,SELECT_BY_TICKET);
  if(OrderStopLoss()<Bid-Point*pipsStopLoss){
    RefreshRates();
    OrderModify(OrderTicket(),OrderOpenPrice(),NormalizeDouble(Bid-Point*pipsStopLoss,Digits),OrderTakeProfit(),0,Blue);
  }

  OrderSelect(SellTrade,SELECT_BY_TICKET);
  if(OrderStopLoss()>Bid+Point*pipsStopLoss){
    RefreshRates();
    OrderModify(OrderTicket(),OrderOpenPrice(),NormalizeDouble(Bid+Point*pipsStopLoss,Digits),OrderTakeProfit(),0,Blue);
  }
  
}

2020.05.24 20:32:55.908	EURGBP,H4: 26851 tick events (24 bars, 27852 bar states) processed in 0:00:01.906 (total time 0:00:11.984)
2020.05.24 20:32:55.908	2020.04.02 23:58:09  10 20 EA EURGBP,H4: OrderSend error 130
2020.05.24 20:32:55.908	2020.04.02 23:58:09  10 20 EA EURGBP,H4: OrderSend error 138
2020.05.24 20:32:55.908	2020.04.02 23:58:07  10 20 EA EURGBP,H4: OrderSend error 130
2020.05.24 20:32:55.908	2020.04.02 23:58:07  10 20 EA EURGBP,H4: OrderSend error 138
2020.05.24 20:32:55.908	2020.04.02 23:57:30  10 20 EA EURGBP,H4: OrderSend error 130
2020.05.24 20:32:55.908	2020.04.02 23:57:30  10 20 EA EURGBP,H4: OrderSend error 138
2020.05.24 20:32:55.908	2020.04.02 23:56:52  10 20 EA EURGBP,H4: OrderSend error 130
2020.05.24 20:32:55.908	2020.04.02 23:56:52  10 20 EA EURGBP,H4: OrderSend error 138
2020.05.24 20:32:55.908	2020.04.02 23:56:15  10 20 EA EURGBP,H4: OrderSend error 130
2020.05.24 20:32:55.908	2020.04.02 23:56:15  10 20 EA EURGBP,H4: OrderSend error 138
2020.05.24 20:32:55.908	2020.04.02 23:55:37  10 20 EA EURGBP,H4: OrderSend error 130
2020.05.24 20:32:55.908	2020.04.02 23:55:37  10 20 EA EURGBP,H4: OrderSend error 138

   void CloseAllOpenPositions(string f, int intMaxSlippage) {
      if(debug)
         Print(">>>",f,"::",__FUNCTION__+"()");
      bool checkOrderClose=true;
      int index=OrdersTotal()-1;
      while(index>=0) {
         if(OrderSelect(index,SELECT_BY_POS,MODE_TRADES)) {
            Print(f,"::Close all Positions: ",TimeCurrent());
            if(OrderSymbol()==Symbol() && OrderMagicNumber()==magic) {
               if(OrderType()==OP_BUYSTOP || OrderType()==OP_SELLSTOP) {
                  checkOrderClose=OrderDelete(OrderTicket(),CLR_NONE);
                  if(!checkOrderClose) {
                     int errorCode=GetLastError();
                     if(errorCode==1 || errorCode==2 || errorCode==5 || errorCode==6 || errorCode==64 || errorCode==65 || errorCode==132 || errorCode==133 || errorCode==139) {
                        Print(__FUNCTION__," Error: delete pendingOrder ",OrderTicket(),"|",OrderComment(),"|",ErrorDescription(errorCode));
                     }
                  }
               }
            }
         }
         index--;
      }

Print(iTime(NULL,0,0));
oder 
Print(iTime(NULL,0,Bars-1));

//=============================================================================
void CheckToOpen()
{
   int    tckt;
   // === default values of Indi
   double upLi=iCustom(Symbol(),MAframe,INDI, 0,0); //HT.up,UpLine
   double dnLi=iCustom(Symbol(),MAframe,INDI, 1,0); //HT.dn,DnLine
   double Ssl=iCustom(Symbol(),MAframe,INDI, 2,0);  //chan.hi,UpperBorder
   double Lsl=iCustom(Symbol(),MAframe,INDI, 3,0);  //chan.low,LowerBorder
   double sigL=iCustom(Symbol(),MAframe,INDI, 4,0); //sig.up,= 1
   double sigS=iCustom(Symbol(),MAframe,INDI, 5,0); //sig.dn,=-1
   bool ShortOnly=(dnLi>0);                         //IfStoppedOutLastShort
   bool LongOnly=(upLi>0);                          //IfStoppedOutLastLong
   Print(__FUNCTION__," HT.up=",DoubleToStr(upLi,_Digits)," HT.dn=",DoubleToStr(dnLi,_Digits),
         " chan.hi=",DoubleToStr(Ssl,_Digits)," chan.lo=",DoubleToStr(Lsl,_Digits),
         " sig.up=",DoubleToStr(sigL,_Digits)," sig.dn=",DoubleToStr(sigS,_Digits) );
   // ============================================================= OpenShort
   if( (sigS==-1 || ShortOnly) && NoOfRunnings(Symbol())!=-1 ) //Sig.dn,HT.dn
   {
      tckt=OrderSend(Symbol(),OP_SELL,Lots,Bid,3,0,0,NULL,EAMAGIC,0,clrRed);
      Print(__FUNCTION__," tck: ",IntegerToString(tckt)," SL: ",DoubleToStr(Ssl,_Digits));
      if(tckt>0) 
      {  
         if(OrderSelect(tckt,SELECT_BY_TICKET))
         {
            Print(__FUNCTION__," order ",IntegerToString(tckt)," selectable");
            if(!OrderModify(tckt,OrderOpenPrice(),
                            NormalizeDouble(Ssl,_Digits),OrderTakeProfit(),0,clrOrange) )
               Print(__FUNCTION__," open short, SL: ",DoubleToStr(Ssl,_Digits) );
         }
      }
      return;
   }
   // ============================================================= OpenLong
   if( (sigL==1 || LongOnly) && NoOfRunnings(Symbol())!=1 ) //Sig.up,HT.up
   {
      tckt=OrderSend(Symbol(),OP_BUY,Lots,Ask,3,0,0,NULL,EAMAGIC,0,clrGreen);
      Print(__FUNCTION__," tck: ",IntegerToString(tckt)," SL: ",DoubleToStr(Lsl,_Digits));
      if(tckt>0)
      {  
         if(OrderSelect(tckt,SELECT_BY_TICKET))
         {
            Print(__FUNCTION__," order ",IntegerToString(tckt)," selectable");
            if(!OrderModify(tckt,OrderOpenPrice(),
                            NormalizeDouble(Lsl,_Digits),OrderTakeProfit(),0,clrOrange) )
               Print(__FUNCTION__," open long, SL: ",DoubleToStr(Lsl,_Digits) );
         }
      }
      return;
   }
}
//=============================================================================
void CheckToTrail()
{
   double Ssl=iCustom(Symbol(),MAframe,INDI, 2,0); //chan.hi
   double Lsl=iCustom(Symbol(),MAframe,INDI, 3,0); //chan.low

   for(int i=0; i<OrdersTotal(); i++)
   {
      if(OrderMagicNumber()!=EAMAGIC || OrderSymbol()!=Symbol()) continue;
   // ============================================================= TrailShort
      if( OrderType()==OP_SELL)
      {
         Print(__FUNCTION__," cur SL=",DoubleToStr(OrderStopLoss(),_Digits),
               " chan.hi=",DoubleToStr(Ssl,_Digits) );
         if(OrderStopLoss()>Ssl ) //SlHigherThanChan.hi
         {
            if(!OrderModify(OrderTicket(),OrderOpenPrice(),
                            NormalizeDouble(Ssl,_Digits),OrderTakeProfit(),0,clrOrange))
            Print(__FUNCTION__," fail modify short, SL ",DoubleToStr(Ssl,_Digits) );
         }
         break;
      }
   // ============================================================= TrailLong
      if(OrderType()==OP_BUY)
      {
         Print(__FUNCTION__," cur SL=",DoubleToStr(OrderStopLoss(),_Digits),
               " chan.low=",DoubleToStr(Lsl,_Digits) );
         if(OrderStopLoss()<Lsl ) //SlLowerThanChan.low
         {
            if(!OrderModify(OrderTicket(),OrderOpenPrice(),
                            NormalizeDouble(Lsl,_Digits),OrderTakeProfit(),0,clrOrange))
            Print(__FUNCTION__," fail modify long, SL ",DoubleToStr(Lsl,_Digits) );
         }
         break;
      }
   }
}