MetaTrader 5 herunterladen

Grafische Kontrolle der Externen Parameter von Indikatoren

3 März 2016, 11:19
Vladimir
0
262

Einführung

Wie oft müssen Sie die externen Parameter von Indikatoren ändern? Viele von Ihnen müssen schon einmal daran gedacht haben sie in das Chart zu verlegen, um bequem ein Symbol oder Objekt mit der Maus an de gewünschte Position zu ziehen, um so das Einrichtungsverfahren des Indikators zu vereinfachen. Die MQL4 Sprache ermöglicht die Anzeige der Indikator-Einstellungen auf dem Bildschirm.


Grafische Steuerung von Parametern

Zunächst müssen wir herausfinden welche Parameter es in unserem Indikator gibt und welche von ihnen wir ändern möchten. Dazu öffnen Sie die Indikator-Eigenschaften und notieren die Namen der Parameter, die im Verlauf der Arbeit geändert werden müssen.

Als Beispiel verwenden wir den ZigZag Indikator, der in der Standard-Auslieferung des Terminals inbegriffen ist. Wählen Sie die Namen der Variablen in den Eigenschaften.


Indikator Parameter

  • ExtDepth=12
  • ExtDeviation=5
  • ExtBackstep=3

Wir erzeugen weitere Variablen und Arrays, die zur Änderung der Parameter-Werte des Indikators verwendet werden.

Die Namen der Parameter werden in Übereinstimmung mit den Parametern des Indikators angegeben, die wir steuern möchten.

// Initial indicator values
int               ExtDepth=12;
int               ExtDeviation=5;
int               ExtBackstep=3;
//---- indicator buffers
double            ZigzagBuffer[];
double            HighMapBuffer[];
double            LowMapBuffer[];
// Array of indicator parameter variables
string            ArrExt[3,3]    ={"12","21","34", "5","8","21", "3","13","34"};
// Arrays of indices
string            Array_Index[]={"Dep -> ","Dev -> ","Back ->"};
int               Coordinats_IndexUp[]={65,160,260};
int               Coordinats_Index[]  ={35,130,230};
int               Coordinats_IndexDn[]={5, 100,200};
// Color for parameter blocks and indices
color             Color_[]={Blue,Green,Red};

Ich glaube, in dieser Phase ist alles klar.

"Dep -> ","Dev -> ","Back ->"

sind ExtDepth, ExtDeviation and ExtBackstep, in dieser Reihenfolge. So werden sie in dem Chart angezeigt.

Für jeden der Parameter verwenden wir drei Variablenwerte,

string            ArrExtDepth[]    ={"12","15","20"};
string            ArrExtDeviation[]={"5",  "8","21"};
string            ArrExtBackstep[] ={"3", "13","34"};

der Einfachheit halber in einem dreidimensionalen Array gespeichert:

string            ArrExt[3,3]    ={"12","21","34", "5","8","21", "3","13","34"};

3, 5, 12 sind standardmäßig eingestellte Werte in den Parametern des ZigZag Indikators

Andere Werte werden hier als Beispiel angegeben. Sie werden als Parametervariablen für die Indikatorsteuerung verwendet.

Unter Berücksichtigung, dass viele grafische Darstellungen beteiligt sind, setzen wir eine Funktion zum Erzeugen und verschieben von Objekten in einen separaten Block:

void Obj_CreateMove_Text (int CreateMove, string Name, int Type, string Number,  color text_color, 
                          int DistX, int DistY)
   {
      if (CreateMove==0)
      ObjectCreate(Name,Type,0,0,0);
      ObjectSetText(Name,Number,10,"Arial",text_color);
      ObjectSet(Name,101,3);
      ObjectSet(Name, 102, DistX);
      ObjectSet(Name, 103, DistY);
   }

Um eine einfache Steuerung zu gewährleisten und um den Code kompakt zu halten, werden alle Koordinaten der grafischen Objekte in Arrays gespeichert. Dies wurde oben bereits demonstriert (siehe am Anfang des Artikels).

Zeichnen wir nun alle Objekte in das Chart-Fenster.

Die linke Seite unseres Charts ist weniger mit Informationen beladen, also werden die Variablen entlang des rechten Rand des Fensters angeordnet. Jeder Parameter hat seinen eigenen Index, dessen Farbe die gleiche sein wird, wie die Farbe der entsprechenden Parametervariablen.

Somit müssen wir drei Parameter-Indizes und drei Variablenwerte für jeden der Parameter erstellen.

Erzeugen von Objekten für die Indikator-Parameter auf dem Bildschirm, Anzeige nummerischer Werte von Variablen für diese Parameter und erstellen der entsprechenden Indizes neben jedem Parameterblock.

// Create objects
   for( ii=0;ii<3;ii++)
      for( i=0;i<3;i++)
      Obj_CreateMove_Text (0, Array_Index[ii]+i, 23, (ArrExt[ii,i]), Color_[ii], 5, Coordinats_IndexDn[ii]+30*i);
      for( i=0;i<3;i++)
      Obj_CreateMove_Text (0, "Index"+Array_Index[i], 23, (Array_Index[i]),   Color_[i], 25, Coordinats_Index[i]);


Abbildung 1

Jetzt müssen wir nur noch einen Block erstellen für den Umgang mit den Benutzerhandlungen, wenn der betreffende Index bewegt wird.

Wir haben Ankerpunkte der Objekte auf dem Chart, nach denen wir die Index-Parameter einen nach dem anderen lesen und die Programmlogik bestimmen.

// Read index coordinates from the chart
      for( i=0;i<3;i++)
           {
            Coordinats[i]=ObjectGet("Index"+Array_Index[i],OBJPROP_YDISTANCE);
               if (Coordinats[i]==0)//If outside of the chart, set again
                  Obj_CreateMove_Text (1, "Index"+Array_Index[i], 23, Array_Index[i], Color_[i], 25, Coordinats_IndexDn[i]);
           }   

Jetzt, nachdem die erhaltenen Werte gespeichert wurden, müssen wir deren Positionen auf dem Chart analysieren und das notwendige tun. Für die Analyse verwenden wir die tatsächlichen Positionen von Indizes, nehmen als Bezugspunkt drei Basiswerte von jedem der Indizes in Bezug auf die Werte der verwendeten Parameter. Wenn der Index über den höchsten Wert in seiner Gruppe bewegt wird, gilt er als auf seinen höchsten Wert verschoben. Wird der Index unter den niedrigsten Parameter verschoben, wird er ebenso auf den niedrigsten Parameterwert verschoben werden. Ist der Index zwischen den höchsten und tiefsten Parameterwerten, übernimmt er den Mittelwert. Zu Vergleichszwecken verwenden wir eine vertikale Skala, d.h.

the OBJPROP_YDISTANCE parameter

von

ObjectGet()
// Analyze positions of indices
      for( i=0;i<3;i++)
         {
            if (Coordinats[i]>Coordinats_IndexUp[i]) 
                  {Move[i] = Coordinats_IndexUp[i]; index[i]=2;}// Index has been moved up
            if (Coordinats[i]>Coordinats_IndexDn[i]  && 
                Coordinats[i]<Coordinats_IndexUp[i])
                  {Move[i] = Coordinats_Index[i];   index[i]=1;}// Index is in the middle
            if (Coordinats[i]<Coordinats_IndexDn[i]) 
                  {Move[i] = Coordinats_IndexDn[i]; index[i]=0;}// Index has been moved down 
            if (Move[i]!=0)

Dann richten wir die Objekte aus, die verschoben wurden.

Speichern die neuen Parameter für die grafische Darstellung von ZigZag.

Stellen den Indikator grafisch dar, basierend auf den eigestellten Werten der grafischen Steuerung

// Move and align the objects depending on their positions
            Obj_CreateMove_Text (1, "Index"+Array_Index[i], 23, Array_Index[i], Color_[i], 25, Move[i]);    
// Save ZigZag parameter values
            switch (i)   
               {
                case 0:  ExtDepth =     StrToInteger(ArrExt[0,index[i]]);  break;
                case 1:  ExtDeviation = StrToInteger(ArrExt[1,index[i]]);  break;
                case 2:  ExtBackstep =  StrToInteger(ArrExt[2,index[i]]);  break;                  
               }/**/
          }
 // Pass parameter values to the custom indicator and plot ZigZag based on the obtained values
     for(i=300;i>0;i--)
            {
               ZigzagBuffer[i]=iCustom(NULL,0,"ZigZag",ExtDepth,ExtDeviation,ExtBackstep,0,i);
               HighMapBuffer[i]=iCustom(NULL,0,"ZigZag",ExtDepth,ExtDeviation,ExtBackstep,1,i);
               LowMapBuffer[i]=iCustom(NULL,0,"ZigZag",ExtDepth,ExtDeviation,ExtBackstep,2,i);
            }

Klicken Sie doppelt auf jedes grafische Objekt. um es zu aktivieren. Wenn es aktiviert ist, kann das Objekt mit der Maus gesteuert werden. Dies muss jedes Mal gemacht werden, wenn Sie sich entscheiden die Parameterwerte zu ändern.

Abbildung 2


Abbildung 3


Abbildung 4

Die endgültige Version des Codes wird wie folgt sein.

//+------------------------------------------------------------------+
//|                                         management_indicator.mq4 |
//|                                  Copyright © 2009, WWW.FIBOOK.RU |
//|                                             http://www.fibook.ru |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2009, WWW.FIBOOK.RU"
#property link      "http://www.fibook.ru"

#property indicator_chart_window
#property indicator_buffers 1
#property indicator_color1 Red
// Initial indicator values
int               ExtDepth=12;
int               ExtDeviation=5;
int               ExtBackstep=3;
//---- indicator buffers
double            ZigzagBuffer[];
double            HighMapBuffer[];
double            LowMapBuffer[];
// Array of indicator parameter variables
string            ArrExt[3,3]    ={"12","21","34", "5","8","21", "3","13","34"};
// Arrays of indices
string            Array_Index[]={"Dep -> ","Dev -> ","Back ->"};
int               Coordinats_IndexUp[]={65,160,260};
int               Coordinats_Index[]  ={35,130,230};
int               Coordinats_IndexDn[]={5, 100,200};
// Color for parameter blocks and indices
color             Color_[]={Blue,Green,Red};
// Variables for calculations
int               i,ii;
int               index[3];
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
//---- indicators
   IndicatorBuffers(3);
//---- drawing settings
   SetIndexStyle(0,DRAW_SECTION);
//---- indicator buffers mapping
   SetIndexBuffer(0,ZigzagBuffer);
   SetIndexBuffer(1,HighMapBuffer);
   SetIndexBuffer(2,LowMapBuffer);
   SetIndexEmptyValue(0,0.0);
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
//----
   
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
int  Coordinats[3];
int  Move[3];
// Check if index objects are on the chart
   if (ObjectGet("IndexDep -> ",OBJPROP_YDISTANCE)<1||
       ObjectGet("IndexDev -> ",OBJPROP_YDISTANCE)<1||
       ObjectGet("IndexBack ->",OBJPROP_YDISTANCE)<1)
// If they are not on the chart, create them
               {
      for( ii=0;ii<3;ii++)
       for( i=0;i<3;i++)
        Obj_CreateMove_Text (0, Array_Index[ii]+i, 23, ArrExt[ii,i], Color_[ii], 5, Coordinats_IndexDn[ii]+30*i);
       for( i=0;i<3;i++)
        Obj_CreateMove_Text (0, "Index"+Array_Index[i], 23, Array_Index[i], Color_[i], 25, Coordinats_IndexDn[i]);
               }
// Read index coordinates from the chart
      for( i=0;i<3;i++)
           {
            Coordinats[i]=ObjectGet("Index"+Array_Index[i],OBJPROP_YDISTANCE);
               if (Coordinats[i]==0)//If outside of the chart, set again
                  Obj_CreateMove_Text (1, "Index"+Array_Index[i], 23, Array_Index[i], Color_[i], 25, Coordinats_IndexDn[i]);
           }    
// Analyze positions of indices
      for( i=0;i<3;i++)
         {
            if (Coordinats[i]>Coordinats_IndexUp[i]) 
                  {Move[i] = Coordinats_IndexUp[i]; index[i]=2;}//Index has been moved up
            if (Coordinats[i]>Coordinats_IndexDn[i]  && 
                Coordinats[i]<Coordinats_IndexUp[i])
                  {Move[i] = Coordinats_Index[i];   index[i]=1;}// Index is in the middle
            if (Coordinats[i]<Coordinats_IndexDn[i]) 
                  {Move[i] = Coordinats_IndexDn[i]; index[i]=0;}// Index has been moved down
            if (Move[i]!=0)
// Move and align the objects depending on their positions
            Obj_CreateMove_Text (1, "Index"+Array_Index[i], 23, Array_Index[i], Color_[i], 25, Move[i]);    
// Save ZigZag parameter values
            switch (i)   
               {
                case 0:  ExtDepth =     StrToInteger(ArrExt[0,index[i]]);  break;
                case 1:  ExtDeviation = StrToInteger(ArrExt[1,index[i]]);  break;
                case 2:  ExtBackstep =  StrToInteger(ArrExt[2,index[i]]);  break;                  
               }/**/
          }
 // Pass parameter values to the custom indicator and plot ZigZag based on the obtained values
     for(i=300;i>0;i--)
            {
               ZigzagBuffer[i]=iCustom(NULL,0,"ZigZag",ExtDepth,ExtDeviation,ExtBackstep,0,i);
               HighMapBuffer[i]=iCustom(NULL,0,"ZigZag",ExtDepth,ExtDeviation,ExtBackstep,1,i);
               LowMapBuffer[i]=iCustom(NULL,0,"ZigZag",ExtDepth,ExtDeviation,ExtBackstep,2,i);
            }
Comment ("ExtDepth =",ExtDepth,", ExtDeviation =",ExtDeviation,", ExtBackstep =",ExtBackstep);        
//----
   return(0);
  }
// Function for creating and moving graphical objects
void Obj_CreateMove_Text (int CreateMove, string Name, int Type, string Number,  color text_color, int DistX, int DistY)
   {
      if (CreateMove==0)
      ObjectCreate(Name,Type,0,0,0);
      ObjectSetText(Name,Number,10,"Arial",text_color);
      ObjectSet(Name,101,3);
      ObjectSet(Name, 102, DistX);
      ObjectSet(Name, 103, DistY);
   }


//+------------------------------------------------------------------+


Fazit

Der oben beschriebene Ansatz kann umgesetzt werden um jeden Indikator extern zu steuern, durch die Anzeige der einzustellenden Parameter.

Übersetzt aus dem Russischen von MetaQuotes Software Corp.
Originalartikel: https://www.mql5.com/ru/articles/1370

Testen von Expert Advisors auf atypischen Zeitrahmen Testen von Expert Advisors auf atypischen Zeitrahmen

Es ist nicht nur einfach, es ist super einfach. Das Testen von Expert Advisors auf atypischen Zeitrahmen ist möglich! Alles was wir tun müssen, ist die Daten der Standard-Zeitrahmen mit den Daten der atypischen Zeitrahmen zu ersetzen. Darüber hinaus können wir auch Expert Advisors testen, die Daten aus mehreren atypischen Zeitrahmen verwenden.

Money Management neu aufgegriffen Money Management neu aufgegriffen

Der Artikel befasst sich mit einigen Fragen, die auftreten, wenn Trader verschiedene Money-Management-Systeme für Forex-Trading verwenden. Experimentelle Daten aus der Durchführung von Trading-Geschäften mit unterschiedlichen Money-Management (MM) Methoden werden ebenfalls beschrieben.

Zeichnen Horizontaler Durchbruch-Ebenen mit Fractals Zeichnen Horizontaler Durchbruch-Ebenen mit Fractals

Der Artikel beschreibt das Erstellen eines Indikators, der die Support/Resistance Ebenen mit Up/Down Fractals anzeigt.

Prognose von Finanzzeitreihen Prognose von Finanzzeitreihen

Die Prognose der Finanzzeitreihen ist ein erforderliches Element jeder Investitionstätigkeit. Das Konzept der Investition selbst - Geld jetzt einzusetzen, um in der Zukunft Gewinne zu erzielen -basiert auf dem Konzept der Vorhersage der Zukunft. Deshalb unterliegt die Prognose von Finanzzeitreihen den Aktivitäten der gesamten Anlageindustrie - alle organisierten Börsen und andere Handelssysteme.