FórumSeções

Ea está criando várias ordens pendentes/limitadas [Help pls] - página 4

Novo comentário
cashcube:

Além disso, o comércio inverso em encomendas paradas também não está funcionando.

Você já foi informado de que isso não é confiável

            if(Volume[0]>1) return(0);

Isto não faz nada

//+------------------------------------------------------------------+
//| OnTick function                                                  |
//+------------------------------------------------------------------+
void OnTick(){
   static datetime timeCur; datetime timePre = timeCur; timeCur=Time[0];
   bool isNewBar = timeCur != timePre;
   if(isNewBar){ 
     return; // Once per bar
   }
   return; // every tick
}  

Você retorna se for um novo bar e também retorna se não for, então você sempre retorna sem fazer nada.

Quando você encontra uma nova barra, você precisa repor o valor.

void OnTick(){
   datetime timeCur=Time[0]; 
   static datetime timePre = timeCur;
   bool isNewBar = timeCur != timePre;
   if(isNewBar){ 
     timePre=timeCur;
     //Do what you want at each new bar // Once per bar
   }
   //Do other stuff that you may need to do every tick
   return; // every tick
}  

Seu código para verificar a última ordem assume que o índice mais alto na história da ordem é o último negócio fechado. Não tenho certeza se isto é sempre verdade.

[Excluído]

Ok, eu apliquei o código...mas quando eu tento chamar a função de início a cada nova barra...ela não atende a nenhuma ordem...

void OnTick(){
   datetime timeCur=Time[0]; 
   static datetime timePre = timeCur;
   bool isNewBar = timeCur != timePre;
   if(isNewBar){ 
     timePre=timeCur;
     //Do what you want at each new bar // Once per bar
start();
   }
   //Do other stuff that you may need to do every tick
   return; // every tick
}  

Mesmo se eu adicionar a função buyCall & sellcall dentro da nova zona de barras...& start() dentro da zona de marcação...isto cria vários pedidos.

Você não deve ter OnTick() e start(), não consigo adivinhar o que isso vai servir.
[Excluído]
Aqui está o código completo para a EA.
// Init function
int init()
{

int CalcDigits = (int)MarketInfo(Symbol(),MODE_DIGITS);

if(CalcDigits == 2 || CalcDigits == 4) CalcSlippage = SlippagePips;
else if(CalcDigits == 3 || CalcDigits == 5) CalcSlippage = SlippagePips * 10;      


if(CalcDigits == 2 || CalcDigits == 3) CalcPoint1 = 0.01;
else if(CalcDigits == 4 || CalcDigits == 5) CalcPoint1 = 0.0001;
      
UsePoint = CalcPoint;
UseSlippage = (int) CalcSlippage; 
return (0);
}
//+------------------------------------------------------------------+

int start()
{

double open = iOpen(NULL,PERIOD_H1,0);        // current candles Open
int CH = TimeHour(TimeCurrent()); // current hour    
double LO = iOpen(NULL,PERIOD_H1,1);
double LC = iClose(NULL,PERIOD_H1,1);
  
//----------------------------  Calculation
double CalcDigits = MarketInfo(Symbol(),MODE_DIGITS);
      {
      if(CalcDigits == 2 || CalcDigits == 3) CalcPoint = 100;
      else if (CalcDigits == 4 || CalcDigits == 5) CalcPoint = 10000;
      }
           
///----------------------------------------------

FS = Split(open);

//-------- 2nd part of Calculation----------------//

S0 = open - (double(FS)* CalcPoint1);
S1 = open - (double((FS*2))* CalcPoint1);
S2 = open - (double((FS*4))* CalcPoint1);
S3 = open - (double((FS*8))* CalcPoint1); 
S4 = open - (double((FS*16))* CalcPoint1);
S5 = open - (double((FS*32))* CalcPoint1);
 
R0 = open + (double(FS)* CalcPoint1);
R1 = open + (double((FS*2))* CalcPoint1);
R2 = open + (double((FS*4))* CalcPoint1);
R3 = open + (double((FS*8))* CalcPoint1); 
R4 = open + (double((FS*16))* CalcPoint1); 
R5 = open + (double((FS*32))* CalcPoint1);  


//---------2nd part-------------------//
   P1 = Split(S0);
   P2 = Split(S1);
   P3 = Split(S2);
   P4 = Split(S3);
   P5 = Split(S4);
   P6 = Split(S5);
   P7 = Split(R0);
   P8 = Split(R1);
   P9 = Split(R2);
   P10 = Split(R3);
   P11 = Split(R4);
   P12 = Split(R5);

 //--------------------
   if(FS == P1 && LC > LO)  BuyCall(S0);
   if(FS == P2 && LC > LO)  BuyCall(S1);
   if(FS == P3 && LC > LO)  BuyCall(S2);
   if( FS == P4 && LC > LO) BuyCall(S3);   
   if( FS == P5 && LC > LO) BuyCall(S4);
   if( FS == P6 && LC > LO) BuyCall(S5);
   if( FS == P7 && LC < LO) SellCall(R0);
   if( FS == P8 && LC < LO) SellCall(R1);
   if( FS == P9 && LC < LO) SellCall(R2);
   if( FS == P10 && LC < LO) SellCall(R3);
   if( FS == P11 && LC < LO) SellCall(R4);                    
   if( FS == P12 && LC < LO) SellCall(R5);     
 
   //-----------------End of experiment----------

//-------------------Reverse trade for Sell
     for(xxx =OrdersHistoryTotal()-1;xxx >=0;xxx --)
     {
         if(OrderSelect(xxx, SELECT_BY_POS,MODE_HISTORY))
         {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()== MagicNumber)
          
          //for sell order reverse
          if(OrderType()==OP_SELL && OrderProfit()<0)    
          { 
             if (OrderOpenPrice()== R0 || OrderOpenPrice()== R1 ||OrderOpenPrice()== R2 ||OrderOpenPrice()== R3 ||OrderOpenPrice()== R4 ||OrderOpenPrice()== R5 )
               {
      
            BuyStopLoss = Ask - (StopLoss * CalcPoint1);
            BuyTakeProfit = Ask + (TakeProfit * CalcPoint1);
            BuyTicket = OrderSend(Symbol(),OP_BUY,LotSize,Ask,UseSlippage,BuyStopLoss,BuyTakeProfit,"Buy Reverse Order",MagicNumber,0,Green);
          }
          break; 
          }
          }
          } 
   
  //-------------Reverse trade for buy
     for(xx =OrdersHistoryTotal()-1;xx >=0;xx --)
     {
         if(OrderSelect(xx, SELECT_BY_POS,MODE_HISTORY))
         {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()== MagicNumber)
           {
          //for buy order reverse
          if(OrderType()==OP_BUY && OrderProfit()<0)
          { 
           if (OrderOpenPrice()== S0 || OrderOpenPrice()== S1 ||OrderOpenPrice()== S2 ||OrderOpenPrice()== S3 ||OrderOpenPrice()== S4 ||OrderOpenPrice()== S5 )
               {         
    
            SellStopLoss = Bid + (StopLoss * CalcPoint1);
            SellTakeProfit = Bid - (TakeProfit * CalcPoint1);
            SellTicket = OrderSend(Symbol(),OP_SELL,LotSize,Bid,UseSlippage,SellStopLoss,SellTakeProfit,"Sell Reverse Order",MagicNumber,0,Red); 
          
          }
         break; 
          }
          }
          }
     } 

//------WHODER CODE for Order Close/Delete in every hour -------

for(int pos = OrdersTotal()-1; pos >= 0 ; pos--) 
if (OrderSelect(pos, SELECT_BY_POS)  &&  OrderMagicNumber() == MagicNumber &&  OrderSymbol() == Symbol() )
{   
     if(OrderType()==OP_SELL && OrderMagicNumber() == MagicNumber &&  OrderSymbol() == Symbol())
     {
     int k = (TimeHour((int)OrderOpenTime())*60) + TimeMinute((int)OrderOpenTime()); 
     int m = (TimeHour((int)TimeCurrent())*60) +  TimeMinute((int)TimeCurrent());    
     if (m >= k+59)
      bool closed = OrderClose( OrderTicket(), OrderLots(), OrderClosePrice(),UseSlippage,Blue);
     }
     //--------------
      if(OrderType()==OP_BUY && OrderMagicNumber() == MagicNumber &&  OrderSymbol() == Symbol())
     {
     int k1 = (TimeHour((int)OrderOpenTime())*60) + TimeMinute((int)OrderOpenTime()); 
    int m1 = (TimeHour((int)TimeCurrent())*60) +  TimeMinute((int)TimeCurrent());    
     if (m1 >= k1+59)
     bool closed = OrderClose( OrderTicket(), OrderLots(), OrderClosePrice(),UseSlippage,Blue);
    }        
}   

   
return(0);
}

Junto com esta função inicial...eu tenho a seguinte função extra...que é chamada na função principal.

int split(duplo x)

BuyCall(duplo BC) nulo

SellCall(duplo SC)

e, por último, a função onTick, sobre a qual estou confuso...como defini-la de uma forma...que não repetirá ordens pendentes tique por tique

...apenas uma seqüência de ordens pendentes em cada hora...além disso, ele verificará se alguma ordem pendente foi interrompida

...então abrirá outro comércio em direção oposta...mas apenas uma seqüência por hora.

Por favor, ajude sempre na mesma área...mas obviamente quer aprender...para que eu não precise fazer perguntas bobas no futuro

...quero esclarecer meu conceito...(

Obrigado por seu tempo.

Isto não atribui um valor a cada tick, apenas uma vez na carga.
static datetime timePre = timeCur;
simplificar
void OnTick(){
   static datetime timeCur;
   datetime timePre = timeCur; timeCur=Time[0]; 
   bool isNewBar = timeCur != timePre;
1234
Novo comentário