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

Nouveau commentaire
 
A13ksandr:Désolé. Bien sûr, tout se passe dans void OnTick(). Je l'ai écrit)
Il y a alors un code d'erreur dans le journal du testeur, vous pouvez l'utiliser pour trouver la solution.
 
evillive:
Il y a alors un code d'erreur dans le journal du testeur et il peut être utilisé pour une enquête plus approfondie.

Aucune erreur. Il se bloque juste à l'entrée de la procédure. Et il y a aussi StartSell, il y entre normalement. C'est une sorte de désordre.

J'ai mis à jour les citations et ça marche. Il n'est pas correct à cause de certains trous, mais au moins il ne pend pas.

 

Bonjour, pourriez-vous m'indiquer le meilleur moyen d'empêcher l'ouverture simultanée de plus d'un nombre défini de séries pour différents instruments (le robot est attaché à plusieurs graphiques de différents instruments en même temps) dans les options binaires ?

extern double Lots = 1 ; // Lots

extern int Exp = 1 ; // Expiration

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

extern int Timeout = 1 ; // Créneau horaire

extern double Multiplier = 3 ; // Multiplicateur

extern int int Slippage = 5 ; // Slippage

extern int MaxOpenOrders = 1 ; // Nombre maximum d'ordres ouverts simultanément

extern int Magic = 774274 ; // 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 (CountTrades() == 0) // Le nombre d'ordres 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() && MaxOpenOrders > OrdersTotal())

{

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

}

if (SignalSell() && MaxOpenOrders > OrdersTotal())

{

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

}

}

}

}

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

int CountTrades(int type = -1)

{

int cnt = 0 ;

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

{

si (OrderSelect(i, SELECT_BY_POS, MODE_TRADES))

{

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

cnt++ ;

}

}

retour(cnt) ;

}

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

int CountHistTrades(int type = -1)

{

int cnt = 0 ;

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

{

si (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))

{

if (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))

{

if (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))

{

if (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))

{

if (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))

{

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

{

si (OrderCloseTime() > time)

{

time = OrderCloseTime() ;

prix = OrderOpenPrice() ;

}

}

}

}

}

}

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

 
alvlaf:

Il suffit de supprimer la condition OrderSymbol() == Symbol() de la fonction CountTrades et d'ajouter OrderType() == OP_BUY || OrderType() == OP_SELL, non ?

Et changer la condition if (SignalBuy() && CountTrades() < MaxOpenOrders) dans OnTick avant OrderSend... Il en va de même pour Sell.
 
A13ksandr:
Merci, j'ai essayé - le robot a commencé à ouvrir un tas d'ordres à chaque tick.
 
A13ksandr:

si (OrderMagicNumber() == Magic && (OrderType() == OP_BUY || OrderType() == OP_SELL))

L'ai-je modifié correctement ?

 
alvlaf:

Bonjour, pourriez-vous m'indiquer le meilleur moyen d'empêcher l'ouverture simultanée de plus d'un nombre défini de séries pour différents instruments (le robot est attaché à plusieurs graphiques de différents instruments en même temps) dans les options binaires ?

extern double Lots = 1 ; // Lots

extern int Exp = 1 ; // Expiration

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

extern int Timeout = 1 ; // Créneau horaire

extern double Multiplier = 3 ; // Multiplier

extern int int Slippage = 5 ; // Slippage

extern int MaxOpenOrders = 1 ; // Nombre maximum d'ordres ouverts simultanément

extern int Magic = 774274 ; // 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 (CountTrades() == 0) // Le nombre d'ordres 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() && MaxOpenOrders > OrdersTotal())

{

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

}

if (SignalSell() && MaxOpenOrders > OrdersTotal())

{

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

}

}

}

}

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

int CountTrades(int type = -1)

{

int cnt = 0 ;

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

{

si (OrderSelect(i, SELECT_BY_POS, MODE_TRADES))

{

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

cnt++ ;

}

}

retour(cnt) ;

}

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

int CountHistTrades(int type = -1)

{

int cnt = 0 ;

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

{

si (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))

{

if (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))

{

if (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))

{

if (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))

{

if (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))

{

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

{

si (OrderCloseTime() > time)

{

time = OrderCloseTime() ;

prix = OrderOpenPrice() ;

}

}

}

}

}

}

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

Dites-moi dans quel but vous utilisez MagicNumber, qu'apporte-t-il dans cette stratégie? IMHO, vous pouvez également jeter la fonction OnInit OnDeinit ici
 
evillive:


L'heure peut être définie directement au format date, sans qu'il soit nécessaire de gaspiller du temps machine pour la conversion, cela fonctionne comme suit :

extern datetime StartTime = D'07:00';

Dans ce format de temps, lorsque nous lançons l'EA, nous obtenons la date de compilation, alors que nous voulons que la date de compilation soit aujourd'hui.

Comment le corriger ?

 
RichLux:

Ce format horaire donne la date de compilation de l'EA au démarrage de l'EA, mais j'aimerais avoir la date du jour.

Comment le réparer ?

Vous changez le paramètre en celui souhaité au démarrage, de la même manière que les autres paramètres utilisateur.

Et pour une raison quelconque, il m'indique la date actuelle au moment de l'exécution du script.

 
LRA:
Dites-moi, s'il vous plaît, quel est le but de l'utilisation du MagicNumber, qu'est-ce qu'il apporte dans cette stratégie? IMHO, vous pouvez également jeter les fonctions OnInit OnDeinit ici
Quel est le but des mots "dans cette stratégie" ? La magie est nécessaire si vous effectuez des transactions manuellement sur le compte ou si vous exécutez un autre Expert Advisor afin que ces ordres ne soient pas touchés. Je pense que oui.
1...108610871088108910901091109210931094109510961097109810991100...1178
Nouveau commentaire
Raison: