Implementando uma Estratégia de Negociação com Bandas de Bollinger usando MQL5: Um Guia Passo a Passo

Introdução

No dinâmico mundo do comércio financeiro, o uso de indicadores técnicos pode ter um grande impacto. As Bandas de Bollinger são uma técnica eficaz que os traders podem usar para determinar possíveis pontos de entrada e saída com base na volatilidade dos preços e na força da tendência. Este artigo explora a automação de escolhas de negociação com uma técnica de Bandas de Bollinger utilizando a linguagem de programação MQL5 no MetaTrader 5.

Os traders podem criar um Expert Advisor (EA) que usa as Bandas de Bollinger para executar ordens de compra e venda com base em condições específicas do mercado, seguindo este tutorial passo a passo. Tópicos importantes, incluindo a configuração do indicador Bandas de Bollinger, controle das posições de negociação e o gerenciamento da execução de ordens e erros, serão abordados. Independentemente do seu nível de experiência com desenvolvimento ou familiaridade com a negociação algorítmica, este tutorial fornecerá uma base sólida para os traders desenvolverem e aprimorarem seus métodos de negociação.

Esta jornada abordará os seguintes tópicos:

1. Definição da estratégia de Bandas de Bollinger
2. Descrição da estratégia de Bandas de Bollinger
3. Implementação passo a passo com MQL5
4. Conclusão

Definição da estratégia de Bandas de Bollinger

A estratégia das Bandas de Bollinger é um método de análise técnica que usa um conjunto de bandas traçadas ao redor de uma média móvel para determinar a utilidade e possíveis oportunidades de negociação. Três bandas formam a estratégia: uma banda inferior (média móvel central menos um múltiplo do desvio padrão), uma banda superior (média móvel central mais um múltiplo do desvio padrão) e uma banda central (média móvel simples). Com base em como o preço interage com as bandas, os traders podem usar essa configuração para identificar situações de sobrecompra ou sobrevenda, identificar possíveis sinais de compra ou venda e prever rompimentos ou reversões de preço.

Descrição da estratégia de Bandas de Bollinger 

Uma ferramenta popular de análise técnica que os traders usam para avaliar a volatilidade do mercado e identificar possíveis oportunidades de negociação é a estratégia de Bandas de Bollinger. John Bollinger criou essa tática, que é composta por três partes principais:

1. Banda Central (SMA): Esta é a média móvel simples (SMA) dos preços de fechamento do ativo para um período determinado. Ela representa o preço médio durante o período especificado e serve como o ponto central de referência da banda.
2. Banda Superior: Esta banda é calculada multiplicando o desvio padrão pela SMA e é mostrada acima da banda central. Ela denota o limite superior do intervalo de preços e é indicativa de condições de sobrecompra ou maior volatilidade. É fornecida por: [{Banda Superior} = {Banda Central} + {Desvio Padrão} {Desvio da Banda&}]
   
3. Banda Inferior: Esta banda é calculada subtraindo um múltiplo do desvio padrão da SMA e é mostrada abaixo da banda central. Como resultado da diminuição da volatilidade ou das condições de sobrevenda, ela denota o limite inferior do intervalo de preços. É fornecida por: [{Banda Inferior} = {Banda Central} - {Desvio Padrão}]
   

Aspectos chave da estratégia:

Movimento de Preço e Interação com a Banda: Os preços geralmente são considerados como sobrevendidos quando se aproximam ou tocam a banda inferior, e como sobrecomprados quando se aproximam ou tocam a banda superior. A identificação de possíveis sinais de compra ou venda pelos traders pode ser auxiliada por essa interação.

• Compressão das Bandas: A "compressão das bandas", que ocorre quando as bandas se restringem e se aproximam uma da outra, é um conceito chave nas Bandas de Bollinger. Isso sugere um período de baixa volatilidade e também pode indicar a iminente ocorrência de um grande movimento de preço ou rompimento. Os traders ficam atentos a possíveis oportunidades de negociação durante essas compressões.

• Confirmação de Tendência: As Bandas de Bollinger são úteis para a confirmação de tendências quando combinadas com outros indicadores. Por exemplo, uma forte tendência de alta pode ser confirmada se o preço romper a banda superior com volume substancial, enquanto uma tendência de baixa pode ser confirmada se o preço romper a banda inferior.                                       

Aplicação da Estratégia:

Usando os níveis de preço em relação às bandas, os traders podem tomar decisões bem-informadas utilizando a estratégia das Bandas de Bollinger. Comprar quando o preço tocar ou cruzar a banda inferior, assumindo um rebote, e vender quando o preço tocar ou cruzar a banda superior, assumindo uma correção, é uma estratégia típica. A estratégia também ajuda a identificar picos de volatilidade e possíveis reversões de tendência.

Implementação passo a passo com MQL5 

Começamos configurando as operações de negociação. A colocação e gerenciamento de ordens são operações de negociação que devem ser tratadas para implementar a estratégia das Bandas de Bollinger com MQL5. Essas operações são facilitadas pela biblioteca de negociação integrada da linguagem MQL5. Vamos discutir a inicialização da biblioteca de negociações e como ela apoia a lógica principal de negociação.

#include<Trade\Trade.mqh> // Incluir a biblioteca de negociação

Devemos criar uma instância da classe CTrade para utilizar as funções oferecidas pela biblioteca de negociação.

CTrade trade; // Criar uma instância da classe CTrade

Podemos usar seus métodos para operações de negociação, como abrir, fechar e modificar ordens, ao adicionar a biblioteca de negociação e inicializar o objeto CTrade. O objeto CTrade oferece várias maneiras de realizar negociações. Usamos ele em nosso EA de Bandas de Bollinger para iniciar ordens de compra e venda de acordo com as condições de negociação especificadas na função onTick. O objeto de negociação é usado para abrir ordens de compra e venda. Uma ordem de compra é aberta pelo EA quando o preço cai abaixo da banda inferior das Bandas de Bollinger.

Com essa configuração, podemos supervisionar efetivamente as atividades de negociação e concentrar-nos na criação de uma lógica de negociação robusta. Os traders podem aprimorar a forma como seu EA reage às condições do mercado e negociações executadas, aprendendo como usar os métodos do {CTrade} para colocar ordens.

Agora configuramos os inputs personalizando a estratégia de negociação. As declarações de input e const em MQL5 permitem que os traders modifiquem e configurem diferentes aspectos de sua estratégia de negociação. Dependendo do estado do mercado e das preferências de negociação, esses inputs podem ser alterados. Vamos discutir a importância desses parâmetros e como a estratégia de Bandas de Bollinger é afetada por eles.

As variáveis de input podem ser alteradas a partir do terminal MetaTrader sem exigir alterações no código. A palavra-chave input é usada para declará-las. O EA de Bandas de Bollinger usa os seguintes parâmetros de entrada:

 // Parâmetros de entrada para a estratégia de Bandas de Bollinger
 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 é o número de períodos utilizados no cálculo da Banda de Bollinger. Enquanto um período menor aumenta a sensibilidade da banda às flutuações de preços, um período maior suaviza as bandas e pode diminuir os sinais de negociação. Modifique isso para levar em conta a volatilidade do mercado ou as necessidades do plano de negociação.

BandDeviation, as bandas superior e inferior são determinadas contando os desvios padrão em relação à média móvel. Bandas mais largas e menos frequentemente tocadas resultam de uma maior divergência, o que pode diminuir os sinais de negociação. Uma divergência menor torna as bandas mais estreitas e aumenta a frequência dos sinais. Ajuste esse valor para regular as responsabilidades das bandas frente às mudanças nos preços.

LotSize é o volume de negociação do ativo. Estabelece o volume de cada negociação. Tamanhos maiores de lote aumentam os ganhos potenciais, mas devem ser ajustados de acordo com o tamanho da sua conta e seu nível de tolerância ao risco.

Slippage é a maior quantidade de deslizamento permitida ao afetar a ordem em pontos. Ajuda a garantir que as ordens sejam preenchidas perto do preço pretendido, levando em consideração pequenas variações de preço entre as colocações de ordens. Ajuste de acordo com o estado do mercado e a liquidez do ativo.

Os valores constantes são valores imutáveis definidos no momento da compilação e não podem ser alterados durante a execução. A palavra-chave const é usada para defini-los:

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

StopLoss é a diferença em pontos entre o stop loss e o preço de abertura. Se o mercado se mover contra você pela quantidade de pontos especificada, você pode limitar suas perdas possíveis fechando a operação. Esse valor deve ser determinado com base na volatilidade do mercado e nas diretrizes de gerenciamento de risco.

TakeProfit é a diferença em pontos entre o take profit e o preço de abertura entre os níveis de impacto e take-profit. Preserva os ganhos ao sair da transação quando o mercado se reverter. Vários pontos para personalização. Ajuste de acordo com o seu nível desejado de lucro e o estado do mercado.

Os traders podem ajustar a estratégia de Bandas de Bollinger ao seu estilo de negociação e ao estado do mercado configurando os parâmetros de entrada e constantes. Eles podem ajustar o desempenho de seu EA e alinhá-lo aos seus objetivos de negociação modificando os parâmetros. É essencial compreender esses fatores e como eles afetam a estratégia para maximizar o desempenho da negociação e gerenciar o risco de forma eficaz.

Depois, analisamos uma variável inteira. Ao longo do script, essa variável é necessária para se referir e interagir com o indicador.

int Bb_Handle; // Handle para o indicador Bandas de Bollinger

Este handle é uma parte essencial do gerenciamento do indicador Bandas de Bollinger no MQL5. Ele garante que a estratégia de negociação funcione de maneira suave e eficaz, facilitando o gerenciamento dos dados e recursos do indicador.

Agora passamos para a função OnInit de um EA que baseia sua lógica de negociação nas Bandas de Bollinger neste tutorial. Quando o EA é reconfigurado ou anexado a um gráfico, a função OnInit é chamada uma vez. Esta função cria os handles necessários para os indicadores e configura os parâmetros iniciais.

O EA define vários parâmetros de entrada antes da função OnInit. Esses parâmetros incluem o período, a desvios das Bandas de Bollinger, o tamanho do lote, o slippage e o stop.

A principal responsabilidade da função OnInit é criar o handle para o indicador Bandas de Bollinger. Isso é feito usando a função iBands.

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

Aqui, estamos tentando criar o indicador Bandas de Bollinger com os parâmetros especificados e atribuindo o handle a Bb_Handle.

Verificar se a criação do handle foi bem-sucedida é crucial. Caso o handle seja inválido, o indicador não foi criado corretamente; para gerenciar esse problema, o EA deve retornar INIT_FAILED e imprimir uma mensagem de erro.

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

A função OnInit deve retornar INIT_SUCCEEDED para mostrar que o procedimento de inicialização foi concluído com sucesso se o handle do indicador for válido.

return(INIT_SUCCEEDED);
  }

Combinando todos os passos, a função OnInit fica conforme mostrado abaixo:

//+------------------------------------------------------------------+
//| 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);
  }

A função OnInit é essencial para configurar os elementos que compõem um EA. O algoritmo garante que ele esteja preparado para executar sua lógica de negociação ao estabelecer um handle para o indicador Bandas de Bollinger e gerenciar qualquer risco.

Em seguida, analisamos a função OnDeinit, que é crucial para o algoritmo, assim como a lógica fundamental de negociação. Garantir que seu Expert Advisor limpe os recursos pode evitar problemas e manter a negociação estável. Quando o EA é excluído de um gráfico ou a plataforma é fechada, a função OnDeinit é acionada. Sua responsabilidade é liberar quaisquer recursos, como handles de indicadores, que foram atribuídos durante as operações do EA. Isso garante que o desempenho da plataforma não seja impactado por vazamentos de memória ou processos persistentes.

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

Liberar o handle do indicador Bandas de Bollinger é a principal responsabilidade da função OnDeinit em nosso Expert Advisor. A função IndicatorRelease é utilizada para isso.

Em seguida, passamos para a função OnTick, que é o coração do nosso Expert Advisor. Ela é acionada toda vez que o preço de atualização para o símbolo atual do gráfico recebe um novo tick. A lógica fundamental de negociação que controla a resposta do EA às condições do mercado está contida nesta função.

//+------------------------------------------------------------------+
//| 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())
    }
  }

Aqui está o detalhamento da função OnTick para facilitar o entendimento:

Definir e recuperar os valores das Bandas de Bollinger: A recuperação dos valores atuais das Bandas de Bollinger é a primeira tarefa. A função CopyBuffer é utilizada para esse propósito, copiando os valores do indicador para 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;

Atribuir valores das bandas às variáveis: Os valores dos arrays são então atribuídos às variáveis para referência mais simples.

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

Recuperar os preços atuais de Ask e Bid: Aqui, precisamos dos preços atuais de Ask e Bid para realizar as negociações.

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

Lógica de negociação baseada nas Bandas de Bollinger: O preço das condições de compra (Buy) é a base da lógica de negociação.

• Condição de compra: realizar uma ordem de compra se não houver posição aberta e o preço estiver abaixo da 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());
     }

• Condição de venda: realizar uma ordem de venda se não houver posição aberta e o preço estiver acima da 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())
    }
  }

Na nossa estratégia de negociação com Bandas de Bollinger, as operações reais acontecem na função OnTick. Podemos desenvolver uma estratégia de negociação confiável e automatizada ao obter cuidadosamente os valores das Bandas de Bollinger e basear as decisões de negociação nesses valores. Cada aspecto dessa função facilita um depuramento mais eficiente e melhorias, garantindo que o nosso EA opere com máxima eficiência em uma variedade de cenários de mercado.

Além da função principal OnTick, nosso Expert Advisor conta com funções auxiliares para gerenciar posições, determinar níveis de take-profit e stop-loss e garantir operações de negociação sem falhas. As funções de suporte são essenciais para preservar a resiliência e eficácia da estratégia de negociação. Vamos abordar as funções auxiliares utilizadas no nosso EA passo a passo de Bandas de Bollinger.

A primeira função auxiliar é verificar por posições abertas. A função isPositionOpen determina se o símbolo fornecido tem uma posição aberta no momento. Isso é necessário para garantir que o EA não abra várias posições simultaneamente para o mesmo 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;
    }

Análise passo a passo da função de verificação de posição aberta:

• Loop por todas as posições: 

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

Fornece o número total de posições disponíveis. Itera por todas as posições usando seu índice.

• Selecionando a posição por índice:  

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

Essa função escolhe a posição com o índice i. Obtém o símbolo da posição selecionada usando PositionGetString.

• Verifica o símbolo e retorna verdadeiro se houver correspondência:
  

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

Compara o símbolo da posição com o símbolo de entrada. Se uma correspondência for encontrada, retorna verdadeiro.

• Retorna falso se não encontrar correspondência.

return false;
    }

Após iterar por todas as posições, retorna falso se nenhuma posição aberta para o símbolo for identificada.

A segunda função auxiliar do nosso EA é fechar todas as posições de um símbolo. Para o símbolo dado, a função CloseAllPositions fecha todas as posições abertas. Isso pode ser útil para gerenciamento de risco ou modificações na estratégia.

//+------------------------------------------------------------------+
//|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);
           }
          }
         }
        

Análise passo a passo para fechar todas as posições de um símbolo:

• Loop por todas as posições em ordem reversa

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

Retorna ao ponto inicial após realizar o loop. Garante que o fechamento da posição não altere a ordem dos índices.

• Selecionando a posição por índice e verificando o símbolo:

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

Escolhe a posição e determina se o símbolo de entrada e o símbolo correspondem.

• Obter o número do ticket e o tipo da posição:

      ulong ticket = PositionGetInteger(POSITION_TICKET);

Recupera o número do ticket da posição.

• Fechar posições de compra ou venda:

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");

Fecha as posições de compra por meio de vendas e as posições de venda por meio de compras. Utiliza os preços de Ask e Bid atuais.

• Pausa para permitir o processamento da ordem:

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

Antes de prosseguir para o próximo slot, pausa por um momento para garantir que a ordem foi processada.

Em seguida, temos nossa última função auxiliar, que calcula os níveis de Stop Loss e Take Profit. Os níveis de Stop Loss (SL) e Take Profit (TP) são determinados pela função CalculateSLTP utilizando o preço atual e o status de compra/venda da negociação.

//+------------------------------------------------------------------+
//| 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;
      }
     }

A análise passo a passo para calcular os níveis das funções Stop Loss e Take Profit:

• Definir os parâmetros da função:

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

• sl: Nível de Stop Loss mencionado.
• tp: O limite de Take Profit.
• price: A taxa atual.
• sBuy: Booleano indicando se a negociação é de compra (verdadeiro) ou venda (falso).

Determinar SL e TP ao abrir uma compra:

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

Stop Loss: subtrai o StopLoss definido (em pontos) do preço atual.

Take Profit: adiciona o TakeProfit definido (em pontos) ao preço atual. Calcular SL e TP para negociações de venda.

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

Stop Loss: aumenta o preço atual pelo StopLoss (em pontos).

Take Profit: subtrai o TakeProfit especificado (em pontos) do preço atual.

O código completo para as funções auxiliares é o seguinte:

//+------------------------------------------------------------------+
//| 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 gerenciando e organizando a lógica básica do nosso Expert Advisor usando as funções auxiliares. Isso garante que o EA funcione sem problemas, gerencie as posições com precisão e calcule os níveis de gerenciamento de risco em nossa estratégia de negociação com Bandas de Bollinger. Por meio da compreensão e aplicação dessas funções auxiliares, você pode melhorar a confiabilidade e a eficiência dos seus algoritmos de negociação em MQL5.

O código completo do nosso artigo é o seguinte:

//+------------------------------------------------------------------+
//|                                               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;
      }
     }

Saúde para nós! Agora criamos um sistema inteligente de negociação com o conceito de Bandas de Bollinger para gerar sinais de negociação.

Resultados do backtest:

Após os testes no testador de estratégia, abaixo estão os resultados:

gráfico

Resultados:

De 2016 a 2019, a estratégia executou 1425 negociações, 857 fechadas com lucro, o que representa 20,28% a mais do que as negociações com perdas.          

Os parâmetros utilizados são os padrões, portanto, os traders podem ajustá-los para se adequar aos seus sistemas de negociação. Abaixo estão os parâmetros que foram usados:

Abaixo estão os parâmetros que foram usados:

Conclusão

Neste artigo, vimos os passos básicos que precisam ser implementados para a automação da estratégia de negociação com Bandas de Bollinger em MQL5. Tivemos a definição básica e a descrição da estratégia e mostramos como ela pode ser implementada em MQL5. Agora, os traders podem usar o conhecimento mostrado para desenvolver uma estratégia de Bandas de Bollinger mais complexa, que pode ser otimizada para produzir melhores resultados no final.

Aviso: O código neste artigo é apenas para fins educacionais e não deve ser interpretado como aconselhamento profissional de investimento. Portanto, implemente cuidadosamente o conhecimento para criar e otimizar seus sistemas para se adequar aos seus estilos de negociação.

Esperamos que você ache útil e um ponto de partida para criar uma estratégia de Bandas de Bollinger melhor otimizada. Anexamos os arquivos necessários para fornecer os exemplos que usamos para demonstrar esses exemplos. Estude o código e aplique-o à sua estratégia específica para obter resultados ideais.