Toute question de débutant, afin de ne pas encombrer le forum. Professionnels, ne passez pas à côté. Nulle part sans toi - 6. - page 1100

Nouveau commentaire
 

Chers programmeurs, pouvez-vous s'il vous plaît m'aider à mettre une interdiction sur l'ouverture de plus d'une série de transactions à la fois (la série est si l'ordre est fermé dans la perte ou zéro et puis ouvre la transaction suivante sur le même instrument, mais avec un plus grand lot), c'est-à-dire, si vous ouvrez une série de transactions la deuxième et les suivantes sont mises sur d'autres instruments sous une interdiction (le bot travaille simultanément sur des instruments différents). Je pense que cela devrait être fait par le biais d'une variable globale dans le terminal, mais je n'ai pas assez de connaissances et d'expérience, je viens juste de commencer à apprendreMQL. Il s'agit d'un conseiller en options binaires. Voici le code

extern double Lots = 1 ; // Lots

extern int Exp = 1 ; // Expiration

extern int Wait = 1 ; // Nombre de chandeliers d'une même direction

extern int Timeout = 1 ; // Intervalle de temps

extern double Multiplier = 3 ; // Multiplicateur

extern int Slippage = 5 ; // Slippage

extern int Magic = 2090 ; // Magie


int ticket, Type ;

double Price, Lot ;

//+------------------------------------------------------------------+

//| Fonction d'initialisation de l'expert |

//+------------------------------------------------------------------+

int OnInit()

{

return(INIT_SUCCEEDED) ;

}

//+------------------------------------------------------------------+

//| Fonction de désinitialisation experte |

//+------------------------------------------------------------------+

void OnDeinit(const int reason)

{

}

//+------------------------------------------------------------------+

//| fonction tick expert |

//+------------------------------------------------------------------+

void OnTick()

{

// --------------- Ouvrir des transactions ---------------

if (OrdersTotal() == 0) // Le nombre de commandes doit être égal à zéro.

{

si ((TypeLastHistOrder() == OP_BUY && PriceCloseLastHistOrder(OP_BUY) < PriceOpenLastHistOrder(OP_BUY))

|| (TypeLastHistOrder() == OP_SELL && PriceCloseLastHistOrder(OP_SELL) > PriceOpenLastHistOrder(OP_SELL)))

// Si la dernière transaction est perdante, la même est ouverte, mais avec un lot plus important.

{

Type = TypeLastHistOrder() ;

if (Type == OP_BUY) Prix = Demande ;

if (Type == OP_SELL) Price = Bid ;

Lot = NormalizeDouble(LotsLastHistOrder()*Multiplier, 2) ;

ticket = OrderSend(Symbol(), Type, Lot, Prix, Slippage, 0, 0, IntegerToString(Exp), Magic) ;

}

si (PriceCloseLastHistOrder() == PriceOpenLastHistOrder() && CountHistTrades() > 0)

// si le bénéfice de la dernière transaction est égal à zéro, la même transaction sera ouverte.

{

Type = TypeLastHistOrder() ;

if (Type == OP_BUY) Prix = Demande ;

if (Type == OP_SELL) Price = Bid ;

Lot = NormalizeDouble(LotsLastHistOrder(), 2) ;

ticket = OrderSend(Symbol(), Type, Lot, Prix, Slippage, 0, 0, IntegerToString(Exp), Magic) ;

}

si ((TypeLastHistOrder() == OP_BUY && PriceCloseLastHistOrder(OP_BUY) > PriceOpenLastHistOrder(OP_BUY))

|| (TypeLastHistOrder() == OP_SELL && PriceCloseLastHistOrder(OP_SELL) < PriceOpenLastHistOrder(OP_SELL)))

|| CountHistTrades() == 0)// Si la dernière transaction est profitable, l'ordre est ouvert.

{

si (SignalBuy() && OrdersTotal() == 0)

{

ticket = OrderSend(Symbol(), OP_BUY, Lots, Ask, Slippage, 0, 0, IntegerToString(Exp), Magic) ;

}

si (SignalSell() && OrdersTotal() == 0)

{

ticket = OrderSend(Symbol(), OP_SELL, Lots, Bid, Slippage, 0, 0, IntegerToString(Exp), Magic) ;

Commentaire ("PriceCloseLastHistOrder(OP_BUY)= ", PriceCloseLastHistOrder(OP_BUY), "PriceCloseLastHistOrder(OP_SELL)=",

PrixCloseLastHistOrder(OP_SELL) ) ;

}

}

}

}

//+------------------------------------------------------------------+

int CountTrades(int type = -1) // Déterminer le nombre de transactions

{

int cnt = 0 ;

for (int i=OrdersTotal()-1 ; i>=0 ; i--) // La boucle passe par tous les ordres ouverts, i est le numéro de l'ordre.

{

if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) // La fonction vérifie si l'ordre portant le numéro i est sur le marché,

// si c'est le cas, les conditions suivantes sont vérifiées...

{

if (OrderSymbol() == Symbol() && OrderMagicNumber() == Magic && (OrderType() == type || type == -1)) // Si le symbole

// le symbole sur lequel l'ordre est ouvert est égal au symbole actuel, le type d'ordre est égal à magic dans les paramètres de l'EA actuel, et

// le type de commande est égal à type (ou type == -1 (dans le cas où le type requis pour le comptage de la commande n'a pas d'importance))

cnt++ ; // 1 est ajouté à la variable cnt et à la fin de la boucle cnt sera égal au nombre de donnes

// ouvert par l'EA actuel pour la paire de devises actuelle avec un certain type.

}

}

return(cnt) ; // la valeur de la variable cnt est retournée

}

//+------------------------------------------------------------------+

int CountHistTrades(int type = -1)

{

int cnt = 0 ;

for (int i=OrdersHistoryTotal()-1 ; i>=0 ; i--)

{

si (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))

{

si (OrderSymbol() == Symbol() && OrderMagicNumber() == Magic && (OrderType() == type || type == -1))

cnt++ ;

}

}

retour(cnt) ;

}

//+------------------------------------------------------------------+

bool SignalBuy()

{

pour (int i=1 ; i<=Wait ; i++)

{

si (Close[i] > Open[i]) return(false)

}

si ((iBarShift(Symbol(), 0, TimeLastHistOrder()+Timeout) >= Wait || (Wait == 0 && TimeCurrent() >= TimeLastHistOrder()+Timeout))

&& CountHistTrades() > 0) return(true) ;

si (CountHistTrades() == 0) return(true) ;

retour (faux) ;

}

//+------------------------------------------------------------------+

bool SignalSell()

{

pour (int i=1 ; i<=Wait ; i++)

{

si (Close[i] < Open[i]) return(false)

}

si ((iBarShift(Symbol(), 0, TimeLastHistOrder()+Timeout) >= Wait || (Wait == 0 && TimeCurrent() >= TimeLastHistOrder()+Timeout))

&& CountHistTrades() > 0) return(true) ;

si (CountHistTrades() == 0) return(true) ;

retour (faux) ;

}

//+------------------------------------------------------------------+

datetime TimeLastHistOrder(int type = -1)

{

datetime lasttime = 0 ;

datetime opentime = 0 ;


for (int i=OrdersHistoryTotal()-1 ; i>=0 ; i--)

{

si (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))

{

si (OrderSymbol() == Symbol() && OrderMagicNumber() == Magic && (OrderType() == type || type == -1))

{

si (OrderCloseTime() > lasttime)

{

lasttime = OrderCloseTime() ;

opentime = OrderOpenTime() ;

}

}

}

}

retour(opentime) ;

}

//+------------------------------------------------------------------+

int TypeLastHistOrder()

{

datetime time = 0 ;

int type = -1 ;

for (int i=OrdersHistoryTotal()-1 ; i>=0 ; i--)

{

si (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))

{

si (OrderSymbol() == Symbol() && OrderMagicNumber() == Magic)

{

si (OrderCloseTime() > time)

{

time = OrderCloseTime() ;

type = OrderType() ;

}

}

}

}

retour(type) ;

}

//+------------------------------------------------------------------+

double LotsLastHistOrder(int type = -1)

{

datetime time = 0 ;

double lots = 0 ;

for (int i=OrdersHistoryTotal()-1 ; i>=0 ; i--)

{

si (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))

{

si (OrderSymbol() == Symbol() && OrderMagicNumber() == Magic && (OrderType() == type || type == -1))

{

si (OrderOpenTime() > time)

{

time = OrderOpenTime() ;

time = OrderLots() ;

}

}

}

}

retour(lots) ;

}

//+------------------------------------------------------------------+

double PriceCloseLastHistOrder(int type = -1)

{

datetime time = 0 ;

double prix = 0 ;

for (int i=OrdersHistoryTotal()-1 ; i>=0 ; i--)

{

si (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))

{

si (OrderSymbol() == Symbol() && OrderMagicNumber() == Magic && (OrderType() == type || type == -1))

{

si (OrderCloseTime() > time)

{

time = OrderCloseTime() ;

prix = OrderClosePrice() ;

}

}

}

}

}

}

//+------------------------------------------------------------------+

double PriceOpenLastHistOrder(int type = -1)

{

datetime time = 0 ;

double prix = 0 ;

for (int i=OrdersHistoryTotal()-1 ; i>=0 ; i--)

{

si (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))

{

si (OrderSymbol() == Symbol() && OrderMagicNumber() == Magic && (OrderType() == type || type == -1))

{

si (OrderCloseTime() > time)

{

time = OrderCloseTime() ;

prix = OrderOpenPrice() ;

}

}

}

}

}

}

//+------------------------------------------------------------------+

 
Bonjour, chers collègues !

J'ai unequestion à propos de la programmation: existe-t-il un moyen d'obtenir l' heure du serveur en millisecondes dans l'EA ?
Par exemple, prenez : 23.09.2016 14h. : 53 min. : 54000 millisecondes ? C'est exactement 54 secondes, 000 millisecondes.
 
e-partner:
Bonjour chers collègues !

J'ai unequestion pendant la programmation: est-il possible d'obtenir d'une manière ou d'une autre dans l'Expert Advisor l'heure du serveur avec une précision de quelques millisecondes?
Par exemple, prenez : 23.09.2016 14h. : 53 min. : 54000 millisecondes ? C'est exactement 54 secondes, 000 millisecondes.

Question intéressante. Que voulez-vous dire, spécifier la dernière heure connue du serveur, l'heure de la dernière citation de TimeCurrent() ou l'heure actuelle sur le serveur ?

Si c'est TimeCurrent(), à quoi cela servira-t-il, si l'on considère qu'un paquet avec une nouvelle cotation passe par l'internet du serveur au terminal pendant 10-500 ms et que ce temps varie de paquet en paquet. En outre, il n'est pas clair, quelle est l'arrivée de la dernière cotation, si elle arrive au serveur depuis plusieurs sources, fournisseurs de liquidités, et qu'elle est ensuite traitée, puis le serveur envoie un nouveau tick. De plus, on ne sait pas comment le minuteur du système du serveur est synchronisé avec le temps astronomique. Le 09.01.2014 de 04:15 à 06:15 MSK (jeudi, jour de bourse) je le constatais, car l'écart n'est pas de l'ordre de l'astronomie, mais de la moyenne de 31 entreprises. La figure pour 25 points de temps montre ces écarts (en secondes, pas en ms) :

Et quel est l'intérêt de calculer quoi que ce soit en quelques millisecondes à partir des données du serveur ?

La deuxième option est plus claire. Si votre ordinateur est synchronisé avec l'heure astronomique avec une précision connue de vous, l'heure astronomique de la ville où fonctionne le serveur est connue avec la même précision. Mais pourquoi en avez-vous besoin...

 

Je n'arrive pas à comprendre où est passée l'optimisation du testeur de stratégie. Les contrôles sont tous debout, je ne peux rien comprendre. MT4 build 1010. Windows 8.1.

Veuillez indiquer comment activer l'optimisation.

Je vais joindre des captures d'écran. Je ne vois pas le bouton d'optimisation.

Dossiers :
desktop.zip  129 kb
 
Pourquoi mon MT4 b1010 ne permet-il pas le débogage sur les données historiques (le bouton et l'élément de menu ne sont pas actifs) ? Dans MT5 tout est ok.
 
Parce que les développeurs l'ont interdit.
 
int Magik ;
int Slippage = 5,stopL1 = 50,takeP1 = 20 ;
int trend, TicketS, TicketB ;
double rsi,TP,SL ;
//+------------------------------------------------------------------+
//| Fonction d'initialisation de l'expert |
//+------------------------------------------------------------------+
int OnInit()
{
if(Chiffres == 3 || Chiffres == 5)
{
Dérapage *= 10 ;
stopL1 *= 10 ;
{ takeP1 *= 10 ;
}

return(INIT_SUCCEEDED) ;
}
//+------------------------------------------------------------------+
//| Fonction de désinitialisation experte |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{

}
//+------------------------------------------------------------------+
//| fonction tick expert |
//+------------------------------------------------------------------+
void OnTick()
{
double priseBuy = FindLastOrderPrise (OP_BUY) ;
double priseSel = FindLastOrderPrise (OP_SELL) ;
double frezeelevl = MarketInfo(OrderSymbol(),MODE_FREEZELEVEL) ;
rsi = iRSI(Symbole(),PERIOD_D1,7,PRICE_CLOSE,0) ;
trend = WhatTrend() ;
si (CountTrades() == 0)
{
si(trend == 1 && rsi <=30)
{
si(OrderSend(Symbol(),OP_BUYLIMIT,0.10,Ask,Slippage,0,0, "first buy order set",Magik,0)== true)
{
TicketB = FindLastTicket(OP_BUY) ;
si(TicketB >0)
{
SL = priseBuy + NormalizeDouble(takeP1 * Point,Digits) ;
TP = priseBuy - NormalizeDouble(stopL1 * Point,Digits) ;
si(OrderModify(TicketB,priseBuy,SL,TP,0)== true)
Commentaire("hooraaaahhhhh") ;
}

}
}// if(trend == 1 && rsi <= 30)
sinon si(trend == 2 && rsi >= 70)
{
if(OrderSend(Symbol(),OP_SELLLIMIT,0.10,Bid,Slippage,0,0, "first order set",Magik,0)== true)
{
for(int i = OrdersTotal()-1;i >0;i--)
{
OrderSelect(i,SELECT_BY_TICKET,MODE_TRADES) ;
si (OrderType()== OP_SELL && OrderMagicNumber() == Magik)
{
double sl = OrderOpenPrice() + NormalizeDouble(stopL1 * Point,Digits) ;
double tp = OrderOpenPrice() - NormalizeDouble(takeP1 * Point,Digits) ;
si(OrderModify(OrderTicket(),OrderOpenPrice(),sl,tp,0)==true)break ;
sinon continuer ;
}
}
}
}
}// (CountTrades() == 0)

}

Je demande à des programmeurs compétents de m'expliquer quelle est mon erreur... Pourquoi l'ordre n'est pas modifié... et le compilateur ne donne pas d'erreur en le faisant...

 
J'ai étudié le tutoriel.j'ai lu et pris des notes...pourriez-vous indiquer les erreurs spécifiquement...car le compilateur ne donne aucune erreur et il n'y a pas d'erreurs dans le testeur.mais l'ordre n'est pas modifié.comme si l'ordre n'était pas du tout visible dans le programme
 
burbur87:
J'ai étudié le tutoriel, j'ai lu et pris des notes. Pourriez-vous indiquer les erreurs spécifiquement... parce que le compilateur ne donne pas d'erreurs et il n'y a pas d'erreurs dans le testeur. Mais l'ordre n'est pas modifié. C'est comme si l'ordre n'est pas du tout vu dans le programme.

Lisez attentivement ce que retourne OrderSend()

 if(OrderSend (Symbol(),OP_SELLLIMIT,0.10,Bid,Slippage,0,0,"первый ордер сел установлен",Magik,0) > 0)

En fait, je ferais la chose suivante :

   int ticket=OrderSend (Symbol(),OP_SELLLIMIT,0.10,Bid,Slippage,0,0,"первый ордер сел установлен",Magik,0);
   if(ticket>=0)
      {
        if(OrderSelect(ticket,SELECT_BY_TICKET,MODE_TRADES))
          {
            if (OrderStopLoss()==0 || OrderTakeProfit()==0)
             {
               double sl = OrderOpenPrice() + NormalizeDouble(stopL1 * Point,Digits);
               double tp = OrderOpenPrice() - NormalizeDouble(takeP1 * Point,Digits);
               if(!OrderModify(OrderTicket(),OrderOpenPrice(),sl,tp,0)) Print("Error ",GetLastError()," modify order ",ticket);
             }
          }
      }
 
Sepulca:

Lisez attentivement ce que retourne OrderSend()

if(ticket>=0)

En fait, je le ferais comme ça :

Un ticket peut-il être nul ?
1...109310941095109610971098109911001101110211031104110511061107...1178
Nouveau commentaire