Indikator Grundlagen - Seite 2

Einloggen oder registrieren, um einen Kommentar zu schreiben
amando
1343
amando  
Carl Schreiber:

Überprüf den Index:

wie definiere ich den idx?

int idx =0;



also 


kommt dann raus, wenn ich das so in die for schleife gebe

if ( i<0 || i>=ArraySize(MA) ) { Print(i,"  sz: ",ArraySize(MA)); Print(1.0/(sqrt(1)-1)); }


Frage ist, warum bekomme ich bei ArraySize(MA) nur eine 1 raus?

Carl Schreiber
Moderator
7652
Carl Schreiber  

Amando, nimm einfach einen existierenden Indikator, den MACD zB. mit 3 Datenpuffer und ändere, das was Du brauchst.

Dann beginnst mit mit etwas, das funktioniert!!

Otto Pauser
1357
Otto Pauser  

Ich schenk dir und der Community was funktionierendes. Ist ein 'gepimpter' iMA der signalbuffer und steigungsbuffer(slope) berechnet. Ist sehr gut zum auslesen im EA geeignet.

Der Code ab Zeile 110 sollte als Buffer.mqh ausgelagert werden. Denn die standard mässige Definition der Buffer ist nach wie vor sehr archaisch und mit sehr vielen Zeilen Code verbunden.

Damit kannst du Buffer in nur einer Zeile Code definieren. Zeile 48 bis 52.

Hab ich schon in einem anderen Forum gepostet, bin aber dort gesperrt worden, weil ich ...... was weis ich.

//+------------------------------------------------------------------+
//|                                                         MYMA.mq5 |
//|                                Copyright © 2018 Ing. Otto Pauser |
//|                        https://www.mql5.com/de/users/kronenchakra|
//+------------------------------------------------------------------+

#property indicator_chart_window
#property indicator_buffers 5                   // ein buffer mehr für die farben
#property indicator_plots   4                   // 4 sichtbare buffer
                                                // simple abkürzungen
#define METHOD    ENUM_MA_METHOD
#define APRICE    ENUM_APPLIED_PRICE
#define BUFTYPE   ENUM_INDEXBUFFER_TYPE
#define DRAWTYPE  ENUM_DRAW_TYPE
#define LINESTYLE ENUM_LINE_STYLE

//+------------------------------------------------------------------+
input int      inp_MA_Period   =          50;   // Period
input METHOD   inp_MA_Method   =   MODE_LWMA;   // Method
input APRICE   inp_MA_APrice   = PRICE_CLOSE;   // Price
input uint     inp_MA_DeltaMin =           2;   // Delta Min for Signal (points)
input bool     inp_MA_ShowLine =        true;   // Show Line
input bool     inp_MA_ShowSign =        true;   // Show Signal
input uint     inp_MA_LWidth   =           1;   // Linewidth
input uint     inp_MA_SigSize  =           1;   // SignalSize
input uint     inp_MA_SIgSymb  =         159;   // Signalsymbol
//+------------------------------------------------------------------+

int    handle;                                  // handle für iMA
double Buffer[];                                // buffer für iMA
double ColBuf[];                                // buffer für die farben
color  Colors[3] = {clrRed,clrLime,clrGray};    // die farben

double sig_UP[];                                // buffer für signal rauf
double sig_DN[];                                // buffer für signal runter
double buf_DX[];                                // buffer für steigung (slope)

double delta, 
       deltaMin=inp_MA_DeltaMin;

string IndName = "MYMA("+IntegerToString(inp_MA_Period)+")";

int OnInit()
{
   DRAWTYPE DRAW_TYPE = inp_MA_ShowSign?DRAW_ARROW     :DRAW_NONE;
   DRAWTYPE DRAW_HLIN = inp_MA_ShowLine?DRAW_COLOR_LINE:DRAW_NONE;
   
   Indi.InitArrow (sig_DN,DRAW_TYPE,STYLE_SOLID,inp_MA_SigSize ,Colors[0],inp_MA_SIgSymb,0,"MYMA DN"   );
   Indi.InitArrow (sig_UP,DRAW_TYPE,STYLE_SOLID,inp_MA_SigSize ,Colors[1],inp_MA_SIgSymb,0,"MYMA UP"   );
   Indi.InitArrow (buf_DX,DRAW_NONE,STYLE_SOLID,inp_MA_SigSize ,Colors[2],inp_MA_SIgSymb,0,"MYMA Delta");
   Indi.ColorLine (Buffer,DRAW_HLIN,STYLE_SOLID,inp_MA_LWidth  ,Colors                    ,"MYMA Value");
   Indi.ColorIndex(ColBuf);

   for(int i=0; i<7; i++)
      PlotIndexSetInteger(0,PLOT_DRAW_BEGIN,inp_MA_Period);

   IndicatorSetString (INDICATOR_SHORTNAME,IndName);
   
   handle=iMA(_Symbol,_Period,inp_MA_Period,0,inp_MA_Method,inp_MA_APrice);
   if(handle==INVALID_HANDLE)
      return(INIT_FAILED);

   return(INIT_SUCCEEDED);
}

int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
{
   int iStart=(prev_calculated==0)?1:prev_calculated-1;     // Startindex berechnen ACHTUNG nicht 0 sondern 1
   int iEnd  = rates_total-1;                               // Endindex berechnen
   int iCopy = iEnd-iStart+1;                               // amount of data to copy
   int bar;

   if(prev_calculated==0)
      {
         ArrayInitialize (Buffer,NULL);
         ArrayInitialize (sig_UP,NULL);
         ArrayInitialize (sig_DN,NULL);
         ArrayInitialize (buf_DX,NULL);
         ArrayInitialize (ColBuf,NULL);
      }
      
   CopyBuffer(handle,0,0,iCopy,Buffer);

   for(bar=iStart; bar<rates_total; bar++)                // main loop of the signal line coloring
      {
         delta=(Buffer[bar]-Buffer[bar-1])/_Point;
         buf_DX[bar]=delta;
         ColBuf[bar]=2;                                  // color clrGray
         sig_DN[bar]=NULL;                               // default no signal
         sig_UP[bar]=NULL;
         
         if(Buffer[bar-1]>Buffer[bar])                   // down
            {
               ColBuf[bar]=0;
               if(buf_DX[bar]< -deltaMin)
                  sig_DN[bar]=Buffer[bar];
            } 

         if(Buffer[bar-1]<Buffer[bar])                   // up
            {
               ColBuf[bar]=1; 
               if(buf_DX[bar]> +deltaMin)
                  sig_UP[bar]=Buffer[bar];
            } 
      }

   return(rates_total);
}

//+------------------------------------------------------------------+
//| sollte als buffer.mqh ausgelagert werden                         |
//+------------------------------------------------------------------+

class CIndi
{
   private:
      int   m_BufIdx,                                          // counter for bufferindex
            m_IntVal;                                          // period for SMA,EMA,WMA the period / for Max/Min lookback
   public:
      bool InitLine (double     &aBuffer[],                    // the buffer
                     DRAWTYPE    aDrwType  =DRAW_LINE,         // DRAW_NONE .. DRAW_COLOR_CANDLES
                     LINESTYLE   aLineStyle=STYLE_SOLID,       // STYLE_SOLID .. STYLE_DASHDOTDOT
                     int         aLineWidth=1,                 // PLOT_LINE_WIDTH
                     int         aLineColor=clrRed,            // PLOT_LINE_COLOR
                     string      aPlotLabel="",                // PLOT_LABEL - "Any String"
                     int         aIntVal   =0,                 // period for SMA,EMA,WMA the period / for Max/Min lookback
                     int         aPlotShift=0,                 // PLOT_SHIFT
                     bool        aAsSeries=false)              // SetAsSeries
                     {
                        SetIndexBuffer     (m_BufIdx,aBuffer,         INDICATOR_DATA);
                        PlotIndexSetInteger(m_BufIdx,PLOT_DRAW_TYPE,  aDrwType  );
                        PlotIndexSetInteger(m_BufIdx,PLOT_LINE_STYLE, aLineStyle);
                        PlotIndexSetInteger(m_BufIdx,PLOT_LINE_WIDTH, aLineWidth);
                        PlotIndexSetInteger(m_BufIdx,PLOT_LINE_COLOR, aLineColor);
                        PlotIndexSetString (m_BufIdx,PLOT_LABEL,      aPlotLabel);
                        PlotIndexSetInteger(m_BufIdx,PLOT_SHIFT,      aPlotShift);
                        PlotIndexSetDouble (m_BufIdx,PLOT_EMPTY_VALUE,NULL);
                        ArrayInitialize    (aBuffer ,NULL);
                        ArraySetAsSeries   (aBuffer ,aAsSeries);
                        m_IntVal=aIntVal;
                        m_BufIdx++;                            // increment bufferindex for next Init()
                        return(true);
                     }

      bool InitArrow(double     &aBuffer[],                    // the buffer
                     DRAWTYPE    aDrwType   =DRAW_ARROW,       // DRAW_NONE .. DRAW_COLOR_CANDLES
                     LINESTYLE   aLineStyle =STYLE_SOLID,      // STYLE_SOLID .. STYLE_DASHDOTDOT
                     int         aArrowSize =1,                // PLOT_LINE_WIDTH
                     int         aArrowColor=clrRed,           // PLOT_LINE_COLOR
                     int         aArrowCode =159,              // ArrowCode (Wingdings Number)
                     int         aArrowShift=0,                // PLOT_ARROW_SHIFT
                     string      aPlotLabel="",                // PLOT_LABEL - "Any String"
                     int         aIntVal   =0,                 // period for SMA,EMA,WMA the period / for Max/Min lookback
                     int         aPlotShift=0,                 // PLOT_SHIFT
                     bool        aAsSeries=false)              // SetAsSeries
                     {
                        SetIndexBuffer     (m_BufIdx,aBuffer,         INDICATOR_DATA);
                        PlotIndexSetInteger(m_BufIdx,PLOT_DRAW_TYPE,  aDrwType  );
                        PlotIndexSetInteger(m_BufIdx,PLOT_LINE_STYLE, aLineStyle);
                        PlotIndexSetInteger(m_BufIdx,PLOT_LINE_WIDTH, aArrowSize);
                        PlotIndexSetInteger(m_BufIdx,PLOT_LINE_COLOR, aArrowColor);
                        PlotIndexSetInteger(m_BufIdx,PLOT_ARROW,      aArrowCode);
                        PlotIndexSetInteger(m_BufIdx,PLOT_ARROW_SHIFT,aArrowShift);
                        PlotIndexSetString (m_BufIdx,PLOT_LABEL,      aPlotLabel);
                        PlotIndexSetInteger(m_BufIdx,PLOT_SHIFT,      aPlotShift);
                        PlotIndexSetDouble (m_BufIdx,PLOT_EMPTY_VALUE,NULL);
                        ArrayInitialize    (aBuffer ,NULL);
                        ArraySetAsSeries   (aBuffer ,aAsSeries);
                        m_IntVal=aIntVal;
                        m_BufIdx++;                                            // increment bufferindex for next Init()
                        return(true);
                     }
      bool ColorLine(double     &aBuffer[],                    // the buffer
                     DRAWTYPE    aDrwType,                     // DRAW_NONE .. DRAW_COLOR_CANDLES
                     LINESTYLE   aLineStyle,                   // STYLE_SOLID .. STYLE_DASHDOTDOT
                     int         aLineWidth,                   // PLOT_LINE_WIDTH
                     color      &aColors[],                    // Array of color
                     string      aPlotLabel="",                // PLOT_LABEL - "Any String"
                     int         aIntVal   =0,                 // period for SMA,EMA,WMA the period / for Max/Min lookback
                     int         aPlotShift=0,                 // PLOT_SHIFT
                     bool        aAsSeries=false)              // SetAsSeries
                     {
                        int nColors=ArraySize(aColors);
                        SetIndexBuffer     (m_BufIdx,aBuffer,         INDICATOR_DATA);
                        PlotIndexSetInteger(m_BufIdx,PLOT_DRAW_TYPE,  aDrwType  );
                        PlotIndexSetInteger(m_BufIdx,PLOT_LINE_STYLE, aLineStyle);
                        PlotIndexSetInteger(m_BufIdx,PLOT_LINE_WIDTH, aLineWidth);
                        PlotIndexSetString (m_BufIdx,PLOT_LABEL,      aPlotLabel);
                        PlotIndexSetInteger(m_BufIdx,PLOT_SHIFT,      aPlotShift);
                        PlotIndexSetDouble (m_BufIdx,PLOT_EMPTY_VALUE,NULL);
                        PlotIndexSetInteger(m_BufIdx,PLOT_COLOR_INDEXES,nColors);
                        ArrayInitialize    (aBuffer ,NULL);
                        ArraySetAsSeries   (aBuffer ,aAsSeries );
               
                        for(int i=0; i<nColors; i++)
                           PlotIndexSetInteger(m_BufIdx,PLOT_LINE_COLOR,i,aColors[i]);
               
                        m_IntVal=aIntVal;
                        m_BufIdx++;                                            // increment bufferindex for next Init()
                        return(true);
                     }

      bool ColorIndex(double    &aBuffer[],                    // the buffer
                     int         aPlotShift=0,                 // PLOT_SHIFT
                     bool        aAsSeries=false)              // SetAsSeries
                     {
                        SetIndexBuffer     (m_BufIdx,aBuffer,         INDICATOR_COLOR_INDEX);
                        PlotIndexSetInteger(m_BufIdx,PLOT_SHIFT,      aPlotShift);
                        PlotIndexSetDouble (m_BufIdx,PLOT_EMPTY_VALUE,NULL);
                        ArrayInitialize    (aBuffer ,NULL);
                        ArraySetAsSeries   (aBuffer,aAsSeries);

                        m_BufIdx++;                                                       // increment bufferindex for next Init()
                        return(true);
                     }

};

CIndi Indi;


Buffer 0 - Signal Down
Buffer 1 . Signal Up
Buffer 2 - Delta (Slope)
Buffer 3 - Value (aktueller Wert des MAs)

Viel Erfolg damit, Ich denke damit kann man schon was anfangen.

Ist ein Beispiel wie man den MT5 wirklich programmiert.

Dateien:
MYMA.mq5 24 kb
Carl Schreiber
Moderator
7652
Carl Schreiber  
Danke, Otto, sehr nett! So geht's auch!
Christian
2470
Christian  

Eintrag eins Klassenbuch:

Eins mit Bienchen :-)

amando
1343
amando  
Christian:

Eintrag eins Klassenbuch:

Eins mit Bienchen :-)

@Otto,

den Indi muss ich mir mal genauer ansehen, aber bei mir sieht der mit den Standard Einstellungen am EURUSD gleich mal ganz anders aus


amando
1343
amando  

aber ich hab mir jetzt mal den Code von @Otto angesehen, ich hab mir angesehen was @Calli so an indicator programmiert.

ich initialisiere die Array gleich, ich hab die gleichen Codezeilen in der OnCalculate,

ich mache in der For Schleife das gleiche wie Otto, und bei mir kommt Array fehler


ich verstehs echt nicht


Edit:

ich hab den ganzen Code jetzt mal auf einen Buffer gekürzt.

das sieht dann so aus


#property indicator_chart_window
#property indicator_buffers 1
#property indicator_plots   1
//--- 

// MA Fibo
#property indicator_label1  "MA_Fibo"   
#property indicator_type1   DRAW_LINE
#property indicator_color1  clrRed, clrBlue
#property indicator_style1  STYLE_SOLID
#property indicator_width1  1




double   MA_Buffer[];  // Fibo Ma

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int MA_Handle;
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int OnInit()
  {

   SetIndexBuffer(0,MA_Buffer,INDICATOR_DATA);

   MA_Handle=iMA(_Symbol,PERIOD_CURRENT,14,0,MODE_LWMA,PRICE_CLOSE);

   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
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[])
  {
//---
   double MA[];

   ArraySetAsSeries(MA,true);                // CopyBuffer da dieser MA ja auch initialisiert wird
   ArraySetAsSeries(MA_Buffer,true);         // kein Copy Buffer da dieser ein Anzeigebuffer ist


   int limit=rates_total-prev_calculated,
   count=(limit>1 ? rates_total : 1),
                                     cop2=0;

   cop2=CopyBuffer(MA_Handle,0,0,count,MA);

   int start=(prev_calculated==0)?0:prev_calculated-1;


   for(int i=start; i<rates_total; i++)
     {

      MA_Buffer[i]=MA[i];

     }

   return(rates_total);
  }
//+------------------------------------------------------------------+

ich verstehs nicht, das geht nicht, und ich seh keinen Fehler im Code

Otto Pauser
1357
Otto Pauser  
amando:

ich verstehs nicht, das geht nicht, und ich seh keinen Fehler im Code

#property indicator_chart_window
#property indicator_buffers 1
#property indicator_plots   1

#property indicator_label1  "MA_Fibo"   
#property indicator_type1   DRAW_LINE
#property indicator_color1  clrRed, clrBlue
#property indicator_style1  STYLE_SOLID
#property indicator_width1  1

int      MA_Handle;
double   MA_Buffer[];

int OnInit()
  {
   SetIndexBuffer(0,MA_Buffer,INDICATOR_DATA);

   MA_Handle=iMA(_Symbol,PERIOD_CURRENT,14,0,MODE_LWMA,PRICE_CLOSE);
   if(MA_Handle==INVALID_HANDLE)
      return(INIT_FAILED);

   return(INIT_SUCCEEDED);
  }

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[])
  {
   int iStart=(prev_calculated==0)?0:prev_calculated-1;              // Startindex berechnen
   int iEnd  = rates_total-1;                                        // Endindex berechnen
   int iCopy = iEnd-iStart+1;                                        // amount of data to copy

   if(CopyBuffer(MA_Handle,0,0,iCopy,MA_Buffer)!=iCopy) return(0);   // falls der Indi noch nicht bereit ist raus und nochmal versuchen

   for(int i=iStart; i<rates_total; i++)                             // hier können eigene Dinge Reinprogrammiert werden
     {

     }

   return(rates_total);
  }

Durch das CopyBuffer wird der Indikator schon gezeichnet.

Die For-Schleife brauchst du für weitergehende Berechnungen.

Schau dir doch mein Beispiel genau an, wo und wie die Signale in die Puffer geschrieben werden.

amando
1343
amando  
Otto Pauser:

Durch das CopyBuffer wird der Indikator schon gezeichnet.

Die For-Schleife brauchst du für weitergehende Berechnungen.

Schau dir doch mein Beispiel genau an, wo und wie die Signale in die Puffer geschrieben werden.

@Otto, Du hast Dir ein Bier verdient. Genau das war es

amando
1343
amando  

damits nicht fad wird hier im Forum,


was bedeutet es, wenn der Debugger "inf" ausgibt?

nehme mal an, es steht in einem direkten zusammenhang mit den +308 Werten

aber in einer FOR Schleife, darf ich ja eine 2te FOR Schleife laufen lassen oder?


 int j,k;
   double sum, sumw;

   for(int i=iStart; i<rates_total; i++)
     {

       sum  = (HalfLength+1)*MA[i];
       sumw = (HalfLength+1);

      for( j=1, k=HalfLength; j<=HalfLength; j++,k--)
        {
         sum  += k*MA[i+j];
         sumw += k;
   
         if(j<=i) // dieser Bereich wird nur für repainten gebraucht, dann repaintet er die letzten Bars(Halflenght)
           {
            sum  += k*MA[i-j];
            sumw += k;
           }   // repainten Ende
        }
        
         range=ATR[i+10]*ATRMultiplier1;
         buffer1[i] = sum/sumw;
         buffer2[i] = buffer1[i]+range;
         buffer3[i] = buffer1[i]-range;

     }
Einloggen oder registrieren, um einen Kommentar zu schreiben