Cómo trabajar con líneas usando MQL5

Introducción

Las líneas en el trading ayudan a observar niveles importantes que se usan para tomar o confirmar decisiones comerciales, así como para el análisis en general. Como estos niveles son tan importantes para los tráders, se plantea la cuestión de si existe alguna forma de trazar líneas automáticamente e incluso de tomar decisiones basándose en ellas: usar líneas de esta forma resultaría aún más cómodo. La respuesta es sí, y esto puede lograrse utilizando el lenguaje de programación MQL5 (MetaQuotes Language 5).

En este artículo, veremos ejemplos del trabajo con líneas utilizando MQL5. Existen muchos métodos diferentes para hacerlo, y elegir uno concreto dependerá de lo que queramos conseguir. Hay muchos tipos de líneas, pero en este artículo trabajaremos solo con tres, las más populares: las líneas de tendencia, las líneas de apoyo y las líneas de resistencia.

En el presente artículo, trataremos los siguientes temas:

1. Líneas de tendencia y MQL5
2. Líneas de apoyo y MQL5
3. Líneas de resistencia y MQL5
4. Conclusión

Hablando con rigor, existen muchos métodos para trabajar con líneas usando las herramientas MQL5. Aquí veremos un método simple. Probablemente el lector tendrá que desarrollarlo más para usarlo en su estrategia específica. Aquí veremos un método para determinar los niveles de precio y, poco después, aprenderemos a trazar en el gráfico el tipo de líneas seleccionado.

Asimismo, veremos qué son las líneas, aprenderemos a identificar sus tipos, veremos cómo dibujarlas manualmente y cómo utilizarlas en el trading. Y lo más importante: vamos a ver cómo se puede utilizar MQL5 para trabajar con líneas de tendencia, apoyo y resistencia. El objetivo principal es aprender a automatizar procesos que faciliten las operaciones y mejoren los resultados. En este artículo usaremos el lenguaje de programación MQL5 (MetaQuotes Language 5) integrado en el terminal MetaTrader 5 y el MetaEditor para escribir el código. Podrá leer cómo instalar MetaTrader 5 o utilizar el MetaEditor en el artículo publicado anteriormente Escribiendo el código MQL5 en el MetaEditor".

Recomendamos a los lectores practicar por su cuenta la escritura de los códigos analizados en este artículo. De este modo, desarrollará sus habilidades de programación, comprenderá mejor el tema y quizá encuentre nuevas ideas para usted y mejore sus resultados comerciales.

¡Atención! Toda la información del presente artículo se ofrece «tal cual», únicamente con fines ilustrativos, y no supone ningún tipo de recomendación. El artículo no garantiza ningún resultado en absoluto. Todo lo que ponga en práctica usando este artículo como base, lo hará bajo su propia cuenta y riesgo; el autor no garantiza resultado alguno.

Líneas de tendencia y MQL5

Las líneas son herramientas de análisis técnico que se usan al comerciar en los mercados financieros. Pueden trazarse en precios o niveles importantes, que a su vez se usan como activadores de una toma de decisiones eficaz. Existen muchos tipos de líneas. Vamos a comenzar con tres tipos básicos: líneas de tendencia, líneas de niveles de apoyo y líneas de niveles de resistencia.

Líneas de tendencia: ¿cómo identificarlas y usarlas? Las líneas de tendencia son líneas que muestran de forma visual el movimiento direccional del precio (hacia arriba o hacia abajo). La línea puede trazarse por encima o por debajo de los precios, dependiendo de la dirección del mercado. Por ello, el objetivo principal de una línea de tendencia será ayudar a determinar la dirección de una tendencia de mercado. Una línea de tendencia alcista estará indicada por una secuencia de mínimos y máximos crecientes. En consecuencia, la señal de una tendencia bajista será una secuencia de al menos tres mínimos y máximos descendentes. Si se construyen y utilizan correctamente, las líneas de tendencia pueden resultar una herramienta muy útil.

Las líneas de tendencia pueden usarse en el trading para abrir órdenes según una tendencia. Si se forma una línea de tendencia alcista, podemos esperar que el precio descienda hacia esta línea de tendencia y rebote hacia arriba, en cuyo caso podremos colocar una orden de compra en esta línea de tendencia. Por el contrario, si vemos una línea de tendencia bajista en el gráfico, podemos suponer que el precio subirá hasta esta línea de tendencia para luego rebotar hacia abajo. En tal caso, podremos colocar una orden de venta en la línea de tendencia bajista.

Más abajo mostramos una línea de tendencia alcista:

La figura anterior muestra un movimiento ascendente. Si unimos los tres puntos mínimos con una línea, veremos que están en una misma línea que apunta hacia arriba.

A continuación, le mostraremos un ejemplo de línea de tendencia alcista:

Como podemos ver en el gráfico anterior, se ha formado una línea de tendencia alcista; el precio ha tocado esta línea muchas veces y ha rebotado en ella debido a la acción de los compradores, lo cual confirma la existencia de una tendencia alcista.

A continuación, encontrará una línea de tendencia bajista:

Existe un claro movimiento a la baja en la imagen. Si unimos los tres puntos máximos con una línea, veremos que se encuentran en la misma línea, apuntando hacia abajo.

Abajo le mostramos un ejemplo de línea de tendencia bajista:

Como podemos ver en el gráfico anterior, se ha formado una línea de tendencia bajista; el precio ha tocado esta línea muchas veces y ha rebotado hacia abajo debido a la acción de los vendedores, lo cual confirma la existencia de una tendencia bajista.

1. Sistema de línea de tendencia alcista

Ahora vamos a crear un programa que se puede usar para crear automáticamente una línea de tendencia alcista en MetaTrader 5. Esta aparecerá debajo de los precios, lo cual le permitirá ver un posible movimiento al alza. El programa comprobará los mínimos del precio en cada tick y determinará si se ha formado una tendencia alcista o no. También eliminaremos la línea anterior, si esta existía, y crearemos una nueva línea azul por debajo del precio. 

Vamos a ver paso a paso lo que hay que hacer para conseguirlo.

Para determinar la primera vela, crearemos una variable entera, cuyo valor tendrá el tipo long de la propiedad correspondiente del gráfico actual; utilizaremos la función ChartGetInteger con los siguientes parámetros:

• chart_id — identificador del gráfico, 0 indicará el gráfico actual.
• prop_id — define el identificador de la propiedad del gráfico, utilizando para ello los valores de la enumeración ENUM_CHART_PROPERTY_INTEGER. En nuestro caso, será el valor CHART_FIRST_VISIBLE_BAR.
• sub_window=0 — número de subventana del gráfico. Utilizaremos el valor 0, la ventana gráfica principal.

int candles=ChartGetInteger(0,CHART_FIRST_VISIBLE_BAR,0);

Crearemos un array con los valores de precio mínimo, y luego obtendremos las variables de tipo double para pLow.

double pLow[];

A continuación, clasificaremos el array creado de datos actuales usando la función ArraySetAsSeries, que retornará un valor de tipo bool (true si se ha realizado correctamente o false en caso contrario).

ArraySetAsSeries(pLow,true);

Después rellenaremos el array pLow creado con los datos usando la función CopyLow: el valor del mínimo del símbolo actual en el marco temporal actual. Parámetros de la función:

• symbol_name — nombre del símbolo, _Symbol será el símbolo del gráfico actual.
• timeframe — marco temporal a calcular, _Period indicará el marco temporal actual del gráfico.
• start_pos — posición inicial para copiar los elementos, para nosotros será 0.
  
• count — número de elementos a copiar, utilizaremos la variable candles precreada.
  
• low_array[] — array de destino para copiar los elementos, pLow.
  

CopyLow(_Symbol,_Period,0,candles,pLow);

Vamos a crear y calcular el valor mínimo de la vela. Para ello, crearemos una variable candleLow de tipo entero, igual al elemento mínimo del array. Para retornar el valor mínimo, utilizaremos la función ArrayMinimum. Parámetros de la función:

• array[] — array en el que analizaremos los elementos, pLow.
  
• start=0 — índice del elemento a partir del cual comenzará la comprobación, utilizaremos 0.
  
• count=WHOLE_ARRAY — número de elementos a comprobar, en nuestro caso serán velas.
  

int candleLow = ArrayMinimum(pLow,0,candles);

Utilizaremos la función MqlRates para crear un array pArray que almacene información sobre precios, volúmenes y diferenciales.

MqlRates pArray[];

Luego clasificaremos el array de precios pArray usando la función ArraySetAsSeries.

ArraySetAsSeries(pArray,true);

Después copiaremos los datos de precio en un array de precios, primero crearemos una variable entera Data, luego usaremos CopyRates para obtener los datos históricos de la estructura MqlRates. Parámetros de la función:

• symbol_name — nombre del símbolo, utilizaremos _Symbol para trabajar con el símbolo del gráfico actual.
• timeframe — define el marco temporal, _Period indicará el marco temporal actual.
• start_pos — indica la posición de inicio del cálculo; especificaremos 0.
• count — número de elementos a copiar, utilizaremos la variable candles precreada.
  
• rates_array[] — array en el que se copian los datos; pArray será el array de precios.
  

int Data = CopyRates(_Symbol,_Period,0,candles,pArray);

A continuación, eliminaremos la línea creada anteriormente para actualizarla. Para ello, utilizaremos la función ObjectDelete, que eliminará cualquier objeto indicado de cualquier gráfico especificado. Parámetros de la función:

• chart_id — identificador del gráfico, _Symbol será el símbolo actual del gráfico.
• name — nombre del objeto a eliminar del gráfico. En nuestro caso, será UpwardTrendline.

ObjectDelete(_Symbol,"UpwardTrendline");

A continuación, crearemos una nueva línea de tendencia utilizando ObjectCreate para crear un objeto de línea de tendencia. Parámetros de la función:

• chart_id — gráfico del símbolo sobre el que se construirá el objeto, _Symbol será el gráfico del símbolo actual.
• name — nombre del objeto, utilizaremos "UpwardTrendline" como nombre.
• type — tipo de objeto, OBJ_TREND será la línea de tendencia.
• nwin — índice de la ventana, 0 será la ventana gráfica principal.
• time1 — hora del primer punto de anclaje, pArray[candleLow].time.
• price1 — precio del primer punto de anclaje, pArray[candleLow].low.
• timeN — hora del N-ésimo punto de anclaje, pArray[0].time.
• priceN — precio del N-ésimo punto de enlace, pArray[0].low.

ObjectCreate(_Symbol,"UpwardTrendline",OBJ_TREND,0,pArray[candleLow].time,pArray[candleLow].low,pArray[0].time,pArray[0].low);

Definiremos el color de la línea de tendencia utilizando la función ObjectSetInteger con el valor de color del objeto. Parámetros de la función:

• chart_id — identificador del gráfico, usaremos 0, el gráfico actual.
• name — nombre del objeto, UpwardTrendline será el nombre predefinido para nuestra línea de tendencia.
• prop_id — identificador de la propiedad del objeto, utilizaremos el valor OBJPROP_COLOR de la enumeración ENUM_OBJECT_PROPERTY_INTEGER.
• prop_value — valor de la propiedad, en nuestro caso será Blue, el color de nuestra línea de tendencia.

ObjectSetInteger(0,"UpwardTrendline",OBJPROP_COLOR,Blue);

Luego definiremos el estilo de la línea, usando de nuevo la función ObjectSetInteger, pero esta vez utilizando un valor diferente de la enumeración ENUM_OBJECT_PROPERTY_INTEGER, a saber, OBJPROP_STYLE, prop_value = STYLE_SOLID, la línea sólida como estilo de la línea de tendencia creada.

ObjectSetInteger(0,"UpwardTrendline",OBJPROP_STYLE,STYLE_SOLID);

Y determinaremos el grosor de la línea. La función ObjectSetInteger se utilizará con el valor OBJPROP_WIDTH de la enumeración ENUM_OBJECT_PROPERTY_INTEGER; el valor de la variable será 3, el grosor real de la línea de tendencia que estamos creando.

ObjectSetInteger(0,"UpwardTrendline",OBJPROP_WIDTH,3);

Haremos que la línea continúe hacia la derecha. Utilizaremos la función ObjectSetInteger con el valor OBJPROP_RAY_RIGHT de la enumeración ENUM_OBJECT_PROPERTY_INTEGER; el valor de la variable será true, es decir, continuaremos la línea hacia la derecha.

ObjectSetInteger(0,"UpwardTrendline",OBJPROP_RAY_RIGHT,true);

A continuación, mostraremos el código completo del programa que trazará automáticamente una línea de tendencia alcista:

//+------------------------------------------------------------------+
//|                                       UpwardTrendline System.mq5 |
//+------------------------------------------------------------------+
void OnTick()
  {
   int candles=ChartGetInteger(0,CHART_FIRST_VISIBLE_BAR,0);
   double pLow[];
   ArraySetAsSeries(pLow,true);
   CopyLow(_Symbol,_Period,0,candles,pLow);
   int candleLow = ArrayMinimum(pLow,0,candles);
   MqlRates pArray[];
   ArraySetAsSeries(pArray,true);
   int Data = CopyRates(_Symbol,_Period,0,candles,pArray);
   ObjectDelete(_Symbol,"UpwardTrendline");
   ObjectCreate(_Symbol,"UpwardTrendline",OBJ_TREND,0,pArray[candleLow].time,pArray[candleLow].low,pArray[0].time,pArray[0].low);
   ObjectSetInteger(0,"UpwardTrendline",OBJPROP_COLOR,Blue);
   ObjectSetInteger(0,"UpwardTrendline",OBJPROP_STYLE,STYLE_SOLID);
   ObjectSetInteger(0,"UpwardTrendline",OBJPROP_WIDTH,3);
   ObjectSetInteger(0,"UpwardTrendline",OBJPROP_RAY_RIGHT,true);
  }
//+------------------------------------------------------------------+

Una vez escrito el código, deberemos compilarlo. No debería haber errores durante la compilación. A continuación, el programa compilado debería aparecer en el Navegador del terminal comercial:

Luego iniciaremos el programa clicando dos veces en el archivo o arrastrándolo y soltándolo en el gráfico. Después de eso, aparecerá la ventana del asesor:

Luego permitiremos el trading algorítmico "Allow Algo Trading" y pulsaremos OK. A continuación, el programa se ejecutará en el gráfico y empezará a funcionar inmediatamente, como se muestra en ejemplo siguiente:

La indicación en la esquina superior derecha del gráfico mostrará que el asesor se está ejecutando en este gráfico. Además, bajo el precio, el asesor habrá dibujado una línea de tendencia alcista azul.

2. Sistema de línea de tendencia bajista

Ahora crearemos un programa que se pueda utilizar para crear automáticamente una línea de tendencia bajista en MetaTrader 5. Esta aparecerá en el gráfico por encima de los precios, lo cual nos permitirá ver un posible movimiento bajista. El programa comprobará los máximos del precio en cada tick y determinará si se ha formado una tendencia bajista. A continuación, eliminaremos la línea anterior, si existía, y crearemos una nueva línea azul por encima de los máximos del precio. 

Más abajo mostramos el código completo del programa en el que se implementa esta funcionalidad.

//+------------------------------------------------------------------+
//|                                     DownwardTrendline System.mq5 |
//+------------------------------------------------------------------+
void OnTick()
  {
   int candles=ChartGetInteger(0,CHART_FIRST_VISIBLE_BAR,0);
   double pHigh[];
   ArraySetAsSeries(pHigh,true);
   CopyHigh(_Symbol,_Period,0,candles,pHigh);
   int candleHigh = ArrayMaximum(pHigh,0,candles);
   MqlRates pArray[];
   ArraySetAsSeries(pArray,true);
   int Data = CopyRates(_Symbol,_Period,0,candles,pArray);
   ObjectDelete(_Symbol,"DnwardTrendline");
   ObjectCreate(_Symbol,"DnwardTrendline",OBJ_TREND,0,pArray[candleHigh].time,pArray[candleHigh].high,pArray[0].time,pArray[0].high);
   ObjectSetInteger(0,"DnwardTrendline",OBJPROP_COLOR,Blue);
   ObjectSetInteger(0,"DnwardTrendline",OBJPROP_STYLE,STYLE_SOLID);
   ObjectSetInteger(0,"DnwardTrendline",OBJPROP_WIDTH,3);
   ObjectSetInteger(0,"DnwardTrendline",OBJPROP_RAY_RIGHT,true);
  }
//+------------------------------------------------------------------+

Diferencias en este código:

Crearemos un array con los precios máximos.

double pHigh[];

Clasificaremos los datos empezando por los actuales.

ArraySetAsSeries(pHigh,true);

Rellenaremos el array con datos.

CopyHigh(_Symbol,_Period,0,candles,pHigh);

Crearemos una variable candle y calcularemos el valor máximo.

int candleHigh = ArrayMaximum(pHigh,0,candles);

Eliminaremos del gráfico la línea de tendencia bajista creada anteriormente.

ObjectDelete(_Symbol,"DnwardTrendline");

Crearemos una nueva línea de tendencia

ObjectCreate(_Symbol,"DnwardTrendline",OBJ_TREND,0,pArray[candleHigh].time,pArray[candleHigh].high,pArray[0].time,pArray[0].high);

Estableceremos el color de la línea de tendencia bajista en azul utilizando la propiedad OBJPROP_COLOR

ObjectSetInteger(0,"DnwardTrendline",OBJPROP_COLOR,Blue);

Para el estilo de línea, seleccionaremos una línea sólida estableciendo la propiedad OBJPROP_STYLE a STYLE_SOLID

ObjectSetInteger(0,"DnwardTrendline",OBJPROP_STYLE,STYLE_SOLID);

Estableceremos un grosor de la línea de tendencia descendente igual a tres usando la propiedad WIDTH

ObjectSetInteger(0,"DnwardTrendline",OBJPROP_WIDTH,3);

Estableceremos la propiedad OBJPROP_RAY_RIGHT en true

ObjectSetInteger(0,"DnwardTrendline",OBJPROP_RAY_RIGHT,true);

Tras realizar la compilación, localizaremos el archivo del asesor experto en la ventana del navegador. Después iniciaremos el asesor experto e inmediatamente comenzaremos a trabajar en el gráfico, dibujando automáticamente una línea de tendencia bajista:

El icono del asesor experto aparecerá en la esquina superior derecha del gráfico, y encima de los precios aparecerá una línea azul de tendencia bajista.

Niveles de apoyo y MQL5

Un nivel de apoyo es un nivel o zona de precios que está por debajo de los precios actuales. Los precios rebotan al alza desde este nivel porque aquí se está formando una fuerza compradora. Por consiguiente, resultan de gran importancia, porque podremos utilizarlos como niveles para entrar en una operación de compra. Existen muchas formas de niveles de apoyo, una de ellas es el nivel de apoyo horizontal. Se parecerá a esto:

Ejemplo de nivel de apoyo en el mercado:

El gráfico anterior muestra una línea de apoyo verde por debajo de los precios, a partir de la cual los precios rebotarán al alza.

Nuestro programa comprobará automáticamente el precio mínimo en cada tick y determinará si existe apoyo. Se eliminará la línea antigua y, a continuación, se construirá una nueva línea de apoyo verde por debajo de los precios. A continuación, le mostramos el código completo de un programa que construye automáticamente una línea de este tipo:

//+------------------------------------------------------------------+
//|                                          Support Line System.mq5 |
//+------------------------------------------------------------------+
void OnTick()
  {
   int candles=ChartGetInteger(0,CHART_FIRST_VISIBLE_BAR,0);
   double pLow[];
   ArraySetAsSeries(pLow,true);
   CopyLow(_Symbol,_Period,0,candles,pLow);
   int candleLow = ArrayMinimum(pLow,0,candles);
   MqlRates pArray[];
   ArraySetAsSeries(pArray,true);
   int Data = CopyRates(_Symbol,_Period,0,candles,pArray);
   ObjectDelete(_Symbol,"supportLine");
   ObjectCreate(_Symbol,"supportLine",OBJ_HLINE,0,pArray[candleLow].time,pArray[candleLow].low,pArray[0].time,pArray[0].low);
   ObjectSetInteger(0,"supportLine",OBJPROP_COLOR,Green);
   ObjectSetInteger(0,"supportLine",OBJPROP_STYLE,STYLE_SOLID);
   ObjectSetInteger(0,"supportLine",OBJPROP_WIDTH,3);
   ObjectSetInteger(0,"supportLine",OBJPROP_RAY,true);
  }
//+------------------------------------------------------------------+

Diferencias en este código:

Si se encuentra en el gráfico un objeto llamado supportLine

ObjectDelete(_Symbol,"supportLine");

Crearemos una nueva línea de apoyo especificando OBJ_HLINE como tipo de objeto a crear.

ObjectCreate(_Symbol,"supportLine",OBJ_HLINE,0,pArray[candleLow].time,pArray[candleLow].low, pArray[0].time,pArray[0].low);

Luego estableceremos el color de la línea de apoyo con ayuda de OBJPROP_COLOR

ObjectSetInteger(0,"supportLine",OBJPROP_COLOR,Green);

Después definiremos el estilo de la línea de apoyo, asignando el valor STYLE_SOLID a la propiedad OBJPROP_STYLE

ObjectSetInteger(0,"supportLine",OBJPROP_STYLE,STYLE_SOLID);

Estableceremos el grosor de la línea en la propiedad OBJPROP_WIDTH

ObjectSetInteger(0,"supportLine",OBJPROP_WIDTH,3);

La línea continuará hacia la derecha usando la propiedad OBJPROP_RAY

ObjectSetInteger(0,"supportLine",OBJPROP_RAY,true);

Después de ello, compilaremos el código del asesor. Si todo es correcto y el programa se compila correctamente, el archivo del asesor aparecerá en la ventana del Navegador en el terminal, lo ejecutaremos como el programa anterior. El icono de la esquina superior derecha nos indicará que el asesor está en marcha. El asesor construirá una línea de apoyo como en el ejemplo siguiente:

En el gráfico anterior, está funcionando Support System EA; debajo del precio, se muestra una línea de apoyo.

Niveles de resistencia y MQL5

Un nivel de resistencia es un nivel o zona de precios que está por encima de los precios actuales. Los precios rebotan a la baja desde este nivel porque aquí se está formando una fuerza vendedora. Por consiguiente, resultarán muy importantes porque podremos utilizarlos como niveles para entrar en una operación de venta. Existen muchas formas de niveles de resistencia. Nos fijaremos en una de ellas: el nivel de apoyo horizontal.

A continuación, le mostraremos un ejemplo de un nivel de resistencia en el mercado:

El gráfico anterior muestra una línea roja sobre los precios: los precios la tocan desde abajo y rebotan en ella. 

El programa comprobará los máximos del precio en cada tick y determinará el nivel de resistencia; si se encuentra una línea de resistencia existente en el gráfico, la eliminaremos y, a continuación, construiremos una nueva línea de resistencia en rojo por encima de los máximos del precio. A continuación, le mostramos el código completo de un programa que construye automáticamente una línea de este tipo:

//+------------------------------------------------------------------+
//|                                       Resistance Line System.mq5 |
//+------------------------------------------------------------------+
void OnTick()
  {
   int candles=ChartGetInteger(0,CHART_FIRST_VISIBLE_BAR,0);
   double pHigh[];
   ArraySetAsSeries(pHigh,true);
   CopyHigh(_Symbol,_Period,0,candles,pHigh);
   int candleHigh = ArrayMaximum(pHigh,0,candles);
   MqlRates pArray[];
   ArraySetAsSeries(pArray,true);
   int Data = CopyRates(_Symbol,_Period,0,candles,pArray);
   ObjectDelete(_Symbol,"resistanceLine");
   ObjectCreate(_Symbol,"resistanceLine",OBJ_HLINE,0,pArray[candleHigh].time,pArray[candleHigh].high,pArray[0].time,pArray[0].high);
   ObjectSetInteger(0,"resistanceLine",OBJPROP_COLOR,Red);
   ObjectSetInteger(0,"resistanceLine",OBJPROP_STYLE,STYLE_SOLID);
   ObjectSetInteger(0,"resistanceLine",OBJPROP_WIDTH,3);
   ObjectSetInteger(0,"DnwardTrendline",OBJPROP_RAY_RIGHT,true);
  }
//+------------------------------------------------------------------+

Diferencias en este código:

Si en el gráfico ya existe una línea llamada resistanceLine, la eliminaremos.

ObjectDelete(_Symbol,"resistanceLine");

Luego crearemos una nueva línea de resistencia especificando OBJ_HLINE como tipo de objeto a crear.

ObjectCreate(_Symbol,"resistanceLine",OBJ_HLINE,0,pArray[candleHigh].time,pArray[candleHigh].high,pArray[0].time,pArray[0].high);

Estableceremos el color de la línea de resistencia con ayuda de OBJPROP_COLOR

ObjectSetInteger(0,"resistanceLine",OBJPROP_COLOR,Red);

Definiremos el estilo de la línea, estableciendo para ello la propiedad OBJPROP_STYLE a STYLE_SOLID

ObjectSetInteger(0,"resistanceLine",OBJPROP_STYLE,STYLE_SOLID);

Estableceremos el grosor de la línea en la propiedad OBJPROP_WIDTH

ObjectSetInteger(0,"resistanceLine",OBJPROP_WIDTH,3);

Haremos que la línea continúe hacia la derecha. Para ello, utilizaremos la propiedad de rayo OBJPROP_RAY_RIGHT con el valor true

ObjectSetInteger(0,"DnwardTrendline",OBJPROP_RAY_RIGHT,true);

Después de ello, compilaremos el código del asesor. Si todo es correcto y el programa se compila correctamente, el archivo del asesor aparecerá en la ventana del Navegador en el terminal, lo ejecutaremos como el programa anterior. El asesor Resistance System EA se iniciará en el gráfico:

En el gráfico anterior, el asesor Resistance System EA se ha iniciado: esto se indicará con el icono del asesor en la esquina superior derecha del gráfico. También aparecerá una línea de apoyo roja por encima de los máximos.

Conclusión

En este artículo hemos presentado las que probablemente sean las tres líneas más importantes utilizadas en el trading. Hablamos de las líneas de tendencia (alcista y bajista), las líneas de apoyo y las líneas de resistencia: hemos analizado su significado y cómo utilizarlas, y también aprendido a trabajar con estas líneas en MQL5 para construirlas automáticamente. Asimismo, hemos creado nuestro propio sistema para cada tipo de línea. Podemos desarrollar aún más este código añadiendo el envío de órdenes para ejecutar operaciones según los niveles. Sin embargo, deberemos probar los programas a fondo antes de usarlos en una cuenta real para asegurarnos de que funcionan, ya que el objetivo principal de este artículo es puramente educativo.

Esperamos que el artículo le haya resultado útil y que pueda usarlo como parte de otro sistema más avanzado o por sí solo. La información de este artículo puede ayudarnos a encontrar nuevas ideas, incluso aquellas que no se han abordado directamente en este artículo. También esperamos que haya escrito y puesto a prueba por sí mismo todo el código de este artículo. Dicha práctica resulta vital para desarrollar las habilidades de programación.

Si le ha gustado el artículo y lo ha encontrado útil, le recomendamos leer otros artículos del autor sobre el desarrollo de sistemas comerciales utilizando indicadores técnicos populares, como el Indicador de Media Móvil, RSI, Sochastic, Parabolic SAR y otros.

Asimismo, en artículos anteriores hemos tocado los fundamentos del lenguaje de programación MQL5, aprendiendo a crear sistemas de trading algorítmico y viendo su utilidad. Quizá le interese leer sobre ello.