Caratteristiche utili da KimIV - pagina 83
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
Come fare in modo che l'EA apra non una posizione, ma 2 o 3 contemporaneamente in una direzione. Per esempio, come posso aprire due posizioni unidirezionali a 0,5 e 0,5 lotti invece di un lotto? O 0,3+0,3+0,3 lotti.
>> Come faccio a impostare il terminale in modo che quando lo passo al russo, dirà tutto in russo, perché la mia lingua è scritta in geroglifici.
Nelle impostazioni regionali di Windows, imposta la lingua in russo per l'uso in applicazioni che non usano Unicode.
Ciao, ho una domanda direttamente a Igor Kim perché è l'autore (se non sbaglio) dell'indicatore i-SignalOfTrade.
L'indicatore esegue tutte le sue funzioni perfettamente, ma le seguenti voci appaiono nel log quando si invia una mail
Posta: 'i-SignalOfTrade' fallito
Posta: 451 Vedi http://pobox.com/~djb/docs/smtplf.html.
e ovviamente il messaggio non va da nessuna parte.
Potete dirmi quale può essere il problema e come risolverlo?
P.S. Il client di posta è configurato correttamente, i messaggi di prova vengono inviati e consegnati senza problemi.
Buon pomeriggio. Può dirmi chi lo sa? Sto lavorando con l'indice RTS. La dimensione della posizione è calcolata da un programma terzo e trasmessa all'Expert Advisor tramite un file txt. Ho due problemi qui:
1. Poiché il blocco di avvio {...} viene attivato solo quando arriva un nuovo tick e i tick nell'indice sono rari, c'è un ritardo nell'esecuzione dell'EA.
L'ho messo su uno strumento con un ticchettio più frequente (EURUSD), ma ancora chiedo - è possibile avviare forzatamente {...}?
2. La dimensione massima della posizione consentita dal mio broker è di 20 lotti. Ho bisogno di aprire una posizione di 100 lotti. In questo momento sto aprendo una posizione alla volta,
ma ci vuole molto tempo, circa 4 secondi per ordine. (cioè ci vogliono 20 secondi per aprire una posizione), e a volte questo non va bene. C'è un modo per farlo più velocemente? (tramite ordini stop preimpostati - non funziona per me).
2. la dimensione massima della posizione consentita dal broker è di 20 lotti. Ho bisogno di aprire una posizione di 100 lotti. Ora sto aprendo in successione,
ma ci vuole molto tempo, circa 4 secondi per ordine. (cioè ci vogliono 20 secondi per aprire una posizione), e a volte questo non va bene. C'è un modo per farlo più velocemente? (attraverso ordini di stop preposizionati - non funziona per me).
https://forum.mql4.com/ru/13567
leggere.
Ho capito bene che in un tick l'EA invierà diversi ordini di acquisto al sistema di trading allo stesso tempo,
invece di aspettare che il server risponda all'accettazione e all'esecuzione del primo ordine, poi del secondo, e così via? ??
Finora l'ho fatto così - esempio - (registro, conto reale, tempo reale)
10.55.13 - ordine acquisto mercato 20 RTS - questo è il primo 20 lotti
10.55.13 - la richiesta è stata asseptata dal server
10.55.13 - richiesta in corso
10.55.17 - l'ordine è stato aperto
10.55.18 - ordine acquisto mercato 20 RTS - questo è il secondo 20 lotti
10.55.18 - la richiesta è stata asseptata dal server
10.55.19 - richiesta in corso
10.55.22 - l'ordine è stato aperto
10.55.23 - ordine acquisto mercato 20 RTS - questo è il terzo 20 lotti
10.55.23 - la richiesta è stata asseptata dal server
10.55.24 - richiesta in corso
10.55.27 - l'ordine è stato aperto
e vorrei che l'intera posizione fosse aperta entro i primi 4 secondi, cioè entro le 10.55.17
2. la dimensione massima della posizione consentita dal broker è di 20 lotti. Ho bisogno di aprire una posizione di 100 lotti. Ora sto aprendo in successione,
ma ci vuole molto tempo, circa 4 secondi per ordine. (cioè ci vogliono 20 secondi per aprire una posizione), e a volte questo non va bene. C'è un modo per farlo più velocemente? (tramite ordini di stop preposizionati - non funziona per me).
Esegui 4 terminali, quindi 4 richieste arriveranno al rivenditore per l'elaborazione in una volta sola, non una per una.
Igor, ciao!
Potreste consigliarmi come implementare la notifica sonora in un indicatore esistente?
Per esempio, in ZigZag. Se volete avere il suono nel momento in cui disegnate la nuova linea, registratelo nell'Organizzatore:
//+------------------------------------------------------------------+
//| Zigzag.mq4 |
//| Copyright © 2005-2007, MetaQuotes Software Corp.
//| https://www.metaquotes.net// |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2007, MetaQuotes Software Corp."
#proprietà link "https://www.metaquotes.net//"
#proprietà indicator_chart_window
#proprietà indicator_buffers 1
#property indicator_color1 Red
//---- parametri dell'indicatore
extern intDepth=12;
extern inttern ExtDeviation=5;
extern inttern ExtBackstep=3;
//---- buffer degli indicatori
doppio ZigzagBuffer[];
doppio HighMapBuffer[];
doppio LowMapBuffer[];
int level=3; // profondità del conteggio
bool downloadhistory=false;
//+------------------------------------------------------------------+
//| funzione di inizializzazione dell'indicatore personalizzato
//+------------------------------------------------------------------+
int init()
{
IndicatorBuffers(3);
//---- impostazioni di disegno
SetIndexStyle(0,DRAW_SECTION);
//---- mappatura dei buffer degli indicatori
SetIndexBuffer(0,ZigzagBuffer);
SetIndexBuffer(1,HighMapBuffer);
SetIndexBuffer(2,LowMapBuffer);
SetIndexEmptyValue(0,0.0);
//---- nome corto dell'indicatore
IndicatoreNomeCorto("ZigZag("+ExtDepth+", "+ExtDeviation+", "+ExtBackstep+")");
//---- inizializzazione fatta
ritorno(0);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int start()
{
int i, counted_bars = IndicatorCounted();
int limit,counterZ,whatlookfor;
int shift, back, lasthighpos, lastlowpos;
doppio val,res;
doppio curlow, curhigh, lasthigh, lastlow;
if (counted_bars==0 && downloadhistory) // la storia è stata scaricata
{
ArrayInitialize(ZigzagBuffer,0.0);
ArrayInitialize(HighMapBuffer,0.0);
ArrayInitialize(LowMapBuffer,0.0;)
}
se (counted_bars==0)
{
limit=Bars-ExtDepth;
downloadhistory=true;
}
se (barre contate>0)
{
mentre (contatoreZ<livello && i<100)
{
res=ZigzagBuffer[i];
se (res!=0) contatoreZ++;
i++;
}
i--;
limite=i;
se (LowMapBuffer[i]!=0)
{
curlow=LowMapBuffer[i];
whatlookfor=1;
}
else
{
curhigh=HighMapBuffer[i];
whatlookfor=-1;
}
per (i=limite-1;i>=0;i--)
{
ZigzagBuffer[i]=0.0;
LowMapBuffer[i]=0.0;
HighMapBuffer[i]=0.0;
}
}
for(shift=limite; shift>=0; shift--)
{
val=Low[iLowest(NULL,0,MODE_LOW,ExtDepth,shift)];
if(val==lastlow) val=0.0;
else
{
lastlow=val;
se((Low[shift]-val)>(ExtDeviation*Point)) val=0.0;
else
{
for(back=1; back<=ExtBackstep; back++)
{
res=LowMapBuffer[shift+back];
se((res!=0)&&(res>val)) LowMapBuffer[shift+back]=0.0;
}
}
}
se (Low[shift]==val) LowMapBuffer[shift]=val; altrimenti LowMapBuffer[shift]=0.0;
//--- alto
val=High[iHighest(NULL,0,MODE_HIGH,ExtDepth,shift)];
if(val==lasthigh) val=0.0;
else
{
lasthigh=val;
se((val-High[shift])>(ExtDeviation*Point)) val=0.0;
else
{
for(back=1; back<=ExtBackstep; back++)
{
res=HighMapBuffer[shift+back];
se((res!=0)&&(res<val)) HighMapBuffer[shift+back]=0.0;
}
}
}
se (High[shift]==val) HighMapBuffer[shift]=val; altrimenti HighMapBuffer[shift]=0.0;
}
// taglio finale
se (whatlookfor==0)
{
lastlow=0;
lasthigh=0;
}
else
{
lastlow=curlow;
lasthigh=curhigh;
}
per (shift=limite;shift>=0;shift--)
{
res=0.0;
interruttore(whatlookfor)
{
caso 0: // cerca il picco o il prato
se (lastlow==0 && lasthigh==0)
{
se (HighMapBuffer[shift]!=0)
{
lasthigh=high[shift];
lasthighpos=shift;
whatlookfor=-1;
ZigzagBuffer[shift]=lasthigh;
res=1;
}
se (LowMapBuffer[shift]=0)
{
lastlow=Low[shift];
lastlowpos=shift;
whatlookfor=1;
ZigzagBuffer[shift]=lastlow;
res=1;
}
}
pausa;
caso 1: // cerca il picco
se (LowMapBuffer[shift]=0.0 && LowMapBuffer[shift]<lastlow && HighMapBuffer[shift]==0.0)
{
ZigzagBuffer[lastlowpos]=0.0;
lastlowpos=shift;
lastlow=LowMapBuffer[shift];
ZigzagBuffer[shift]=lastlow;
res=1;
}
se (HighMapBuffer[shift]=0.0 && LowMapBuffer[shift]==0.0)
{
lasthigh=HighMapBuffer[shift];
lasthighpos=shift;
ZigzagBuffer[shift]=lasthigh;
whatlookfor=-1;
res=1;
}
pausa;
caso -1: // cerca il prato
se (HighMapBuffer[shift]=0.0 && HighMapBuffer[shift]>lasthigh && LowMapBuffer[shift]==0.0)
{
ZigzagBuffer[lasthighpos]=0.0;
lasthighpos=shift;
lasthigh=HighMapBuffer[shift];
ZigzagBuffer[shift]=lasthigh;
}
se (LowMapBuffer[shift]=0.0 && HighMapBuffer[shift]==0.0)
{
lastlow=LowMapBuffer[shift];
lastlowpos=shift;
ZigzagBuffer[shift]=lastlow;
whatlookfor=1;
}
pausa;
default: ritorno;
}
}
ritorno(0);
}
//+------------------------------------------------------------------+