Qualquer pergunta de novato, de modo a não desorganizar o fórum. Profissionais, não passem por aqui. Em nenhum lugar sem você - 6. - página 1093
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
Depois há um código de erro no registro do testador e ele pode ser usado para investigação posterior.
Sem erros. Isso só depende da entrada no procedimento. E há também o StartSell, que entra normalmente. Isto é algum tipo de confusão.
Atualizei as citações e funciona. Não é correto por causa de alguns buracos, mas pelo menos não é pendurado.
Saudações, você poderia me dizer qual a melhor maneira de evitar a abertura simultânea de mais de um conjunto de séries para diferentes instrumentos (o bot é anexado a vários gráficos de diferentes instrumentos ao mesmo tempo) em opções binárias?
Lotes duplos externos = 1; // Lotes
Exp = 1; // Expiração
externo int Espera = 0; // Número de castiçais de uma direção
Tempo esgotado externo int = 1; // Horário
duplo multiplicador externo = 3; // Multiplicador
int int externo Slippage = 5; // Slippage
Externo int MaxOpenOrders = 1; // Número máximo de ordens abertas simultaneamente
magia interna externa = 774274; // Magia
int ticket, Tipo;
preço duplo, lote;
//+------------------------------------------------------------------+
//| Função de iniciação de especialistas |
//+------------------------------------------------------------------+
int OnInit()
{
return(INIT_SUCCEED);
}
//+------------------------------------------------------------------+
//| Função de desinicialização especializada |
//+------------------------------------------------------------------+
nulo OnDeinit(const int razão)
{
}
//+------------------------------------------------------------------+
//| função tick expert |
//+------------------------------------------------------------------+
nulo OnTick()
{
// --------------- Comércios abertos ---------------
se (CountTrades() == 0) // Número de pedidos deve ser igual a zero
{
if ((TypeLastHistOrder() == OP_BUY && PriceCloseLastHistOrder(OP_BUY) < PriceOpenLastHistOrder(OP_BUY))
|| (TypeLastHistOrder() == OP_SELLL && PriceCloseLastHistOrder(OP_SELLL) > PriceOpenLastHistOrder(OP_SELLL))
// Se o último comércio estiver perdendo, o mesmo é aberto, mas com lote maior
{
Tipo = TypeLastHistOrder();
se (Tipo == OP_BUY) Preço = Perguntar;
se (Tipo == OP_SELL) Preço = Licitação;
Lote = NormalizeDuplo(LotsLastHistOrder()*Multiplier, 2);
bilhete = OrderSend(Symbol(), Type, Lot, Price, Slippage, 0, 0, IntegerToString(Exp), Magic);
}
if (PriceCloseLastHistOrder() == PriceOpenLastHistOrder() && CountHistTrades() > 0)
// se o lucro do último comércio for igual a zero, o mesmo comércio será aberto
{
Tipo = TypeLastHistOrder();
se (Tipo == OP_BUY) Preço = Perguntar;
se (Tipo == OP_SELL) Preço = Licitação;
Lote = NormalizeDuplo(LotsLastHistOrder(), 2);
bilhete = OrderSend(Symbol(), Type, Lot, Price, Slippage, 0, 0, IntegerToString(Exp), Magic);
}
if (((TypeLastHistOrder() == OP_BUY && PriceCloseLastHistOrder(OP_BUY) > PriceOpenLastHistOrder(OP_BUY))
|| (TypeLastHistOrder() == OP_SELLL && PriceCloseLastHistOrder(OP_SELLL) < PriceOpenLastHistOrder(OP_SELLL))
|| CountHistTrades() == 0)// Se a última negociação for lucrativa, a ordem é aberta
{
if (SignalBuy() && MaxOpenOrders > OrderTotal())
{
bilhete = OrderSend(Symbol(), OP_BUY, Lots, Ask, Slippage, 0, 0, IntegerToString(Exp), Magic);
}
if (SignalSell() && MaxOpenOrders > OrderTotal())
{
bilhete = OrderSend(Symbol(), OP_SELL, Lots, Bid, Slippage, 0, 0, IntegerToString(Exp), Magic);
}
}
}
}
//+------------------------------------------------------------------+
int CountTrades(int tipo = -1)
{
int cnt = 0;
para (int i=OrdensTotal()-1; i>=0; i--)
{
se (OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
{
if (OrderSymbol() == Symbol() && OrderMagicNumber() == Magic && (OrderType() == type ||| type == -1))
cnt++;
}
}
retorno(cnt);
}
//+------------------------------------------------------------------+
int CountHistTrades(int tipo = -1)
{
int cnt = 0;
para (int i=OrdensHistóriaTotal()-1; i>=0; i--)
{
se (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))
{
if (OrderSymbol() == Symbol() && OrderMagicNumber() == Magic && (OrderType() == type ||| type == -1))
cnt++;
}
}
retorno(cnt);
}
//+------------------------------------------------------------------+
bool SignalBuy()
{
para (int i=1; i<=Wait; i++)
{
se (Fechar[i] > Abrir[i]) retornar(falso)
}
if ((iBarShift(Symbol(), 0, TimeLastHistOrder()+Timeout) >= Espera ||| (Espera == 0 && TimeCurrent() >= TimeLastHistOrder()+Timeout))
&& CountHistTrades() > 0) retorno(true);
se (CountHistTrades() == 0) retornar(true);
retorno(falso);
}
//+------------------------------------------------------------------+
bool SignalSell()
{
para (int i=1; i<=Wait; i++)
{
se (Fechar[i] < Abrir[i]) retornar(falso)
}
if ((iBarShift(Symbol(), 0, TimeLastHistOrder()+Timeout) >= Espera ||| (Espera == 0 && TimeCurrent() >= TimeLastHistOrder()+Timeout))
&& CountHistTrades() > 0) retorno(true);
se (CountHistTrades() == 0) retornar(true);
retorno(falso);
}
//+------------------------------------------------------------------+
dataHoraHoraLastHistOrder(tipo int = -1)
{
data/hora da última vez = 0;
data/hora opentime = 0;
para (int i=OrdensHistóriaTotal()-1; i>=0; i--)
{
se (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))
{
if (OrderSymbol() == Symbol() && OrderMagicNumber() == Magic && (OrderType() == type ||| type == -1))
{
se (OrderCloseTime() > última vez)
{
lasttime = OrderCloseTime();
opentime = OrderOpenTime();
}
}
}
}
retorno(opentime);
}
//+------------------------------------------------------------------+
int TypeLastHistOrder()
{
data/hora = 0;
tipo int = -1;
para (int i=OrdensHistóriaTotal()-1; i>=0; i--)
{
se (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))
{
se (OrderSymbol() == Symbol() && OrderMagicNumber() == Magic)
{
se (OrderCloseTime() > tempo)
{
tempo = OrderCloseTime();
tipo = OrderType();
}
}
}
}
retorno(tipo);
}
//+------------------------------------------------------------------+
double LotsLastHistOrder(tipo int = -1)
{
data/hora = 0;
lotes duplos = 0;
para (int i=OrdensHistóriaTotal()-1; i>=0; i--)
{
se (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))
{
if (OrderSymbol() == Symbol() && OrderMagicNumber() == Magic && (OrderType() == type ||| type == -1))
{
se (OrderOpenTime() > tempo)
{
tempo = OrderOpenTime();
tempo = OrderLots();
}
}
}
}
devolução(lotes);
}
//+------------------------------------------------------------------+
duplo PriceCloseLastHistOrder(int tipo = -1)
{
data/hora = 0;
preço duplo = 0;
para (int i=OrdensHistóriaTotal()-1; i>=0; i--)
{
se (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))
{
if (OrderSymbol() == Symbol() && OrderMagicNumber() == Magic && (OrderType() == type ||| type == -1))
{
se (OrderCloseTime() > tempo)
{
tempo = OrderCloseTime();
preço = OrderClosePrice();
}
}
}
}
}
}
//+------------------------------------------------------------------+
duplo PriceOpenLastHistOrder(int tipo = -1)
{
data/hora = 0;
preço duplo = 0;
para (int i=OrdensHistóriaTotal()-1; i>=0; i--)
{
se (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))
{
if (OrderSymbol() == Symbol() && OrderMagicNumber() == Magic && (OrderType() == type ||| type == -1))
{
se (OrderCloseTime() > tempo)
{
tempo = OrderCloseTime();
preço = OrderOpenPrice();
}
}
}
}
}
}
//+------------------------------------------------------------------+
Basta apagar a condição OrderSymbol() == Symbol() da função CountTrades e adicionar OrderType() == OP_BUY || OrderType() == OP_SELLL, não?
E mudar a condição se (SignalBuy() && CountTrades() < MaxOpenOrders) em OnTick antes do pedidoEnviar... O mesmo para Vender.if (OrderMagicNumber() == Magic && (OrderType() == OrderType() == OP_BUY || OrderType() == OP_SELLL))
Eu o mudei corretamente?
Saudações, você poderia me dizer qual a melhor maneira de evitar a abertura simultânea de mais de um conjunto de séries para diferentes instrumentos (o bot é anexado a vários gráficos de diferentes instrumentos ao mesmo tempo) em opções binárias?
Lotes duplos externos = 1; // Lotes
Exp = 1; // Expiração
externo int Espera = 0; // Número de castiçais de uma direção
Tempo esgotado externo int = 1; // Horário
duplo multiplicador externo = 3; // Multiplicador
int int externo Slippage = 5; // Slippage
Externo int MaxOpenOrders = 1; // Número máximo de ordens abertas simultaneamente
magia interna externa = 774274; // Magia
int ticket, Tipo;
preço duplo, lote;
//+------------------------------------------------------------------+
//| Função de iniciação de especialistas |
//+------------------------------------------------------------------+
int OnInit()
{
return(INIT_SUCCEED);
}
//+------------------------------------------------------------------+
//| Função de desinicialização especializada |
//+------------------------------------------------------------------+
nulo OnDeinit(const int razão)
{
}
//+------------------------------------------------------------------+
//| função tick expert |
//+------------------------------------------------------------------+
nulo OnTick()
{
// --------------- Comércios abertos ---------------
se (CountTrades() == 0) // Número de pedidos deve ser igual a zero
{
if ((TypeLastHistOrder() == OP_BUY && PriceCloseLastHistOrder(OP_BUY) < PriceOpenLastHistOrder(OP_BUY))
|| (TypeLastHistOrder() == OP_SELLL && PriceCloseLastHistOrder(OP_SELLL) > PriceOpenLastHistOrder(OP_SELLL))
// Se o último comércio estiver perdendo, o mesmo é aberto, mas com lote maior
{
Tipo = TypeLastHistOrder();
se (Tipo == OP_BUY) Preço = Perguntar;
se (Tipo == OP_SELL) Preço = Licitação;
Lote = NormalizeDuplo(LotsLastHistOrder()*Multiplier, 2);
bilhete = OrderSend(Symbol(), Type, Lot, Price, Slippage, 0, 0, IntegerToString(Exp), Magic);
}
if (PriceCloseLastHistOrder() == PriceOpenLastHistOrder() && CountHistTrades() > 0)
// se o lucro do último comércio for igual a zero, o mesmo comércio será aberto
{
Tipo = TypeLastHistOrder();
se (Tipo == OP_BUY) Preço = Perguntar;
se (Tipo == OP_SELL) Preço = Licitação;
Lote = NormalizeDuplo(LotsLastHistOrder(), 2);
bilhete = OrderSend(Symbol(), Type, Lot, Price, Slippage, 0, 0, IntegerToString(Exp), Magic);
}
if (((TypeLastHistOrder() == OP_BUY && PriceCloseLastHistOrder(OP_BUY) > PriceOpenLastHistOrder(OP_BUY))
|| (TypeLastHistOrder() == OP_SELLL && PriceCloseLastHistOrder(OP_SELLL) < PriceOpenLastHistOrder(OP_SELLL))
|| CountHistTrades() == 0)// Se a última negociação for lucrativa, a ordem é aberta
{
if (SignalBuy() && MaxOpenOrders > OrderTotal())
{
bilhete = OrderSend(Symbol(), OP_BUY, Lots, Ask, Slippage, 0, 0, IntegerToString(Exp), Magic);
}
if (SignalSell() && MaxOpenOrders > OrderTotal())
{
bilhete = OrderSend(Symbol(), OP_SELL, Lots, Bid, Slippage, 0, 0, IntegerToString(Exp), Magic);
}
}
}
}
//+------------------------------------------------------------------+
int CountTrades(int tipo = -1)
{
int cnt = 0;
para (int i=OrdensTotal()-1; i>=0; i--)
{
se (OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
{
if (OrderSymbol() == Symbol() && OrderMagicNumber() == Magic && (OrderType() == type ||| type == -1))
cnt++;
}
}
retorno(cnt);
}
//+------------------------------------------------------------------+
int CountHistTrades(int tipo = -1)
{
int cnt = 0;
para (int i=OrdensHistóriaTotal()-1; i>=0; i--)
{
se (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))
{
if (OrderSymbol() == Symbol() && OrderMagicNumber() == Magic && (OrderType() == type ||| type == -1))
cnt++;
}
}
retorno(cnt);
}
//+------------------------------------------------------------------+
bool SignalBuy()
{
para (int i=1; i<=Wait; i++)
{
se (Fechar[i] > Abrir[i]) retornar(falso)
}
if ((iBarShift(Symbol(), 0, TimeLastHistOrder()+Timeout) >= Espera ||| (Espera == 0 && TimeCurrent() >= TimeLastHistOrder()+Timeout))
&& CountHistTrades() > 0) retorno(true);
se (CountHistTrades() == 0) retornar(true);
retorno(falso);
}
//+------------------------------------------------------------------+
bool SignalSell()
{
para (int i=1; i<=Wait; i++)
{
se (Fechar[i] < Abrir[i]) retornar(falso)
}
if ((iBarShift(Symbol(), 0, TimeLastHistOrder()+Timeout) >= Espera ||| (Espera == 0 && TimeCurrent() >= TimeLastHistOrder()+Timeout))
&& CountHistTrades() > 0) retorno(true);
se (CountHistTrades() == 0) retornar(true);
retorno(falso);
}
//+------------------------------------------------------------------+
dataHoraHoraLastHistOrder(tipo int = -1)
{
data/hora da última vez = 0;
data/hora opentime = 0;
para (int i=OrdensHistóriaTotal()-1; i>=0; i--)
{
se (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))
{
if (OrderSymbol() == Symbol() && OrderMagicNumber() == Magic && (OrderType() == type ||| type == -1))
{
se (OrderCloseTime() > última vez)
{
lasttime = OrderCloseTime();
opentime = OrderOpenTime();
}
}
}
}
retorno(opentime);
}
//+------------------------------------------------------------------+
int TypeLastHistOrder()
{
data/hora = 0;
tipo int = -1;
para (int i=OrdensHistóriaTotal()-1; i>=0; i--)
{
se (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))
{
se (OrderSymbol() == Symbol() && OrderMagicNumber() == Magic)
{
se (OrderCloseTime() > tempo)
{
tempo = OrderCloseTime();
tipo = OrderType();
}
}
}
}
retorno(tipo);
}
//+------------------------------------------------------------------+
double LotsLastHistOrder(tipo int = -1)
{
data/hora = 0;
lotes duplos = 0;
para (int i=OrdensHistóriaTotal()-1; i>=0; i--)
{
se (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))
{
if (OrderSymbol() == Symbol() && OrderMagicNumber() == Magic && (OrderType() == type ||| type == -1))
{
se (OrderOpenTime() > tempo)
{
tempo = OrderOpenTime();
tempo = OrderLots();
}
}
}
}
devolução(lotes);
}
//+------------------------------------------------------------------+
duplo PriceCloseLastHistOrder(int tipo = -1)
{
data/hora = 0;
preço duplo = 0;
para (int i=OrdensHistóriaTotal()-1; i>=0; i--)
{
se (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))
{
if (OrderSymbol() == Symbol() && OrderMagicNumber() == Magic && (OrderType() == type ||| type == -1))
{
se (OrderCloseTime() > tempo)
{
tempo = OrderCloseTime();
preço = OrderClosePrice();
}
}
}
}
}
}
//+------------------------------------------------------------------+
duplo PriceOpenLastHistOrder(int tipo = -1)
{
data/hora = 0;
preço duplo = 0;
para (int i=OrdensHistóriaTotal()-1; i>=0; i--)
{
se (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))
{
if (OrderSymbol() == Symbol() && OrderMagicNumber() == Magic && (OrderType() == type ||| type == -1))
{
se (OrderCloseTime() > tempo)
{
tempo = OrderCloseTime();
preço = OrderOpenPrice();
}
}
}
}
}
}
//+------------------------------------------------------------------+
O tempo pode ser ajustado diretamente no formato de data e hora, não há necessidade de perder tempo com a conversão, funciona assim:
extern datetime StartTime = D'07: 00';
Neste formato de tempo, quando iniciamos a EA, obtemos a data de compilação, enquanto queremos que a data de compilação seja hoje.
Como corrigi-lo?
Este formato de tempo dá a data de compilação da EA ao iniciar a EA, mas eu gostaria de ter a data de hoje.
Como consertá-lo?
Você muda o parâmetro para o desejado na inicialização, da mesma forma que os outros parâmetros do usuário.
E por alguma razão me mostra a data atual no momento da execução do roteiro.
Por favor, diga-me, qual é o propósito de usar o MagicNumber, o que ele dá nesta estratégia? IMHO, você também pode jogar fora as funções OnInit OnDeinit aqui