Problema con la quantità totale di ordini aperti - pagina 4

Nuovo commento
 

Ciao a tutti

Anche se l'aggiunta di RefreshRates() sembra fare la differenza, sto ancora avendo lo stesso problema: a volte apre entrambi gli ordini in sospeso, a volte solo uno dei due e a volte nessuno dei due. Ricevo ancora l'errore 130 quando non apre un ordine o entrambi, ma nessun errore quando entrambi vengono aperti. Ho anche notato che su quelle coppie in cui i miei input sono inferiori a MODE_STOPLEVEL, non apre mai un ordine e ho sempre l'errore 130, anche se il programma regola i miei input come richiesto. Sto stampando i valori e sono regolati come previsto. Quindi sto cercando di capire perché il mio OrderSend non funziona veramente.

Su una coppia come EURUSD dove lo stoplevel è 5, di solito invia entrambi gli ordini, ma non sempre, mentre su una coppia come EURAUD dove lo stoplevel è 10, non invia mai un ordine

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());
     }

Ho anche provato così, ma non fa alcuna differenza:

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);

E anche se faccio così non fa differenza:

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

Grazie a tutti per l'aiuto, finalmente sono riuscito a farlo funzionare, l'unico modo che avevo per farlo funzionare in modo coerente era cambiarlo in questo modo:

 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());
     }

Ho anche capito che il livello di Pipmove prima che l'ordine pendente venga attivato deve anche essere più alto di stoplevel. Così tutto sembra funzionare ora... Grazie

 
Trader3000:

Grazie a tutti per l'aiuto, finalmente sono riuscito a farlo funzionare, l'unico modo in cui sono riuscito a farlo funzionare in modo coerente è stato cambiarlo in questo modo:

Ho anche capito che il livello di Pipmove prima che l'ordine pendente venga attivato deve anche essere più alto di stoplevel. Così tutto sembra funzionare ora... Grazie

No, neanche questo funziona perché ora continuerà ad aprire un sell_stop finché c'è un trade aperto
 
La semplice risposta è di non cercare di aprire ordini pendenti così vicini al prezzo corrente. 5 punti sono di solito mezzo pip
 
GumRai:
La risposta semplice è di non cercare di aprire ordini pendenti così vicini al prezzo corrente. 5 punti sono di solito mezzo pip

Grazie per la risposta. Il mio calcolo è effettivamente in pip, quindi gli ordini pendenti sono almeno 50 punti (5 pip di distanza dal prezzo corrente), tuttavia, sembra funzionare se lo sposto almeno 1 pip più lontano dallo stoplevel, che è di 50 punti sulla EURUSD. Sembra che ora apra entrambi i trade tranne il primo dopo averlo trascinato sul grafico. Ma mi va bene così per ora. Il mio codice ora è così:

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);
     }

Mi sono imbattuto in un problema separato ma simile: una volta che uno degli ordini pendenti viene attivato, può succedere una delle due cose: o si attiva il TrailingStop e a quel punto l'altro ordine pendente viene cancellato, o se quel trade mi va contro dovrebbe aprire una copertura nella direzione opposta. A seconda di come scrivo il codice, si aprirà più di una copertura o nessuna copertura. Ho provato di tutto, comprese le due seguenti:

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

Oppure:


//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);
        }

Dovrei usare un ciclo for separato per questo? Grazie

 

Ciao a tutti

Sono state settimane di tentativi e non ho ancora fatto alcun progresso. Tutto funziona ora, tranne che in certe condizioni l'EA apre più di un trade di copertura sul trade originale. Lo SL sul trade originale è di 11 pip e lo SL sul trade di copertura è di 9 pip. A volte l'hedge trade viene fermato a 9 pip mentre il trade originale è ancora aperto, quindi aprirà un secondo hedge trade e anche un terzo e un quarto mentre il trade originale è ancora aperto. Voglio semplicemente limitare la quantità di hedge trade a uno e se viene fermato, aspettare e vedere cosa succede con il trade originale.

Questo è il tipo di risultati che ottengo:

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 vendere stop 30 0.48 1.16642 1.16812 0.00000 0.00 4834.24

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

579 2015.01.15 11:39 cancellare 29 0.48 1.16786 1.16616 0.00000 0.00 4834.24

580 2015.01.15 11:42 comprare 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 buy 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 modifica 32 1.44 1.16742 1.16893 0.00000 0.00 4623.04

Gli ordini buystop e sellstop (29 e 30) vengono aperti come dovrebbero. Il prezzo scende e l'ordine di vendita (30) viene riempito mentre il buystop (29) viene cancellato. Il prezzo sale di nuovo e l'ordine hedge (martingala) (31) viene attivato (3*lotsize). Il prezzo scende di nuovo e l'ordine di copertura (31) viene fermato, ma poiché 30 è ancora aperto, si attiva un altro ordine di copertura (32), ecc. Come posso evitare che l'ordine 32 venga attivato? Grazie


 

Ciao a tutti, è più di un mese che cerco di risolvere questo problema e comincio a pensare che sia programmaticamente impossibile da codificare, quindi se qualcuno mi conferma questo, posso metterlo a riposo e andare avanti. Non è possibile impostare un livello profondo per il numero di ordini di copertura (martingala) come spiegato nel post sopra? Grazie.

Il meglio che ho finora è:

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);
        }
     }
  }
 

Ci sono diversi modi in cui questo può essere ottenuto.

Quando la copertura è aperta, create una variabile globale del terminale del cliente.

Dategli un nome che includa il numero del ticket della compravendita principale.

Dategli un valore che agisca come una bandiera che un trade di copertura è stato aperto per quel numero di ticket, o un conteggio della copertura se necessario.

Controllare il GV prima di aprire una copertura.


L'hedge e l'operazione principale hanno lotti di dimensioni diverse.

Prima di aprire una copertura, controlla gli ordini aperti e la cronologia per vedere se è stato aperto un ordine opposto con la dimensione del lotto pertinente con un OrderOpenTime() successivo all'orario di apertura dell'operazione principale.

 
GumRai:

Ci sono diversi modi in cui questo può essere ottenuto.

Quando la copertura è aperta, create una variabile globale del terminale del cliente.

Dategli un nome che includa il numero del ticket della compravendita principale.

Dategli un valore che agisca come una bandiera che un'operazione di copertura è stata aperta per quel numero di biglietto, o un conteggio della copertura se necessario.

Controllare il GV prima di aprire una copertura.


L'hedge e l'operazione principale hanno lotti di dimensioni diverse.

Prima di aprire una copertura, controlla gli ordini aperti e la cronologia per vedere se è stato aperto un ordine opposto con la dimensione del lotto pertinente con un OrderOpenTime() successivo al tempo di apertura dell'operazione principale.

Grazie mille, esaminerò queste opzioni e vi farò sapere.
 

Così ho cercato di ottenere questo attraverso una Variabile Globale, ma da quando ho aggiunto questo codice, non sta aprendo affatto un trade di copertura. Penso che il problema sia che l'EA sta facendo un GlobalVariableCheck, ma dato che non ne è stato ancora creato nessuno, non continua. Tuttavia, seleziona e stampa il numero di biglietto corretto. Forse sto sbagliando. Ecco il codice rilevante:

//+------------------------------------------------------------------+
//|  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
Nuovo commento
Motivazione: