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

Novo comentário
 
A13ksandr:Desculpe! É claro que tudo acontece no vazio OnTick(). Eu escrevi isso)
Depois há um código de erro no registro do testador, você pode usá-lo para descobrir o código.
 
evillive:
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();

}

}

}

}

}

}

//+------------------------------------------------------------------+

 
alvlaf:

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.
 
A13ksandr:
Obrigado, experimentei-o - o bot começou a abrir um monte de pedidos a cada tique.
 
A13ksandr:

if (OrderMagicNumber() == Magic && (OrderType() == OrderType() == OP_BUY || OrderType() == OP_SELLL))

Eu o mudei corretamente?

 
alvlaf:

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();

}

}

}

}

}

}

//+------------------------------------------------------------------+

Por favor me diga para que propósito você está usando o MagicNumber, o que ele dá nesta estratégia? IMHO, você também pode jogar fora a função OnInit OnDeinit aqui
 
evillive:


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?

 
RichLux:

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.

 
LRA:
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
Qual é a finalidade das palavras "nesta estratégia"? A magia é necessária se você fizer negócios manualmente na conta ou executar outro Expert Advisor para que estas ordens não sejam tocadas. Eu acho que sim.
1...108610871088108910901091109210931094109510961097109810991100...1178
Novo comentário