Desarrollo de un sistema de repetición (Parte 48): Conceptos que hay que entender y comprender

Introducción

En el artículo anterior Desarrollo de un sistema de repetición (Parte 47): Proyecto Chart Trade (VI), logramos hacer funcional el indicador Chart Trade. Así que podemos volver a centrarnos en lo que realmente necesitamos desarrollar.

Al inicio de esta serie de artículos sobre el sistema de repetición/simulador, intenté durante algún tiempo que el servicio pudiera colocar el indicador de control en el gráfico. Aunque no lograba hacerlo en un principio, no desistí y continué intentando. A pesar de numerosos intentos fallidos, no conseguía tener éxito en lograr tal cosa. Y como el proyecto no podía quedarse parado, en ese momento decidí seguir adelante de otra manera.

Sin embargo, lo que me atormentaba era el hecho de que podía hacer las cosas utilizando un script, pero cuando intentaba hacerlo usando un servicio, no lograba de ninguna manera que funcionara como esperaba.

Bueno, pero ahí podrías pensar: ¿y qué? El hecho de conseguir hacerlo usando un script no significa nada. Sin embargo, si piensas así, debo pedirte disculpas por tu falta de conocimiento en programación MQL5. Cualquier script creado en MQL5 puede transformarse en un servicio. Básicamente, hay dos diferencias entre un servicio y un script. Aunque existen más, estas dos son más evidentes y cualquiera puede darse cuenta.

La primera diferencia es que el script siempre está vinculado a un gráfico determinado y permanece allí hasta que el gráfico se cierra. Un detalle es que, al cambiar el marco temporal, MetaTrader 5 realmente envía un comando para que el gráfico se trace de nuevo. Sin embargo, para hacerlo más rápidamente, cierra el objeto gráfico (no la ventana, sino el objeto dentro de la ventana) y abre uno nuevo. Esto permite redibujar rápidamente el gráfico. Sin embargo, cuando haces esto, el script no vuelve al gráfico, ya que no tiene esta capacidad porque no tiene ciertos eventos en él.

Entonces, si quieres usar un script para observar el gráfico, no podrás hacerlo directamente en él. La forma de hacerlo es usar algo fuera del gráfico que sea capaz de observarlo. Esto parece muy complicado y confuso. Sin embargo, en la mayoría de las ocasiones puedes lograrlo modificando algunos detalles en el código y convirtiendo un script en un servicio. De esta forma, el servicio dejará de estar vinculado a un gráfico concreto, pero podrá seguir observando el gráfico del activo.

Tal vez no consigas entender de hecho la lógica y el motivo por el cual esto debería suceder. Pero si no lo consigues, no será posible pasar a las siguientes etapas que tendremos que realizar. Por tanto, es extremadamente importante que un servicio pueda observar lo que está sucediendo en un gráfico específico para lo que necesitaremos hacer en breve. No porque tengamos que construir, sino porque necesitaremos observar.

Por tanto, utiliza este artículo como recurso de investigación, ya que el contenido que contiene será extremadamente necesario para el sistema de repetición/simulación. Además, te será de gran utilidad para proyectos mucho más complejos y elaborados. Cuando necesitemos analizar un gráfico, pero no podamos limitarnos a él.

Implementación del script de ejemplo

Para comprender de hecho cómo funciona y el nivel del desafío que tendremos que enfrentar, empezaremos con un ejemplo muy simple. No obstante, será funcional, por lo que podrá servir de ancla para algo aún más complicado que de hecho se implementará después.

Empecemos por lo más básico. Entonces, utilizaremos primero un script. Bien, pero bien sencillo. Este puede verse a continuación:

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. #property version   "1.00"
04. //+------------------------------------------------------------------+
05. void OnStart()
06. {
07.     long id;
08.     string szSymbol;
09.     int handle;
10.     bool bRet;
11.     ENUM_TIMEFRAMES tf;
12.     
13.     id = ChartID();
14.     szSymbol = ChartSymbol(id);
15.     tf = ChartPeriod(id);
16.     handle = iMA(szSymbol, tf, 9, 0, MODE_EMA, PRICE_CLOSE);
17.     bRet = ChartIndicatorAdd(id, 0, handle);
18.     
19.     Print(ChartIndicatorName(id, 0, 0), " ", szSymbol, " ", handle, "  ", bRet, " >> ",id);
20.     
21.     Print("*******");
22. }
23. //+------------------------------------------------------------------+

Código fuente del script de ejemplo

Sé que este script es muy simple, pero servirá para explicar lo que haremos en realidad. Observa que en las líneas 02 y 03 tenemos datos sobre las propiedades del código. Bien, estas no son tan importantes para nuestra explicación. Pero en la línea 05 comenzamos de hecho nuestro código. Ya que se trata de un script muy simple, la única función que realmente se necesita es la OnStart.

Muy bien. Entre las líneas 07 a la 11, tenemos nuestras variables locales. Aquí es necesario que notes algo importante. De hecho, no necesitamos todas estas variables en un script. No para lo que vamos a hacer. En realidad, no necesitaríamos ninguna de estas variables. Pero, debido a la línea 19, las estaremos usando aquí en el script.

En realidad, lo que sucede en el script es lo siguiente: En la línea 13, capturamos la ID del gráfico en el que se colocará el script. Luego, en la línea 14, tomamos el nombre del activo que se encuentra en ese gráfico. En la línea 15, capturamos el marco temporal en el cual se ejecutará nuestro script. Todos estos 3 pasos son, de hecho, innecesarios. A pesar de que el paso en la línea 13 sea necesario, los pasos presentes en las líneas 14 y 15 no son necesarios para un script. Pero pronto quedará claro por qué estos pasos existen aquí.

En la línea 16, haremos que MetaTrader 5 coloque en el gráfico uno de los indicadores técnicos que forman parte de la plataforma. En este caso, una media móvil. Ahora observa lo siguiente: La media móvil que se añadirá será una de 9 períodos y del tipo exponencial , cuyos valores se habrán calculado en función del precio de cierre. Si todo está correcto, este indicador retornará un handle.

En la línea 17, utilizamos el handle creado en la línea 16 y le decimos a MetaTrader 5 que el indicador al que pertenece el handle debe iniciarse en la pantalla del gráfico. Ya en la línea 19, imprimimos todos los valores que fueron capturados y usados por el script. Esto sería una forma de depurarlo. Pero también sirve para otra cosa que veremos pronto.

Observa que todo lo que hicimos podría haberse hecho de otras muchas formas. Seguramente estarás pensando: “¡Qué código más inútil! ¿Por qué alguien crearía algo así?”. De hecho, no te condeno por pensar así. Pero, en lo que respecta a la programación, no todo es inútil, salvo cuando se crea algo sin ningún tipo de propósito.

Si ejecutas este script en el gráfico, verás que se presenta una media móvil de 9 periodos, cuyo cálculo se basa en el precio de cierre. Como el código del script entra y sale muy rápidamente, prácticamente está orientado a probar otra cosa. No tiene ningún tipo de verificación de errores. Cualquier error que se produzca se verá en la caja de mensajes del MetaTrader 5.

Ahora es cuando la cosa de hecho empieza a ponerse interesante: Entonces, pensemos lo siguiente: Si modificamos la línea 16 por otra, por ejemplo:

handle = iCustom(szSymbol, tf, "Replay\\Chart Trade.ex5", id);

Podemos hacer que nuestro indicador Chart Trade se coloque en el gráfico mediante el script. Pero aún debes estar pensando cuál es la verdadera utilidad de esto. Como se mencionó al inicio de este artículo, el asunto se vuelve interesante cuando empezamos a usar este script, no solo como script, sino como servicio.

Conversión de un script en un servicio

Convertir un script en un servicio no es una de las cosas más complicadas. Al menos al principio. Esto se debe a que, básicamente, la única diferencia que existe en el código es el uso de una propiedad que informa de que el script es en realidad un servicio. Básicamente es esto. Pero, a pesar de su simplicidad, existen algunos detalles que debes entender y aprender para lograr hacer esto de la manera correcta.

Volvamos a nuestro ejemplo del tema anterior. Si intentas convertir ese script en un servicio manteniendo el código intacto y añadiendo la propiedad que informa de que se trata de un servicio, notarás que no es posible hacer que las cosas sucedan. ¿Por qué?

El motivo es que, a diferencia del script, un servicio no está de hecho vinculado a un gráfico. Y el hecho de que esto suceda, hace que las cosas sean un poco más complicadas.

Para simplificar un poco las cosas, empecemos por entender cómo funciona MetaTrader 5. Iniciemos la plataforma sin ningún gráfico abierto. Es decir, podemos añadir servicios, pero no podemos hacer nada más. A partir del momento en que se añade el primer gráfico, se pueden colocar indicadores, scripts y Expert Advisors en él. Sin embargo, también podemos realizar algunas manipulaciones en el gráfico usando un servicio.

Probablemente nunca hayas intentado hacer esto o hayas visto a alguien hacerlo. Hasta ahora. Pero sí, puedes hacer que el servicio coloque ciertas cosas en el gráfico. Llegaremos allí, pero vamos con calma. Porque si no comprendes esta base que estoy tratando de mostrar, no entenderás mis nuevos artículos, ya que utilizaré mucho este tipo de cosas para agilizar y facilitar otras.

A medida que vas añadiendo gráficos en MetaTrader 5, si no cierras los gráficos anteriores, se va creando una fila de gráficos. El orden en el que se accede a ellos no es el mismo orden en el que están organizados en el terminal MetaTrader 5. El orden será el orden en que fueron abiertos. Este es el primer punto. Afortunadamente, MQL5 nos proporciona medios para navegar en esta lista de gráficos, y esto será importante para nosotros.

Entonces, si lo que quieres es, en lugar de crear una plantilla, desarrollar una forma de añadir indicadores específicos a activos específicos, deberás usar un servicio. ¿Parece complicado? Bueno, en realidad no es tan complicado. No si logras comprender realmente lo que está sucediendo.

Volvamos al código del tema anterior, donde añadíamos una media móvil exponencial de 9 periodos usando un script. Pero ahora queremos hacer que en el momento en que se abra el primer gráfico, este reciba esa media móvil. Independientemente de cuál sea el activo. Lo importante es que sea el primer gráfico en abrirse. Con esto necesitaremos que ese mismo script sea modificado al código de servicio que se muestra a continuación. 

01. //+------------------------------------------------------------------+
02. #property service
03. #property copyright "Daniel Jose"
04. #property version   "1.00"
05. //+------------------------------------------------------------------+
06. void OnStart()
07. {
08.     long id;
09.     string szSymbol;
10.     int handle;
11.     bool bRet;
12.     ENUM_TIMEFRAMES tf;
13.     
14.     Print("Waiting for the chart of the first asset to be opened...");
15.     while ((id = ChartFirst()) < 0);
16.     szSymbol = ChartSymbol(id);
17.     tf = ChartPeriod(id);
18.     handle = iMA(szSymbol, tf, 9, 0, MODE_EMA, PRICE_CLOSE);
19.     bRet = ChartIndicatorAdd(id, 0, handle);
20.     
21.     Print(ChartIndicatorName(id, 0, 0), " ", szSymbol, " ", handle, "  ", bRet, " >> ",id);
22.     
23.     Print("*******");
24. }
25. //+------------------------------------------------------------------+

Código fuente del servicio.

Observa con atención este código visto anteriormente. Compáralo con el código del tema anterior. Ahora responde: ¿Cuál es la diferencia entre ellos? Bueno, seguramente dirás que es la línea 02, donde ahora existe una propiedad que define este código como un servicio. De hecho, esto es verdad, pero además de esto, ¿qué más? Bueno, también tenemos la presencia de dos líneas diferentes. En la línea 14, imprimimos un mensaje informando de que el servicio está esperando que se coloque un gráfico en el terminal de MetaTrader 5. Y la línea 15, donde esperamos que este gráfico sea abierto.

Así es como la cosa aquí comienza a ponerse mucho más interesante. Para entender lo que realmente está sucediendo, escribe este código arriba y compílalo con el MetaEditor. Abre el MetaTrader 5, luego cierra todos los gráficos, absolutamente todos. Después de esto, inicia el servicio que acabamos de construir. Abre la caja de mensajes, y podrás ver el mensaje que se muestra en la línea 14. Si esto sucede, significa que hiciste todo correctamente. Ahora abre un gráfico de algún activo. Verás al instante el mensaje presente en la línea 21, y el servicio se cerrará. Pero, al observar el gráfico, notarás que contiene la media móvil exponencial de 9 periodos, tal y como se esperaba. Esto es porque el servicio la colocó allí.

Muy bien, espero que tú, querido lector, estés siguiendo lo que se está explicando, porque ahora vamos a complicar un poco más las cosas.

Garantizar un gráfico normalizado:

La parte realmente más interesante del uso de servicios comienza a partir de ahora. A mucha gente le gusta utilizar un modelo gráfico estandarizado, para lo cual se crean plantillas. La plantilla predeterminada de cierta manera nos ayuda justamente en esto. Garantiza que todos los gráficos tendrán un estándar en el momento en que sean creados. Pero, una vez que la plantilla se haya colocado, podemos eliminar sin querer algún indicador o cambiar la configuración de alguno de ellos. En muchos casos, esto no supone un problema real. Puedes simplemente reponer el indicador y listo. Pero, ¿podemos usar MetaTrader 5 de manera que no nos deje colgados? ¿Haciendo que tengamos siempre algo muy cercano a lo que sería un terminal Bloomberg?

Sí, es posible hacer esto. De hecho, podemos impedir que el usuario, o nosotros mismos, desconfiguremos algo en el terminal. En este caso específico, estoy hablando de indicadores. En artículos anteriores, mostré cómo puedes forzar al sistema a mantener este o aquel indicador en el gráfico. Esto se ha estado haciendo durante bastante tiempo en este sistema de repetición/simulador, para evitar que el Indicador de control sea removido del gráfico. Pero existe una solución más versátil que permite mantener cualquier cosa en el gráfico o evitar que aparezcan otras.

En cuanto a evitar, creo que no tiene mucho sentido mostrar cómo hacer esto, pero en cuanto a mantener, creo que realmente es algo interesante. Entonces, modificando una vez más el código visto en el tema anterior, tendremos el código que se muestra a continuación: 

01. //+------------------------------------------------------------------+
02. #property service
03. #property copyright "Daniel Jose"
04. #property version   "1.00"
05. //+------------------------------------------------------------------+
06. void OnStart()
07. {
08.     long id;
09.     string szSymbol;
10.     int handle;
11.     
12.     Print("Waiting for the chart of the first asset to be opened...");
13.     while (!_StopFlag)
14.     {
15.             while (((id = ChartFirst()) < 0) && (!_StopFlag));
16.             while ((id > 0) && (!_StopFlag))
17.             {
18.                     if (ChartIndicatorName(id, 0, 0) != "MA(9)")
19.                     {
20.                             handle = iMA(szSymbol = ChartSymbol(id), ChartPeriod(id), 9, 0, MODE_EMA, PRICE_CLOSE);
21.                             ChartIndicatorAdd(id, 0, handle);
22.                             IndicatorRelease(handle);
23.                     }
24.                     id = ChartNext(id);
25.             }
26.             Sleep(250);
27.     }
28.     Print("Service finish...");
29. }
30. //+------------------------------------------------------------------+

Código del servicio mejorado.

Puedes notar que este código contiene algunas cosas que parecen extrañas. Sin embargo, cada una de las cosas presentes en él tiene su motivo y justificación para estar allí. En sí, no es muy diferente del código visto en el tema anterior. Pero logra hacer algo un tanto curioso. Entonces, entenderás lo que este código está haciendo, así podrás adaptarlo a tus propias necesidades e intereses.

En la línea 12, imprimimos un mensaje que indica que el servicio se encuentra en modo de espera. Así como en la línea 28, informamos que el servicio fue removido y ya no está en ejecución. Todo lo que sucede en medio de estas dos líneas es lo que realmente nos interesa. Para garantizar que el servicio se cierre de manera adecuada y sin causar problemas en el MetaTrader 5, probamos la constante _StopFlag, esta tendrá un valor verdadero mientras no solicitemos que el servicio se cierre.

Así, en la línea 13 entramos en un bucle infinito. Este bucle realmente no es infinito, ya que en el momento en que informamos que deseamos cerrar el servicio, este bucle se cerrará.

En la línea 15, tenemos lo mismo que teníamos en el código anterior. Pero ahora añadimos una prueba para evitar problemas al cerrar el servicio. Ahora presta atención: Cuando ChartFirst devuelve un valor, este será el valor de la primera ventana que abriste en el terminal MetaTrader 5. Este valor estará en la variable "id". Recuerda este hecho, pues es importante tener en cuenta la secuencia de las cosas a partir de este punto.

En la línea 18, verificamos si la ventana que estamos probando contiene un indicador iMA, siendo una media de 9 periodos. Si esta condición no se satisface, es decir, la media no existe en el gráfico, procederemos a añadirla. Esto se hace primero generando un handle, en la línea 20, y luego en la línea 21 añadimos la media al gráfico. Una vez hecho esto, retiramos el handle, ya que no lo necesitamos más. De esta manera, si eliminas la media del gráfico, esta se añadirá de nuevo. Esto se hará automáticamente por el servicio, mientras esté en ejecución.

La línea 24 buscará la siguiente ventana. Ahora observa que necesitamos el índice de la ventana actual, para que el MetaTrader 5 pueda saber cuál será el próximo índice. No confundas las cosas. Si se encuentra otra ventana, el bucle se repetirá. Hasta que ChartNext devuelva el valor de -1, cuando el bucle que comenzó en la línea 16 será cerrado.

Pues bien, no necesitamos que el servicio ejecute como un sonámbulo sin sentido. En la línea 26, generamos un pequeño retardo de aproximadamente 250 milisegundos hasta la próxima iteración de los bucles. De esta manera, el servicio se ejecutará 4 veces por segundo, y se garantizará que la media móvil especificada siempre esté presente en cualquiera de los gráficos que puedan estar abiertos en el terminal MetaTrader 5. Este tipo de cosas son muy interesantes, ¿verdad?

Pero podemos hacer un poco más que esto. Podemos forzar las cosas a que se coloquen en un gráfico específico de un activo en concreto. Este tipo de cosa es justamente lo que al comienzo de esta serie de artículos intenté muchas veces lograr. Pero por una u otra razón, no lo conseguía hacer. Ahora supongamos que tú, que estás operando en la B3 (Bolsa de Brasil), decides que necesitas usar un determinado indicador solo en un activo específico. Y siempre en este activo. Una forma de hacer esto sería usando una plantilla. Pero es muy probable que en el ajetreo del día a día termines cerrando este activo y, al volver a abrir el gráfico, no te des cuenta de que falta el indicador tan necesario, hasta que sea demasiado tarde.

Al usar esta técnica de control mediante servicio, esto no ocurrirá, pues en cuanto se abra el gráfico del activo en el terminal MetaTrader 5, el servicio se encargará de añadir el indicador al gráfico. Y si quieres utilizar una plantilla para añadir más cosas, también podrás hacerlo. Pero el uso de la plantilla se verá en otra oportunidad. Esto ya que involucra algunas cosas que se verán en los próximos artículos de esta serie.

Entonces, veamos cómo hacer esto. Para no confundir las cosas, veámoslo en un nuevo tema.

 

Garantizando un terminal de calidad

Si te pareció interesante lo visto en el tema anterior, prepárate porque en este la cosa será aún más interesante. Ya que podremos hacer exactamente lo dicho en el tema anterior, es decir, podremos hacer que el gráfico de un activo sea siempre igual a un terminal preconfigurado. Más o menos como si pudiéramos hacer que MetaTrader 5 se pareciera al Terminal Bloomberg. Pero con una ventaja: La configuración nunca se modificará de forma accidental, ya que no estará ligada a una plantilla, sino a una configuración del servicio.

Para ilustrarlo, veamos cómo se modificó el código del servicio, que se vio en el tema anterior, para promover lo que deseamos. Este código modificado se muestra a continuación en su totalidad:

01. //+------------------------------------------------------------------+
02. #property service
03. #property copyright "Daniel Jose"
04. #property version   "1.00"
05. //+------------------------------------------------------------------+
06. void OnStart()
07. {
08.     long id;
09.     string szSymbol;
10.     int handle;
11.     ENUM_TIMEFRAMES tf;
12.     
13.     Print("Waiting for the chart of the first asset to be opened...");
14.     while (!_StopFlag)
15.     {
16.             while (((id = ChartFirst()) < 0) && (!_StopFlag));
17.             while ((id > 0) && (!_StopFlag))
18.             {
19.                     szSymbol = ChartSymbol(id);
20.                     tf = ChartPeriod(id);
21.                     if ((StringSubstr(szSymbol, 0, 3) == "WDO") && (ChartWindowFind(id, "Stoch(8,3,3)") < 0))
22.                     {
23.                             handle = iStochastic(szSymbol, tf, 8, 3, 3,MODE_SMA, STO_CLOSECLOSE);
24.                             ChartIndicatorAdd(id, (int)ChartGetInteger(id, CHART_WINDOWS_TOTAL), handle);
25.                             IndicatorRelease(handle);
26.                     }
27.                     if (ChartIndicatorName(id, 0, 0) != "MA(9)")
28.                     {
29.                             handle = iMA(szSymbol, tf, 9, 0, MODE_EMA, PRICE_CLOSE);
30.                             ChartIndicatorAdd(id, 0, handle);
31.                             IndicatorRelease(handle);
32.                     }
33.                     id = ChartNext(id);
34.             }
35.             Sleep(250);
36.     }
37.     Print("Service finish...");
38. }
39. //+------------------------------------------------------------------+

Código del servicio

Nota que los cambios son pocos, pero los resultados son sorprendentes. En esta ocasión, usaremos un activo que se encuentra disponible en B3 (Bolsa de Brasil) para llevar a cabo la demostración. El activo en cuestión es el mini contrato futuro del dólar. Este contrato vence mes a mes, pero esto no supone un problema. Para comprenderlo, veamos la explicación del código en sí. No es algo complejo, pero es preciso prestar atención a los detalles, ya que, de lo contrario, no obtendrás lo que esperabas.

No describiré lo que ya se ha visto, así que nos centraremos en las novedades. En las líneas 19 y 20 introducimos los datos del gráfico que el servicio verificará. Necesitamos el nombre del activo, así como el marco temporal del gráfico. Esto es para evitar cometer algún error después. Entonces colocamos estos valores en dos variables.

En la línea 21, hacemos dos comprobaciones.

• La primera es el nombre del activo que queremos configurar. 
• La segunda se refiere a la presencia o no de un indicador específico.

Si ambas comprobaciones son verdaderas, ejecutaremos las próximas líneas. Ahora, presten atención al hecho de que en el nombre del activo usamos solo las tres primeras letras, ya que es un contrato futuro con un período de validez. Pero, como no queremos cambiar constantemente el nombre del activo, usamos lo que es común en todas las ocasiones en que este se negocia, con independencia del contrato vigente.

Un segundo punto de atención es con relación al indicador. Noten que tenemos que informar el nombre corto del mismo. Si no sabes cuál es este nombre, coloca simplemente este indicador en el gráfico y usa un script simple para imprimir este nombre en el terminal. Así sabrás exactamente cuál nombre debe ser usado allí. En este caso, nos referimos al indicador estocástico de 8 períodos, media de 3 y constante de 3. Pero si el indicador es otro, cambia la string por el nombre correcto. De lo contrario, tendremos problemas en la próxima etapa.

Bien, volvamos al hecho de que el indicador no esté presente en el gráfico del activo especificado. En este caso, primero ejecutaremos la línea 23, donde configuramos el indicador deseado. Después, en la línea 24, añadimos el indicador en una nueva subventana. Cuidado con este punto, si indicas un número de subventana, MetaTrader 5 colocará el indicador en la ventana indicada. Esto puede generar una gran confusión. Pero de la forma en que está el código, MetaTrader 5 creará una nueva subventana y añadirá el indicador en esta subventana recién creada.

En la línea 25, liberamos el handle. El motivo es que ya no lo necesitamos, por lo que debe ser liberado. Ahora, todo esto descrito solo sucederá si el indicador no está presente en el gráfico. Si intentas eliminarlo, el servicio hará que MetaTrader 5 lo vuelva a colocar en el gráfico. Si está presente en el gráfico, el servicio se mantendrá inactivo, sin más.

Observación importante: Aunque el código funcione y tenga un rendimiento adecuado, por motivos prácticos es aconsejable cambiar la prueba vista en la línea 27 por algo un poco mejor. En el caso de usar más indicadores en el mismo gráfico, lo mejor es probar el nombre, y no el índice, como se hace en el código. Para hacer esto, bastaría cambiar la línea 27 por el código mostrado abajo: 

27.     if (ChartIndicatorGet(id, 0, "MA(9)") == INVALID_HANDLE)

De esta forma, no importará el índice que tenga el indicador, solo uno estará presente y será colocado en el gráfico por el servicio.

Conclusión

En este artículo, mostré algo que pocos saben realmente cómo hacer. Si este era tu caso, me alegra mucho haberte mostrado que MetaTrader 5 puede ser una herramienta mucho más poderosa de lo que parece. Es posible que sea la mejor plataforma que existe para quien realmente sabe lo que hace y puede explorar sus capacidades y cualidades.

En el video, puedes ver cómo se comportará MetaTrader 5 al usar el último servicio mencionado en este artículo. Pero, además de lo que se mostró aquí, que es solo una introducción a lo que realmente necesitaremos hacer, me alegra mucho que tú, querido lector, hayas tenido la curiosidad de leer y tratar de aprender un poco más. Sin embargo, me gustaría destacar que el aprendizaje no consiste solo en leer un artículo, sino en buscar uno mismo la solución a los problemas que van surgiendo.

Siempre intenta sacar el máximo provecho posible de algo. Cuando llegues al límite de lo que era posible, busca personas más cualificadas para encontrar una solución, pero siempre tratando de superar lo que ya se ha hecho antes. Así, las cosas van evolucionando y te conviertes en un verdadero profesional.

Video de demostración.