MetaTrader 5 / Negociação
English Русский 中文 Español Deutsch 日本語
preview
Desenvolvimento de um sistema de negociação baseado no indicador Fibonacci

Desenvolvimento de um sistema de negociação baseado no indicador Fibonacci

MetaTrader 5 — Negociação | 29 junho 2023, 10:02
1 019 0
Mohamed Abdelmaaboud
Mohamed Abdelmaaboud

Introdução

Este é um novo artigo da série em que aprendemos a criar sistemas de negociação com base em ferramentas analíticas e indicadores técnicos populares. Desta vez, vamos explorar como criar um sistema de negociação com base no indicador Retração de Fibonacci (Fibonacci Retracement). Este é, sem dúvida, um dos indicadores mais populares no trading. Vamos desenvolver um sistema de negociação que pode ser utilizado na plataforma de negociação MetaTrader 5. Vamos escrever um programa na linguagem MQL5 usando o ambiente integrado MetaEditor. Já discutimos em detalhes como fazer o download e usar o MetaTrader 5 e a IDE. Você pode ler "Como escrever código MQL5 no editor MetaEditor" em um artigo anterior.

Hoje vamos estudar:

É importante notar que é melhor usar Fibonacci em conjunto com outras ferramentas técnicas, como análise de tendência, suporte e resistência, etc., pois isso proporcionará uma compreensão e resultados melhores. Também é muito importante testar e otimizar cuidadosamente as estratégias antes de aplicá-las à negociação, para garantir que elas sejam adequadas. Recomendo que você escreva todos os códigos por conta própria e siga todos os passos mencionados neste artigo. Essa prática ajudará a melhorar suas habilidades de programação.

Atenção! Todo o conteúdo deste artigo é apresentado "tal qual como está", apenas para fins educacionais e não constitui uma recomendação de trading. O artigo não fornece qualquer garantia de resultados. Tudo o que você implementar baseado neste artigo será por sua conta e risco, o autor não garante nenhum resultado.


Definição de Fibonacci

Nesta parte, vamos aprender o que é a ferramenta Retração de Fibonacci e como ela pode ser usada em um gráfico. Fibonacci é uma ferramenta técnica que pode ser usada para identificar áreas de suporte ou resistência em um gráfico (ou seja, áreas em que esperamos que haja um movimento de reversão). Ela é baseada na sequência de Fibonacci, que é uma série matemática de números em que cada número é a soma dos dois números anteriores. No gráfico, os níveis de Fibonacci são plotados como linhas horizontais. Os níveis mais populares no gráfico são 23,6%, 38,2%, 50% e 61,8%.

Para visualizar esses níveis em um gráfico, basta selecionar esse indicador na lista de ferramentas técnicas disponíveis no MetaTrader 5 e aplicá-lo ao gráfico. Veja como fazer isso passo a passo:

Abra o terminal MetaTrader 5, vá para a guia Inserir --> Objetos --> Retração de Fibonacci

Executando níveis de Fibonacci em um gráfico

Em seguida, se houver uma correção após uma tendência de alta, traçamos do mínimo ao máximo e, ao contrário, se houver uma correção após uma tendência de baixa, traçamos do máximo ao mínimo, como nos exemplos a seguir.

Fibonacci após uma tendência de alta:

Ativando níveis de Fibonacci em um gráfico durante uma tendência de alta

Fibonacci após uma tendência de baixa:

Acionando níveis de Fibonacci em um gráfico durante uma tendência de baixa

Como visto nos exemplos acima, no gráfico é exibida uma linha de tendência traçada entre os dois pontos mais altos e mais baixos, além de linhas horizontais nos níveis de 23,6%, 38,2%, 50% e 61,8%. Esses são os níveis em que podemos esperar uma correção ou retração após uma tendência de alta ou baixa, ou seja, podemos esperar que o preço atinja esses níveis e reverta sua direção. Devido a essa característica, os níveis de Fibonacci podem ser usados como níveis de suporte ou resistência.

Os níveis podem ser ajustados por meio da janela de configurações. Para fazer isso, clique com o botão direito do mouse na ferramenta de desenho ou no gráfico. Selecione "Objetos" no menu e, na lista, escolha "Níveis de Fibonacci". Em seguida, a seguinte janela será aberta:

Níveis de Fibonacci janela 1

Na guia "Configurações comuns", é possível escolher o nome do objeto e o estilo de exibição: preços, tipo e espessura da linha.

Níveis de Fibonacci janela 2

Como mostrado na figura acima, a ferramenta permite ajustar de forma flexível os próprios níveis, bem como a aparência deles no gráfico.

Níveis de Fibonacci janela 3

Na guia "Parâmetros", é possível definir a data, hora e valor a partir dos quais começaremos a traçar os níveis, bem como a data, hora e valores nos quais a construção do objeto de Fibonacci será concluída.


Estratégias com base no indicador Fibonacci

Nesta parte, por meio de estratégias simples, vamos aprender como utilizar os níveis de Retração de Fibonacci. Vamos discutir dois métodos. Um deles envolve a determinação dos níveis de Fibonacci com base na última vela diária, e o outro envolve a definição do número de velas em qualquer período gráfico e a determinação dos níveis com base nelas. Em seguida, trabalharemos com outra estratégia, na qual receberemos sinais de compra ou venda com base em um nível de Fibonacci pré-determinado. Vamos examinar cada uma dessas estratégias em detalhes.

Primeira abordagem: com base em dados diários

Sistema simples: Simple FIBO

De acordo com as condições dessa estratégia, iremos obter os níveis de correção de Fibonacci com base nos dados e no estado da vela diária. Se a última vela diária for de alta, iremos traçar os níveis de Fibonacci de alta do mínimo ao máximo da vela e também obter os valores de preço de cada nível. Se a última vela diária for de baixa, iremos traçar os níveis de Fibonacci de baixa do máximo ao mínimo da vela e novamente obter os valores de preço para cada um deles.

Temos o seguinte:

Fechamento do último dia acima da abertura ==> vela de alta

Traçamos os níveis de Fibonacci em verde e obtemos os preços desses níveis.  

Fechamento do último dia abaixo da abertura ==> vela de baixa

Traçamos os níveis de Fibonacci em vermelho e obtemos os preços desses níveis.

Sinais de Fibonacci:

Essa estratégia irá gerar sinais de compra e venda com base em níveis de Fibonacci específicos de alta e baixa. Por exemplo, definimos um nível de Fibonacci de alta em 38.2% e, em seguida, obtemos o preço desse nível para abrir uma posição de compra. Ao definir esse nível para velas de baixa, obtemos o nível de preço para entrar em uma posição de venda.

Segunda abordagem: com base em um array de velas específicas

Segundo sistema simples: Simple FIBO 2

Nessa estratégia, iremos obter os níveis de preço de Fibonacci com base em um array de velas. A direção do mercado (alta ou baixa) para traçar os níveis correspondentes de Fibonacci será determinada com base em todo o array de velas.

Temos o seguinte:

Se a abertura da primeira vela no array for menor que o fechamento da última vela do mesmo array, significa que estamos lidando com níveis de Fibonacci de alta e obtemos o valor de preço correspondente.

Se a abertura da primeira vela no array for maior que o fechamento da última vela do mesmo array, trabalhamos com níveis de Fibonacci de baixa e obtemos o valor de preço correspondente.

Sinais com base nos níveis de Fibonacci 2: 

Essa estratégia irá gerar sinais de entrada em posições de compra e venda com base nos níveis de Fibonacci selecionados, que servirão como níveis de entrada. Se, de acordo com as regras descritas acima, tivermos um Fibonacci de alta, iremos determinar o nível de preço em que podemos entrar em uma posição de compra. Para Fibonacci de baixa, iremos obter o nível de entrada em uma posição de venda.


Esquema das estratégias de Fibonacci

Nesta parte, iremos criar esquemas de desenvolvimento para escrever o código das duas estratégias discutidas. Esses planos/esquemas permitem organizar visualmente o processo de desenvolvimento do sistema de negociação.

Primeira abordagem: com base em dados diários

Vamos lembrar que, nessa abordagem, iremos utilizar apenas a última vela diária e seus valores de abertura, fechamento, máximo e mínimo. Ao comparar os preços de abertura e fechamento, podemos determinar se a vela é de alta ou baixa. Em seguida, com base no tipo de movimento dessa última vela diária, iremos traçar o objeto Fibonacci e obter os sinais.

Sistema simples: Simple FIBO

Esquema de um sistema Fibonacci simples

Sinais de Fibonacci:

esquema de sinais de Fibonacci

Segunda abordagem: com base em um array de velas específicas

Nessa abordagem, iremos trabalhar com um número específico de velas em um array. Iremos determinar o preço de abertura da primeira vela e o fechamento da última vela, assim como o valor máximo e mínimo. Ao comparar os preços de abertura e fechamento, podemos determinar se a vela é de alta ou baixa. Novamente, de acordo com o tipo de movimento das velas nesse array, iremos traçar o objeto Fibonacci e obter os sinais.

Segundo sistema simples: Simple FIBO 2

Segundo sistema simples: Simple FIBO 2

Sinais de Fibonacci 2

Esquema de sinais de Fibonacci 2

Sistema de negociação com Fibonacci

Agora vamos ver como implementar tudo o que discutimos até agora em um sistema de negociação. Vamos criar um programa que irá exibir os níveis de Fibonacci como comentários no gráfico. Iremos testar ambos os métodos: usando apenas a última vela formada no período diário e selecionando um número específico dessas velas (trabalhando com um array de valores). Também vamos aprender como gerar sinais de compra e venda com base em cada uma dessas abordagens usando os níveis de Fibonacci. Vamos examinar tudo em detalhes.

Primeira abordagem: com base em dados diários

Sistema simples: Simple FIBO

Como estamos usando dados diários para essa estratégia, precisamos seguir as seguintes etapas:

Definir o nome do objeto usando uma macro substituição (#define) para pré-processar o código-fonte antes da compilação.

#define FIB_OBJ "Fibonacci Retracement"

Criar uma variável inteira barsTotal.

int barsTotal;

Em seguida, no onTick, criamos uma variável inteira para obter as barras usando a função iBar, que retorna o número de barras históricas disponíveis para o símbolo. Os parâmetros da função são:

  • symbol — nome do símbolo; usamos é _Symbol, ou seja, calculamos usando o símbolo do gráfico atual.
  • timeframe — período gráfico para o cálculo; usamos D1.
int bars = iBars(_Symbol, PERIOD_D1);

Geramos uma condição para determinar qual vela diária devemos usar para o objeto Fibonacci. O parâmetro barTotal não deve ser igual a bars - verificamos isso usando o operador (!=). Além disso, a hora atual deve ser maior do que a hora de fechamento dessa vela diária. Para isso, usamos a função TimeCurrent e StringToTime, que converte uma string de valor de tempo em um valor do tipo datetime.

if(barsTotal != bars  && TimeCurrent() > StringToTime("00:05"))

Se essa condição for cumprida, o programa irá fazer o seguinte:

Definir barsTotal como bars.

barsTotal=bars;

Remover qualquer objeto FIB_OBJ do gráfico usando a função ObjectDelete. Os parâmetros da função são:

  • chart_id — identificador do gráfico, usamos 0, que é o gráfico atual. 
  • name — nome do objeto (FIB_OBJ).
ObjectDelete(0,FIB_OBJ);

Criar quatro variáveis para os valores de preço (abertura, fechamento, máximo e mínimo), preenchidas com as funções iOpen, iClose, iHigh e iLow, que retornam os valores correspondentes da nossa barra diária. Parâmetros da função:

  • symbol — nome do símbolo; usamos é _Symbol, ou seja, calculamos o valor usando o símbolo do gráfico atual.
  • timeframe — período gráfico para cálculos, usamos o período diário PERIOD_D1.
  • start — índice do elemento a partir do qual a verificação começa, não usamos esse valor.
      double open = iOpen(_Symbol,PERIOD_D1,1);
      double close = iClose(_Symbol,PERIOD_D1,1);
      double high = iHigh(_Symbol,PERIOD_D1,1);
      double low = iLow(_Symbol,PERIOD_D1,1);

Determinamos o tempo de início e o tempo de término, que serão usados posteriormente para desenhar nosso objeto Fibonacci. Para isso, vamos usar a função iTime, que retorna o tempo de abertura da barra. Os parâmetros da função são:

  • symbol — nome do símbolo; usamos é _Symbol, ou seja, calculamos o valor usando o símbolo do gráfico atual.
  • timeframe — período gráfico para cálculos, usamos o período diário PERIOD_D1.
  • start — índice do elemento a partir do qual a verificação começa; aqui, especificaremos 1 para a hora de início e 0 para a hora de término.

Para a hora de término, subtraímos 1 do valor retornado, pois será o momento de um novo dia - será a barra diária atual no momento desses cálculos. Na verdade, estamos determinando a barra anterior.

      datetime startingTime = iTime(_Symbol,PERIOD_D1,1);
      datetime endingTime = iTime(_Symbol,PERIOD_D1,0)-1;

Em seguida, estabelecemos duas condições usando a declaração condicional if-else para desenhar o objeto Fibonacci.

Se o fechamento for maior que o aberto, então esta é uma vela de alta, e então fazemos o seguinte.

Criamos o objeto usando a função ObjectCreate para desenhar o objeto com os parâmetros especificados. Os parâmetros da função são:

  • chart_id — identificador do gráfico, 0 significa o gráfico atual.
  • name — nome do objeto usado (FIB_OBJ).
  • type — tipo de objeto usado, OBJ_FIBO — níveis de fibonacci
  • nwin — índice da janela, usamos 0 — janela principal do gráfico.
  • time1 — hora do primeiro ponto de ancoragem, que é igual à hora de início.
  • price1 — preço do primeiro ponto de ancoragem, aqui verificamos o mínimo.
  • timeN=0 — hora do ponto final, é a hora final.
  • priceN=0 — preço do último ponto, usamos o máximo.

Atualizamos as cores do objeto de acordo com a direção da barra usando a função ObjectSetInteger e o operador for do laço. Os parâmetros de ObjectSetInteger são:

  • chart_id — identificador do gráfico; no nosso caso, é 0, o que corresponde ao gráfico atual.
  • name — nome do objeto em uso, FIB_OBJ.
  • prop_id — identificador de propriedade (cor), OBJPROP_COLOR.
  • prop_value — valor da propriedade de cor, clrGreen.
  • Usamos um laço for para atualizar continuamente a cor do objeto.
Definimos os níveis de Fibonacci, 23.6 - 38.2 - 50 - 61.8 - 100. Exibimos um comentário no gráfico com os valores do último dia, abertura e fechamento. 
      if(close>open)
        {
         ObjectCreate(0,FIB_OBJ,OBJ_FIBO,0,startingTime,low,endingTime,high);
         ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrGreen);
         for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++)
           {
            ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrGreen);
           }
         double fibRetracLvl1 = NormalizeDouble(high - (high-low) * 23.6 / 100,_Digits);
         double fibRetracLvl2 = NormalizeDouble(high - (high-low) * 38.2 / 100,_Digits);
         double fibRetracLvl3 = NormalizeDouble(high - (high-low) * 50 / 100,_Digits);
         double fibRetracLvl4 = NormalizeDouble(high - (high-low) * 61.8 / 100,_Digits);
         double fibRetracLvl5 = NormalizeDouble(high - (high-low) * 100 / 100,_Digits);
         Comment("Last Day Open = ",open,"\n",
                 "Last Day Close = ",close,"\n",
                 "Fib lvl 0% = ",high,"\n",
                 "Fib lvl 23.6% = ",fibRetracLvl1,"\n",
                 "Fib lvl 38.2% = ",fibRetracLvl2,"\n",
                 "Fib lvl 50% = ",fibRetracLvl3,"\n",
                 "Fib lvl 61.8% = ",fibRetracLvl4,"\n",
                 "Fib lvl 100% = ",fibRetracLvl5);
        }

Se for uma vela de baixa, fazemos o mesmo, mas a diferença será a seguinte:

  • Criamos um objeto, começando do máximo ao mínimo.
  • A cor do objeto será vermelha.
      else
        {
         ObjectCreate(0,FIB_OBJ,OBJ_FIBO,0,startingTime,high,endingTime,low);
         ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrRed);
         for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++)
           {
            ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrRed);
           }
         double fibRetracLvl1 = NormalizeDouble(low + (high-low) * 23.6 / 100,_Digits);
         double fibRetracLvl2 = NormalizeDouble(low + (high-low) * 38.2 / 100,_Digits);
         double fibRetracLvl3 = NormalizeDouble(low + (high-low) * 50 / 100,_Digits);
         double fibRetracLvl4 = NormalizeDouble(low + (high-low) * 61.8 / 100,_Digits);
         double fibRetracLvl5 = NormalizeDouble(low + (high-low) * 100 / 100,_Digits);
         Comment("Last Day Open = ",open,"\n",
                 "Last Day Close = ",close,"\n",
                 "Fib lvl 0% = ",low,"\n",
                 "Fib lvl 23.6% = ",fibRetracLvl1,"\n",
                 "Fib lvl 38.2% = ",fibRetracLvl2,"\n",
                 "Fib lvl 50% = ",fibRetracLvl3,"\n",
                 "Fib lvl 61.8% = ",fibRetracLvl4,"\n",
                 "Fib lvl 100% = ",fibRetracLvl5);
        }

Abaixo está o código desta estratégia.

//+------------------------------------------------------------------+
//|                                         Simple Fibo System#2.mq5 |
//|                                  Copyright 2023, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2023, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
#define FIB_OBJ "Fibonacci Retracement"
#property script_show_inputs
input double fibRetracLvl = 38.2;
int barsTotal;
//+------------------------------------------------------------------+
void OnTick()
  {

   int bars = iBars(_Symbol, PERIOD_D1);
   if(barsTotal != bars  && TimeCurrent() > StringToTime("00:05"))
     {
      barsTotal=bars;
      ObjectDelete(0,FIB_OBJ);
      double open = iOpen(_Symbol,PERIOD_D1,1);
      double close = iClose(_Symbol,PERIOD_D1,1);
      double closeCandle = iClose(_Symbol,_Period,1);
      double high = iHigh(_Symbol,PERIOD_D1,1);
      double low = iLow(_Symbol,PERIOD_D1,1);
      datetime startingTime = iTime(_Symbol,PERIOD_D1,1);
      datetime endingTime = iTime(_Symbol,PERIOD_D1,0)-1;
      if(close>open)
        {
         ObjectCreate(0,FIB_OBJ,OBJ_FIBO,0,startingTime,low,endingTime,high);
         ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrGreen);
         for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++)
           {
            ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrGreen);
           }
         double fibRetracLvl1 = NormalizeDouble(high - (high-low) * 23.6 / 100,_Digits);
         double fibRetracLvl2 = NormalizeDouble(high - (high-low) * 38.2 / 100,_Digits);
         double fibRetracLvl3 = NormalizeDouble(high - (high-low) * 50 / 100,_Digits);
         double fibRetracLvl4 = NormalizeDouble(high - (high-low) * 61.8 / 100,_Digits);
         double fibRetracLvl5 = NormalizeDouble(high - (high-low) * 100 / 100,_Digits);
         double entryLvl = NormalizeDouble(high - (high-low) * fibRetracLvl /100,_Digits);
         Comment("Last Day Open = ",open,"\n",
                 "Last Day Close = ",close,"\n",
                 "Buy Entry Price: ",entryLvl,"\n",
                 "Close: ",closeCandle,"\n");
        }
      else
        {
         ObjectCreate(0,FIB_OBJ,OBJ_FIBO,0,startingTime,high,endingTime,low);
         ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrRed);
         for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++)
           {
            ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrRed);
           }
         double fibRetracLvl1 = NormalizeDouble(low + (high-low) * 23.6 / 100,_Digits);
         double fibRetracLvl2 = NormalizeDouble(low + (high-low) * 38.2 / 100,_Digits);
         double fibRetracLvl3 = NormalizeDouble(low + (high-low) * 50 / 100,_Digits);
         double fibRetracLvl4 = NormalizeDouble(low + (high-low) * 61.8 / 100,_Digits);
         double fibRetracLvl5 = NormalizeDouble(low + (high-low) * 100 / 100,_Digits);
         double entryLvl = NormalizeDouble(low + (high-low) * fibRetracLvl /100,_Digits);
           {
            Comment("Last Day Open = ",open,"\n",
                    "Last Day Close = ",close,"\n",
                    "Sell Entry Price: ",entryLvl,"\n",
                    "Close: ",closeCandle);
           }
        }
     }
  }
//+------------------------------------------------------------------+

Aqui está o código completo para implementar essa estratégia:

//+------------------------------------------------------------------+
//|                                         Simple Fibo System#1.mq5 |
//|                                  Copyright 2023, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2023, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
#define FIB_OBJ "Fibonacci Retracement"
int barsTotal;
//+------------------------------------------------------------------+
void OnTick()
  {
   int bars = iBars(_Symbol, PERIOD_D1);
   if(barsTotal != bars  && TimeCurrent() > StringToTime("00:05"))
     {
      barsTotal=bars;
      ObjectDelete(0,FIB_OBJ);
      double open = iOpen(_Symbol,PERIOD_D1,1);
      double close = iClose(_Symbol,PERIOD_D1,1);
      double high = iHigh(_Symbol,PERIOD_D1,1);
      double low = iLow(_Symbol,PERIOD_D1,1);
      datetime startingTime = iTime(_Symbol,PERIOD_D1,1);
      datetime endingTime = iTime(_Symbol,PERIOD_D1,0)-1;
      if(close>open)
        {
         ObjectCreate(0,FIB_OBJ,OBJ_FIBO,0,startingTime,low,endingTime,high);
         ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrGreen);
         for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++)
           {
            ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrGreen);
           }
         double fibRetracLvl1 = NormalizeDouble(high - (high-low) * 23.6 / 100,_Digits);
         double fibRetracLvl2 = NormalizeDouble(high - (high-low) * 38.2 / 100,_Digits);
         double fibRetracLvl3 = NormalizeDouble(high - (high-low) * 50 / 100,_Digits);
         double fibRetracLvl4 = NormalizeDouble(high - (high-low) * 61.8 / 100,_Digits);
         double fibRetracLvl5 = NormalizeDouble(high - (high-low) * 100 / 100,_Digits);
         Comment("Last Day Open = ",open,"\n",
                 "Last Day Close = ",close,"\n",
                 "Fib lvl 0% = ",high,"\n",
                 "Fib lvl 23.6% = ",fibRetracLvl1,"\n",
                 "Fib lvl 38.2% = ",fibRetracLvl2,"\n",
                 "Fib lvl 50% = ",fibRetracLvl3,"\n",
                 "Fib lvl 61.8% = ",fibRetracLvl4,"\n",
                 "Fib lvl 100% = ",fibRetracLvl5);
        }
      else
        {
         ObjectCreate(0,FIB_OBJ,OBJ_FIBO,0,startingTime,high,endingTime,low);
         ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrRed);
         for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++)
           {
            ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrRed);
           }
         double fibRetracLvl1 = NormalizeDouble(low + (high-low) * 23.6 / 100,_Digits);
         double fibRetracLvl2 = NormalizeDouble(low + (high-low) * 38.2 / 100,_Digits);
         double fibRetracLvl3 = NormalizeDouble(low + (high-low) * 50 / 100,_Digits);
         double fibRetracLvl4 = NormalizeDouble(low + (high-low) * 61.8 / 100,_Digits);
         double fibRetracLvl5 = NormalizeDouble(low + (high-low) * 100 / 100,_Digits);
         Comment("Last Day Open = ",open,"\n",
                 "Last Day Close = ",close,"\n",
                 "Fib lvl 0% = ",low,"\n",
                 "Fib lvl 23.6% = ",fibRetracLvl1,"\n",
                 "Fib lvl 38.2% = ",fibRetracLvl2,"\n",
                 "Fib lvl 50% = ",fibRetracLvl3,"\n",
                 "Fib lvl 61.8% = ",fibRetracLvl4,"\n",
                 "Fib lvl 100% = ",fibRetracLvl5);
        }
     }
  }
//+------------------------------------------------------------------+

Compilamos o código do EA e ele aparece na janela do Navegador no terminal. A partir daí, executamos o EA no gráfico. Abaixo está um exemplo de teste com velas de alta e baixa:

Vela diária de alta:

Sistema Simples de Fibonacci - Alta - Diário

Os níveis de Fibonacci são traçados do mínimo ao máximo, na cor verde, e os níveis de Fibonacci, abertura e fechamento são calculados para o gráfico diário. Isso é mostrado na captura de tela a seguir:

Sistema Simples de Fibonacci - Alta

Assim, obtivemos o resultado esperado: os níveis de Fibonacci são traçados do mínimo ao máximo e exibidos em verde. Além disso, no gráfico, deve haver um comentário com os seguintes valores:

  • Last day open — corresponde ao valor de abertura da vela diária no gráfico
  • Last day close — valor de fechamento.
  • Cinco níveis de Fibonacci.

Vela diária de baixa:

Sistema Simples de Fibonacci - Baixa

Agora os níveis de Fibonacci são traçados do máximo ao mínimo, na cor vermelha, e os níveis de Fibonacci, abertura e fechamento são calculados para o gráfico diário. Isso é mostrado na captura de tela a seguir:

Sinal de Fibonacci - Alta - Diário

Na imagem acima: os níveis de Fibonacci são traçados do máximo ao mínimo e exibidos em vermelho. No gráfico, há um comentário com os seguintes valores:

  • Last day open — corresponde ao valor de abertura da vela diária no gráfico
  • Last day close — valor de fechamento.
  • Cinco níveis de Fibonacci.

Sinais de Fibonacci:

Para desenvolver essa abordagem, vamos criar um sistema de negociação que pode gerar sinais de compra e venda com base nos níveis de Fibonacci. Abaixo está o código completo para esse sistema:

//+------------------------------------------------------------------+
//|                                         Simple Fibo System#2.mq5 |
//|                                  Copyright 2023, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2023, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
#define FIB_OBJ "Fibonacci Retracement"
#property script_show_inputs
input double fibRetracLvl = 38.2;
int barsTotal;
//+------------------------------------------------------------------+
void OnTick()
  {

   int bars = iBars(_Symbol, PERIOD_D1);
   if(barsTotal != bars  && TimeCurrent() > StringToTime("00:05"))
     {
      barsTotal=bars;
      ObjectDelete(0,FIB_OBJ);
      double open = iOpen(_Symbol,PERIOD_D1,1);
      double close = iClose(_Symbol,PERIOD_D1,1);
      double closeCandle = iClose(_Symbol,_Period,1);
      double high = iHigh(_Symbol,PERIOD_D1,1);
      double low = iLow(_Symbol,PERIOD_D1,1);
      datetime startingTime = iTime(_Symbol,PERIOD_D1,1);
      datetime endingTime = iTime(_Symbol,PERIOD_D1,0)-1;
      if(close>open)
        {
         ObjectCreate(0,FIB_OBJ,OBJ_FIBO,0,startingTime,low,endingTime,high);
         ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrGreen);
         for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++)
           {
            ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrGreen);
           }
         double fibRetracLvl1 = NormalizeDouble(high - (high-low) * 23.6 / 100,_Digits);
         double fibRetracLvl2 = NormalizeDouble(high - (high-low) * 38.2 / 100,_Digits);
         double fibRetracLvl3 = NormalizeDouble(high - (high-low) * 50 / 100,_Digits);
         double fibRetracLvl4 = NormalizeDouble(high - (high-low) * 61.8 / 100,_Digits);
         double fibRetracLvl5 = NormalizeDouble(high - (high-low) * 100 / 100,_Digits);
         double entryLvl = NormalizeDouble(high - (high-low) * fibRetracLvl /100,_Digits);
         Comment("Last Day Open = ",open,"\n",
                 "Last Day Close = ",close,"\n",
                 "Buy Entry Price: ",entryLvl);
        }
      else
        {
         ObjectCreate(0,FIB_OBJ,OBJ_FIBO,0,startingTime,high,endingTime,low);
         ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrRed);
         for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++)
           {
            ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrRed);
           }
         double fibRetracLvl1 = NormalizeDouble(low + (high-low) * 23.6 / 100,_Digits);
         double fibRetracLvl2 = NormalizeDouble(low + (high-low) * 38.2 / 100,_Digits);
         double fibRetracLvl3 = NormalizeDouble(low + (high-low) * 50 / 100,_Digits);
         double fibRetracLvl4 = NormalizeDouble(low + (high-low) * 61.8 / 100,_Digits);
         double fibRetracLvl5 = NormalizeDouble(low + (high-low) * 100 / 100,_Digits);
         double entryLvl = NormalizeDouble(low + (high-low) * fibRetracLvl /100,_Digits);
           {
            Comment("Last Day Open = ",open,"\n",
                    "Last Day Close = ",close,"\n",
                    "Sell Entry Price: ",entryLvl);
           }
        }
     }
  }
//+------------------------------------------------------------------+

Essas são as diferenças neste código:

Adicionamos propriedades para exibir uma janela na qual o usuário pode inserir um valor. Isso é feito usando #property script_show_inputs, que exibe uma janela com as propriedades.

#property script_show_inputs

Usamos uma variável de entrada para criar a variável double fibRetracLvl com um valor padrão de 38,2.

input double fibRetracLvl = 38.2;

Determinamos o nível de entrada com base no valor inserido pelo usuário no caso de uma tendência de alta.

double entryLvl = NormalizeDouble(high - (high-low) * fibRetracLvl /100,_Digits);

Determinamos o nível de entrada com base no valor inserido pelo usuário no caso de uma tendência de baixa.

double entryLvl = NormalizeDouble(low + (high-low) * fibRetracLvl /100,_Digits);

Comentário no gráfico no caso de uma tendência de alta.

         Comment("Last Day Open = ",open,"\n",
                 "Last Day Close = ",close,"\n",
                 "Buy Entry Price: ",entryLvl,"\n",
                 "Close: ",closeCandle,"\n");

Comentário no gráfico no caso de uma tendência de baixa.

            Comment("Last Day Open = ",open,"\n",
                    "Last Day Close = ",close,"\n",
                    "Sell Entry Price: ",entryLvl,"\n",
                    "Close: ",closeCandle);

Compilamos o código do EA. Em seguida, ele aparece na janela do Navegador no terminal. A partir daí, executamos o EA no gráfico. Abaixo está um exemplo de teste com velas de alta e baixa:

Vela diária de alta:

Sinal de Fibonacci - alta - diário

Assim, devemos obter os níveis de Fibonacci traçados em verde, do mínimo ao máximo no período de 15 minutos, a abertura e o fechamento do último dia são os mesmos que no gráfico diário, e o nível de entrada é o nível de preço próximo a 38,2. Para o gráfico de 15 minutos, temos o seguinte:

Sinal de Fibonacci - alta - diário

Então, este é um gráfico de 15 minutos onde temos todas as construções e valores necessários:

  • Abertura do último dia — nível de abertura do gráfico diário.
  • Last day close — valor de fechamento.
  • Buy entry price — preço para entrar no nível de Fibonacci 38,2.

Vela diária de baixa:

Sinal Fibonacci - alta - vela diária

Agora vamos verificar o gráfico de 15 minutos, onde devemos obter um sinal com base na estratégia de negociação, que deve mostrar um nível de entrada para venda com base no nível de Fibonacci 38.2. Verifiquemos no gráfico abaixo:

Sinal de Fibonacci - Baixa

Como podemos ver, no gráfico acima, um sinal foi formado com os seguintes valores:

  • Abertura do último dia — nível de abertura do gráfico diário.
  • Last day close — valor de fechamento.
  • Preço de entrada de venda — preço de entrada em Fibonacci 38,2.

Segunda abordagem: com base em um array de velas específicas

Segundo sistema simples: Simple FIBO 2

Nesta abordagem, usaremos um conjunto fixo de velas que serão usadas para construir os níveis de Fibonacci. Vamos analisar passo a passo como fazer isso:

Definimos FIB_OBJ usando #define.

#define FIB_OBJ "Fibonacci Retracement"

Criamos variáveis inteiras para o valor máximo e mínimo.

int highestCandle, lowestCandle;

Criamos dois arrays para os máximos e mínimos.

double high[],low[];

Classificacmos os dados nos arrays usando a função ArraySetAsSeries. Os parâmetros da função são:

  • array[] — definimos os arrays criados.
  • flag — definimos a direção da indexação no array, true.
ArraySetAsSeries(high,true);
ArraySetAsSeries(low,true);

Obtemos os dados históricos dos máximos e mínimos usando as funções CopyHigh e CopyLow. Parâmetros do CopyHigh:

  • symbol_name — nome do símbolo; especificamos _Symbol para usar o atual.
  • period — período de cálculo do indicador; usamos o período atual (_period) 
  • start_pos — definimos a posição inicial do cálculo, indicamos 0 para iniciar na vela atual.
  • count — quantidade de dados a serem copiados, especificamos 100
  • high_array[] — array de destino, que no nosso caso é high.

Para o CopyLow, os parâmetros serão os mesmos, mas um array low será criado como o array de destino.

CopyHigh(_Symbol,_Period,0,100,high);
CopyLow(_Symbol,_Period,0,100,low);

Determinamos o preço de abertura da primeira vela no array e o preço de fechamento da última vela usando as funções iOpen e iClose.

double openCandle = iOpen(_Symbol,_Period,100);
double closeCandle = iClose(_Symbol,_Period,1);

Determinamos os valores máximo e mínimo nos arrays high e low usando as funções ArrayMaximum e ArrayMinimum. Parâmetros da função:

  • array[] — array, high para os máximos e low para os mínimos.
  • start=0 — índice do elemento a partir do qual a verificação começa, usamos 0.
  • count — número de elementos a serem verificados, aqui é 100 ou WHOLE_ARRAY.
highestCandle=ArrayMaximum(high,0,100);
lowestCandle=ArrayMinimum(low,0,100);

Criamos um array de preços usando a função MqlRates para armazenar informações sobre os preços e ordenamos os dados nesse array usando a função ArraySetAsSeries.

MqlRates pArray[];
ArraySetAsSeries(pArray,true);

Obtemos os dados históricos usando a função CopyRates do MqlRates. Os parâmetros da função são:

  • symbol_name — nome do símbolo para cálculo do indicador, _Symbol — símbolo atual.
  • timeframe — período gráfico para cálculo, _Period significa o período gráfico atual.
  • start_pos — posição do início do cálculo do indicador, especificamos 0 para o cálculo a partir da posição atual
  • count — quantidade de dados a serem copiados, Bars.
  • rates_array[] — array aonde copiamos os dados, pArray
int pData=CopyRates(_Symbol,_Period,0,Bars(_Symbol,_Period),pArray);

Determinamos o dateTime e os preços do nível zero e do nível 100 usando ObjectGetInteger e ObjectGetDouble.

datetime dTlvl0 = ObjectGetInteger(0,"Fibonacci Retracement",OBJPROP_TIME,0);
double PriceFibLvl00 = ObjectGetDouble(0,"Fibonacci Retracement",OBJPROP_PRICE,0);
datetime dTlvl1 = ObjectGetInteger(0,"Fibonacci Retracement",OBJPROP_TIME,1);
double PriceFibLvl0 = ObjectGetDouble(0,"Fibonacci Retracement",OBJPROP_PRICE,1);

Configuramos as condições para tendências de alta e baixa usando o operador if-else.

No caso de uma tendência de alta (CloseCandle maior que openCandle), os passos seguintes serão executados:

  • Removemos o objeto FIBO previamente criado usando a função ObjectDelete.
  • Criamos um novo objeto FIBO, começando do mínimo e terminando no máximo do array, usando a função ObjectCreate.
  • Atualizamos as cores do objeto FIBO - alterando para verde - usando a função ObjectSetInteger e um laço for para continuar atualizando de acordo com a tendência.
  • Determinamos o intervalo de preços, calculando a diferença entre o máximo e o mínimo.
  • Determinamos os níveis de FIBO, que são 23.6 - 38.2 - 50 - 61.8.
  • Exibimos um comentário no gráfico com os níveis Array Open, Array Close e FIBO.
   if(closeCandle>openCandle)
     {
      ObjectDelete(_Symbol, "Fibonacci Retracement");
      ObjectCreate(_Symbol, "Fibonacci Retracement",OBJ_FIBO,0,pArray[100].time,
                   pArray[lowestCandle].low,pArray[0].time,pArray[highestCandle].high);
      ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrGreen);
      for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++)
        {
         ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrGreen);
        }
      double pRange =  PriceFibLvl0 - PriceFibLvl00;
      double PriceFibLvl1 = NormalizeDouble (PriceFibLvl0 - pRange * 23.6/100,_Digits);
      double PriceFibLvl2 = NormalizeDouble (PriceFibLvl0 - pRange * 38.2/100,_Digits);
      double PriceFibLvl3 = NormalizeDouble (PriceFibLvl0 - pRange * 50/100,_Digits);
      double PriceFibLvl4 = NormalizeDouble(PriceFibLvl0 - pRange * 61.8/100,_Digits);
      Comment("Array Open: ",openCandle,"\n",
              "Array Close: ",closeCandle,"\n",
              "Fib lvl 0% = ",PriceFibLvl0,"\n",
              "Fib lvl 23.6% = ",PriceFibLvl1,"\n",
              "Fib lvl 38.2% = ",PriceFibLvl2,"\n",
              "Fib lvl 50% = ",PriceFibLvl3,"\n",
              "Fib lvl 61.8% = ",PriceFibLvl4,"\n",
              "Fib lvl 100% = ",PriceFibLvl00);
     }

No caso de uma tendência de baixa (CloseCandle menor que openCandle), os passos serão os seguintes:

  • Removemos o objeto FIBO previamente criado usando a função ObjectDelete.
  • Criamos um novo objeto FIBO, indo do máximo ao mínimo do array, usando o ObjectCreate.
  • Atualizamos as cores do objeto FIBO - alteramos para vermelho usando o ObjectSetInteger e um laço for para continuar atualizando de acordo com a tendência.
  • Determinamos a faixa de preço, obtendo a diferença entre o mínimo e o máximo.
  • Determinamos os níveis de FIBO, que são 23.6 - 38.2 - 50 - 61.8.
  • Exibimos um comentário no gráfico com os níveis Array Open, Array Close e FIBO.
   else
     {
      ObjectDelete(_Symbol, "Fibonacci Retracement");
      ObjectCreate(_Symbol, "Fibonacci Retracement",OBJ_FIBO,0,pArray[100].time,
                   pArray[highestCandle].high,pArray[0].time,pArray[lowestCandle].low);
      ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrRed);
      for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++)
        {
         ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrRed);
        }
      double pRange =  PriceFibLvl00 - PriceFibLvl0;
      double PriceFibLvl1 = NormalizeDouble (PriceFibLvl0 + pRange * 23.6/100,_Digits);
      double PriceFibLvl2 = NormalizeDouble (PriceFibLvl0 + pRange * 38.2/100,_Digits);
      double PriceFibLvl3 = NormalizeDouble(PriceFibLvl0 + pRange * 50/100,_Digits);
      double PriceFibLvl4 = NormalizeDouble (PriceFibLvl0 + pRange * 61.8/100,_Digits);
      Comment("Array Open: ",openCandle,"\n",
              "Array Close: ",closeCandle,"\n",
              "Fib lvl 0% = ",PriceFibLvl0,"\n",
              "Fib lvl 23.6% = ",PriceFibLvl1,"\n",
              "Fib lvl 38.2% = ",PriceFibLvl2,"\n",
              "Fib lvl 50% = ",PriceFibLvl3,"\n",
              "Fib lvl 61.8% = ",PriceFibLvl4,"\n",
              "Fib lvl 100% = ",PriceFibLvl00);
     }

Abaixo está o código completo:

//+------------------------------------------------------------------+
//|                                         Simple Fibo System 2.mq5 |
//|                                  Copyright 2023, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2023, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
#define FIB_OBJ "Fibonacci Retracement"
//+------------------------------------------------------------------+
void OnTick()
  {
   int highestCandle, lowestCandle;
   double high[],low[];
   ArraySetAsSeries(high,true);
   ArraySetAsSeries(low,true);
   CopyHigh(_Symbol,_Period,0,100,high);
   CopyLow(_Symbol,_Period,0,100,low);
   double openCandle = iOpen(_Symbol,_Period,100);
   double closeCandle = iClose(_Symbol,_Period,1);
   highestCandle=ArrayMaximum(high,0,100);
   lowestCandle=ArrayMinimum(low,0,100);
   MqlRates pArray[];
   ArraySetAsSeries(pArray,true);
   int pData=CopyRates(_Symbol,_Period,0,Bars(_Symbol,_Period),pArray);
   datetime dTlvl0 = ObjectGetInteger(0,"Fibonacci Retracement",OBJPROP_TIME,0);
   double PriceFibLvl00 = ObjectGetDouble(0,"Fibonacci Retracement",OBJPROP_PRICE,0);
   datetime dTlvl1 = ObjectGetInteger(0,"Fibonacci Retracement",OBJPROP_TIME,1);
   double PriceFibLvl0 = ObjectGetDouble(0,"Fibonacci Retracement",OBJPROP_PRICE,1);
   if(closeCandle>openCandle)
     {
      ObjectDelete(_Symbol, "Fibonacci Retracement");
      ObjectCreate(_Symbol, "Fibonacci Retracement",OBJ_FIBO,0,pArray[100].time,
                   pArray[lowestCandle].low,pArray[0].time,pArray[highestCandle].high);
      ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrGreen);
      for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++)
        {
         ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrGreen);
        }
      double pRange =  PriceFibLvl0 - PriceFibLvl00;
      double PriceFibLvl1 = NormalizeDouble (PriceFibLvl0 - pRange * 23.6/100,_Digits);
      double PriceFibLvl2 = NormalizeDouble (PriceFibLvl0 - pRange * 38.2/100,_Digits);
      double PriceFibLvl3 = NormalizeDouble (PriceFibLvl0 - pRange * 50/100,_Digits);
      double PriceFibLvl4 = NormalizeDouble(PriceFibLvl0 - pRange * 61.8/100,_Digits);
      Comment("Array Open: ",openCandle,"\n",
              "Array Close: ",closeCandle,"\n",
              "Fib lvl 0% = ",PriceFibLvl0,"\n",
              "Fib lvl 23.6% = ",PriceFibLvl1,"\n",
              "Fib lvl 38.2% = ",PriceFibLvl2,"\n",
              "Fib lvl 50% = ",PriceFibLvl3,"\n",
              "Fib lvl 61.8% = ",PriceFibLvl4,"\n",
              "Fib lvl 100% = ",PriceFibLvl00);
     }
   else
     {
      ObjectDelete(_Symbol, "Fibonacci Retracement");
      ObjectCreate(_Symbol, "Fibonacci Retracement",OBJ_FIBO,0,pArray[100].time,
                   pArray[highestCandle].high,pArray[0].time,pArray[lowestCandle].low);
      ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrRed);
      for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++)
        {
         ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrRed);
        }
      double pRange =  PriceFibLvl00 - PriceFibLvl0;
      double PriceFibLvl1 = NormalizeDouble (PriceFibLvl0 + pRange * 23.6/100,_Digits);
      double PriceFibLvl2 = NormalizeDouble (PriceFibLvl0 + pRange * 38.2/100,_Digits);
      double PriceFibLvl3 = NormalizeDouble(PriceFibLvl0 + pRange * 50/100,_Digits);
      double PriceFibLvl4 = NormalizeDouble (PriceFibLvl0 + pRange * 61.8/100,_Digits);
      Comment("Array Open: ",openCandle,"\n",
              "Array Close: ",closeCandle,"\n",
              "Fib lvl 0% = ",PriceFibLvl0,"\n",
              "Fib lvl 23.6% = ",PriceFibLvl1,"\n",
              "Fib lvl 38.2% = ",PriceFibLvl2,"\n",
              "Fib lvl 50% = ",PriceFibLvl3,"\n",
              "Fib lvl 61.8% = ",PriceFibLvl4,"\n",
              "Fib lvl 100% = ",PriceFibLvl00);
     }
  }
//+------------------------------------------------------------------+

Compilamos o código e o executamos no gráfico a partir do Navegador. O EA irá gerar sinais. Abaixo estão exemplos de sinais de teste.

No caso de um array de alta:

Sistema Simples de Fibonacci 2 - Alta

Assim, no gráfico acima, temos os níveis de Fibonacci traçados em verde e um comentário no canto superior esquerdo do gráfico com os seguintes valores:

  • Array open — valor da abertura no array.
  • Array close — valor de fechamento no array.
  • Níveis de Fibonacci 0, 23,6, 38,2, 50, 61,8, 100.

No caso de um array de baixa:

Sistema Simples de Fibonacci 2 - Baixa

Aqui, temos os níveis de Fibonacci traçados em vermelho e um comentário no canto superior esquerdo do gráfico com os seguintes valores:

  • Array open — valor da abertura no array.
  • Array close — valor de fechamento no array.
  • Níveis de Fibonacci 0, 23,6, 38,2, 50, 61,8, 100.

Sinais de Fibonacci 2

Agora, criaremos um sistema de negociação com base na segunda abordagem, que retornará sinais de compra e venda com base nos níveis de Fibonacci. O código completo para esse sistema de negociação é o seguinte:

//+------------------------------------------------------------------+
//|                                               Fibo Signals 2.mq5 |
//|                                  Copyright 2023, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2023, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
#define FIB_OBJ "Fibonacci Retracement"
#property script_show_inputs
input double fibRetracLvl = 38.2;
//+------------------------------------------------------------------+
void OnTick()
  {
   int highestCandle, lowestCandle;
   double high[],low[];
   ArraySetAsSeries(high,true);
   ArraySetAsSeries(low,true);
   CopyHigh(_Symbol,_Period,0,100,high);
   CopyLow(_Symbol,_Period,0,100,low);
   double openCandle = iOpen(_Symbol,_Period,100);
   double closeCandle = iClose(_Symbol,_Period,1);
   highestCandle=ArrayMaximum(high,0,100);
   lowestCandle=ArrayMinimum(low,0,100);
   MqlRates pArray[];
   ArraySetAsSeries(pArray,true);
   int pData=CopyRates(_Symbol,_Period,0,Bars(_Symbol,_Period),pArray);
   datetime dTlvl0 = ObjectGetInteger(0,"Fibonacci Retracement",OBJPROP_TIME,0);
   double PriceFibLvl00 = ObjectGetDouble(0,"Fibonacci Retracement",OBJPROP_PRICE,0);
   datetime dTlvl1 = ObjectGetInteger(0,"Fibonacci Retracement",OBJPROP_TIME,1);
   double PriceFibLvl0 = ObjectGetDouble(0,"Fibonacci Retracement",OBJPROP_PRICE,1);
   if
   (closeCandle>openCandle)
     {
      ObjectDelete(_Symbol, "Fibonacci Retracement");
      ObjectCreate(_Symbol, "Fibonacci Retracement",OBJ_FIBO,0,pArray[100].time,
                   pArray[lowestCandle].low,pArray[0].time,pArray[highestCandle].high);
      ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrGreen);
      for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++)
        {
         ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrGreen);
        }
      double pRange =  PriceFibLvl0 - PriceFibLvl00;
      double PriceFibLvl1 = NormalizeDouble(PriceFibLvl0 - pRange * 23.6/100,_Digits);
      double PriceFibLvl2 = NormalizeDouble(PriceFibLvl0 - pRange * 38.2/100,_Digits);
      double PriceFibLvl3 = NormalizeDouble(PriceFibLvl0 - pRange * 50/100,_Digits);
      double PriceFibLvl4 = NormalizeDouble(PriceFibLvl0 - pRange * 61.8/100,_Digits);
      double entryLvl = NormalizeDouble(PriceFibLvl0 - pRange * fibRetracLvl/100,_Digits);
      Comment("Array Open: ",openCandle,"\n",
              "Array Close: ",closeCandle,"\n",
              "Buy Entry Price: ",entryLvl);
     }
   else
     {
      ObjectDelete(_Symbol, "Fibonacci Retracement");
      ObjectCreate(_Symbol, "Fibonacci Retracement",OBJ_FIBO,0,pArray[100].time,
                   pArray[highestCandle].high,pArray[0].time,pArray[lowestCandle].low);
      ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrRed);
      for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++)
        {
         ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrRed);
        }
      double pRange =  PriceFibLvl00 - PriceFibLvl0;
      double PriceFibLvl1 = NormalizeDouble(PriceFibLvl0 + pRange * 23.6/100,_Digits);
      double PriceFibLvl2 = NormalizeDouble(PriceFibLvl0 + pRange * 38.2/100,_Digits);
      double PriceFibLvl3 = NormalizeDouble(PriceFibLvl0 + pRange * 50/100,_Digits);
      double PriceFibLvl4 = NormalizeDouble(PriceFibLvl0 + pRange * 61.8/100,_Digits);
      double entryLvl = NormalizeDouble(PriceFibLvl0 + pRange * fibRetracLvl/100,_Digits);
      Comment("Array Open: ",openCandle,"\n",
              "Array Close: ",closeCandle,"\n",
              "Sell Entry Price: ",entryLvl);
     }
  }
//+------------------------------------------------------------------+

Essas são as diferenças neste código:

Aqui, adicionamos a propriedade #property script_show_inputs, que exibe uma janela com as propriedades. Usamos uma variável de entrada para criar fibRetracLvl do tipo double, por exemplo, com o valor padrão de 38,2.

#property script_show_inputs
input double fibRetracLvl = 38.2;

Determinamos o nível de entrada com base no valor especificado pelo usuário no caso de uma tendência de alta:

double entryLvl = NormalizeDouble(PriceFibLvl0 - pRange * fibRetracLvl/100,_Digits);

Determinamos o nível de entrada com base no valor inserido pelo usuário no caso de uma tendência de baixa.

double entryLvl = NormalizeDouble(PriceFibLvl0 + pRange * fibRetracLvl/100,_Digits);

Comentário para o Fibonacci de alta.

      Comment("Array Open: ",openCandle,"\n",
              "Array Close: ",closeCandle,"\n",
              "Buy Entry Price: ",entryLvl);

Comentário para o Fibonacci de baixa.

      Comment("Array Open: ",openCandle,"\n",
              "Array Close: ",closeCandle,"\n",
              "Sell Entry Price: ",entryLvl);

Compilamos o código do EA e ele aparece na janela do Navegador no terminal. A partir daí, o executamos no gráfico. Abaixo estão exemplos para arrays de alta e baixa.

Array de alta:

Sinal de Fibonacci 2 - Alta

No gráfico acima, temos os níveis de Fibonacci traçados em verde, do mínimo ao máximo, e um comentário no gráfico com os seguintes valores:

  • Array open — valor da abertura no array.
  • Array close — valor de fechamento no array.
  • Preço de entrada de compra — preço para entrar em uma posição de compra em Fibonacci 38.2.

No caso de um array de baixa:

Sinal de Fibonacci 2 - Baixa

No gráfico, temos os níveis de Fibonacci traçados em vermelho, do máximo ao mínimo, e um comentário no gráfico com os seguintes valores:

  • Array open — valor da abertura no array.
  • Array close — valor de fechamento no array.
  • Sell entry price — preço para entrar em uma negociação de venda no nível Fibonacci 38.2.


Considerações finais

Aprendemos como criar um sistema de negociação simples com base nos níveis de Fibonacci usando o MQL5. Esse sistema de negociação é destinado a ser usado na plataforma de negociação MetaTrader 5. Antes de criar estratégias, examinamos em detalhes a ferramenta técnica Fibonacci e aprendemos como usá-la no MetaTrader 5.

Além disso, apresentei a vocês duas abordagens para criar níveis de Fibonacci: uma usando dados diários e outra usando um array de velsa em qualquer período gráfico para gerar níveis de entrada de compra ou venda com base nos níveis de Fibonacci. Como em todos os artigos anteriores, enfatizo a importância de testar cuidadosamente todos os novos conhecimentos antes de aplicá-los em uma conta real, para garantir que eles se adequem ao seu estilo e compreensão de negociação. O que funciona para os outros nem sempre funcionará para você. Além disso, lembre-se de que o objetivo principal das estratégias é educacional.

Espero que este artigo ajude a melhorar um pouco sua negociação e traga novas ideias. Desejo a todos vocês negociações lucrativas! Se você gostou deste artigo e o considerou útil, confira meus artigos anteriores desta mesma série para aprender a desenvolver sistemas de negociação com base em vários indicadores técnicos populares. Já cobrimos indicadores como Stochastic, RSI, Bollinger Bands, Moving Averages, Envelopes, MACD, ADX e outros.

Traduzido do Inglês pela MetaQuotes Ltd.
Artigo original: https://www.mql5.com/en/articles/12301

Aviso: Todos os direitos sobre esses materiais pertencem à MetaQuotes Ltd. É proibida a reimpressão total ou parcial.

Outros artigos do autor

Ir para discussão
Desenvolvendo um sistema de Replay - Simulação de mercado (Parte 17): Tiquete e mais tiquetes (I) Desenvolvendo um sistema de Replay - Simulação de mercado (Parte 17): Tiquete e mais tiquetes (I)
Aqui vamos começar a ver como implementar algo realmente bem interessante e curioso. Mas ao mesmo tempo extremamente complicado por conta de algumas questões que muitos confundem. Mas pior do que as confundir, é o fato de que alguns operadores que se dizem profissionais, não fazem ideia a importância de tais conceitos no mercado de capital. Sim, apesar do foco aqui ser programação, entender algumas questões que envolvem operações em mercados, é de extrema valia para o que iremos começar a implementar aqui.
Algoritmos de otimização populacionais: Algoritmo de mudas, semeadura e crescimento (SSG) Algoritmos de otimização populacionais: Algoritmo de mudas, semeadura e crescimento (SSG)
O algoritmo de “mudas, semeadura e crescimento” (Saplings Sowing and Growing up, SSG) é inspirado em um dos organismos mais resistentes do planeta, um exemplo notável de sobrevivência em inúmeras condições.
Indicadores baseados na classe CCanvas: Preenchendo canais com transparência Indicadores baseados na classe CCanvas: Preenchendo canais com transparência
Neste artigo, abordaremos os métodos de criação de indicadores personalizados que são desenhados usando a classe CCanvas da Biblioteca Padrão no MetaTrader 5. Também discutiremos as propriedades dos gráficos para a transformação de coordenadas. Daremos especial atenção aos indicadores que preenchem a área entre duas linhas usando transparência.
Ciência de Dados e Aprendizado de Máquina (Parte 13): Analisando o mercado financeiro usando a análise de componentes principais (PCA) Ciência de Dados e Aprendizado de Máquina (Parte 13): Analisando o mercado financeiro usando a análise de componentes principais (PCA)
Vamos tentar melhorar qualitativamente nossa análise dos mercados financeiros usando a análise de componentes principais (PCA). Aprenderemos como essa técnica pode ajudar a identificar padrões ocultos nos dados, identificar tendências de mercado ocultas e otimizar estratégias de investimento. Neste artigo, veremos como o PCA oferece uma nova perspectiva para a análise de dados financeiros complexos, ajudando-nos a ver informações que não percebemos usando abordagens tradicionais. Veremos se sua aplicação aos dados do mercado financeiro proporciona uma vantagem sobre a concorrência e nos ajuda a ficar um passo à frente.