Toute question de débutant, afin de ne pas encombrer le forum. Professionnels, ne passez pas à côté. Nulle part sans toi - 6. - page 1096
Vous manquez des opportunités de trading :
- Applications de trading gratuites
- Plus de 8 000 signaux à copier
- Actualités économiques pour explorer les marchés financiers
Inscription
Se connecter
Vous acceptez la politique du site Web et les conditions d'utilisation
Si vous n'avez pas de compte, veuillez vous inscrire
Bonjour !
Comment pouvez-vous déterminer si une position est fermée sur TP ? Je ne pense pas que l'utilisation de OrderClosePrice()==OrderTakeProfit() soit correcte.
Dans le commentaire de l'ordre, cherchez [tp] s'il y a...
Dans le commentaire de l'ordre, cherchez [tp] s'il y en a un...
Bonjour Profi.
aidez à réparer l'erreur dans l'indicateur.....
fonctionne.
Le signal est déclenché sur la barre 0.
Mais lorsque d'autres ticks sont reçus sur la barre actuelle, il se déclenche à nouveau et donne de nouveaux signaux.
J'ai besoin qu'il place ce signal dans un cercle à la place du prix de l'événement actuel lorsque l'événement Vente ou Achat se produit, et qu'aucun autre événement n'a été traité sur cette barre ouverte.
Je veux éviter les nouveaux signaux et les cercles sur cette barre.
________________________
Je comprends que vous allez dire que c'est absurde, que ce sont des faux signaux, etc., mais c'est exactement ce dont j'ai besoin.
Je sais que je devrais créer un drapeau, un marqueur, etc. - mais je n'ai pas le temps d'étudier la langue moi-même.
_________________________
Je vous serais très reconnaissant si vous pouviez ajouter un tel drapeau au fichier joint et marquer les lignes ajoutées avec la couleur......
Merci, et j'espère que quelqu'un répondra
Il y a quelques erreurs, mais on ne peut pas les corriger. Qu'est-ce qui ne va pas ici ?
//+------------------------------------------------------------------+S'il vous plaît, aidez-moi à faire du commerce sur les nouvelles. J'ai besoin d'un EA qui a deux fonctions principales.
La première fonction : placer desordres en attente avec un TP et un SL donnés, à un moment donné et à un niveau de prix donné.
La deuxième fonction : maintenir les ordres en attente parallèlement au prix. Il s'agit de les déplacer en même temps que le prix (il est trop fastidieux de le faire manuellement). A un moment donné, au moment de la publication des nouvelles, nous devons arrêter cette action et attendre que le prix touche l'un des ordres. La deuxième commande est ensuite immédiatement supprimée.
Encore une fois :
2 minutes avant le communiqué de presse, placez deux ordres stop opposés à une distance de 10 points du prix, activez immédiatement la fonction de déplacement parallèle au prix, 2 minutes de déplacement avec le prix, un ordre s'éloigne du prix, le second rattrape le prix. Au moment du communiqué, vous devez désactiver la fonction de mouvement des ordres en attente, puis attendre la rupture de l'un des ordres. La deuxième commande est supprimée immédiatement après la rupture de la première.
Variables qui sont modifiées dans les propriétés d'un EA (approximativement comme je l'imagine, je ne sais pas quelle est la réalisation dans la réalité) :
TP - 600 (par défaut)
Trall - 300 (par défaut)
SL - 100 (par défaut)
Pips - 100 (distance du prix par défaut)
Slippage - 100 (slippage en pips par défaut)
Lot - 0,1
Risque - 10 //pourcentage (bon, ce n'est pas nécessaire, je le demanderai plus tard si nécessaire)
TimeNews1On - true (utilisez les cellules ci-dessous pour entrer le temps, false - le conseiller ne les négocie pas)
TimeNewsHour - heure (heure du communiqué de presse 1)
TimeNewsMin - minutes (durée du communiqué de presse 1)
TimeNews2On - false (par défaut)
TimeNewsHour - heures (heure du communiqué de presse 2)
TimeNewsMin - minutes (durée du communiqué de presse 2)
TimeNews3On - faux
TimeNewsHour - heures (heure du communiqué de presse 3)
TimeNewsMin - minutes (durée du communiqué de presse 3)
TimeNews4On - faux
TimeNewsHour - heures (heure du communiqué de presse 4)
TimeNewsMin - minutes (durée du communiqué de presse 4)
TimeNews5On - faux
TimeNewsHour - heures (heure du communiqué de presse 5)
TimeNewsMin - minutes (durée du communiqué de presse 5)
Insta, cinq chiffres.
Je fais tout cela manuellement, c'est trop de problèmes, et maintenant je n'ai pas le temps de travailler sur les nouvelles, je veux placer le conseiller expert le matin ou le soir sur les paires qui seront des nouvelles ce jour-là, de sorte qu'ils vont tous travailler.
--------------------------------------
Si vous connaissez un tel expert, merci de le partager.
Merci d'avance !
Revenons à votre code source. Essayez comme ça :
int OnInit()
{
if (!GlobalVariableCheck("AllowNewOrders")) GlobalVariableSet("AllowNewOrders",1) ;
return(INIT_SUCCEED) ;
}
void OnDeInit()
{
GlobalVariableSet("AllowNewOrders",1);
}
void OnTick()
{
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.
{
GlobalVariableSet("AllowNewOrders", 0) ;
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.
{
GlobalVariableSet("AllowNewOrders", 0) ;
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 (GlobalVariableGet("AllowNewOrders") > 0)retour ;
si (SignalBuy() && MaxOpenOrders > OrdersTotal())
{
ticket = OrderSend(Symbol(), OP_BUY, Lots, Ask, Slippage, 0, 0, IntegerToString(Exp), Magic) ;
if (ticket>0) GlobalVariableSet("AllowNewOrders", 0) ;
}
si (SignalSell() && MaxOpenOrders > OrdersTotal())
{
ticket = OrderSend(Symbol(), OP_SELL, Lots, Bid, Slippage, 0, 0, IntegerToString(Exp), Magic) ;
if (ticket>0) GlobalVariableSet("AllowNewOrders", 0) ;
}
}
}
}
Je ne l'ai pas vérifié, car je ne comprends pas comment plusieurs copies d'un EA avec une limite totale de 1 ordre vont déterminer sur quel symbole (après une série rentable) il est préférable de commencer à trader ?
Aidez-nous à faire du commerce sur la base de ces nouvelles. J'ai vraiment besoin d'un EA qui devrait avoir deux fonctions principales.
Première fonction : placer desordres en attente avec un TP et un SL donnés, à un moment donné et à un niveau donné du prix.
La deuxième fonction : maintenir les ordres en attente parallèlement au prix. Il s'agit de les déplacer en même temps que le prix (il est trop fastidieux de le faire manuellement). À un moment donné, au moment de la publication des nouvelles, nous devons arrêter cette action et attendre que le prix touche l'un des ordres. La deuxième commande est ensuite immédiatement supprimée.
Encore une fois :
2 minutes avant le communiqué de presse, placez deux ordres stop opposés à une distance de 10 points du prix, activez immédiatement la fonction de déplacement parallèle au prix, 2 minutes de déplacement avec le prix, un ordre s'éloigne du prix, le second rattrape le prix. Au moment du communiqué, vous devez désactiver la fonction de mouvement des ordres en attente, puis attendre la rupture de l'un des ordres. Le second sera supprimé immédiatement après la rupture du premier.
Si vous connaissez ou avez rencontré de tels conseillers, veuillez nous en faire part
Merci d'avance !
Je peux vous envoyer le code pour lire les nouvelles à partir d'un fichier, ça peut être utile. Une fois par semaine, vous regardez le calendrier économique et entrez les données dans le fichier folder_with_terminal\MQL4\Files\novosti.txt des nouvelles auxquelles vous devez prêter attention, le conseiller peut être activé même juste avant les nouvelles (vous pouvez utiliser ce conseiller pour suivre le début, par exemple, de la session américaine - au cas où il y a un fort mouvement). Je n'ai pas terminé le code de trading car j'ai été sérieusement "trompé" plusieurs fois par les nouvelles :)) La dernière version a placé six ordres (3 stops d'achat + 3 stops de vente) à différentes distances avec différents Take Profit. Quoi qu'il en soit, mon code de news fonctionne, mais je dois améliorer mon code de trading.
#propriété stricte
input string NewsFilename = "novosti.txt" ; // Nom du fichier texte contenant les nouvelles
input int MinutesBefore = 5 ; // Combien de minutes avant la publication des nouvelles les ordres doivent-ils être placés ?
input int MinutesAfter1 = 15 ; // combien de minutes après la publication de la nouvelle retirent les ordres du 1er groupe ?
input int MinutesAfter2 = 30 ; // combien de minutes après le communiqué de presse retirez-vous les ordres du groupe 2 ?
input int MinutesAfter3 = 30 ; // combien de minutes après la publication du communiqué de presse faut-il retirer les ordres du groupe 3 ?
input int PriceIndent1 = 15 ; // Indentation du prix en points
input int PriceIndent2 = 5 ; // Recul en points par rapport au TakeProfit précédent
input int TakeProfit1 = 40 ; // Taille du TakeProfit pour le 1er groupe en points
input int TakeProfit2 = 60 ; // Taille du TakeProfit pour le 2ème groupe en points
input int TakeProfit3 = 100 ; // Taille du TakeProfit pour le 3ème groupe en points
input int StopLoss = 20 ; // Taille du StopLoss pour tous les ordres en points
input double Multiplier1 = 1.0 ; // Coefficient au lot d'ordre du 2ème groupe
input double Multiplier2 = 2.0 ; // coefficient aux lots d'ordre du 3ème groupe
input int MaximalRisk = 10 ; // Risque maximum en pourcentages
//====================================================================================================
datetime Times[200] ; // LastTime ;
chaîne Symboles [200] ;
bool NewsPassed [200] ;
int NewsCount ;
//====================================================================================================
int OnInit()
{
// Chargement des nouvelles fraîches
if (!LoadNews()) return(INIT_FAILED) ;
return(INIT_SUCCEEDED) ;
}
//====================================================================================================
void OnTick()
{
if (!IsTradeAllowed()) return ;
datetime TestTime = iTime(Symbol(), PERIOD_H1, 0) ;
// Mise à jour des nouvelles au début de chaque journée
si (TimeDay(TestTime) != TimeDay(LastTime))
{
LastTime = TestTime ;
if (!LoadNews())
{
Alert("Erreur de mise à jour des informations !") ;
retour ;
}
}
//-------------------------------------------------------------------------------------------------
for (int i = 0 ; i < NewsCount ; i++)
{
// Le communiqué de presse de Till met en place des ordres de percée
if (Times[i] > TimeCurrent() && Times[i] - TimeCurrent() <= MinutesBefore * 60 && !NewsPassed[i])
{
PrintFormat("L'heure actuelle est %s, il est temps de régler les commandes de devises - %s", TimeToStr(TimeCurrent(), TIME_DATE|TIME_MINUTES), Symbols[i]) ;
SetupOrders(Symboles[i] ;
NewsPassed[i] = true ;
}
}
//-------------------------------------------------------------------------------------------------
}
//====================================================================================================
bool LoadNews()
{
int Count, Tick = 0 ;
string Str, Data[40] ;
ResetLastError() ;
si (!FileIsExist(NewsFilename, 0))
{
PrintFormat("Le fichier de nouvelles %s n'existe pas.", NewsFilename) ;
Print("Le fichier doit se trouver dans le dossier \\MQL4\\Files, en cas de test - dans le dossier \\Tester\Files.") ;
retour (faux) ;
}
int Handle = FileOpen(NewsFilename, FILE_READ|FILE_SHARE_READ|FILE_TXT) ;
si (Handle != INVALID_HANDLE)
{
while (!FileIsEnding(Handle))
{
Str = FileReadString(Handle) ;
Count = StringSplit(Str, StringGetChar(" ", 0), Data) ;
for (int i = 1 ; i < Count ; i = i + 2)
{
Times[Tick] = StringToTime(Data[0] + " + Data[i]) ;
Symboles[Tick] = Données[i + 1] ;
Tick++ ;
}
}
FileClose(Handle) ;
NewsCount = Tick ;
for (int i = 0 ; i < NewsCount ; i++)
{
si (Times[i] > TimeCurrent()) NewsPassed[i] = false ;
sinon NewsPassed[i] = false ;
}
PrintFormat("Nombre de nouvelles téléchargées - %i.", NewsCount) ;
retour (vrai) ;
}
PrintFormat("Impossible d'ouvrir le fichier %s. Code d'erreur %d.", NewsFilename, GetLastError()) ;
retour (faux) ;
}
//====================================================================================================
void SetupOrders(string Sym)
{
int Ticket, Dig, Count ;
double Price, TP, SL, Lot ;
datetime KeepAlive = TimeCurrent() + (MinutesBefore + MinutesAfter1) * 60 ;
chaîne de caractères SymList[7] ;
//-------------------------------------------------------------------------------------------------
si (Sym == "AUD")
{
SymList[0] = "AUDCAD" ; SymList[1] = "AUDCHF" ; SymList[2] = "AUDJPY" ; SymList[3] = "AUDNZD" ;
SymList[4] = "AUDUSD" ; SymList[5] = "EURAUD" ; SymList[6] = "GBPAUD" ;
}
//-------------------------------------------------------------------------------------------------
si (Sym == "CAD")
{
SymList[0] = "AUDCAD" ; SymList[1] = "CADCHF" ; SymList[2] = "CADJPY" ; SymList[3] = "EURCAD" ;
SymList[4] = "GBPCAD" ; SymList[5] = "NZDCAD" ; SymList[6] = "USDCAD" ;
}
//-------------------------------------------------------------------------------------------------
si (Sym == "CHF")
{
SymList[0] = "AUDCHF" ; SymList[1] = "CADCHF" ; SymList[2] = "EURCHF" ; SymList[3] = "GBPCHF" ;
SymList[4] = "CHFJPY" ; SymList[5] = "NZDCHF" ; SymList[6] = "USDCHF" ;
}
//-------------------------------------------------------------------------------------------------
si (Sym == "EUR")
{
SymList[0] = "EURAUD" ; SymList[1] = "EURCAD" ; SymList[2] = "EURCHF" ; SymList[3] = "EURGBP" ;
SymList[4] = "EURJPY" ; SymList[5] = "EURNZD" ; SymList[6] = "EURUSD" ;
}
//-------------------------------------------------------------------------------------------------
si (Sym == "GBP")
{
SymList[0] = "EURGBP" ; SymList[1] = "GBPAUD" ; SymList[2] = "GBPCAD" ; SymList[3] = "GBPCHF" ;
SymList[4] = "GBPJPY" ; SymList[5] = "GBPNZD" ; SymList[6] = "GBPUSD" ;
}
//-------------------------------------------------------------------------------------------------
si (Sym == "JPY")
{
SymList[0] = "AUDJPY" ; SymList[1] = "CADJPY" ; SymList[2] = "CHFJPY" ; SymList[3] = "EURJPY" ;
SymList[4] = "GBPJPY" ; SymList[5] = "NZDJPY" ; SymList[6] = "USDJPY" ;
}
//-------------------------------------------------------------------------------------------------
si (Sym == "NZD")
{
SymList[0] = "AUDNZD" ; SymList[1] = "EURNZD" ; SymList[2] = "GBPNZD" ; SymList[3] = "NZDCAD" ;
SymList[4] = "NZDCHF" ; SymList[5] = "NZDJPY" ; SymList[6] = "NZDUSD" ;
}
//-------------------------------------------------------------------------------------------------
si (Sym == "USD")
{
SymList[0] = "AUSUSD" ; SymList[1] = "EURUSD" ; SymList[2] = "GBPUSD" ; SymList[3] = "NZDUSD" ;
SymList[4] = "USDCAD" ; SymList[5] = "USDCHF" ; SymList[6] = "USDJPY" ;
}
//-------------------------------------------------------------------------------------------------
for (int i = 0 ; i < 7 ; i++)
{
Compte = 0 ;
Dig = int(MarketInfo(SymList[i], MODE_DIGITS)) ;
Lot = NormalizeDouble(0.01, 2) ;
/Achat
KeepAlive = TimeCurrent() + (MinutesBefore + MinutesAfter1) * 60 ;
Prix = NormalizeDouble(MarketInfo(SymList[i], MODE_ASK) + PriceIndent1 / pow(10, Dig-1), Dig) ;
TP = NormalizeDouble(Price + TakeProfit1 / pow(10, Dig-1), Dig) ;
SL = NormalizeDouble(Price - StopLoss / pow(10, Dig-1), Dig) ;
Ticket = OrderSend(SymList[i], OP_BUYSTOP, Lot, Price, 5, SL, TP, NULL, 0, KeepAlive, clrLimeGreen) ;
si (Ticket > 0) Count++ ; else PrintFormat("Erreur lors de la création de l'ordre %i, symbole %s, prix %f, Prise %f, Stop %f, Lot %f.", GetLastError(), SymList[i], Prix, TP, SL, Lot) ;
KeepAlive = TimeCurrent() + (MinutesBefore + MinutesAfter2) * 60 ;
Prix = NormalizeDouble(TP + PriceIndent2 / pow(10, Dig-1), Dig) ;
TP = NormalizeDouble(Price + TakeProfit2 / pow(10, Dig-1), Dig) ;
SL = NormalizeDouble(Price - StopLoss / pow(10, Dig-1), Dig) ;
Ticket = OrderSend(SymList[i], OP_BUYSTOP, Lot * Multiplier1, Price, 5, SL, TP, NULL, 0, KeepAlive, clrLimeGreen) ;
si (Ticket > 0) Count++ ; else PrintFormat("Erreur lors de la création de l'ordre %i, symbole %s, prix %f, Prise %f, Stop %f, Lot %f.", GetLastError(), SymList[i], Prix, TP, SL, Lot*Multiplicateur1) ;
KeepAlive = TimeCurrent() + (MinutesBefore + MinutesAfter3) * 60 ;
Prix = NormalizeDouble(TP + PriceIndent2 / pow(10, Dig-1), Dig) ;
TP = NormalizeDouble(Price + TakeProfit2 / pow(10, Dig-1), Dig) ;
SL = NormalizeDouble(Price - StopLoss / pow(10, Dig-1), Dig) ;
Ticket = OrderSend(SymList[i], OP_BUYSTOP, Lot*Multiplier2, Price, 5, SL, TP, NULL, 0, KeepAlive, clrLimeGreen) ;
si (Ticket > 0) Count++ ; else PrintFormat("Erreur lors de la création de l'ordre %i, symbole %s, prix %f, prise %f, stop %f, lot %f.", GetLastError(), SymList[i], Prix, TP, SL, Lot*Multiplicateur2) ;
// Vente
KeepAlive = TimeCurrent() + (MinutesBefore + MinutesAfter1) * 60 ;
Prix = NormalizeDouble(MarketInfo(SymList[i], MODE_BID) - PriceIndent1 / pow(10, Dig-1), Dig) ;
TP = NormalizeDouble(Price - TakeProfit1 / pow(10, Dig-1), Dig) ;
SL = NormalizeDouble(Price + StopLoss / pow(10, Dig-1), Dig) ;
Ticket = OrderSend(SymList[i], OP_SELLSTOP, Lot, Price, 5, SL, TP, NULL, 0, KeepAlive, clrOrangeRed) ;
si (Ticket > 0) Count++ ; else PrintFormat("Erreur lors de la création de l'ordre %i, symbole %s, prix %f, Prise %f, Stop %f, Lot %f.", GetLastError(), SymList[i], Prix, TP, SL, Lot) ;
KeepAlive = TimeCurrent() + (MinutesBefore + MinutesAfter2) * 60 ;
Prix = NormalizeDouble(TP - PriceIndent2 / pow(10, Dig-1), Dig) ;
TP = NormalizeDouble(Price - TakeProfit2 / pow(10, Dig-1), Dig) ;
SL = NormalizeDouble(Price + StopLoss / pow(10, Dig-1), Dig) ;
Ticket = OrderSend(SymList[i], OP_SELLSTOP, Lot, Price, 5, SL, TP, NULL, 0, KeepAlive, clrOrangeRed) ;
si (Ticket > 0) Count++ ; else PrintFormat("Erreur lors de la création de l'ordre %i, symbole %s, prix %f, Prise %f, Stop %f, Lot %f.", GetLastError(), SymList[i], Prix, TP, SL, Lot*Multiplicateur1) ;
KeepAlive = TimeCurrent() + (MinutesBefore + MinutesAfter3) * 60 ;
Prix = NormalizeDouble(TP - PriceIndent2 / pow(10, Dig-1), Dig) ;
TP = NormalizeDouble(Price - TakeProfit3 / pow(10, Dig-1), Dig) ;
SL = NormalizeDouble(Price + StopLoss / pow(10, Dig-1), Dig) ;
Ticket = OrderSend(SymList[i], OP_SELLSTOP, Lot, Price, 5, SL, TP, NULL, 0, KeepAlive, clrOrangeRed) ;
PrintFormat("Il y a %i ordres placés par le symbole %s", SymList[i], Count);0 }
}
Le fichier de nouvelles ressemble à ceci :
15.09.2016 01:45 NZD 04:30 AUD 10:30 CHF 14:00 GBP 15:30 USD
16.09.2016 15:30 USD 17:00 USD
et ainsi de suite...
Revenons à votre code source. Essayez comme ça :
int OnInit()
{
if (!GlobalVariableCheck("AllowNewOrders")) GlobalVariableSet("AllowNewOrders",1) ;
return(INIT_SUCCEED) ;
}
void OnDeInit()
{
GlobalVariableSet("AllowNewOrders",1);
}
void OnTick()
{
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.
{
GlobalVariableSet("AllowNewOrders", 0) ;
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.
{
GlobalVariableSet("AllowNewOrders", 0) ;
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 (GlobalVariableGet("AllowNewOrders") > 0)retour ;
si (SignalBuy() && MaxOpenOrders > OrdersTotal())
{
ticket = OrderSend(Symbol(), OP_BUY, Lots, Ask, Slippage, 0, 0, IntegerToString(Exp), Magic) ;
if (ticket>0) GlobalVariableSet("AllowNewOrders", 0) ;
}
if (SignalSell() && MaxOpenOrders > OrdersTotal())
{
ticket = OrderSend(Symbol(), OP_SELL, Lots, Bid, Slippage, 0, 0, IntegerToString(Exp), Magic) ;
if (ticket>0) GlobalVariableSet("AllowNewOrders", 0) ;
}
}
}
}
Je ne l'ai pas vérifié, car je ne comprends pas comment plusieurs copies d'un EA avec une limite totale de 1 ordre vont détecter à quel symbole (après une série profitable) il est préférable de commencer à trader ?
Alexander, le robot doit attendre le nombre spécifié de bougies dans chaque symbole dans une direction et ensuite commencer une série, c'est-à-dire, à quel symbole cette condition est déclenchée en premier pour ce symbole et ouvrir la première transaction. Dans le même temps, vous devez interdire l'ouverture d'une série pour d'autres symboles tant que la première série n'est pas terminée avec profit.
Le dernier code que vous avez donné est un pas en avant - il n'ouvre aucun marché (c'est-à-dire que l'interdiction est active). Je n'ai pas du tout compris pourquoi. Vous trouverez ci-joint une capture d'écran du journal.
Il est peut-être temps d'apprendre à insérer du code!