MetaTrader 5 / Negociação
English Русский 中文 Español Deutsch 日本語 한국어 Français Italiano Türkçe
preview
Como desenvolver um sistema de negociação baseado no indicador Oscilador Acelerador

Como desenvolver um sistema de negociação baseado no indicador Oscilador Acelerador

MetaTrader 5 — Negociação | 18 janeiro 2023, 09:24
225 0
Mohamed Abdelmaaboud
Mohamed Abdelmaaboud

Introdução

Aqui está um novo artigo de nossa série sobre como desenvolver um sistema de negociação com base nos indicadores técnicos mais populares. Vamos aprender neste artigo uma nova ferramenta técnica que pode ser usada a nosso favor na negociação. Nós aprenderemos sobre o indicador Oscilador Acelerador (AC) em detalhes à medida que aprendemos o que ele é, o que ele mede, como ele pode ser calculado, como lê-lo e usá-lo por meio das estratégias simples de negociação e, em seguida, como nós podemos criar um sistema de negociação com base nelas.

Os seguintes tópicos serão o nosso caminho para aprender mais sobre este indicador:

  1. Definição do Oscilador Acelerador
  2. Estratégia do Oscilador Acelerador
  3. Esquema da estratégia do Oscilador Acelerador
  4. Sistema de negociação do Oscilador Acelerador
  5. Conclusão

Nós usaremos a MQL5 (MetaQuotes Language 5) para escrever os nossos códigos por ele, que está embutido na plataforma de negociação MetaTrader 5, que será usada para executar o nosso sistema de negociação. Se você não sabe como baixar a MetaTrader 5 e como usar a MQL5, você pode ler o tópico Escrevendo códigos em MQL5 no MetaEditor de um artigo anterior para saber mais sobre isso. Todas as estratégias mencionadas aqui são desenvolvidas apenas para fins educacionais e você deve testá-las antes de usá-las em sua conta real para garantir que elas sejam lucrativas e adequadas para você. Eu aconselho você a aplicar o que você aprendeu caso deseje melhorar as suas habilidades de negociação e codificação, pois esta etapa é uma etapa importante, pois ela será útil para obter todos os benefícios deste artigo.

Ressalva: Qualquer informação fornecida aqui é apenas para fins educacionais e sem fins comerciais ou de aconselhamento. As informações não garantem nenhum tipo de resultado. Se você optar por usar esses materiais em qualquer uma de suas contas de negociação, você fará isso por sua conta e risco, sendo o único responsável.


Definição do Oscilador Acelerador

O Oscilador Acelerador (AC) é um indicador de momentum desenvolvido por Bill Williams. Ele mede se há uma mudança no momentum. Se o momentum de uma tendência de alta diminuir, isso pode significar que há menos interesse em comprar o instrumento e, nesse caso, nós podemos ver um movimento diferente na direção oposta da venda e vice-versa, se o momentum de uma tendência de baixa diminuir, isso pode significar que há menos interesse em vender o instrumento e podemos ver um aumento no poder de compra. Ele é um indicador importante também, pois ele pode se mover antes do preço.

Portanto, o principal objetivo deste indicador é medir a aceleração e desaceleração do poder de mercado em ambas as direções, para cima ou para baixo, para obter insights sobre quanto tempo o movimento atual do preço continuará e estará pronto para qualquer mudança.

Agora, vamos aprender como nós podemos calcular este indicador manualmente através dos seguintes passos:

AC = AO - SMA (AO, 5)

Onde:

Ac = Oscilador Acelerador.

AO = Oscilador Acelerador, a propósito, você pode ler meu artigo anterior sobre o Awesome Oscillator para saber mais sobre isso.

SMA = Média Móvel Simples.

5 = o período de SMA.

Para calcular o AO siga os seguintes passos:

MEDIAN PRICE = (HIGH + LOW) / 2 

AO = SMA (MEDIAN PRICE, 5) - SMA (MEDIAN PRICE, 34)

Felizmente, não precisamos calcular esse indicador manualmente, já que nós temos na plataforma de negociação MetaTrader 5, e tudo o que precisamos fazer é escolhê-lo entre os indicadores disponíveis. Ao abrir a plataforma de negociação, nós pressionaremos Inserir --> Indicadores --> Bill Williams --> Oscilador Acelerador

Inserção do AC

Em seguida, nós encontraremos a janela dos parâmetros do indicador para definir as nossas preferências da seguinte forma:

Parâmetro do AC

1- para determinar a cor dos valores de alta.

2- para determinar a espessura do histograma.

3- para determinar a cor dos valores de baixa.

Após determinar os parâmetros anteriores de acordo com nossas preferências e pressionar "OK", nós encontraremos o indicador inserido no gráfico da mesma forma que a seguir:

AC anexado

Como nós podemos ver no gráfico anterior, nós temos o indicador inserido na parte inferior do gráfico e temos os valores do AC oscilando em torno de zero com base na aceleração do momento.

O nível zero significa que há um equilíbrio entre os touros e os ursos das duas partes do mercado. Se o AC for maior que o nível zero, significa que nós podemos encontrar uma continuação do movimento ascendente e vice-versa, se o AC for menor que o nível zero, significa que nós podemos encontrar uma continuação do movimento descendente.


Estratégia do Oscilador Acelerador

Neste tópico, nós aprenderemos as estratégias de negociação simples para serem usadas com base no conceito básico do indicador AC, mas você deve testá-las antes de usá-las em sua conta real, pois o principal objetivo aqui é apenas educacional. Portanto, você deve garantir que ele seja adequado e lucrativo para a sua negociação.

  • Estratégia um: Cruzamento do AC Zero:

Com base nessa estratégia, precisamos usar o AC para saber quando há um sinal de alta ou baixa, comparando os dois valores para determinar as suas posições, o valor AC atual e o nível zero do indicador AC. Se o valor AC atual for maior que o nível zero, será um sinal de alta. No outro cenário, se o valor AC atual for menor que o nível zero, será um sinal de baixa.

Simplesmente,

AC > nível zero --> Alta

AC < nível zero --> Baixa

  • Estratégia dois: Força do AC:

Com base nessa estratégia, nós precisamos obter os sinais com a força do movimento AC com base na comparação do valor do AC atual com os valores máximos e mínimos do AC dos últimos dez valores do AC para determinar a posição de cada valor para obter o sinal adequado. Se o valor do AC atual for maior que o valor do AC máximo, será um sinal de força. No outro cenário, se o valor do AC atual for menor que o valor do AC mínimo, será um sinal de fraqueza.

Simplesmente,

AC > Valor máximo do AC --> AC é forte

AC < Valor mínimo do AC --> AC é fraco

  • Estratégia três: Estratégia do AC & MA:

Com base nessa estratégia, precisamos obter sinais de compra ou venda dependendo da verificação dos cinco valores e eles são o preço de fechamento, a média móvel exponencial de 50 períodos, o AC atual, o valor do AC máximo e mínimo dos últimos dez valores para determinar a posição deles para obter o sinal adequado. Se o AC atual for maior que o valor máximo do AC e o preço de fechamento for maior que a EMA de 50 períodos, será um sinal de compra. No outro cenário, se o AC atual for menor que o valor mínimo do AC e o preço de fechamento for menor que a MME de 50 períodos, será um sinal de venda.

Simplesmente,

AC > Valor máximo do AC e Fechamento > 50 - EMA --> Compra

AC < Valor mínimo do AC e Fechamento < 50 - EMA --> Venda 

Esquema da estratégia do Oscilador Acelerador

Neste tópico, nós vamos desenvolver um esquema passo a passo para cada estratégia mencionada para nos ajudar a criar um sistema de negociação sem problemas.

  • Estratégia um: Cruzamento do AC Zero:

De acordo com esta estratégia, nós precisamos criar um sistema de negociação que possa ser usado para gerar automaticamente os sinais de alta ou baixa como um comentário no gráfico com base na verificação contínua do valor do AC atual e do nível zero do indicador do AC para determinar a posição deles e retornar o sinal adequado. Se o valor do AC atual for maior que o nível zero, nós precisamos que o sistema de negociação retorne um comentário no gráfico com os seguintes valores:

  • Altista
  • Valor do AC

No outro caso, se o valor do AC for menor que o nível zero, nós precisamos que o sistema de negociação retorne um comentário no gráfico com os seguintes valores:

  • Baixista
  • Valor do AC

A seguir está o esquema deste sistema de negociação:

Esquema do Cruzamento do AC Zero

  • Estratégia dois: Força do AC:

De acordo com esta estratégia, nós precisamos criar um sistema de negociação que possa ser usado para gerar um sinal com a força do movimento do AC, se for forte ou fraco, com base na verificação contínua de três valores. Eles são o valor do AC atual, a máxima e mínima dos últimos dez valores do indicador do AC. Se o valor do AC atual for maior que o valor máximo, precisamos que o sistema de negociação retorne um comentário no gráfico com os seguintes valores:

  • AC é forte
  • Valor do AC
  • Valor máximo do AC
  • Valor mínimo do AC

No outro caso, se o valor do AC atual for menor que o valor mínimo, nós precisamos que o sistema de negociação retorne um comentário no gráfico com os seguintes valores:

  • AC é fraco
  • Valor do AC
  • Valor máximo do AC
  • Valor mínimo do AC

A seguir está o esquema deste sistema de negociação:

Esquema da força do AC

  • Estratégia três: Estratégia do AC & MA:

De acordo com esta estratégia, nós precisamos criar um sistema de negociação que possa ser usado para gerar os sinais de compra e venda como um comentário no gráfico com base na verificação contínua dos cinco valores a seguir: O AC atual, o AC máximo e mínimo, o preço de fechamento e o valor da média móvel para determinar a posição deles para gerar o sinal adequado. Se o AC atual for maior que o valor do AC máximo e o preço de fechamento for maior que a média móvel, nós precisamos que o sistema de negociação gere um comentário no gráfico como um sinal com os seguintes valores:

  • Compra
  • Preço de fechamento
  • Valor do AC
  • AC Máx.
  • AC Min
  • Valor da MA

No outro caso, se o AC atual for menor que o valor mínimo de AC e o preço de fechamento for menor que a média móvel, nós precisamos que o sistema de negociação retorne um comentário no gráfico com os seguintes valores:

  • Venda
  • Preço de fechamento
  • Valor do AC
  • AC Máx.
  • AC Min
  • Valor da MA

A seguir está o esquema deste sistema de negociação:

Esquema da Estratégia AC _ MA

Sistema de negociação do Oscilador Acelerador

Neste tópico interessante, nós vamos criar o nosso sistema de negociação com base nas estratégias mencionadas, mas criaremos uma base para elas criando um sistema de negociação simples que será capaz de retornar um comentário no gráfico com o valor do AC atual e a seguir estão as etapas para fazer isso:

Criar um array para o acArray usando a função "double":

double acArray[];

Usar a função "ArraySetAsSeries" para o acArray retornar true ou false como um valor booleano. Seus parâmetros são:

  • array[]: usaremos o acArray.
  • flag: Usaremos "true" como uma direção de indexação do array.
ArraySetAsSeries(acArray,true);

Definir o indicador AC usando a função "iAC" para retornar o manipulador do indicador Accelerator Oscillator. Seus parâmetros são:

  • symbol: usaremos o (_Symbol) a ser aplicado ao símbolo atual.
  • period: usaremos o (_period) para ser aplicado ao período atual.
int acDef = iAC(_Symbol,_Period);

Obter os dados do buffer do indicador AC usando a função "CopyBuffer". Seus parâmetros são: 

  • indicador_handle: usaremos o (acDef) do manipulador do indicador AC predefinido.
  • buffer_num: para determinar o número do buffer do indicador, usaremos (0).
  • start_pos: para determinar a posição inicial, usaremos (0).
  • count: para determinar a quantidade a copiar, usaremos (3).
  • buffer[]: para determinar o array de destino a ser copiado, nós usaremos (acArray).
CopyBuffer(acDef,0,0,3,acArray);

Definir o valor do AC após criar uma variável do tipo double para o acVal e normalizá-lo usando o "NormalizeDouble". Os parâmetros do "NormalizeDouble" são:

  • value: Número normalizado. Usaremos (acArray[0]).
  • digits: para determinar o número de dígitos após a casa decimal. Usaremos (7).
double acVal = NormalizeDouble(acArray[0],7);

Retorna o comentário do valor do AC atual no gráfico usando a função "Comment".

Comment("AC Value is ",acVal);

A seguir está o código completo do sistema de negociação anterior:

//+------------------------------------------------------------------+
//|                                                    Simple AC.mq5 |
//|                                  Copyright 2022, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2022, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
//+------------------------------------------------------------------+
  void OnTick()
  {
   double acArray[];
   ArraySetAsSeries(acArray,true);
   int acDef = iAC(_Symbol,_Period);
   CopyBuffer(acDef,0,0,3,acArray);
   double acVal = NormalizeDouble(acArray[0],7);
   Comment("AC Value is ",acVal);
  }
//+------------------------------------------------------------------+

Depois de compilar este código, vamos encontrá-lo no navegador na pasta Expert Advisors igual a seguir:

Simple AC nav

Para executar este arquivo, vamos arrastá-lo e soltá-lo no gráfico desejado, então encontraremos a janela do mesmo igual a seguinte:

Janela Simple AC

Simple AC anexado

Como nós podemos ver na foto anterior no canto superior direito, temos o expert anexado ao gráfico. Agora, nós estamos prontos para receber o nosso sinal e ele será igual ao seguinte:

Simple AC signal

Como podemos ver no canto superior esquerdo, temos um comentário sobre o valor do AC atual.

  • Estratégia um: Cruzamento do AC Zero:

A seguir, o código completo para criar o sistema de negociação desta estratégia:

//+------------------------------------------------------------------+
//|                                            AC Zero Crossover.mq5 |
//|                                  Copyright 2022, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2022, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
//+------------------------------------------------------------------+
  void OnTick()
  {
   double acArray[];
   ArraySetAsSeries(acArray,true);
   int acDef = iAC(_Symbol,_Period);
   CopyBuffer(acDef,0,0,3,acArray);
   double acVal = NormalizeDouble(acArray[0],7);
   if(acVal > 0)
     {
      Comment("Bullish","\n"
              "AC Value is ",acVal);
     }
   if(acVal < 0)
     {
      Comment("Bearish","\n"
              "AC Value is ",acVal);
     }
  }
//+------------------------------------------------------------------+

Diferenças neste código:

Condições da estratégia.

Em caso de sinal de alta:

   if(acVal > 0)
     {
      Comment("Bullish","\n"
              "AC Value is ",acVal);
     }

Em caso de sinal de baixa

   if(acVal < 0)
     {
      Comment("Bearish","\n"
              "AC Value is ",acVal);
     }

Depois de compilar este código, certificando-se de que não há erros e executando-o arrastando e soltando no gráfico da mesma forma que aprendemos antes, encontraremos anexado ao gráfico o seguinte:

AC Zero Crossover anexado

No canto superior direito, nós podemos ver o expert desta estratégia anexado ao gráfico. Estamos prontos agora para receber os nossos sinais.

No caso de um sinal de alta:

Cruzamento do AC Zero - sinal de alta

Podemos ver no canto superior esquerdo que temos o comentário como sinal desta estratégia com os seguintes valores:

  • Altista
  • Valor do AC

No caso de um sinal de baixa:

Cruzamento do AC Zero - sinal de baixa

Nós podemos ver no canto superior esquerdo que temos os seguintes valores:

  • Baixista
  • Valor do AC
  • Estratégia dois: Força do AC:

A seguir, o código completo para criar o sistema de negociação desta estratégia:

//+------------------------------------------------------------------+
//|                                                  AC Strength.mq5 |
//|                                  Copyright 2022, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2022, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
//+------------------------------------------------------------------+
void OnTick()
  {
   double acArray[];
   ArraySetAsSeries(acArray,true);
   int acDef = iAC(_Symbol,_Period);
   CopyBuffer(acDef,0,0,11,acArray);
   double acCurrVal = NormalizeDouble(acArray[0],7);
   int acMaxArray = ArrayMaximum(acArray,1,WHOLE_ARRAY);
   int acMinArray = ArrayMinimum(acArray,1,WHOLE_ARRAY);
   double acMaxVal = NormalizeDouble(acArray[acMaxArray],7);
   double acMinVal = NormalizeDouble(acArray[acMinArray],7);
   if(acCurrVal>acMaxVal)
     {
      Comment("AC is strong ","\n",
              "AC Value is ",acCurrVal,"\n",
              "AC Max is ",acMaxVal,"\n",
              "AC Min is ",acMinVal);
     }
   if(acCurrVal<acMinVal)
     {
      Comment("AC is weak ","\n",
              "AC Value is ",acCurrVal,"\n",
              "AC Max is ",acMaxVal,"\n",
              "AC Min is ",acMinVal);
     }
  }
//+------------------------------------------------------------------+

Diferenças neste código.

Definindo o valor atual de AC:

double acCurrVal = NormalizeDouble(acArray[0],7);

Definindo o valor máximo em todo o array de AC usando a função "ArrayMaximum" para retornar o valor máximo. Seus parâmetros:

  • array[]: usaremos o acArray.
  • start: o ponto de partida para verificação. Usaremos (1).
  • count: total de elementos do array para verificação. Usaremos (WHOLE_ARRAY) para verificar todo esse array.
int acMaxArray = ArrayMaximum(acArray,1,WHOLE_ARRAY);

Definindo o valor mínimo em todo o array de AC usando a função "ArrayMinimum" para retornar o valor mínimo. Seus parâmetros:

  • array[]: usaremos (acArray).
  • start: o ponto de partida para verificação. Usaremos (1).
  • count: total de elementos do array para verificação. Usaremos (WHOLE_ARRAY) para verificar todo esse array.
int acMinArray = ArrayMinimum(acArray,1,WHOLE_ARRAY);

Normalizando os valores da máxima e mínima usando a função "NormalizeDouble".

   double acMaxVal = NormalizeDouble(acArray[acMaxArray],7);
   double acMinVal = NormalizeDouble(acArray[acMinArray],7);

Condições da estratégia:

Em caso de sinal forte,

   if(acCurrVal>acMaxVal)
     {
      Comment("AC is strong ","\n",
              "AC Value is ",acCurrVal,"\n",
              "AC Max is ",acMaxVal,"\n",
              "AC Min is ",acMinVal);
     }

Em caso de sinal fraco,

   if(acCurrVal<acMinVal)
     {
      Comment("AC is weak ","\n",
              "AC Value is ",acCurrVal,"\n",
              "AC Max is ",acMaxVal,"\n",
              "AC Min is ",acMinVal);
     }

Após compilar e executar este código no gráfico desejado, o encontraremos anexado igual ao seguinte:

AC strength anexado

Como podemos ver, o expert está anexado no canto superior direito do gráfico, estamos prontos para receber os sinais dessa estratégia da mesma forma que os seguintes exemplos de teste.

Em caso de sinal forte:

Força do AC - sinal forte

Como podemos ver no gráfico no canto superior esquerdo, nós recebemos nosso sinal com os seguintes valores:

  • AC é forte
  • Valor do AC
  • Valor máximo do AC
  • Valor mínimo do AC

Em caso de fraqueza:

Força do AC - sinal fraco

Podemos obter o sinal com os seguintes valores:

  • AC é fraco
  • Valor do AC
  • Valor máximo do AC
  • Valor mínimo do AC
  • Estratégia três: Estratégia do AC & MA:

A seguir, o código completo para criar o sistema de negociação desta estratégia:

//+------------------------------------------------------------------+
//|                                                  AC Strength.mq5 |
//|                                  Copyright 2022, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2022, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
//+------------------------------------------------------------------+
void OnTick()
  {
   double acArray[];
   ArraySetAsSeries(acArray,true);
   int acDef = iAC(_Symbol,_Period);
   CopyBuffer(acDef,0,0,11,acArray);
   double acCurrVal = NormalizeDouble(acArray[0],7);
   int acMaxArray = ArrayMaximum(acArray,1,WHOLE_ARRAY);
   int acMinArray = ArrayMinimum(acArray,1,WHOLE_ARRAY);
   double acMaxVal = NormalizeDouble(acArray[acMaxArray],7);
   double acMinVal = NormalizeDouble(acArray[acMinArray],7);
   if(acCurrVal>acMaxVal)
     {
      Comment("AC is strong ","\n",
              "AC Value is ",acCurrVal,"\n",
              "AC Max is ",acMaxVal,"\n",
              "AC Min is ",acMinVal);
     }
   if(acCurrVal<acMinVal)
     {
      Comment("AC is weak ","\n",
              "AC Value is ",acCurrVal,"\n",
              "AC Max is ",acMaxVal,"\n",
              "AC Min is ",acMinVal);
     }
  }
//+------------------------------------------------------------------+

Diferenças neste código:

Criação dos arrays de pArray, acArray e maArray. Usaremos a função do tipo double para acArray e maArray, mas usaremos a função MqlRates para pArray para armazenar as informações sobre o preço, volume e spread.

   MqlRates pArray[];
   double acArray[];
   double maArray[];

Definir a flag AS_SERIES para os arrays de (acArray) e (maArray) como mencionamos antes e definir Data usando a função "CopyRates" para obter os dados históricos da estrutura MqlRates, seus parâmetros são:

  • symbol_name: usaremos _Symbol para ser aplicado ao símbolo atual.
  • timeframe: usaremos _Period para ser aplicado ao período atual.
  • start_pos: para determinar a posição inicial, usaremos (0). 
  • count: para determinar a contagem de dados a copiar, usaremos (1).
  • rates_array[]: para determinar o array de destino a ser copiado, usaremos o método pArray.
   int Data=CopyRates(_Symbol,_Period,0,1,pArray);
   ArraySetAsSeries(acArray,true);
   ArraySetAsSeries(maArray,true);

Vamos definir o AC, MA:

Para o AC usaremos a função "iCA" da mesma forma que mencionamos. Mas para o MA, vamos usar a função "iMA", seus parâmetros:

  • symbol: vamos usar (_Symbol)
  • period: vamos usar (_period)
  • ma_period: para determinar o período da média móvel, usaremos 50 
  • ma_shift: para determinar o deslocamento horizontal, usaremos (0) 
  • ma_method: para determinar o tipo da média móvel, usaremos MA exponencial 
  • applied_price: para determinar o tipo de preço utilizável, usaremos o preço de fechamento
   int acDef = iAC(_Symbol,_Period);
   int maDef = iMA(_Symbol,_Period,50,0,MODE_EMA,PRICE_CLOSE);

Obteremos os dados do buffer dos indicadores AC e MA usando a função "CopyBuffer".

   CopyBuffer(acDef,0,0,3,acArray);
   CopyBuffer(maDef,0,0,3,maArray);

Obtendo os valores máximos e mínimos do acArray.

   int acMaxArray = ArrayMaximum(acArray,1,WHOLE_ARRAY);
   int acMinArray = ArrayMinimum(acArray,1,WHOLE_ARRAY);

Definindo os valores de AC, AC máximo, AC mínimo e a Média Móvel Exponencial.

   double acVal = NormalizeDouble(acArray[0],7);
   double acMaxVal = NormalizeDouble(acArray[acMaxArray],7);
   double acMinVal = NormalizeDouble(acArray[acMinArray],7);
   double maVal = NormalizeDouble(maArray[0],7);

Condições da estratégia.

No caso de um sinal de compra:

   if(acVal > acMaxVal && closingPrice > maVal)
     {
      Comment("Buy","\n"
              "Closing Price is ",closingPrice,"\n",
              "Ac Value is ",acVal,"\n",
              "AC Max is ",acMaxVal,"\n",
              "AC Min is ",acMinVal,"\n",
              "MA Value is ",maVal);
     }

No caso de um sinal de venda:

   if(acVal < acMinVal && closingPrice < maVal)
     {
      Comment("Sell","\n"
              "Closing Price is ",closingPrice,"\n",
              "Ac Value is ",acVal,"\n",
              "AC Max is ",acMaxVal,"\n",
              "AC Min is ",acMinVal,"\n",
              "MA Value is ",maVal);
     }

Após compilar este código e executá-lo para ser anexado para receber o nosso sinal, ele será anexado igual ao seguinte:

AC _ MA Strategy anexado

Como podemos ver no canto superior direito, o expert está anexado ao gráfico. Agora, podemos receber os nossos sinais.

No caso de um sinal de compra:

Estratégia AC & MA - sinal de compra

Como podemos ver no canto superior esquerdo, temos os seguintes valores:

  • Compra
  • Preço de fechamento
  • Valor do AC
  • AC Máx.
  • AC Min
  • Valor da MA

No caso de um sinal de venda:

Estratégia AC & MA - sinal de venda

Temos o comentário com os seguintes valores:

  • Venda
  • Preço de fechamento
  • Valor do AC
  • AC Máx.
  • AC Min
  • Valor da MA

Conclusão

Depois de tudo o que aprendemos neste artigo, supõe-se que você esteja entendendo bem o indicador Oscilador Acelerador, pois o abordamos neste artigo e aprendemos o que ele é, o que ele mede, como nós podemos calculá-lo, como podemos ler e usá-lo por meio de estratégias de negociação simples, que são as seguintes:

  • Cruzamento do AC Zero: para obter os sinais de alta e baixa com base no cruzamento entre o valor AC e o nível zero do indicador AC.
  • Força do AC: para obter um sinal da força do movimento do AC baseado na comparação entre o valor do AC atual com a máxima e mínima dos últimos dez valores do AC.
  • Estratégia AC & MA: para obter os sinais de compra e venda com base no posicionamento do preço de fechamento, na média móvel exponencial de 50 períodos, no valor atual do AC, no valor máximo do AC e no valor mínimo do AC.

Em seguida, nós projetamos um esquema passo a passo para todas as estratégias mencionadas para nos ajudar a criar o nosso sistema de negociação de maneira fácil, eficaz e sem problemas. Então, chegamos à parte mais interessante do artigo, escrevemos nossos códigos para criar um sistema de negociação baseado nas estratégias mencionadas para serem executadas na MetaTrader 5 e gerarem sinais automáticos sem nenhuma leitura manual ou monitoramento das condições a serem aplicadas.

Espero que você tenha tentado aplicar o que aprendeu da mesma forma que eu disse no início deste artigo e obtido os benefícios completos deste artigo, obtendo mais informações sobre o tópico deste artigo ou qualquer tópico relacionado. É importante confirmar novamente que você deve testar qualquer estratégia antes de usá-la em sua conta real, pois isso pode não ser útil para você, pois não há nada adequado para todas as pessoas. Além disso, o objetivo principal aqui é apenas a educação.

Espero que você tenha achado este artigo útil para sua negociação para obter melhores resultados e se quiser ler mais artigos semelhantes sobre como desenvolver um sistema de negociação com base nos indicadores técnicos mais populares, como RSI, MACD, MA, Stochastic, Bollinger Bands. ..etc. Você pode ler meus artigos anteriores desta série para saber mais sobre isso.

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

Arquivos anexados |
Baixar como ZIP
Simple_AC.mq5 (0.86 KB)
AC_Zero_Crossover.mq5 (1.02 KB)
AC_Strength.mq5 (1.46 KB)
AC_e_MA_Strategy.mq5 (1.98 KB)
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
Algoritmos de otimização populacionais: Enxame de partículas (PSO) Algoritmos de otimização populacionais: Enxame de partículas (PSO)
Neste artigo vamos analisar o popular algoritmo de otimização por enxame de partículas (PSO). Anteriormente, discutimos características importantes de algoritmos de otimização, como convergência, velocidade de convergência, estabilidade, escalabilidade e desenvolvemos uma bancada de testes. Também analisamos um algoritmo simples baseado em geradores de números aleatórios (GNA).
DoEasy. Controles (Parte 22): SplitContainer. Alterando as propriedades do objeto criado DoEasy. Controles (Parte 22): SplitContainer. Alterando as propriedades do objeto criado
Neste artigo, implementamos a alteração das propriedades e da aparência do controle SplitContainer após sua criação.
Algoritmos de otimização populacionais: Otimização de colônia de formigas (ACO) Algoritmos de otimização populacionais: Otimização de colônia de formigas (ACO)
Desta vez, vamos dar uma olhada no algoritmo de otimização de colônia de formigas ("Ant Colony optimization algorithm", em inglês). O algoritmo é muito interessante e ambíguo. Trata-se de uma tentativa de criar um novo tipo de ACO.
DoEasy. Controles (Parte 21): O controle SplitContainer. Separador de painéis DoEasy. Controles (Parte 21): O controle SplitContainer. Separador de painéis
Neste artigo, criaremos uma classe do objeto separador de painéis auxiliar para o controle SplitContainer.