Desarrollo de un sistema de repetición (Parte 38): Pavimentando el terreno (II)

Introducción

En el artículo anterior "Desarrollo de un sistema de repetición (Parte 37): Pavimentando el terreno (I), expliqué y mostré cómo se puede, de una manera súper sencilla, evitar que el usuario duplique un indicador en el gráfico. En el artículo, demostré que mediante el uso de un código muy simple con sólo unas pocas líneas, la plataforma MetaTrader 5 nos ayudaría a evitar tener un indicador del que sólo queremos tener uno en el gráfico. De hecho, no se iba a duplicar.

Es importante que hayas entendido el contenido y, sobre todo, cómo has conseguido el resultado deseado. En ningún caso debe duplicarse un indicador.

Al reiterar el principio de no duplicación en MetaTrader 5, destacamos que aún estamos lejos de lograr una comunicación bidireccional entre el indicador y el Expert Advisor. Todavía estamos muy lejos de esto. Sin embargo, la garantía de que el indicador no se duplique en el gráfico aporta tranquilidad. Esto se debe a que, cuando se produce la interacción entre el indicador y el EA, sabremos que estamos tratando con el indicador correcto.

En este artículo, vamos a empezar a ver las cosas a través de los ojos del EA, pero también tendremos que hacer algunas modificaciones en el indicador, ya que el del artículo anterior, por desgracia, no puede responder al EA en absoluto. Esto sucede cuando la EA quiere saber algo.

Creación de la primera comunicación entre procesos

Para que puedas entender realmente lo que está sucediendo, necesitamos crear algunos puntos de control. Empecemos con el código del indicador; no te preocupes, estos puntos serán fáciles de entender.

El código del indicador puede verse completo a continuación:

01. #property copyright "Daniel Jose"
02. #property link      ""
03. #property version   "1.00"
04. #property indicator_chart_window
05. #property indicator_plots 0
06. //+------------------------------------------------------------------+
07. #define def_ShortName       "SWAP MSG"
08. #define def_ShortNameTmp    def_ShortName + "_Tmp"
09. //+------------------------------------------------------------------+
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.     Print("Indicator configured with the following value:", user00);
26.     
27.     return INIT_SUCCEEDED;
28. }
29. //+------------------------------------------------------------------+
30. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
31. {
32.     return rates_total;
33. }
34. //+------------------------------------------------------------------+

Nótese que la única adición al código es la línea 25. Esta será nuestra línea de verificación, al menos por primera vez. Nuestro interés en este momento es ver cómo el EA está interactuando y si puedes enviar información o datos al indicador.

Un detalle a tener en cuenta es que, en la línea 10, el tipo de información que espera el indicador es un doble. Esto se hace a propósito, ya que la intención es crear un mecanismo que pueda sustituir al sistema de variables globales terminales, a efectos de comunicación entre el SV y el indicador. Si los medios desarrollados o aplicados resultan inadecuados, no costará mucho trabajo sustituir este modelo por el de variables globales terminales.

Sin embargo, nada te impide utilizar otros tipos de datos para fomentar la comunicación, al menos en lo que respecta a la transferencia de datos de la EA al indicador.

Ahora que hemos modificado el código del indicador, podemos pasar al código del EA, que puedes ver completo a continuación:

01. #property copyright "Daniel Jose"
02. #property link      ""
03. #property version   "1.00"
04. //+------------------------------------------------------------------+
05. input double user00 = 2.0;
06. //+------------------------------------------------------------------+
07. int m_handle;
08. long m_id;
09. //+------------------------------------------------------------------+
10. int OnInit()
11. {
12.     m_id = ChartID();
13.     if ((m_handle = ChartIndicatorGet(m_id, 0, "SWAP MSG")) == INVALID_HANDLE)
14.     {
15.             m_handle = iCustom(NULL, PERIOD_CURRENT, "Mode Swap\\Swap MSG.ex5", user00);
16.             ChartIndicatorAdd(m_id, 0, m_handle);
17.     }
18.     Print("Indicator loading result:", m_handle != INVALID_HANDLE ? "Success" : "Failed");
19.     
20.     return INIT_SUCCEEDED;
21. }
22. //+------------------------------------------------------------------+
23. void OnDeinit(const int reason)
24. {
25.     ChartIndicatorDelete(m_id, 0, "SWAP MSG");
26.     IndicatorRelease(m_handle);
27. }
28. //+------------------------------------------------------------------+
29. void OnTick()
30. {
31. }
32. //+------------------------------------------------------------------+

Para muchos, este código del EA puede resultar bastante extraño. Veamos cómo funciona. Presta atención, porque esta es la primera fase de lo que realmente tenemos que hacer.

En la línea 05, damos al usuario una forma o medio de ajustar el valor que se pasará al indicador. Recuerda: queremos probar y entender cómo se va a producir la comunicación. Las líneas 07 y 08 contienen dos variables globales internas en el código del EA. Normalmente, no me gusta utilizar variables globales; pero, en este caso, puedo hacer una excepción. El contenido de estas variables se definirá dentro del código que maneja el comando OnInit, que comienza en la línea 10.

A partir de aquí, muchos dirán: "Aquí es cuando las cosas se ponen feas". La razón es que, en este punto, necesitamos entender algunas cosas.

En la línea 12, inicializamos la variable que indicará el índice del marco temporal donde se encuentra el EA. Pero en la línea 13, empiezan los problemas para los que empiezan. Mucha gente simplemente no añade esta línea a su código, lo cual, en cierto modo, es un error. No es algo grave que vaya a romper tu código de inmediato; no, pero el hecho de incluir la línea 13 en el código impide que tengamos ciertos tipos de fallos. Y muchos de estos fallos son de tipo RUN-TIME, pueden ocurrir en cualquier momento, lo que dificulta su corrección.

El hecho de que utilicemos este código en la línea 13 significa que, si MetaTrader 5 ya tiene el indicador que queremos en el gráfico, esto devuelve el "handle" de este indicador. De esta forma, no tenemos que responsabilizarnos de colocar el indicador en el gráfico.

Pero, si la línea 13 indica que el gráfico no contiene el indicador deseado, vamos a ejecutar el código que añadirá el indicador al gráfico. Recuerda el siguiente hecho: el indicador que queremos y utilizaremos es un indicador personalizado. Para ello, utilizaremos la llamada iCustom, que puede verse en la línea 15.

Ahora viene la parte complicada de toda esta historia. ¿Por qué iCustom, presente en la línea 15, se declara así? ¿Tienes alguna idea de por qué? Para entenderlo, veamos qué nos dice la documentación:

int  iCustom(
                 string            symbol,   // símbolo nome
                 ENUM_TIMEFRAMES   period,   // período
                 string            name      // folder/nome_do_indicador_personalizado
                 ...                         // lista de parâmetros de entrada do indicador
             );

Puedes ver en la tabla anterior que el primer parámetro de la función es el nombre del símbolo. Pero en la línea 15 del código, el primer parámetro es un NULL. ¿Por qué ocurre esto? ¿Por qué no he utilizado la constante _Symbol? La razón es que para el compilador, ambos datos, tanto NULL como _Symbol son la misma cosa. De esta manera, el indicador se creará utilizando el mismo símbolo o activo que se encuentra en el gráfico del EA.

El siguiente parámetro de la lista es el tiempo, o periodo del gráfico. Una vez más, tenemos algo diferente de lo que muchos esperarían. En la línea 15, utilizamos el valor PERIOD_CURRENT, pero ¿por qué? La razón es que quiero que el indicador permanezca sincronizado con el mismo periodo que el EA. Un detalle: si deseas que el indicador mire a otro periodo del gráfico, simplemente indica el periodo deseado aquí, en este parámetro. De esta manera, el indicador se fijará en un período específico, mientras que el EA puede fluir entre diferentes períodos.

Cuando se trata de indicadores personalizados, creo que es este tercer parámetro en el que la cosa se va a poner realmente fea. Mucha gente no sabe qué poner aquí, y otras veces desisten porque no entienden o indican el lugar equivocado. Si pones la ubicación incorrecta, MetaTrader 5 no será capaz de encontrar el indicador que deseas utilizar.

Mira lo que se declara en la línea 15, en este tercer parámetro. Estoy indicando no solo un nombre, sino un nombre con una ruta. ¿De dónde procede esta información? Para averiguarlo, hay que volver al artículo anterior para saber de dónde procede esta información. Mira la figura 01.

Figura 01 - Creación del indicador

En esta figura 01, puedes ver de dónde procede la información del tercer parámetro. Ten en cuenta que es prácticamente lo mismo. Con las siguientes modificaciones: primero, borramos el directorio raíz, en este caso, indicators. Esto se debe a que MetaTrader 5 buscará primero el indicador precisamente en este directorio. El segundo punto es que hemos añadido el archivo .ex5. Esto nos da la ubicación correcta para el archivo ejecutable. Cuando MetaTrader 5 coloca el EA en el gráfico y ejecuta la línea 15, sabrá dónde y qué indicador utilizar.

A continuación, veremos algunas cuestiones relacionadas con esto, así como los problemas que pueden surgir. Pero primero, vamos a ceñirnos a lo básico.

A partir de este tercer parámetro, cualquier otro parámetro es opcional. Si deseas utilizar o enviar un valor al indicador, debes hacerlo desde el cuarto parámetro. Hay que tener cuidado y hacerlo en la misma secuencia en que aparecen los parámetros en el indicador. Asegúrate también de que son del mismo tipo. No debe introducir un valor doble cuando el indicador espera recibir un valor float o long. Si lo hace, MetaTrader 5 provocará un error tan pronto como se inicie el indicador.

Hay otra forma de enviar los parámetros al indicador, pero, por ahora y para simplificar, vamos a utilizar iCustom. Así que, si miras el código del indicador, verás que en la línea 10 se espera un valor doble. Este valor se contabiliza en el indicador a través del EA, en el cuarto parámetro de la línea 15 del código del EA.

Ahora, una pregunta importante. Muchos lo descuidan, y eso es lo que hace que todo el sistema tenga problemas. Esta es la línea 16 del código del EA. ¿Por qué es tan importante esta línea?

Hay casos en los que se puede ignorar esta línea cuando se trata de indicadores personalizados; sobre todo, los indicadores que queremos y deseamos para forzar y obligar a MetaTrader 5 a mantener solo y únicamente una sola instantánea de qué se coloca en el gráfico. No podemos ignorar o descuidar la línea 16 de ninguna manera, forma o manera, y cuando la línea 16 está presente, también se debe agregar la línea 25.

Estas dos líneas nos evitan problemas. La línea 16 reproducirá el indicador en el gráfico. De esta forma, si el usuario intenta reproducir otra instancia del indicador en el mismo gráfico, MetaTrader 5, junto con el código del indicador, prohibirá que se lance una nueva instantánea. Si se elimina la línea 16 del código del EA, el usuario puede colocar inadvertidamente una nueva instancia del indicador en el gráfico, dejando no al EA sino al usuario confundido sobre los aspectos involucrados en los cálculos realizados por el indicador.

En el caso de un indicador de cálculo, tendrá una especie de problema; sin embargo, en el caso de un indicador como Chart Trader, el problema es aún más complicado. Dado que en este caso se trata de objetos gráficos, vamos a tomarlo con calma; vamos a llegar a este punto. Entendamos primero cómo hacer las cosas correctamente. Y correctamente. Así entenderás realmente cómo hacer cosas más complejas.

Muy bien, creo que has entendido, al menos por ahora, la importancia de la línea 16. Y la línea 25, ¿qué hace? Esta línea eliminará del gráfico el indicador del que le estamos informando. Ten en cuenta una cosa: es necesario conocer el nombre del indicador que se va a eliminar. Este nombre se coloca en el indicador en la línea 24 del código del indicador. Estos nombres tienen que ser idénticos; de lo contrario, MetaTrader 5 no sabrá qué indicador eliminar. Además, en algunos casos, también tenemos que informarle de qué subventana se trata. Como no estamos utilizando una subventana, este valor se deja como CERO.

Ahora, en la línea 26, eliminamos, o más bien destruimos, el manejador del indicador. Eso es porque ya no lo necesitamos.

Así que vamos a ver cómo MetaTrader 5 maneja este esquema de comunicación entre el EA y el Indicador. Para entenderlo, hay que hacer algunas cosas. Así que presta mucha atención a los detalles de lo que hay que hacer. Y con cada modificación, prueba y experimenta con el código generado. Debido a que cada uno de los cambios traerá una manera diferente para MetaTrader 5 de hacer frente a ellos. Mucho más que leer las explicaciones anteriores, hay que entender lo que está pasando. Se deben tener en cuenta tres situaciones para que entiendas lo que sucede cuando se codifica el EA de una manera determinada, o cuando se programa el mismo EA creado de forma diferente. El código utilizado tanto en el EA como en el indicador es el mismo que he estado explicando hasta ahora; la única diferencia está en el contenido, o más bien, en la presencia o ausencia de una línea de código de EA.

Hagamos lo siguiente:

• Primero, compila el código con todas las líneas y observa cómo funciona el sistema en MetaTrader 5.
• A continuación, elimina las líneas 16 y 25, y vuelve a probar el sistema en MetaTrader 5.
• Por último, elimina solo la línea 16 y mantén la línea 25. Vuelve a probar el sistema.

Tal vez pienses que todo esto no tiene sentido, que tú, como programador experimentado, nunca cometerás esos errores. Pero, sabiendo lo que cada línea de código hace y causa cuando se ejecuta por MetaTrader 5, quizá sea mucho más importante de lo que parece.

Si has llegado a este punto, has entendido la segunda fase en la que podemos pasar datos del EA al Indicador, y esto sin utilizar las variables globales del terminal. Estarás haciendo grandes progresos para convertirte en un programador de calidad. Si sigues sin entenderlo, no te desanimes. Vuelve al principio de este artículo o del anterior e intenta comprender este paso. Ahora, las cosas se van a complicar de verdad. Y no bromeo; de hecho, se va a complicar mucho. Ahora vamos a hacer que el Indicador envíe datos al EA.

Aquí es donde el indicador envía los datos al EA. En algunos casos, puede ser sencillo. Esto es correcto. Pero cualquiera que haya seguido mis artículos se habrá dado cuenta de que me gusta llevar las cosas al extremo, hacer sudar al ordenador y rogarle que haga las cosas de otra manera. Pero tengo mucho interés en que tanto el lenguaje como la plataforma funcionen dentro de los límites de lo posible.

Indicator Create o iCustom. ¿Cuál utilizar?

Hay una pregunta que atormenta a muchos principiantes. Esta pregunta se refiere a cómo llamar a los indicadores personalizados. Hay dos maneras de hacerlo. La primera se vio en el tema anterior, donde expliqué el uso de iCustom. Pero también hay otra manera, y no podía descuidarlo, dada su igual importancia. Esto se debe a que algunos tipos de modelado son más atractivos, mientras que en otros bastará con utilizar iCustom.

No se trata ni se tratará aquí de decirte que utilices un método u otro. El objetivo es mostrar cómo puedes hacer uso de la llamada IndicatorCreate para poder cargar también tus indicadores personalizados.

Antes de empezar, entendamos una cosa, y es para bien. La función IndicatorCreate no es una función especial. No, en realidad, es una función base. ¿Y qué significa esto en realidad? Una función base es aquella que sirve esencialmente para promover otras funciones, pero con un detalle: las funciones "derivadas" hacen uso de la función base, pero simplifican el uso de la función base.

Este tipo de cosas se consiguen al no tener que modelar la llamada como se esperaría de la función base. Puedes utilizar un modelado más sencillo y agradable. Esto da lugar a otras funciones, que pueden verse en la documentación como Indicadores Técnicos. Entre estos indicadores se encuentra iCustom, que de hecho sería una función derivada con el fin de simplificar la modelización.

Pero, ¿cómo se vería el código fuente del EA visto al principio de este artículo si en lugar de usar iCustom, usáramos IndicatorCreate? Tu código se puede ver a continuación:

01. #property copyright "Daniel Jose"
02. #property link      ""
03. #property version   "1.00"
04. //+------------------------------------------------------------------+
05. input double user00 = 2.2;
06. //+------------------------------------------------------------------+
07. int m_handle;
08. long m_id;
09. //+------------------------------------------------------------------+
10. int OnInit()
11. {
12.     MqlParam params[];
13.     
14.     m_id = ChartID();       
15.     if ((m_handle = ChartIndicatorGet(m_id, 0, "SWAP MSG")) == INVALID_HANDLE)
16.     {
17.             ArrayResize(params, 2);
18.             params[0].type = TYPE_STRING;
19.             params[0].string_value = "Mode Swap\\SWAP MSG";
20.             params[1].type = TYPE_DOUBLE;
21.             params[1].double_value = user00;
22.             m_handle = IndicatorCreate(NULL, PERIOD_CURRENT, IND_CUSTOM, ArraySize(params), params);
23.             ChartIndicatorAdd(m_id, 0, m_handle);
24.     }
25.     Print("Indicator loading result:", m_handle != INVALID_HANDLE ? "Success" : "Failed");
26.     
27.     return INIT_SUCCEEDED;
28. }
29. //+------------------------------------------------------------------+
30. void OnDeinit(const int reason)
31. {
32.     ChartIndicatorDelete(m_id, 0, "SWAP MSG");
33.     IndicatorRelease(m_handle);
34. }
35. //+------------------------------------------------------------------+
36. void OnTick()
37. {
38. }
39. //+------------------------------------------------------------------+

Código fuente del EA

Observa y compara las diferencias entre este código de arriba y el visto al principio del artículo. Ambos hacen exactamente lo mismo. La gran pregunta es: ¿Por qué este código, que utiliza la llamada IndicatorCreate, tiene que hacerse de esta manera?

De hecho, la función iCustom oculta precisamente lo que necesitamos hacer. Pero entendamos lo que está pasando.

Primero, tenemos que declarar una variable, se declara en la línea 12 como un array. Ten en cuenta que tenemos que hacerlo así. Si el indicador no está presente en el gráfico, tenemos que crearlo. Para ello, tenemos que decirle a la función IndicatorCreate qué hacer y cómo hacerlo.

Independientemente del número de parámetros que utilicemos en el indicador, tenemos que decirle a la función IndicatorCreate cuál es el nombre del indicador. Así que, si solo vamos a introducir el nombre del indicador, la función ArrayResize de la línea 17 debería asignar no dos, sino una posición. Si tuviéramos que pasar 5 parámetros al indicador, tendríamos que asignar 6 posiciones. Siempre será así. Mira cuántos parámetros tenemos que enviar y asigna una posición extra.

Una vez entendido esto, vamos a configurar el array. Porque en la línea 22, le estamos diciendo a la función IndicatorCreate que vamos a utilizar un indicador personalizado. Para ello, se utiliza la enumeración IND_CUSTOM. Necesitaremos y deberemos hacer algunas cosas. En la línea 18, vemos cómo debemos proceder para la primera posición del array. Recuerda que MQL5 deriva de C++, así que empezamos a contar desde CERO. El tipo de información en la primera posición debe ser STRING. Por eso, la declaración se hace de la forma que se ve en la línea 18.

En la línea 19, introduciremos el nombre del indicador personalizado que se utilizará. Atención: Ten en cuenta que el nombre del indicador es el mismo que el que se utilizaría si utilizáramos la llamada iCustom. La diferencia aquí es que no estamos indicando la extensión del archivo. Se supone que el archivo será un ejecutable, por lo que la extensión será .ex5. Por lo tanto, indicar la extensión es opcional.

IMPORTANTE: Lo que se ha hecho en las líneas 18 y 19 debe hacerse siempre que se utilice un indicador personalizado. Si utilizas cualquier otro indicador, sea cual sea, en cuanto empieces a configurar los datos del array, deberás indicar los parámetros como verás a partir de ahora, es decir, a partir de la línea 20.

Ahora que hemos expresado a la función IndicatorCreate qué indicador personalizado utilizar, empecemos a rellenar los parámetros que se le pasarán. Estos parámetros deben declararse en el orden correcto. No importa qué indicador utilices; el intercambio de tipos o la declaración de tipos erróneos generará errores RUN-TIME. Así que ten mucho cuidado y calma al rellenar estos datos.

En la línea 20, indicamos que el primer parámetro será de tipo double. Pero podría ser cualquiera de los tipos definidos en la enumeración ENUM_DATATYPE. Se puede utilizar cualquiera de ellos, pero hay algunas advertencias.

En pocas palabras, y eso es decirlo de forma muy sencilla, se utilizarán los tipos TYPE_DOUBLE y TYPE_FLOAT, en este caso, en la línea 21, valor_doble.

Si la línea 20 utilizara el tipo TYPE_STRING, la línea 21 arrojaría el valor a la variable string_value. Para cualquiera de los otros tipos posibles declarados en la línea 20, se introduciría el valor en la línea 21, utilizando la variable integer_value.

Y como esto es importante, quiero dejar clara esta información. Consulta el cuadro siguiente para comprenderlo mejor:

Identificador usado	Tipo de datos	Dónde colocar el valor
TIPO_BOOL	Booleano	integer_value
TYPE_CHAR	Char	integer_value
TYPE_UCHAR	Unsigned Char	integer_value
TYPE_SHORT	Short	integer_value
TYPE_USHORT	Unsigned Short	integer_value
TYPE_COLOR	Color	integer_value
TYPE_INT	Integer	integer_value
TYPE_UINT	Unsigned Integer	integer_value
TYPE_DATETIME	DateTime	integer_value
TYPE_LONG	Long	integer_value
TYPE_ULONG	Unsigned Long	integer_value
TYPE_FLOAT	Float	double_value
TYPE_DOUBLE	Double	double_value
TYPE_STRING	String	string_value

Tabla de correspondencia.

Esta tabla muestra claramente lo que utilizarás en la línea 20 (Identificador a utilizar) y qué variable recibirá el valor, en la línea 21. Debes hacer esto para cada uno de los parámetros que se pasarán a tu indicador personalizado. Como aquí solo estamos utilizando un parámetro, solo trabajaremos con él.

Observa que es mucho más laborioso utilizar la llamada IndicatorCreate que su derivado, iCustom. Esto es para nuestro caso concreto.

Una vez establecidos todos los parámetros que queremos definir, llegamos a la línea 22, donde realmente llamamos a la función. Ten en cuenta que estoy haciendo esto de tal manera que puedo aumentar o reducir cosas muy fácilmente. Todos los campos están rellenados para que no tenga que volver a editar la línea 22, en caso de que necesite cambiar el indicador o el número de parámetros.

La idea es siempre simplificar las cosas y nunca complicarlas.

Debido a este trabajo extra para poder establecer el mismo tipo de ejecución por parte de MetaTrader 5, en los códigos actuales, no me verás a menudo usando la función IndicatorCreate. Pero nada te impide utilizarlo.

Antes de terminar este artículo, me gustaría hablar brevemente de otra función: IndicatorParameters. Esta función se utiliza para ayudarnos a comprobar, por así decirlo, algo sobre un indicador desconocido. Para entenderlo, digamos que tienes varios indicadores diferentes en tu gráfico, cada uno inicializado de una manera determinada. Es posible que desees automatizar algún tipo de estrategia basada en indicadores. Pero como el mercado cambia tan repentinamente, puede llevar unos minutos ajustar correctamente todos los indicadores.

Para acelerar un poco las cosas, utilizamos la función IndicatorParameters. Una vez ejecutada la llamada a esta función, MetaTrader 5 rellenará esta función para que sepamos cómo se configura específicamente un indicador determinado. Basándose en otros análisis, se utiliza otra función, normalmente IndicatorCreate, para modificar la configuración de un indicador determinado. Si el EA utiliza este indicador para comprar o vender, sabrá inmediatamente qué hacer, debido a que tendremos un disparador siendo ejecutado.

Esta cuestión ha sido ampliamente explorada y demostrada, en la medida de lo posible, en la secuencia sobre automatización. Para ser más específico, en el artículo "Aprender a construir un EA que opere automáticamente (Parte 15): Automatización (VII)", demuestro cómo usar un indicador como disparador para comprar o vender.

Pero, como acabo de mencionar, puedes utilizar la función IndicatorParameters como una forma de hacer que el mismo tipo de EA sea aún más interesante. Sin embargo, no exploraremos el uso de la función IndicatorParameters, al menos no en esta secuencia sobre el sistema de repetición/simulador. Ojalá hubiera mencionado lo útil que es esta función para aquellos que desconocen su finalidad.

Conclusión

En este artículo, te he mostrado de la forma más sencilla posible cómo enviar datos al indicador, aunque lo he hecho utilizando un EA. Puedes utilizar otros tipos de procesos, tales como Scripts. Aunque estaría muy bien, pero en el momento en que estoy escribiendo este artículo, no ha sido posible tener la posibilidad de utilizar los servicios como forma de realizar este mismo trabajo, debido a las características que entraña la cuestión de los servicios.

Pero no pasa nada, tenemos que trabajar con lo que tenemos. Sin embargo, este asunto aún no se ha cerrado del todo. Todavía tenemos que ver cómo enviar datos desde el indicador al EA, en nuestro caso. Pero es diferente de lo que podría pensarse; no será como lo ves normalmente o como ya lo conoces. Recuerda, queremos una forma de utilizar Chat Trader en el sistema de repetición/simulación, pero no queremos tener que usar variables globales de terminal para esto, tampoco queremos compilar varios programas a riesgo de olvidarnos de compilar alguno.

Para saber lo cerca que estaremos de lo que necesitamos para Chart Trader, necesitaremos otro artículo. Y este será el tema principal del próximo artículo: Comprender cómo acercarnos a lo que necesitamos para crear el Chart Trader.

No te pierdas el próximo artículo, porque el tema será muy interesante y apasionante si se ve y se explica.