[ARQUIVO] Qualquer pergunta de novato, de modo a não desorganizar o fórum. Profissionais, não passem por aqui. Em nenhum lugar sem você - 3. - página 450

Novo comentário
 
T-G:
Sim, mas o ponto da questão é que a ordem anterior foi fechada com um menos. A função não tem tempo para mostrar isso, primeiro a ordem é aberta depois de um par de ticks e só depois a função mostra a última perda, mas a ordem já foi aberta.
Eu escrevi um esqueleto de código com cheque
 
Eu fiz isso mais uma vez disse que não tinha tempo para verificar primeiro se passava como se não houvesse um alce abre um negócio e depois chega a ele que havia um alce
 
artmedia70:

Por que não usar o parâmetro Expiração pendente do pedido?

É claro que existe a possibilidade de que este parâmetro não possa ser utilizado.

Em alguns servidores comerciais, o tempo de expiração de ordens pendentes pode ser proibido. Neste caso, um erro 147 (ERR_TRADE_EXPIRATION_DENIED) será gerado ao tentar definir um valor não zero no parâmetro de expiração.

Essa é a única maneira, é claro...

Mudei a linha como você sugeriu e o Consultor Especialista parou de trabalhar.

ticket=OrderSend(Symbol(),OP_BUYSTOP,Lots,Ask+PriceDistance*Point,3,Ask+PriceDistance*Point-StopLoss*Point,Ask+PriceDistance*Point+TakeProfit*Point, "PD",1,TimeCurrent()+10*60,Green);

Ao mesmo tempo, sei com certeza que não há proibição.

Favor informar onde o erro pode estar.

 
T-G:
Eu fiz isso mais uma vez disse que não tinha tempo para verificar primeiro se passava como se não houvesse um alce abre um negócio e depois chega a ele que havia um alce
Os milagres não acontecem. Você deveria ver um telepata...
 
OlegArH:

Fiz mudanças na linha, como sugeriu, e o consultor especializado parou de trabalhar.

ticket=OrderSend(Symbol(),OP_BUYSTOP,Lots,Ask+PriceDistance*Point,3,Ask+PriceDistance*Point-StopLoss*Point,Ask+PriceDistance*Point+TakeProfit*Point, "PD",1,TimeCurrent()+10*60,Green);

Ao mesmo tempo, sei com certeza que não há proibição.

Favor informar onde o erro pode estar.

É improvável que tenha parado de funcionar, mas é provável que seus critérios sejam errôneos. Sem o código, é difícil pensar em uma razão pela qual a EA não está funcionando...
 
artmedia70:
É improvável que tenha parado de funcionar, mas é provável que seu critério seja coxo. Sem o código, é difícil pensar em uma razão pela qual a EA não funciona...

Aqui está tudo o que rabisquei até agora:

duplo TakeProfit externo = 50;
StopLoss duplo externo=100;
dobro do preçoDistância externa = 50;
Lotes duplos externos = 1;
TrailingStop duplo externo = 50;
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int start()
{
int cnt, bilhete, total;

total=OrdensTotal();
if(total<1)
{
ticket=OrderSend(Symbol(),OP_BUYSTOP,Lots,Ask+PriceDistance*Point,3,Ask+PriceDistance*Point-StopLoss*Point,Ask+PriceDistance*Point+TakeProfit*Point, "PD",1,0,Green);
Dormir (10000);
ticket=OrderSend(Symbol(),OP_SELLSTOP,Lots,Bid-PriceDistance*Point,3,Bid-PriceDistance*Point+StopLoss*Point,Bid-PriceDistance*Point-TakeProfit*Point, "PD",2,0,Red);
}

for(cnt=0;cnt<total;cnt++)
{
OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
if(OrderType()<=OP_SELL && // verificar a posição aberta
OrderSymbol()==Symbol()) // verificar o símbolo
{
if(OrderType()==OP_BUY) // posição longa é aberta
{
// deve ser fechado?
se(1!=1)
{
OrderClose(OrderTicket(),OrderLots(),Bid,3,Violet); // posição fechada
retornar(0); // sair
}
// verificar a parada de trilha
if(TrailingStop>0)
{
if(Bid-OrderOpenPrice()>Point*TrailingStop)
{
if(OrderStopLoss()<Bid-Point*TrailingStop)
{
OrderModify(OrderTicket(),OrderOpenPrice(),Bid-Point*TrailingStop,OrderTakeProfit(),0,Green);
retorno(0);
}
}
}
}
senão // ir para a posição curta
{
// deve ser fechado?
se(1!=1)
{
OrderClose(OrderTicket(),OrderLots(),Ask,3,Violet); // posição fechada
retornar(0); // sair
}
// verificar a parada de trilha
if(TrailingStop>0)
{
if((OrderOpenPrice()-Ask)>(Point*TrailingStop))
{
if((OrderStopLoss()>(Ask+Point*TrailingStop)) ||| (OrderStopLoss()==0)))
{
OrderModify(OrderTicket(),OrderOpenPrice(),Ask+Point*TrailingStop,OrderTakeProfit(),0,Red);
retorno(0);
}
}
}
}
}
}
retorno(0);
}

// o fim.

Funciona assim.... Mas, de acordo com isso, abre negócios indefinidamente, o rastejador.

Obrigado de antemão!

 
OlegArH:

Aqui está tudo o que rabisquei até agora:

duplo TakeProfit externo = 50;
StopLoss duplo externo=100;
preço duplo externoDistância = 50;
Lotes duplos externos = 1;
TrailingStop duplo externo = 50;
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int start()
{
int cnt, bilhete, total;

total=OrdensTotal();
if(total<1)
{
ticket=OrderSend(Symbol(),OP_BUYSTOP,Lots,Ask+PriceDistance*Point,3,Ask+PriceDistance*Point-StopLoss*Point,Ask+PriceDistance*Point+TakeProfit*Point, "PD",1,0,Green);
Dormir (10000);
ticket=OrderSend(Symbol(),OP_SELLSTOP,Lots,Bid-PriceDistance*Point,3,Bid-PriceDistance*Point+StopLoss*Point,Bid-PriceDistance*Point-TakeProfit*Point, "PD",2,0,Red);
}

for(cnt=0;cnt<total;cnt++)
{
OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
if(OrderType()<=OP_SELL && // verificar a posição aberta
OrderSymbol()==Symbol()) // verificar o símbolo
{
if(OrderType()==OP_BUY) // posição longa é aberta
{
// deve ser fechado?
se(1!=1)
{
OrderClose(OrderTicket(),OrderLots(),Bid,3,Violet); // posição fechada
retornar(0); // sair
}
// verificar a parada de trilha
if(TrailingStop>0)
{
if(Bid-OrderOpenPrice()>Point*TrailingStop)
{
if(OrderStopLoss()<Bid-Point*TrailingStop)
{
OrderModify(OrderTicket(),OrderOpenPrice(),Bid-Point*TrailingStop,OrderTakeProfit(),0,Green);
retorno(0);
}
}
}
}
senão // ir para a posição curta
{
// deve ser fechado?
se(1!=1)
{
OrderClose(OrderTicket(),OrderLots(),Ask,3,Violet); // posição fechada
retornar(0); // sair
}
// verificar a parada de trilha
if(TrailingStop>0)
{
if((OrderOpenPrice()-Ask)>(Point*TrailingStop))
{
if((OrderStopLoss()>(Ask+Point*TrailingStop)) ||| (OrderStopLoss()==0)))
{
OrderModify(OrderTicket(),OrderOpenPrice(),Ask+Point*TrailingStop,OrderTakeProfit(),0,Red);
retorno(0);
}
}
}
}
}
}
retorno(0);
}

// o fim.

Funciona assim.... Mas, de acordo com isso, abre negócios indefinidamente, o rastejador.

Obrigado de antemão!


Aprenda a inserir código - leia tudo.
 
Roman.:

Aprenda a inserir código - leia tudo.

Roman, obrigado pela resposta!
O que eu tenho que fazer é fazer com que o robô abra os negócios pelo tempo a partir do momento em que eles são abertos automaticamente.

Por exemplo, o robô abre um comércio TARGET, define automaticamente o tempo de expiração +600 segundos do atual e é isso....

Neste caso, a opção quando ele mesmo as retira não se encaixa, uma vez que a TC na qual eu "treino" há restrições para a modificação das ordens pendentes se o preço se aproximar de 10 pontos + Spread para o preço de abertura, incluindo aquelas ainda não abertas.

Além disso, a questão é que se uma ordem já está aberta, ela não deve ser apagada, mas devemos deixá-la "passar" e borbulhar até sua "morte". E se definirmos o ordendelite, a função também fechará as ordens que já tenham sido acionadas. (?)

Quanto ao livro didático - bem, não sou um programador por temperamento, sou um brilhante humanitário - desenho, modelo, componho e não afio para nada mais!)

Eu tenho tentado entrar de boa fé. Algumas delas faziam sentido e outras não.

É por isso que estou aqui.....

 
OlegArH:

Roman, obrigado pela resposta!
É apenas uma questão de conseguir que o robô abra os negócios a tempo a partir do momento em que eles são abertos automaticamente.

Por exemplo, o robô abre um comércio TARGET, define automaticamente o tempo de expiração +600 segundos do atual e é isso....

Neste caso, a opção quando ele mesmo as retira não se encaixa, uma vez que a TC na qual eu "treino" há restrições para a modificação das ordens pendentes se o preço se aproximar de 10 pontos + Spread para o preço de abertura, incluindo aquelas ainda não abertas.

Além disso, a questão é que se uma ordem já está aberta, ela não deve ser apagada, mas deve ser permitida a "jogar através" e falhar. E se definirmos o ordendelite, a função também fechará as ordens que já tenham sido acionadas. (?)

Quanto ao livro didático - bem, não sou um programador por temperamento, sou um brilhante humanitário - desenho, modelo, componho e não afio para nada mais!)

Eu tenho tentado entrar de boa fé. Algumas delas faziam sentido e outras não.

É por isso que estou aqui.....

Tente descrever em palavras o que você escreveu aqui:

extern double TakeProfit = 50;
extern double StopLoss=100;
extern double PriceDistance = 50;
extern double Lots = 1;
extern double TrailingStop = 50;
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int start()
{
   int cnt, ticket, total;

   total=OrdersTotal();
   if(total<1) {
      ticket=OrderSend(Symbol(),OP_BUYSTOP,Lots,Ask+PriceDistance*Point,3,Ask+PriceDistance*Point-StopLoss*Point,
                       Ask+PriceDistance*Point+TakeProfit*Point,"PD",1,0,Green);
      Sleep (10000);
      ticket=OrderSend(Symbol(),OP_SELLSTOP,Lots,Bid-PriceDistance*Point,3,Bid-PriceDistance*Point+StopLoss*Point,
                       Bid-PriceDistance*Point-TakeProfit*Point,"PD",2,0,Red);
      }

   for(cnt=0;cnt<total;cnt++) {
      OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
      if(OrderType()<=OP_SELL &&                         // check for opened position
         OrderSymbol()==Symbol()) {                      // check for symbol
         if(OrderType()==OP_BUY) {                       // long position is opened
            if(1!=1) {
               OrderClose(OrderTicket(),OrderLots(),Bid,3,Violet); // close position
               return(0);                                // exit
               }
                                                         // check for trailing stop
            if(TrailingStop>0) {
               if(Bid-OrderOpenPrice()>Point*TrailingStop) {
                  if(OrderStopLoss()<Bid-Point*TrailingStop) {
                     OrderModify(OrderTicket(),OrderOpenPrice(),Bid-Point*TrailingStop,OrderTakeProfit(),0,Green);
                     return(0);
                     }
                  }
               }
            }
         else {                                          // go to short position
                                                         // should it be closed?
            if(1!=1) {
               OrderClose(OrderTicket(),OrderLots(),Ask,3,Violet); // close position
               return(0);                                // exit
               }
                                                         // check for trailing stop
            if(TrailingStop>0) {
               if((OrderOpenPrice()-Ask)>(Point*TrailingStop)) {
                  if((OrderStopLoss()>(Ask+Point*TrailingStop)) || (OrderStopLoss()==0)) {
                     OrderModify(OrderTicket(),OrderOpenPrice(),Ask+Point*TrailingStop,OrderTakeProfit(),0,Red);
                     return(0);
                     }
                  }
               }
            }
         }
      }
   return(0);
}

Pessoalmente, à primeira vista, para mim, acabou por ser um quebra-cabeças sua idéia: se um não for igual a um, então feche a ordem...

Não observei o resto depois disso...

ZS e não tente, nem pense que é possível escrever uma EA normal em um ciclo...

 
OlegArH:

...E se você colocar ordem de compra, a função também fechará as ordens que já foram acionadas. (?)

...


Não. Dê uma olhada mais de perto. Uma ordem pendente acionada torna-se uma ordem de mercado - esta função não tem nada a ver com isso.

"Deleta uma ordem pendente previamente estabelecida. Devolve VERDADEIRO se a função for concluída com sucesso. Retornar FALSO

se a função não tiver sido concluída com sucesso. Ligue para GetLastError() para obter informações de erro".

1...443444445446447448449450451452453454455456457...652
Novo comentário