Duvida importação ICUSTOM MT5

 

Estou tentando importar um indicador e quando coloco para rodar apresenta o seguinte erro

2020.10.21 18:49:15.861 2020.10.01 09:00:00 array out of range in 'keltner_channel315.mq5' (271,47)

para chamar o indicado estou utilizando  handle = iCustom(Symbol(),PERIOD_CURRENT,"keltner_channel315.ex5",20,MODE_SMA,3.0);

Abaixo segue o código:


 #property copyright "mladen"

   #property link      "www.forex-tsd.com"


//------------------------------------------------------------------


#property indicator_chart_window

#property indicator_buffers 10

#property indicator_plots   4


#property indicator_label1  "Average"

#property indicator_type1   DRAW_COLOR_LINE

#property indicator_color1  clrDeepSkyBlue,clrPaleVioletRed

#property indicator_style1  STYLE_SOLID

#property indicator_width1  2

#property indicator_label2  "Upper band"

#property indicator_type2   DRAW_LINE

#property indicator_color2  C'216,237,243'

#property indicator_style2  STYLE_SOLID

#property indicator_width2  2

#property indicator_label3  "Lower band"

#property indicator_type3   DRAW_LINE

#property indicator_color3  clrMistyRose

#property indicator_style3  STYLE_SOLID

#property indicator_width3  2

#property indicator_label4  "Keltner MA trend"

#property indicator_type4   DRAW_COLOR_BARS

#property indicator_color4  clrDeepSkyBlue,clrPaleVioletRed

#property indicator_style4  STYLE_SOLID


//

//

//

//

//


enum enPrices

{

   pr_close,      // Close

   pr_open,       // Open

   pr_high,       // High

   pr_low,        // Low

   pr_median,     // Median

   pr_typical,    // Typical

   pr_weighted,   // Weighted

   pr_haclose,    // Heiken ashi close

   pr_haopen ,    // Heiken ashi open

   pr_hahigh,     // Heiken ashi high

   pr_halow,      // Heiken ashi low

   pr_hamedian,   // Heiken ashi median

   pr_hatypical,  // Heiken ashi typical

   pr_haweighted, // Heiken ashi weighted

   pr_haaverage   // Heiken ashi average

};


enum enMaModes

{

   ma_Simple,  // Simple moving average

   ma_Expo     // Exponential moving average

};

enum enMaVisble

{

   mv_Visible,    // Middle line visible

   mv_NotVisible  // Middle line not visible

};


//

//

//

//

//


enum enCandleMode

{

   cm_None,   // Do not draw candles nor bars

   cm_Bars,   // Draw as bars

   cm_Candles // Draw as candles

};


enum enAtrMode

{

   atr_Rng,   // Calculate using range

   atr_Atr    // Calculate using ATR

};


//

//

//

//

//


input ENUM_TIMEFRAMES    TimeFrame       = PERIOD_CURRENT; // Time frame

input int                MAPeriod        = 20;             // Moving average period

input enMaModes          MAMethod        = ma_Simple;      // Moving average type

input enMaVisble         MAVisible       = mv_Visible;     // Midlle line visible ?

input enPrices           Price           = pr_typical;     // Moving average price 

input color              MaColorUp       = clrDeepSkyBlue; // Color for slope up

input color              MaColorDown     = clrPaleVioletRed; // Color for slope down

input int                AtrPeriod       = 20;             // Range period

input double             AtrMultiplier   = 2.0;            // Range multiplier

input enAtrMode          AtrMode         = atr_Rng;        // Range calculating mode 

input enCandleMode       ViewBars        = cm_None;        // View bars as :

input bool               Interpolate     = true;           // Interpolate mtf data


//

//

//

//

//


double channelBo[];

double channelBh[];

double channelBl[];

double channelBc[];

double channelUp[];

double channelDn[];

double ma[];

double colorBuffer[];

double colorBufferb[];

double countBuffer[];

ENUM_TIMEFRAMES timeFrame;

int             mtfHandle;

int             atrHandle;

bool            calculating;


//------------------------------------------------------------------

//                                                                  

//------------------------------------------------------------------

//

//

//

//

//


int OnInit()

{

   SetIndexBuffer(0,ma,INDICATOR_DATA);

   SetIndexBuffer(1,colorBuffer,INDICATOR_COLOR_INDEX); 

   SetIndexBuffer(2,channelUp,INDICATOR_DATA);

   SetIndexBuffer(3,channelDn,INDICATOR_DATA);

   SetIndexBuffer(4,channelBo,INDICATOR_DATA); 

   SetIndexBuffer(5,channelBh,INDICATOR_DATA);

   SetIndexBuffer(6,channelBl,INDICATOR_DATA);

   SetIndexBuffer(7,channelBc,INDICATOR_DATA);

   SetIndexBuffer(8,colorBufferb,INDICATOR_COLOR_INDEX); 

   SetIndexBuffer(9,countBuffer,INDICATOR_CALCULATIONS); 


   int type = DRAW_NONE;

         if (ViewBars== cm_Bars)    type = DRAW_COLOR_BARS;

         if (ViewBars== cm_Candles) type = DRAW_COLOR_CANDLES;

               PlotIndexSetInteger(3,PLOT_DRAW_TYPE,type);


         if (MAVisible==mv_NotVisible)

         {

            PlotIndexSetInteger(0,PLOT_LINE_COLOR,0,clrNONE);

            PlotIndexSetInteger(0,PLOT_LINE_COLOR,1,clrNONE);

         }               

         else

         {

            PlotIndexSetInteger(0,PLOT_LINE_COLOR,0,MaColorUp);

            PlotIndexSetInteger(0,PLOT_LINE_COLOR,1,MaColorDown);

         }               

         


   //

   //

   //

   //

   //

         

   timeFrame   = MathMax(_Period,TimeFrame);

   calculating = (timeFrame==_Period);

   if (!calculating)

         mtfHandle = iCustom(NULL,timeFrame,getIndicatorName(),PERIOD_CURRENT,MAPeriod,MAMethod,MAVisible,Price,MaColorUp,MaColorDown,AtrPeriod,AtrMultiplier,AtrMode);


   IndicatorSetString(INDICATOR_SHORTNAME,getPeriodToString(timeFrame)+" Keltner channel ("+string(MAPeriod)+","+string(AtrPeriod)+")");

   return(0);

}


//------------------------------------------------------------------

//                                                                  

//------------------------------------------------------------------

//

//

//

//

//


int OnCalculate(const int rates_total,

                const int prev_calculated,

                const datetime& time[],

                const double& open[],

                const double& high[],

                const double& low[],

                const double& close[],

                const long& tick_volume[],

                const long& volume[],

                const int& spread[])

{


   //

   //

   //

   //

   //

   

   if (calculating)

   {

         for (int i=(int)MathMax(prev_calculated-1,1); i<rates_total; i++)

         {

            double atr=0;

            for (int k=0; k<AtrPeriod && (i-k-1)>=0; k++)

               if (AtrMode==atr_Atr)

                     atr += MathMax(high[i-k],close[i-k-1])-MathMin(low[i-k],close[i-k-1]);

               else  atr += high[i-k]-low[i-k];

                     atr /= AtrPeriod;

            

               //

               //

               //

               //

               //


                  double price = getPrice(Price,open,close,high,low,i,rates_total);

                  switch(MAMethod)

                  {

                     case ma_Simple: ma[i] = iSma(price,MAPeriod,i,rates_total); break;

                     case ma_Expo:   ma[i] = iEma(price,MAPeriod,i,rates_total); break;

                  }


               //

               //

               //

               //

               //

               

               colorBuffer[i] = colorBuffer[i-1];

                  if (ma[i]>ma[i-1]) colorBuffer[i]=0;

                  if (ma[i]<ma[i-1]) colorBuffer[i]=1;

               colorBufferb[i] = colorBuffer[i];

               channelUp[i] = ma[i]+atr*AtrMultiplier;

               channelDn[i] = ma[i]-atr*AtrMultiplier;

               channelBo[i] = open[i];

               channelBh[i] = high[i];

               channelBl[i] = low[i];

               channelBc[i] = close[i];

         }      

         countBuffer[rates_total-1] = MathMax(rates_total-prev_calculated+1,1);

         return(rates_total);

   }

   

   //

   //

   //

   //

   //

   

   if (BarsCalculated(mtfHandle)<=0) return(0);

      datetime times[]; 

      datetime startTime = time[0]-PeriodSeconds(timeFrame);

      datetime endTime   = time[rates_total-1];

         int bars = CopyTime(NULL,timeFrame,startTime,endTime,times);

        

         if (times[0]>time[0] || bars<1 || bars>rates_total) return(rates_total);

               double tma[];   CopyBuffer(mtfHandle,0,0,bars,tma);

               double tcolo[]; CopyBuffer(mtfHandle,1,0,bars,tcolo);

               double tchnu[]; CopyBuffer(mtfHandle,2,0,bars,tchnu);

               double tchnd[]; CopyBuffer(mtfHandle,3,0,bars,tchnd);

               double count[]; CopyBuffer(mtfHandle,9,0,bars,count);

         int maxb = (int)MathMax(MathMin(count[bars-1]*PeriodSeconds(timeFrame)/PeriodSeconds(_Period),rates_total-1),1);


         //

         //

         //

         //

         //

         

         for(int i=(int)MathMax(prev_calculated-maxb,0); i<rates_total; i++)

         {

            int d = dateArrayBsearch(times,time[i],bars);

            if (d > -1 && d < bars)

            {

               ma[i]           = tma[d];

               channelUp[i]    = tchnu[d];

               channelDn[i]    = tchnd[d];

               colorBuffer[i]  = tcolo[d];

               colorBufferb[i] = tcolo[d];

                  channelBo[i] = open[i];

                  channelBh[i] = high[i];

                  channelBl[i] = low[i];

                  channelBc[i] = close[i];

            }

            if (!Interpolate) continue;

        

            //

            //

            //

            //

            //

         

            int j=MathMin(i+1,rates_total-1);


            if (d!=dateArrayBsearch(times,time[j],bars) || i==j)

            {

               int n,k;

                  for(n = 1; (i-n)> 0 && time[i-n] >= times[d] && n<(PeriodSeconds(timeFrame)/PeriodSeconds(_Period)); n++) continue;

                  for(k = 1; (i-k)>=0 && k<n; k++)

                  {

                     ma[i-k]        = ma[i]        + (ma[i-n]        - ma[i]       )*(double)k/n;

                     channelUp[i-k] = channelUp[i] + (channelUp[i-n] - channelUp[i])*(double)k/n;

                     channelDn[i-k] = channelDn[i] + (channelDn[i-n] - channelDn[i])*(double)k/n;

                  }                  

            }

            

         }


   //

   //

   //

   //

   //

   

   return(rates_total);

}




//------------------------------------------------------------------

//                                                                  

//------------------------------------------------------------------

//

//

//

//

//



double workHa[][4];

double getPrice(enPrices price, const double& open[], const double& close[], const double& high[], const double& low[], int i, int bars)

{


   //

   //

   //

   //

   //

   

   if (price>=pr_haclose && price<=pr_haaverage)

   {

      if (ArrayRange(workHa,0)!= bars) ArrayResize(workHa,bars);


         //

         //

         //

         //

         //

         

         double haOpen;

         if (i>0)

                haOpen  = (workHa[i-1][2] + workHa[i-1][3])/2.0;

         else   haOpen  = open[i]+close[i];

         double haClose = (open[i] + high[i] + low[i] + close[i]) / 4.0;

         double haHigh  = MathMax(high[i], MathMax(haOpen,haClose));

         double haLow   = MathMin(low[i] , MathMin(haOpen,haClose));


         if(haOpen  <haClose) { workHa[i][0] = haLow;  workHa[i][1] = haHigh; } 

         else                 { workHa[i][0] = haHigh; workHa[i][1] = haLow;  } 

                                workHa[i][2] = haOpen;

                                workHa[i][3] = haClose;

         //

         //

         //

         //

         //

         

         switch (price)

         {

            case pr_haclose:     return(haClose);

            case pr_haopen:      return(haOpen);

            case pr_hahigh:      return(haHigh);

            case pr_halow:       return(haLow);

            case pr_hamedian:    return((haHigh+haLow)/2.0);

            case pr_hatypical:   return((haHigh+haLow+haClose)/3.0);

            case pr_haweighted:  return((haHigh+haLow+haClose+haClose)/4.0);

            case pr_haaverage:   return((haHigh+haLow+haClose+haOpen)/4.0);

         }

   }

   

   //

   //

   //

   //

   //

   

   switch (price)

   {

      case pr_close:     return(close[i]);

      case pr_open:      return(open[i]);

      case pr_high:      return(high[i]);

      case pr_low:       return(low[i]);

      case pr_median:    return((high[i]+low[i])/2.0);

      case pr_typical:   return((high[i]+low[i]+close[i])/3.0);

      case pr_weighted:  return((high[i]+low[i]+close[i]+close[i])/4.0);

   }

   return(0);

}



//------------------------------------------------------------------

//                                                                  

//------------------------------------------------------------------

//

//

//

//

//


double workSma[][2];

double iSma(double price, int period, int r, int bars, int instanceNo=0)

{

   if (ArrayRange(workSma,0)!= bars) ArrayResize(workSma,bars); instanceNo *= 2;


   //

   //

   //

   //

   //

      

   workSma[r][instanceNo] = price;

   if (r>=period)

          workSma[r][instanceNo+1] = workSma[r-1][instanceNo+1]+(workSma[r][instanceNo]-workSma[r-period][instanceNo])/period;

   else { workSma[r][instanceNo+1] = 0; for(int k=0; k<period && (r-k)>=0; k++) workSma[r][instanceNo+1] += workSma[r-k][instanceNo];  

          workSma[r][instanceNo+1] /= (double)period; }

   return(workSma[r][instanceNo+1]);

}


//

//

//

//

//


double workEma[][1];

double iEma(double price, double period, int r, int bars, int instanceNo=0)

{

   if (ArraySize(workEma)!= bars) ArrayResize(workEma,bars);


   //

   //

   //

   //

   //

      

   double alpha = 2.0 / (1.0+period);

          workEma[r][instanceNo] = workEma[r-1][instanceNo]+alpha*(price-workEma[r-1][instanceNo]);

   return(workEma[r][instanceNo]);

}



//------------------------------------------------------------------

//                                                                  

//------------------------------------------------------------------

//

//

//

//

//


string getIndicatorName()

{

   string progPath    = MQL5InfoString(MQL5_PROGRAM_PATH);

   string toFind      = "MQL5\\Indicators\\";

   int    startLength = StringFind(progPath,toFind)+StringLen(toFind);

         

         string indicatorName = StringSubstr(progPath,startLength);

                indicatorName = StringSubstr(indicatorName,0,StringLen(indicatorName)-4);

   return(indicatorName);

}


//

//

//

//

//

 

string getPeriodToString(int period)

{

   int i;

   static int    _per[]={1,2,3,4,5,6,10,12,15,20,30,0x4001,0x4002,0x4003,0x4004,0x4006,0x4008,0x400c,0x4018,0x8001,0xc001};

   static string _tfs[]={"1 minute","2 minutes","3 minutes","4 minutes","5 minutes","6 minutes","10 minutes","12 minutes",

                         "15 minutes","20 minutes","30 minutes","1 hour","2 hours","3 hours","4 hours","6 hours","8 hours",

                         "12 hours","daily","weekly","monthly"};

   

   if (period==PERIOD_CURRENT) 

       period = Period();   

            for(i=0;i<20;i++) if(period==_per[i]) break;

   return(_tfs[i]);   

}



//------------------------------------------------------------------

//                                                                  

//------------------------------------------------------------------

//

//

//

//

//


int dateArrayBsearch(datetime& times[], datetime toFind, int total)

{

   int mid   = 0;

   int first = 0;

   int last  = total-1;

   

   while (last >= first)

   {

      mid = (first + last) >> 1;

      if (toFind == times[mid] || (mid < (total-1) && (toFind > times[mid]) && (toFind < times[mid+1]))) break;

      if (toFind <  times[mid])

            last  = mid - 1;

      else  first = mid + 1;

   }

   return (mid);

}

Razão: