FórumSeções

SOMENTE VELA / BARRA - Como catalogar ou segregar uma vela? - POR FAVOR, ME CORRIJA! - página 2

Novo comentário
Wodzuuu:

Para aqueles que ainda não entenderam minha EA, escreva uma história: D hehehe


O evento são velas - apresenta várias opções para compra e venda ou fechamento.

Entendo mais olhando para seu código do que lendo o que você escreveu . . . . ;-)

Em vez de assistir a programas de TV como sua segunda função, você deveria considerar a leitura e compreensão do Livro;-)

O que você está tentando alcançar é direto e usado em muitas estratégias, mas seu código - e suas histórias - são confusos e parcialmente errados - pelo menos o código.... não tem certeza sobre as histórias.

//Pseudo code

if(NewBar) ResetSignals();                //Set all SignalxExecuted to false
if(SignalBuy1&&!SignalBuy1Executed&&OpenOrders()==1){
//do open buy position
  SignalBuy1Executed=true;                //Set Signal to exectued to prevent a reuse in the same bar
}

if(SignalBuy2&&!SignalBuy2Executed&&OpenOrders()==2){
//do open buy position
  SignalBuy2Executed=true;                //Set Signal to exectued to prevent a reuse in the same bar
}

SignalBuy1=CheckForOpenBull42();          //Check for Signal1 condition is true
SignalBuy2=CheckForOpenBull62();	  //Check for Signal2 condition is true	

if(OpenOrders()>0)CheckForClose();        //Check any order needs to be closed


//and so on.....

Por que você não tenta implementar apenas um sinal por enquanto e se concentra na codificação das funções necessárias? Se você tem um bom código para um sinal, provavelmente é fácil implementar os outros sinais e muitas funções já estão lá então.

Mais tarde você poderia usar Arrays e outras funções para simplificá-lo, mas a simplificação de seu código acima não deve ser seu maior problema neste momento.

[Excluído]

Kronin Yes! você me entende :), muitas das estratégias em uma EA.
Tenho que escrever 150 políticas e elas devem caminhar ao mesmo tempo no mesmo gráfico, e executar todas as estratégias ao mesmo tempo . Quando eu executar 150 EA ao mesmo tempo meu PC explodirá - eu acho que sim.

Depois disso, é inútil porque você pode ter apenas uma estratégia EA e muitas já dentro.

É claro que a estratégia não pode interferir umas com as outras e, quando executar uma, a segunda também pode funcionar, e eu posso ter executado a estratégia 1, e 3 e 5. e a estratégia (1,3,5) funcionando ao mesmo tempo.

Não vou escrever mais histórias :)


Meu código está errado - é conhecido, eu tentei colocar as duas estratégias em uma única EA, o código funciona bem , mas a totalidade não está funcionando bem

Seucódigo é muito interessante, vou estudá-lo, por favor me dê algum tempo

[Excluído]

Olá amigos, depois de um longo trabalho em código e através de informações do código Kronin é estruturado e funciona.
O código apresenta duas estratégias em um único EA


1.para um cenário de compra de velapequena é marcado com uma seta azul, são duas opções para COMPRAR
2. para a vela média cenário decompra a vela é marcado com uma seta vermelha, são três opções para COMPRAR

Eu tambémtenho uma situação onde 1 ponto = 1 pip é conveniente (para resolver o problema é para mais tarde)
Não usar opções se (NewBar) ResetSignals () porque eu acho que não são a causa do erro

Se você excluir uma função PARTE 2 no início() uma estratégia azul irá funcionar , e funciona bem
Se você executar o código PART1 e PART2 contendo duas estratégias de lançamento, mas elas se sobreporão. isto é um erro

Você poderia dar uma olhada Kronin

//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
#define MAGICMA  20050610

//+------------------------------------------------------------------+
//| Check NEW BAR     WORK AT BARS  M15                                 |
//+------------------------------------------------------------------+
/*

bool New_Bar = false;

bool Fun_New_Bar()                

   {                                
   static datetime New_Time=0;      
   New_Bar=false;                   
   if(New_Time!=Time[0])           
      {
      New_Time=Time[0];                
      New_Bar=true;                    
      }
   }
*/

//+------------------------------------------------------------------+
//| Calculate open positions    HOW MEANY OF THIS                    |
//+------------------------------------------------------------------+

int OpenOrders(string symbol)
  {
   int buys=0,sells=0;
//----
   for(int i=0;i<OrdersTotal();i++)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==false) break; 
      if(OrderSymbol()==Symbol() && OrderMagicNumber()==MAGICMA)
        {
         if(OrderType()==OP_BUY) buys++;
        }
     }
//---- return orders volume
   return(buys);
  }

//+------------------------------------------------------------------+
//| Calculate candle      These is condidion                         |
//+------------------------------------------------------------------+

// scenario 1 / EA 1  /  startegy 1 / blue

bool BULL4()
   {
   if(Close[1]-Open[1]>=4*Point && Close[1]-Open[1]<=5*Point)
   return(true);
   } 

// scenario 2 / EA 2  /  startegy 2 / red

bool BULL6()
   {
   if(Close[1]-Open[1]>=6*Point && Close[1]-Open[1]<=7*Point)
   return(true);
   }
      
//+------------------------------------------------------------------+
//| Check for open order conditions                                  |
//+------------------------------------------------------------------+

// Check for open for scenario 1 / EA 1  /  startegy 1 
 
bool OpenBULL41()
  {
   int    res;
   if(Bid==Close[1]+3*Point)  
     {
      res=OrderSend(Symbol(),OP_BUY,0.41,Ask,0,Close[1]-25*Point,0,"",MAGICMA,0,Blue);
      return (true);
     }
   return (false);  
  }
  
//----------------------------------- 
bool OpenBULL42()
  {
   int    res;
   if(Ask>OrderOpenPrice()+4*Point)  
     {
      res=OrderSend(Symbol(),OP_BUY,0.42,Ask,0,Close[1]-25*Point,0,"",MAGICMA,0,Blue);
      return;
     }
  }  
  
// Check for open for scenario 2 / EA 2  /  startegy 2
  
void OpenBULL61()
  {
   int    res;
   if(Bid==Close[1]+4*Point)  
     {
      res=OrderSend(Symbol(),OP_BUY,0.61,Ask,0,Close[1]-25*Point,0,"",MAGICMA,0,Red);
      return;
     }
  }
//-----------------------------------  
 
void OpenBULL62()
  {
   int    res;
   if(Ask>OrderOpenPrice()+2*Point)  
     {
      res=OrderSend(Symbol(),OP_BUY,0.62,Ask,0,Close[1]-25*Point,0,"",MAGICMA,0,Red);
      return;
     }
  }
  
//----------------------------------- 
void OpenBULL63()
  {
   int    res;
   if(Ask>OrderOpenPrice()+2*Point)  
     {
      res=OrderSend(Symbol(),OP_BUY,0.63,Ask,0,Close[1]-25*Point,0,"",MAGICMA,0,Red);
      return;
     }
  }
//+------------------------------------------------------------------+
//| Check for close order conditions                                 |
//+------------------------------------------------------------------+

void CheckForClose()
{
   RefreshRates();
   if(OrderOpenPrice()+4*Point< Ask)
   for (int i = OrdersTotal()-1; i >= 0;i--)       // I Have do -1 in "OrdersTotal()-1"
   {
      OrderSelect(i,SELECT_BY_POS,MODE_TRADES);
      if (OrderSymbol() == Symbol()) 
      {
         bool ticket = true;
         if (OrderType() == OP_BUY) ticket = OrderClose(OrderTicket(),OrderLots(),Bid,1,Black);

      }
   }
} 
/*
void CheckForClose2()
{
   RefreshRates();
   if(OrderOpenPrice()+6*Point< Ask)
   for (int i = OrdersTotal(); i >= 0;i--)
   {
      OrderSelect(i,SELECT_BY_POS,MODE_TRADES);
      if (OrderSymbol() == Symbol()) 
      {
         bool ticket = true;
         if (OrderType() == OP_BUY) ticket = OrderClose(OrderTicket(),OrderLots(),Bid,1,Black);

      }
   }
} 
*/
                                       
//+------------------------------------------------------------------+
//| Start function                                 |
//+------------------------------------------------------------------+
void start()
  {
      
//------------------                                                          PART1      
           bool SignalBULL41Executed=false;
            if(BULL4() && !SignalBULL41Executed && OpenOrders(Symbol())==0)
               {
               OpenBULL41();//do open buy position
               SignalBULL41Executed=true;
               }
               
            bool SignalBULL42Executed=false;
            if(!SignalBULL42Executed && OpenOrders(Symbol())==1)
               {
               OpenBULL42();//do open buy position
               SignalBULL42Executed=true;
               }  
               
            if(OpenOrders(Symbol())>0)CheckForClose();  
            
//------------------                                                          PART 2
            
            bool SignalBULL61Executed=false;
            if(BULL6() && !SignalBULL61Executed && OpenOrders(Symbol())==0)
               {
               OpenBULL61();//do open buy position
               SignalBULL61Executed=true;
               }
               
            bool SignalBULL62Executed=false;
            if(!SignalBULL62Executed && OpenOrders(Symbol())==1)
               {
               OpenBULL62();//do open buy position
               SignalBULL62Executed=true;
               }  
               
           bool SignalBULL63Executed=false;
            if(!SignalBULL63Executed && OpenOrders(Symbol())==2)
               {
               OpenBULL63();//do open buy position
               SignalBULL63Executed=true;
               }                
               
//            if(SignalBULL61Executed && OpenOrders(Symbol())>0)CheckForClose2();                    
            
  }
//+------------------------------------------------------------------+
Wodzuuu:

Não usar opções se (NewBar) ResetSignals () porque eu acho que não são a causa do erro

A forma como a função Fun_NewBar() é codificada não permitirá que você faça isso . . . você precisa fazer assim para que seja digitado bool e retorne um valor bool. .

bool Fun_New_Bar()                
   {                                
   static datetime New_Time=0;      
                     
   if(New_Time!=Time[0])           
      {
      New_Time=Time[0];                
      return(true);       // <---- we have a new bar so the function returns true
      }

   return(false);
   }
[Excluído]

Sim, você está certo e há int (já corrigido) que eu não vejo antes. Obrigado.
Mas esta função eu não uso, é como um texto

Não creio que isto se aplique a funções que me separam deduas estratégias sobrepostas. Eu não vejo a relação. Ou talvez eu esteja errado?

//Pseudo code

if(NewBar) ResetSignals();                //Set all SignalxExecuted to false
if(SignalBuy1&&!SignalBuy1Executed&&OpenOrders()==1){
//do open buy position
  SignalBuy1Executed=true;                //Set Signal to exectued to prevent a reuse in the same bar
}

É bom ver que você fez alguns progressos, mas ainda é um longo caminho a percorrer :-)

Você precisa consertar o que o RaptorUK afirmou acima. O restabelecimento dos Sinais é importante, caso contrário, a EA pára muito em breve com a abertura de novos negócios.
Sua implementação está errada. Se você reiniciar o SignalExecuted com cada sinal, isso não tem sentido. Talvez ele não abra mais negociações, porque você filtra também as OpenOrders. Mas, como sua estratégia permite ter múltiplas ordens abertas, posso imaginar que você também queira um algoritmo para fechar ordens, então você precisa do reset da bandeira SignalExecuted em uma nova barra (com sua implementação é inútil e você não precisa dela).

Se eu fizer com que você esteja correto, você não executará o BULL4 se o BULL6 também for verdadeiro. Ou em outras palavras, estratégia azul somente, se a estratégia vermelha não for válida, ou pequena vela somente se a vela média não for válida.

if(BULL4()&&!BULL6(){             // <--- only strategy BULL4 is valid, we are looking at a 'small' bar.
  if(!SignalBULL41Executed && OpenOrders(Symbol())==0){
    OpenBULL41();//do open buy position
    SignalBULL41Executed=true;
  }
  if(!SignalBULL42Executed && OpenOrders(Symbol())==1){
    OpenBULL42();//do open buy position
    SignalBULL42Executed=true;
}

Próximos passos:

// Check for open for scenario 1 / EA 1  /  startegy 1 
 
bool OpenBULL41()
  {
   int    res;
   if(Bid==Close[1]+3*Point)  					                       // <--- equal makes no sense here and you should not compare doubles for equality. 
                                                                                                  Read (again): https://www.mql5.com/en/forum/136997 
     {
      res=OrderSend(Symbol(),OP_BUY,0.41,Ask,0,Close[1]-25*Point,0,"",MAGICMA,0,Blue); // <--- what is your plan with res? You are aware, it does include the ticket 
                                                                                                  number or -1, aren't you?

      return (true);                                                                   // <--- Even if OrderSend() fails you return true.
     }
   return (false);  
  }
  
//----------------------------------- 
bool OpenBULL42()
  {
   int    res;
   if(Ask>OrderOpenPrice()+4*Point) 							// <--- OrderOpenPrice() from a somewhere selected order may or may not work here 
                                                                                                  (may because only one order is open), but it is not nice coded. 
     {
      res=OrderSend(Symbol(),OP_BUY,0.42,Ask,0,Close[1]-25*Point,0,"",MAGICMA,0,Blue);
      return;
     }
  }  

A função CheckForClose() tem praticamente os mesmos problemas e adicionalmente nenhum filtro para o número mágico. Também aqui, o OrderOpenPrice() selecionado de um pedido na contagem de compras poderia terminar fechando o pedido errado (não tenho certeza de que funcione de fato).
Por favor, leia também novamente o que o Raptor escreveu na primeira página deste tópico.

A partir de seus posts e dos comentários no código, tenho a sensação de que você quer saber qual ordem pertence a qual estratégia. Para conseguir isso, você pode definir um segundo número mágico para a segunda estratégia. Então é mais fácil fechar as ordens de acordo com a estratégia em que foram abertas.

kronin:

Próximos passos:

A partir de seus posts e dos comentários no código, tenho a sensação de que você quer saber qual ordem pertence a qual estratégia. Para conseguir isso, você pode definir um segundo número mágico para a segunda estratégia. Então é mais fácil fechar as ordens de acordo com a estratégia em que foram abertas.

Não seria mais simples executar 2 estratégias diferentes em 2 EAs separados, cada um em seu próprio gráfico?
RaptorUK:
Não seria mais simples executar 2 estratégias diferentes em 2 EAs separados, cada um em seu próprio gráfico?

Sim, para 2, 3, 4, 5... acordado. Mas de acordo com as histórias e esta:"Tenho que escrever 150 políticas e elas devem caminhar ao mesmo tempo no mesmo gráfico, e executar todas as estratégias de uma só vez". Quando eu executar 150 EA aomesmo tempo meu PC vai explodir - eu acho que sim."
Eu acho que ele planeja executar muitas estratégias mais em uma EA....

12345
Novo comentário