Qualsiasi domanda da principiante, per non ingombrare il forum. Professionisti, non passate oltre. Da nessuna parte senza di te - 6. - pagina 1096
Ti stai perdendo delle opportunità di trading:
- App di trading gratuite
- Oltre 8.000 segnali per il copy trading
- Notizie economiche per esplorare i mercati finanziari
Registrazione
Accedi
Accetti la politica del sito e le condizioni d’uso
Se non hai un account, registrati
Ciao!
Come si può determinare se una posizione è chiusa su TP? Non credo che OrderClosePrice()==OrderTakeProfit() sia corretto da usare.
Nel commento all'ordine cerca [tp] se c'è...
Nel commento dell'ordine cerca [tp] se c'è...
Ciao Profi.
aiutare a risolvere l'errore nell'indicatore.....
l'indicatore funziona.
Il segnale si attiva sulla barra 0.
Ma quando altri tick sono ricevuti sulla barra corrente, si innesca di nuovo e dà nuovi segnali.
Ho bisogno che metta questo segnale in un cerchio al posto del prezzo dell'evento corrente quando si verifica l'evento Sell o Buy, e nessun altro evento è stato elaborato su questa barra aperta.
Voglio evitare nuovi segnali e cerchi su questa barra.
________________________
Capisco che direte che è una sciocchezza, che sono falsi segnali, ecc. ma questo è esattamente ciò di cui ho bisogno.
So che dovrei creare una bandiera, un marcatore, ecc. - ma non ho tempo per studiare la lingua da solo.
_________________________
Vi sarei molto grato se poteste aggiungere una tale bandiera al file allegato e contrassegnare le linee aggiunte con il colore.....
Grazie, e spero che qualcuno risponda
Commette un paio di errori, non riesce a fare le cose per bene. Cosa c'è di sbagliato qui?
//+------------------------------------------------------------------+Per favore aiutatemi a fare trading sulle notizie. Ho bisogno di un EA che abbia due funzioni principali.
La prima funzione: piazzareordini pendenti con un dato TP e SL, in un dato momento a un dato livello di prezzo.
La seconda funzione: mantenere gli ordini pendenti paralleli al prezzo. Significa spostarli insieme al prezzo (è troppo fastidioso farlo manualmente). In un dato momento, al momento della pubblicazione della notizia, dobbiamo fermare questa azione e aspettare che il prezzo tocchi uno degli ordini. Il secondo ordine viene subito dopo cancellato.
Ancora una volta:
2 minuti prima del rilascio della notizia, metti due ordini di stop opposti ad una distanza di 10 punti dal prezzo, attiva immediatamente la funzione di movimento parallelo al prezzo, 2 minuti si muovono insieme al prezzo, un ordine scappa dal prezzo, il secondo recupera il prezzo. Al rilascio della notizia, si dovrebbe disabilitare la funzione di movimento degli ordini pendenti e poi aspettare la rottura di uno degli ordini. Il secondo ordine viene cancellato immediatamente dopo la rottura del primo.
Variabili che vengono cambiate nelle proprietà di un EA (approssimativamente come immagino, non so quale sia la realizzazione nella realtà)
TP - 600 (per impostazione predefinita)
Trall - 300 (predefinito)
SL - 100 (predefinito)
Pips - 100 (distanza dal prezzo per impostazione predefinita)
Slippage - 100 (slippage in pip di default)
Lotto - 0,1
Rischio - 10 //percentuale (beh, questo non è necessario, lo chiederò più tardi se necessario)
TimeNews1On - true (usa le celle sottostanti per inserire il tempo, false - l'advisor non le scambia)
TimeNewsHour - ora (tempo di rilascio delle notizie 1)
TimeNewsMin - minuti (tempo di rilascio della notizia 1)
TimeNews2On - false (di default)
TimeNewsHour - ore (tempo di rilascio delle notizie 2)
TimeNewsMin - minuti (tempo di rilascio della notizia 2)
TimeNews3On - falso
TimeNewsHour - ore (tempo di rilascio delle notizie 3)
TimeNewsMin - minuti (tempo di rilascio delle notizie 3)
TimeNews4On - falso
TimeNewsHour - ore (tempo di rilascio delle notizie 4)
TimeNewsMin - minuti (tempo di rilascio delle notizie 4)
TimeNews5On - falso
TimeNewsHour - ore (tempo di rilascio delle notizie 5)
TimeNewsMin - minuti (tempo di rilascio delle notizie 5)
Insta, cinque cifre.
Sto facendo tutto questo manualmente, è troppo faticoso, e ora non ho tempo per elaborare le notizie, voglio mettere l'Expert Advisor al mattino o alla sera su coppie dove ci saranno notizie in quel giorno, in modo che funzionino tutte.
--------------------------------------
Se conoscete un tale esperto, per favore condividetelo.
Grazie in anticipo!
Torniamo al vostro codice sorgente. Prova così:
int OnInit()
{
if (!GlobalVariableCheck("AllowNewOrders")) GlobalVariableSet("AllowNewOrders",1);
return(INIT_SUCCEED);
}
void OnDeInit()
{
GlobalVariableSet("AllowNewOrders",1);
}
void OnTick()
{
if (CountTrades() == 0) // Il numero di ordini deve essere zero
{
se ((TypeLastHistOrder() == OP_BUY && PriceCloseLastHistOrder(OP_BUY) < PriceOpenLastHistOrder(OP_BUY))
|| (TypeLastHistOrder() == OP_SELL && PriceCloseLastHistOrder(OP_SELL) > PriceOpenLastHistOrder(OP_SELL))
// Se l'ultimo trade è perdente, si apre lo stesso, ma con un lotto più grande
{
GlobalVariableSet("AllowNewOrders", 0);
Type = TypeLastHistOrder();
if (Type == OP_BUY) Price = Ask;
if (Type == OP_SELL) Price = Bid;
Lot = NormalizeDouble(LotsLastHistOrder()*Multiplier, 2);
ticket = OrderSend(Symbol(), Type, Lot, Price, Slippage, 0, 0, IntegerToString(Exp), Magic);
}
se (PriceCloseLastHistOrder() == PriceOpenLastHistOrder() && CountHistTrades() > 0)
// se il profitto dell'ultimo trade è uguale a zero, lo stesso trade sarà aperto
{
GlobalVariableSet("AllowNewOrders", 0);
Type = TypeLastHistOrder();
if (Type == OP_BUY) Price = Ask;
if (Type == OP_SELL) Price = Bid;
Lot = NormalizeDouble(LotsLastHistOrder(), 2);
ticket = OrderSend(Symbol(), Type, Lot, Price, Slippage, 0, 0, IntegerToString(Exp), Magic);
}
se (((TypeLastHistOrder() == OP_BUY && PriceCloseLastHistOrder(OP_BUY) > PriceOpenLastHistOrder(OP_BUY))
|| (TypeLastHistOrder() == OP_SELL && PriceCloseLastHistOrder(OP_SELL) < PriceOpenLastHistOrder(OP_SELL))
|| CountHistTrades() == 0)// Se l'ultimo trade è redditizio, l'ordine viene aperto
{
se (GlobalVariableGet("AllowNewOrders") > 0)ritorna;
se (SignalBuy() && MaxOpenOrders > OrdersTotal())
{
ticket = OrderSend(Symbol(), OP_BUY, Lots, Ask, Slippage, 0, 0, IntegerToString(Exp), Magic);
if (ticket>0) GlobalVariableSet("AllowNewOrders", 0);
}
se (SignalSell() && MaxOpenOrders > OrdersTotal())
{
ticket = OrderSend(Symbol(), OP_SELL, Lots, Bid, Slippage, 0, 0, IntegerToString(Exp), Magic);
if (ticket>0) GlobalVariableSet("AllowNewOrders", 0);
}
}
}
}
Non l'ho controllato, perché non capisco come più copie di un EA con un limite totale di 1 ordine determineranno su quale simbolo (dopo una serie redditizia) è meglio iniziare il trading?
Per favore, aiutate a fare trading sulle notizie. Ho davvero bisogno di un EA che dovrebbe avere due funzioni principali.
Prima funzione: immissione diordini pendenti con un dato TP e SL, in un dato momento ad un dato livello dal prezzo.
La seconda funzione: mantenere gli ordini pendenti paralleli al prezzo. Significa spostarli insieme al prezzo (è così fastidioso farlo manualmente). In un dato momento, al momento della pubblicazione della notizia, dobbiamo fermare questa azione e aspettare che il prezzo tocchi uno degli ordini. Il secondo ordine viene subito dopo cancellato.
Ancora una volta:
2 minuti prima del rilascio della notizia, metti due ordini di stop opposti ad una distanza di 10 punti dal prezzo, attiva immediatamente la funzione di movimento parallelo al prezzo, 2 minuti si muovono insieme al prezzo, un ordine si allontana dal prezzo, il secondo recupera il prezzo. Al rilascio della notizia, si dovrebbe disabilitare la funzione di movimento degli ordini pendenti e poi aspettare la rottura di uno degli ordini. Il secondo sarà cancellato immediatamente dopo la rottura del primo.
Se conosci o hai incontrato tali consulenti, per favore condividi
Grazie in anticipo!
Posso mandarti il codice per leggere le notizie da un file, potrebbe tornarti utile. Una volta alla settimana, si guarda il calendario economico e si inseriscono i dati nel file folder_with_terminal\MQL4\Files\novosti.txt delle notizie a cui si dovrebbe prestare attenzione, il consulente può essere attivato anche poco prima delle notizie (è possibile utilizzare questo consulente per monitorare l'inizio, ad esempio, della sessione americana - nel caso in cui ci sia un forte movimento). Non ho finito il codice di trading perché sono stato seriamente "fregato" un paio di volte dalle notizie :)) L'ultima versione ha piazzato sei ordini (3 buy stop + 3 sell stop) a distanze diverse con diversi Take Profit. Comunque, il mio codice di notizie funziona, ma devo migliorare il mio codice di trading.
#proprietà rigorosa
input string NewsFilename = "novosti.txt"; // Nome del file di testo contenente le notizie
input int MinutesBefore = 5; // Quanti minuti prima della pubblicazione della notizia dovrebbero essere piazzati gli ordini
input int MinutesAfter1 = 15; // quanti minuti dopo il rilascio della notizia rimuovere gli ordini del 1° gruppo
input int MinutesAfter2 = 30; // quanti minuti dopo il rilascio della notizia rimuovere gli ordini del gruppo 2
input int MinutesAfter3 = 30; // quanti minuti dopo il rilascio della notizia rimuovere gli ordini del gruppo 3
input int PriceIndent1 = 15; // rientro dal prezzo in punti
input int PriceIndent2 = 5; // Passo indietro dal precedente TakeProfit in punti
input int TakeProfit1 = 40; // Dimensione del TakeProfit per il 1° gruppo in punti
input int TakeProfit2 = 60; // Dimensione del TakeProfit per il 2° gruppo in punti
input int TakeProfit3 = 100; // dimensione del TakeProfit per il 3° gruppo in punti
input int StopLoss = 20; // dimensione dello StopLoss per tutti gli ordini in punti
input double Multiplier1 = 1.0; // Coefficiente al lotto d'ordine del 2° gruppo
input double Multiplier2 = 2.0; // coefficiente ai lotti d'ordine del 3° gruppo
input int MaximalRisk = 10; // rischio massimo in percentuale
//====================================================================================================
datetime Times[200]; // LastTime;
stringa Symbols[200];
bool NewsPassed[200];
int NewsCount;
//====================================================================================================
int OnInit()
{
// Caricamento notizie fresche
se (!LoadNews()) ritorna(INIT_FAILED);
return(INIT_SUCCEED);
}
//====================================================================================================
void OnTick()
{
if (!IsTradeAllowed()) return;
datetime TestTime = iTime(Symbol(), PERIOD_H1, 0);
// Aggiornamento delle notizie all'inizio di ogni giorno
se (TimeDay(TestTime) != TimeDay(LastTime))
{
LastTime = TestTime;
se (!LoadNews())
{
Alert("Errore di aggiornamento delle notizie!");
ritorno;
}
}
//-------------------------------------------------------------------------------------------------
per (int i = 0; i < NewsCount; i++)
{
// Till news release mettere ordini per la svolta
if (Times[i] > TimeCurrent() && Times[i] - TimeCurrent() <= MinutesBefore * 60 && !NewsPassed[i])
{
PrintFormat("L'ora corrente è %s, è ora di impostare gli ordini di valuta - %s", TimeToStr(TimeCurrent(), TIME_DATE|TIME_MINUTES), Symbols[i]);
SetupOrders(Symbols[i];
NewsPassed[i] = true;
}
}
//-------------------------------------------------------------------------------------------------
}
//====================================================================================================
bool LoadNews()
{
int Count, Tick = 0;
stringa Str, Data[40];
ResetLastError();
se (!FileIsExist(NewsFilename, 0))
{
PrintFormat("Il file di notizie %s non esiste", NewsFilename);
Print("Il file deve essere nella cartella \MQL4\Files, in caso di test - nella cartella \Tester\Files.");
return(false);
}
int Handle = FileOpen(NewsFilename, FILE_READ|FILE_SHARE_READ|FILE_TXT);
se (Handle != INVALID_HANDLE)
{
mentre (!FileIsEnding(Handle))
{
Str = FileReadString(Handle);
Count = StringSplit(Str, StringGetChar(" ", 0), Data);
per (int i = 1; i < Conte; i = i + 2)
{
Times[Tick] = StringToTime(Data[0] + " + Data[i]);
Simboli[Tick] = Dati[i + 1];
Tick++;
}
}
FileClose(Handle);
NewsCount = Tick;
per (int i = 0; i < NewsCount; i++)
{
se (Tempi[i] > TempoCorrente()) NewsPassed[i] = false;
altrimenti NewsPassed[i] = false;
}
PrintFormat("Numero di notizie caricate - %i.", NewsCount);
return(true);
}
PrintFormat("Impossibile aprire il file %s. Codice di errore %d.", NewsFilename, GetLastError());
return(false);
}
//====================================================================================================
void SetupOrders(string Sym)
{
int Ticket, Dig, Count;
doppio Prezzo, TP, SL, Lotto;
datetime KeepAlive = TimeCurrent() + (MinutesBefore + MinutesAfter1) * 60;
stringa SymList[7];
//-------------------------------------------------------------------------------------------------
se (Sym == "AUD")
{
SymList[0] = "AUDCAD"; SymList[1] = "AUDCHF"; SymList[2] = "AUDJPY"; SymList[3] = "AUDNZD";
SymList[4] = "AUDUSD"; SymList[5] = "EURAUD"; SymList[6] = "GBPAUD";
}
//-------------------------------------------------------------------------------------------------
se (Sym == "CAD")
{
SymList[0] = "AUDCAD"; SymList[1] = "CADCHF"; SymList[2] = "CADJPY"; SymList[3] = "EURCAD";
SymList[4] = "GBPCAD"; SymList[5] = "NZDCAD"; SymList[6] = "USDCAD";
}
//-------------------------------------------------------------------------------------------------
se (Sym == "CHF")
{
SymList[0] = "AUDCHF"; SymList[1] = "CADCHF"; SymList[2] = "EURCHF"; SymList[3] = "GBPCHF";
SymList[4] = "CHFJPY"; SymList[5] = "NZDCHF"; SymList[6] = "USDCHF";
}
//-------------------------------------------------------------------------------------------------
se (Sym == "EUR")
{
SymList[0] = "EURAUD"; SymList[1] = "EURCAD"; SymList[2] = "EURCHF"; SymList[3] = "EURGBP";
SymList[4] = "EURJPY"; SymList[5] = "EURNZD"; SymList[6] = "EURUSD";
}
//-------------------------------------------------------------------------------------------------
se (Sym == "GBP")
{
SymList[0] = "EURGBP"; SymList[1] = "GBPAUD"; SymList[2] = "GBPCAD"; SymList[3] = "GBPCHF";
SymList[4] = "GBPJPY"; SymList[5] = "GBPNZD"; SymList[6] = "GBPUSD";
}
//-------------------------------------------------------------------------------------------------
se (Sym == "JPY")
{
SymList[0] = "AUDJPY"; SymList[1] = "CADJPY"; SymList[2] = "CHFJPY"; SymList[3] = "EURJPY";
SymList[4] = "GBPJPY"; SymList[5] = "NZDJPY"; SymList[6] = "USDJPY";
}
//-------------------------------------------------------------------------------------------------
se (Sym == "NZD")
{
SymList[0] = "AUDNZD"; SymList[1] = "EURNZD"; SymList[2] = "GBPNZD"; SymList[3] = "NZDCAD";
SymList[4] = "NZDCHF"; SymList[5] = "NZDJPY"; SymList[6] = "NZDUSD";
}
//-------------------------------------------------------------------------------------------------
se (Sym == "USD")
{
SymList[0] = "AUSUSD"; SymList[1] = "EURUSD"; SymList[2] = "GBPUSD"; SymList[3] = "NZDUSD";
SymList[4] = "USDCAD"; SymList[5] = "USDCHF"; SymList[6] = "USDJPY";
}
//-------------------------------------------------------------------------------------------------
per (int i = 0; i < 7; i++)
{
Conta = 0;
Dig = int(MarketInfo(SymList[i], MODE_DIGITS));
Lotto = NormalizeDouble(0.01, 2);
//Acquista
KeepAlive = TimeCurrent() + (MinutesBefore + MinutesAfter1) * 60;
Prezzo = 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);
if (Ticket > 0) Count++; else PrintFormat("Error creating the order %i, symbol %s, price %f, Take %f, Stop %f, Lot %f.", GetLastError(), SymList[i], Price, TP, SL, Lot);
KeepAlive = TimeCurrent() + (MinutesBefore + MinutesAfter2) * 60;
Prezzo = 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);
if (Ticket > 0) Count++; else PrintFormat("Error creating the order %i, symbol %s, price %f, Take %f, Stop %f, Lot %f.", GetLastError(), SymList[i], Price, TP, SL, Lot*Multiplier1);
KeepAlive = TimeCurrent() + (MinutesBefore + MinutesAfter3) * 60;
Prezzo = 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);
if (Ticket > 0) Count++; else PrintFormat("Error creating the order %i, symbol %s, price %f, take %f, stop %f, lot %f.", GetLastError(), SymList[i], Price, TP, SL, Lot*Multiplier2);
// Vendere
KeepAlive = TimeCurrent() + (MinutesBefore + MinutesAfter1) * 60;
Prezzo = 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);
if (Ticket > 0) Count++; else PrintFormat("Error creating the order %i, symbol %s, price %f, Take %f, Stop %f, Lot %f.", GetLastError(), SymList[i], Price, TP, SL, Lot);
KeepAlive = TimeCurrent() + (MinutesBefore + MinutesAfter2) * 60;
Prezzo = 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);
if (Ticket > 0) Count++; else PrintFormat("Error creating the order %i, symbol %s, price %f, Take %f, Stop %f, Lot %f.", GetLastError(), SymList[i], Price, TP, SL, Lot*Multiplier1);
KeepAlive = TimeCurrent() + (MinutesBefore + MinutesAfter3) * 60;
Prezzo = 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("Ci sono %i ordini piazzati dal simbolo %s", SymList[i], Count);0 }
}
Il file delle notizie si presenta così:
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
e così via...
Torniamo al vostro codice sorgente. Prova così:
int OnInit()
{
if (!GlobalVariableCheck("AllowNewOrders")) GlobalVariableSet("AllowNewOrders",1);
return(INIT_SUCCEED);
}
void OnDeInit()
{
GlobalVariableSet("AllowNewOrders",1);
}
void OnTick()
{
if (CountTrades() == 0) // Il numero di ordini deve essere zero
{
se ((TypeLastHistOrder() == OP_BUY && PriceCloseLastHistOrder(OP_BUY) < PriceOpenLastHistOrder(OP_BUY))
|| (TypeLastHistOrder() == OP_SELL && PriceCloseLastHistOrder(OP_SELL) > PriceOpenLastHistOrder(OP_SELL))
// Se l'ultimo trade è perdente, si apre lo stesso, ma con un lotto più grande
{
GlobalVariableSet("AllowNewOrders", 0);
Type = TypeLastHistOrder();
if (Type == OP_BUY) Price = Ask;
if (Type == OP_SELL) Price = Bid;
Lot = NormalizeDouble(LotsLastHistOrder()*Multiplier, 2);
ticket = OrderSend(Symbol(), Type, Lot, Price, Slippage, 0, 0, IntegerToString(Exp), Magic);
}
se (PriceCloseLastHistOrder() == PriceOpenLastHistOrder() && CountHistTrades() > 0)
// se il profitto dell'ultimo trade è uguale a zero, lo stesso trade sarà aperto
{
GlobalVariableSet("AllowNewOrders", 0);
Type = TypeLastHistOrder();
if (Type == OP_BUY) Price = Ask;
if (Type == OP_SELL) Price = Bid;
Lot = NormalizeDouble(LotsLastHistOrder(), 2);
ticket = OrderSend(Symbol(), Type, Lot, Price, Slippage, 0, 0, IntegerToString(Exp), Magic);
}
se (((TypeLastHistOrder() == OP_BUY && PriceCloseLastHistOrder(OP_BUY) > PriceOpenLastHistOrder(OP_BUY))
|| (TypeLastHistOrder() == OP_SELL && PriceCloseLastHistOrder(OP_SELL) < PriceOpenLastHistOrder(OP_SELL))
|| CountHistTrades() == 0)// Se l'ultimo trade è redditizio, l'ordine viene aperto
{
se (GlobalVariableGet("AllowNewOrders") > 0)ritorna;
se (SignalBuy() && MaxOpenOrders > OrdersTotal())
{
ticket = OrderSend(Symbol(), OP_BUY, Lots, Ask, Slippage, 0, 0, IntegerToString(Exp), Magic);
if (ticket>0) GlobalVariableSet("AllowNewOrders", 0);
}
se (SignalSell() && MaxOpenOrders > OrdersTotal())
{
ticket = OrderSend(Symbol(), OP_SELL, Lots, Bid, Slippage, 0, 0, IntegerToString(Exp), Magic);
if (ticket>0) GlobalVariableSet("AllowNewOrders", 0);
}
}
}
}
Non l'ho controllato, perché non capisco come diverse copie di un EA con un limite totale di 1 ordine rileveranno a quale simbolo (dopo una serie redditizia) è meglio iniziare il trading?
Alexander, il bot deve aspettare il numero specificato di candele in ogni simbolo in una direzione e poi iniziare una serie, cioè, a quale simbolo questa condizione è innescata prima per quel simbolo e aprire il primo commercio. Allo stesso tempo, si dovrebbe proibire l'apertura di una serie per altri simboli fino a quando la prima serie finisce con profitto.
L'ultimo codice che avete dato è un passo avanti - non apre nessun accordo (cioè, il divieto è attivo). Non ho capito perché nessuno. In allegato c'è uno screenshot del log.
Forse è il momento di imparare a inserire il codice!