Simulación de mercado (Parte 06): Transfiriendo información desde MetaTrader 5 hacia Excel

Introducción

Una de las cosas que más complican la vida a algunas personas con MetaTrader 5 es la falta de ciertos recursos, por así decirlo.

A muchas personas, especialmente a los no programadores, les resulta muy difícil transferir información entre MetaTrader 5 y otros programas. Uno de esos programas es Excel. Muchos utilizan Excel para gestionar y controlar sus riesgos, ya que es un programa muy bueno y fácil de aprender, incluso para quienes no son programadores de VBA. Sin embargo, transferir información de MetaTrader 5 a Excel, o viceversa, no es una tarea sencilla, sobre todo si no se tienen conocimientos de programación.

No obstante, es bastante útil que exista esta comunicación, pues facilita la vida de quienes desean operar y gestionar el riesgo que asumen mediante Excel. Sin conocimientos adecuados de programación, es muy probable que termines utilizando programas desconocidos o que renuncies a utilizar MetaTrader 5 simplemente porque no logras transferir información de la plataforma a Excel.

Por fortuna, Excel ofrece varias formas interesantes de lograrlo. Más adelante hablaremos de ellas con más detalle. Sin embargo, MetaTrader 5 no dispone de ningún recurso estándar que permita enviar información a Excel, por lo que es necesario tener conocimientos de programación o adquirir alguna herramienta para transferir los datos.

Entender el problema

Empecemos por comprender las primeras dificultades y los métodos más habituales de transferencia de datos entre programas y Excel. Uno de los métodos más habituales es utilizar RTD (Real Time Data) o DDE (Dynamic Data Exchange). Sin embargo, ambas soluciones requieren conocimientos sobre cómo programar una interfaz COM (Component Object Model), y muchos programadores no los tienen. Además, aunque logres crear algo así, no es una solución muy flexible.

Tanto RTD como DDE son formas de comunicación unidireccionales, es decir, que únicamente ejecutan el puente entre un sistema y otro, sin permitirnos ciertas cosas que también resultan interesantes, sobre todo en Excel. Pero, el hecho de que Excel cuente con soporte nativo para estos sistemas es una gran ventaja, ya que tendremos un tipo de comunicación en tiempo real.

Pero pensemos en términos más amplios: ¿cuántas veces necesitas realmente información en Excel en tiempo real? En la mayoría de los casos, un pequeño retraso es perfectamente aceptable. Y aquí no me refiero a personas que desean utilizar Excel como sistema de control para operar con algún robot. Si utilizas MetaTrader 5, sin duda querrás que los cálculos se realicen dentro de la propia plataforma y no enviarlos a Excel para que este calcule la posición y, basándose en los resultados, haga que el Asesor Experto tome una decisión dentro de MetaTrader 5, porque hacerlo así no tiene ningún sentido.

Sin embargo, quienes realizan operaciones que pueden durar dos o más días o quienes operan con la estrategia Long Short, sin duda querrán contar con Excel para gestionar con mayor tranquilidad el capital utilizado y para tomar decisiones relacionadas con el control de riesgos. En este caso, querrás que Excel reciba las cotizaciones e informaciones de manera automática. Imagina que estás trabajando con la estrategia Long Short y mantienes 20 posiciones en ese modelo. Tendrías que actualizar manualmente 40 cotizaciones cada día o cada hora, dependiendo de cómo operes.

El riesgo de cometer algún tipo de error o hacer alguna tontería es enorme, sin mencionar el tiempo que perderías transfiriendo esas 40 cotizaciones una por una. Vaya trabajazo.

Por ello, algunas personas buscan soluciones para este problema. Una de ellas consiste en utilizar cotizaciones que provienen directamente de la web.

Solución web

Esta solución web se basa en utilizar el propio Excel para realizar las actualizaciones por nosotros, de manera automática. Pero aquí aparece un pequeño problema.

Aunque es una solución fácil de crear, no es adecuada. Esto se debe a que habrá un retraso entre las cotizaciones, que puede ser mayor o menor. Sin embargo, este retraso no se debe a las capturas, sino a que la mayoría de los servicios de información financiera son de pago.

No existe almuerzo gratis. No cuando el asunto es ganar dinero.

No estoy aquí para juzgar si es correcto o incorrecto cobrar por estos servicios. La cuestión aquí es: ¿qué sentido tiene hacer uso de esto si tienes una plataforma en tus manos? En este caso, MetaTrader 5.

Al utilizar esta solución, el usuario abre en Google la hoja de cálculo relacionada con su correo electrónico. En esta hoja, escribe el siguiente comando:

GoogleFinance

Al añadir este comando a una celda de la hoja de cálculo en línea, podrás llevar a cabo una serie de acciones relacionadas con el símbolo del que deseas obtener datos. Todos estos datos se actualizarán periódicamente. Normalmente, hay un retraso entre estas actualizaciones. Si estás operando una posición que solo puede modificarse después de algunos días, ese retraso no es un problema. Esto pensando en términos de Buy and Hold, pero si estás haciendo trading, la cosa puede ser un poco más complicada.

Pero, volviendo a la cuestión principal, cuando termines de editar la hoja de cálculo en línea, podrás guardarla y exportarla para utilizarla en otro sitio. En realidad, no se tratará de una exportación auténtica. Lo que quieres es obtener los valores que la función GoogleFinance está capturando y pasarlos a otra hoja de cálculo, esta vez en tu terminal, para poder trabajar con más calma.

Aunque esta solución funciona para la mayoría de los casos, no es adecuada para todos. En algunos casos, de hecho, necesitamos la cotización, y normalmente solo la cotización, pero con un mínimo de retraso. Sin embargo, independientemente de lo que se haga, no se conseguirá una velocidad de actualización inferior a un minuto con esta solución. Esto se puede observar en la imagen 01.

Imagen 01 - Ventana de propiedades

En esta imagen 01, vemos la ventana de propiedades que ajusta la temporización de actualización del componente importado por Excel. Si no sabes cómo se llega a esta ventana o nunca la has visto, no te preocupes. Te mostraré cómo se llega a este punto. Pero ten en cuenta lo siguiente: aunque pongas el tiempo mínimo de un minuto, no significa que la cotización utilizada tenga un retraso de un minuto entre ellas, ya que la función GoogleFinance no se actualiza a esta velocidad.

Así que es bueno que seas consciente de lo que estamos haciendo aquí. Te voy a mostrar cómo obtener la cotización del símbolo con un retraso de un minuto. Si quieres tener una cotización en tiempo real, con cada variación de precio, tendrás que usar un enfoque diferente. El enfoque que veremos aquí cumplirá perfectamente su objetivo en la mayoría de los casos y será muy útil para resolver una amplia variedad de problemas. Esto se debe a que la programación necesaria es muy fácil de entender y a que tendremos una forma bastante eficaz de comunicación entre MetaTrader 5 y Excel.

Comprender la implementación

Existen soluciones mucho más complejas que utilizan Python para obtener una cotización en tiempo real, y otras más simples que emplean RTD o DDE. Sin embargo, la que veremos aquí se puede crear directamente en MQL5, es fácil y rápida de implementar, y al mismo tiempo es elegante y agradable de utilizar.

Lo primero que necesitas entender es que existen cuatro formas básicas de aplicación para MetaTrader 5, cada una adecuada para un propósito determinado.

• Expert Advisor: los conocidos EA, o robots, son aplicaciones de MetaTrader 5 que nos permiten enviar órdenes o solicitudes de trading al servidor presente en la Bolsa. Estos programas están básicamente orientados a este tipo de tarea.
• Indicadores: permiten añadir o mostrar algo en el gráfico. Sirven para diversas funciones relacionadas con el monitoreo del precio, con el fin de mostrarnos algo específico para lo que fueron programados.
• Script: estos permiten realizar algún tipo de tarea. Normalmente, los scripts entran y salen muy rápidamente del gráfico, sin permanecer allí por mucho tiempo. Pero siempre están vinculados a un gráfico específico.
• Servicios: al igual que los scripts, normalmente ejecutan algún tipo de tarea específica y entran y salen rápidamente. Pero, a diferencia de los scripts, los servicios no están vinculados a ningún gráfico en particular y permanecen activos incluso cuando no hay ningún gráfico abierto en el terminal MetaTrader 5.

Como habrás notado, todas las aplicaciones de MetaTrader 5 son útiles. Pero los servicios son los únicos que no dependen de si hay un gráfico abierto en la plataforma, por lo que son la mejor solución.

Nota: aunque los servicios y los scripts tienen un comportamiento diferente, ya que los scripts están vinculados a un gráfico, en términos de código son prácticamente idénticos. La única diferencia entre ellos es que un servicio tiene activada la siguiente propiedad en su código:

#property service

El mero hecho de que esta línea esté presente en el código del script hace que deje de ser un script y se convierta en un servicio.

Por lo tanto, la solución que utilizaremos será crear un servicio. No obstante, como he mencionado, también se puede utilizar como un script. En este caso, estará vinculado a un gráfico. El único cambio que habrá que hacer en el código será eliminar la propiedad mostrada arriba. Volveremos a esto más adelante, cuando veamos el código en sí.

Comenzar a implementar la solución

Dado que algunos lectores tal vez no tengan muchos conocimientos de Excel, mostraré cómo hacer las cosas en él, al menos lo básico. Si ya conoces este programa, puedes pasar al siguiente tema, donde mostraré cómo implementar el servicio en MQL5 para usarlo en MetaTrader 5 y obtener los datos que quieras directamente en Excel.

Antes de hacer nada, deberás editar un pequeño archivo. MetaTrader 5 lo utilizará más adelante, pero no puedes colocarlo en cualquier sitio. Por motivos de seguridad, MQL5 no te permite utilizar cualquier punto del sistema de archivos de tu computador. Para hacerlo correctamente, abre MetaEditor y, en la pestaña de navegación, haz lo que se muestra en la animación 01 a continuación:

Animación 01 - Acceso al directorio correcto

Al hacerlo, se abrirá el explorador de archivos del sistema operativo y te encontrarás en la carpeta FILES, dentro del directorio MQL5. El archivo que deberás crear debe estar inicialmente en esta carpeta. Dentro de esta carpeta, deberás crear el siguiente archivo que se muestra a continuación. Esto solo es para ejemplificar lo que haremos realmente.

PETR4;
VALE3;
ITUB3;

Guarda este archivo con el nombre QUOTE.CSV. Pero no cierres todavía el explorador de archivos. Lo necesitaremos en la siguiente etapa para localizar fácilmente el archivo que acabamos de guardar.

Ahora abre Excel, con una hoja en blanco, y sigue la siguiente secuencia para vincular este archivo QUOTE.CSV con la hoja de cálculo que estamos creando en Excel.

Figura 02

En esta figura 02 se muestra dónde se encuentra la opción a la que necesitaremos acceder. Si no está disponible en Excel, búscala en Get Data. En cualquier caso, deberás seleccionar la opción de importar datos desde un archivo de texto. El proceso sería casi igual que importar datos desde la web, pero aquí utilizaremos un archivo.

Figura 03

Tras utilizar la opción mostrada en la figura 02, se abrirá una ventana de búsqueda. Navega por ella hasta el lugar indicado en el explorador de archivos para llegar al archivo QUOTE.CSV, que estará guardado en el directorio MQL5. Cuando lo encuentres, selecciónalo y verás el contenido mostrado en la figura 03. Observa las configuraciones de carga del archivo que se muestran en la parte superior de la figura 03. Si todo está correcto, haz clic en la flecha que hay junto al botón Load y selecciona Load To... Serás dirigido a la figura 04.

Figura 04

En esta figura 04 puedes seleccionar dónde se insertarán los datos en la hoja de cálculo. En este caso, y dado que se trata solo de una demostración, déjalo tal y como se indica en la región resaltada. A continuación, haz clic en el botón "OK" y obtendrás el resultado que se muestra en la figura 05.

Figura 05

Bien. Los datos ya están cargados. Pero, aún queda un paso más: indicar a Excel cómo y cuándo deben actualizarse. Recuerda que no estamos utilizando un servidor RTD ni DDE. Por lo tanto, es necesario indicarle a Excel cuándo debe actualizar esos datos; de lo contrario, nunca se actualizarán. Si tienes conocimientos de VBA, podrás desarrollar algo mejor. Pero aquí quiero mantener las cosas sencillas, para que cualquiera pueda lograr el objetivo propuesto. Para que Excel sepa cómo y cuándo actualizar los datos del archivo QUOTE.CSV, debes acceder a lo que se muestra en la figura 06.

Figura 06

Al seleccionar la tabla en Excel, la pestaña Query se activará. En ella, selecciona el elemento Properties, como se muestra en la imagen superior. Al hacer clic en este elemento, verás inicialmente la figura 07.

Figura 07

Observa con atención la figura 07. En esta ventana, deberás modificar algunos ajustes para que Excel pueda actualizar automáticamente los datos. Ten en cuenta que el objeto que se actualizará es únicamente la tabla que acabamos de crear a partir de los datos del archivo QUOTE.CSV. Por lo tanto, cambia la configuración de la figura 07 para que quede como se muestra en la figura 08.

Figura 08

Cuando confirmes los cambios haciendo clic en OK, Excel pasará a seguir las configuraciones definidas. Así, aproximadamente cada 60 segundos, se actualizarán los datos de la hoja de cálculo conforme se vayan modificando en el archivo. Prueba lo siguiente: abre el archivo en un editor de texto y añade un valor, más o menos como se muestra a continuación.

PETR4;30.80
VALE3;190.31
ITUB3;25.89

Guarda el archivo QUOTE.CSV, pero no es necesario que cierres el editor de texto. Espera un momento y comprueba el resultado en Excel. Verás que la hoja de cálculo se actualiza casi como por arte de magia, tal y como se muestra en la figura 09.

Figura 09

Cambia los valores de nuevo usando el editor de texto hasta que comprendas lo que está ocurriendo. Nota que, a partir de este momento, podemos hacer muchas cosas sin necesidad de recurrir a soluciones complicadas o ineficientes. Otra cosa que tal vez sea interesante mencionar es que puedes usar un recurso compartido local. De este modo, Excel puede ejecutarse en un terminal diferente al de MetaTrader 5, sin necesidad de que estén en la misma máquina.

Implementación del servicio en MQL5

En la explicación del tema anterior, mencioné el uso de un archivo y dónde debes colocarlo. Pero para finalizar realmente este artículo, necesitamos crear el servicio que se ejecutará en MetaTrader 5, aunque no te preocupes, porque es muy sencillo de crear y utilizar. De hecho, al final del artículo encontrarás un vídeo demostrativo que resolverá cualquier duda sobre el funcionamiento del sistema.

Antes que nada, debo decir que, a diferencia de lo que se muestra en el vídeo de demostración, no es necesario tener los símbolos en la ventana de Observación de mercado. En el vídeo, los símbolos aparecen solo para que puedas seguir visualmente cómo se desarrolla el proceso. En una ejecución típica, eso no es realmente necesario; el servicio puede ejecutarse por sí solo sin interferir en los símbolos de la ventana de observación de mercado ni en el rendimiento de MetaTrader 5.

Muy bien, partiendo del hecho de que ya has creado el archivo que necesitamos, tal y como se mostró en el tema anterior, podemos pasar al código del servicio y entender así cómo funcionará todo el proceso. A continuación se muestra el código completo del servicio:

01. //+------------------------------------------------------------------+
02. #property service
03. #property copyright "Daniel Jose"
04. #property description "Quote sharing service between"
05. #property description "MetaTrader 5 and Excel"
06. #property version   "1.00"
07. //+------------------------------------------------------------------+
08. input string user01 = "Quote.csv"; //FileName
09. //+------------------------------------------------------------------+
10. class C_ShareAtExcel
11. {
12.     private :
13.             string  szSymbol[],
14.                     szFileName;
15.             int     maxBuff;
16.             bool    bError;
17. //+------------------------------------------------------------------+
18. inline void Message(const string szMsg)
19.                     {
20.                             PrintFormat("Sharing service with Excel: [%s].", szMsg);
21.                     }
22. //+------------------------------------------------------------------+
23.     public  :
24. //+------------------------------------------------------------------+
25.             C_ShareAtExcel(string szArg)
26.                     :bError(true),
27.                      maxBuff(0),
28.                      szFileName(szArg)
29.                     {
30.                             int     file;
31.                             string  sz0, szRet[];
32.     
33.                             if ((file = FileOpen(szFileName, FILE_CSV | FILE_READ | FILE_ANSI)) == INVALID_HANDLE)
34.                             {
35.                                     Message("Failed");
36.                                     return;
37.                             }
38.                             while (!FileIsEnding(file))
39.                             {
40.                                     sz0 = FileReadString(file);
41.                                     if (StringSplit(sz0, ';', szRet) > 1)
42.                                     {
43.                                             ArrayResize(szSymbol, maxBuff + 1);
44.                                             szSymbol[maxBuff] = szRet[0];
45.                                             StringToUpper(szSymbol[maxBuff]);
46.                                             maxBuff++;
47.                                     }
48.                             }
49.                             FileClose(file);
50.                             bError = false;
51.                             Message("Started");
52.                     }
53. //+------------------------------------------------------------------+
54.             ~C_ShareAtExcel()
55.                     {
56.                             ArrayResize(szSymbol, 0);
57.                             Message("Finished");
58.                     }
59. //+------------------------------------------------------------------+
60.             void Looping(int seconds)
61.                     {
62.                             string  szInfo;
63.                             int     file;
64.                             
65.                             while ((!_StopFlag) && (!bError))
66.                             {
67.                                     szInfo = "";
68.                                     for (int c0 = 0; c0 < maxBuff; c0++)
69.                                             szInfo += StringFormat("%s;%0.2f\r\n", szSymbol[c0], iClose(szSymbol[c0], PERIOD_D1, 0));
70.                                     if ((file = FileOpen(szFileName, FILE_TXT | FILE_WRITE | FILE_ANSI | FILE_SHARE_WRITE)) != INVALID_HANDLE)
71.                                     {
72.                                             FileWriteString(file, szInfo);
73.                                             FileClose(file);
74.                                     };
75.                                     Sleep(seconds * 1000);
76.                             }
77.                     }
78. //+------------------------------------------------------------------+
79. };
80. //+------------------------------------------------------------------+
81. C_ShareAtExcel *share;
82. //+------------------------------------------------------------------+
83. void OnStart()
84. {
85.     share = new C_ShareAtExcel(user01);
86.     
87.     share.Looping(2);
88.     
89.     delete share;
90. }
91. //+------------------------------------------------------------------+

Código fuente del servicio

Como puedes observar, el código es muy compacto. Pero, como es mi costumbre, aquí hacemos uso de una clase, de modo que, si en el futuro se toma esa decisión, se pueda reutilizar el código en otro tipo de aplicación. Sin embargo, nada te impide crear este mismo código como un único procedimiento, con todo el contenido dentro de la función OnStart.

Pero vayamos a los detalles y a la explicación del funcionamiento del código. De este modo, incluso si estás empezando con MQL5, podrás adaptarlo para transferir otras informaciones a Excel. Nota: aquí me refiero a Excel, pero nada impide que transfieras datos a otros programas o sistemas.

En la línea 2 se indica la propiedad del código. Esto le indicará a MQL5 que el código debe tratarse como un servicio. Si deseas utilizarlo como un script, deshabilita o elimina esta línea. Esto no influirá en el trabajo ni en la ejecución del código, solo hará que quede vinculado a un gráfico para que pueda funcionar.

En la línea 8, damos al usuario la posibilidad de indicar qué archivo va a utilizar. Recordamos que el archivo debe crearse y editarse tal y como se informó en el tema anterior; de lo contrario, el sistema no funcionará.

En la línea 10, iniciamos la creación de nuestra clase. Atención a la línea 12, donde declaramos una sección privada, es decir, todo lo que venga a partir de este punto será privado de la clase y no podrá ser accedido desde fuera de ella. A continuación, declaramos algunas variables globales para la clase y, justo después, en la línea 18, creamos un procedimiento para estandarizar los mensajes que se imprimirán en el terminal. Estos mensajes indican lo que está haciendo el servicio.

En la línea 24, declaramos una sección pública. A partir de aquí, todo lo que haya en la clase podrá accederse como si formara parte de ella. Inmediatamente después, en la línea 26, comenzamos a crear un constructor de la clase. Recibirá como argumento el nombre del archivo que usaremos. Observa que la programación está pensada para que la clase no forme parte del código del servicio. Esta es la forma correcta de trabajar con programación orientada a objetos (POO). Aunque tengamos la información de la línea 8, debemos pensar como si no la tuviéramos y que se pasará después.

Aquí, en la línea 33, intentaremos abrir el archivo indicado. Si no tenemos éxito al intentar abrirlo para lectura, lo indicaremos en la línea 35 y el código retornará a la línea 36. Sin embargo, si el archivo puede accederse, comenzaremos a leerlo. La lectura se realizará línea por línea y, para ello, usaremos el bucle que se inicia en la línea 38. En la línea 40, leemos una línea completa del archivo indicado. En la línea 41, aislaremos el código del símbolo de cualquier otro tipo de información presente en ella. Observa que hacemos uso del separador punto y coma (;).

Si la línea 41 indica que el sistema es válido, asignaremos una nueva posición en la memoria y almacenaremos el código del símbolo en dicha posición. Ten en cuenta que el código no necesita estar en mayúsculas, ya que en la línea 45 lo ajustamos. No obstante, ten en cuenta que no existe ninguna verificación para comprobar si el símbolo realmente existe. Es decir, necesitas indicar el código de un símbolo válido. Sin embargo, este tipo de comprobación no es totalmente necesaria aquí. Me refiero a la verificación del código del símbolo, ya que, cuando se carguen los datos en Excel, te darás cuenta rápidamente de si hay algo extraño y podrás corregirlo. Por esta razón, no es necesario verificar el código del símbolo dentro de MQL5.

Si todo ocurre correctamente, cerraremos el archivo e informaremos en el terminal que el servicio está activo, utilizando la línea 51.

A continuación, veremos el destructor de la clase. Su código comienza en la línea 54. Con solo dos líneas, este destructor liberará la memoria asignada e informará de que la clase está siendo tomada de la lista de tareas del sistema.

Ahora, en la línea 60 tenemos el procedimiento principal de nuestra rutina. Este procedimiento hará que la clase permanezca en bucle hasta que se finalice el servicio. El bucle comienza en la línea 65. Atención: este bucle no genera sobrecarga en el procesador ni en la plataforma. Entre una ejecución y otra, establecemos un intervalo para que puedan ejecutarse otras tareas. Este intervalo se define en segundos y se pasa como argumento en la llamada. Dicho argumento se usa en la línea 75, donde la pausa se produce antes de que se ejecute el siguiente ciclo.

Y es aquí donde sucede la magia, dentro de este bucle. En la línea 67, limpiamos el contenido de la cadena que se grabará en el archivo. Para que la grabación sea lo más rápida posible, ya que podríamos estar escribiendo mientras Excel lee los datos (y sí, esto puede suceder), en la línea 68 se ejecuta un bucle. Este bucle construirá, en la línea 69, los datos que se enviarán a Excel. En este punto, puedes colocar cualquier cosa. Literalmente, cualquier cosa.

Cuando el bucle de la línea 68 finalice, intentaremos acceder al archivo en la línea 70. Atención: normalmente, intentar escribir en un archivo al mismo tiempo que otra aplicación intenta leerlo genera errores de acceso. Algunos de estos errores pueden causar fallos en la transferencia de datos. Este tipo de fallo se estudia ampliamente cuando se trabaja con algoritmos del tipo productor-consumidor. Pero, en este caso, MQL5 nos permite, por fortuna, utilizar el indicador FILE_SHARE_WRITE, que informa al sistema de que es posible que estemos accediendo al archivo al mismo tiempo que otra aplicación.

Si tenemos éxito al escribir en el archivo, este se graba en una sola llamada, en la línea 72. Justo después, en la línea 73, se cierra el archivo.

Así, el ciclo se completa y permanece en ejecución durante todo el tiempo.

Conclusión

En este artículo has aprendido a transferir datos de MetaTrader 5 a Excel de forma sencilla e interesante, un método ideal para hacer un seguimiento de tu cartera o de operaciones que no requieren actualización en tiempo real.

En el siguiente vídeo puedes ver cómo funciona el sistema y aclarar cualquier duda que pueda surgirte respecto al uso de valores financieros. Dado que el sistema es muy sencillo y la explicación del artículo es más que suficiente para que cualquiera pueda utilizar el código, no se adjuntará ningún archivo, especialmente porque todo dependerá de los símbolos que tú realmente vayas a monitorizar.