Características úteis da KimIV - página 83
Você está perdendo oportunidades de negociação:
- Aplicativos de negociação gratuitos
- 8 000+ sinais para cópia
- Notícias econômicas para análise dos mercados financeiros
Registro
Login
Você concorda com a política do site e com os termos de uso
Se você não tem uma conta, por favor registre-se
Como fazer a EA abrir não uma posição, mas 2 ou 3 de uma só vez em uma direção. Por exemplo, como posso abrir duas posições unidirecionais a 0,5 e 0,5 lotes em vez de um lote? Ou 0,3+0,3+0,3 lotes.
>> Como eu monto o terminal para que quando eu o trocar para russo, ele diga tudo em russo, porque meu idioma está escrito em hieróglifos.
Em configurações regionais do Windows, defina o idioma para russo para uso em aplicações que não usam Unicode.
Olá, tenho uma pergunta diretamente a Igor Kim porque ele é o autor (se não estou enganado) do indicador i-SignalOfTrade.
O indicador executa todas as suas funções perfeitamente, mas as seguintes entradas aparecem no registro ao enviar um e-mail
Correio: 'i-SignalOfTrade' falhou
Mail: 451 Veja http://pobox.com/~djb/docs/smtplf.html.
e, é claro, a mensagem não vai a lugar algum.
Você pode me dizer qual pode ser o problema e como resolvê-lo?
P.S. O cliente de correio é configurado corretamente, as mensagens de teste são enviadas e entregues sem problemas.
Boa tarde. Você pode me dizer quem sabe? Estou trabalhando com o Índice RTS. O tamanho da posição é calculado por um programa de terceiros e transmitido para o Expert Advisor através de um arquivo txt. Tenho dois problemas aqui:
Como o bloco de partida {...} só é ativado quando um novo tick chega e os ticks no índice são raros, há um atraso na execução da EA.
Eu o coloquei em um instrumento que faz tic-tac mais freqüentemente ( EURUSD ), mas eu ainda gostaria de perguntar - é possível forçar o início {...}?
2. o tamanho máximo de posição permitido pelo meu corretor é de 20 lotes. Preciso abrir uma posição de 100 lotes. Neste momento, estou abrindo uma posição de cada vez,
mas isso leva muito tempo, cerca de 4 segundos por pedido. (ou seja, leva 20 segundos para abrir uma posição), e às vezes isso não é bom. Há alguma maneira de fazê-lo mais rapidamente? (via ordens de parada pré-estabelecidas - não funciona para mim).
2. O tamanho máximo de posição permitido pelo corretor é de 20 lotes. Preciso abrir uma posição de 100 lotes. Agora estou abrindo em sucessão,
mas isso leva muito tempo, cerca de 4 segundos por pedido. (ou seja, demora 20 segundos para abrir uma posição), e às vezes isso não é bom. Há alguma maneira de fazê-lo mais rapidamente? (através de ordens de parada pré-fixadas não é bom para mim).
https://forum.mql4.com/ru/13567
leia.
Entendi corretamente que em um só tique o EA enviará várias ordens de compra ao sistema comercial ao mesmo tempo,
em vez de esperar que o servidor responda na primeira aceitação e execução do pedido, depois na segunda, e assim por diante ? ??
Tenho-o assim até agora - exemplo - (log, conta real, tempo real)
10.55.13 - mercado de compra de pedidos 20 RTS - este é o primeiro 20 lotes
10.55.13 - o pedido foi assentido pelo servidor
10.55.13 - pedido em processo
10.55.17 - o pedido foi aberto
10.55.18 - mercado de compra de pedidos 20 RTS - este é o segundo 20 lotes
10.55.18 - o pedido foi assentido pelo servidor
10.55.19 - pedido em processo
10.55.22 - o pedido foi aberto
10.55.23 - mercado de compra de pedidos 20 RTS - este é o terceiro 20 lotes
10.55.23 - o pedido foi assentido pelo servidor
10.55.24 - solicitação em processo
10.55.27 - o pedido foi aberto
e eu gostaria de ter a posição inteira aberta em 4 segundos, ou seja, até 10.55.17
2. O tamanho máximo de posição permitido pelo corretor é de 20 lotes. Preciso abrir uma posição de 100 lotes. Agora estou abrindo em sucessão,
mas isso leva muito tempo, cerca de 4 segundos por pedido. (ou seja, leva 20 segundos para abrir uma posição), e às vezes isso não é bom. Há alguma maneira de fazê-lo mais rapidamente? (via ordens de parada pré-estabelecidas - não funciona para mim).
Execute 4 terminais, então 4 pedidos chegarão ao revendedor para processamento de uma só vez, não um a um.
Igor, olá!
Você poderia aconselhar como implementar uma notificação sonora em um indicador existente?
Por exemplo, em ZigZag. Se você quiser ter som no momento de desenhar a nova linha, por favor, registre-a no Organizador:
//+------------------------------------------------------------------+
//| Zigzag.mq4 |
//| Copyright © 2005-2007, MetaQuotes Software Corp.
//| https://www.metaquotes.net// |
//+------------------------------------------------------------------+
#direitos autorais "Copyright © 2007, MetaQuotes Software Corp."
#link da propriedade "https://www.metaquotes.net//"
#janela_do_cartão_indicador de propriedade
#property indicator_buffers 1
#indicador de propriedade_cores1 Vermelho
//---- parâmetros indicadores
intDepth=12;
ExtDeviação Externa Interna=5;
ExtBackstep ExtBackstep=3;
//---- buffers indicadores
duplo ZigzagBuffer[];
duplo HighMapBuffer[];
duplo LowMapBuffer[];
int level=3; // profundidade da recontagem
bool downloadhistory=false;
//+------------------------------------------------------------------+
//| Função de inicialização do indicador personalizado |
//+------------------------------------------------------------------+
int init()
{
IndicatorBuffers(3);
//---- definições de desenho
SetIndexStyle(0,DRAW_SECTION);
//---- mapeamento de buffers indicadores
SetIndexBuffer(0,ZigzagBuffer);
SetIndexBuffer(1,HighMapBuffer);
SetIndexBuffer(2,LowMapBuffer);
SetIndexEmptyValue(0,0,0.0);
//---- indicador nome curto
IndicatorShortName("ZigZag("+ExtDepth+", "+ExtDeviation+", "+ExtBackstep+")"));
//---- inicialização feita
retorno(0);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int start()
{
int i, counted_bars = IndicatorCounted();
int limit,counterZ,o que se pretende;
int shift,back,lasthighpos,lastlowpos;
duplo val,res;
duplo curlow,curhigh,lasthigh,lastlow;
se (counted_bars==0 && downloadhistory) // histórico foi baixado
{
ArrayInitialize(ZigzagBuffer,0.0);
ArrayInitialize(HighMapBuffer,0.0);
ArrayInitialize(LowMapBuffer,0.0;)
}
se (counted_bars==0)
{
limit=Bars-ExtDepth;
downloadhistory=true;
}
se (contado_barras>0)
{
enquanto (counterZ<level && i<100)
{
res=ZigzagBuffer[i];
se (res!=0) counterZ++;
i++;
}
i--;
limite=i;
se (LowMapBuffer[i]!=0)
{
curlow=LowMapBuffer[i];
o que se observa para=1;
}
senão
{
curhigh=HighMapBuffer[i];
o que se observa para=-1;
}
para (i=limit-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;
senão
{
lastlow=val;
if((Low[shift]-val)>(ExtDeviation*Point)) val=0,0;
senão
{
for(back=1; back<=ExtBackstep; back++)
{
res=LowMapBuffer[shift+back];
if((res!=0)&&(res>val)) LowMapBuffer[shift+back]=0,0;
}
}
}
if (Baixo[shift]==val) LowMapBuffer[shift]=val; else LowMapBuffer[shift]=0.0;
//--- alto
val=High[iHighest(NULL,0,MODE_HIGH,ExtDepth,shift)];
if(val===lasthigh) val=0,0;
senão
{
lasthigh=val;
if((val-High[shift])>(ExtDeviation*Point)) val=0,0;
senão
{
for(back=1; back<=ExtBackstep; back++)
{
res=HighMapBuffer[shift+back];
if((res!=0)&&(res<val)) HighMapBuffer[shift+back]=0,0;
}
}
}
if (High[shift]==val) HighMapBuffer[shift]=val; else HighMapBuffer[shift]=0.0;
}
// corte final
se (o que se observa para==0)
{
lastlow=0;
lasthigh=0;
}
senão
{
lastlow=curlow;
lasthigh=curhigh;
}
para (shift=limite;shift>=0;shift--)
{
res=0,0;
switch(whatlookfor)
{
caso 0: // procurar por pico ou gramado
se (lastlow==0 && lasthigh==0)
{
se (HighMapBuffer[shift]!=0)
{
lasthigh=high[shift];
lasthighpos=shift;
o que se observa para=-1;
ZigzagBuffer[shift]=lasthigh;
res=1;
}
se (LowMapBuffer[shift]=0)
{
lastlow=Low[shift];
lastlowpos=shift;
o que se observa para=1;
ZigzagBuffer[shift]=lastlow;
res=1;
}
}
pausa;
caso 1: // procurar por pico
if (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;
o que se observa para=-1;
res=1;
}
pausa;
caso -1: // procurar por gramado
se (HighMapBuffer[shift]=0.0 && HighMapBuffer[shift]>lasthigh && LowMapBuffer[shift]==0.0)
{
ZigzagBuffer[lasthighpos]=0,0;
lasthighpos=shift;
lasthigh=HighMapBuffer[shift];
ZigzagBuffer[shift]=lasthigh;
}
if (LowMapBuffer[shift]=0.0 && HighMapBuffer[shift]==0.0)
{
lastlow=LowMapBuffer[shift];
lastlowpos=shift;
ZigzagBuffer[shift]=lastlow;
o que se observa para=1;
}
pausa;
padrão: devolução;
}
}
retorno(0);
}
//+------------------------------------------------------------------+