Problem mit der Gesamtzahl der offenen Aufträge - Seite 4

Neuer Kommentar
 

Hallo zusammen

Sorry, aber ich habe mich zu früh geäußert. Obwohl das Hinzufügen von RefreshRates() einen Unterschied zu machen scheint, habe ich immer noch das gleiche Problem. Manchmal werden beide ausstehenden Aufträge geöffnet, manchmal nur einer der beiden und manchmal keiner. Ich erhalte immer noch den Fehler 130, wenn kein Auftrag geöffnet wird, oder beide, aber keine Fehler, wenn beide tatsächlich geöffnet werden. Mir ist auch aufgefallen, dass bei den Paaren, bei denen meine Eingaben unter MODE_STOPLEVEL liegen, nie eine Order eröffnet wird und ich immer den Fehler 130 erhalte, obwohl das Programm meine Eingaben wie gewünscht anpasst. Ich drucke die Werte aus und sie werden wie erwartet angepasst. Ich versuche also herauszufinden, warum mein OrderSend nicht wirklich funktioniert.

Bei einem Paar wie EURUSD, bei dem das Stoplevel 5 ist, werden normalerweise beide Orders gesendet, aber nicht immer. Bei einem Paar wie EURAUD, bei dem das Stoplevel 10 ist, wird jedoch nie eine Order gesendet.

extern int TrailingStart=20;
extern int TrailingStop=5;

extern int Hedge=10;
extern double Multiplier=3;

extern int StopLossOriginal=11;

extern int StopLossHedge=9;

extern double Percentage=1;
extern double Lotsize=0.01;
extern double MyMaxlots=30;

extern datetime StartTime1 = D'2016.03.25 16:50';

extern int Pipmove=5;
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int init()
//---
  {
   int TS=TrailingStart-TrailingStop;
   double stoplevel=(MarketInfo(Symbol(),MODE_STOPLEVEL))/10;
   if(StopLossOriginal<stoplevel || StopLossHedge<stoplevel || TS<stoplevel)
     {
      MessageBox("Please note: Your inputs for StopLossOriginal, StopLossHedge and/or"+
                 "\nTrailingStop are below the minimum levels required by your broker,"+
                 "\nand have been increased automatically to "+StringConcatenate(stoplevel)+" Pips");
     }
   return(0);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int deinit()
  {
   return(0);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int start()
  {
   int TS=TrailingStart-TrailingStop;
   Print("TS = ",TS);
   int sloss=StopLossOriginal-Pipmove;
   int stoplevel=(MarketInfo(Symbol(),MODE_STOPLEVEL))/10;
   Print("stoplevel = ",stoplevel);
     
   double Lots = NormalizeDouble(AccountEquity()*Percentage*Lotsize/100, 2),
          point=Point*10,
          Price=Pipmove*point,
          SL=(StopLossOriginal-Pipmove)*point,
          MinLots = MarketInfo(Symbol(),MODE_MINLOT),
          MaxLots = MarketInfo(Symbol(),MODE_MAXLOT),
          HedgeLots=NormalizeDouble(OrderLots()*Multiplier,2);
          
   if(sloss<=stoplevel) SL=stoplevel*point;
   Print("SL = ",SL);
   if(StopLossHedge<=stoplevel) StopLossHedge=stoplevel;
   Print("StopLossHedge = ",StopLossHedge);
   if(TS<=stoplevel) TrailingStart=(stoplevel+TrailingStop); 
   Print("TrailingStart = ",TrailingStart);     
          
   datetime time1=StartTime1-3300;      

   if(Lots>MaxLots) Lots=MaxLots;
   if(Lots<MinLots) Lots=MinLots;
   if(HedgeLots>MaxLots) HedgeLots=MaxLots;
   if(Lots>MaxLots || Lots<MinLots || HedgeLots>MaxLots)
     {
      MessageBox("Lotsize have been adjusted automatically");
     }

   int buy_ticket=0, sell_ticket=0, buystop_ticket=0, sellstop_ticket=0, total=0;
   for(int i= OrdersTotal()-1; i>= 0; i--)
      if(OrderSelect(i,SELECT_BY_POS) && OrderMagicNumber()==magic && OrderSymbol()==Symbol())
        {
         total++;
         if(OrderType()==OP_BUYSTOP) buystop_ticket=OrderTicket();
         if(OrderType()==OP_SELLSTOP) sellstop_ticket=OrderTicket();
         if(OrderType()==OP_BUY) buy_ticket=OrderTicket();
         if(OrderType()==OP_SELL) sell_ticket=OrderTicket();
        }

   if(total==0 && Time[0]==time1)
     {
      buy_ticket=OrderSend(Symbol(),OP_BUYSTOP,Lots,Ask+Price,30,0,0,"Pending",magic,0,Lime);
      OrderModify(OrderTicket(),OrderOpenPrice(),Ask-SL,OrderTakeProfit(),Yellow);
      Print("Buystop = ",GetLastError());
      Sleep(1000);
      RefreshRates();
      Sleep(1000);
      sell_ticket=OrderSend(Symbol(),OP_SELLSTOP,Lots,Bid-Price,30,0,0,"Pending",magic,0,Red);
      OrderModify(OrderTicket(),OrderOpenPrice(),Bid+SL,OrderTakeProfit(),Yellow);
      Print("Sellstop = ",GetLastError());
     }

Ich habe es auch auf diese Weise versucht, aber es macht keinen Unterschied:

buy_ticket=OrderSend(Symbol(),OP_BUYSTOP,Lots,Ask+Price,30,Ask-SL,0,"Pending",magic,0,Lime);
      RefreshRates();
sell_ticket=OrderSend(Symbol(),OP_SELLSTOP,Lots,Bid-Price,30,Bid+SL,0,"Pending",magic,0,Red);

Und selbst wenn ich dies tue, macht es keinen Unterschied:

if(total==0) // && (Time[0]==time1)
 

Vielen Dank für all die Hilfe. Ich habe es endlich zum Laufen gebracht. Der einzige Weg, wie ich es dazu bringen konnte, durchgängig zu funktionieren, war, es so zu ändern:

 if(total==0)
     {
      buystop_ticket=OrderSend(Symbol(),OP_BUYSTOP,Lots,Ask+Price,30,Ask-SL,0,"Pending",magic,0,Lime);
      Print("buystop = ",GetLastError());
      RefreshRates();
     }
   if(total==1)
     {
      sellstop_ticket=OrderSend(Symbol(),OP_SELLSTOP,Lots,Bid-Price,30,Bid+SL,0,"Pending",magic,0,Red);
      Print("sellstop = ",GetLastError());
     }

Ich habe auch herausgefunden, dass der Pipmove-Level vor der Aktivierung der Pending-Order höher sein muss als der Stoplevel. Jetzt scheint also alles zu funktionieren. Danke

 
Trader3000:

Vielen Dank für all die Hilfe. Ich habe es endlich zum Laufen gebracht. Der einzige Weg, wie ich es dazu bringen konnte, durchgängig zu funktionieren, war, es so zu ändern:

Ich habe auch herausgefunden, dass der Pipmove-Level vor der Aktivierung der Pending-Order höher sein muss als der Stoplevel. Jetzt scheint also alles zu funktionieren. Danke

Nein, das funktioniert auch nicht, weil jetzt weiterhin ein sell_stop geöffnet wird, solange ein Trade offen ist.
 
Die einfache Antwort ist, dass man nicht versuchen sollte, schwebende Aufträge so nahe am aktuellen Kurs zu eröffnen. 5 Punkte ist in der Regel ein halber Pip
 
GumRai:
Die einfache Antwort ist, dass Sie nicht versuchen sollten, schwebende Aufträge so nahe am aktuellen Kurs zu eröffnen. 5 Punkte sind normalerweise ein halber Pip.

Vielen Dank für die Antwort. Ich rechne eigentlich in Pips, also sind die Pending Orders mindestens 50 Punkte (5 Pips vom aktuellen Kurs entfernt), aber es scheint zu funktionieren, wenn ich sie mindestens 1 Pip weiter vom Stoplevel wegbewege, was beim EURUSD 50 Punkte sind. Es scheint so, als ob jetzt beide Trades geöffnet werden, außer dem ersten, nachdem ich ihn auf das Diagramm gezogen habe. Aber damit komme ich erst einmal klar. Mein Code sieht jetzt so aus:

extern int TrailingStart=20;
extern int TrailingStop=5;
extern int Hedge=10;
extern double Multiplier=3;
extern int StopLossOriginal=11;
extern int StopLossHedge=9;
extern double Percentage=1;
extern double Lotsize=0.01;
extern double MyMaxlots=30;
extern datetime StartTime1 = D'2016.03.25 14:50';
extern int Pipmove=5;
int i,TS=TrailingStart-TrailingStop,stoplevel=(MarketInfo(Symbol(),MODE_STOPLEVEL))/10; //stoplevel has been converted from points to pips (/10)

int start()
  {
   double Lots = NormalizeDouble(AccountEquity()*Percentage*Lotsize/100, 2),
          point=Point*10,
          Price=Pipmove*point,
          SL=StopLossOriginal*point,
          MinLots = MarketInfo(Symbol(),MODE_MINLOT),
          MaxLots = MarketInfo(Symbol(),MODE_MAXLOT),
          HedgeLots=NormalizeDouble(OrderLots()*Multiplier,2);

   if(StopLossHedge<stoplevel) StopLossHedge=stoplevel;
   if(TS<stoplevel) TrailingStart=(stoplevel+TrailingStop);
   if(Pipmove<stoplevel+1) Pipmove=stoplevel+1;
   if(StopLossOriginal<=StopLossHedge) StopLossOriginal=StopLossHedge+1;

   datetime time1=StartTime1-300;

   int buy_ticket=0,sell_ticket=0,buystop_ticket=0,sellstop_ticket=0,total=0;
   for(i=OrdersTotal()-1; i>=0; i--)
      if(OrderSelect(i,SELECT_BY_POS) && OrderMagicNumber()==magic && OrderSymbol()==Symbol())
        {
         total++;
         if(OrderType()==OP_BUYSTOP) buystop_ticket=OrderTicket();
         if(OrderType()==OP_SELLSTOP) sellstop_ticket=OrderTicket();
         if(OrderType()==OP_BUY) buy_ticket=OrderTicket();
         if(OrderType()==OP_SELL) sell_ticket=OrderTicket();
        }

   if(total<1 && Time[0]==time1)
     {
      buystop_ticket=OrderSend(Symbol(),OP_BUYSTOP,Lots,Ask+Price,30,Ask-SL,0,"Pending",magic,0,Lime);
      RefreshRates();
      sellstop_ticket=OrderSend(Symbol(),OP_SELLSTOP,Lots,Bid-Price,30,Bid+SL,0,"Pending",magic,0,Red);
     }

Ich bin auf ein anderes, aber ähnliches Problem gestoßen. Sobald eine der schwebenden Orders ausgelöst wird, kann eines von zwei Dingen passieren. Entweder wird der TrailingStop ausgelöst, woraufhin die andere schwebende Order gelöscht wird, oder wenn dieser Handel gegen mich läuft, sollte eine Absicherung in die entgegengesetzte Richtung geöffnet werden. Je nachdem, wie ich den Code schreibe, werden entweder mehrere Absicherungen oder gar keine Absicherung geöffnet. Ich habe alles ausprobiert, einschließlich der folgenden beiden:

if(OrderSelect(buy_ticket,SELECT_BY_TICKET) && OrderType()==OP_BUY)
     {
      if(Bid-OrderOpenPrice()>TrailingStart*point)
        {
         if(OrderStopLoss()<Bid-TrailingStop*point)
           {
            if(OrderModify(OrderTicket(),OrderOpenPrice(),Bid-TrailingStop*point,OrderTakeProfit(),Blue))
              {
               if(OrderSelect(sellstop_ticket,SELECT_BY_TICKET) && OrderType()==OP_SELLSTOP)
                 {
                  if(OrderDelete(sellstop_ticket,Orange))
                     return(0);
                 }
              }
           }
        }
      if(OrderOpenPrice()>Bid+Hedge*point && buy_ticket==1 && sell_ticket<=1)
            {
              sell_ticket=OrderSend(Symbol(),OP_SELL,HedgeLots,Bid,3,Bid+StopLossHedge*point,0,"Hedge",magic,0,Red);
            }  
        }
//Same for Sell

Oder:


//Same up to here:
else if(total<=2 && OrderOpenPrice()>Bid+Hedge*point)
        {
         sell_ticket=OrderSend(Symbol(),OP_SELL,HedgeLots,Bid,3,Bid+StopLossHedge*point,0,"Hedge",magic,0,Red);
        }

Sollte ich dafür eine separate for-Schleife verwenden? Vielen Dank

 

Hallo zusammen

ich versuche es schon seit Wochen und habe immer noch keine Fortschritte gemacht. Alles funktioniert jetzt, außer dass der EA unter bestimmten Bedingungen mehr als einen Hedge-Trade auf den ursprünglichen Handel öffnet. Der SL auf den ursprünglichen Handel ist 11 Pips und der SL auf den Hedge-Trade ist 9 Pips. Manchmal wird der Hedge-Handel bei 9 Pips gestoppt, während der ursprüngliche Handel noch offen ist. Dann wird ein zweiter Hedge-Handel und sogar ein dritter und vierter eröffnet, während der ursprüngliche Handel noch offen ist. Ich möchte einfach die Anzahl der Hedge-Handel auf einen beschränken und wenn er gestoppt wird, einfach abwarten und sehen, was mit dem ursprünglichen Handel passiert.

Das ist die Art von Ergebnissen, die ich erhalte:

576 2015.01.15 11:39 buy stop 29 0.48 1.16786 1.16616 0.00000 0.00 4834.24

577 2015.01.15 11:39 sell stop 30 0.48 1.16642 1.16812 0.00000 0.00 4834.24

578 2015.01.15 11:39 sell 30 0.48 1.16642 1.16812 0.00000 0.00 4834.24

579 2015.01.15 11:39 löschen 29 0.48 1.16786 1.16616 0.00000 0.00 4834.24

580 2015.01.15 11:42 kaufen 31 1.44 1.16743 1.16653 0.00000 0.00 4834.24

581 2015.01.15 11:42 s/l 31 1.44 1.16653 1.16653 0.00000 -129.60 4704.64

582 2015.01.15 11:44 kaufen 32 1.44 1.16742 1.16652 0.00000 0.00 4704.64

583 2015.01.15 11:44 s/l 30 0.48 1.16812 1.16812 0.00000 -81.60 4623.04

584 2015.01.15 11:48 ändern 32 1.44 1.16742 1.16893 0.00000 0.00 4623.04

Die Kauf- und Verkaufsstopp-Aufträge (29 und 30) werden ordnungsgemäß eröffnet. Dann fällt der Kurs, und der Verkaufsauftrag (30) wird ausgeführt, während der Kaufstopp (29) gelöscht wird. Dann steigt der Kurs wieder, und der Hedge(Martingale)-Auftrag (31) wird ausgelöst (3*Lotgröße). Der Preis fällt dann wieder und der Hedge (31) wird gestoppt, aber da 30 noch offen ist, wird ein weiterer Hedge (32) ausgelöst usw. Wie kann ich verhindern, dass der Auftrag 32 ausgelöst wird? Vielen Dank


 

Hallo zusammen, es ist nun schon über einen Monat her, dass ich versucht habe, dieses Problem zu lösen, und ich fange an zu glauben, dass es programmtechnisch unmöglich zu kodieren ist. Wenn also jemand dies bitte bestätigen kann, kann ich das Problem aus der Welt schaffen und weitermachen. Ist es nicht möglich, ein tiefes Niveau für die Anzahl der Hedge(Martingale)-Aufträge festzulegen, wie im obigen Beitrag erklärt? Vielen Dank.

Das Beste, was ich bis jetzt habe, ist:

int start()
{
   int buy_ticket=0;
   int sell_ticket=0;
   int total=0;
   for(int i= OrdersTotal()-1; i>= 0; i--)
      if(OrderSelect(i,SELECT_BY_POS) && OrderSymbol()==Symbol())
     {
         total++;
         if(OrderType()==OP_BUY) buy_ticket=OrderTicket();
         if(OrderType()==OP_SELL) sell_ticket=OrderTicket();
        }
   /*if(total==1 && OrderSelect(buy_ticket,SELECT_BY_TICKET) && OrderType()==OP_BUY) <------- this blocked out code is irrelevant, but I want to put it here for completeness
     {
      if(Bid-OrderOpenPrice()>TrailingStart*point)
        {
         if(OrderStopLoss()<Bid-TrailingStop*point)
           {
            if(OrderModify(OrderTicket(),OrderOpenPrice(),Bid-TrailingStop *point,OrderTakeProfit(),Blue))
               return(0);
           }
        }*/
      else if(OrderOpenPrice()>Bid+Hedge*point)
        {
         sell_ticket=OrderSend(Symbol(),OP_SELL,HedgeLots,Bid,3,Bid+StopLossHedge*point,0,"Hedge",magic,0,Blue);
         return(0);
        }
     }
  }
 

Es gibt verschiedene Möglichkeiten, dies zu erreichen.

Wenn der Hedge eröffnet wird, erstellen Sie eine globale Variable des Client-Terminals.

Geben Sie ihr einen Namen, der die Ticketnummer des Hauptgeschäfts enthält.

Geben Sie ihr einen Wert, der als Kennzeichen dafür dient, dass für diese Ticketnummer ein Hedge-Geschäft eröffnet wurde, oder gegebenenfalls einen Hedge-Zähler.

Prüfen Sie den GV, bevor Sie einen Hedge eröffnen.


Der Hedge und das Hauptgeschäft haben unterschiedliche Losgrößen.

Prüfen Sie vor der Eröffnung eines Hedge-Geschäfts die offenen Aufträge und die Historie, um festzustellen, ob ein gegenteiliger Auftrag mit der entsprechenden Losgröße und einer OrderOpenTime() eröffnet wurde, die nach der Öffnungszeit des Hauptgeschäfts liegt.

 
GumRai:

Es gibt verschiedene Möglichkeiten, dies zu erreichen.

Wenn der Hedge eröffnet wird, erstellen Sie eine Globale Variable des Client-Terminals.

Geben Sie ihm einen Namen, der die Ticketnummer des Hauptgeschäfts enthält.

Geben Sie ihm einen Wert, der als Kennzeichen dafür dient, dass für diese Ticketnummer ein Hedge-Geschäft eröffnet wurde, oder eine Hedge-Zahl, falls erforderlich.

Prüfen Sie den GV, bevor Sie einen Hedge eröffnen.


Der Hedge und das Hauptgeschäft haben unterschiedliche Losgrößen.

Prüfen Sie vor der Eröffnung eines Hedge-Geschäfts die offenen Aufträge und die Historie, um festzustellen, ob ein gegenteiliger Auftrag mit der entsprechenden Losgröße und einer OrderOpenTime(), die nach der Öffnungszeit des Hauptgeschäfts liegt, eröffnet wurde.

Vielen Dank, ich werde mir diese Optionen ansehen und Ihnen Bescheid geben.
 

Also habe ich versucht, dies durch eine Globale Variable zu erreichen, aber seit ich diesen Code hinzugefügt habe, wird überhaupt kein Hedge-Handel eröffnet. Ich denke, dass das Problem darin besteht, dass der EA einen GlobalVariableCheck durchführt, aber da noch keiner erstellt wurde, fährt er nicht fort. Er wählt jedoch die richtige Ticketnummer aus und druckt sie. Vielleicht mache ich es falsch. Hier ist der relevante Code:

//+------------------------------------------------------------------+
//|  Hedge                                                           |
//+------------------------------------------------------------------+
void Hedgetrade(){
int buy_hedge=0,sell_hedge=0,total=0;
double Pip=Point*10,HedgeLots=NormalizeDouble(OrderLots()*Multiplier,2),SLHedge=StopLossHedge*Pip;
   for(int i=OrdersTotal()-1; i>=0; i--){
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)&& OrderSymbol()==Symbol()){
      total++;
      int ticket=OrderTicket();
      Print("ticket = ",ticket);
     }          
         if(OrderType()==OP_BUY){
            if(buy_hedge==0 && sell_hedge==0 && OrderOpenPrice()>Bid+Hedge*Pip)
               GlobalVariableCheck(ticket);
               sell_hedge=OrderSend(Symbol(),OP_SELL,HedgeLots,Bid,3,Bid+SLHedge,0,"Hedge",0,0,Blue);
                  GlobalVariableSet(ticket,1);
                 }
         if(OrderType()==OP_SELL){
            if(sell_hedge==0 && buy_hedge==0 && OrderOpenPrice()<Ask-Hedge*Pip)
               GlobalVariableCheck(ticket);
               buy_hedge=OrderSend(Symbol(),OP_BUY,HedgeLots,Ask,3,Ask-SLHedge,0,"Hedge",0,0,Red);
                  GlobalVariableSet(ticket,1);
              }
            }
          }
12345
Neuer Kommentar