Del básico al intermedio: Eventos (I)

Introducción

En el artículo anterior, "Del básico al intermedio: Struct (II)", hablamos sobre estructuras básicas y sobre cómo podríamos utilizarlas para pasar valores dentro de funciones y procedimientos. A pesar de que este tema sobre estructuras aún no se ha explorado a fondo, creo que todavía no es el momento de abordar ciertos aspectos presentes y posibles dentro de las estructuras. Esto se debe a que, hasta donde he podido observar, en MQL5 no es necesario que la programación sea muy avanzada. Y, por favor, no me malinterpretes por decir esto.

Lo que quiero decir con esto es que, con muy poco conocimiento, pero con una base de conceptos bien elaborada, tú, mi querido lector, puedes hacer e implementar casi cualquier tipo de aplicación para ser utilizada en MetaTrader 5. Y, teniendo en cuenta que, muy probablemente, en el 95 % de los casos —por no decir en más— vas a hacer aplicaciones simples, no veo motivo para entrar en detalles más complejos ahora.

Por tanto, voy a hacer una pausa en la explicación de los conceptos básicos de programación y vamos a empezar a ver cómo crear códigos para mostrar cómo implementar una aplicación para MetaTrader 5 utilizando MQL5 puro.

Bien, como este artículo explica los principios básicos de la implementación de códigos en MQL5, vamos a empezar por la implementación más básica. Pero antes de eso, necesitamos hablar de otro asunto.

Concepto básico sobre eventos

No me extenderé mucho sobre este tema, ya que hablar sobre lo que se refiere al título de este tema daría para escribir un libro entero sobre programación —y esto lo digo literalmente—, ya que es un tema extremadamente extenso y con muchas sutilezas. Sin embargo, antes de empezar a hablar sobre cómo implementar una aplicación que se utilizará en MetaTrader 5, debemos nivelar un poco las cosas.

Prácticamente todas las aplicaciones gráficas hacen uso de eventos. El momento en que se genera cada evento no depende de tu programa ni de lo que estés implementando. En general, esto es así. Existen casos especiales en los que podemos disparar eventos desde dentro de nuestra aplicación. Aunque, como son casos especiales, no debes tomar esto como una forma de controlar el código en ningún caso. En realidad, muchas veces, un programador que va a implementar algún tipo de código para ser ejecutado en un entorno concreto no está programando nada. Simplemente está indicando cómo su código deberá responder a cada uno de los eventos que se produzcan.

Algunos eventos pueden ignorarse en una aplicación, pero en otra tendrán prioridad sobre cualquier otra actividad. Y esto es algo muy complicado y difícil de entender para muchos principiantes, ya que hasta ahora todos los códigos presentados NO TENÍAN COMO OBJETIVO TRATAR EVENTOS. Simplemente ejecutan aquello para lo que fueron programados.

Sin embargo, cuando vamos a programar un indicador o incluso un asesor experto para utilizarlo en MetaTrader 5, no nos preocupamos en absoluto por hacer que las cosas ocurran. Aunque pueda parecer extraño, lo que nos interesa es indicar cómo deberá responder el indicador o el Asesor Experto a un evento determinado.

Por ejemplo, cuando usas un programa como Gimp, que te permite dibujar en una ventana, imaginas que el programa está trabajando de una manera determinada. Pero, en el fondo, simplemente está respondiendo a eventos que tú, como usuario, estás generando, como hacer clic, presionar una tecla o incluso arrastrar el mouse. Todo esto son eventos. El programa NO SABE ni le interesa estar mirando lo que estás haciendo. Simplemente espera un evento y responde a él. Y, al final, obtienes una imagen manipulada y dibujada.

Lo mismo sucede con MetaTrader 5: no importa lo que el usuario pueda estar haciendo. Simplemente se queda allí, inmóvil, esperando recibir algún tipo de evento. Cuando este ocurre, responde de alguna forma.

Pero espera, ¿quién es entonces el responsable de generar los eventos? Bueno, sin entrar en muchos detalles, eres tú. La responsabilidad de indicar qué aplicación gráfica va a recibir cada evento es del sistema operativo. Como usuario, no puedes indicarle esto al sistema operativo. Tú simplemente le dices al sistema operativo que tal aplicación debe hacer tal cosa, por ejemplo, ser minimizada, maximizada o qué sucede cuando se pide cerrar la aplicación.

A diferencia de lo que muchos piensan, NO ES el sistema operativo quien dice cómo se cerrará una aplicación, sino la propia aplicación. Por esta razón, cuando estás escribiendo un texto y pides cerrar la ventana de edición, el editor puede preguntarte si deseas guardar las modificaciones. Si el sistema operativo tuviera que encargarse de esto, sería mucho más complicado. En última instancia, por tanto, es la propia aplicación la que dice cómo responderá a un evento, nunca el sistema operativo. Por tanto, afirmar que un sistema es mejor que otro es, en mi opinión, una muestra de ignorancia y falta de conocimiento sobre cómo funcionan realmente las cosas.

Aunque MetaTrader 5 puede ejecutarse en un sistema operativo diferente a Windows, vamos a suponer que, en cualquier caso, se ejecuta dentro de Windows. Incluso si estás utilizando la versión web del terminal MetaTrader 5, por simplificar la explicación, vamos a dar por hecho que Windows es la base del sistema.

Bien, pero ¿por qué crear este concepto? El motivo es que tú, mi querido lector, interesado en aprender a programar para MetaTrader 5, necesitas entender que cualquier aplicación que se ejecute en MetaTrader 5 no responderá a eventos provenientes directamente de Windows, sino a eventos provenientes de MetaTrader 5. Nuevamente, es importante dejar esto claro: existen situaciones específicas en las que una aplicación que se ejecute en MetaTrader 5 responderá directamente a Windows. Pero esto es algo muy específico que exige un nivel de programación bastante avanzado, cosa que no se aplica en este momento.

Muy bien, entonces, ahora que hemos hablado de estas cosas y ya tenemos una cierta noción, podemos plasmar todo lo mencionado en una imagen. Esta imagen se encuentra justo debajo.

Imagen 01

Esta imagen es bastante emblemática, ya que nos muestra el camino que sigue un evento generado por el usuario hasta que alguna aplicación ejecutada en MetaTrader 5 lo recibe. Ten en cuenta que, aunque mencionemos una aplicación como un Asesor Experto, en realidad puede ser cualquier aplicación que se ejecute en MetaTrader 5. Sin embargo, como el Asesor Experto es el que responde a la mayoría de los eventos, si no a todos, lo utilicé para explicar dónde estaría nuestra aplicación en todo este proceso.

Esta fue la parte fácil; ahora viene la divertida. Existen dos tipos de eventos: los síncronos y los asíncronos. Los eventos síncronos pueden ocurrir cada cierto tiempo, por lo que están ligados de alguna manera con el reloj del sistema. Un ejemplo de este tipo de evento es la aparición de una nueva barra en el gráfico. Siempre ocurrirá de vez en cuando. Sin embargo, también pueden darse eventos síncronos que provienen de eventos no síncronos, lo que hace que algunas cosas resulten bastante interesantes. Sin embargo, antes de hablar de eventos síncronos que provienen de eventos no síncronos, debemos entender qué es un evento no síncrono.

Un evento asíncrono es todo evento generado de manera aleatoria. Por ejemplo, presionar una tecla, mover el mouse o incluso abrir o cerrar una posición. En este caso específico, la posición se abriría o cerraría por esta razón: el precio alcanzó cierto nivel. En resumen, un evento no síncrono es todo evento del que no se sabe cuándo ni en qué orden va a ocurrir.

Pero, como se ha mencionado, también es posible que los eventos síncronos se basen en eventos asíncronos. Un ejemplo de esta situación sería cuando seleccionas algo en el gráfico de MetaTrader 5 y después arrastras o eliminas el objeto. El momento en que ocurrió cada evento no importa, pero sí el orden o secuencia en que ocurrieron. Por eso muchas personas tienen dificultades para programar ciertos tipos de aplicaciones. Esto se debe a que puede ser necesario responder a eventos síncronos de origen no síncrono. De todos modos, no necesitas preocuparte por esto ahora. A medida que avancemos en los artículos, veremos cómo trabajar con este tipo de situaciones.

Primeros eventos en la práctica

Este es un momento en el que debo confesar que resulta algo desafiante. Quiero mostrarte cómo ocurren los eventos, pero no quiero crear algo que no tenga sentido. Por ello, vamos a necesitar recurrir a algún medio sencillo de entender y autoexplicativo. Así no perderemos mucho tiempo intentando explicar cómo ocurren los eventos y cómo son tratados. Este tipo de cosas es bastante intuitivo para quien entiende de eventos, pero puede resultar muy confuso para quien no. Así que vamos a hacer una primera captura y tratamiento de eventos en la práctica.

Antes de empezar, debemos comprender una característica excepcional de MQL5: la división entre diferentes tipos de aplicación. Básicamente, en MQL5 tenemos dos tipos de aplicación: las que pueden responder a eventos del usuario y las que no. Esto es directo. Entre las que pueden capturar y, por tanto, responder a eventos de interacción del usuario, se encuentran los indicadores y el Asesor Experto. Entre las que no pueden responder a eventos del usuario, por no poder capturar tales eventos, se encuentran los scripts y los servicios. Es importante saber esto para poder elegir la mejor alternativa.

Bien, básicamente hemos trabajado solo con scripts. En ellos, tenemos un punto de entrada, que es el procedimiento OnStart. A partir de ahí, todo debe generarse y controlarse por ti, como programador. Sin embargo, en este caso, queremos capturar eventos de cualquier tipo. Por eso, necesitamos comenzar a pensar con calma y conocer qué puede ofrecernos cada modelo permitido en MetaTrader 5.

Si estás leyendo este artículo, seguro que ya has utilizado, al menos parcialmente, MetaTrader 5 con las aplicaciones que vienen por defecto. En ese caso, habrás notado que podemos tener varios indicadores en un mismo gráfico. Sin embargo, solo puede haber un único Asesor Experto. Entonces, dependiendo de tu objetivo, podemos implementar las cosas en un indicador o en un asesor experto.

Sin embargo, hay un pequeño detalle que es necesario comprender antes incluso de empezar a implementar el código. Este detalle se refiere a las limitaciones existentes en los indicadores y en el Asesor Experto. Sí, mi querido lector, existen limitaciones.

Por ejemplo, un indicador NO PUEDE establecer contacto con el sistema de órdenes. Esta función es exclusiva del Asesor Experto. En cambio, el Asesor Experto NO PUEDE, al menos de forma simple, dibujar líneas ni efectuar cálculos orientados a indicar algo en el gráfico. Además, en principio, un asesor experto NO TIENE CÓMO acceder a las funciones de la biblioteca MQL5 para dibujar en el gráfico. Esta función es exclusiva de los indicadores. Por eso, es muy importante saber cómo trabajar con estos modelos. Y esto se mostrará aquí, a lo largo de los artículos.

Es posible que estés pensando: «Pero entonces no hay forma de crear algo que sea realmente útil, ya que existen limitaciones que nos impiden crear una aplicación única». De hecho, mi querido lector, MetaTrader 5 fue concebido para ser una plataforma muy estable y segura. Por esta razón, existen mecanismos que veremos en el futuro y que nos permiten comunicarnos con diferentes aplicaciones, lo que nos da la posibilidad de crear algo muy interesante y fácil de mantener a largo plazo.

Muy bien, tras esta primera y breve introducción al tema, vamos a empezar viendo cómo se capturan los eventos. Por ahora, no nos preocuparemos de tratarlos, solo de capturarlos. Para ello, inicialmente utilizaremos un indicador. Podéis verlo justo abajo, en su código mínimo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. int OnInit()
05. {
06.    return INIT_SUCCEEDED;
07. };
08. //+------------------------------------------------------------------+
09. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
10. {
11.    return rates_total;
12. };
13. //+------------------------------------------------------------------+

Código 01

Empezamos con el código mínimo para que el concepto de evento se comprenda bien. De nada sirve que te pongas a copiar código sin entender por qué necesita implementarse de esa forma.

Muy bien, entonces, cuando este indicador se coloque en el gráfico, ocurrirán algunas cosas en una secuencia lógica. Entender esto es muy importante para que puedas liberarte y comenzar a crear tus propios códigos. En este código 01, tenemos dos eventos que se están capturando. La forma en que MetaTrader 5 va a trabajar con estos eventos determinará cómo debemos tratarlos. Sé que esto puede resultar algo confuso al principio, pero podemos hacer que nuestra aplicación interactúe y realice acciones que los desarrolladores no imaginaron cuando implementaron MetaTrader 5. No obstante, para poder hacer esto, necesitamos entender cuándo y cómo se disparará cada evento.

Claro que aquí, como estamos en una fase inicial y nos centramos solo en la didáctica, no voy a mostrar cómo puedes «forzar» a MetaTrader 5 a hacer cosas que muchos consideran imposibles. Pero, si estudias y practicas lo suficiente, lograrás hacer prácticamente cualquier cosa usando MQL5 junto con MetaTrader 5, como, por ejemplo, un editor de vídeo o de imagen. Cosas para las que MetaTrader 5 no está destinado, ya que su objetivo principal es permitirnos comprar y vender instrumentos financieros en un mercado electrónico.

Muy bien, entonces ahora podemos tomar la imagen 01 y expandirla para que aparezca este código 01, que es un indicador. Con esto, tenemos el siguiente flujo de mensajes.

Imagen 02

En esta imagen 02 se muestra la extensión de la imagen 01. Lo que vemos en esta imagen 02 es lo que ocurre internamente en el último punto donde se tratan los eventos. Pues bien, como aquí vamos a tratar las cosas siguiendo una cierta dirección, tal vez sea interesante para ti entender un poco más sobre otros tipos de eventos que no abordaré aquí en los artículos.

Para ello, te recomiendo que consultes la documentación de MQL5 en: Funciones de manipulación de eventos, pues allí tendrás una idea mucho más detallada de los eventos que cubre MQL5, ya que cada uno de ellos tiene un propósito y un objetivo.

Pero, volviendo a nuestra cuestión, vamos a entender cuándo se disparará cada uno de estos eventos que hemos visto en el código 01. Para entenderlo, todo lo que necesitamos hacer es añadir un pequeño comando que ya se ha utilizado en los artículos. Así, el código 01 quedará como se muestra a continuación.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. int OnInit()
05. {
06.    Print(__FUNCTION__);
07. 
08.    return INIT_SUCCEEDED;
09. };
10. //+------------------------------------------------------------------+
11. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
12. {
13.    Print(__FUNCTION__);
14. 
15.    return rates_total;
16. };
17. //+------------------------------------------------------------------+

Código 02

Genial, ahora ya sabemos lo que ocurre entre bastidores. Pero al ver este código 02, puedes pensar: «Amigo, pero este código no sirve para nada». ¿Por qué crear algo así? Bien, mi querido lector, en realidad este código es extremadamente útil para lo que queremos hacer. Observa lo siguiente: lo único que hará este código es imprimir un mensaje en el terminal que indique qué evento se está capturando. Esto se hace en las líneas seis y trece. Sin embargo, fíjate en lo que ocurre cuando lo colocamos en cualquier gráfico.

Animación 01

En esta animación 01, podemos ver cuándo MetaTrader 5 disparó un evento que fue capturado por nuestro indicador, mostrado en el código 02. Y eso es precisamente lo que estás percibiendo, querido lector. A pesar de que nuestro modesto código parezca completamente inútil, ha sido capaz de mostrarnos cómo un evento disparado por MetaTrader 5 ha provocado que suceda algo que nosotros mismos habíamos programado. En este caso, el tratamiento que estamos dando a los eventos capturados es imprimir un mensaje sencillo en el terminal, algo que, en un principio, no parecía que fuera a ocurrir. Se observa la secuencia de disparos, pero también se aprecia que la línea 13 se ha impreso dos veces: la primera, cuando se colocó el indicador en el gráfico; y la segunda, cuando cambió la cotización del símbolo.

Entender este tipo de cosas es extremadamente importante y nos será de gran utilidad, ya que, al estar tratando eventos provenientes de MetaTrader 5, necesitaremos cambiar la forma de implementar los códigos cuando trabajemos con indicadores y asesores expertos, que son los únicos que responden a eventos disparados por MetaTrader 5.

Genial. Vamos a realizar un nuevo cambio en el código 02 para añadir un manejador de eventos más. Ahora, el código que se va a ejecutar es el que podemos ver justo debajo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. int OnInit()
05. {
06.    Print(__FUNCTION__);
07. 
08.    return INIT_SUCCEEDED;
09. };
10. //+------------------------------------------------------------------+
11. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
12. {
13.    Print(__FUNCTION__);
14. 
15.    return rates_total;
16. };
17. //+------------------------------------------------------------------+
18. void OnDeinit(const int reason)
19. {
20.    Print(__FUNCTION__);
21. };
22. //+------------------------------------------------------------------+

Código 03

De nuevo, tenemos un código muy sencillo que, aparentemente, no servirá para nada. Sin embargo, cuando lo ejecutemos, veremos qué ocurre.

Animación 02

De la misma forma que ocurrió en el primer caso, en el que observábamos cómo respondía nuestra aplicación a los eventos disparados por MetaTrader 5, aquí tenemos otro tipo de captura. Quiero que entiendas lo siguiente, querido lector: el indicador se encontraba en el gráfico y este utilizaba un marco temporal determinado. Tan pronto como cambiamos el marco temporal, se dispara un evento que, a su vez, está siendo capturado por el indicador mostrado en el código 03.

Ahora viene la parte que nos interesa. Cuando se producía el cambio de marco temporal con el indicador mostrado en el código 02 presente en el gráfico, simplemente perdíamos ese evento. En otras palabras, ignorábamos el hecho de que MetaTrader 5 lo iba a disparar y simplemente afirmábamos lo siguiente:

Mira, MetaTrader 5, haz lo que sea necesario para que todo siga funcionando, porque no tengo ningún problema con eso.

Entonces, MetaTrader 5 disparaba el evento, pero el código 02 lo ignoraba. Así, teníamos la impresión de que el indicador sabía cómo actuar en ese tipo de situaciones. Sin embargo, no siempre eso es lo que realmente queremos que suceda. En estos casos, podemos utilizar un procedimiento que se ve en la línea 18 del código 03 para capturar este evento y, de esta manera, adoptar las medidas necesarias para evitar que sucedan otros eventos inesperados.

Sé que muchos de ustedes, sobre todo quienes ya tienen cierta familiaridad con la programación en MQL5, piensan que no necesitamos preocuparnos por muchos eventos que ocurren en un indicador. Sin embargo, existen situaciones en las que, si ignoras ciertos eventos, podrías llegar a experimentar fallos extraños reportados por MetaTrader 5, ya que, si tu aplicación no toma las medidas necesarias, MetaTrader 5 tomará la libertad de hacer lo que sea necesario para garantizar que los problemas de tu código no lleguen a interferir con el funcionamiento general de la plataforma.

Aunque muchos piensen que es difícil que los indicadores tengan errores, de hecho ocurren y, cuando esto pasa, si MetaTrader 5 dispara un evento que nuestro código ignora, es posible que tengamos problemas de rendimiento en la plataforma, como lentitud o incluso bloqueos. Pero la culpa no es de MetaTrader 5, sino de tu aplicación, que no responde adecuadamente a los eventos disparados.

Para demostrarlo, vamos a implementar un código muy sencillo y divertido que tiene un objetivo muy sencillo, pero interesante: decirnos cuántas veces se disparó el evento OnCalculate durante un período de tiempo determinado. Este código se puede ver a continuación:

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. uint gl_Counter;
05. //+------------------------------------------------------------------+
06. int OnInit()
07. {
08.    gl_Counter = 0;
09. 
10.    Print(__FUNCTION__);
11. 
12.    return INIT_SUCCEEDED;
13. };
14. //+------------------------------------------------------------------+
15. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
16. {
17.    if (!gl_Counter)
18.    {
19.       uint arr[];
20. 
21.       if (FileLoad(_Symbol, arr) > 0)
22.          gl_Counter = arr[0];
23.    }
24.    
25.    Print(__FUNCTION__, " :: ", ++gl_Counter);
26. 
27.    return rates_total;
28. };
29. //+------------------------------------------------------------------+
30. void OnDeinit(const int reason)
31. {
32.    uint arr[1];
33. 
34.    arr[0] = gl_Counter;
35.    FileSave(_Symbol, arr);
36. 
37.    Print(__FUNCTION__);
38. };
39. //+------------------------------------------------------------------+

Código 04

En este código no hay nada que no se haya visto y comentado ya, por lo que es perfectamente comprensible para cualquier persona que esté estudiando y practicando lo que se ha mostrado en estos artículos. Tal vez la única parte que pueda generar alguna duda sea la relacionada con las funciones FileLoad y FileSave. Como están muy bien explicadas en la propia documentación, no veo motivo para dar más detalles aquí.

Sin embargo, cuando se ejecuta, este código 04 genera algo parecido a lo que se muestra a continuación.

Animación 03

Observa que, aunque cambiemos el marco temporal, el contador sigue incrementándose. Esto se debe precisamente a que, en la línea 30 de este código, estamos capturando el evento que MetaTrader 5 dispara cuando algo necesita ser hecho por nuestro código. En este caso, no estamos tratando ninguna de las causas que hicieron que MetaTrader 5 disparara el evento. Solo le indicamos a MetaTrader 5 que guarde en disco una variable determinada. Podríamos hacer esto de diversas otras maneras, como discutiremos pronto. Pero el objetivo aquí es mostrar precisamente que puede haber situaciones en las que necesitamos tratar un evento y otras en las que podemos ignorarlo. Todo depende de qué y cómo pretendemos alcanzar nuestro objetivo final.

Ahora, fíjate que, si el procedimiento de la línea 30 no existiera o no tratáramos el evento de manera adecuada, el contador comenzaría desde cero cada vez que cambiáramos el marco temporal. Esto es lo que ocurre en la línea ocho, donde comenzamos a contar cuántas veces se ha ejecutado OnCalculate. Este código es bastante interesante, ¿no crees? Es sencillo, pero nos permite comprender diversos aspectos relacionados con los eventos generados por MetaTrader 5.

Consideraciones finales

En este artículo, empezamos a divertirnos de manera mucho más intensa. Esto se debe a que este es el primero de una serie de artículos en los que veremos cómo tratar los eventos. Intentaré abordar este tema de forma lúdica, sencilla y didáctica, y te mostraré que no siempre debemos utilizar la solución propuesta por otro programador. Esto se debe a que, en la mayoría de las ocasiones, la solución propuesta por una persona puede que no sea la ideal para ti en ese momento concreto.

Sé que muchos están ansiosos por ver lo que se tratará en los próximos artículos, pero antes de lanzarse de lleno a algo que se volverá cada vez más complicado, te recomiendo que practiques y estudies lo que se ha visto en este artículo. Te aseguro que valdrá mucho la pena practicar y procurar entender lo visto aquí. Como sugerencia e incentivo para que puedas pensar en qué puedes practicar, intenta modificar el código 04, que encontrarás en el anexo, para que el valor del contador se almacene solo si hay un evento de cambio de marco temporal. En cualquier otro tipo de evento que MetaTrader 5 llegue a disparar, el contador deberá reiniciar su recuento desde cero.

En el próximo artículo, te mostraré cómo puedes hacerlo de forma bastante segura y sencilla. Así que, manos a la obra y a estudiar.