Automatización de estrategias comerciales con la estrategia de tendencia Parabolic SAR en MQL5: Creación de un asesor experto eficaz

 Introducción

Las estrategias de trading algorítmico han revolucionado enormemente el trading financiero al permitir a los operadores tomar decisiones informadas rápidamente. Esto ha ayudado a eliminar errores humanos y sesgos emocionales a medida que los sistemas automatizados siguen parámetros predeterminados en un entorno de mercado de rápido movimiento. Por lo tanto, en el trading automatizado existe consistencia ya que el sistema utiliza la misma lógica para ejecutar operaciones cada vez.

Es una práctica común crear e implementar técnicas automatizadas utilizando MetaTrader 5. Este artículo profundiza en el proceso de creación de un Asesor Experto (Expert Advisor, EA) que utiliza el indicador Parabolic SAR para ejecutar operaciones automáticamente.

Descripción general de la estrategia Parabolic SAR

Indicador Parabolic SAR. Este indicador fue inventado en 1978 por Welles Wilder. El indicador resalta posibles puntos de reversión en la tendencia del mercado a través de una serie de puntos en un gráfico que sigue el movimiento del precio hacia arriba y hacia abajo. Cuando los puntos están por debajo del precio, el mercado está en tendencia alcista; cuando están por encima, el mercado está en tendencia bajista. Esto lo hace particularmente útil para identificar posibles puntos de reversión, donde una tendencia podría estar llegando a su fin. 

Paso SAR (SAR Step): Esto ayuda a determinar qué tan cerca los puntos SAR siguen el precio. El paso inferior se queda unos puntos por detrás del precio, lo que disminuye la sensibilidad. Un paso más alto mueve los puntos más cerca del precio, aumentando la sensibilidad.

Puntos SAR: Esto actúa como un factor de aceleración como límite superior. En un mercado en tendencia, el Parabolic SAR aumenta los pasos para alcanzar los precios. Por lo tanto, los traders pueden identificar puntos de entrada y salida para posibles reversiones de tendencias.

Esta estrategia puede integrarse con otros indicadores para hacerla más completa o utilizarse como una estrategia independiente en mercados en tendencia, como divisas y materias primas.

Implementación en MQL5

En el encabezado, incluimos metadatos básicos como el copyright y el número de versión. La biblioteca Trade.mqh está incluida para gestionar operaciones comerciales, es decir, abrir y cerrar posiciones.

#property copyright "Copyright 2024, MetaQuotes Ltd." "Duke"
#property link      "https://www.mql5.com"
#property version   "1.00"
#include <Trade\Trade.mqh>

Definamos ahora los parámetros de entrada que nos permiten personalizar el EA.

LotSize: Ayuda al EA a determinar el tamaño de las operaciones. Esto significa que un LotSize pequeño reducirá los riesgos y los beneficios debido a la reducción del tamaño de la operación. Además, si el LotSize es grande, significa que habrá mayores riesgos y beneficios.

SAR_Step y SAR_Maximum: Controlan la sensibilidad en la detección del movimiento del precio y el cálculo del indicador Parabolic SAR.

Slippage: Esto ayudará al EA a establecer el deslizamiento máximo permitido al colocar órdenes.

//--- Input parameters
input double LotSize = 0.2  ;                    // Lot size for trading
input double SAR_Step = 0.02;                    // Parabolic SAR step
input double SAR_Maximum = 0.2;                  // Parabolic SAR maximum
input int Slippage = 3;                          // Slippage for orders

Podemos crear una instancia de la clase CTrade para gestionar las operaciones comerciales.

//--- Trade object
CTrade trade;

Nuestro siguiente paso es la función OnInit que se ejecuta cuando se carga el EA. En este EA simple, simplemente imprime un mensaje de confirmación para la inicialización exitosa del registro del Asesor Experto (Expert Advisor, EA). Por lo tanto, comprobaremos que el EA se ha cargado e inicializado sin ningún problema. Esta función también es útil para depurar y garantizar que el EA está listo para empezar a procesar datos. La función también puede devolver INIT_FAILED si la inicialización ha fallado por algún motivo, impidiendo el funcionamiento del EA.

int OnInit()
  {
//--- Initialization code here
   Print("Parabolic SAR EA Initialized");
   return(INIT_SUCCEEDED);
  }

Pasamos a la función OnDeinit. Cuando se recompila el EA, se elimina del gráfico. Esta acción activa la función OnDeinit para realizar tareas de limpieza y garantizar que los recursos se liberan adecuadamente. Usted puede determinar si el EA fue explícitamente eliminado, recompilado, o el resultado del cierre de la terminal mirando este registro, esto puede ofrecer información reveladora durante la etapa de desarrollo y pruebas. Esta función puede ampliarse a cualquier procedimiento de limpieza necesario. Por ejemplo, es posible que necesite cerrar cualquier recurso abierto, liberar identificadores de archivos o guardar el estado actual.

Esto ayudará a mejorar la confiabilidad y la estabilidad, ya que garantizará que los problemas de rendimiento de las primeras ejecuciones no interfieran con la capacidad del EA para recargar o reiniciar.

void OnDeinit(const int reason)
  {
//--- Cleanup code here
   Print("Parabolic SAR EA Deinitialized");
  }

Después de OnDeinit miramos la función OnTick. Esta función es el núcleo del EA y se ejecuta con cada tick del mercado. Calcula el valor del Parabolic SAR y lo compara con el último precio de cierre. En base a esta comparación, el EA determina si abrir una orden de compra o de venta.

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- Get the Parabolic SAR value
   double sar = iSAR(_Symbol, _Period, SAR_Step, SAR_Maximum);        // Calculate the Parabolic SAR value
   double lastPrice = iClose(_Symbol, _Period, 1);                    // Get the close price of the previous candle

//--- Check if there is an existing position
   if(!IsPositionOpen(_Symbol))
     {
      //--- Determine trade direction based on SAR
      if(lastPrice > sar)
        {
         OpenBuyOrder();                                              // If the last price is above the SAR, open a buy order
        }
      else
         if(lastPrice < sar)
           {
            OpenSellOrder();                                          // If the last price is below the SAR, open a sell order
           }
     }
  }   

Ahora podemos desglosar la función OnTick para una mejor comprensión.

• El cálculo del Parabolic SAR: La primera línea del código calcula el valor del Parabolic SAR:

 double sar = iSAR(_Symbol, _Period, SAR_Step, SAR_Maximum);        // Calculate the Parabolic SAR value

- iSAR(): Esta es una función incorporada en las plataformas MetaTrader que calcula el valor del indicador Parabolic SAR para un activo determinado durante un período especificado.

- _Symbol: Se refiere al instrumento financiero o activo de negociación como EURUSD, Oro o cualquier otro elemento de negociación que esté analizando en ese momento.

- _Period: Indica el marco temporal del gráfico (como 1 minuto, 1 hora, 1 día, etc.). Esto ayuda a la función a determinar qué velas utilizar para calcular el SAR.

- SAR_Step y SAR_Maximum: Son parámetros específicos del indicador Parabolic SAR que controlan su sensibilidad. SAR_Step es el valor de paso incremental que acelera el indicador a medida que avanza la tendencia, mientras que SAR_Maximum limita la aceleración para evitar que el indicador reaccione demasiado rápido a los cambios de precio.

• Recuperar el precio de cierre de la vela anterior: La siguiente línea recupera el precio de cierre de la última vela completada:

double lastPrice = iClose(_Symbol, _Period, 1);                   // Get the close price of the previous candle

- iClose(): Esta función devuelve el precio de cierre de una vela concreta del gráfico.

- _Symbol y _Period: Al igual que la función iSAR(), hace referencia al instrumento financiero y al marco temporal concretos que se están analizando.

- 1: Este parámetro especifica qué precio de cierre de vela queremos. En este caso, 1 indica la última vela completada (la anterior), ya que la vela actual aún se está formando.

Este valor, almacenado en LastPrice, representa el nivel de precio final en el que se cotizó el activo cuando se cerró la última vela.

Utilizamos el código Parabolic SAR para automatizar decisiones sobre el establecimiento de Stop Loss y la determinación de salidas o reversiones de operaciones. Por ejemplo, si el precio de cierre cae por debajo del valor del SAR en una posición larga, puede indicar un cambio de tendencia, lo que llevaría al operador a cerrar la posición o a considerar una posición corta. El EA utiliza esta comparación para determinar si el mercado continúa su tendencia o la invierte, esto ayuda a eliminar las emociones y confiar en señales claras para operar.

Cuando se construye un algoritmo de negociación, es común implementar una comprobación para ver si una posición para un activo específico (símbolo) ya está abierta.

//--- Check if there is an existing position
   if(!IsPositionOpen(_Symbol))

IsPositinOpen(_Symbol): Esta función comprueba si existe actualmente una posición abierta para el símbolo _Symbol. El símbolo suele representar el ticket o código del activo. 

!IsPositionOpen(_Symbol): Esto significa que la condición se convierte en verdadera sólo si no hay posición abierta para el símbolo dado.

La sentencia "if": Si no hay posición abierta para el símbolo dado, se ejecutará el código dentro del bloque "if". Esto podría implicar la apertura de una nueva posición, la ejecución de una operación o la activación de otra lógica de negociación.

Por lo tanto, esta función garantizará que no se produzcan sobreoperaciones provocadas por la apertura de varias posiciones para el mismo símbolo. Esto ayudará al sistema a mantener un mejor control de la actividad comercial.

Parabolic SAR sigue las tendencias, indicando los puntos de entrada y salida con un Stop Loss que se ajusta a los movimientos del precio. Un cruce indica un posible cambio de tendencia.

 //--- Determine trade direction based on SAR
      if(lastPrice > sar)
        {
         OpenBuyOrder();                                              // If the last price is above the SAR, open a buy order
        }
      else
         if(lastPrice < sar)
           {
            OpenSellOrder();                                          // If the last price is below the SAR, open a sell order
           }
     }
  }

LastPrice: Representa el precio de mercado actual del activo negociado.

sar: Es el valor del Parabolic SAR en el momento actual.

Mediante la comparación de ambas, el algoritmo determina si la tendencia es alcista o bajista y actúa en consecuencia.

La lógica de compra y venta

Órdenes de compra:Las órdenes de compra se inician cuando el último precio supera el valor "sar", lo que indica una tendencia al alza. A continuación, el algoritmo activa la función OpenBuyOrder() para ejecutar la operación, basándose en el supuesto de que el mercado seguirá subiendo con el precio por encima del SAR.

Órdenes de venta: Por el contrario, si el último precio es inferior a "sar", esto se interpreta como una señal de que el mercado está en una tendencia bajista. El algoritmo responde llamando a la función OpenSellOrder(), iniciando una operación de venta. Aquí, la estrategia supone que, dado que el precio ha caído por debajo del SAR, el mercado puede seguir cayendo.

El código prioriza la evaluación de una orden de compra primero. Si se cumple la condición para una orden de compra (LastPrice > sar), el sistema ejecuta inmediatamente una operación de compra. Si esa condición no se cumple (LastPrice < sar), el código busca una condición de venta. Si la condición es verdadera, se ejecuta una operación de venta.

Nuestro siguiente paso es la función de "utilidad".

Aquí comenzamos comprobando la función OpenPositions. La función IsPositionOpen verifica si ya hay una posición abierta para el símbolo comercial actual. Esto evita que el EA abra múltiples posiciones en la misma dirección simultáneamente.

//+------------------------------------------------------------------+
//|Check if there is an open position for the given symbol           |
//+------------------------------------------------------------------+
bool IsPositionOpen(string symbol)
  {
   uint total=PositionsTotal();                                     //Get the total number of open positions
   for(uint i=0; i<total; i++)
     {
      string POSITION_SYMBOL=PositionGetSymbol(i);                 //Get the symbol of the position
      if(POSITION_SYMBOL == _Symbol)                               //Check if the symbol matches the current symbol
        { 
         return true;
        }
     }
   return false;
  }

 Veámoslo ahora en detalle desglosando el código de la función del siguiente modo:

• Parámetros de entrada: La función toma un argumento de símbolo de cadena (string) que representa un símbolo deseado, como un par de divisas o un ticket de acciones.
• Obtiene posiciones totales: la función recupera el número total de posiciones abiertas actualmente utilizando PositionsTotal(). Esta función devuelve el número de posiciones abiertas en la terminal en el momento de la ejecución.
• Itera a través de posiciones: utilizando un bucle "for", el código itera a través de todas las posiciones abiertas. La variable total contiene el número de posiciones abiertas, el bucle se ejecuta desde 0 hasta el total - 1.
• Comparar símbolos: el símbolo recuperado, POSITION_SYMBOL, se compara luego con el símbolo actual utilizando la condición if (POSITION_SYMBOL==_SYMBOL). La variable _Symbol es un identificador predefinido que representa el símbolo del gráfico desde el que se llama la función. Si los símbolos coinciden, indica que ya hay una posición abierta para el símbolo dado.
• Valor de retorno: si la función encuentra una coincidencia (es decir, ya hay una posición abierta para el símbolo dado), devuelve verdadero. Si no se encuentra ninguna posición coincidente después de que el bucle haya verificado todas las posiciones abiertas, la función devuelve falso, lo que indica que no hay posiciones abiertas para el símbolo especificado.

Esta función es particularmente útil para evitar que el algoritmo abra una nueva posición en el mismo cuando ya hay una activa. Por ejemplo, si está negociando "EURUSD" y la función devuelve verdadero, la estrategia podría evitar abrir una nueva posición y, en cambio, centrarse en administrar la existente.  

Nuestra siguiente función de utilidad es OpenBuyOrder(); esta función es responsable de ejecutar una operación de compra. Intenta abrir una orden de compra con un tamaño de lote específico, al mismo tiempo que incluye el manejo de errores para garantizar que el proceso se complete correctamente o para notificar al comerciante si algo sale mal.

//+------------------------------------------------------------------+
//| Open a Buy order                                                 |
//+------------------------------------------------------------------+
void OpenBuyOrder()
  {
   if(trade.Buy(LotSize, NULL, 0, 0, 0, "Buy Order"))
     {
      Print("Buy order placed successfully");
     }
   else
     {
      Print("Error placing buy order: ", GetLastError());
     }
  }

La función se declara como void OpenBuyOrder(), esto significa que no devuelve ningún valor sino que realiza una tarea específica, en este caso colocar una orden de compra.

La función utiliza el método trade.Buy() para ejecutar una orden de compra. El método requiere los siguientes parámetros:

• LotSize: Especifica el tamaño de la orden y, en nuestro caso, es 0.2.
• NULL: Se refiere al símbolo actual del gráfico desde el que se llama a la función. En este caso, NULL toma por defecto el símbolo del gráfico actual.
• 0: Fija el precio al que se realiza la orden. El uso de cero indica que la orden se ejecutará al precio de mercado actual.
• 0: Este parámetro representa el nivel de Stop Loss. 0 significa que no se especifica ningún Stop Loss al abrir la orden.
• 0: Este parámetro es el nivel de toma de beneficios. Establecerlo en cero significa que no se establece inicialmente ningún Take Profit.
• "Buy Order": Es el comentario asociado a la orden, utilizado a efectos de identificación.

Si la orden se coloca con éxito (if(trade.Buy(....) se evalúa como true), la función llama a la función Print() para registrar el mensaje: "Buy order placed successfully". Esto informa al operador de que la orden se ha ejecutado correctamente.

Si la orden falla (else), la función registra un mensaje de error: "Error placing buy order", seguido del código de error específico devuelto por GetLastError(). La función GetLastError() recupera el último error que se ha producido en el sistema, lo que proporciona al comerciante desarrollador información valiosa para solucionar el problema.

Nuestra última función de utilidad es abrir una orden de venta: Esta función está diseñada para automatizar el proceso de apertura de una orden de venta en un sistema de negociación algorítmica. Esta función refleja la lógica de la función OpenBuyOrder() pero está adaptada para operaciones cortas, u órdenes de venta, en el mercado.

//+------------------------------------------------------------------+
//| Open a Sell order                                                |
//+------------------------------------------------------------------+
void OpenSellOrder()
  {
   if(trade.Sell(LotSize, NULL, 0, 0, 0, "Sell Order"))
     {
      Print("Sell order placed successfully");
     }
   else
     {
      Print("Error placing sell order: ", GetLastError());
     }
  }

La función void OpenSellOrder() no devuelve ningún valor, sino que se centra en realizar una tarea específica: colocar una orden de venta.

El método trade.Sell() se utiliza para iniciar una orden de venta. Los parámetros que se pasan a este método son los siguientes:

• Lotsize: Define el número de lotes para la orden de venta y, en nuestro caso, es 0.2.
• NULL: Representa el símbolo del gráfico actual desde el que se llama a la función. Al pasar NULL, la función por defecto opera con el símbolo en el gráfico actual.
• 0: Establece el precio de la orden. Si se utiliza 0, la orden se ejecutará al precio de mercado actual. 
• 0: Representa el nivel de Stop Loss. Un valor de 0 significa que no se especifica ningún nivel de Stop Loss cuando se abre la orden. 
• 0: Especificado el nivel de Take Profit. Un valor de cero significa que no se establece ninguna toma de ganancias inicialmente.
• "Sell order":Este es un comentario adjunto al pedido, que ayuda a identificar y rastrear el pedido.

Si la orden de venta se realiza correctamente, se registra un mensaje de éxito mediante la función Print(). El mensaje "Sell order placed successfully" aparecerá en el registro de la terminal para confirmar que la operación se ha ejecutado.

En caso de que la orden de venta falle por cualquier motivo, la función registra un mensaje de error: "Error placing sell order", seguido del código de error específico devuelto por GetLastError(). Esto ayuda a diagnosticar por qué no se realizó la orden de venta.

A continuación el código completo de nuestro artículo:

//+------------------------------------------------------------------+
//|                                              ParabolicSAR_EA.mq5 |
//|                            Copyright 2024, MetaQuotes Ltd."Duke" |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2024, MetaQuotes Ltd." "Duke"
#property link      "https://www.mql5.com"
#property version   "1.00"
#include <Trade\Trade.mqh>

//--- Input parameters
input double LotSize = 0.2  ;                    // Lot size for trading
input double SAR_Step = 0.02;                    // Parabolic SAR step
input double SAR_Maximum = 0.2;                 // Parabolic SAR maximum
input int Slippage = 3;                        // Slippage for orders

//--- Trade object
CTrade trade;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- Initialization code here
   Print("Parabolic SAR EA Initialized");
   return(INIT_SUCCEEDED);
  }

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//--- Cleanup code here
   Print("Parabolic SAR EA Deinitialized");
  }

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- Get the Parabolic SAR value
   double sar = iSAR(_Symbol, _Period, SAR_Step, SAR_Maximum);        // Calculate the Parabolic SAR value
   double lastPrice = iClose(_Symbol, _Period, 1);                    // Get the close price of the previous candle

//--- Check if there is an existing position
   if(!IsPositionOpen(_Symbol))                                       
     {
      //--- Determine trade direction based on SAR
      if(lastPrice > sar)
        {
         OpenBuyOrder();                                              // If the last price is above the SAR, open a buy order
        }
      else
         if(lastPrice < sar)
           {
            OpenSellOrder();                                          // If the last price is below the SAR, open a sell order
           }
     }
  }
//+------------------------------------------------------------------+
//|Check if there is an open position for the given symbol           |
//+------------------------------------------------------------------+
bool IsPositionOpen(string symbol)
  {
   uint total=PositionsTotal();                                     //Get the total number of open positions
   for(uint i=0; i<total; i++)
     {
      string POSITION_SYMBOL=PositionGetSymbol(i);                 //Get the symbol of the position
      if(POSITION_SYMBOL == _Symbol)                               //Check if the symbol matches the current symbol
        {
         return true;
        }
     }
   return false;
  }
//+------------------------------------------------------------------+
//| Open a Buy order                                                 |
//+------------------------------------------------------------------+
void OpenBuyOrder()
  {
   if(trade.Buy(LotSize, NULL, 0, 0, 0, "Buy Order"))
     {
      Print("Buy order placed successfully");
     }
   else
     {
      Print("Error placing buy order: ", GetLastError());
     }
  }

//+------------------------------------------------------------------+
//| Open a Sell order                                                |
//+------------------------------------------------------------------+
void OpenSellOrder()
  {
   if(trade.Sell(LotSize, NULL, 0, 0, 0, "Sell Order"))
     {
      Print("Sell order placed successfully");
     }
   else
     {
      Print("Error placing sell order: ", GetLastError());
     }
  }

Hasta este punto ya hemos implementado nuestro EA.

A continuación se muestran los resultados del backtest:

 

La prueba se realizó en el par USDJPY en un gráfico M1. El período de prueba fue del 01.01.2024 al 05.08.2024. Tipo de modelado; Todos los ticks. 

A continuación se muestran los parámetros de entrada utilizados en el proceso de prueba:

       

Tras varias pruebas en un gráfico M1, pude darme de que:

• Esta estrategia es adecuada para USDJPY y EURUSD.
• Esta estrategia no funciona bien en GBPUSD.

Conclusión

De los resultados podemos concluir que este simple Asesor Experto (EA) puede asegurar a un trader algunos buenos resultados si se realiza un mayor refinamiento y adaptación del EA para mejorar su gestión y también reducir la exposición de los activos a altos riesgos. Esto implicará implementar funciones de gestión de riesgos como agregar un stop dinámico que ayudará a mejorar el rendimiento del EA al asegurar ganancias a medida que el mercado se mueve favorablemente. Optimización de parámetros, varias pruebas y ajustes precisos como SAR Step y Maximum para un rendimiento óptimo en diversas condiciones del mercado.

Descargo de responsabilidad: Este código solo está destinado a ayudar a los operadores a obtener los conceptos básicos de la implementación de la estrategia Parabolic SAR y la elaboración de un asesor experto eficaz. Los resultados de demostración que obtuvimos de nuestra prueba retrospectiva no garantizan el rendimiento futuro del EA en el trading.

Es fundamental realizar pruebas retrospectivas y pruebas futuras exhaustivas antes de la implementación en vivo, y el monitoreo continuo es esencial para evitar pérdidas inesperadas y realizar ajustes rápidos. La automatización del comercio con esta estrategia puede ayudar a minimizar los errores humanos y la fatiga, lo que permite la creación de un sistema de comercio sofisticado y rentable a través de la personalización, la optimización y las pruebas. Por lo tanto, adoptar este tipo de automatización puede conducir a una capitalización más eficiente de las oportunidades y a un mejor rendimiento comercial. Hasta este punto, el artículo ha demostrado y proporcionado los conocimientos y las habilidades necesarias para la implementación de la estrategia Parabolic SAR. Se puede acceder a cualquier otro recurso necesario para la implementación en nuestra plataforma MQL5.