Do básico ao intermediário: Indicadores técnicos (I)

Introdução

No artigo anterior Do básico ao intermediário: Sobrecarga de operadores (VI), foi demonstrado uma forma de se conseguir trabalhar com a sobrecarga de operadores em seu nível mais interessante. Onde no final, precisávamos programar cada vez menos e ao mesmo tempo, que nos era permitido gerar um código que fosse cada vez mais simples de ser compreendido. Pelo menos é assim que eu penso com relação ao resultado final. Talvez devido a minha experiência em C e C++, onde o código tende a ser bastante simbólico. Diferente do que normalmente podemos observar em códigos MQL5, ou de outras linguagens como Python por exemplo. Mas diferente do Python que você não conseguirá, usando a própria linguagem para tentar a tornar mais simbólica. No caso do MQL5, conseguimos produzir algo como o que foi visto nos artigos anteriores.

De fato, devo concordar com uma coisa. Esta ideia dos criadores do MQL5, de permitir que programadores com mais experiência demonstrem como poderíamos fazer as coisas. Foi de fato uma ideia genial. Além é claro, o fato de que o MQL5, venha a se parecer em diversos aspectos com as linguagens C e C++. Isto torna bem mais fácil que tais profissionais, tenham uma curva de aprendizado muito boa. Apesar de que estas linguagens C e C++, serem muito mais difíceis e complicadas de se dominar do que o MQL5. Mas isto não vem ao caso.

Mas neste artigo iremos explorar uma coisa um pouco mais suave e diferente. Talvez até mesmo bem mais interessante para grande parte de vocês. Já que os últimos artigos, foram mesmo artigos muito densos e com material que não é muito fácil de ser estudado e de ser assimilado, assim de uma hora para outra. Então neste artigo, vamos ver algo bem mais agradável, e consideravelmente muito mais simples. E será algo que você poderá vir a usufruir quase que de imediato.

Ok, então chegou o momento de nos afastarmos de coisas que podem nos distrair, e focar no que será visto e explicado neste artigo. Então vamos começar.

Indicadores técnicos (I)

Talvez uma das coisas que mais toma tempo de pessoas que estão querendo iniciar seus estudos no MQL5. E isto visando criar algum tipo de mecanismo de setup, para poder agilizar suas analises quando for operar no mercado. É o de entender como criar, ou melhor dizendo, programar um indicador qualquer. Assim como também o ligar a um Expert Advisor. Mas isto será visto em detalhes futuramente.

Já vimos em Do básico ao intermediário: Indicador (IV), como implementar um simples indicador, cujo objetivo seria indicar quando uma barra está dentro de outra anterior. Gerando assim o que seria conhecido como inside bar. Apesar de que, todo e qualquer código mostrado aqui, ter como princípio a didática e ser voltado ao aprendizado. Não posso negar que em alguns momentos, podemos sim ter algum tipo de aplicação muito simples sendo criada. Mesmo que ela não esteja devidamente programada não podendo de maneira alguma ser considerada 100% finalizado. E este será o caso que iremos ver a partir de agora. Então cuidado ao utilizar o que será implementado aqui em uma conta real. Pois pode haver perdas financeiras por questões obvias. Já que isto que iremos fazer é apenas uma aplicação didática.

Se você é iniciante no que se refere a programação em MQL5, já deve ter procurado saber como criar indicadores para isto, ou para aquilo. No entanto, o próprio MetaTrader 5, já nos fornece por padrão diversos indicadores que são previamente calculados, internamente dentro da própria plataforma. E não, não estou falando dos indicadores que você pode observar, ao olhar o conteúdo do diretório de indicadores. Não são aqueles, dos quais estou me referindo.

Os indicadores dos quais estou me referindo, podem ser vistos em Funções Indicadores Técnicos, todos aqueles indicadores listados neste local indicado, são indicadores que estão sendo calculados por padrão pelo MetaTrader 5. Você não precisa de fato criar todo um código para os calcular. Tudo que você precisa fazer é criar um acesso dentro de seu código para poder os utilizar. Isto vale para todo e qualquer aplicação que tenha sido feita visando ser utilizada pelo MetaTrader 5.

Sei que para muitos, este tipo de abordagem pode parecer um tanto quanto sem graça, enquanto para outros isto pode ser difícil de ser implementado. Pois sendo iniciante, você logo pensa que precisa criar todo o código necessário para que o cálculo do indicador venha a ser feito. E em outros casos, você pode imaginar que ao plotar o indicador no gráfico, se você não o tiver criado do zero, não conseguirá ter um controle total e completo do que deverá ser feito pelo indicador.

Ok, este tipo de pensamento, de certa maneira faz parte do aprendizado. Você não vai conseguir realmente aprender algo, se ficar utilizando coisas já prontas. Pois isto não é de fato um aprendizado, mas apenas uma maneira de poupar tempo, tentando reinventar a roda. Mas como todo bom profissional, você deve sempre, na medida do possível, tentar estabelecer metas e objetivo. O que não torna o fato de que tentar saber como trabalhar com todos os recursos que são oferecidos por uma ferramenta, são mera perda de tempo. Pois isto não é verdade. Por isto, estou mostrando muitas coisas, das quais você provavelmente nunca irá de fato precisar usar. Uma delas foi a sobrecarga de operadores. Aquilo é divertido, mas talvez você nunca venha de fato a fazer uso daquele conhecimento.

Mas por que você está mencionando isto? O motivo, meu caro leitor, é que você irá encontrar uma vasta quantidade de pessoas que irão lhe mostrar como fazer isto, ou aquilo. Porém poucos irão de fato lhe mostrar por que fazer isto ou então aquilo. E desta forma, você escolhe qual o caminho mais fácil e rápido para atingir seu objetivo.

Muito bem, então vamos começar, com o que acredito ser o indicador mais simples de todos. Uma média móvel. Para criar este tipo de coisa, utilizando os indicadores técnicos. Tudo que precisamos fazer é codificar algo como mostrado logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. #property description "DEMO Indicator"
05. //+------------------------------------------------------------------+
06. #property indicator_chart_window
07. #property indicator_applied_price   PRICE_CLOSE
08. #property indicator_buffers         1
09. #property indicator_plots           1
10. #property indicator_type1           DRAW_LINE
11. #property indicator_color1          clrRed
12. #property indicator_style1          STYLE_SOLID
13. #property indicator_width1          1
14. //+------------------------------------------------------------------+
15. #define  def_nPeriods               9
16. //+------------------------------------------------------------------+
17. double   Buff_iMA[];
18. int      Handle;
19. //+------------------------------------------------------------------+
20. int OnInit(void)
21. {
22.    SetIndexBuffer(0, Buff_iMA, INDICATOR_DATA);
23.    if ((Handle = iMA(NULL, NULL, def_nPeriods, 0, MODE_EMA, _AppliedTo)) == INVALID_HANDLE)
24.    {
25.       Print("Could not start the indicator...");
26.       return INIT_FAILED;
27.    };
28. 
29.    return INIT_SUCCEEDED;
30. };
31. //+------------------------------------------------------------------+
32. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
33. {
34.    CopyBuffer(Handle, 0, 0, Bars(NULL, NULL), Buff_iMA);
35. 
36.    return rates_total;
37. };
38. //+------------------------------------------------------------------+
39. void OnDeinit(const int reason)
40. {
41.    if (Handle != INVALID_HANDLE) 
42.       IndicatorRelease(Handle);
43. };
44. //+------------------------------------------------------------------+

Código 01

Este código 01, tem tudo que precisamos para criar uma média móvel a plotar no gráfico. É bem verdade, que não podemos mudar o tipo de média e o período, ou melhor dizendo, a quantidade de barras que serão usadas no cálculo. Porém podemos mudar diversas coisas, como cor, espessura, estilo da linha, e o padrão de preço que será utilizado. E tudo isto fazendo uso deste código aparentemente ridículo em termos de grau de dificuldade.

Mas espere um pouco, você está me dizendo que podemos mudar diversas coisas aqui. Porém não estou vendo nenhuma linha que indica isto. Ao meu ver, se desejarmos mudar algo, precisaremos recompilar o código para fazer isto. Então temos um incrédulo ( RISOS ). Perfeito, gosto quando as pessoas de fato duvidam das coisas no primeiro momento. Então vamos ver como este código se comporta para ver se estou ou não dizendo a verdade sobre ele.

Para iniciar, precisamos de um código que sabidamente nos irá fornecer os dados corretos. Antes de usarmos o nosso código 01 no gráfico. Para a nossa felicidade, o MetaTrader 5, conta com um bem adequado. Assim iremos adicionar este indicador inicial para fins de averiguação. Isto é visto na animação logo abaixo.

Animação 01

Agora temos uma forma de checar se o código 01, está ou não funcionado. Pois bem, vamos adicionar ele agora ao gráfico. Ao fazermos isto, teremos como resultado o que é visto na animação logo abaixo.

Animação 02

Veja que ele se encaixou perfeitamente sobre a média que já estava no gráfico. Agora para mudar os parâmetros, fazemos o que é mostrado na animação logo abaixo.

Animação 03

Note que apesar de à primeira vista não termos como ajustar as coisas, fizemos todos os ajustes que mencionei que eram possíveis de serem feitos. Demonstrando assim que de fato o código funciona como a via sido mencionado. Porém não ficamos restritos a este tipo de coisa. Podemos ir um pouco mais além. Mas vamos com calma. Primeiro quero explicar, por que este código 01 funciona como foi mostrado nas animações. Boa parte do que você precisa saber, já foi explicado em um outro artigo.

Veja os artigos Do básico ao intermediário: Indicador (I), até o Do básico ao intermediário: Indicador (IV), para entender a base deste código 01.

Talvez também venha a ser necessário que você veja o artigo Do básico ao intermediário: Eventos (I), onde foi explicado a base por trás da programação baseada em eventos. Isto irá lhe ajudar a entender como e por que o código 01 funciona.

Considerando que você, já tem o conhecimento necessário para entender o que será explicado. Podemos continuar. Note que na linha 15 estou definindo um valor. Este será o valor a ser calculado como média móvel. Agora vem a parte criativa do código. Dizer que é a parte criativa, pode parecer estranho, mas você logo irá entender o motivo. Como todo e qualquer indicador que irá plotar algo no gráfico, precisamos definir pelo menos um buffer. Isto está sendo feito na linha 22. Na linha 23 tentamos definir a variável que será utilizada pelo manipulador do indicador técnico. Agora preste atenção a isto, meu caro leitor. Cada indicador técnico, necessita de ser configurado para que o MetaTrader 5, saiba o que fazer com ele.

Não adianta você simplesmente dizer, eu quero um indicador, que o MetaTrader 5 irá o criar como você o deseja. Para que isto de fato venha a ocorrer, precisamos dizer ao MetaTrader 5, como o indicador deverá ser calculado. Para saber quais informações você precisa dar ao MetaTrader 5, consulte a documentação, no que se refere aos indicadores técnicos. No entanto, na maior parte das vezes, você pode colocar os dois primeiros argumentos, como é visto no código 01. Isto irá garantir que o indicador, irá se adaptar ao ativo e tempo gráfico atual. Se você definir aqui, um tempo gráfico, ou mesmo um ativo qualquer, o MetaTrader 5, irá procurar e utilizar os dados que você está definindo aqui.

Isto nos permite, ter um gráfico sendo plotado nos 10 minutos. Porém com os cálculos sendo efetuados com base nas informações presentes no que seria o gráfico dos 60 minutos, ou mesmo o gráfico do diário. A mesma coisa se refere em relação ao ativo. Você pode indicar um ativo, e no entanto usar o indicador no gráfico de um outro ativo.

Cara isto é muito doido. Não sabia que podíamos fazer isto. Sim meu caro leitor, podemos fazer isto e muito mais. A questão é por que você faria isto na prática?

Ok, agora como você pode ver precisamos no caso do iMA, informar no terceiro argumento, qual a quantidade de barras a serem usadas no cálculo. Logo depois, o deslocamento destas barras. Normalmente se utiliza o valor zero aqui, mas podemos precisar utilizar um outro valor, como por exemplo, no caso de você está implementando a média para visualizar o que seria a formação de uma reversão de tendência. Já o quinto parâmetro, dizemos, aqui no caso do iMA, qual o tipo de média a ser calculado. E por último, dizemos qual será o tipo de preço a ser usado no cálculo.

Se tivermos sucesso com a criação do manipulador, o próximo passo será dado no tratador de evento OnCalculate. Caso venhamos a ter uma falha, isto será indicado pela mensagem vista na linha 25. De qualquer forma, tendo tipo falha ou sucesso aqui, em algum momento o evento OnDeinit será executado. E ao fazer isto, iremos remover o manipulador na linha 42. Sendo este processo uma boa prática de programação. Já que em teoria, se não removermos o manipulador, o MetaTrader irá continuar efetuando cálculos que já não são necessários. Consumindo assim recursos preciosos.

Agora vamos ver a parte criativa do código. Está se encontra no evento OnCalculate. Mas espera um pouco, onde estão os cálculos para criar a média móvel? Bem, esta é a parte interessante meu caro leitor. Você não precisa criar os cálculos, ou se quer se preocupar com eles. Já que eles estão sendo feitos pelo MetaTrader 5. Por conta disto, tudo que precisamos fazer, é simplesmente pedir para que o MetaTrader 5, faça a transferência dos valores que ele calculou para dentro do buffer do indicador. Isto é feito na linha 34.

Hum. Estou vendo, mas não estou entendendo. Mesmo depois de ter visto os resultados nas animações. Não consigo entender direito o que esta linha 34 está fazendo e por que precisamos dela. Certo, então vamos entender isto. Como o MetaTrader 5 faz os cálculos para nós, os cálculos ficam dentro de um buffer interno na plataforma. Para podermos ter acesso a estes dados, precisamos dizer ao MetaTrader 5, que dados queremos que ele nos forneça.

Para fazer isto, precisamos saber qual o manipulador usado nos cálculos. Sem isto, não temos como reaver as informações. Mas espere um pouco. Você está me dizendo que se eu souber, onde os dados estão, posso ler eles a qualquer momento? Sim, meu caro leitor, desde que eles estejam disponíveis, você os poderá acessar a qualquer momento, sabendo qual manipulador utilizar. Interessante. De fato isto é algo bem interessante, e no futuro irei mostrar como você pode usar isto ao seu favor. Mas vamos continuar entendendo o que este código 01 está fazendo.

O segundo argumento da linha 34 poderá variar dependendo de certas coisas. Normalmente ele será igual a zero. Porém isto não é uma regra. Com relação ao terceiro parâmetro, em quase todos os casos ele será igual a zero. Salvo o fato de você desejar fazer uma análise a fim de tentar capturar uma reversão de tendência, ou mesmo analisar um movimento específico. Mas no geral este terceiro parâmetro será zero.

Com relação ao quarto parâmetro, temos uma coisa interessante aqui. Dependendo da forma como você venha a configurar as coisas, pode ser que venhamos a ter mais ou menos dados sendo plotados. Porém dependendo da forma como você vier a trabalhar aqui, pode gerar um tipo de média móvel bem curiosa a princípio. Já o último parâmetro, estará ligado ao que seria o segundo parâmetro. Justamente pelo fato de que ambos estão ligados ao buffer onde os dados a serem plotados irão ficar.

Agora vamos fazer um pouco de graça aqui. E esta tem tudo a ver justamente com o quarto parâmetro da linha 34. Para entender o que eu falei a pouco sobre o fato de termos algo curioso e interessante aqui. Vamos modificar este código do evento OnCalculate, para o que é visto no fragmento logo abaixo.

                   .
                   .
                   .
31. //+------------------------------------------------------------------+
32. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
33. {
34.     CopyBuffer(Handle, 0, 0, def_nPeriods, Buff_iMA);
35.     PlotIndexSetInteger(0, PLOT_DRAW_BEGIN, Bars(NULL, NULL) - def_nPeriods);
36. 
37.    return rates_total;
38. };
39. //+------------------------------------------------------------------+
                   .
                   .
                   .

fragmento 01

Agora preste atenção meu caro leitor. Normalmente você irá ver as médias móveis sendo plotadas de um passado muito distante até a barra mais atual presente no gráfico. Porém, como programadores, podemos fazer as coisas de uma forma totalmente diferente. Impedindo assim que o gráfico fique demasiadamente poluído, ou com informações desnecessárias.

O que este fragmento 01, faz é criar uma média móvel estilo verme. Que conforme novas barras vão surgindo, ela vai caminhando. Sempre plotando uma média móvel, cujo comprimento, corresponde a quantidade de períodos que foram necessários nos cálculos. Na animação logo abaixo você pode ver isto ocorrendo.

Animação 04

Note que existe uma média móvel em amarelo dentro da média em vermelho. A média em vermelho é a que vimos lá no início do artigo. Já está média em amarelo é a que corresponde ao código 01, porém fazendo uso do fragmento 01. Assim que uma nova barra surge, a média se desloca para que a quantidade de posições entre se início e seu final, continue sendo de nove barras, ou o valor que está sendo definido na linha 15 do código 01. Muito legal este tipo de coisa não é mesmo? E veja como foi muito simples e fácil de criar este tipo de coisa. É este tipo de implementação que você consegue quando aprende a programar. Usuários comuns não sabem que podemos fazer isto aqui no MetaTrader 5.

Bacana. Mas será que não teria como deixar as coisas mais interessantes? Digo isto, pois gostaria de saber como eu poderia, sem precisar compilar o código diversas vezes, mudar a quantidade de barras usadas no cálculo, ou quem sabe o tipo de média a ser usada. Sim meu caro leitor, podemos fazer isto e de maneira muito simples, fácil e rápida.

Partindo do código 01, mudamos o mesmo usando o fragmento logo abaixo.

                   .
                   .
                   .
14. //+------------------------------------------------------------------+
15. input uint              def_nPeriods = 9;
16. input ENUM_MA_METHOD    def_MA_Method  = MODE_EMA;
17. //+------------------------------------------------------------------+
18. double   Buff_iMA[];
19. int      Handle;
20. //+------------------------------------------------------------------+
21. int OnInit(void)
22. {
23.    SetIndexBuffer(0, Buff_iMA, INDICATOR_DATA);
24.    if ((Handle = iMA(NULL, NULL, def_nPeriods, 0, def_MA_Method, _AppliedTo)) == INVALID_HANDLE)
25.    {
26.       Print("Could not start the indicator...");
27.       return INIT_FAILED;
28.    };
29. 
30.    return INIT_SUCCEEDED;
31. };
32. //+------------------------------------------------------------------+
                   .
                   .
                   .

Fragmento 02

Agora, compilando novamente o código, você passará a ter acesso ao que é visto na imagem logo abaixo.

Imagem 01

Apesar de funcionar, isto que é visto em destaque na imagem 01, não é muito representativo para um usuário. O correto, será modificarmos o próprio fragmento 02, para o que é visto abaixo. Desta forma teremos como resultado o que é visto na imagem logo na sequência.

                   .
                   .
                   .
14. //+------------------------------------------------------------------+
15. input uint              def_nPeriods = 9;             //Period:
16. input ENUM_MA_METHOD    def_MA_Method  = MODE_EMA;    //Method:
17. //+------------------------------------------------------------------+
                   .
                   .
                   .

Fragmento 03

Imagem 02

Agora o usuário irá saber do que cada valor irá interferir no cálculo. Apesar de não ter a mínima ideia de como realmente o código funciona, ou como a média móvel pode estar sendo plotada. É bem verdade que este indicador funciona. Porém, dependendo de como você venha a implementar seu indicador, pode ser que você venha a ver algo relativamente estranho sendo mostrado no gráfico, quando seu indicador vier a ser colocado no gráfico. O problema pode ser visto na imagem logo abaixo.

Imagem 03

O problema em si está sendo destacado dentro deste círculo em verde. Mas por que meu indicador gerou este tipo de informação? O motivo meu caro leitor, são os dados que se encontram presentes dentro do indicador. No caso deste indicador visto neste artigo, se o código estivesse como mostrado logo abaixo, este mesmo problema iria acontecer.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. #property description "DEMO Indicator"
05. //+------------------------------------------------------------------+
06. #property indicator_chart_window
07. #property indicator_applied_price   PRICE_CLOSE
08. #property indicator_buffers         1
09. #property indicator_plots           1
10. #property indicator_type1           DRAW_LINE
11. #property indicator_color1          clrRed
12. #property indicator_style1          STYLE_SOLID
13. #property indicator_width1          1
14. //+------------------------------------------------------------------+
15. input uint              def_nPeriods = 9;             //Period:
16. input ENUM_MA_METHOD    def_MA_Method  = MODE_EMA;    //Method:
17. //+------------------------------------------------------------------+
18. double   Buff_iMA[];
19. int      Handle;
20. //+------------------------------------------------------------------+
21. int OnInit(void)
22. {
23.    SetIndexBuffer(0, Buff_iMA, INDICATOR_DATA);
24.    if ((Handle = iMA(NULL, NULL, def_nPeriods, 0, def_MA_Method, _AppliedTo)) == INVALID_HANDLE)
25.    {
26.       Print("Could not start the indicator...");
27.       return INIT_FAILED;
28.    };
29. 
30.    return INIT_SUCCEEDED;
31. };
32. //+------------------------------------------------------------------+
33. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
34. {
35.    CopyBuffer(Handle, 0, 0, def_nPeriods, Buff_iMA);
36. 
37.    return rates_total;
38. };
39. //+------------------------------------------------------------------+
40. void OnDeinit(const int reason)
41. {
42.    if (Handle != INVALID_HANDLE) 
43.       IndicatorRelease(Handle);
44. };
45. //+------------------------------------------------------------------+

Código 02

Mas espere um pouco. Este código 02 é quase igual ao código 01. Porém não percebi este problema sendo mostrado lá. Mas ele ainda assim está lá meu caro leitor. O detalhe é que por conta de que temos muitas barras presentes ali no gráfico. O problema acaba ficando meio que escondido. Mas ainda assim ele continua presente. O detalhe é que aqui neste código 02, o problema ficou mais evidente justamente por conta de que na linha 35 onde copiamos os valores para o buffer do indicador a ser plotado. Temos uma menor distância, entre o que seria o início e o final dos dados. Porém o que quero mostrar com isto é que mesmo quando você não percebe uma falha no seu código, isto não quer dizer que ela não exista. Mas apenas estão em um lugar que você não consegue ver.

Ok, para corrigir este tipo de problema temos duas maneiras, basicamente. A primeira foi no fragmento 01, onde a linha 35 daquele fragmento corrige justamente esta questão. Outra maneira de também conseguir resolver esta mesma questão, é fazendo a inicialização do buffer de dados a serem plotados. O local exato de onde você irá inicializar o buffer de dados do indicador, indica que tipo de resultado poderemos vir a ter.

Para deixar isto um pouco mais claro para você possa entender. Vamos fazer dois testes. O primeiro será o de inicializar o buffer diretamente no procedimento OnInit, como pode ser visto logo abaixo.

                   .
                   .
                   .
20. //+------------------------------------------------------------------+
21. int OnInit(void)
22. {
23.    SetIndexBuffer(0, Buff_iMA, INDICATOR_DATA);
24.     ArrayInitialize(Buff_iMA, EMPTY_VALUE);
25.    if ((Handle = iMA(NULL, 0, def_nPeriods, 0, def_MA_Method, _AppliedTo)) == INVALID_HANDLE)
26.    {
27.       Print("Could not start the indicator...");
28.       return INIT_FAILED;
29.    };
30. 
31.    return INIT_SUCCEEDED;
32. };
33. //+------------------------------------------------------------------+
34. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
35. {
36.    CopyBuffer(Handle, 0, 0, def_nPeriods, Buff_iMA);
37. 
38.    return rates_total;
39. };
40. //+------------------------------------------------------------------+
                   .
                   .
                   .

Fragmento 04

Só que esta abordagem, pode deixar o indicador meio doido. Como você pode observar na imagem logo abaixo.

Imagem 04

Note como o desenho da média vista nesta imagem 04 está completamente doida? Isto costuma acontecer quando você força o indicador a ser atualizado, entre uma e outra chamada que o MetaTrader 5 poderá vir a fazer a função OnCalculate. Lembre-se de que os dados a serem plotados estão vindo do MetaTrader 5. Nós não os estamos calculando localmente. Estamos simplesmente utilizando os dados previamente calculados pelo MetaTrader 5. E como mesmo depois de o MetaTrader 5, disparar um evento OnCalculate. O evento NÃO FARÁ a plotagem ser corrigida. Isto por que, durante a cópia do buffer, estaremos capturando apenas parte dos valores previamente calculados. Veja isto sendo feito na linha 36.

Agora se você estiver carregando todos os dados que foram calculados pelo MetaTrader 5, este mesmo problema visto na imagem 04 não irá ocorrer. Por isto que você precisa tomar cuidado quando for programar as coisas. Ainda mais se o seu objetivo é o de comercializar ou mesmo utilizar estes cálculos e aplicações para automatizar suas operações no mercado financeiro.

Muito bem, mas vamos voltar a nossa questão principal. Lembra que foi dito que haveria basicamente duas formas de inicializar o buffer? Pois bem, a segunda forma é vista logo abaixo.

                   .
                   .
                   .
20. //+------------------------------------------------------------------+
21. int OnInit(void)
22. {
23.    SetIndexBuffer(0, Buff_iMA, INDICATOR_DATA);
24.    if ((Handle = iMA(NULL, 0, def_nPeriods, 0, def_MA_Method, _AppliedTo)) == INVALID_HANDLE)
25.    {
26.       Print("Could not start the indicator...");
27.       return INIT_FAILED;
28.    };
29. 
30.    return INIT_SUCCEEDED;
31. };
32. //+------------------------------------------------------------------+
33. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
34. {
35.    ArrayInitialize(Buff_iMA, EMPTY_VALUE);
36.    CopyBuffer(Handle, 0, 0, def_nPeriods, Buff_iMA);
37. 
38.    return rates_total;
39. };
40. //+------------------------------------------------------------------+
                   .
                   .
                   .

Fragmento 05

A vantagem deste segundo método é que o indicador não correrá o risco de ficar meio doido. E o resultado será algo muito similar ao que foi visto na animação 04, onde o indicador irá acompanhar o desenrolar das coisas. Porém talvez a animação 04 não tenha deixado as coisas claras o bastante. Se este foi o caso, veja a animação logo abaixo.

Animação 05

Como foi dito antes, este tipo de coisa é muito legal. E como uma última coisa a ser mostrada neste artigo, quero explicar como você faz para modificar algo que é mostrado durante a configuração do indicador pelo usuário. Tal coisa pode ser vista na imagem 05

Imagem 05

Este tipo de informação não é nada sugestivo para o usuário. Porém você pode dizer que mexer nisto daqui não faz muito sentido. De fato, em muitos casos isto não faz realmente muito sentido. Porém quero lembrar a você, caso você não tenha visto, que podemos ter em um mesmo indicador diversas linhas, ou informações, sendo plotadas ao mesmo tempo.

No artigo Do básico ao intermediário: Indicador (III), mostrei como isto poderia ser feito. No entanto, ali acabei me esquecendo de mostrar como mudar esta informação destacada na imagem 05. E fazer isto, é algo bastante simples e direto. Tudo que precisamos fazer é adicionar ao código o que é visto na linha 14 do fragmento logo abaixo.

                   .
                   .
                   .
12. #property indicator_style1          STYLE_SOLID
13. #property indicator_width1          1
14. #property indicator_label1          "EMA"
15. //+------------------------------------------------------------------+
16. input uint              def_nPeriods   = 9;           //Period:
17. input ENUM_MA_METHOD    def_MA_Method  = MODE_EMA;    //Method:
                   .
                   .
                   .

Fragmento 06

Com isto teremos o que pode ser visto na imagem logo na sequência.

Imagem 06

Apesar de isto funcionar relativamente bem, e tornar as coisas bem interessantes e mais simples para o usuário de ajustar alguma coisa. Temos um pequeno inconveniente aqui, que é justamente o fato de que esta informação que estamos vendo sendo destacada na imagem 06, ser uma informação estática. Ou seja, se o usuário mudar o tipo da média móvel, esta informação na imagem 06, não irá acompanhar a mudança. E se você estiver definindo diversas médias móveis em um mesmo indicador. Isto acabará destruindo completamente a experiência do usuário.

Resolver este tipo de questão é uma tarefa bem simples. Porém não irei abordar isto neste exato momento. Já que quero mostrar algumas outras coisas relacionadas a deixar com que diversas informações passem a ter um tratamento um pouco mais dinâmico. Porém isto será visto no próximo artigo.

Considerações finais

Neste artigo vimos como poderíamos utilizar indicadores técnicos que estão presentes e são mantidos pelo próprio MetaTrader 5. Saber, entender e conhecer este tipo de indicador pode vir a tornar seu trabalho de implementar algo, em uma tarefa muito mais simples, rápida e eficiente. Visto que você não precisa se preocupar com a parte referente aos cálculos a serem efetuados. A própria plataforma se encarrega de fazer isto para nós.

No entanto, saber como utilizar os indicadores técnicos é apenas uma parte de um todo bem mais amplo. No próximo artigo, iremos ver como podemos tirar bem mais proveito deste tipo de implementação. Isto a fim de conseguir implementar de maneira bem mais simples certos tipos de modelos operacionais. Então até breve.

Arquivo MQ5	Descrição
Code 01	Demonstração básica
Code 02	Demonstração básica