Implementación de una estrategia de trading con Bandas de Bollinger en MQL5: Guía paso a paso

Introducción

En el dinámico mundo del comercio financiero, el uso de indicadores técnicos puede tener un gran impacto. Las Bandas de Bollinger son una técnica efectiva que los operadores pueden utilizar para determinar posibles puntos de entrada y salida en función de la volatilidad de los precios y la fuerza de la tendencia. Este artículo explora la automatización de las opciones comerciales con una técnica de comercio de Bandas de Bollinger utilizando el lenguaje de programación MQL5 en MetaTrader 5.

Los traders pueden crear un Asesor Experto (EA) que utilice Bandas de Bollinger para ejecutar órdenes de compra y venta basadas en condiciones particulares del mercado siguiendo este tutorial paso a paso. Se cubrirán temas importantes, incluida la configuración del indicador de Bandas de Bollinger, el control de posiciones comerciales y el tratamiento de la ejecución de órdenes y la gestión de errores. Independientemente de su nivel de experiencia con el desarrollo o familiaridad con el trading algorítmico, este tutorial brindará a los traders una base sólida sobre la cual diseñar y mejorar sus métodos de trading.

Este viaje cubrirá los siguientes temas:

1. Definición de la estrategia de Bandas de Bollinger
2. Descripción de la estrategia de Bandas de Bollinger
3. Implementación paso a paso con MQL5
4. Conclusión

Definición de la estrategia de Bandas de Bollinger

La estrategia de las Bandas de Bollinger es un método de análisis técnico que utiliza un conjunto de Bandas trazadas alrededor de una media móvil para determinar la utilidad y las posibles oportunidades de negociación. Tres Bandas componen la estrategia: una banda inferior (banda media menos un múltiplo de la desviación típica), una banda superior (banda media más un múltiplo de la desviación típica) y una banda media (media móvil simple). Basándose en cómo interactúa el precio con las Bandas, los operadores pueden utilizar esta configuración para identificar situaciones de sobrecompra o sobreventa, identificar posibles señales de compra o venta y predecir rupturas o retrocesos del precio.

Descripción de la estrategia de Bandas de Bollinger 

Una popular herramienta de análisis técnico que los operadores utilizan para evaluar la volatilidad del mercado y detectar posibles oportunidades de negociación es la estrategia de las Bandas de Bollinger. John Bollinger creó esta táctica, que consta de tres partes principales:

1. Banda media (SMA): Es la media móvil simple (Simple Moving Average, SMA) de los precios de cierre del activo durante un periodo determinado. Representa el precio medio durante el periodo especificado y sirve como punto de referencia central de la banda.
2. Banda superior: Esta banda se calcula multiplicando la desviación típica por la SMA y se muestra por encima de la banda media. Denota el límite superior del rango de precios y es indicativo de condiciones de sobrecompra o mayor volatilidad. Viene dado por : [{Banda superior} = {Banda media} + {Desviación estándar} {Desviación de banda}]
   
3. Banda inferior: Esta banda se calcula deduciendo un múltiplo de la desviación típica de la SMA y se muestra debajo de la banda media. Como resultado de la disminución de la volatilidad o de circunstancias de sobreventa, denota el límite inferior del rango de precios. La proporciona: [{Banda inferior} = {Banda media} - {Desviación estándar}]
   

Aspectos clave de la estrategia:

Movimiento de precios e interacción de Bandas: Los precios suelen considerarse sobrevendidos cuando se acercan o tocan la banda inferior, y sobrecomprados cuando se acercan o tocan la banda superior. Esta interacción puede ayudar a los operadores a identificar posibles señales de compra o venta.

• Compresión de las Bandas: La «compresión de las Bandas», que se produce cuando las Bandas se contraen y convergen entre sí, es una idea clave en las Bandas de Bollinger. Esto sugiere un momento de baja volatilidad y también puede presagiar la inminente aparición de un gran movimiento de precios o ruptura. Los operadores están atentos a las posibles oportunidades de negociación durante estos momentos.

• Confirmación de la tendencia: Las Bandas de Bollinger son útiles para la confirmación de la tendencia cuando se combinan con otros indicadores. Por ejemplo, una fuerte tendencia alcista puede confirmarse si el precio rompe por encima de la banda superior con un volumen considerable, mientras que una tendencia bajista puede confirmarse si el precio rompe por debajo de la banda inferior.                                       

Aplicación de la estrategia:

Utilizando los niveles de precios sobre las Bandas, los operadores pueden tomar decisiones bien informadas utilizando la estrategia de las Bandas de Bollinger. Comprar cuando el precio toca o cruza la banda inferior, suponiendo un rebote, y vender cuando el precio toca o cruza la banda superior, suponiendo un retroceso, es una estrategia típica. La estrategia también ayuda a detectar picos de volatilidad y posibles cambios de tendencia.

Aplicación paso a paso con MQL5 

Empezamos estableciendo operaciones comerciales. La colocación y gestión de órdenes son operaciones de trading que deben ser manejadas para implementar una estrategia de Bandas de Bollinger con MQL5. Estas operaciones se hacen más fáciles gracias a la biblioteca comercial incorporada del lenguaje MQL5. Analicemos la inicialización de la biblioteca comercial y cómo respalda la lógica comercial principal.

#include<Trade\Trade.mqh> // Include the trade library

Debemos construir una instancia de la clase CTrade para utilizar las funciones ofrecidas por la biblioteca comercial.

CTrade trade; // Create an instance of the CTrade class  

Podemos utilizar sus métodos para operaciones comerciales, como abrir, cerrar y cambiar órdenes, agregando la biblioteca comercial e inicializando el objeto CTrade. El objeto CTrade ofrece múltiples formas de realizar transacciones. Lo utilizamos en nuestro EA de Bandas de Bollinger para iniciar órdenes de compra y venta según las circunstancias comerciales especificadas en la función OnTick. El objeto comercial se utiliza para abrir órdenes de compra y venta. El EA abre una orden de compra cuando el precio cae por debajo de la banda de Bollinger inferior.

Con esta configuración, podemos supervisar eficazmente las actividades comerciales y concentrarnos en crear una lógica comercial sólida. Los operadores pueden mejorar la forma en que su EA reacciona a las condiciones del mercado y ejecuta las operaciones aprendiendo a utilizar los métodos CTrade para colocar órdenes.

Ahora configuramos las entradas personalizando la estrategia comercial. Las declaraciones de entrada y constante en MQL5 permiten a los operadores modificar y configurar diferentes aspectos de su estrategia comercial. Dependiendo del estado del mercado y de las preferencias comerciales, estas entradas pueden modificarse. Analicemos la importancia de estos parámetros y cómo afectan el método de negociación de Bandas de Bollinger.

Las entradas de variables se pueden cambiar desde la terminal MetaTrader sin necesidad de realizar modificaciones en el código. La palabra clave "input" se utiliza para declararlos. El EA de Bandas de Bollinger utiliza los siguientes parámetros de entrada:

 // Input parameters for the Bollinger Bands strategy
 input int BandPeriod = 30;
 input double BandDeviation = 2.0;
 input double LotSize = 0.2;
 input int Slippage = 3;
 const double StopLoss = 70;
 const double TakeProfit = 140;

BandPeriod es el número de períodos utilizados en el cálculo de las Bandas de Bollinger. Mientras que un período más bajo aumenta la sensibilidad de las Bandas a las fluctuaciones de precios, un período más grande suaviza las Bandas y puede disminuir las señales comerciales. Modifique esto para tener en cuenta la volatilidad del mercado o las necesidades del plan comercial.

BandDeviation, las Bandas superior e inferior se determinan contando las desviaciones estándar que se desvían de la media móvil. Las Bandas más amplias y menos probables de tocar son el resultado de una desviación mayor que puede disminuir las señales comerciales. Una divergencia menor hace que las Bandas sean más estrechas y la frecuencia de la señal más alta. Ajuste este valor para regular las responsabilidades de las Bandas ante los cambios en los precios.

LotSize es el volumen comercial del activo. Establece el volumen de cada operación. Los mayores tamaños de lote aumentan las posibles ganancias, pero también lo puede modificar en función del tamaño de su cuenta y de su nivel de tolerancia al riesgo.

El Slippage es la cantidad máxima de deslizamiento permitida al ejecutar la orden, expresada en puntos. Ayuda a garantizar que los pedidos se completen cerca del precio previsto, teniendo en cuenta las pequeñas variaciones de precio entre las colocaciones de pedidos. Ajustar en función del estado del mercado y la liquidez del activo.

Las constantes son valores inmutables que se establecen en el momento de la compilación y no se pueden modificar durante el tiempo de ejecución. La palabra clave "const" se utiliza para definirlos:

const double StopLoss = 70;           
const double TakeProfit = 140;   

Stop Loss, la diferencia de puntos entre el Stop Loss y el precio de apertura. Si el mercado se mueve en su contra por los puntos especificados, puede limitar sus posibles pérdidas cerrando la operación. Esta cifra debe determinarse en función de la volatilidad del mercado y de sus pautas de gestión de riesgos.

Take Profit es la diferencia en puntos entre el nivel de Take Profit y el precio de apertura. Preserva las ganancias al salir de la transacción cuando el mercado cambia. Varios puntos para la personalización. Ajuste según el nivel de beneficio deseado y el estado del mercado.

Los operadores pueden ajustar el método de negociación de las Bandas de Bollinger a su estilo de negociación y al estado del mercado configurando parámetros de entrada y constantes. Pueden ajustar el rendimiento de su EA y adaptarlo a sus objetivos comerciales modificando los parámetros. Es esencial comprender estos factores y cómo afectan la estrategia para maximizar el rendimiento comercial y gestionar el riesgo de manera eficiente.

A continuación, analizamos una variable "integer" (entera). A lo largo del script, este manejador es necesario para referirse a la indicación e interactuar con ella.

int Bb_Handle; // Handle for the Bollinger Bands indicator

Este controlador es una parte esencial para manejar el indicador de Bandas de Bollinger de MQL5. Garantiza que la estrategia comercial pueda ejecutarse de manera fluida y eficaz al agilizar la gestión de los datos y recursos de los indicadores.

Ahora pasamos a la función OnInit de un EA que basa su lógica comercial en las Bandas de Bollinger en este tutorial. Cuando se reinicia el EA o se adjunta a un gráfico, la función OnInit se invoca una vez. Esta función crea todos los controladores necesarios para los indicadores y configura los parámetros iniciales.

El EA define varios parámetros de entrada de utilidad antes de la función OnInit. Estos parámetros incluyen el periodo, la desviación de las Bandas de Bollinger, el tamaño del lote, el deslizamiento, el Stop Loss y el Take Profit.

La creación de un controlador para el indicador de Bandas de Bollinger es la responsabilidad principal de la función OnInit. Esto se hace utilizando la función iBands.

int OnInit()
  {
   Bb_Handle = iBands(_Symbol, _Period, BandPeriod, BandDeviation, 0, PRICE_CLOSE);

Aquí estamos intentando crear el indicador de Bandas de Bollinger con el parámetro especificado y asignando el controlador a Bb_Handle.

Es fundamental verificar que la creación del identificador se haya realizado correctamente. En caso de que el identificador no sea válido o no se haya realizado la indicación para gestionar adecuadamente este problema, el EA debe devolver INIT_FAILED e imprimir un mensaje de error.

if(Bb_Handle == INVALID_HANDLE)
     {
      Print("Error creating Bollinger Bands indicator");
      return(INIT_FAILED);
     }

La función OnInit debe devolver INIT_SUCCEEDED para mostrar que el procedimiento de inicialización finalizó exitosamente si el indicador es válido.

return(INIT_SUCCEEDED);
  }

Combinando todos los pasos, la función OnInit se ve como se muestra a continuación:

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   // Create the Bollinger Bands indicator handle
   Bb_Handle = iBands(_Symbol, _Period, BandPeriod, BandDeviation, 0, PRICE_CLOSE); 
    { 
    if(Bb_Handle == INVALID_HANDLE)
     {
      Print("Error creating Bollinger Bands indicator"); 
      return(INIT_FAILED);
     }
   return(INIT_SUCCEEDED);
  }

La función OnInit es esencial para configurar los elementos que componen un EA. El algoritmo se asegura de estar preparado para llevar a cabo su lógica comercial estableciendo un control para el indicador de Bandas de Bollinger y gestionando cualquier riesgo.

A continuación, analizamos la ficción de OnDeinit, esta función es crucial para el algoritmo como la lógica comercial fundamental. Asegurarse de que su Asesor Experto limpie los recursos podría evitar problemas y mantener la estabilidad del trading. Cuando se elimina el EA de un gráfico o se cierra la plataforma, se activa la función OnDeinit. Su responsabilidad es liberar cualquier recurso, como los indicadores, que se asignaron durante las operaciones del EA. Esto garantiza que el rendimiento de la plataforma no se vea afectada por pérdidas de memoria o procesos persistentes.

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   // Release the Bollinger Bands indicator hande
   IndicatorRelease(Bb_Handle);
  }

La liberación del controlador del indicador de Bandas de Bollinger es la principal responsabilidad de la función OnDeinit en nuestro Asesor Experto. Se utiliza la función IndicatorRelease.

A continuación, pasamos a la función OnTick, que es el corazón de nuestro Asesor Experto. Se activa cada vez que la actualización de precios del símbolo del gráfico actual recibe un nuevo tick. La lógica comercial fundamental que controla la respuesta del EA a las condiciones del mercado está contenida en esta función:

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
    double upperBand[], lowerBand[], middleBand[];
   
    // Copy the Bollinger Bands values into arrays
    if(CopyBuffer(Bb_Handle, 0, 0, 1, upperBand) <= 0||
      (CopyBuffer(Bb_Handle, 1, 0, 1, middleBand) <= 0||
      (CopyBuffer(Bb_Handle, 2, 0, 1, lowerBand) <= 0||
   {
     Print("Error copying band values");
     return;
    
     double upper = upperBand[0];
     double lower = lowerBand[0];
     double middle = middleBand[0];
     double price = Close[0];
     double Ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
     double Bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
     
     // Buy signal: price is below the lower band and no open positions 
    if(price < lower && ! IsPositionOpen(_symbol))
      {
       double sl, tp;
       CalculateSLTP(sl, tp, price, true);
      if(trade.Buy(LotSize, _symbol, Ask, sl, tp, "Buy Order"))
        Print("Buy order opened at price: ", price);
      else
      { 
       Print("Error opening BUY order:", trade.ResultRetcode());
     }
      // Sell signal: price is above the upper band no open positions
      else if(price > upper && ! IsPositionOpen(_symbol))
       {
        double sl, tp;
        CalculateSLTP(sl, tp, price, false);
       if(trade.Sell(LotSize, _Symbol, Bid, sl, tp, "Sell Order"));
         Print("Sell order opened at price:", Price);
      else
         print("Error opening SELL order:", trade.ResultRetcode())
    }
  }

A continuación se muestra el desglose detallado de la función OnTick para una fácil comprensión:

Definir y recuperar los valores de las Bandas de Bollinger: Recuperar los valores actuales de las Bandas de Bollinger es la primera tarea. Para este propósito se utiliza la función CopyBuffer, que copia los valores del indicador en matrices (arrays).

double upperBand[], lowerBand[], middleBand[];
   
    // Copy the Bollinger Bands values into arrays
    if(CopyBuffer(Bb_Handle, 0, 0, 1, upperBand) <= 0||
      (CopyBuffer(Bb_Handle, 1, 0, 1, middleBand) <= 0||
      (CopyBuffer(Bb_Handle, 2, 0, 1, lowerBand) <= 0||
   {
     Print("Error copying band values");
     return;

Asignar valores de banda a variables: Luego, los valores de las matrices se asignan a variables para una referencia más sencilla.

     double upper = upperBand[0];
     double lower = lowerBand[0];
     double middle = middleBand[0];
     double price = Close[0];

Recuperar precios actuales de oferta (Ask) y demanda (Bid): Aquí es donde necesitamos los precios actuales de oferta y demanda para realizar operaciones.

     double Ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
     double Bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);

Lógica de negociación basada en las Bandas de Bollinger: El precio de las condiciones de compra es la base de la lógica de trading.

• Condición de compra: Coloque una orden de compra si no hay ninguna posición abierta y el precio está por debajo de la banda inferior. 

   // Buy signal: price is below the lower band and no open positions 
    if(price < lower && ! IsPositionOpen(_symbol))
      {
       double sl, tp;
       CalculateSLTP(sl, tp, price, true);
      if(trade.Buy(LotSize, _symbol, Ask, sl, tp, "Buy Order"))
        Print("Buy order opened at price: ", price);
      else
      { 
       Print("Error opening BUY order:", trade.ResultRetcode());
     }

• Condición de venta: Coloque una orden de venta cuando no haya ninguna posición abierta y el precio esté por encima de la banda superior.

 // Sell signal: price is above the upper band no open positions
      else if(price > upper && ! IsPositionOpen(_symbol))
       {
        double sl, tp;
        CalculateSLTP(sl, tp, price, false);
       if(trade.Sell(LotSize, _Symbol, Bid, sl, tp, "Sell Order"));
         Print("Sell order opened at price:", Price);
      else
         print("Error opening SELL order:", trade.ResultRetcode())
    }
  }

En nuestra estrategia de negociación de Bandas de Bollinger, las operaciones reales tienen lugar en la función OnTick. Podemos desarrollar una estrategia comercial confiable y automatizada obteniendo cuidadosamente los valores de las Bandas de Bollinger y basando las decisiones comerciales en ellos. Cada aspecto de esta función facilita una depuración y mejoras más eficientes, garantizando que nuestro EA funcione con la máxima eficiencia en una variedad de escenarios de mercado.

Además de la función principal de OnTick, nuestro asesor experto se basa en funciones de ayuda para gestionar posiciones, determinar niveles de Take Profit y Stop Loss, y garantizar operaciones comerciales fluidas. Las funciones de soporte son esenciales para preservar la resiliencia y la eficacia de la estrategia comercial. Repasaremos las funciones de ayuda utilizadas en nuestro EA de Bandas de Bollinger paso a paso.

La primera función de ayuda es comprobar si hay posiciones abiertas. La función isPositionOpen determina si el símbolo suministrado tenía una posición abierta en este momento. Esto es necesario para asegurarse de que el EA no abra simultáneamente varios lugares para el mismo símbolo.

//+------------------------------------------------------------------+
//| Check if there's an open position for a symbol                   |
//+------------------------------------------------------------------+
   
   bool IsPositionOpen(string symbol)
   }
    for(int i = 0;  i< PositionsTotal(); i++)
    }
     if(PositionSelectByIndex(i) && PositionGetString(POSITION_SYMBOL) == symbol)
       return true;
     {
      return false;
    }

Desglose paso a paso de la función de verificación de posición abierta:

• Recorrer todas las posiciones: 

for(int i = 0;  i< PositionsTotal(); i++)
    }

Proporciona el número total de posiciones disponibles. Recorre todas las posiciones utilizando su índice.

• Selección de posición por índice:  

if(PositionSelectByIndex(i) && PositionGetString(POSITION_SYMBOL) == symbol)
       

Esta función elige la ubicación del índice "i". Obtiene el símbolo de la posición seleccionada mediante PositionGetString.

• Comprueba el símbolo y devuelve true si coincide:
  

if(PositionSelectByIndex(i) && PositionGetString(POSITION_SYMBOL) == symbol)
       return true;
     

Compara el símbolo de la posición con el símbolo de entrada. Si se encuentra una coincidencia devuelve true.

• Devuelve false si no se encuentra ninguna coincidencia.

return false;
    }

Después de recorrer cada posición, devuelve false si no se identifica ninguna posición abierta para el símbolo.

La segunda función de ayuda de nuestro EA es cerrar todas las posiciones de un símbolo. Para el símbolo dado, la función CloseAllPositions cierra todas las posiciones abiertas. Esto puede ser útil para la gestión de riesgos o la modificación de estrategias.

//+------------------------------------------------------------------+
//|Close all positions for a symbol                                  |
//+------------------------------------------------------------------+
   void CloseAllPositions(string symbol)
  {
   for(int i = PositionsTotal() - 1; i >= 0; i--)
   {
    if(PositionSelectByIndex(i) && PositionGetString(POSITION_SYMBOL) == symbol)
     {
      ulong ticket = PositionGetInteger(POSITION_TICKET);
    if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY)
         trade.sell(LotSize, symbol, symbolInfoDouble(symbol, SYMBOL_BID), Slippage, 0, "Close Buy");
     {
     if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL)
          trade.Buy(LotSize, symbol, SymbolInfoDouble(symbol, SYMBOL_ASK), Slippage, 0, "Close Sell");
          // Wait for order to be processed before continuing
            Sleep(1000);
           }
          }
         }
        

Desglose paso a paso para cerrar todas las posiciones para como función de símbolo:

• Recorrer todas las posiciones en sentido inverso

for(int i = 0;  i< PositionsTotal(); i++)    

Vuelve al punto de partida después de hacer un bucle. Asegura que la posición de cierre no cambie el orden del índice.

• Selección de posición por índice y símbolo de verificación:

   if(PositionSelectByIndex(i) && PositionGetString(POSITION_SYMBOL) == symbol

Elige la ubicación y determina si el símbolo de entrada y el símbolo coinciden.

• Obtener el ticket de posición y tipo:

      ulong ticket = PositionGetInteger(POSITION_TICKET);

Recupera el número de ticket de la posición.

• Cerrar posiciones de compra o venta:

if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY)
        trade.Sell(LotSize, symbol, SymbolInfoDouble(symbol, SYMBOL_BID), Slippage, 0, "Close Buy");
  else if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL)
        trade.Buy(LotSize, symbol, SymbolInfoDouble(symbol, SYMBOL_ASK), Slippage, 0, "Close Sell");

Cierra posiciones de compra mediante ventas y posiciones de venta mediante compras. Hace uso de los precios de compra y venta vigentes en este momento.

• Pausa para permitir el procesamiento del pedido:

      // Wait for order to be processed before continuing
            Sleep(1000);
           }
          }
         }

Antes de pasar a la siguiente ranura, se detiene un momento para asegurarse de que se ha procesado el pedido.

A continuación está nuestra última función de ayuda que es el cálculo de los niveles de Stop Loss y Take Profit. Los niveles de Stop Loss (SL) y Take Profit (TP) se determinan mediante la función CalculateSLTP utilizando el precio actual y el estado de compra/venta de la operación.

//+------------------------------------------------------------------+
//| Calculate Stop Loss and Take Profit levels                       |
//+------------------------------------------------------------------+
   void CalculateSLTP(double &sl, double &tp, double price, bool isBuy)
   {
    if(isBuy)
     {
      sl = price - StopLoss *_Point;
      tp = price + TakeProfit *_Point;
     }
     else 
      {
       sl = price + StopLoss *_Point;
       tp = price - TakeProfit *_Point;
      }
     }

El desglose paso a paso para calcular los niveles de la función Stop Loss y Take Profit:

• Definir los parámetros de la función:

void CalculateSLTP(double &sl, double &tp, double price, bool isBuy)

• sl: El umbral de Stop Loss.
• tp: El umbral de Take Profit.
• price: La cotización actual.
• IsBuy: Booleano que indica si la operación es de compra (true) o de venta (false).

Determinar SL y TP al abrir una compra:

if(isBuy)
  {
    sl = price - StopLoss * _Point;
    tp = price + TakeProfit * _Point;
  }

Stop Loss: resta el Stop Loss definido (en puntos) del Take Profit actual.

Take Profit: Añade el Take Profit definido (en puntos) al precio actual. Calcular SL y TP para operaciones de venta.

else
  {
    sl = price + StopLoss * _Point;
    tp = price - TakeProfit * _Point;
  }
}

Stop Loss: Aumenta el StopLoss (en puntos) del precio actual.

Take Profit: Resta el Take Profit especificado (en puntos) del precio actual.

El código completo de las funciones de ayuda es el siguiente:

//+------------------------------------------------------------------+
//| Check if there's an open position for a symbol                   |
//+------------------------------------------------------------------+
   
   bool IsPositionOpen(string symbol)
   }
    for(int i = 0;  i< PositionsTotal(); i++)
    }
     if(PositionSelectByIndex(i) && PositionGetString(POSITION_SYMBOL) == symbol)
       return true;
     {
      return false;
    }
//+------------------------------------------------------------------+
//|Close all positions for a symbol                                  |
//+------------------------------------------------------------------+
   void CloseAllPositions(string symbol)
  {
   for(int i = PositionsTotal() - 1; i >= 0; i--)
   {
    if(PositionSelectByIndex(i) && PositionGetString(POSITION_SYMBOL) == symbol)
     {
      ulong ticket = PositionGetInteger(POSITION_TICKET);
    if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY)
         trade.sell(LotSize, symbol, symbolInfoDouble(symbol, SYMBOL_BID), Slippage, 0, "Close Buy");
     {
     if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL)
          trade.Buy(LotSize, symbol, SymbolInfoDouble(symbol, SYMBOL_ASK), Slippage, 0, "Close Sell");
          // Wait for order to be processed before continuing
            Sleep(1000);
           }
          }
         }
        
//+------------------------------------------------------------------+
//| Calculate Stop Loss and Take Profit levels                       |
//+------------------------------------------------------------------+
   void CalculateSLTP(double &sl, double &tp, double price, bool isBuy)
   {
    if(isBuy)
     {
      sl = price - StopLoss *_Point;
      tp = price + TakeProfit *_Point;
     }
     else 
      {
       sl = price + StopLoss *_Point;
       tp = price - TakeProfit *_Point;
      }
     }

Estamos gestionando y organizando la lógica básica de nuestro Asesor Experto utilizando las funciones de ayuda. Esto garantiza que el EA funcione sin problemas, gestione las posiciones con precisión y calcule eficazmente los niveles de gestión de riesgos para nuestra estrategia de trading con Bandas de Bollinger. A través de la comprensión y la aplicación de estas funciones de ayuda, puede mejorar la fiabilidad y la eficiencia de sus algoritmos de negociación MQL5.

El código completo de nuestro artículo es el siguiente:

//+------------------------------------------------------------------+
//|                                               BollingerBands.mq5 |
//|                                  Copyright 2024, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2024, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"

 #include<Trade\Trade.mqh> // Include the trade library
 CTrade trade; // Create an instance of the CTrade class  

 // Input parameters for the Bollinger Bands strategy
 input int BandPeriod = 30;
 input double BandDeviation = 2.0;
 input double LotSize = 0.2;
 input int Slippage = 3;
 const double StopLoss = 70;
 const double TakeProfit = 140;
 
 int Bb_Handle; // Handle for the Bollinger Bands indicator 

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   // Create the Bollinger Bands indicator handle
   Bb_Handle = iBands(_Symbol, _Period, BandPeriod, BandDeviation, 0, PRICE_CLOSE); 
    { 
    if(Bb_Handle == INVALID_HANDLE)
     {
      Print("Error creating Bollinger Bands indicator"); 
      return(INIT_FAILED);
     }
   return(INIT_SUCCEEDED);
  }
 
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   // Release the Bollinger Bands indicator hande
   IndicatorRelease(Bb_Handle);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
    double upperBand[], lowerBand[], middleBand[];
   
    // Copy the Bollinger Bands values into arrays
    if(CopyBuffer(Bb_Handle, 0, 0, 1, upperBand) <= 0||
      (CopyBuffer(Bb_Handle, 1, 0, 1, middleBand) <= 0||
      (CopyBuffer(Bb_Handle, 2, 0, 1, lowerBand) <= 0||
   {
     Print("Error copying band values");
     return;
    
     double upper = upperBand[0];
     double lower = lowerBand[0];
     double middle = middleBand[0];
     double price = Close[0];
     double Ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
     double Bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
     
     // Buy signal: price is below the lower band and no open positions 
    if(price < lower && ! IsPositionOpen(_symbol))
      {
       double sl, tp;
       CalculateSLTP(sl, tp, price, true);
      if(trade.Buy(LotSize, _symbol, Ask, sl, tp, "Buy Order"))
        Print("Buy order opened at price: ", price);
      else
      { 
       Print("Error opening BUY order:", trade.ResultRetcode());
     }
      // Sell signal: price is above the upper band no open positions
      else if(price > upper && ! IsPositionOpen(_symbol))
       {
        double sl, tp;
        CalculateSLTP(sl, tp, price, false);
       if(trade.Sell(LotSize, _Symbol, Bid, sl, tp, "Sell Order"));
         Print("Sell order opened at price:", Price);
      else
         print("Error opening SELL order:", trade.ResultRetcode())
    }
  }

//+------------------------------------------------------------------+
//| Check if there's an open position for a symbol                   |
//+------------------------------------------------------------------+
   
   bool IsPositionOpen(string symbol)
   }
    for(int i = 0;  i< PositionsTotal(); i++)
    }
     if(PositionSelectByIndex(i) && PositionGetString(POSITION_SYMBOL) == symbol)
       return true;
     {
      return false;
    }
//+------------------------------------------------------------------+
//|Close all positions for a symbol                                  |
//+------------------------------------------------------------------+
   void CloseAllPositions(string symbol)
  {
   for(int i = PositionsTotal() - 1; i >= 0; i--)
   {
    if(PositionSelectByIndex(i) && PositionGetString(POSITION_SYMBOL) == symbol)
     {
      ulong ticket = PositionGetInteger(POSITION_TICKET);
    if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY)
         trade.sell(LotSize, symbol, symbolInfoDouble(symbol, SYMBOL_BID), Slippage, 0, "Close Buy");
     {
     if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL)
          trade.Buy(LotSize, symbol, SymbolInfoDouble(symbol, SYMBOL_ASK), Slippage, 0, "Close Sell");
          // Wait for order to be processed before continuing
            Sleep(1000);
           }
          }
         }
        
//+------------------------------------------------------------------+
//| Calculate Stop Loss and Take Profit levels                       |
//+------------------------------------------------------------------+
   void CalculateSLTP(double &sl, double &tp, double price, bool isBuy)
   {
    if(isBuy)
     {
      sl = price - StopLoss *_Point;
      tp = price + TakeProfit *_Point;
     }
     else 
      {
       sl = price + StopLoss *_Point;
       tp = price - TakeProfit *_Point;
      }
     }

¡Un brindis por nosotros! Ahora hemos desarrollado un sistema basado en el concepto de Smart Money (Dinero inteligente), utilizando la estrategia de Bandas de Bollinger para generar señales de trading precisas.

Resultados de pruebas retrospectivas

Luego de la prueba en el probador de estrategias, a continuación se muestran los resultados:

Gráfico:

Resultados:

De 2016 a 2019, la estrategia ejecutó 1425 operaciones, 857 se cerraron con ganancias, lo que supone un 20,28% más que las operaciones con pérdidas.          

Los parámetros que se han utilizado son por defecto, por lo que los operadores pueden ajustarlos para adaptarlos a sus sistemas de negociación. A continuación se indican los parámetros utilizados:

Estos son los ajustes que hemos utilizado para realizar nuestra prueba:

Conclusión

En este artículo, analizamos los pasos básicos que deben implementarse para automatizar la estrategia de negociación de Bandas de Bollinger en MQL5. Tenemos la definición y descripción básica de la estrategia y mostramos cómo se puede implementar en MQL5. Los comerciantes ahora pueden usar el conocimiento mostrado para desarrollar una estrategia de Bandas de Bollinger más compleja que se puede optimizar para producir mejores resultados al final.

Descargo de responsabilidad: El código de este artículo es para fines puramente educativos y no debe tomarse como asesoramiento de inversión profesional. Por lo tanto, implemente cuidadosamente el conocimiento para crear y optimizar sus sistemas para que se ajusten a sus estilos comerciales.

Esperamos que lo encuentre útil y un trampolín hacia la creación de una estrategia de Bandas de Bollinger mejor optimizada. Hemos adjuntado los archivos necesarios para proporcionar los ejemplos que utilizamos para demostrar estos ejemplos. Estudia el código y aplícalo a tu estrategia específica para obtener resultados óptimos.