Startseite - Metatrader Forum | Forex Expert-Advisor

[Vorschau] MetaTrader 4 - CandleClock für Offline Charts
Forum: Indikatoren

129 Views:
1 Antworten:

vor 2 Tagen, 11:53
von AM581

[Vorschau] Zeitsteuerung für Aktion
Forum: Programmierung MQL5

231 Views:
0 Antworten:

vor einer Woche, 15:59
von Hippo25

[Vorschau]

Themenvorschau

Es ist der Klassiker - Außenstab und seine Range vom Hoch zum Tief.

Ich wollte und habe den Code selber geschrieben und mein Vorhaben nahezu komplett gelöst. Nun ist aber doch noch ein kleines, aber entscheidendes Problem aufgetaucht:

Wenn die Range vom Außenstab verlassen wird, soll der EA dies mit einem Print ausweisen und ab da an auch wieder Trades erlauben. Ich habe hierzu einen Array erstellt und fülle diesen Array mit Kursinformationen vom aktuellen Chart an.

Mit open der aktuellen Bar[0] wird der Außenstab Bar[2] ausgewiesen (Bar[1] entsprechend als Innenstab). Das klappt soweit alles.

Nun soll der EA wie oben erwähnt bei verlassen der Range vom Außenstab dies mitteilen und den Handel wieder erlauben. Das funktioniert ebenfalls, aber nur, wenn die Range mit der Bar[0], die den Außenstab deklariert hat, geschieht. Erfolgt der Range-Ausbruch ein oder mehrere Kerzen später, passiert nichts.

Ich vermute, dass der Fehler darin liegt, dass ich zwar die Bar[2] auslese und die Werte eine Variablen zuordne, doch beim öffnen der nächsten Bar passen die werte nicht mehr. Anders ausgedrückt: die Werte werden nur verwendet, solange es keine neue Bar gibt.

Kann man die Werte aus dem Array irgendwie fixieren, dass sie dauerhaft bleiben - zumindest bis sie getriggert werden?

Hier der Code dazu (der Code dient lediglich zu Lernzwecken und stellt keine Strategie dar):

--> es geht vermutlich hauptsächlich um die Bereiche
calcSetup()
calcOutsideBarRange()

Code:

//+------------------------------------------------------------------+
//|                                            lern- und test-EA.mq5 |
//|                                         Copyright 2024, Anfänger |
//+------------------------------------------------------------------+
#property copyright "Copyright 2024, Anfänger"
#property version   "1.10"

#include       <Trade/Trade.mqh>

enum ENUM_LOT  {LOT_FIX,LOT_AMOUNT,LOT_PERCENT};
enum ENUM_SL   {SL_FIX,SL_CANDLE};

input group    "SIGNAL"
input string   TimeRangeStart          = "11:02";
input string   TimeRangeEnd            = "11:12";

input group    "RISIKO"
input ENUM_LOT Lotcalculation          = LOT_AMOUNT;
input double   RiskInLots              = 0.2;
input double   RiskInAmount            = 10.00;
input double   RiskInPercent           = 0.25;

input group    "HANDEL"
input ENUM_SL  SlVariable              = SL_CANDLE;
input uint     SlInitial               = 1500;
input uint     TpInitial               = 3000;

input group    "DIVERS"
input uint     SymbolBuffer            = 100;
input ulong    Magic                   = 202403271656;

CTrade         trade;
ulong          buyTicket;
ulong          sellTicket;
double         high1;
double         low1;
static double  outsideBarHigh;
static double  outsideBarLow;
bool           outsideBar;
bool           outsideBarRange;
bool           noSignal;
bool           longSignal;
bool           shortSignal;
datetime       timeRangeStart;
datetime       timeRangeEnd;
datetime       timeSignal;


int OnInit(){
   static bool isInit = false;
   if(!isInit){
      isInit = true;
      Print(__FUNCTION__," > EA (re)start");
   }
   return(INIT_SUCCEEDED);
}

void OnDeinit(const int reason){
   
}

void OnTick(){
   //---TimeRange
   if(timeRangeStart != StringToTime(TimeRangeStart)){
      calcTimes();
   }
   
   //---Signal
   if(TimeCurrent() >= timeRangeStart && TimeCurrent() < timeRangeEnd){
      timeSignal = iTime(_Symbol,PERIOD_CURRENT,0);
      static datetime timestapSignal;
      if(timestapSignal != timeSignal){
         timestapSignal = timeSignal;
         calcSetup();
      }
   }
   
   //---Range Outsidebar
   if(outsideBar == true){
      calcOutsideBarRange();
   }
   
   //---Order
   if(longSignal == true){
      executeBuy();
   }
   longSignal = false;
   
   if(shortSignal == true){
      executeSell();
   }
   shortSignal = false;
   
   //---Close Order
   double bid = SymbolInfoDouble(_Symbol,SYMBOL_BID);
   
   if(OrderSelect(buyTicket) && bid <= OrderGetDouble(ORDER_SL)){
      closeOrder();
   }
   if(OrderSelect(sellTicket) && bid >= OrderGetDouble(ORDER_SL)){
      closeOrder();
   }
}

void calcTimes(){
   timeRangeStart = StringToTime(TimeRangeStart);
   timeRangeEnd   = StringToTime(TimeRangeEnd);
}

void calcSetup(){
   double bid = SymbolInfoDouble(_Symbol,SYMBOL_BID);
   
   // Array erstellen
   MqlRates priceInformation[];
   
   // Abwärts sortieren
   ArraySetAsSeries(priceInformation,true);
   
   // Preisdaten in das Array kopieren
   int Data = CopyRates(Symbol(),Period(),0,Bars(Symbol(),Period()),priceInformation);
     
   // Outsidebar[2] prüfen
   if(priceInformation[2].high >= priceInformation[1].high && priceInformation[2].low <= priceInformation[1].low){
      outsideBar = true;
      outsideBarHigh = priceInformation[2].high;
      outsideBarLow  = priceInformation[2].low;
      Print(priceInformation[2].time," no signal - outsideBar (H ",outsideBarHigh,"; L ",outsideBarLow,")");
      Print(priceInformation[1].time," no signal - insideBar");
   }else outsideBar = false;
      
   //---Candle 1
   double open1       = iOpen(_Symbol,PERIOD_CURRENT,1);
          high1       = iHigh(_Symbol,PERIOD_CURRENT,1);
          low1        = iLow(_Symbol,PERIOD_CURRENT,1);
   double close1      = iClose(_Symbol,PERIOD_CURRENT,1);
   
   //---Candle 2
   double open2       = iOpen(_Symbol,PERIOD_CURRENT,2);
   double high2       = iHigh(_Symbol,PERIOD_CURRENT,2);
   double low2        = iLow(_Symbol,PERIOD_CURRENT,2);
   double close2      = iClose(_Symbol,PERIOD_CURRENT,2);
   
   //---No Signal
   bool higherLowerBar = (high1 > high2 && low1 < low2);
   bool doji          = (open1 == close1);
   
   if(higherLowerBar == true){
      noSignal = true;
         if(outsideBar == true){
            Print(priceInformation[1].time," no signal (H/L-Bar) - inside an outsideBar ");
         }else Print(priceInformation[1].time," no signal - higherLowerBar ");
      return;
   }
   if(doji == true){
      noSignal = true;
         if(outsideBar == true){
            Print(priceInformation[1].time," no signal (doji) - inside an outsideBar ");
         }else Print(priceInformation[1].time," no signal - doji ");
      return;
   }
   
   //---Long Signal
   bool lowerLow      = (low1 < low2 && high1 <= high2);
   
   if(lowerLow == true){
      if(outsideBarRange == true){
         Print(priceInformation[1].time," no long signal - inside an outsideBarRange ");
      }else if(outsideBarRange == false){
         longSignal = true;
         Print(priceInformation[1].time," !!! LONG SIGNAL");
      }
   }
   
   //---Short Signal
   bool higherHigh    = (high1 > high2 && low1 >= low2);
   
   if(higherHigh == true){
      if(outsideBarRange == true){
         Print(priceInformation[1].time," no short signal - inside an outsideBarRange ");
      }else if(outsideBarRange == false){
         shortSignal = true;
         Print(priceInformation[1].time," !!! SHORT SIGNAL");
      }
   }
}

void calcOutsideBarRange(){
   double bid = SymbolInfoDouble(_Symbol,SYMBOL_BID);
   
   if(bid <= outsideBarHigh && bid >= outsideBarLow){
      outsideBarRange = true;
   }else if(bid > outsideBarHigh || bid < outsideBarLow){
      outsideBarRange = false;
      outsideBar =false;
      Print("  left OutsideBarRange");
   }
}

void executeBuy(){
   double ask   = SymbolInfoDouble(_Symbol,SYMBOL_ASK);
   double bid   = SymbolInfoDouble(_Symbol,SYMBOL_BID);
   double spread = roundUp(ask - bid);
   double sl = 0;
   
   double entry = roundUp(high1 + spread + SymbolBuffer * _Point);
   if(SlVariable == SL_FIX){
          sl    = entry - SlInitial * _Point;
   }else  sl    = roundUp(low1 - SymbolBuffer * _Point);
   double tp    = roundUp(entry + TpInitial * _Point);
   Print("  Long: entry ",entry," (spread ",spread,"), sl ",sl,", tp ",tp);
   
   double lots  = calclots(entry - sl);
   double price = SymbolInfoDouble(_Symbol,SYMBOL_BID);
   
   if(price < entry){  
      if(trade.BuyStop(lots,entry,_Symbol,sl,tp,0,0)){
         if(trade.ResultRetcode() == TRADE_RETCODE_DONE){
            buyTicket = trade.ResultOrder();
            Print("  --> Buy-Stop-Order #",buyTicket," was sent");
         }
      }
   }
   if(price >= entry){
      if(trade.Buy(lots,_Symbol,entry,sl,tp)){
         if(trade.ResultRetcode() == TRADE_RETCODE_DONE){
            buyTicket = trade.ResultOrder();
            Print("  --> Buy-Market-Order #",buyTicket," was sent");
         }
      }
   }
}

void executeSell(){
   double ask   = SymbolInfoDouble(_Symbol,SYMBOL_ASK);
   double bid   = SymbolInfoDouble(_Symbol,SYMBOL_BID);
   double spread = roundUp(ask - bid);
   double sl = 0;
   
   double entry = roundDn(low1 - SymbolBuffer * _Point);
   if(SlVariable == SL_FIX){
          sl    = entry + SlInitial * _Point;
   }else  sl    = roundDn(high1 + spread + SymbolBuffer * _Point);
   double tp    = roundDn(entry - TpInitial * _Point);
   Print("  Short: entry ",entry,", sl ",sl," (spread ",spread,"), tp ",tp);
   
   double lots  = calclots(sl - entry);
   double price = SymbolInfoDouble(_Symbol,SYMBOL_BID);
   
   if(price > entry){  
      if(trade.SellStop(lots,entry,_Symbol,sl,tp,0,0)){
         if(trade.ResultRetcode() == TRADE_RETCODE_DONE){
            sellTicket = trade.ResultOrder();
            Print("  --> Sell-Stop-Order #",sellTicket," was sent");
         }
      }
   }
   if(price <= entry){
      if(trade.Sell(lots,_Symbol,entry,sl,tp)){
         if(trade.ResultRetcode() == TRADE_RETCODE_DONE){
            sellTicket = trade.ResultOrder();
            Print("  --> Sell-Market-Order #",sellTicket," was sent");
         }
      }
   }
}

void closeOrder(){
   for(int i = OrdersTotal()-1; i >= 0; i--){
      buyTicket = OrderGetTicket(i);
      if(OrderGetString(ORDER_SYMBOL) != _Symbol && OrderGetInteger(ORDER_MAGIC) != Magic) continue;
      if(OrderSelect(buyTicket) && OrderGetInteger(ORDER_TYPE) == ORDER_TYPE_BUY_STOP){
         if(trade.OrderDelete(buyTicket)){
            Print("  -x-> Buy-Stop-Order #",buyTicket," gelöscht da SL erreicht");
         }
      }
   }
   for(int i = OrdersTotal()-1; i >= 0; i--){
      sellTicket = OrderGetTicket(i);
      if(OrderGetString(ORDER_SYMBOL) != _Symbol && OrderGetInteger(ORDER_MAGIC) != Magic) continue;
      if(OrderSelect(sellTicket) && OrderGetInteger(ORDER_TYPE) == ORDER_TYPE_SELL_STOP){
         if(trade.OrderDelete(sellTicket)){
            Print("  -x-> Sell-Stop-Order #",sellTicket," gelöscht da SL erreicht");
         }
      }
   }
}

double roundUp(double price){
   double ticksize = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_TRADE_TICK_SIZE),_Digits);
   price = NormalizeDouble(price,_Digits);
   double rest = price - NormalizeDouble(price/ticksize,0) * ticksize;
   rest = NormalizeDouble(rest,_Digits);
   if(rest != 0){
      for (double i = _Point; i <= ticksize; i += _Point){
         price = NormalizeDouble(price + _Point,_Digits);
         rest = price - NormalizeDouble(price/ticksize,0) * ticksize;
         rest = NormalizeDouble(rest,_Digits);
         if(rest == 0) break;
      }
   }
   return price;
}

double roundDn(double price){
   double ticksize = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_TRADE_TICK_SIZE),_Digits);
   price = NormalizeDouble(price,_Digits);
   double rest = price - NormalizeDouble(price/ticksize,0) * ticksize;
   rest = NormalizeDouble(rest,_Digits);
   if(rest != 0){
      for (double i = _Point; i <= ticksize; i += _Point){
         price = NormalizeDouble(price - _Point,_Digits);
         rest = price - NormalizeDouble(price/ticksize,0) * ticksize;
         rest = NormalizeDouble(rest,_Digits);
         if(rest == 0) break;
      }
   }
   return price;
}

double calclots(double slPoints){ // slPoints = Strecke (entry - sl; sl - entry)
   double lots = 0;
   double ticksize = SymbolInfoDouble(_Symbol,SYMBOL_TRADE_TICK_SIZE);
   double tickvalue = SymbolInfoDouble(_Symbol,SYMBOL_TRADE_TICK_VALUE);
   double lotstep = SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_STEP);
   double moneyPerLotstep = slPoints / ticksize * tickvalue * lotstep;

   if(Lotcalculation == LOT_FIX){
      lots = NormalizeDouble(RiskInLots,_Digits);
      Print("  Fixe Lotsize: ",lots," lots");
   }
   if(Lotcalculation == LOT_AMOUNT){
      lots = NormalizeDouble(MathFloor(RiskInAmount / moneyPerLotstep) * lotstep,_Digits);
      Print("  Lotsize berechnet über Betrag: ",lots," lots");
   }
   if(Lotcalculation == LOT_PERCENT){  // ACCOUNT_EQUITY = inkl. offene Positionen; ACCOUNT_BALANCE = ohne offene Positionen
      double riskPerTrade = AccountInfoDouble(ACCOUNT_EQUITY) * RiskInPercent / 100;
      lots = NormalizeDouble(MathFloor(riskPerTrade / moneyPerLotstep) * lotstep,_Digits);
      Print("  Lotsize prozentual berechnet: ",lots," lots");
   }
   lots = MathMin(lots,SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_MAX));
   lots = MathMax(lots,SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_MIN));
   return lots;
}

Vorab schon mal vielen Dank für die Tipps und Hinweise. :-)

Array-Wert trotz fortlaufender Bars...
Forum: Programmierung MQL5

99 Views:
1 Antworten:

vor 2 Wochen, 10:30
von murkel

[Vorschau]

Themenvorschau

Hallo zusammen,

da ich noch totaler Anfänger bin, habe ich einen "Übungs-EA" geschrieben, um mit diesem das eine oder andere zu lernen. Daher ist der unten anhängende Code keine Strategie, sondern dient in der Tat nur zu lernzwecken.

Durch den EA sollen lediglich bei höherem Hoch / tieferem Tief Buy- oder Sell-Stopp-Orders mit SL und TP in den Markt gesetzt werden. Das klappt schon mal fehlerfrei.

Dann soll, wenn die Order getriggert wurde, die Position mit erreichen des SL oder TP geschlossen werden. Auch das klappt fehlerfrei. Dass das fast nur Verluste bringt, soll hier keine Rolle spielen.

Orders, die im Markt sind und deren eigentlicher SL bereits vor dem Entry erreicht werden, sollen gelöscht werden. Dies klappt - aber nur teilweise.

Somit kommen wir zu meinem Problem:
Ich habe den SL mit der variablen "buyOrderDelete" und "sellOrderDelete" besetzt und wenn der Bid-Kurs <= buy/sellOrderDelete ist, soll die Order gelöscht werden. Macht der EA auch, doch wenn ich nun zwei (oder mehrere) offene Orders (in eine Richtung) habe, löscht er nur die erste Order - die anderen Order, deren SL ebenfalls erreicht wurde, bleiben im Markt.

Wie kann den jeweiligen SL der richtigen Order zuordnen - damit jede Order gelöscht wird, deren SL erreicht ist (nicht aber die Orders, deren SL noch nicht erreicht ist).

Code:

//+------------------------------------------------------------------+
//|                                            lern- und test-EA.mq5 |
//|                                         Copyright 2024, Anfänger |
//+------------------------------------------------------------------+
#property copyright "Copyright 2024, Anfänger"
#property version   "1.00"

#include       <Trade/Trade.mqh>

enum ENUM_LOT  {LOT_FIX,LOT_AMOUNT,LOT_PERCENT};
enum ENUM_SL   {SL_FIX,SL_CANDLE};

input group    "SIGNAL"
input string   TimeRangeStart          = "11:02";
input string   TimeRangeEnd            = "11:12";

input group    "RISIKO"
input ENUM_LOT Lotcalculation          = LOT_AMOUNT;
input double   RiskInLots              = 0.2;
input double   RiskInAmount            = 10.00;
input double   RiskInPercent           = 0.25;

input group    "HANDEL"
input ENUM_SL  SlVariable              = SL_CANDLE;
input uint     SlInitial               = 1500;
input uint     TpInitial               = 3000;

input group    "DIVERS"
input uint     SymbolBuffer            = 100;
input ulong    Magic                   = 202403271656;

CTrade         trade;
ulong          buyTicket;
ulong          sellTicket;
double         high1;
double         low1;
double         buyOrderDelete;
double         sellOrderDelete;
bool           noSignal;
bool           longSignal;
bool           shortSignal;
datetime       timeRangeStart;
datetime       timeRangeEnd;
datetime       timeSignal;


int OnInit(){
   static bool isInit = false;
   if(!isInit){
      isInit = true;
      Print(__FUNCTION__," > EA (re)start");
   }
   return(INIT_SUCCEEDED);
}

void OnDeinit(const int reason){
   
}

void OnTick(){
   //---TimeRange
   if(timeRangeStart != StringToTime(TimeRangeStart)){
      calcTimes();
   }
   
   //---Signal
   if(TimeCurrent() >= timeRangeStart && TimeCurrent() < timeRangeEnd){
      timeSignal = iTime(_Symbol,PERIOD_CURRENT,0);
      static datetime timestapSignal;
      if(timestapSignal != timeSignal){
         timestapSignal = timeSignal;
         calcSignal();
      }
   }
   
   //---Order
   if(longSignal == true){
      executeBuy();
   }
   longSignal = false;
   
   if(shortSignal == true){
      executeSell();
   }
   shortSignal = false;
   
   //---Close Order
   double bid = SymbolInfoDouble(_Symbol,SYMBOL_BID);
   
   if(bid <= buyOrderDelete && OrderSelect(buyTicket)){
      if(trade.OrderDelete(buyTicket)){
         Print("  -x-> Buy-Stop-Order #",buyTicket," cancelled, SL reached");
      }
   }
   if(bid >= sellOrderDelete && OrderSelect(sellTicket)){
      if(trade.OrderDelete(sellTicket)){
         Print("  -x-> Sell-Stop-Order #",sellTicket," cancelled, SL reached");
      }
   }
}

void calcTimes(){
   timeRangeStart = StringToTime(TimeRangeStart);
   timeRangeEnd   = StringToTime(TimeRangeEnd);
}

void calcSignal(){
   //---Candle 1
   double open1         = iOpen(_Symbol,PERIOD_CURRENT,1);
          high1         = iHigh(_Symbol,PERIOD_CURRENT,1);
          low1          = iLow(_Symbol,PERIOD_CURRENT,1);
   double close1        = iClose(_Symbol,PERIOD_CURRENT,1);
   
   //---Candle 2
   double open2         = iOpen(_Symbol,PERIOD_CURRENT,2);
   double high2         = iHigh(_Symbol,PERIOD_CURRENT,2);
   double low2          = iLow(_Symbol,PERIOD_CURRENT,2);
   double close2        = iClose(_Symbol,PERIOD_CURRENT,2);
   
   //---No Signal
   bool higherLowerBar  = (high1 > high2 && low1 < low2);
   bool insideBar       = (high1 <= high2 && low1 >= low2);
   bool doji            = (open1 == close1);
   
   if(higherLowerBar == true){
      noSignal = true;
      Print("  no signal - higherLowerBar ",higherLowerBar);
      return;
   }
   if(doji == true){
      noSignal = true;
      Print("  no signal - doji ",doji);
      return;
   }
   if(insideBar == true){
      noSignal = true;
      Print("  no signal - insideBar ",insideBar);
      return;
   }
   
   //---Long Signal
   bool lowerLow = (low1 < low2 && high1 <= high2);
   
   if(lowerLow == true){
      longSignal = true;
      Print("!!! LONG SIGNAL");
   }else
      {Print("  no long signal");
   }
   
   //---Short Signal
   bool higherHigh    = (high1 > high2 && low1 >= low2);
   
   if(higherHigh == true){
      shortSignal = true;
      Print("!!! SHORT SIGNAL");
   }else
      {Print("  no short signal");
   }
}

void executeBuy(){
   double ask     = SymbolInfoDouble(_Symbol,SYMBOL_ASK);
   double bid     = SymbolInfoDouble(_Symbol,SYMBOL_BID);
   double spread  = roundUp(ask - bid);
   double entry   = roundUp(high1 + spread + SymbolBuffer * _Point);
   double sl      = 0;
   
   if(SlVariable == SL_FIX){
      sl = entry - SlInitial * _Point;
   }else  sl = roundUp(low1 - SymbolBuffer * _Point);
   
   double tp = roundUp(entry + TpInitial * _Point);
   Print("  Long: entry ",entry," (spread ",spread,"), sl ",sl,", tp ",tp);
   
   double lots    = calclots(entry - sl);
   double price   = SymbolInfoDouble(_Symbol,SYMBOL_BID);
   
   if(price < entry){  
      if(trade.BuyStop(lots,entry,_Symbol,sl,tp,0,0)){
         if(trade.ResultRetcode() == TRADE_RETCODE_DONE){
            buyTicket = trade.ResultOrder();
            Print("  --> Buy-Stop-Order #",buyTicket," was sent");
            buyOrderDelete = sl;
         }
      }
   }
   if(price >= entry){
      if(trade.Buy(lots,_Symbol,entry,sl,tp)){
         if(trade.ResultRetcode() == TRADE_RETCODE_DONE){
            buyTicket = trade.ResultOrder();
            Print("  --> Buy-Market-Order #",buyTicket," was sent");
         }
      }
   }
}

void executeSell(){
   double ask     = SymbolInfoDouble(_Symbol,SYMBOL_ASK);
   double bid     = SymbolInfoDouble(_Symbol,SYMBOL_BID);
   double spread  = roundUp(ask - bid);
   double entry   = roundDn(low1 - SymbolBuffer * _Point);
   double sl      = 0;
   
   if(SlVariable == SL_FIX){
      sl = entry + SlInitial * _Point;
   }else  sl = roundDn(high1 + spread + SymbolBuffer * _Point);
   
   double tp    = roundDn(entry - TpInitial * _Point);
   Print("  Short: entry ",entry,", sl ",sl," (spread ",spread,"), tp ",tp);
   
   double lots  = calclots(sl - entry);
   double price = SymbolInfoDouble(_Symbol,SYMBOL_BID);
   
   if(price > entry){  
      if(trade.SellStop(lots,entry,_Symbol,sl,tp,0,0)){
         if(trade.ResultRetcode() == TRADE_RETCODE_DONE){
            sellTicket = trade.ResultOrder();
            Print("  --> Sell-Stop-Order #",sellTicket," was sent");
            sellOrderDelete = sl;
         }
      }
   }
   if(price <= entry){
      if(trade.Sell(lots,_Symbol,entry,sl,tp)){
         if(trade.ResultRetcode() == TRADE_RETCODE_DONE){
            sellTicket = trade.ResultOrder();
            Print("  --> Sell-Market-Order #",sellTicket," was sent");
         }
      }
   }
}

double roundUp(double price){
   double ticksize = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_TRADE_TICK_SIZE),_Digits);
   price = NormalizeDouble(price,_Digits);
   double rest = price - NormalizeDouble(price/ticksize,0) * ticksize;
   rest = NormalizeDouble(rest,_Digits);
   if(rest != 0){
      for (double i = _Point; i <= ticksize; i += _Point){
         price = NormalizeDouble(price + _Point,_Digits);
         rest = price - NormalizeDouble(price/ticksize,0) * ticksize;
         rest = NormalizeDouble(rest,_Digits);
         if(rest == 0) break;
      }
   }
   return price;
}

double roundDn(double price){
   double ticksize = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_TRADE_TICK_SIZE),_Digits);
   price = NormalizeDouble(price,_Digits);
   double rest = price - NormalizeDouble(price/ticksize,0) * ticksize;
   rest = NormalizeDouble(rest,_Digits);
   if(rest != 0){
      for (double i = _Point; i <= ticksize; i += _Point){
         price = NormalizeDouble(price - _Point,_Digits);
         rest = price - NormalizeDouble(price/ticksize,0) * ticksize;
         rest = NormalizeDouble(rest,_Digits);
         if(rest == 0) break;
      }
   }
   return price;
}

double calclots(double slPoints){
   double lots = 0;
   double ticksize = SymbolInfoDouble(_Symbol,SYMBOL_TRADE_TICK_SIZE);
   double tickvalue = SymbolInfoDouble(_Symbol,SYMBOL_TRADE_TICK_VALUE);
   double lotstep = SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_STEP);
   double moneyPerLotstep = slPoints / ticksize * tickvalue * lotstep;

   if(Lotcalculation == LOT_FIX){
      lots = RiskInLots;
      Print("  fixed lot size: ",lots," lot");
   }
   if(Lotcalculation == LOT_AMOUNT){
      lots = MathFloor(RiskInAmount / moneyPerLotstep) * lotstep;
      Print("  lot size caculated via amount: ",lots," lot");
   }
   if(Lotcalculation == LOT_PERCENT){
      double riskPerTrade = AccountInfoDouble(ACCOUNT_EQUITY) * RiskInPercent / 100;
      lots = MathFloor(riskPerTrade / moneyPerLotstep) * lotstep;
      Print("  lot size calculated as a percentage: ",lots," lot");
   }
   lots = MathMin(lots,SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_MAX));
   lots = MathMax(lots,SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_MIN));
   return lots;
}

Den Ansatz mit einer Schleife habe ich probiert - bin aber ehrlich gesagt noch "zu blöd" es hinzubekommen. Außerdem bin ich auch der Meinung, dass mit einer Schleife alle Order gelöscht werden - was wiederum ebenfalls nicht gewünscht ist.

Dennoch möchte ich euch zeigen, was ich hierzu geschrieben habe. In OnTick habe ich abgefragt (nur mal für die Buy-Variante):

Code:

   //---Close Order
   double bid = SymbolInfoDouble(_Symbol,SYMBOL_BID);
   
   if(bid <= buyOrderDelete && OrderSelect(buyTicket)){
      closeOrder();
   }

Und dazu weiter unten folgende Funktion:

Code:

void closeOrder(){
   for(int i = OrdersTotal()-1; i >= 0; i--){
      buyTicket = OrderGetTicket(i);
      if(OrderSelect(buyTicket)){
         if(OrderGetString(ORDER_SYMBOL) != _Symbol) continue;            
         if(OrderGetInteger(ORDER_MAGIC) != Magic) continue;
         if(OrderGetInteger(ORDER_TYPE) == ORDER_TYPE_BUY_STOP){
            if(trade.OrderDelete(buyTicket)){
               Print("  -x-> Buy-Stop-Order #",buyTicket," gelöscht da SL erreicht");
            }
         }
      }
   }
}

Mit dieser Variante löscht er gar keine Buy-Orders.

Wie gesagt, so lange ich nur eine Order in jede Richtung habe, klappt die Löschung, sofern notwendig, problemlos ... aber halt nicht mit mehr als einer Order in eine Richtung.

Schon mal vielen Dank für Lösungsansätze. :-)

Nicht alle Orders löschen, sondern nur eine...
Forum: Programmierung MQL5

102 Views:
2 Antworten:

vor 2 Wochen, 13:36
von murkel

[Vorschau] Suche EA´s mit 3-5 % Performance
Forum: Expert-Advisors

338 Views:
2 Antworten:

vor 2 Wochen, 22:16
von traderdoc

[Vorschau] Datenlücke mit Fehlermeldung "array out of...
Forum: Allgemeine Fragen

368 Views:
2 Antworten:

vor 3 Wochen, 10:38
von murkel

[Vorschau] Mt4 / ea
Forum: Kleinanzeigen

751 Views:
0 Antworten:

02.03.24, 12:07
von Robin

[Vorschau]

Themenvorschau

Hallo,

ich bekomme beim Markt von MQL5 bei der Validation meines EA´s eine Fehlermeldung, das wäre diese:
invalid lots amount for OrderSend function
OrderSend error 4051

Der EA läuft aber einwandfrei. An was kann das liegen?

Code:

int ACCOUNT_NUMBER=0;// <----------------------------
//+------------------------------------------------------------------+
//|                                                Real Odin.mq4          |
//|                                      BullsBears-Trading Akademie |
//|                            bullsbears.trading.akademie@gmail.com |
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//+--------------------------------- --------------------------------+
//+----- http://bullsbears-trading.de -------------------------------+
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//+----- Real Odin Expert Advisor ---------------------------------+
//+------------------------------------------------------------------+
//+----- http://bullsbears-trading.de -------------------------------+
//+------------------------------------------------------------------+

#property version   "1.0" 
#property copyright "BullsBearsTradingAkademie"
#property link      "bullsbears.trading.akademie@gmail.com"
#property strict
#define buy -2
#define sell 2

#include <stdlib.mqh>
#include <WinUser32.mqh>
#import "wininet.dll"
#define INTERNET_FLAG_PRAGMA_NOCACHE    0x00000100 // Forces the request to be resolved by the origin server, even if a cached copy exists on the proxy.
#define INTERNET_FLAG_NO_CACHE_WRITE    0x04000000 // Does not add the returned entity to the cache. 
#define INTERNET_FLAG_RELOAD            0x80000000 // Forces a download of the requested file, object, or directory listing from the origin server, not from the cache.

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int InternetOpenA(string sAgent, int lAccessType, string sProxyName="", string sProxyBypass="", int lFlags=0);
int InternetOpenUrlA(int hInternetSession, string sUrl, string sHeaders="", int lHeadersLength=0, int lFlags=0, int lContext=0);
int InternetReadFile(int hFile, string sBuffer, int lNumBytesToRead, int& lNumberOfBytesRead[]);
int InternetCloseHandle(int hInet);
#import

enum yn
  {
   n=0,//NO
   y=1 //YES
  };
//---- input parameters
extern string  separator_01="----  General  Settings  ----";
extern bool      use_daily_target=false;
extern double    daily_target=100;
extern bool      trade_in_fri=true;
extern int       magic=22;
extern double    start_lot=0.01;
extern double    range=25;
extern bool      rge_multiplier=false;
extern double    r_multiplier=1.5;
extern int       level=10;
extern string  separator_02="----  Lot & TP  Settings  ----";
extern bool      lot_multiplier=true;
extern double    l_multiplier=2.0;
extern double    increment=0.1;
extern bool      power_lots=true;
extern bool      tp_by_level=true;
extern double    tp_1=25;
extern double    tp_2=0;
extern bool      use_sl_and_tp=false;
extern double    sl_std=60;
extern double    tp_std=30;
extern double    tp_in_money=5.0;
extern bool      stealth_mode=true;
 string  separator_03="----  Hedge  Settings  ----";
 bool      hedge=true;
 int       h_level=3;
 int       h_top_level=100;
 double    h_tp=80;
 double    h_sl=25;
 double    b_even_set=10;
 double    h_offset=20;
 double    h_factor=1.05;
 bool      level_limit=false;
 extern string  separator_04="----  Indicator  Settings  ----";                                                                                                   
 extern bool      use_bb=true;
 extern int       bb_period=20;
 extern int       bb_deviation=2;
 extern int       bb_shift=0;
 extern bool      use_stoch=true;
 extern int       k=5;
 extern int       d=3;
 extern int       slowing=3;
 extern int       price_field=0;
 extern int       stoch_shift=0;
 extern int       lo_level=30;
 extern int       up_level=70;
 extern bool      use_rsi=true;
 extern int       rsi_period=12;
 extern int       rsi_shift=0;
 extern int       lower=30;
 extern int       upper=70;
 string  separator_00="----  RSI - Foward  Trend   ----";
 bool      forward_trend=false;
 int       rsi_period_1=30;
 int       rsi_shift_1=0;
 int       lower_min=35;
 int       lower_max=33;
 int       upper_min=65;
 int       upper_max=67;
 bool      use_velocity=true;
 int       fv_period=10;
 int       fv_offset=20;
 string  separator_05="----  RSI - Hedge  Entry   ----";
 bool      h_rsi_entry=true;
 int       rsi_period_2=14;
 int       rsi_shift_2=0;
 int       lower_2=25;
 int       upper_2=75;
 bool      h_velocity=false;
 bool      use_h_rsi=false;
 int       vel_period=13;
 int       vel_offset=50;
 string  separator_06="----  RSI - Hedge  Exit   ----";
 bool      h_rsi_exit=true;
 int       rsi_period_3=14;
 int       rsi_shift_3=0;
 int       lower_3=50;
 int       upper_3=50;
 double    sl_threshold=0;
 string  separator_07="----  RSI - TP  Override   ----";
 bool      tp_override=true;
 int       rsi_period_4=14;
 int       rsi_shift_4=0;
 int       lower_4=25;
 int       upper_4=75;
 string  separator_08="----  Additional  ----";
extern string  separator_09="----  Trading  Sessions  ----";
extern bool      use_trading_sessions=false;
extern bool      asian_session=true;  //  0:00 -  8:00 GMT
extern bool      euro_session=true;   //  6:00 - 16:00 GMT
extern bool      ny_session=true;     // 12:00 - 21:00 GMT
extern int       gmt_shift=1;
extern bool      daylight_savings=false;
extern string  separator_10="----  Asian  Daily  /  GMT  ----";
extern bool      asian_daily=true;
extern int       sun_asian_open=0, sun_asian_close=8;
extern int       mon_asian_open=0, mon_asian_close=8;
extern int       tue_asian_open=0, tue_asian_close=8;
extern int       wed_asian_open=0, wed_asian_close=8;
extern int       thu_asian_open=0, thu_asian_close=8;
extern int       fri_asian_open=0, fri_asian_close=8;
extern string  separator_11="----  European  Daily  /  GMT  ----";
extern bool      euro_daily=true;
extern int       sun_euro_open=6,  sun_euro_close=16;
extern int       mon_euro_open=6,  mon_euro_close=16;
extern int       tue_euro_open=6,  tue_euro_close=16;
extern int       wed_euro_open=6,  wed_euro_close=16;
extern int       thu_euro_open=6,  thu_euro_close=16;
extern int       fri_euro_open=6,  fri_euro_close=16;
extern string  separator_12="----  New  York  Daily  /  GMT  ----";
extern bool      ny_daily=true;
extern int       sun_ny_open=12,   sun_ny_close=21;
extern int       mon_ny_open=12,   mon_ny_close=21;
extern int       tue_ny_open=12,   tue_ny_close=21;
extern int       wed_ny_open=12,   wed_ny_close=21;
extern int       thu_ny_open=12,   thu_ny_close=21;
extern int       fri_ny_open=12,   fri_ny_close=21;
 string BreakEven            = "--------------------< Break Even >--------------------";//Break Even Settings ............................................................................................................
 bool   UseBreakEven         = 0;      // Use Break Even
 double BreakEvenStart       = 10;     // Break Even Trigger
 double BreakEvenProfit      = 1;      // Break Even Profit
extern string TrailingStopLoss     = "--------------------< Trailing Stop >--------------------";//Trailing Stop Settings ............................................................................................................
input bool   UseTrailingStop      = 0;      // Use Trailing
input double TrailingStart        = 10;     // Trailing Start
input double TrailingStop         = 7;      // Trailing Stop
input string News_Filter           = "--------------------< News Filter >--------------------";//*
input bool   NewsFilter            = 0;      // Use News Filter
input int    MinBefore             = 15;     // Minutes Before News
input int    MinAfter              = 15;     // Minutes After News 
input bool 	 IncludeHigh 		     = true;   // High Impact News
input bool 	 IncludeMedium 		  = true;   // Medium Impact News
input bool 	 IncludeLow 			  = false;  // Low Impact News    
input bool 	 IncludeSpeaks 		  = true; 	 
input bool   AutoReportToCurrSym   = false;  // Auto Report to current Symbol
input bool	 ReportAllForUSD	     = true;
input bool   ReportAllForEUR       = true;
input bool   ReportAllForGBP       = true; 
input bool   ReportAllForNZD       = true;
input bool   ReportAllForJPY       = true;
input bool   ReportAllForAUD       = true;
input bool   ReportAllForCHF       = true;
input bool   ReportAllForCAD       = true;
input bool   ReportAllForCNY       = false;

input bool new_=false;//Fixed logic
input double max_percent_loss=5;//Max percent to stop

bool t_day[5];
datetime mtd_time,trail_sek;

double pt;
double minlot;
double stoplevel;
double std=0.1;
double rge;
double balance;
double bal_2=0;
double b_hedge;
double s_hedge;
double p_lot;
double pl_bal=0;
double st_lot;
double pl_factor;
double t_profit=0;
int prec=0;
int b_cnt;
int s_cnt;
int h_cnt;
int m;
int end_cycle;
bool e_cycle_set;
bool closeall;
datetime get_time;
bool h_b_e,EnableFileErrorLogging=0,NewsTime=0;
int PrevMinute=-1;
string NewsTimeComment="";
datetime tim;
//+------------------------------------------------------------------+
//| expert initialization function                                   |
//+------------------------------------------------------------------+
int init()
  {
//----
   if(Digits==3 || Digits==5)
      pt=10*Point;
   else
      pt=Point;
   minlot   =   MarketInfo(Symbol(),MODE_MINLOT);
   stoplevel=MarketInfo(Symbol(),MODE_STOPLEVEL);
   if(start_lot<minlot)
      Print("lotsize is to small.");
   if(sl_std<stoplevel)
      Print("stoploss is to tight.");
   if(tp_std<stoplevel)
      Print("takeprofit is to tight.");
   if(minlot==0.01)
     {
      prec=2;
      std=10.0;
     }
   if(minlot==0.1)
     {
      prec=1;
      std=1.0;
     }
//----
   range*=pt;
   rge=range;
   sl_std*=pt;
   tp_std*=pt;
   tp_1*=pt;
   tp_2*=pt;
   h_tp*=pt;
   h_sl*=pt;
   h_offset*=pt;
   b_even_set*=pt;
   sl_threshold*=pt;
   if(h_velocity)
      h_level=1;
   if(hedge && level_limit)
      level=h_level;
//----
   if(use_sl_and_tp)
      stealth_mode=false;
//----
   if(!GlobalVariableGet("bal_2"+Symbol()+(string)magic))
      GlobalVariableSet("bal_2"+Symbol()+(string)magic,0);
   if(GlobalVariableGet("bal_2"+Symbol()+(string)magic)>0)
      bal_2=GlobalVariableGet("bal_2"+Symbol()+(string)magic);
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| expert deinitialization function                                 |
//+------------------------------------------------------------------+
int deinit()
  {
//----

//----
   return(0);
  }
//+-------------------------------------------------------------------+
//| pofit                                                             |
//+-------------------------------------------------------------------+
double pofit()
  {
   double profit=0;
   for(int i=OrdersTotal()-1; i>=0; i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==magic)
           {
            profit+=OrderProfit()+OrderSwap();
           }
        }
     }
   return(profit);
  }
//+------------------------------------------------------------------+
//| expert start function                                            |
//+------------------------------------------------------------------+
int start()
  {
   if(ACCOUNT_NUMBER>0 && ACCOUNT_NUMBER!=AccountNumber())
     {
      Comment("Wrong Account number!");
      return 0;
     }
   double cur_p=pofit();
   double prec_p=0;
   if(AccountBalance()>0)
      prec_p=NormalizeDouble(((AccountBalance()+cur_p)*100/AccountBalance())-100,2);

   if(prec_p<0)
     {
      if(MathAbs(prec_p) >= MathAbs(max_percent_loss))
        {
         Comment("EA NOT WORKING BY ACCOUNT MAX PERCENT LOSS");
         return 0;
        }
     }
//---
   News();
   BreakEvens();
   TrailingStops();
//----
   if(use_daily_target && dailyprofit()>=daily_target)
     {
      Comment("\ndaily target achieved.");
      return(0);
     }
   if(!trade_in_fri && DayOfWeek()==5 && T()==0)
     {
      Comment("\nstop trading in Friday.");
      return(0);
     }
//+------------------------------------------------------------------+
//| start of ecTrage mod - ramble_32@yahoo.com                       |
//+------------------------------------------------------------------+
   h_cnt=0;
   b_cnt=0;
   s_cnt=0;
   double lot2;
   for(int i=0; i<OrdersTotal(); i++) // additional
     {
      bool os = OrderSelect(i,SELECT_BY_POS,MODE_TRADES);
      if(OrderSymbol()!=Symbol() || OrderMagicNumber()!=magic)
         continue;
      //----
      if(OT2()=="H")
        {
         h_cnt++;
        }
      else
        {
         if(cmd()<2)
            if(cmd()==0)
               b_cnt++;
         if(cmd()==1)
            s_cnt++;
        }
     }
   if(h_cnt==0)
      h_b_e=false;
//+------------------------------------------------------------------+
   double AE=AccountEquity();
   if(power_lots)
     {
      if(pl_bal==0)
        {
         pl_bal=AE;
         st_lot=start_lot;
        }
      if(T()==0)
        {
         pl_factor=AE/pl_bal;
         st_lot=start_lot*pl_factor;
        }
     }
//+------------------------------------------------------------------+
   if(lot_multiplier)
      lot2=NormalizeDouble(st_lot*MathPow(l_multiplier,T()),prec);
   else
      lot2=NormalizeDouble(st_lot+(increment*T()),          prec);
   if(rge_multiplier)
      rge=range*MathPow(r_multiplier,T());
//+------------------------------------------------------------------+
   int o_send=2;
   if(use_trading_sessions)
     {
      o_send=order_send();
     }
   else
     {
      if(signal()==buy)
         o_send=0;
      if(signal()==sell)
         o_send=1;
     }
//----
   if(e_cycle_set)
      end_cycle++;
   if(end_cycle>1)
     {
      e_cycle_set=false;
      end_cycle=0;
     }
   if(T()==0)
     {
      closeall=false;
      get_time=TimeCurrent();
     }
//----

   if((IsTesting() || (IsExpertEnabled() && IsTradeAllowed())) && !NewsTime && !closeall && end_cycle==0 && h_cnt==0 && (!new_ || tim!=Time[0])) // additional
     {
      tim=Time[0];
      if(T()<level)
        {
         if((o_send==0 || (b_cnt>0 && Ask<=LOOP()-rge))&& allow_open_order(0))                          // BUY
           {
            if(hedge && T()==0)
               s_hedge=Bid-rge;
            bool os = OrderSend(Symbol(),0,lot2,Ask,20,0,0,"L"+((string)b_cnt+(string)1),magic,0,Blue);
           }
         if((o_send==1 || (s_cnt>0 && Bid>=LOOP()+rge)) && allow_open_order(1))                         // SELL
           {
            if(hedge && T()==0)
               b_hedge=Ask+rge;
            bool os = OrderSend(Symbol(),1,lot2,Bid,20,0,0,"L"+((string)s_cnt+(string)1),magic,0,Red);
           }
        }
      //----
      if(hedges() && h_rsi_entry)                                               // HEDGE
        {
         if(h_velocity)
           {
            if(s_cnt>0 && Ask>=b_hedge && ((!use_h_rsi && h_velo()>vel_offset)
                                           || (use_h_rsi && h_entry()>upper_2)) && allow_open_order(0))
               bool os = OrderSend(Symbol(),0,h_lot(),Ask,20,0,0,"H"+((string)s_cnt+(string)1),magic,0,Blue);
            //----
            if(b_cnt>0 && Bid<=s_hedge && ((!use_h_rsi && h_velo()<-vel_offset)
                                           || (use_h_rsi && h_entry()<lower_2)) && allow_open_order(1))
               bool os = OrderSend(Symbol(),1,h_lot(),Bid,20,0,0,"H"+((string)b_cnt+(string)1),magic,0,Red);
           }
         if(!h_velocity)
           {
            if(s_cnt>0 && Ask>=LOOP() && Ask<=LOOP()+h_offset && h_entry()>upper_2 && allow_open_order(0))
               bool os = OrderSend(Symbol(),0,h_lot(), Ask,20,0,0,"H"+((string)s_cnt+(string)1),magic,0,Blue);
            //----
            if(b_cnt>0 && Bid<=LOOP() && Bid>=LOOP()-h_offset && h_entry()<lower_2 && allow_open_order(1))
               bool os = OrderSend(Symbol(),1,h_lot(), Bid,20,0,0,"H"+((string)b_cnt+(string)1),magic,0,Red);
           }
        }
     }
//+------------------------------------------------------------------+
   double OOP=0, OSL=0, OTP=0, sl_0=sl_std, tp_0=tp_std, h2_tp=h_tp;
   for(int i=0; i<OrdersTotal(); i++) // additional
     {
      bool os = OrderSelect(i,SELECT_BY_POS,MODE_TRADES);
      if(OrderSymbol()!=Symbol() || OrderMagicNumber()!=magic || cmd()>1)
         continue;
      OOP=OrderOpenPrice();
      if(OT2()=="H")
        {
         if(cmd()==0)
           {

            if(tp_override && h_tp_over()>upper_4)
               h2_tp=0;
            OSL=OOP()-h_sl;
            if(h_sl==0)
               OSL=0;
            OTP=OOP()+h2_tp;
            if(h2_tp==0)
               OTP=0;
            if(Ask>=OOP()+b_even_set)
               h_b_e=true;
            if(h_b_e)
               OSL=OOP()+(2*pt);
            double stop=MarketInfo(Symbol(),MODE_STOPLEVEL);
            if(OSL<Bid-stop*Point() && OTP>Ask+stop*Point() && (NormalizeDouble(OSL,_Digits)!=OrderStopLoss() || NormalizeDouble(OTP,_Digits)!=OrderTakeProfit()))
              {
               bool om = OrderModify(OrderTicket(),OrderOpenPrice(),NormalizeDouble(OSL,_Digits),NormalizeDouble(OTP,_Digits),0,CLR_NONE);
               if(!om)
                  Print("er1");
              }
           }
         if(cmd()==1)
           {
            if(tp_override && h_tp_over()<lower_4)
               h2_tp=0;
            OSL=OOP()+h_sl;
            if(h_sl==0)
               OSL=0;
            OTP=OOP()-h2_tp;
            if(h2_tp==0)
               OTP=0;
            if(Bid<=OOP()-b_even_set)
               h_b_e=true;
            if(h_b_e)
               OSL=OOP()-(2*pt);
            double stop=MarketInfo(Symbol(),MODE_STOPLEVEL);
            if(OTP<Bid-stop*Point() && OSL>Ask+stop*Point() && (NormalizeDouble(OSL,_Digits)!=OrderStopLoss() || NormalizeDouble(OTP,_Digits)!=OrderTakeProfit()))
              {
               bool om = OrderModify(OrderTicket(),OrderOpenPrice(),NormalizeDouble(OSL,_Digits),NormalizeDouble(OTP,_Digits),0,CLR_NONE);
               if(!om)
                  Print("er2");
              }
           }
         //----
         if(h_rsi_exit)
           {
            if((cmd()==0 && Ask>OOP()-sl_threshold && h_exit()<lower_3)
               || (cmd()==1 && Bid<OOP()+sl_threshold && h_exit()>upper_3))
               bool oc = OrderClose(OrderTicket(),OrderLots(),OrderClosePrice(),3,CLR_NONE);
           }
        }
     }
//+------------------------------------------------------------------+
   double deviate=0, h_dev=0;
   sl_0=sl_std;
   tp_0=tp_std;
   for(int i=0; i<OrdersTotal(); i++) // additional
     {
      bool os = OrderSelect(i,SELECT_BY_POS,MODE_TRADES);
      if(OrderSymbol()!=Symbol() || OrderMagicNumber()!=magic || cmd()>1)
         continue;
      OOP=OrderOpenPrice();
      OTP=OrderOpenPrice();
      if(LCT()==1)
        {
         if(cmd()==0 && Ask<=OOP())
            deviate=OOP()-Ask;
         if(cmd()==1 && Bid>=OOP())
            deviate=Bid-OOP();
        }
      if(OT2()=="H")
        {
         if(cmd()==0 &&Ask<=OOP())
            h_dev=OOP()-Ask;
         if(cmd()==1 &&Bid>=OOP())
            h_dev=Bid-OOP();
        }
      if(tp_by_level)
        {
         tp_0=tp_1;
         if(LCT()>1)
            tp_0=tp_2;
        }
      if((!stealth_mode || tp_by_level) && OT2()!="H")
        {
         if(cmd()==1)
           {
            sl_0*=-1;
            tp_0*=-1;
           }

         if(use_sl_and_tp)
            OSL=OOP-sl_0;
         OTP=OOP+tp_0;
         if(tp_0==0)
            OTP=0;
         if(sl_0==0)
            OSL=0;
         double stop=MarketInfo(Symbol(),MODE_STOPLEVEL);
         if((OrderTakeProfit()==0 && OTP > 0) || (OrderStopLoss()==0 && OSL > 0))
           {
            if(OrderType()==0 && (OTP==0 || OTP>Ask+stop*Point()) && (OSL==0 || OSL<Bid-stop*Point()))
              {
               bool om = OrderModify(OrderTicket(),OrderOpenPrice(),NormalizeDouble(OSL,_Digits),NormalizeDouble(OTP,_Digits),0,clrNONE);
               if(!om)
                  Print("er3");
              }

            if(OrderType()==1 && (OTP==0 || OTP<Bid-stop*Point()) && (OSL==0 || OSL>Ask+stop*Point()))
              {
               bool om = OrderModify(OrderTicket(),OrderOpenPrice(),NormalizeDouble(OSL,_Digits),NormalizeDouble(OTP,_Digits),0,clrNONE);
               if(!om)
                  Print("er4");
              }
           }
        }
     }
//+------------------------------------------------------------------+
//| end of ecTrage mod - ramble_32@yahoo.com                         |
//+------------------------------------------------------------------+
   if(use_sl_and_tp && T()>1)
     {
      int type=0;
      double s_l=0, t_p=0;
      for(int i=0; i<OrdersTotal(); i++)
        {
         bool os = OrderSelect(i,SELECT_BY_POS,MODE_TRADES);
         if(OrderSymbol()!=Symbol() || OrderMagicNumber()!=magic || cmd()>1)
            continue;
         type=OrderType();
         s_l=OrderStopLoss();
         t_p=OrderTakeProfit();
        }
      //----
      for(int i=OrdersTotal()-1; i>=0; i--)
        {
         bool os = OrderSelect(i,SELECT_BY_POS,MODE_TRADES);
         if(OrderSymbol()!=Symbol() || OrderMagicNumber()!=magic || cmd()>1)
            continue;
         if(OrderType()==type)
           {
            double stop=MarketInfo(Symbol(),MODE_STOPLEVEL);
            if(OrderStopLoss()!=s_l || OrderTakeProfit()!=t_p)
              {
               if(OrderType()==0 && s_l<Bid-stop*Point() && t_p>Ask+stop*Point())
                 {
                  bool om = OrderModify(OrderTicket(),OrderOpenPrice(),NormalizeDouble(s_l,_Digits),NormalizeDouble(t_p,_Digits),0,CLR_NONE);
                  if(!om)
                     Print("OrderModify error");
                 }

               if(OrderType()==1 && t_p<Bid-stop*Point() && s_l>Ask+stop*Point())
                 {
                  bool om = OrderModify(OrderTicket(),OrderOpenPrice(),NormalizeDouble(s_l,_Digits),NormalizeDouble(t_p,_Digits),0,CLR_NONE);
                  if(!om)
                     Print("OrderModify error");
                 }

              }
           }
        }
     }
//+------------------------------------------------------------------+
   double profit=0;
   for(int i=0; i<OrdersTotal(); i++)
     {
      bool os = OrderSelect(i,SELECT_BY_POS,MODE_TRADES);
      if(OrderSymbol()!=Symbol() || OrderMagicNumber()!=magic || cmd()>1)
         continue;
      profit+=OrderProfit();
     }
//+------------------------------------------------------------------+
   double h2_loss=0;
   balance=0;
   for(int i=0; i<OrdersHistoryTotal(); i++)
     {
      bool ost2 = OrderSelect(i,SELECT_BY_POS,MODE_HISTORY);
      if(OrderSymbol()!=Symbol() || OrderMagicNumber()!=magic || cmd()>1)
         continue;
      balance+=OrderProfit();
     }
//----
   if(T()==0 || bal_2==0)
     {
      GlobalVariableSet("bal_2"+Symbol()+(string)magic,balance);
      bal_2=GlobalVariableGet("bal_2"+Symbol()+(string)magic);
     }
   double tp_m=tp_in_money*pl_factor, tp_m2=balance-bal_2+profit;
   if(tp_m2>=tp_m && profit>0)
     {
      closeall();
      closeall=true;
      e_cycle_set=true;
     }
//+------------------------------------------------------------------+
   string OT="--", h2_factor="0 %", v_dsp="N", trend="Counter", t_dsp=" / RSI";
   if(b_cnt>0)
      OT="B";
   if(s_cnt>0)
      OT="S";
   if(hedge)
      h2_factor=DoubleToStr(h_factor*100,0)+"%";
   if(h_velocity)
      v_dsp="Y";
   if(forward_trend)
      trend="Forward";
   if(use_velocity)
      t_dsp=" / V / "+(string)fv_period+" / "+(string)fv_offset;
   double h_lot=0, t_lot=h_lot()*(1/h_factor);
   if(h_cnt>0)
      h_lot=h_lot();
   if(t_profit==0 || balance+profit>t_profit)
      t_profit=balance+profit;
//----
   string line_1="Level = "+(string)T()+" / "+(string)level+" / "+OT+"  |  Equity = "+DoubleToStr(AE,2)+"  |  Profit = "+DoubleToStr(balance+profit,2)+" / "+DoubleToStr(t_profit,2)+"  |  Target = "+DoubleToStr(tp_m2,2)+" / "+DoubleToStr(tp_m,2)+"\n";
   string line_2="Hedge = "+h2_factor+" / "+(string)h_cnt+" / "+(string)h_level+"  |  H Lot = "+DoubleToStr(h_lot,2)+" / "+DoubleToStr(t_lot,2)+"  |  Spread = "+DoubleToStr((Ask-Bid)/pt,2)+"  |  Deviation = "+DoubleToStr(deviate/pt,0)+" / "+DoubleToStr(h_dev/pt,0)+"\n";
   string line_3="Trend = "+trend+t_dsp+"  |  Velocity = "+v_dsp+" / "+DoubleToStr(h_velo(),0)+" / "+(string)vel_offset;
//----
   Comment(line_1, line_2, line_3+"\nPercent current: "+DoubleToString(prec_p,2)+"%");
//----
   return(0);
  }
//+------------------------------------------------------------------+
double dailyprofit()
  {
   int day=Day();
   double res=0;
   for(int i=0; i<OrdersHistoryTotal(); i++)
     {
      bool ot5 = OrderSelect(i,SELECT_BY_POS,MODE_HISTORY);
      if(OrderSymbol()!=Symbol() || OrderMagicNumber()!=magic)
         continue;
      if(TimeDay(OrderOpenTime())==day)
         res+=OrderProfit();
     }
   return(res);
  }
//+------------------------------------------------------------------+
int T() // modified
  {
   int Ts=0;
   for(int i=0; i<OrdersTotal(); i++)
     {
      bool os = OrderSelect(i,SELECT_BY_POS,MODE_TRADES);
      if(OrderSymbol()!=Symbol() || OrderMagicNumber()!=magic)
         continue;
      if(OT2()!="H")
         Ts++;
     }
   return(Ts);
  }
//+------------------------------------------------------------------+
double h_lot() // additional
  {
   double h_lots=0;
   for(int i=0; i<OrdersTotal(); i++)
     {
      bool os = OrderSelect(i,SELECT_BY_POS,MODE_TRADES);
      if(OrderSymbol()!=Symbol() || OrderMagicNumber()!=magic)
         continue;
      if(OT2()!="H")
         h_lots+=OrderLots();
     }
   h_lots=NormalizeDouble(h_lots, prec);
   return(h_lots);
  }
//+------------------------------------------------------------------+
double LOOP() // additional
  {
   double LOOPs=0;
   int t_cnt=0;
   for(int i=0; i<OrdersTotal(); i++)
     {
      bool os = OrderSelect(i,SELECT_BY_POS,MODE_TRADES);
      if(OrderSymbol()!=Symbol() || OrderMagicNumber()!=magic || cmd()>1)
         continue;
      if(cmd()==0)
        {
         t_cnt++;
         if(t_cnt==1 || (t_cnt>1 && OOP()<LOOPs))
            LOOPs=OOP();
        }
      if(cmd()==1)
        {
         t_cnt++;
         if(t_cnt==1 || (t_cnt>1 && OOP()>LOOPs))
            LOOPs=OOP();
        }
     }
   return(LOOPs);
  }
//+------------------------------------------------------------------+
int cmd() // additional
  {
   int cmds=OrderType();
   return(cmds);
  }
double OOP() // additional
  {
   double OOPs=OrderOpenPrice();
   return(OOPs);
  }
string OT2() // additional
  {
   string OT2s=StringSubstr(OrderComment(),0,1);
   return(OT2s);
  }
int LCT()
  {
   int LCTs=StrToInteger(StringSubstr(OrderComment(),1,3));
   return(LCTs);
  }
bool hedges() // additional
  {
   bool hedge_2=false;
   if(hedge && T()>=h_level && T()<=h_top_level)
      hedge_2=true;
   return(hedge_2);
  }
//+------------------------------------------------------------------+
double h_entry() // additional
  {
   double rsi_1=0;
   if(hedges() && h_cnt==0)
     {
      if(h_rsi_entry)
         rsi_1=iRSI(Symbol(),0,rsi_period_2,PRICE_CLOSE,rsi_shift_2);
     }
   return(rsi_1);
  }
double h_exit() // additional
  {
   double rsi_2=0;
   if(hedges() && h_cnt>0)
     {
      if(h_rsi_exit)
         rsi_2=iRSI(Symbol(),0,rsi_period_3,PRICE_CLOSE,rsi_shift_3);
     }
   return(rsi_2);
  }
double h_tp_over() // additional
  {
   double rsi_3=0;
   if(hedges() && h_cnt>0)
     {
      if(tp_override)
         rsi_3=iRSI(Symbol(),0,rsi_period_4,PRICE_CLOSE,rsi_shift_4);
     }
   return(rsi_3);
  }
double h_velo()
  {
   double velo=0; // additional
   if(hedge && h_cnt==0)
     {
      if(h_rsi_entry && h_velocity)
         velo=iCustom(NULL,0,"J_TPO_Velocity",vel_period,0,0);
     }
   return(velo);
  }
//+------------------------------------------------------------------+
int order_send()
  {
   int o_sends=2;
   if(use_trading_sessions)
     {
      int total_shift=gmt_shift;
      if(daylight_savings)
         total_shift=gmt_shift+1;
      int asian_open=0+total_shift, asian_close=8 +total_shift;
      int euro_open=6 +total_shift, euro_close=16 +total_shift;
      int ny_open=12  +total_shift, ny_close=21   +total_shift;
      //----
      if(DayOfWeek()==0) // sunday
        {
         if(asian_daily)
           {
            asian_open=sun_asian_open;
            asian_close=sun_asian_close;
           }
         if(euro_daily)
           {
            euro_open=sun_euro_open;
            euro_close=sun_euro_close;
           }
         if(ny_daily)
           {
            ny_open=sun_ny_open;
            ny_close=sun_ny_close;
           }
         //---
         if(!t_day[0])
           {
            t_day[0]=true;
            mtd_time=TimeCurrent();
            t_day[5]=false;
           }
        }
      if(DayOfWeek()==1) // monday
        {
         if(asian_daily)
           {
            asian_open=mon_asian_open;
            asian_close=mon_asian_close;
           }
         if(euro_daily)
           {
            euro_open=mon_euro_open;
            euro_close=mon_euro_close;
           }
         if(ny_daily)
           {
            ny_open=mon_ny_open;
            ny_close=mon_ny_close;
           }
         //---
         if(!t_day[1])
           {
            t_day[1]=true;
            mtd_time=TimeCurrent();
            t_day[0]=false;
           }
        }
      if(DayOfWeek()==2) // tuesday
        {
         if(asian_daily)
           {
            asian_open=tue_asian_open;
            asian_close=tue_asian_close;
           }
         if(euro_daily)
           {
            euro_open=tue_euro_open;
            euro_close=tue_euro_close;
           }
         if(ny_daily)
           {
            ny_open=tue_ny_open;
            ny_close=tue_ny_close;
           }
         //---
         if(!t_day[2])
           {
            t_day[2]=true;
            mtd_time=TimeCurrent();
            t_day[1]=false;
           }
        }
      if(DayOfWeek()==3) // wednesday
        {
         if(asian_daily)
           {
            asian_open=wed_asian_open;
            asian_close=wed_asian_close;
           }
         if(euro_daily)
           {
            euro_open=wed_euro_open;
            euro_close=wed_euro_close;
           }
         if(ny_daily)
           {
            ny_open=wed_ny_open;
            ny_close=wed_ny_close;
           }
         //---
         if(!t_day[3])
           {
            t_day[3]=true;
            mtd_time=TimeCurrent();
            t_day[2]=false;
           }
        }
      if(DayOfWeek()==4) // thursday
        {
         if(asian_daily)
           {
            asian_open=thu_asian_open;
            asian_close=thu_asian_close;
           }
         if(euro_daily)
           {
            euro_open=thu_euro_open;
            euro_close=thu_euro_close;
           }
         if(ny_daily)
           {
            ny_open=thu_ny_open;
            ny_close=thu_ny_close;
           }
         //---
         if(!t_day[4])
           {
            t_day[4]=true;
            mtd_time=TimeCurrent();
            t_day[3]=false;
           }
        }
      if(DayOfWeek()==5) // friday
        {
         if(asian_daily)
           {
            asian_open=fri_asian_open;
            asian_close=fri_asian_close;
           }
         if(euro_daily)
           {
            euro_open=fri_euro_open;
            euro_close=fri_euro_close;
           }
         if(ny_daily)
           {
            ny_open=fri_ny_open;
            ny_close=fri_ny_close;
           }
         //---
         if(!t_day[5])
           {
            t_day[5]=true;
            mtd_time=TimeCurrent();
            t_day[4]=false;
           }
        }
      //----
      bool o_time=false;
      if(asian_session && Hour()>=asian_open && Hour()<=asian_close)
         o_time=true;
      if(euro_session  && Hour()>=euro_open  && Hour()<=euro_close)
         o_time=true;
      if(ny_session    && Hour()>=ny_open    && Hour()<=ny_close)
         o_time=true;
      //----
      if(o_time)
        {
         if(signal()==buy)
            o_sends=0;
         if(signal()==sell)
            o_sends=1;
        }
     }
   return(o_sends);
  }
//+------------------------------------------------------------------+
int signal()
  {
   if(T()==0) // additional
     {
      if(forward_trend)
        {
         if(!use_velocity)
           {
            double rsi_1=iRSI(Symbol(),0,rsi_period_1,PRICE_CLOSE,rsi_shift_1);
            if(rsi_1>upper_min && rsi_1<upper_max)
               return(buy);
            if(rsi_1<lower_min && rsi_1>lower_max)
               return(sell);
           }
         if(use_velocity)
           {
            double velo=iCustom(NULL,0,"J_TPO_Velocity",fv_period,0,0);
            if(velo>vel_offset)
               return(buy);
            if(velo<-vel_offset)
               return(sell);
           }
        }
      if(!forward_trend)
        {
         double upBB=iBands(Symbol(),0,bb_period,bb_deviation,0,PRICE_CLOSE,MODE_UPPER,bb_shift);
         double loBB=iBands(Symbol(),0,bb_period,bb_deviation,0,PRICE_CLOSE,MODE_LOWER,bb_shift);
         double stoch=iStochastic(Symbol(),0,k,d,slowing,MODE_SMA,price_field,MODE_SIGNAL,stoch_shift);
         double rsi=iRSI(Symbol(),0,rsi_period,PRICE_CLOSE,rsi_shift);
         if(use_bb && use_stoch && use_rsi)
           {
            if(High[bb_shift]>upBB && stoch>up_level && rsi>upper)
               return(sell);
            if(Low[bb_shift]<loBB && stoch<lo_level && rsi<lower)
               return(buy);
           }
         if(use_bb && use_stoch && !use_rsi)
           {
            if(High[bb_shift]>upBB && stoch>up_level)
               return(sell);
            if(Low[bb_shift]<loBB && stoch<lo_level)
               return(buy);
           }
         if(use_bb && !use_stoch && !use_rsi)
           {
            if(High[bb_shift]>upBB)
               return(sell);
            if(Low[bb_shift]<loBB)
               return(buy);
           }
         if(!use_bb && use_stoch && use_rsi)
           {
            if(stoch>up_level && rsi>upper)
               return(sell);
            if(stoch<lo_level && rsi<lower)
               return(buy);
           }
         if(!use_bb && use_stoch && !use_rsi)
           {
            if(stoch>up_level)
               return(sell);
            if(stoch<lo_level)
               return(buy);
           }
         if(use_bb && !use_stoch && use_rsi)
           {
            if(High[bb_shift]>upBB && rsi>upper)
               return(sell);
            if(Low[bb_shift]<loBB && rsi<lower)
               return(buy);
           }
         if(!use_bb && !use_stoch && use_rsi)
           {
            if(rsi>upper)
               return(sell);
            if(rsi<lower)
               return(buy);
           }
        }
     }
   return(0);
  }
//+------------------------------------------------------------------+
void closeall()
  {
  Print("closeall");
   for(int i=OrdersTotal()-1; i>=0; i--)
     {
      bool os = OrderSelect(i,SELECT_BY_POS,MODE_TRADES);
      if(OrderSymbol()!=Symbol() || OrderMagicNumber()!=magic)
         continue;
      if(cmd()>1)
         bool od = OrderDelete(OrderTicket());
      else
        {
         if(cmd()==0)
            bool oc = OrderClose(OrderTicket(),OrderLots(),Bid,3,CLR_NONE);
         else
            bool oc = OrderClose(OrderTicket(),OrderLots(),Ask,3,CLR_NONE);
        }
     }
  }
//HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
//+------------------------------------------------------------------+
//| Trailing Stop                                                    |
//+------------------------------------------------------------------+
void TrailingStops()
  {
   if(!UseTrailingStop || TrailingStop == 0)
      return;
   if(trail_sek>TimeCurrent())
      return;
   for(int i = 0; i < OrdersTotal(); i++)
     {
      if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
        {
         if(OrderSymbol() == Symbol() && (magic == 0 || OrderMagicNumber() == magic))
           {
            if(OrderType() == OP_BUY)
              {
               if(Bid - OrderOpenPrice() > TrailingStart * _Point && OrderStopLoss() < ND(Bid-TrailingStop*_Point))
                 {
                  Trail(ND(Bid - TrailingStop * _Point),OrderTicket());
                 }
              }
            if(OrderType() == OP_SELL)
              {
               if(OrderOpenPrice() - Ask > TrailingStart * _Point && (OrderStopLoss()==0||OrderStopLoss()>ND(Ask+TrailingStop*_Point)))
                 {
                  Trail(ND(Ask + TrailingStop * _Point),OrderTicket());
                 }
              }
           }
        }
     }
  }
//+------------------------------------------------------------------------------------------------------------------------------------+
void Trail(double sl, int ticket)
  {
   if(OrderSelect(ticket, SELECT_BY_TICKET,MODE_TRADES))
     {
      double stop=MarketInfo(Symbol(),MODE_STOPLEVEL);
      if(OrderType()==0 && sl<Bid-stop*Point())
        {
         trail_sek=TimeCurrent()+5;
         bool modify = OrderModify(ticket, OrderOpenPrice(), sl, OrderTakeProfit(), 0, clrGold);
         int err = GetLastError();
         if(err!=ERR_NO_ERROR)
           {
            Print("Error on Trail Order modify = ", ErrorDescription(err));
           }

        }

      if(OrderType()==1 && sl>Ask+stop*Point())
        {
         trail_sek=TimeCurrent()+5;
         bool modify = OrderModify(ticket, OrderOpenPrice(), sl, OrderTakeProfit(), 0, clrGold);
         int err = GetLastError();
         if(err!=ERR_NO_ERROR)
           {
            Print("Error on Trail Order modify = ", ErrorDescription(err));
           }
        }
     }
  }
//HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
//+------------------------------------------------------------------+
//| Break Even                                                       |
//+------------------------------------------------------------------+
void BreakEvens()
  {
   if(!UseBreakEven || BreakEvenStart == 0)
      return;

   for(int i = 0; i < OrdersTotal(); i++)
     {
      if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
        {
         if(OrderSymbol() == Symbol() && (magic == 0 || OrderMagicNumber() == magic))
           {
            if(OrderType() == OP_BUY)
              {
               if(Bid-OrderOpenPrice() > BreakEvenStart*_Point && ND(OrderOpenPrice()+BreakEvenProfit*_Point) > OrderStopLoss())
                 {
                  Modify(ND(OrderOpenPrice()+BreakEvenProfit*_Point),OrderTicket());
                 }
              }
            if(OrderType() == OP_SELL)
              {
               if(OrderOpenPrice()-Ask > BreakEvenStart*_Point && (0 == OrderStopLoss() || ND(OrderOpenPrice()-BreakEvenProfit*_Point) < OrderStopLoss()))
                 {
                  Modify(ND(OrderOpenPrice()-BreakEvenProfit*_Point),OrderTicket());
                 }
              }
           }
        }
     }
  }
//+------------------------------------------------------------------------------------------------------------------------------------+
bool Modify(double sl, int ticket)
  {
   if(OrderSelect(ticket,SELECT_BY_TICKET,MODE_TRADES))
     {
      if(OrderModify(ticket, OrderOpenPrice(), sl, OrderTakeProfit(), 0, clrGold))
         return(true);
      int err = GetLastError();
      if(err!=ERR_NO_ERROR)
        {
         Print("Error on BreakEven Order modify = ", ErrorDescription(err));
        }
     }
   return(false);
  }
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+
double ND(double price)
  {
   if(price > 0)
      return(NormalizeDouble(price,_Digits));
   return(0);
  }
//HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
//+------------------------------------------------------------------+
//| Check Symbol Points                                              |
//+------------------------------------------------------------------+
double point(string symbol=NULL)
  {
   string sym=symbol;
   if(symbol==NULL)
      sym=Symbol();
   double bid=MarketInfo(sym,MODE_BID);
   int digits=(int)MarketInfo(sym,MODE_DIGITS);

   if(digits<=1)
      return(1); //CFD & Indexes
   if(digits==4 || digits==5)
      return(0.0001);
   if((digits==2 || digits==3) && bid>1000)
      return(1);
   if((digits==2 || digits==3) && bid<1000)
      return(0.01);
   if(StringFind(sym,"XAU")>-1 || StringFind(sym,"xau")>-1 || StringFind(sym,"GOLD")>-1)
      return(0.1);//Gold
   return(0);
  }
//HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH//
//+------------------------------------------------------------------+
//| News Filter Settings                                             |
//+------------------------------------------------------------------+
void News()
{ 
     string pair = Symbol();
	  string psy = StringSubstr(pair, 0, 3);
	  string nsy = StringSubstr(pair, 3, 3);
	  bool USD = ReportAllForUSD;
	  bool EUR = ReportAllForEUR;
	  bool GBP = ReportAllForGBP;
	  bool NZD = ReportAllForNZD;
	  bool JPY = ReportAllForJPY;
	  bool AUD = ReportAllForAUD;
	  bool CHF = ReportAllForCHF;
	  bool CAD = ReportAllForCAD;
	  bool CNY = ReportAllForCNY;
	  if(AutoReportToCurrSym){
	  USD = (psy=="USD" || nsy=="USD");
	  EUR = (psy=="EUR" || nsy=="EUR");
	  GBP = (psy=="GBP" || nsy=="GBP");
	  NZD = (psy=="NZD" || nsy=="NZD");
	  JPY = (psy=="JPY" || nsy=="JPY");
	  AUD = (psy=="AUD" || nsy=="AUD");
	  CHF = (psy=="CHF" || nsy=="CHF");
	  CAD = (psy=="CAD" || nsy=="CAD");
	  CNY = (psy=="CNY" || nsy=="CNY");}	  
	  
    if(NewsFilter && !IsTesting() && !IsOptimization())
      {
       if(Minute() != PrevMinute)
         {
          PrevMinute = Minute();

          double minutesSincePrevEvent = iCustom(NULL,0,"FFCal",IncludeHigh,IncludeMedium,IncludeLow,IncludeSpeaks,0,0,1,-1,-1,USD,EUR,GBP,NZD,JPY,AUD,CHF,CAD,CNY,1,0);
          double minutesUntilNextEvent = iCustom(NULL,0,"FFCal",IncludeHigh,IncludeMedium,IncludeLow,IncludeSpeaks,0,0,1,-1,-1,USD,EUR,GBP,NZD,JPY,AUD,CHF,CAD,CNY,1,1);

          NewsTime        = false;
          NewsTimeComment = "No News, Trading Allowed!"; 
            
          if((minutesUntilNextEvent <= MinBefore) || (minutesSincePrevEvent <= MinAfter))
            {
             NewsTime        = true;
             NewsTimeComment = "Ongoing News, Trading Disallowed!"; 
            }
         }
      }
    else
      {
       NewsTime        = false;
       NewsTimeComment = "Use News Filter = false !!!";
      }
}  
//HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| Found                                                            |
//+------------------------------------------------------------------+
bool allow_open_order(int typs)
  {
   if(!new_)
      return true;
   for(int i=OrdersHistoryTotal()-1; i>=0; i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_HISTORY))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==magic && OrderType()==typs)
           {
            if(OrderProfit()>0 && OrderCloseTime() > TimeCurrent()-PeriodSeconds()*5)
               return false;
            return true;
           }
        }
     }
   return true;
  }
//+------------------------------------------------------------------+

Fehlermeldung 4051
Forum: Programmierung MQL4

662 Views:
0 Antworten:

01.03.24, 07:28
von Alex60

[Vorschau]

Themenvorschau

Hallo zusammen,

ich habe meinen ersten EA geschrieben, bzw. bin dabei und komme bei folgendem Problem nicht weiter:

Der EA soll zum Beginn eines neuen Tages den Vortag, also die Kerze vom Vortag, nach bestimmten Kriterien untersuchen und das Ergebnis zunächst mal als Printausgabe im Journal darstellen. Das hat soweit zur vollsten Zufriedenheit geklappt. Ergebnis war stets um 00:05:00 entweder kein Signal oder Long oder Short oder warum kein Signal. Soweit so gut.

Nun möchte ich aber einen weitere Aktion zu einer anderen Zeit mir ausgeben - im Beispiel soll um 12:00 Uhr nur dann was im Journal ausgegeben werden, wenn am Vortag auch nur ein Signal vorhanden war. Hier liegt nun mein Problem:

Der EA läuft bis zum ersten Signal korrekt - sprich, wenn kein Signal, auch keine Ausgabe "12:00 Uhr". Ab dem ersten Signal kommt diese Ausgabe dann komplett durcheinander. Mal korrekt, mal nicht, und mal doppelt. Wo liegt der Fehler?

Hier der Code, der hoffentlich korrekt angezeigt wird und im Anhang ein Bild vom Journal-Ergebnis.

Code:

input ENUM_TIMEFRAMES TimeframeSignal = PERIOD_D1;  //Zeiteinheit Signal
input string TimeSignalApp = "12:00";  //Anwendungszeit Signal
input double MinWick = 1.5;  //Docht im Verhältnis zum Körper

bool noSignal, longSignal, shortSignal;
datetime timeSignal;
datetime timeSignalApp;

int OnInit(){

   return(INIT_SUCCEEDED);
}

void OnDeinit(const int reason){

}

void OnTick(){
   //---One-time calculation signal
   if(timeSignal != iTime(_Symbol,TimeframeSignal,0)){  //iTime = Zeitpunkt der Eröffnung einer Bar 
      calcSignal();
   }
   
   //---One-time calculation signal application
   if(timeSignalApp != StringToTime(TimeSignalApp)){
      calcSignalApp();
   }
   
   if(TimeCurrent() == timeSignalApp){
      if(shortSignal == true || longSignal == true){
         Print("12:00 Uhr");
      }
   }

   Comment("\nServerzeit: ",TimeCurrent());

}

void calcSignal(){
   timeSignal = iTime(_Symbol,TimeframeSignal,0);
   
   //---Candle 1
   double open1 = iOpen(_Symbol,TimeframeSignal,1);
   double high1 = iHigh(_Symbol,TimeframeSignal,1);
   double low1 = iLow(_Symbol,TimeframeSignal,1);
   double close1 = iClose(_Symbol,TimeframeSignal,1);
      
   double upperWick = high1 - MathMax(open1,close1);
   double lowerWick = MathMin(open1,close1) - low1;
   
   double candleBodySize = MathMax(open1,close1) - MathMin(open1,close1);
   
   double upperWickBodyRatio = upperWick / candleBodySize;
   double lowerWickBodyRatio = lowerWick / candleBodySize;
   
   //---Candle 2
   double open2 = iOpen(_Symbol,TimeframeSignal,2);
   double high2 = iHigh(_Symbol,TimeframeSignal,2);
   double low2 = iLow(_Symbol,TimeframeSignal,2);
   double close2 = iClose(_Symbol,TimeframeSignal,2);
   
   //---Volume
   long volumeCandle1 = iVolume(_Symbol,TimeframeSignal,1);
   long volumeCandle2 = iVolume(_Symbol,TimeframeSignal,2);
   
   //---Candle 3
   double open3 = iOpen(_Symbol,TimeframeSignal,3);
   double high3 = iHigh(_Symbol,TimeframeSignal,3);
   double low3 = iLow(_Symbol,TimeframeSignal,3);
   double close3 = iClose(_Symbol,TimeframeSignal,3);
   
   //---No Signal
   bool outsideBar = (high1 > high2 && low1 < low2); //first -> second candle
   bool insideBar1 = (high1 <= high2 && low1 >= low2); //first -> second candle
   bool insideBar2 = ((high1 <= high3 && low1 >= low3) && (high2 <= high3 && low2 >= low3)); //first -> third candle
   bool volume = volumeCandle1 > volumeCandle2; //lower volume

   if(outsideBar == true || insideBar1 == true || insideBar2 == true || volume != true){
      noSignal = true;
      Print("no signal (volume ",volume,", outsidebar ",outsideBar,", insidebar1 ",insideBar1," ,insideBar2 ",insideBar2,")");
      }else{
         noSignal = false;
   }
   
   //---Short Signal
   bool higherHigh = (high1 > high2 && low1 >= low2);
   bool upperWickLength = (upperWickBodyRatio >= MinWick);

   if(higherHigh == true){
      if(upperWickLength == true){
         shortSignal = true;
         Print("SHORT SIGNAL");
      }else{
         shortSignal = false;
         Print("no short signal - wick length to small");                
         }
   }
   
   //---Long Signal
   bool lowerLow = (low1 < low2 && high1 <= high2);
   bool lowerWickLength = (lowerWickBodyRatio >= MinWick);

   if(lowerLow == true){
      if(lowerWickLength == true){
         longSignal = true;
         Print("LONG SIGNAL");
      }else{
         longSignal = false;
         Print("no long signal - wick length to small");
         }
   }
}

void calcSignalApp(){
   timeSignalApp = StringToTime(TimeSignalApp);
   
}

Schon jetzt vielen Dank für eure Hilfe. :-)

murkel

EA berechnet zweiten Zeitstempel nicht zur gewünschten...
Forum: Programmierung MQL5

780 Views:
2 Antworten:

27.02.24, 19:16
von murkel

[Vorschau] Neue Registrierung auf www.mql5.com
Forum: Signaldienste

665 Views:
1 Antworten:

24.02.24, 18:20
von NonExperts

[Vorschau] AutoTrading ausschalten
Forum: Programmierung MQL4

536 Views:
2 Antworten:

12.02.24, 09:10
von steini84

[Vorschau]

Themenvorschau

Hi,

ich habe einen Code geschrieben. Es soll jeden Tag um 17.30 ein trade eröffnet werden buy. Dieser soll am nächsten Tag um 8.50 Uhr geschlossen werden.
Im Backtest wird mir jedoch nur ein Trade eröffnet in nem Zeitraum von 2 Monaten und nicht geschlossen am nächsten Tag
Kann da mal wer über den Code schauen?

Code:

// Handelszeiten
input int      openHour = 17;
input int      openMinute = 30;
input int      closeHour = 8;
input int      closeMinute = 50;

// Globale Variable für die Handelsaktivität
bool canOpenTrade = true;

int start() {
    // Überprüfe, ob es Zeit ist, einen Trade zu eröffnen
    if (canOpenTrade && Hour() == openHour && Minute() == openMinute) {
        // Eröffne einen Kauf-Trade
        int ticket = OrderSend(Symbol(), OP_BUY, lotSize, Ask, 3, 0, 0, "Buy Order", 0, 0, Green);
        if (ticket > 0) {
            canOpenTrade = false; // Setze die Variable auf false, um weitere Trades zu verhindern
            Print("Kauf-Trade erfolgreich eröffnet. Ticket: ", ticket);
        } else {
            Print("Fehler beim Öffnen des Kauf-Trades. Fehlercode: ", GetLastError());
        }
    }

    // Überprüfe, ob es Zeit ist, den Trade zu schließen
    if (!canOpenTrade && Hour() == closeHour && Minute() == closeMinute) {
        // Schließe alle offenen Trades
        for (int i = OrdersHistoryTotal() - 1; i >= 0; i--) {
            if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES) && OrderSymbol() == Symbol() && OrderMagicNumber() == 0) {
                bool closed = OrderClose(OrderTicket(), OrderLots(), Bid, 3, Red);
                if (closed) {
                    canOpenTrade = true; // Setze die Variable auf true, um am nächsten Tag einen neuen Trade zu ermöglichen
                    Print("Trade erfolgreich geschlossen.");
                } else {
                    Print("Fehler beim Schließen des Trades. Fehlercode: ", GetLastError());
                }
            }
        }
    }

    return 0;
}

Probleme mit Ausführung im Code
Forum: Programmierung MQL4

260 Views:
2 Antworten:

08.02.24, 07:06
von Alex60

[Vorschau] Alarm überarbeiten
Forum: Programmierung MQL4

210 Views:
3 Antworten:

07.02.24, 22:45
von traderdoc

[Vorschau] Nomenklatur beim Programmieren generell
Forum: Programmierung MQL4

176 Views:
2 Antworten:

04.02.24, 10:47
von cashfox

[Vorschau] Überlegungen zum Programmieren einer fallenden oder...
Forum: Programmierung MQL4

187 Views:
6 Antworten:

04.02.24, 10:45
von cashfox

[Vorschau] EA läuft simultan auf mehreren Underlyings?
Forum: Expert-Advisors

1021 Views:
8 Antworten:

01.02.24, 17:17
von traderdoc

[Vorschau] E-Mail-Versand
Forum: Allgemeine Fragen

1256 Views:
0 Antworten:

31.01.24, 22:27
von DD-Torsten

[Vorschau] Live Ansicht des Account auf einer Homepage
Forum: Allgemeine Fragen

847 Views:
0 Antworten:

29.01.24, 20:59
von Trading-4u.com

[Vorschau] Programmierer gesucht EA Expert Advisor
Forum: Kleinanzeigen

821 Views:
0 Antworten:

03.01.24, 10:50
von Deep-Mirror

[Vorschau]

Themenvorschau

Hallo Freunde und Helfer

Ich habe einen einfachen Indikator in MTQL5 geschrieben der Vortageshoch und Vortagestief ausgeben soll.

Es gibt keine Fehlermeldungen und dennoch lässt sich der Indikator nicht im Chart anzeigen.

Code:

#property strict
#property indicator_chart_window

#property indicator_buffers 2

#property indicator_color1 clrBlue
#property indicator_color2 clrRed 
#property indicator_style1 STYLE_DASHDOT
#property indicator_style2 STYLE_DASHDOT
#property indicator_label1 "Vortageshoch"
#property indicator_label2 "Vortagestief" 

double arrHigh[];
double arrLow[]; 

int OnInit(){

   SetIndexBuffer(0,arrHigh);
   SetIndexBuffer(1,arrLow);
   
   return(INIT_SUCCEEDED);
} 

int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[]){
                
     
     static double lastHigh = 0;
     static double lastLow = INT_MAX; 
     
     static double currentHigh = 0;
     static double currentLow = INT_MAX;
     
     static datetime timestamp = 0; 
     for(int i = rates_total-prev_calculated; i >= 0; i--){     
               if(i >= rates_total) continue;
               
               datetime timeDay = iTime(_Symbol,PERIOD_D1,iBarShift(_Symbol,PERIOD_D1,time[i]));
               if(timestamp != timeDay){
                  timestamp = timeDay; 
                  
                  currentHigh = lastHigh;
                  currentLow = lastLow; 
                  lastHigh = 0;
                  lastLow = INT_MAX;              
                }
                
             lastHigh = MathMax(lastHigh,high[i]);
             lastLow = MathMin(lastLow,low[i]);
             
             arrHigh[i] = currentHigh;
             arrLow[i] = currentLow;
                          
             }

      return(rates_total);
}

Hoffe mir kann jemand bei dem Problem helfen.

Indikator wird nicht angezeigt
Forum: Programmierung MQL5

717 Views:
0 Antworten:

22.12.23, 11:52
von thecreating