Desarrollo de un sistema de repetición (Parte 37): Pavimentando el terreno (I)

Introducción

En este artículo, voy a abordar una cuestión muy importante. Es una buena idea centrarse al máximo en comprender el contenido de este artículo, y no lo digo para que lo leas por leer. Quiero y necesito recalcar que, si no entiendes este artículo en concreto, puedes abandonar por completo cualquier esperanza de comprender el contenido de los siguientes.

Todo lo que voy a mostrar, explicar y hablar en este artículo será extremadamente necesario para que seas capaz de comprender, al menos mínimamente, los siguientes.

Y no bromeo. Porque creo que mucha gente no tiene ni idea de lo que realmente podemos hacer. Esto se hace utilizando MQL5 con el fin de hacer que las cosas se comporten de una manera determinada en MetaTrader 5.

Todo este tiempo, he estado escribiendo artículos con el fin de documentar para ti, querido lector, cómo hacer algunas cosas en MetaTrader 5. He estado evitando o posponiendo hablar de un determinado tema, he estado dando rodeos, intentando hablar de algo que llevo mucho tiempo haciendo en mis programas.

Estas cosas me permiten modular mi sistema de tal manera que a menudo tengo más trabajo modificando el código original que simplemente visualizándolo, utilizando solo MQL5.

Todos los códigos que has visto todo este tiempo son, en realidad, códigos modificados. No están ni cerca de lo que usé originalmente. Pero ahora, he llegado a una encrucijada en la que no veo cómo hacer las cosas de otra manera. O traigo el código original, o, mejor dicho, muy parecido al que uso en realidad, o no podré continuar con el proyecto del sistema de repetición/simulador.

El problema no es ni siquiera la codificación en sí. En mi opinión, es bastante sencilla y fácil de hacer. El problema es que quiero darte los conocimientos necesarios para que puedas no solo utilizar el sistema, sino también modificarlo. Esto es así para que se comporte de la manera deseable y necesaria para que puedas generar estudios o análisis propios.

Quiero que todo el mundo aprenda a andar con sus propios pies y no dependa de muletas, esperando que alguien le traiga una solución. Lo que sea.

Lo que tengo que hacer, y haré en este artículo, te muestra cómo se puede, utilizando indicadores y algunos EAs, tener un comportamiento muy específico y una programación muy modular, hasta el punto de crear algún tipo de sistema complejo. Pero aquí está el problema: compilarás el menor número posible de cosas.

Para que te hagas una idea, el sistema de repetición/simulador tiene actualmente 3 ejecutables: un EA, un servicio y un indicador. Y aún así, esto nos permite desarrollar el sistema de órdenes. Recuerda que un sistema de este tipo sustituiría al servidor de negociación, esto es para que podamos generar estudios, operando como si estuviéramos en una cuenta demo o real.

Ya que todavía tenemos que traer algunas cosas del pasado en el sistema de repetición/simulación, esto incluye Chart Trader. Necesitamos algún tipo de sistema, pero debe ser sostenible y fácil de utilizar. Aunque lo hice en el artículo Desarrollo de un EA comercial desde cero (Parte 30): ¿¡El CHART TRADE ahora como indicador?!, no es adecuado para lo que necesitamos.

Necesitamos que las cosas se hagan de una forma mucho más transparente y que no nos cause molestias.

Podemos hacer las cosas mucho mejor, pero hay que mostrarlo con un ejemplo más sencillo. Si vamos directamente a la aplicación deseada, estoy casi total y absolutamente seguro de que pocos, si es que hay alguien, podrán seguir el ritmo. Me quedé totalmente atrás y no quiero esto. Así que vamos a ver cómo hacemos las cosas a partir de ahora. Prepárate para entrar en mi UNIVERSO.

Empezar a construir el indicador

Lo que vamos a hacer aquí es extremadamente complejo desde el punto de vista de alguien que no sabe cómo funciona MetaTrader 5. Al final, no publicaré ningún archivo adjunto. Quiero que sigas la explicación para que sepas que podrás experimentar lo que ves aquí y conozcas al detalle cómo funcionan las cosas.

Para empezar, vamos a crear un indicador. Al utilizar MetaEditor, debes hacer las cosas de la siguiente manera:

Figura 01 - Seleccionamos lo que vamos a crear.

Figura 02 - Creamos un directorio como este.

Figura 03 - Dar un nombre al indicador.

Figura 04 - Mantenemos las cosas básicas.

Hasta ahora, como se puede ver en la figura 04, hemos creado básicamente lo mismo para cualquier tipo de indicador que vayas a hacer. En este punto de la figura 04, a veces podemos tener una cosa u otra, pero en cualquier caso, podemos añadir o modificar las funciones de gestión de eventos más adelante si es necesario. Así que no te preocupes, puedes seguir creando el indicador normalmente.

Figura 05 - Hacemos clic en Concluir.

Finalmente, verás la imagen de la figura 05. En este punto, solo debes crear en finalizar.

La idea aquí es crear un indicador que se colocará en la ventana CERO, pero se pueden utilizar los mismos conceptos para colocar el indicador en cualquier ventana. Pero, de nuevo, no te preocupes. Presta atención a la idea principal del artículo.

Al final de este proceso, en la ventana del MetaEditor, verás el siguiente código:

#property copyright "Daniel Jose"
#property link      ""
#property version   "1.00"
#property indicator_chart_window
//+------------------------------------------------------------------+
//| Custom indicator initialization function                     |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- indicator buffers mapping
   
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                           |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const int begin,
                const double &price[])
  {
//---
   
//--- return value of prev_calculated for next call
   return(rates_total);
  }
//+------------------------------------------------------------------+

Sé que a mucha gente no le gusta o prefiere utilizar el formato propio del MetaEditor. Bien, pero para mí, este formato es menos agradable de usar. Pero esto es un asunto personal. Lo que realmente importa es que puedas leer fácilmente tu código y entenderlo.

Así que vamos a empezar a modificar este código estándar a lo que realmente necesitamos.

Si intentas compilar este código estándar, recibirás una advertencia.

Figura 06 - Salida del compilador.

Aunque en la figura 06 se puede ver que el código ha sido compilado, no se creó del todo de la manera correcta. Muchos programadores simplemente ignoran el hecho de que el compilador les está advirtiendo de un fallo. Esto puede verse en la FLECHA ROJA.

El hecho de que se haya producido un fallo, incluso uno aparentemente no catastrófico, podría poner en RIESGO el código. Por lo tanto, bajo ninguna circunstancia se debe utilizar código que haya sido notificado por el compilador como defectuoso. No lo hagas NUNCA.

Para solucionarlo, vamos a hacer algo muy sencillo: indicar al compilador que somos conscientes de lo que hará el indicador.

#property copyright "Daniel Jose"
#property link      ""
#property version   "1.00"
#property indicator_chart_window
#property indicator_plots 0
//+------------------------------------------------------------------+
int OnInit()
{
        return INIT_SUCCEEDED;
}
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
{
        return rates_total;
}
//+------------------------------------------------------------------+

Al añadir la línea resaltada, le estaremos diciendo al compilador que somos conscientes de lo que realmente estamos haciendo. El resultado es el que se muestra en la figura 07.

Figura 07 - El resultado de una compilación perfecta.

Siempre que compiles código, presta atención y ve si el compilador te dice exactamente lo mismo que en la figura 07. Solo así tendrás un código perfectamente compilado y sin mayores problemas.

Podrías pensar: "Pero todo esto ya lo sabíamos." Bien. Pero quiero dejar esto claro. No quiero que nadie se queje de que el sistema no funciona o no funciona correctamente debido a alguna modificación. Quiero animar a todos a modificar y adaptar el sistema a sus necesidades. Y para ello, primero hay que conocer los fundamentos, tener una base sólida y bien formada en cuanto a conocimientos y conceptos.

Ahora que tenemos el indicador básico, creemos también el EA básico.

Empezar a construir el EA

Ahora, esto es lo que vamos a hacer: vamos a construir un EA para que podamos poner en práctica lo que necesitamos. Para ello, vamos paso a paso.

Figura 08 - Indicación de lo que vamos a construir.

Figura 09 - Definimos el directorio a utilizar.

Figura 10 - Definición del nombre del ejecutable.

Como puedes ver, estamos haciendo lo mismo paso a paso que en la fase del indicador. La única diferencia es la elección que hicimos al principio de la creación.

Figura 11 - Dejaremos todo por defecto.

Figura 12 - Aquí sólo tenemos que hacer clic en Finalizar.

Una vez realizado este paso a paso, tendrás en el MetaEditor un archivo como el que se muestra a continuación:

#property copyright "Daniel Jose"
#property link      ""
#property version   "1.00"
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---
   
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---
   
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//---
   
  }
//+------------------------------------------------------------------+

Al igual que con el indicador, también voy a hacer algunos cambios de formato aquí. Pero a diferencia del indicador, cuando pidas a MetaEditor que compile este código, recibirás la siguiente información del compilador.

Figura 13 - Resultado de la solicitud de compilación.

Puede que estés pensando: ¿¡Pero a dónde vas con esto!? Cálmate, querido lector. Tranquilo. Pronto entenderás lo que vamos a hacer. Tranquilo.

Ahora que tenemos un sistema básico, tanto para el Indicador como para el EA, empecemos a hacer lo que hemos venido a hacer en este artículo: conectarlos.

Mucho más importante que saber cómo crear un indicador o cómo crear un EA, saber cómo hacer que ambos se comuniquen y trabajen juntos marca la diferencia. Mucha gente conoce lo básico, lo que le permite utilizar un indicador para que el EA pueda utilizar los datos calculados por el indicador. 

Si no sabes cómo hacerlo, te sugiero encarecidamente que primero aprendas a hacerlo. Un buen punto de partida es este artículo: "Desarrollo de un EA comercial desde cero (Parte 10): Acceso a los indicadores personalizados". Explica de forma sencilla cómo acceder a los valores calculados por el indicador. Al mismo tiempo, te muestro cómo inicializar el indicador de una manera muy sencilla, antes incluso de que puedas acceder a cualquier información que se haya calculado, en función de lo que pretendas hacer.

Todo esto es muy bonito y sencillo, porque utilizando la idea de la figura 14 se puede leer el contenido de un indicador. Ahora, usando la figura 15, puedes crear el indicador usando el EA.

Figura 14 - EA leyendo el indicador.

Figura 15 - Creación del indicador por el EA.

Pero a pesar de ello, esta forma de trabajar no funciona cuando necesitamos hacer algo como lo que hicimos utilizando Chart Trade. Al transformar Chart Trader en un indicador, tuvimos que tomar un camino diferente. Esto fue en su momento, e incluso allí ya se mencionaba que esto se cambiaría en el futuro. Allí utilizamos algo que puedes ver en la figura 16.

Figura 16 - Comunicación bidireccional.

Cuando es necesario transferir información entre distintas partes, o más bien entre distintos procesos, necesitamos algún medio para hacerlo. En MetaTrader 5 primero podemos hacer uso de las variables globales del terminal. Este mismo concepto se utiliza desde hace tiempo en el sistema de repetición/simulación. Esto es para que el servicio pueda comunicarse de alguna manera con el indicador.

Hay otras formas de promover esta misma comunicación. Pero no quiero, ni pretendo, utilizar técnicas que no me permitan aprovechar al máximo lo que MQL5 y MetaTrader 5 tienen que ofrecer. Cuando utilizamos la plataforma y su lenguaje en profundidad, podemos beneficiarnos de cualquier mejora futura. ¡¡¡Si empiezas a inventar soluciones que no aprovechan plenamente lo que se ofrece, ¿cómo te vas a beneficiar si MQL5 o incluso MetaTrader 5 mejoran?!!!

Aunque el sistema que se ve en la figura 16 es muy adecuado en muchas situaciones, no nos favorece mucho.

Para entenderlo, intentemos comprender el siguiente hecho: ¿Cuántos indicadores tendremos que poner en el gráfico para tener una buena experiencia en el sistema de repetición/simulador? Uno. Dos. Cinco. La verdad es que no podemos saberlo con certeza. Pero esto es lo que ya sabemos: necesitaremos al menos dos indicadores. Y eso es por ahora, no para más adelante. Es por ahora. Necesitamos al menos dos indicadores en el sistema de repetición/simulador.

Quizás te lo preguntes: ¿Cómo es posible? Bueno, el primer indicador es el que se utiliza para controlar la repetición/simulador. Este ha estado con nosotros desde hace mucho tiempo. Ahora necesitamos otro: el Chart Trader. Esto nos permite enviar órdenes directamente. Y la razón por la que necesitamos Chart Trader es que, a diferencia del mercado físico, aquí, en la repetición/simulador, los botones de la esquina superior (figura 17) no nos sirven para nada.

Figura 17 - Botones de Quick Trader.

Realmente necesitamos alguna forma de enviar órdenes, pero necesitamos que sea la misma, tanto en la repetición/simulador como si estás usando una cuenta DEMO o REAL. La forma de interactuar con la plataforma tiene que ser la misma.

Aunque la figura 16 nos permite realizar una comunicación entre el EA y el Indicador para poder enviar órdenes, está lejos de ser la mejor forma. El hecho principal es que necesitamos mantener variables terminales globales, las cuales podrían utilizarse mejor para otras cosas. Podemos tomar un camino muy distinto para fomentar precisamente la comunicación que necesitamos.

Teniendo esto en cuenta, nos embarcamos en un nuevo enfoque, el cual puede verse en la figura 18.

Figura 18 - Nuevo protocolo de comunicación.

Al ver esta figura, uno podría pensar inmediatamente: "¿Estás loco? ¿Cómo vas a conseguir que el EA y el Indicador se comuniquen directamente? ¿Dónde está el truco en esta historia?". No, no hay ninguna broma. Y no, no estoy loco. El hecho es que hay formas y formas de comunicarse directamente. Esto puede verse en las figuras 14 y 15. Pero además de esos medios, tenemos otro a nuestra disposición. Lo que realmente necesitamos es comprender cómo hacer el mejor uso posible de esos mismos medios.

Antes de seguir, déjame preguntarte algo: ¿Alguna vez has probado o experimentado MetaTrader 5 de una manera diferente a como todo el mundo lo utiliza? ¿Has probado o experimentado con el lenguaje MQL5 hasta el punto de decir: "Esto también podría permitirnos hacerlo"? Si la respuesta a cualquiera de estas dos preguntas es NO, entonces les invito a ver y comprender hasta dónde llega la madriguera del conejo.

Iniciar la comunicación entre procesos.

Como debería haber quedado claro en los temas anteriores, aquí vamos a construir una forma de comunicación entre un indicador y un EA, para que no necesiten utilizar las variables globales del terminal, salvo en casos especiales. Así, pueden intercambiar información de manera eficiente.

La idea no es complicada, y el concepto aún menos. Sin embargo, sin entender ciertos detalles, NO tendrás éxito. Es crucial entender muy bien lo que voy a explicarte. No asumas que ya sabes programar en MQL5, porque lo que voy a explicar va más allá de los límites del uso normal y convencional tanto de MetaTrader 5 como del lenguaje MQL5.

Para empezar, debemos tener en cuenta algunas cosas. Esto sería como establecer un protocolo. No importa lo que pienses o imagines, sigue el camino y los resultados llegarán. Desvíate, y fracasarás estrepitosamente.

Así que, en el código del indicador, empezamos añadiendo las primeras líneas como se muestra a continuación.

 1. #property copyright "Daniel Jose"
 2. #property link      ""
 3. #property version   "1.00"
 4. #property indicator_chart_window
 5. #property indicator_plots 0
 6. //+------------------------------------------------------------------+
 7. #define def_ShortName       "SWAP MSG"
 8. #define def_ShortNameTmp    def_ShortName + "_Tmp"
 9. //+------------------------------------------------------------------+
10. input double user00 = 0.0;
11. //+------------------------------------------------------------------+
12. long m_id;
13. //+------------------------------------------------------------------+
14. int OnInit()
15. {
16.     m_id = ChartID();
17.     IndicatorSetString(INDICATOR_SHORTNAME, def_ShortNameTmp);
18.     if (ChartWindowFind(m_id, def_ShortName) != -1)
19.     {
20.              ChartIndicatorDelete(m_id, 0, def_ShortNameTmp);
21.             Print("Only one instance is allowed...");
22.             return INIT_FAILED;
23.     }
24.     IndicatorSetString(INDICATOR_SHORTNAME, def_ShortName);
25.     
26.     return INIT_SUCCEEDED;
27. }
28. //+------------------------------------------------------------------+
29. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
30. {
31.     return rates_total;
32. }
33. //+------------------------------------------------------------------+

Quizás estén pensando: "¡Qué desastre es esto!" Pero no, no hay confusión. Aquí estoy, forzando a MetaTrader 5 a garantizar que solo haya un indicador en el gráfico. ¿Cómo? Simple, estoy probando si el indicador ya está en el gráfico o no.

Siempre que lo desees, puedes forzar a MetaTrader 5 a mantener solo un indicador en el gráfico utilizando el código mencionado anteriormente. Pero, para comprender cómo funciona, vamos a desglosarlo, enumerando y explicando las líneas clave para que sea más fácil seguir toda la explicación.

En la línea 7, definimos cómo se llamará realmente nuestro indicador. Este nombre será conservado por MetaTrader 5 durante todo el tiempo que el indicador esté en el gráfico.

Para definir este nombre, utilizamos la rutina de la línea 24. Aquí es donde definimos el nombre que utilizará el indicador. La razón por la cual definimos la línea 8 es debido a la forma en que funciona MetaTrader 5.

MetaTrader 5 es una plataforma basada en eventos. Esto significa que cuando ocurre cualquier tipo de evento, ya sea un movimiento en el precio, un cambio en el tiempo del gráfico, un movimiento del ratón, la pulsación de una tecla, añadir o eliminar algo del gráfico, MetaTrader 5 desencadena algún tipo de evento. Cada tipo de evento tiene un destino y una consecuencia.

Cuando MetaTrader 5 activa un evento de actualización, todos y cada uno de los objetos, indicadores, EAs, y otras cosas que puedan estar presentes en el gráfico deben ser actualizados de alguna manera. En el caso de los scripts, simplemente se expulsan del gráfico, mientras que en el caso de los indicadores y EAs, tienen una nueva llamada a la función OnInit. Si algo sucede y el indicador necesita ser re-actualizado desde cero, MetaTrader 5 forzará una llamada a la línea 14. ¿Cuál es el problema? El problema surge porque necesitamos que el indicador tenga un nombre corto que sea reconocido por MetaTrader 5, de lo contrario, no podremos realizar la prueba que se ve en la línea 18.

Uno podría pensar que simplemente podríamos poner la línea 24 antes de la 18, pero ahí radica el problema. Si añadimos la línea 24 antes de la línea 18, cuando el indicador sea marcado en la línea 18 como ya presente en el gráfico, obtendrá un resultado positivo. Esto haría que al ejecutar la línea 20, MetaTrader 5 expulse el indicador del gráfico, cuando en realidad queremos que permanezca. Pero queremos que solo haya una instancia de él.

No sé si estás siguiendo el hilo de la conversación. Por la razón explicada anteriormente, necesitamos un nombre temporal, definido en la línea 8, donde hacemos un ligero cambio en el nombre corto del indicador antes de probar, en la línea 18, si el indicador ya está en el gráfico. Usamos la línea 17 para definir un nombre temporal para el indicador. NOTA: Este nombre debe ser único de alguna manera, de lo contrario, tendríamos problemas.

Si el indicador ya está presente en el gráfico, la línea 18 permitirá que se ejecute la línea 20, eliminando así el indicador que está intentando entrar en el gráfico. Para avisar al usuario del fallo, tenemos la línea 21, que imprimirá un mensaje en el cuadro de mensajes de MetaTrader 5. Y en la línea 22, el indicador volverá, indicando que no ha sido posible su publicación en el gráfico.

Si el indicador entra en el gráfico, la línea 24 corregirá el nombre del indicador, así que no será posible colocar un nuevo indicador en el gráfico, en principio. Pero existe una "laguna jurídica", no realmente una laguna, sino una característica MetaTrader 5 es capaz de notar la diferencia hasta el punto de saber si estás añadiendo o no un nuevo indicador al gráfico, lo cual se facilita por la adición de la línea 10 al código.

Si el usuario NO CAMBIA el valor de la variable al colocar el indicador sobre el gráfico (variable declarada en la línea 10), MetaTrader 5 entenderá que el indicador es el mismo que ya está en el gráfico, si ya hay uno presente. Si el usuario cambia el valor, MetaTrader 5 puede tomar dos decisiones completamente diferentes, basadas en la percepción de si es el mismo indicador o uno nuevo que se está añadiendo.

• La primera es cuando no hay indicador, se colocará en el gráfico.
• La segunda es cuando ya existe un indicador. En este caso, si el valor indicado en la variable es diferente del indicador que ya aparece en el gráfico. MetaTrader 5 entenderá esto como otro indicador. Si el valor es idéntico, MetaTrader 5 lo reconocerá como el mismo indicador.

Este enfoque permite limitar el número de indicadores con el mismo nombre en el gráfico a uno, y únicamente uno. Si así lo deseas, puedes establecer y permitir un número máximo de indicadores con el mismo nombre. Todo lo que necesitas hacer es modificar la prueba realizada en la línea 18. De esta forma, puedes configurar a MetaTrader 5 para aceptar, por ejemplo, 3 indicadores con el mismo nombre. Sin embargo, si el usuario intenta colocar un cuarto indicador con el mismo nombre, MetaTrader 5 lo prohibirá. Bueno, más precisamente, el código del indicador lo hará, ya que evitará este intento de colocar un cuarto indicador.

Como ves, es posible configurar y restringir el sistema hasta el punto de impedir tener indicadores duplicados en el gráfico. Esto es importante y se discutirá más a fondo más adelante en esta misma serie sobre el sistema de repetición/simulador.

Hay algunos puntos en el código de este indicador que explicaré más adelante para que puedas comprender cómo comunicarte entre el EA y el indicador sin usar las variables globales del terminal. Estos puntos son la línea 5 y la línea 10. Pero vamos paso a paso para que puedas entender realmente la lógica detrás de este tipo de programación.

Para que entiendas lo que realmente está pasando, puedes crear el código explicado anteriormente en detalle y ejecutarlo en la plataforma MetaTrader 5.

Conclusión

Aquí, en este artículo, podrás ver cómo funciona el bloqueo o restricción del posicionamiento de más de un indicador en el gráfico, después de crear y ejecutar el código explicado en detalle en la plataforma MetaTrader 5. Puedes usar estos conocimientos para facilitar muchas otras cosas, lo que te hará la vida mucho más fácil, tanto como operador como usuario de la plataforma MetaTrader 5, proporcionándote una mejor experiencia al utilizar la plataforma.

Aunque la razón de esto puede no estar clara en este artículo, los conocimientos presentados, si se utilizan bien y de la forma adecuada, te permitirán hacer mucho más y evitar una serie de problemas por tener indicadores duplicados o incluso innecesarios en el gráfico.

No es raro que un usuario con menos experiencia en el uso de MetaTrader 5 coloque el mismo indicador varias veces en el gráfico, lo que hace que el uso y la configuración de estos indicadores duplicados sea extremadamente desagradable. Y todo esto se puede evitar utilizando código, que, como has visto, es bastante sencillo pero extremadamente capaz de hacer lo que está diseñado para hacer.

Espero que estos conocimientos te sean útiles y los hayas asimilado. En el próximo artículo, te mostraré cómo podemos dar el siguiente paso en términos de allanar el camino para la comunicación directa entre el EA y el indicador, algo indispensable para lo que necesitaremos hacer en nuestro sistema de repetición/simulación.