Descargar MetaTrader 5

Control gráfico de los parámetros externos de los indicadores

12 abril 2016, 15:13
Vladimir
0
158

Introducción

¿Con qué frecuencia tiene que configurar o cambiar los parámetros externos de los indicadores? Muchos de ustedes habrán pensado alguna vez en moverlos al gráfico para poder arrastrar un icono o un objeto a la posición necesaria utilizando el ratón, y así simplificar el proceso de configuración del indicador. El lenguaje MQL4 permite mostrar los ajustes del indicador en la pantalla.



Parámetros de control gráfico

Lo primero es encontrar qué parámetros hay en el indicador y cuáles se van a cambiar. Para ello, abra las propiedades del indicador y escriba los nombres de los parámetros que necesitarán cambiarse durante el trabajo.

Como ejemplo, utilice el indicador ZigZag que se incluye en la entrega estándar de la terminal. Seleccione el nombre de las variables en las propiedades.


Parámetros del indicador

ExtDepth=12

ExtDeviation=5

ExtBackstep=3

Más adelante se crean las variables y las gamas que se utilizarán para cambiar los valores de los parámetros del indicador.

Los nombres de los parámetros del indicador se darán según los parámetros del indicador que se va a controlar.

// 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};

Creo que hasta ahora todo está claro.

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

son ExtDepth, ExtDeviation y ExtBackstep, respectivamente. Así es como se mostrarán en el gráfico.

Para cada parámetro, se utilizarán tres valores de variables

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

almacenados en una gama de tres dimensiones para más comodidad.

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

3,5, 12 son valores estándar establecidos por defecto en los parámetros del indicador ZigZag estándar.

Aquí se dan otros valores como ejemplo. Se utilizarán como parámetros de variables para el control del indicador.

Considerando que habrá muchas esquematizaciones, se pondrá una función para crear y mover los objetos en un bloque separado:

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);
   }

Para asegurar la facilidad de control y para mantener el código compacto, todas las coordenadas de los objetos gráficos se almacenan en gamas. Esto ya se ha demostrado antes (vea el principio del artículo).

Ahora tracemos los objetos en la ventana del gráfico.

El lado derecho del gráfico está menos cargado de información, así que las variables se ordenarán verticalmente por todo el borde derecho de la ventana. Cada parámetro tiene su propio índice, cuyo color será el mismo que el de los parámetros variables correspondientes.

De este modo, habrá que crear tres índices de parámetros y tres valores de variables para cada parámetro.

Cree los objetos para los parámetros del indicador en la pantalla, muestre los valores verticales numéricos para estos parámetros y cree los índices correspondientes junto a cada bloque de parámetros.

// 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]);


Imagen 1.

Ahora sólo hay que crear un bloque para controlar las acciones del usuario cuando se mueva el índice relevante.

Hay puntos de anclaje para los objetos del gráfico según los que se leen los parámetros del índice uno a uno y se determina la lógica del programa.

// 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]);
           }   

Ahora que se han guardado los valores obtenidos, hay que analizar la posición en el gráfico y hacer lo que sea necesario. Para el análisis, utilizamos las posiciones actuales de los índices, tomando como punto de referencia tres valores de base de cada uno de los índices relativo al valor de los parámetros utilizados. Si el índice se mueve arriba del valor más alto de este grupo, se considerará para moverse hasta el valor más alto. Si el índice se mueve por debajo del valor del parámetro más bajo, de forma similar, se moverá al valor más bajo del parámetro. Si el índice está entre el valor más alto y el más bajo del parámetro, tendrá un valor en el medio. Para comparar, se utiliza un aumento vertical, es decir

the OBJPROP_YDISTANCE parameter

de

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)

Luego se alinean los objetos que se han movido.

Guarde los nuevos valores del parámetro para esquematizar ZigZag.

Trace el indicador basado en los valores establecidos utilizando el control gráfico.

// 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);
            }

Haga doble clic en cualquier objeto gráfico para activarlo. Cuando esté activado, el objeto se puede controlar utilizando el ratón. Esto hay que hacerlo cada vez que decida cambiar el valor del parámetro.

Imagen 2.


Imagen 3.


Imagen 4.

La versión final del código será de la siguiente manera.

//+------------------------------------------------------------------+
//|                                         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);
   }


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


Conclusión

El método describo arriba se puede implementar para controlar cualquier indicador externamente mostrando los parámetros que hay que configurar.

Traducción del ruso hecha por MetaQuotes Software Corp.
Artículo original: https://www.mql5.com/ru/articles/1370

Leer fuentes de noticias RSS a través de MQL4 Leer fuentes de noticias RSS a través de MQL4

Este artículo trata un ejemplo de lectura de márgenes RSS a través de MQL4 utilizando las funciones para el análisis de etiquetas HTML. Intentaremos hacer un trabajo que se pueda transformar en un indicador de noticias o en un lector RSS en lenguaje MQL4.

LibMatrix: Librería de Álgebra Matrix (Parte uno) LibMatrix: Librería de Álgebra Matrix (Parte uno)

El autor familiariza a los lectores con una librería de álgebra matrix simple y ofrece descripciones y peculiaridades de las funciones principales.

Alerta y comentario para indicadores externos. Análisis multidivisa a través de escáner externo Alerta y comentario para indicadores externos. Análisis multidivisa a través de escáner externo

Alerta para análisis multidivisa y con periodos múltiples de tiempo de indicadores externos. El artículo trata sobre un método de adquirir información de los indicadores externos sin tener que adjuntarlos o abrir un gráfico. Lo llamamos escaneo externo.

Alerta y comentario para indicadores externos (Parte dos) Alerta y comentario para indicadores externos (Parte dos)

Desde que publiqué el artículo "Alerta y comentario para indicadores externos", he recibido peticiones y preguntas sobre la posibilidad de desarrollar un informador externo que funcione en base a las líneas del indicador. Una vez analizadas todas las preguntas, decidí continuar con el tema. Almacenar los datos en un buffer de un indicador resultó ser otra área de interés para los usuarios.