Problème avec le montant total des ordres ouverts - page 4

Nouveau commentaire
 

Bonjour à tous

Désolé, mais j'ai parlé trop vite. Bien que l'ajout de RefreshRates() semble faire une différence, j'ai toujours le même problème. Il ouvre parfois les deux ordres en attente, parfois seulement l'un des deux, et parfois aucun des deux. Je reçois toujours l'erreur 130 quand il n'ouvre pas un ordre, ou les deux, mais aucune erreur quand les deux sont effectivement ouverts. J'ai également remarqué que sur les paires où mes entrées sont inférieures à MODE_STOPLEVEL, il n'ouvre jamais d'ordre et j'ai toujours l'erreur 130, même si le programme ajuste mes entrées comme demandé. J'imprime les valeurs et elles sont ajustées comme prévu. J'essaie donc de comprendre pourquoi mon OrderSend ne fonctionne pas vraiment.

Sur une paire comme EURUSD où le niveau de base est de 5, il envoie généralement les deux ordres, mais pas toujours. Cependant, sur une paire comme EURAUD où le niveau de base est de 10, il n'envoie jamais d'ordre.

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

J'ai également essayé comme cela, mais cela ne fait aucune différence :

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

Et même si je fais cela, cela ne fait aucune différence :

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

Merci pour votre aide à tous. J'ai finalement réussi à le faire fonctionner. La seule façon de le faire fonctionner de manière cohérente était de le changer en ceci :

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

J'ai aussi compris que le niveau de Pipmove avant que l'ordre en attente ne soit activé doit aussi être supérieur au stoplevel. Donc tout semble fonctionner maintenant... Merci.

 
Trader3000:

Merci pour votre aide à tous. J'ai finalement réussi à le faire fonctionner. La seule façon de le faire fonctionner de manière cohérente était de le changer en ceci :

J'ai aussi compris que le niveau de Pipmove avant que l'ordre en attente ne soit activé doit aussi être supérieur au stoplevel. Donc tout semble fonctionner maintenant... Merci.

Non, cela ne fonctionne pas non plus parce qu'il va maintenant continuer à ouvrir un sell_stop tant qu'il y a une transaction ouverte.
 
La réponse simple est de ne pas essayer d'ouvrir des ordres en attente si près du prix actuel. 5 points correspondent généralement à un demi-pip
 
GumRai:
La réponse simple est de ne pas essayer d'ouvrir des ordres en attente si près du prix actuel. 5 points correspondent généralement à un demi-pip.

Merci pour la réponse. Mon calcul est en fait en pips, donc les ordres en attente sont au moins à 50 points (5 pips du prix actuel), cependant, il semble fonctionner si je le déplace au moins 1 pip plus loin du niveau de référence, qui est de 50 points sur l'EURUSD. Il semble qu'il ouvre maintenant les deux trades sauf le premier après que je l'ai fait glisser sur le graphique. Mais je suis d'accord avec cela pour le moment. Mon code ressemble maintenant à ceci :

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

J'ai rencontré un problème distinct mais similaire. Une fois que l'un des ordres en attente est déclenché, l'une des deux choses suivantes peut se produire. Soit il déclenche le TrailingStop, auquel cas l'autre ordre en attente est supprimé. Soit, si cette transaction est en ma défaveur, il devrait ouvrir une couverture dans la direction opposée. Selon la façon dont j'écris le code, il ouvrira plus d'une couverture ou aucune couverture. J'ai tout essayé, y compris les deux suivantes :

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

Ou bien :


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

Dois-je utiliser une boucle for séparée pour cela ? Merci.

 

Bonjour à tous

Cela fait des semaines que j'essaie et je n'ai toujours pas progressé. Tout fonctionne maintenant, sauf que dans certaines conditions, l'EA ouvre plus d'un hedge trade sur le trade original. Le SL sur le trade original est de 11 pips et le SL sur le Hedge trade est de 9 pips. Parfois, le hedge trade est arrêté à 9 pips alors que le trade original est encore ouvert. Il ouvre alors un deuxième hedge trade et même un troisième et un quatrième alors que le trade original est encore ouvert. Je veux simplement limiter le nombre de hedge trades à un seul et s'il est arrêté, attendre et voir ce qui se passe avec le trade original.

C'est le type de résultats que j'obtiens :

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

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

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

Les ordres buystop et sellstop (29 et 30) sont ouverts comme il se doit. Le prix baisse ensuite et l'ordre de vente (30) est exécuté tandis que le buystop (29) est supprimé. Le prix remonte ensuite et l'ordre hedge(martingale) (31) est déclenché (3*lotsize). Le prix baisse à nouveau et le hedge (31) est stoppé, mais comme 30 est toujours ouvert, il déclenche un autre hedge (32), etc. Comment puis-je empêcher le déclenchement de l'ordre 32 ? Merci.


 

Bonjour à tous. Cela fait plus d'un mois que j'essaie de résoudre ce problème et je commence à penser qu'il est impossible de le coder. Si quelqu'un veut bien me le confirmer, je pourrai passer à autre chose. N'est-il pas possible de définir un niveau profond pour le nombre d'ordres de couverture (martingale) comme expliqué dans le message ci-dessus ? Merci.

Le meilleur que j'ai jusqu'à présent est :

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

Il existe différentes façons d'y parvenir.

Lorsque la couverture est ouverte, créez une Variable Globale du terminal client.

Donnez-lui un nom qui inclut le numéro de ticket de la transaction principale.

Donnez-lui une valeur qui sert d'indicateur qu'une opération de couverture a été ouverte pour ce numéro de ticket, ou un compte de couverture si nécessaire.

Vérifiez le GV avant d'ouvrir une opération de couverture.


Le hedge et le trade principal ont des tailles de lot différentes.

Avant d'ouvrir une couverture, vérifiez les ordres ouverts et l'historique pour voir si un ordre opposé a été ouvert avec la taille de lot correspondante et une OrderOpenTime() postérieure à l'heure d'ouverture de la transaction principale.

 
GumRai:

Il existe différentes façons d'y parvenir.

Lorsque la couverture est ouverte, créez une variable globale du terminal client.

Donnez-lui un nom qui inclut le numéro de ticket de la transaction principale.

Donnez-lui une valeur qui indique qu'une opération de couverture a été ouverte pour ce numéro de ticket, ou un nombre de couvertures si nécessaire.

Vérifiez le GV avant d'ouvrir une opération de couverture.


La transaction de couverture et la transaction principale ont des tailles de lot différentes.

Avant d'ouvrir une couverture, vérifiez les ordres ouverts et l'historique pour voir si un ordre opposé a été ouvert avec la taille de lot correspondante et une OrderOpenTime() ultérieure à l'heure d'ouverture de la transaction principale.

Merci beaucoup, je vais examiner ces options et vous tenir au courant.
 

J'ai donc essayé d'y parvenir par le biais d'une variable globale, mais depuis que j'ai ajouté ce code, il n'ouvre pas du tout de transaction de couverture. Je pense que le problème est que l'EA effectue un GlobalVariableCheck, mais comme aucun n'a encore été créé, il ne continue pas. Il sélectionne et imprime cependant le bon numéro de ticket. Peut-être que je m'y prends mal. Voici le code correspondant :

//+------------------------------------------------------------------+
//|  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
Nouveau commentaire
Raison: