[ARCHIVE] Toute question de débutant, afin de ne pas encombrer le forum. Professionnels, ne passez pas à côté. Nulle part sans toi - 3. - page 450

Nouveau commentaire
 
T-G:
Oui, mais le point de la question est que l'ordre précédent a été fermé avec un moins. La fonction n'a pas le temps de le montrer, d'abord l'ordre est ouvert après quelques ticks et seulement alors la fonction montre la dernière perte mais l'ordre a déjà été ouvert.
J'ai écrit un squelette de code avec contrôle
 
Je l'ai fait et une fois de plus, il a dit qu'il n'avait pas le temps de vérifier. Il a d'abord fait comme s'il n'y avait pas d'orignal, puis il s'est rendu compte qu'il y avait un orignal.
 
artmedia70:

Pourquoi ne pas utiliser le paramètre Expiration de l'ordre en attente.

Il est bien sûr possible que ce paramètre ne puisse pas être utilisé.

Sur certains serveurs commerciaux, le délai d'expiration des ordres en attente peut être interdit. Dans ce cas, une erreur 147 (ERR_TRADE_EXPIRATION_DENIED) sera générée lors de la tentative de définir une valeur non nulle dans le paramètre d'expiration.

C'est la seule façon, bien sûr...

J'ai modifié la ligne comme vous l'avez suggéré et le conseiller expert a cessé de fonctionner...

ticket=OrderSend(Symbol(),OP_BUYSTOP,Lots,Ask+PriceDistance*Point,3,Ask+PriceDistance*Point-StopLoss*Point,Ask+PriceDistance*Point+TakeProfit*Point, "PD",1,TimeCurrent()+10*60,Green) ;

En même temps, je sais avec certitude qu'il n'y a pas d'interdiction.

Veuillez indiquer où se trouve l'erreur.

 
T-G:
Je l'ai fait et une fois de plus, il a dit qu'il n'avait pas le temps de vérifier. Il a d'abord fait comme s'il n'y avait pas d'orignal, puis il s'est rendu compte qu'il y avait un orignal.
Les miracles n'arrivent pas. Vous devriez voir un télépathe...
 
OlegArH:

J'ai apporté des modifications à la ligne comme vous l'avez suggéré, et le conseiller expert a cessé de fonctionner...

ticket=OrderSend(Symbol(),OP_BUYSTOP,Lots,Ask+PriceDistance*Point,3,Ask+PriceDistance*Point-StopLoss*Point,Ask+PriceDistance*Point+TakeProfit*Point, "PD",1,TimeCurrent()+10*60,Green) ;

En même temps, je sais avec certitude qu'il n'y a pas d'interdiction.

Veuillez indiquer où se trouve l'erreur.

Il est peu probable qu'il ait cessé de fonctionner, mais vos critères sont probablement erronés. Sans le code, il est difficile de trouver une raison pour laquelle l'EA ne fonctionne pas...
 
artmedia70:
Il est peu probable qu'il ait cessé de fonctionner, mais vos critères risquent d'être boiteux. Sans le code, il est difficile de trouver une raison pour laquelle l'EA ne fonctionne pas...

Voici tout ce que j'ai griffonné jusqu'à présent :

extern double TakeProfit = 50 ;
extern double StopLoss=100 ;
externe double PriceDistance = 50 ;
extern double Lots = 1 ;
extern double TrailingStop = 50 ;
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int start()
{
int cnt, ticket, total ;

total=OrdersTotal() ;
si(total<1)
{
ticket=OrderSend(Symbol(),OP_BUYSTOP,Lots,Ask+PriceDistance*Point,3,Ask+PriceDistance*Point-StopLoss*Point,Ask+PriceDistance*Point+TakeProfit*Point, "PD",1,0,Green) ;
Dormir (10000) ;
ticket=OrderSend(Symbol(),OP_SELLSTOP,Lots,Bid-PriceDistance*Point,3,Bid-PriceDistance*Point+StopLoss*Point,Bid-PriceDistance*Point-TakeProfit*Point, "PD",2,0,Red) ;
}

for(cnt=0;cnt<total;cnt++)
{
OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES) ;
if(OrderType()<=OP_SELL && // vérification de la position ouverte
OrderSymbol()==Symbol()) // vérification du symbole
{
if(OrderType()==OP_BUY) // une position longue est ouverte
{
// doit-il être fermé ?
si(1!=1)
{
OrderClose(OrderTicket(),OrderLots(),Bid,3,Violet) ; // fermer la position
return(0) ; // sortie
}
// vérifier le trailing stop
si(TrailingStop>0)
{
si(Bid-OrderOpenPrice()>Point*TrailingStop)
{
si(OrderStopLoss()<Bid-Point*TrailingStop)
{
OrderModify(OrderTicket(),OrderOpenPrice(),Bid-Point*TrailingStop,OrderTakeProfit(),0,Green) ;
retour(0) ;
}
}
}
}
else // passer en position courte
{
// doit-il être fermé ?
si(1!=1)
{
OrderClose(OrderTicket(),OrderLots(),Ask,3,Violet) ; // position de clôture
return(0) ; // sortie
}
// vérifier le trailing stop
si(TrailingStop>0)
{
si((OrderOpenPrice()-Ask)>(Point*TrailingStop))
{
si((OrderStopLoss()>(Ask+Point*TrailingStop)) || (OrderStopLoss()==0)))
{
OrderModify(OrderTicket(),OrderOpenPrice(),Ask+Point*TrailingStop,OrderTakeProfit(),0,Red) ;
retour(0) ;
}
}
}
}
}
}
retour(0) ;
}

// la fin.

Cela fonctionne comme suit : .... Mais, en conséquence, ouvre des commerces indéfiniment, la liane.

Merci d'avance !

 
OlegArH:

Voici tout ce que j'ai griffonné jusqu'à présent :

extern double TakeProfit = 50 ;
extern double StopLoss=100 ;
externe double PriceDistance = 50 ;
extern double Lots = 1 ;
extern double TrailingStop = 50 ;
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int start()
{
int cnt, ticket, total ;

total=OrdersTotal() ;
si(total<1)
{
ticket=OrderSend(Symbol(),OP_BUYSTOP,Lots,Ask+PriceDistance*Point,3,Ask+PriceDistance*Point-StopLoss*Point,Ask+PriceDistance*Point+TakeProfit*Point, "PD",1,0,Green) ;
Dormir (10000) ;
ticket=OrderSend(Symbol(),OP_SELLSTOP,Lots,Bid-PriceDistance*Point,3,Bid-PriceDistance*Point+StopLoss*Point,Bid-PriceDistance*Point-TakeProfit*Point, "PD",2,0,Red) ;
}

for(cnt=0;cnt<total;cnt++)
{
OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES) ;
if(OrderType()<=OP_SELL && // vérification de la position ouverte
OrderSymbol()==Symbol()) // vérification du symbole
{
if(OrderType()==OP_BUY) // une position longue est ouverte
{
// doit-il être fermé ?
si(1!=1)
{
OrderClose(OrderTicket(),OrderLots(),Bid,3,Violet) ; // fermer la position
return(0) ; // sortie
}
// vérifier le trailing stop
si(TrailingStop>0)
{
si(Bid-OrderOpenPrice()>Point*TrailingStop)
{
si(OrderStopLoss()<Bid-Point*TrailingStop)
{
OrderModify(OrderTicket(),OrderOpenPrice(),Bid-Point*TrailingStop,OrderTakeProfit(),0,Green) ;
retour(0) ;
}
}
}
}
else // passer en position courte
{
// doit-il être fermé ?
si(1!=1)
{
OrderClose(OrderTicket(),OrderLots(),Ask,3,Violet) ; // position de clôture
return(0) ; // sortie
}
// vérifier le trailing stop
si(TrailingStop>0)
{
si((OrderOpenPrice()-Ask)>(Point*TrailingStop))
{
si((OrderStopLoss()>(Ask+Point*TrailingStop)) || (OrderStopLoss()==0)))
{
OrderModify(OrderTicket(),OrderOpenPrice(),Ask+Point*TrailingStop,OrderTakeProfit(),0,Red) ;
retour(0) ;
}
}
}
}
}
}
retour(0) ;
}

// la fin.

Cela fonctionne comme suit : .... Mais, en conséquence, ouvre des commerces indéfiniment, la liane.

Merci d'avance !


Apprenez à insérer du code - lisez-le entièrement.
 
Roman.:

Apprenez à insérer du code - lisez-le entièrement.

Roman, merci pour la réponse !
Ce que je dois faire, c'est faire en sorte que le robot ouvre les transactions pour la durée à partir du moment où elles sont automatiquement ouvertes.

Par exemple, le robot ouvre une transaction TARGET, définit automatiquement un délai d'expiration de +600 sec à partir du délai actuel et c'est tout.....

Dans ce cas, l'option où il les supprime lui-même ne convient pas, puisque le TC sur lequel je me "forme" comporte des restrictions sur la modification des ordres en cours si le prix s'est rapproché de plus de 10 points + Spread du prix d'ouverture, y compris ceux qui ne sont pas encore ouverts.

En outre, le fait est que si un ordre est déjà ouvert, il ne doit pas être supprimé, mais nous devons le laisser "jouer" et bouillonner jusqu'à sa "mort". Et si nous définissons orderdelite, la fonction fermera également les ordres qui ont déjà été déclenchés. ( ?)

Quant au manuel - eh bien, je ne suis pas un programmeur par tempérament, je suis un brillant humaniste - je dessine, je modèle, je compose, et je n'aiguise pour rien d'autre).

J'ai essayé de m'y mettre de bonne foi. Certaines choses avaient du sens, d'autres non.

C'est pourquoi je suis ici......

 
OlegArH:

Roman, merci pour la réponse !
Il s'agit simplement de faire en sorte que le robot ouvre les transactions à temps à partir du moment où elles sont automatiquement ouvertes.

Par exemple, le robot ouvre une transaction TARGET, définit automatiquement un délai d'expiration de +600 sec à partir du délai actuel et c'est tout.....

Dans ce cas, l'option où il les supprime lui-même ne convient pas, puisque le TC sur lequel je me "forme" comporte des restrictions sur la modification des ordres en cours si le prix s'est rapproché de plus de 10 points + Spread du prix d'ouverture, y compris ceux qui ne sont pas encore ouverts.

En outre, le fait est que si un ordre est déjà ouvert, il ne doit pas être supprimé, mais nous devons le laisser "jouer" et bouillonner jusqu'à sa "mort". Et si nous définissons orderdelite, la fonction fermera également les ordres qui ont déjà été déclenchés. ( ?)

Quant au manuel - eh bien, je ne suis pas un programmeur par tempérament, je suis un brillant humaniste - je dessine, je modèle, je compose, et je n'aiguise pour rien d'autre).

J'ai essayé de m'y mettre de bonne foi. Certaines choses avaient du sens, d'autres non.

C'est pourquoi je suis ici......

Essayez de décrire en mots ce que vous avez écrit ici :

extern double TakeProfit = 50;
extern double StopLoss=100;
extern double PriceDistance = 50;
extern double Lots = 1;
extern double TrailingStop = 50;
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int start()
{
   int cnt, ticket, total;

   total=OrdersTotal();
   if(total<1) {
      ticket=OrderSend(Symbol(),OP_BUYSTOP,Lots,Ask+PriceDistance*Point,3,Ask+PriceDistance*Point-StopLoss*Point,
                       Ask+PriceDistance*Point+TakeProfit*Point,"PD",1,0,Green);
      Sleep (10000);
      ticket=OrderSend(Symbol(),OP_SELLSTOP,Lots,Bid-PriceDistance*Point,3,Bid-PriceDistance*Point+StopLoss*Point,
                       Bid-PriceDistance*Point-TakeProfit*Point,"PD",2,0,Red);
      }

   for(cnt=0;cnt<total;cnt++) {
      OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
      if(OrderType()<=OP_SELL &&                         // check for opened position
         OrderSymbol()==Symbol()) {                      // check for symbol
         if(OrderType()==OP_BUY) {                       // long position is opened
            if(1!=1) {
               OrderClose(OrderTicket(),OrderLots(),Bid,3,Violet); // close position
               return(0);                                // exit
               }
                                                         // check for trailing stop
            if(TrailingStop>0) {
               if(Bid-OrderOpenPrice()>Point*TrailingStop) {
                  if(OrderStopLoss()<Bid-Point*TrailingStop) {
                     OrderModify(OrderTicket(),OrderOpenPrice(),Bid-Point*TrailingStop,OrderTakeProfit(),0,Green);
                     return(0);
                     }
                  }
               }
            }
         else {                                          // go to short position
                                                         // should it be closed?
            if(1!=1) {
               OrderClose(OrderTicket(),OrderLots(),Ask,3,Violet); // close position
               return(0);                                // exit
               }
                                                         // check for trailing stop
            if(TrailingStop>0) {
               if((OrderOpenPrice()-Ask)>(Point*TrailingStop)) {
                  if((OrderStopLoss()>(Ask+Point*TrailingStop)) || (OrderStopLoss()==0)) {
                     OrderModify(OrderTicket(),OrderOpenPrice(),Ask+Point*TrailingStop,OrderTakeProfit(),0,Red);
                     return(0);
                     }
                  }
               }
            }
         }
      }
   return(0);
}

Personnellement, pour moi, au tout premier coup d'œil, cela s'est avéré être un puzzle votre idée : Si un n'est pas égal à un, alors fermez la commande....

Je n'ai pas regardé le reste après ça...

ZS et n'essayez pas, ne pensez même pas, qu'il est possible d'écrire un EA normal en un cycle...

 
OlegArH:

...Et si vous mettez orderdelite, la fonction fermera également les ordres qui ont déjà été déclenchés. ( ?)

...


Non. Regardez de plus près. Un ordre en attente déclenché devient un ordre au marché - cette fonction n'a rien à voir avec cela.

" Supprime un ordre en attente précédemment défini. Renvoie VRAI si la fonction s'est déroulée avec succès. Retourner FALSE

si la fonction n'a pas été achevée avec succès. Appelez GetLastError() pour obtenir des informations sur les erreurs."

1...443444445446447448449450451452453454455456457...652
Nouveau commentaire
Raison: