Como chamar indicadores no MQL5

Introdução

No MQL5 existem diversas formar para chamar indicadores e a maioria destas formas é realizada usando as funções IndicatorCreate() e iCustom(). Além disso, estas funções apenas retornam o handle indicador e o trabalho adicional nos indicadores é feito por ele. Então o que é handle? Como lidar com as funções IndicatorCreate() e iCustom()? E como seu expert irá obter os dados do indicador? Todas estas questões são cobertas no artigo.

Criação de um arquivo fonte

Para começar com nosso expert, vamos criar seu arquivo fonte. Faremos isso com frequência no MetaEditor chamando o Assistente MQL5 a partir do menu File (Arquivo) -> New (Novo). Na primeira etapa selecione o Expert Advisor e pressione Next (Próximo).

Na segunda etapa somos solicitados a inserir o nome, os detalhes de contato do autor e os parâmetros de entrada para o Expert Advisor. Insira apenas o Nome do advisor (campo obrigatório) e o Autor. Você pode adicionar parâmetros de entrada depois diretamente no código do programa, se necessário.

Depois de clicar em Finish (Terminar) o Assistente criará o seguinte código-fonte:

//+------------------------------------------------------------------+
//|                                                   SampleMQL5.mq5 |
//|                                             Copyright KlimMalgin |
//|                                                                  |
//+------------------------------------------------------------------+
#property copyright "KlimMalgin"
#property link      ""
#property version   "1.00"
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---
   
//---
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---
   
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//---
   
  }
//+------------------------------------------------------------------+

Estrutura do arquivo fonte

Vamos examinar brevemente a estrutura do arquivo fonte de um expert e ir adiante.

O código do programa começa com um cabeçalho. É um comentário, contendo o nome do arquivo e autor. Após o título vem as Propriedades do programa (#property) de um expert. Aqui a versão do programa é automaticamente indicada, assim como o nome do autor e o link para sua página, se você os inseriu. Após descrever as propriedades, os parâmetros de entrada são especificados (não os especificamos ainda) e depois as variáveis globais são declaradas.

Quero observar que as propriedades devem ser definidas no aquivo mql5 principal. Todas as propriedades dos arquivos inclusos serão ignoradas!

A seguir vem três funções que processam eventos:

• OnInit() - Roda uma vez que o expert inicia, na mudança de caractere ou uma troca de período em que o expert é definido;
• OnDeinit(const int reason (consta o motivo int)) - Também roda uma vez, quando o expert finaliza seu trabalho ou quando a reinicialização é realizada. O parâmetro reason (motivo) contém o código do motivo da não inicialização;
• OnTick() - Começa sempre quando você recebe um novo tick no gráfico onde o expert é anexado.

Indicadores de conexões

No MQL5, os métodos de trabalho com indicadores mudou! No MQL4, para obter o valor do indicador em uma barra em particular, o índice desta barra passou para a função iCustom() como parâmetro. Agora não conseguimos o valor do buffer do indicador, mas seu handle. E usando este handle, podemos obter os valores do indicador em um determinado intervalo usando uma função especial chamada CopyBuffer(). Então, o que é um handle?

Handle é um identificador exclusivo, criado para usar com um determinado indicador. É representado como um número inteiro e é armazenado no tipo int da variável. Existem 2 formas de obter o handle do indicador no MQL5:\

• Chamando a função IndicatorCreate() que retornará o handle do indicador no caso de sucesso, e -1 em caso de falha;
• Chamando uma das funções technical indicators (indicadores técnicos). O resultado da sua execução é similar.
  

Ambos métodos são igualmente válidos e você decide qual deles usar. Vamos considerar ambos modos nos detalhes.

Obtendo o handle do indicador usando a função IndicatorCreate()

Então, como resultado da execução bem sucedida da função IndicatorCreate() teremos o handle do indicador e, no caso de falha, a função retornará o valor igual a -1 INVALID_HANDLE (HANDLE INVÁLIDO. Se o indicador chamado possui parâmetros, então antes de chamar a função devemos preencher um array de parâmetros do tipo MqlParam. Cada elemento deste array é representado como uma estrutura do tipo MqlParam, contendo 4 campos. O primeiro campo desta estrutura indica qual dos três campos restantes são usados como parâmetro para o indicador.

Vamos escrever o código que criará handles de indicadores SAR Parabólicos e Média móvel. Começaremos com a declaração das variáveis globais que armazenarão os handles e declararão um array do tipo MqlParam para definir parâmetros para os indicadores:

int MA1 = 0,            // Declaring variable to store fast MA handle
    MA2 = 0,            // Declaring variable to store slow MA handle
    SAR = 0;            // Declaring variable to store SAR handle
    
MqlParam params[];      // Array for storing indicators parameters

Este código deve ser posicionado imediatamente após a definição das propriedades do expert.

Agora, quando as variáveis estão declaradas, você pode preencher o array de parâmetros e chamar a função IndicatorCreate(). É melhor fazer isso na função OnInit(), já que o indicador será criado uma vez no início do programa e não em cada tick!

Vamos preencher o array de parâmetros e chamar o primeiro indicador:

int OnInit()
{
//---
   // Setting the params size equal to number of called indicator parameters
   ArrayResize(params,4);

   // Setting the period of fast MA
   params[0].type         =TYPE_INT;
   params[0].integer_value=5;
   // Offset
   params[1].type         =TYPE_INT;
   params[1].integer_value=0;
   // Calculation method: simple averaging
   params[2].type         =TYPE_INT;
   params[2].integer_value=MODE_SMA;
   // Price type for calculation: the Close prices
   params[3].type         =TYPE_INT;
   params[3].integer_value=PRICE_CLOSE;
   
   MA1 = IndicatorCreate(Symbol(), // Symbol used to calculate the indicator
                         0,        // Timeframe. 0 means current
                         IND_MA,   // Indicator type from the ENUM_INDICATOR enumeration
                         4,        // Number of parameters passed in the params array
                         params    // Parameters array
                         );   
//---
return(0);
}

Como o array params foi declarado como um array dinâmico, por ex., tamanho do array não foi definido entre colchetes, então antes de usá-lo é preciso definir seu tamanho. Usando a função ArrayResize() definiremos o tamanho igual para o número de parâmetros que transferiremos no array. Para a média móvel são necessários quatro parâmetros.

O primeiro parâmetro é o período MA. É definido como um número inteiro. Consequentemente, para o campo tipo do primeiro parâmetro definiremos o valor TYPE_INT, com isso nossa função IndicatorCreate() "entenderá" que o valor deve ser retirado do campo integer_value. Uma vez que todos os parâmetros para a média móvel tenham o tipo int, eles serão definidos de acordo.

Uma vez que o array estiver preenchido, você pode chamar a função IndicatorCreate(). Sua saída será armazenada na variável MA1. Não deve haver dificuldades em chamar a função e apenas cinco parâmetros devem ser transferidos para ela:

• Primeiro, o nome da ferramenta de trabalho. A função Symbol() retornará o nome da ferramenta atual na qual o expert está rodando;
• O segundo parâmetro especifica o quadro de tempo, no qual os valores do indicador são contados;
  
• O terceiro parâmetro especifica o tipo de indicador, que será chamado;
  
• O quarto parâmetro especifica o número de parâmetros a serem passados no array Params;
• E, finalmente, o quinto parâmetro é o array de parâmetros de entrada do indicador.

É isso! Temos o handle MA rápido e temos que ter o MA lento e handles dos indicadores SAR. Como resultado, a função OnInit() parecerá dessa forma:

int OnInit()
  {
//---

   // Setting the params size equal to number of called indicator's parameters
   ArrayResize(params,4);

//*    Calling indicators   *
//***************************
   // Setting the period of fast MA
   params[0].type         =TYPE_INT;
   params[0].integer_value=5;
   // Offset
   params[1].type         =TYPE_INT;
   params[1].integer_value=0;
   // Calculation method: simple averaging
   params[2].type         =TYPE_INT;
   params[2].integer_value=MODE_SMA;
   // Price type for calculation: the Close prices
   params[3].type         =TYPE_INT;
   params[3].integer_value=PRICE_CLOSE;
   
   MA1 = IndicatorCreate(Symbol(), 0, IND_MA, 4, params);
   
   // Setting the period of slow MA
   params[0].type         =TYPE_INT;
   params[0].integer_value=21;
   // Offset   
   params[1].type         =TYPE_INT;
   params[1].integer_value=0;
   // Calculation method: simple averaging
   params[2].type         =TYPE_INT;
   params[2].integer_value=MODE_SMA;
   // Price type for calculation: the Close prices
   params[3].type         =TYPE_INT;
   params[3].integer_value=PRICE_CLOSE;
   
   MA2 = IndicatorCreate(Symbol(), 0, IND_MA, 4, params);
   
   
   // Changing array size to store the SAR indicator parameters
   ArrayResize(params,2);
   // Step
   params[0].type         =TYPE_DOUBLE;
   params[0].double_value = 0.02;
   // Maximum
   params[1].type         =TYPE_DOUBLE;
   params[1].double_value = 0.2;
   
   SAR = IndicatorCreate(Symbol(), 0, IND_SAR, 2, params);
   
//---
   return(0);
  }

Para obter o handle MA lento você pode apenas mudar o período de 5 para 21. E quando o SAR Parabólico é chamado, os números de ponto flutuante (duplos) são transferidos como seus parâmetros. Ao preencher o array você deve levar isso em conta e colocar TYPE_DOUBLE no campo de tipo, e o parâmetro em si para o campo double_value, respectivamente. Além disso, o SAR requer apenas dois parâmetros, então o tamanho do array vai mudando para 2 usando a função ArrayResize().

Por hora a indicação IndicatorCreate() termina. Na minha opinião, este método de chamar indicadores é mais conveniente na abordagem de objeto orientado quando a biblioteca de classes é criada para trabalhar com indicadores. Esta biblioteca tornará projetos de grande escala mais fáceis de processar. E para escrever e testar experts rapidamente é melhor usar o seguinte método.

Obtendo o handle usando funções de indicadores técnicos

O segundo método que permite que você obtenha o handle indicador é chamar as funções indicadores técnicos. Cada uma destas funções são destinadas a obter o handle de um dos indicadores padrão enviados com o MetaTrader 5. Todas elas têm um determinado conjunto de parâmetros, dependendo do indicador que são destinadas. Por exemplo, para o indicador CCI a função iCCI() é chamada e parece da seguinte forma:

   CCI = iCCI(
              Symbol(),            // symbol name
              PERIOD_CURRENT,      // period
              20,                  // averaging period
              PRICE_CLOSE          // price type or handle
              );

Outro handle de indicador pode ser enviado como o último parâmetro na função de indicadores técnicos em vez do tipo do preço. Então, o indicador, chamado desta forma, será calculado usando não os dados de preço, mas os dados de outro indicador.

A função iCustom() causa interesse em particular entre outras funções de indicadores técnicos, porque pode chamar quaisquer indicadores, incluindo os personalizados. Vamos escrever o código similar ao de cima, mas usando a função iCustom().

int OnInit()
  {
//---

   MA1 = iCustom(NULL,0,"Custom Moving Average",
                          5,          // Period
                          0,          // Offset
                          MODE_SMA,   // Calculation method
                          PRICE_CLOSE // Calculating on Close prices
                 );

   MA2 = iCustom(NULL,0,"Custom Moving Average",
                          21,         // Period
                          0,          // Offset
                          MODE_SMA,   // Calculation method
                          PRICE_CLOSE // Calculating on Close prices
                 );

   SAR = iCustom(NULL,0,"ParabolicSAR",
                          0.02,        // Step
                          0.2          // Maximum
                 );

//---
   return(0);
  }

Tenha em mente que é melhor obter o handle uma vez durante o início do expert, então vamos fazer a chamada na função OnInit().

A função iCustom contém os seguintes parâmetros:

1. Nome da ferramenta de trabalho, no qual os dados são usados para calcular o indicador. NULL - significa a ferramenta atual. Você pode usar a função Symbol() em vez de NULL, não tem muita diferença. No caso de Symbol(), o nome de um instrumento é transferido para iCustom(), mas no caso de NULL, iCustom() encontra o instrumento financeiro sozinho.
2. Período de gráfico. Para especificar o período você pode usar quadros de tempo de gráfico predefinidos, assim como 0 - para se referir ao quadro de tempo atual.
3. Nome do indicador. O indicador chamado deve ser compilado e deve estar na pasta "MQL5\Indicators\" ou em qualquer uma de suas subpastas.
4. Parâmetros restantes. Estes valores serão usados como parâmetros de entrada para o indicador chamado, então o tipo deles e a sequência devem estar de acordo um com o outro. Se não forem especificados, então os valores padrão serão usados.

Como dito anteriormente - este método é mais conveniente para usar com indicadores se você não tiver uma biblioteca que tenha usado para trabalhar. Agora, quando os handles são recebidos, você pode começar a trabalhar com valores dos indicadores!

Obtendo os dados do indicador

O mais legal de trabalhar com dados do indicador no MQL5 é que agora temos a oportunidade de obter dados apenas em um determinado intervalo que precisamos. Você pode definir o intervalo de diferentes formas:

• Obtendo o número específico de barras relativo a barra selecionada;
• Obtendo o número específico de barras relativo a data selecionada;
• Obtendo dados do indicador em um determinado intervalo, por ex., especificando as datas de início e fim.

Para ler a data do indicador, a função CopyBuffer() é utilizada. Qual método de obtenção de dados será usado depende dos parâmetros de entrada que serão transferidos para esta função.

Vamos escrever o código que copia os dados do indicador (obtivemos seus handles anteriormente) nos arrays:

void OnTick()
  {
//---

// Dynamic arrays to store indicators values
double _ma1[],
       _ma2[],
       _sar[];

// Setting the indexing in arrays the same as in timeseries, i.e. array element with zero
// index will store the values of the last bar, with 1th index - the last but one, etc.
   ArraySetAsSeries(_ma1, true);
   ArraySetAsSeries(_ma2, true);
   ArraySetAsSeries(_sar, true);

// Using indicators handles, let's copy the values of indicator
// buffers to arrays, specially prepared for this purpose
   if (CopyBuffer(MA1,0,0,20,_ma1) < 0){Print("CopyBufferMA1 error =",GetLastError());}
   if (CopyBuffer(MA2,0,0,20,_ma2) < 0){Print("CopyBufferMA2 error =",GetLastError());}
   if (CopyBuffer(SAR,0,0,20,_sar) < 0){Print("CopyBufferSAR error =",GetLastError());}


//---
  }

Agora todo nosso trabalho focará na função OnTick(), porque em cada tick os dados dos indicadores estão mudando e devem ser atualizados.

Primeiro, vamos declarar arrays dinâmicos para cada buffer de indicador. Na minha opinião, é mais conveniente trabalhar com dados de indicador, se a indexação do array será a mesma que as séries de tempo, por ex., no elemento de array 0 haverá dados da última barra, no elemento número 1 - o último mas único, etc. O método de indexação é definido usando a função ArraySetAsSeries().

Uma vez que o método de indexação é definido, podemos começar a preencher os arrays. Para calcular cada indicador chamaremos a função CopyBuffer() com o seguinte conjunto de parâmetros.

1. Handle do indicador, no qual os dados você quer obter.
2. Númerodo buffer do indicador. Como os indicadores MA e SAR têm um buffer, então o definiremos como 0. Se houver mais de um buffer, então o segundo será o número 1 e o terceiro o número 2, etc.
3. Barra inicial, a partir de onde a contagem começa.
4. O número de barras que quer copiar.
5. O array{/0} no qual os dados são copiados.

Na chamada bem sucedida, a função CopyBuffer() retornará o número de elementos copiados, em caso de falha, retornará -1. Em caso de falha, o erro deve ser rastreado, então se o valor retornado for menor que 0 - tentaremos escrever o erro no log de experts usando a função Print().

Conclusão

Por hora nosso trabalho com indicadores está longe do fim. Este artigo cobre apenas os métodos básicos de acesso de seus dados. E por motivo de conveniência é melhor usar a abordagem orientada a objeto, que é implementada no MQL5 em um nível muito satisfatório!