Erro 'array out of range'

Novo comentário
 
Boa noite amigos!

Alguém consegue me ajudar com esse erro?

Comecei a fazer um robô de forma amadora mesmo, pra testar algumas ideias e até que funciona legal, porém começou a aparecer um erro e não consegui localizar...

Vou postar o código abaixo, acredito que seja algum problema com Arrays com copyticks, começou a aparecer quando usei ArrayMaximum e ArrayMinimum, até removi tudo mas não voltou a funcionar direito.


#include <Trade\Trade.mqh>
CTrade mTrade;

//+------------------------------------------------------------------+ 
//| Declaração das variáveis                                         | 
//+------------------------------------------------------------------+ 

MqlRates          bar[];
MqlTick           precoTick[];

input             int      smaCurta =  8; // SMA Curta
input             int      smaRapida = 21; // SMA Rápida
input             int      smaLonga = 200; // SMA Longa
input             int      adxPeriodo = 8; // ADX Período
input             int      nivelAdx = 32; // Setup Faslo ADX > Nível

// Melhor configuração EUR USD com TP de 300 e stop de low ou high da ultima barra + 5pips
input             double   lote = 0.10; // Volume Lote
input             int      takeProfit = 100; // Take Profit
input             int      stopLoss = 0; // Pips + Stop Loss
input             double   gatilhoBE = 20; // Gatilho Break Even

input             ulong    magic_number = 123456; // Número Mágico
input             ulong    desvPts = 50; // Desvio em Pontos
input             ENUM_ORDER_TYPE_FILLING preenchimento = ORDER_FILLING_FOK; // Preenchimnento da Ordem

// Array para armazenar os dados da Média Móvel
double            smaCurtaArray[];
double            smaRapidaArray[];
double            smaLongaArray[];
double            adxArray[];
double            adMenosArray[];
double            adMaisArray[];
double            stopCompra;
double            stopVenda;

double            PRC;
double            STL;
double            TKP;

// Handle para receber o método da Média Móvel
int               smaCurtaHandle;
int               smaRapidaHandle;
int               smaLongaHandle;
int               smaLastPriceHandle;
int               adxHandle;

bool              posAberta;
bool              ordPendente;
bool              beAtivo;


//+------------------------------------------------------------------+ 
//| Função Oninit                                                           | 
//+------------------------------------------------------------------+ 


int OnInit()
   {
   
      smaCurtaHandle    =  iMA(_Symbol, _Period, smaCurta, 0, MODE_SMA, PRICE_CLOSE);        
      if (smaCurtaHandle==INVALID_HANDLE)
         {
            Print("Erro ao criar média móvel curta - erro!", GetLastError());
            return(INIT_FAILED);
         }
      smaRapidaHandle   =  iMA(_Symbol, _Period, smaRapida, 0, MODE_SMA, PRICE_CLOSE);       
      if (smaRapidaHandle==INVALID_HANDLE)
         {
            Print("Erro ao criar média móvel rápida - erro!", GetLastError());
            return(INIT_FAILED);
         }
      smaLongaHandle    =  iMA(_Symbol, _Period, smaLonga, 0, MODE_SMA, PRICE_CLOSE);        
      if (smaLongaHandle==INVALID_HANDLE)
         {
            Print("Erro ao criar média móvel longa - erro!", GetLastError());
            return(INIT_FAILED);
         }
      adxHandle = iADX(_Symbol, _Period, adxPeriodo);
      if(adxHandle ==INVALID_HANDLE)
         {
            printf("Erro ao criar ADX!");
            return(INIT_FAILED);
         }

      ArraySetAsSeries(bar, true);
      ArraySetAsSeries(precoTick, true);
      
      ArraySetAsSeries(smaCurtaArray, true);
      ArraySetAsSeries(smaRapidaArray, true);
      ArraySetAsSeries(smaLongaArray, true);
      ArraySetAsSeries(adxArray, true);
      ArraySetAsSeries(adMenosArray, true);
      ArraySetAsSeries(adMaisArray, true);

      mTrade.SetTypeFilling(preenchimento);             
      mTrade.SetDeviationInPoints(desvPts);              
      mTrade.SetExpertMagicNumber(magic_number);         
      
      return(INIT_SUCCEEDED);
   
   }
//---------

//+------------------------------------------------------------------+ 
//| Função OnTick                                                    | 
//+------------------------------------------------------------------+ 
// Vai executação a função em toda mudança de tick

void OnTick()
  {
      
      if(!SymbolInfoTick(_Symbol, precoTick[0]))
         {
            Alert("Erro ao obter informações de preços: ", GetLastError());
            return;
         }
      
      if (CopyBuffer(smaCurtaHandle, 0, 0, 10, smaCurtaArray)<0)
         {
            Print("Erro ao copiar média móvel curta - erro!", GetLastError());
            return;
         }
      if (CopyBuffer(smaRapidaHandle, 0, 0, 10, smaRapidaArray)<0)
         {
            Print("Erro ao copiar média móvel rápida - erro!", GetLastError());
            return;
         } 
      if (CopyBuffer(smaLongaHandle, 0, 0, 10, smaLongaArray)<0)
         {
            Print("Erro ao copiar média móvel longa - erro!", GetLastError());
            return;
         }
       if (CopyBuffer(adxHandle, MAIN_LINE, 0, 3, adxArray)<0)
         {
            Print("Erro ao copiar adx - erro!", GetLastError());
            return;
         }
       if (CopyBuffer(adxHandle, PLUSDI_LINE, 0, 3, adMaisArray)<0)
         {
            Print("Erro ao copiar ad+ - erro!", GetLastError());
            return;
         }
        if (CopyBuffer(adxHandle, MINUSDI_LINE, 0, 3, adMenosArray)<0)
         {
            Print("Erro ao copiar ad- - erro!", GetLastError());
            return;
         }
         
        int Mybars = Bars(_Symbol, _Period);
        
        if( Mybars<adxPeriodo)
         {
            Alert("Não existem barras suficientes para calcular adx!");
            return;
         }

     
      if (CopyRates(_Symbol, PERIOD_CURRENT, 0, 10, bar)<0)  
         {
            Print("Erro ao copiar período das barras - erro!", GetLastError());
            return;
         }
         
      if (CopyTicks(_Symbol, precoTick, COPY_TICKS_TRADE, 0, 10)<0)  
         {
            Print("Erro ao copiar precoTick - erro!", GetLastError());
            return;
         }
         
         
            
//-----------------------------------------   
         
      
         
      posAberta = false;
      for(int i = PositionsTotal()-1; i>=0; i--)
         {
            string symbol = PositionGetSymbol(i);
            ulong magic = PositionGetInteger(POSITION_MAGIC);
            if(symbol == _Symbol && magic==magic_number)
               {
                  posAberta = true;
                  break;
               }
         }
         
      ordPendente = false;
      for(int i = OrdersTotal()-1; i>=0; i--)
         {
            ulong    ticket   = OrderGetTicket(i);
            string   symbol   = OrderGetString(ORDER_SYMBOL);
            ulong    magic    = PositionGetInteger(POSITION_MAGIC);
            if(symbol == _Symbol && magic==magic_number)
               {
                  ordPendente = true;
                  break;
               }
         }
//+------------------------------------------------------------------+ 
//| Lógica de setup falso                                            | 
//+------------------------------------------------------------------+       
      
   bool setupTrue = (
   
      adxArray[0] > nivelAdx 
      && adxArray[0] > adxArray[1]

   );
   
   
        
//+------------------------------------------------------------------+ 
//| Lógica de compra                                                 | 
//+------------------------------------------------------------------+ 

   
bool LogicaCompra = (   

            setupTrue
         && bar[0].tick_volume > bar[1].tick_volume   

         && bar[3].close < bar[3].open
         && bar[2].close < bar[2].open
         && bar[1].close < bar[1].open
         
         && precoTick[1].last  ==  (bar[1].close + bar[1].open) / 2
         && precoTick[0].last  >  precoTick[1].last
         
         && precoTick[0].last >   smaRapidaArray[0]

);

      
//+------------------------------------------------------------------+ 
//| Lógica de venda                                                 | 
//+------------------------------------------------------------------+ 

  
bool LogicaVenda = (false);   

   
//+------------------------------------------------------------------+ 
//| Lógica de Stops                                                  | 
//+------------------------------------------------------------------+    

       stopCompra    =     bar[1].low;
       stopVenda     =     bar[1].high;
    
//---------------------------------------------------------------         



      if(!posAberta)
         {
            beAtivo = false;
         }
      if(posAberta && !beAtivo)
         {
            BreakEven(precoTick[0].last);   
         }   
//---         
      
      if (
            (LogicaCompra) 
            && !posAberta
            && !ordPendente)
            {
      
            PRC = NormalizeDouble(precoTick[0].ask, _Digits);
            STL = NormalizeDouble(stopCompra, _Digits)-stopLoss*_Point;
            TKP = NormalizeDouble(precoTick[0].ask, _Digits)+takeProfit*_Point;
            
            if (mTrade.Buy(lote, _Symbol, PRC, STL, TKP, NULL))
               {
                  Print("Ordem de compra sem falha. ResultRecode. ", mTrade.ResultRetcode(), "RetCodeDescription: ", mTrade.ResultRetcodeDescription());
               }
             else
               {
                  Print("Ordem de compra com falha. ResultRecode. ", mTrade.ResultRetcode(), "RetCodeDescription: ", mTrade.ResultRetcodeDescription());
               }
            } 

      else if (
            (LogicaVenda) 
            && !posAberta
            && !ordPendente)
            {
      
            PRC = NormalizeDouble(precoTick[0].bid, _Digits);
            STL = NormalizeDouble(stopVenda, _Digits)+stopLoss*_Point;
            TKP = NormalizeDouble(precoTick[0].bid, _Digits)-takeProfit*_Point;
            
            if (mTrade.Sell(lote, _Symbol, PRC, STL, TKP, NULL))
               {
                  Print("Ordem de venda sem falha. ResultRecode. ", mTrade.ResultRetcode(), "RetCodeDescription: ", mTrade.ResultRetcodeDescription());
               }
             else
               {
                  Print("Ordem de venda com falha. ResultRecode. ", mTrade.ResultRetcode(), "RetCodeDescription: ", mTrade.ResultRetcodeDescription());
               }
            } 

  }
  
  
  

 //---

 void BreakEven(double preco)
   {
      for(int i = PositionsTotal()-1; i>=0; i--)
         {
            string symbol = PositionGetSymbol(i);
            ulong magic = PositionGetInteger(POSITION_MAGIC);
            if(symbol == _Symbol && magic == magic_number)
               {
                  ulong PositionTicket = PositionGetInteger(POSITION_TICKET);
                  double PrecoEntrada = PositionGetDouble(POSITION_PRICE_OPEN);
                  double TakeProfitCorrente = PositionGetDouble(POSITION_TP);
                  if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY)
                     {
                        if(preco >= (PrecoEntrada + gatilhoBE))
                           {
                              if(mTrade.PositionModify(PositionTicket, PrecoEntrada, TakeProfitCorrente))
                                 {
                                    Print("BrakEven - sem falha. ResultRetcode: ", mTrade.ResultRetcode(), ", RetcodeDescription: ", mTrade.ResultRetcodeDescription());
                                     beAtivo = true; // Para não ser executrado toda vez a cada tick
                                 }
                               else 
                                 {
                                    Print("BrakEven - com falha. ResultRetcode: ", mTrade.ResultRetcode(), ", RetcodeDescription: ", mTrade.ResultRetcodeDescription());
                                     beAtivo = true; // Para não ser executrado toda vez a cada tick
                                 }
                           }
                     }
                  else if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL)
                     {
                        if(preco <= (PrecoEntrada - gatilhoBE))
                           {
                              if(mTrade.PositionModify(PositionTicket, PrecoEntrada, TakeProfitCorrente))
                                 {
                                    Print("BrakEven - sem falha. ResultRetcode: ", mTrade.ResultRetcode(), ", RetcodeDescription: ", mTrade.ResultRetcodeDescription());
                                    beAtivo = true; // Para não ser executrado toda vez a cada tick
                                 }
                               else 
                                 {
                                    Print("BrakEven - com falha. ResultRetcode: ", mTrade.ResultRetcode(), ", RetcodeDescription: ", mTrade.ResultRetcodeDescription());
                                    beAtivo = true; // Para não ser executrado toda vez a cada tick
                                 }
                           }
                     }   
               } 
         }
   }
   
   

  
 
luishmx1:
Boa noite amigos!

Alguém consegue me ajudar com esse erro?

Comecei a fazer um robô de forma amadora mesmo, pra testar algumas ideias e até que funciona legal, porém começou a aparecer um erro e não consegui localizar...

Vou postar o código abaixo, acredito que seja algum problema com Arrays com copyticks, começou a aparecer quando usei ArrayMaximum e ArrayMinimum, até removi tudo mas não voltou a funcionar direito.


Tira teu primeiro if do onTick. Nele tu nao tem um array alocado. Quando tenta acessar a posição zero vai dar o erro mencionado. Ja os copyrates/copyticks verifica que o array nao existe e faz a alocação pra voce.

Você pode manter o if se alocar o array ou passar a usar uma variavel que ja esta alocada (nao precisaria ser um array, so n confundir com a outra).
 
Acabei refazendo ele todo, tinha muita alocação de buffer....


vlw parceiro!
Novo comentário
Razão: