Do básico ao intermediário: Eventos (I)

Introdução

No artigo anterior Do básico ao intermediário: Struct (II), falamos sobre estruturas básicas e de como poderíamos utilizar elas para repassar valores para dentro de funções e procedimentos. Apesar deste tema sobre estruturas ainda não ter sido explorado a fundo. Creio que ainda não é o momento para entramos em certas coisas presentes e possíveis de serem feitas em estruturas. Isto porque, até onde consegui notar, aqui no MQL5, não precisamos de fato, que a programação venha a ser feita em um nível muito elevado. E por favor, não me entendam mal por eu dizer isto.

O que quero dizer com isto, é que com bem pouco conhecimento, porém com uma base de conceitos bem elaborados. Você, meu caro leitor, consegue fazer e implementar quase qualquer tipo de aplicação, para ser utilizado no MetaTrader 5. E tendo em vista, que muito provavelmente 95%, isto para não dizer um número maior, das vezes, você irá de fato fazer apenas aplicações simples. Não vejo motivo, para entrar em alguns detalhes mais complexos neste momento.

Sendo assim, irei dar um tempo na parte referente a explicação sobre conceitos de programação básica. E iremos começar a ver como criar códigos que de fato, serão orientados a mostrar como implementar uma aplicação para MetaTrader 5, usando para isto MQL5 puro.

Bem, como este artigo é um artigo para explicar as bases envolvidas nesta maneira de implementar códigos em MQL5. Vamos começar vendo o que seria a implementação mais básica de todas. Mas antes disto, precisamos falar de um outro assunto.

Conceito básico sobre eventos

Aqui, não irei me estender muito, já que falar sobre o que se refere ao título deste tópico, conseguiria produzir um livro inteiro, sobre programação. E isto falando de maneira literal. Já que é um tipo de assunto, extremamente extenso e com várias nuances presentes nele. Porém, precisamos nivelar um pouco as coisas, antes mesmo, de começarmos realmente a falar, sobre como implementar uma aplicação que será utilizada no MetaTrader 5.

Praticamente toda aplicação gráfica, faz uso de eventos. O momento em que um ou outro evento será gerado, independe do seu programa, ou do que você esteja implementado. Isto no geral. Existem casos especiais em que podemos disparar eventos, de dentro de nossa aplicação. Porém, como são casos especiais, você não deve de forma alguma tomar isto como uma forma de controlar um código. Na verdade, muitas vezes um programador, que irá implementar algum tipo de código, para ser executado em um certo ambiente, não está de fato programando algo. Ele está apenas dizendo, como seu código deverá responder a cada um dos eventos que esteja chegando.

Alguns eventos, podem ser ignorados em uma aplicação, mas em outra eles terão prioridade sobre qualquer outra atividade. E entender isto, para muitos iniciantes é algo muito complicado e difícil. Já que até este momento, todos os códigos apresentados, NÃO VISAM TRATAR EVENTOS. Eles apenas executam aquilo que foram programados para fazer.

No entanto, quando vamos programar um indicador ou mesmo um Expert Advisor para ser utilizado no MetaTrader 5. Não estamos de forma alguma preocupados em fazer as coisas acontecerem. Por mais que isto possa parecer estranho. O que estamos de fato interessados, é em dizer, como o indicador ou Expert Advisor, deverá responder a um dado evento.

Por exemplo: Quando você usa um programa como Gimp, que permite você desenhar em uma janela, você imagina que o programa está trabalhando de uma determinada maneira. Mas bem lá no fundo, ele apenas está respondendo a eventos que você, como usuário está gerando. Como um clique, um pressionar de uma tecla, ou mesmo o arrastar do mouse. Tudo isto são eventos. O programa NÃO SABE e não se interessa em ficar olhando o que você está fazendo. Ele apenas espera um evento e responde a ele. E no final, você tem uma imagem sendo manipulada e desenhada.

A mesma coisa acontece com o MetaTrader 5. Para ele não interessa, o que o usuário possa estar fazendo. Ele apenas fica ali, imóvel, esperando receber algum tipo de evento. Quando o evento ocorrer ele responde a isto de alguma forma.

Mas espere um pouco, quem então é responsável por gerar os eventos? Bem, sem entrar em muitos detalhes: Você. Porém, a responsabilidade de dizer, qual aplicação gráfica é que irá receber qual evento, é do sistema operacional. Você, como usuário, não é capaz de dizer isto. Você apenas diz ao sistema operacional que tal aplicação deve fazer tal coisa. Como por exemplo: Ser minimizada, maximizada ou mesmo o que acontece quando pedimos para fechar a aplicação.

Diferente do que muitos pensam. Quem de fato diz, como uma aplicação será fechada, NÃO É o sistema operacional. Mas sim a própria aplicação. Por conta disto, é que quando você está digitando um texto, e pede para fechar a janela de edição. O editor pode vir a lhe pergunta se você deseja ou não salvar as modificações. Se o sistema operacional tivesse que tomar conta disto, o mesmo seria muito, mas muito mais complicado. Então em última instância, quem diz como uma aplicação irá responder a um evento, é a própria aplicação. Nunca o sistema operacional. Por isto, dizer que um sistema é melhor que outro, ao meu ver é pura ignorância e falta de conhecimento de como as coisas de fato funcionam.

Ok, apesar de que o MetaTrader 5, pode ser executado em um sistema operacional, diferente do Windows. Vamos adotar a tese de que ele ainda assim, estaria sendo executado dentro do Windows. Mesmo se você estiver utilizando uma versão WEB do terminal MetaTrader 5. Ainda assim, por motivos de simplificar a explicação, vamos estabelecer que o Windows é a base do sistema.

Certo, mas por que criar este conceito? O motivo é que você, meu caro leitor, interessado em aprender como programar para o MetaTrader 5, precisa entender, que qualquer aplicação rodando no MetaTrader 5, não estará respondendo a eventos diretamente vindos do Windows. Mas sim eventos vindos do MetaTrader 5. Novamente, e é bom deixar isto bem claro. Existem situações específicas em que uma aplicação, rodando no MetaTrader 5, estará de fato respondendo diretamente ao Windows. Mas isto é algo muito específico, já que exige um nível de programação bem elevado. Coisa que não se aplica neste momento.

Muito bem, então agora que tais coisas foram ditas e já temos uma certa noção. Podemos colocar tudo que foi mencionado em uma imagem. Com isto, temos a imagem vista logo abaixo.

Imagem 01

Esta imagem é bastante emblemática, já que ela nos mostra o caminho entre um evento que o usuário possa estar gerando, até o momento em que alguma aplicação rodando no MetaTrader 5, venha a receber este mesmo evento. Note que, apesar de estarmos mencionando uma aplicação, como sendo um Expert Advisor, ela na verdade pode ser qualquer uma possível de ser executada no MetaTrader 5. Porém, como o Expert Advisor é o que responde a maior parte dos eventos, se não todos, usei ele como forma de mencionar onde estaria a nossa aplicação, nesta história toda.

Esta foi a parte fácil, agora vem a parte divertida. Pois existem excepcionalmente dois tipos de eventos. Os eventos síncronos e os não síncronos. Eventos síncronos podem ser do tipo, que acontece a cada x período de tempo. Estando desta forma ligados de alguma maneira com o relógio do sistema. Um exemplo deste tipo de evento, é o surgimento de uma nova barra no gráfico. Ele sempre irá ocorrer de tempos em tempos. Mas também podem vir a ter eventos síncronos oriundos de eventos não síncronos. O que torna algumas coisas, bem interessantes. Mas antes de falarmos sobre eventos síncronos que vem de eventos não síncronos. Precisamos entender o que seria um evento não síncrono.

Um evento não síncrono, é todo evento, gerado de maneira aleatória. Por exemplo, o pressionar de uma tecla, o movimento do mouse, ou mesmo uma operação de abertura ou fechamento de posição. Neste caso especifico, a posição seria aberta ou fechada, por conta que o preço atingiu certo patamar. Resumindo: Um evento não síncrono é todo evento que você não sabe quando irá ocorrer e a ordem em que ele irá ser apresentado.

Mas como foi dito, também podemos ter eventos síncronos, com base em eventos não síncronos. Um exemplo este tipo de situação, seria quando você seleciona algo no gráfico do MetaTrader 5, e depois arrasta ou deleta o objeto. O momento em que cada evento ocorreu não importa, porém ele aconteceu em uma determinada ordem, ou sequência. Por isto, que muitos tem dificuldade em programar certos tipos de aplicações. Isto porque pode ser necessário responder a eventos síncronos com origem não síncrona. De qualquer forma, você não precisa se preocupar com isto, neste momento. Conforme formos avançando nos artigos, iremos ver como trabalhar com este tipo de situação.

Primeiros eventos na prática

Este é um momento, do qual devo confessar ser um tanto quanto desafiador. Isto porque, quero mostrar a você meu caro leitor, como eventos acontecem. Mas ao mesmo tempo, não quero ter de criar algo que não faça muito sentido. Sendo assim, vamos precisar recorrer a algum meio, que seja simples de entender. Porém que seja ao mesmo tempo auto explicativo. Isto para não tomar muito do nosso tempo, tentando explicar como eventos acontecem e como são tratados. Já que este tipo de coisa, é bastante intuitiva para quem entende sobre eventos, mas pode ser muito confuso para quem não os entende. Assim sendo, vamos fazer uma primeira tentativa de captura e tratamento de eventos na prática.

Antes de começarmos precisamos entender uma coisa, excepcionalmente, presente no MQL5. Que é a divisão entre tipos diferentes de aplicação. Basicamente no MQL5, temos dois tipos de aplicação. As que podem responder a eventos do usuário e as que não podem responder a eventos do usuário. Isto de forma direta. Pois bem, entre as que podem capturar e por consequência, responder eventos de interação do usuário, temos os indicadores e o Expert Advisor. Já as que não podem responder a eventos do usuário, por não poder capturar tais eventos, temos scripts e serviços. Saber disto, é muito importante, para que você possa escolher qual a melhor alternativa a ser adotada.

Bem, até o presente momento, basicamente trabalhamos apenas utilizando scripts. Neles temos um ponto de entrada que é o procedimento OnStart. Daí para frente, tudo deve ser gerado e controlado por você, como programador. Mas, no caso atual, queremos capturar eventos, sejam eles quais forem. E é neste ponto que precisamos começar a pensar com calma e conhecer o que cada modelo permitido no MetaTrader 5, pode nos oferecer.

Se você está lendo este artigo, com toda a certeza, já deve ter experimentado, mesmo que parcialmente o MetaTrader 5. Com as aplicações que vem por padrão nele. Com isto, deve ter notado que podemos ter diversos indicadores em um mesmo gráfico. No entanto, apenas e somente um único Expert Advisor presente. Então dependendo, do seu objetivo, podemos vir a implementar as coisas em um indicador, ou em um Expert Advisor.

Entretanto, existe um pequeno detalhe, que precisa ser compreendido, antes mesmo de começar a implementar o código em si. Este detalhe se refere as limitações que existem em indicadores e no Expert Advisor. E sim, meu caro leitor, existem limitações.

Por exemplo: Um indicador NÃO PODE estabelecer contato com o sistema de ordens, isto é exclusividade do Expert Advisor. Já o Expert Advisor NÃO PODE, pelo menos de forma simples, DESENHAR LINHAS e efetuar cálculos voltados a indicar algo no gráfico. Mas em princípio, um Expert Advisor, NÃO TEM COMO ACESSAR funções de biblioteca do MQL5, para desenhar no gráfico. Estas são exclusividade dos indicadores. Por isto, saber como trabalhar com tais modelos é muito importante. E isto será mostrado aqui, no decorrer dos artigos.

Ok, então você pode estar pensando: Cara, mas então não tem como criar algo que seja realmente util. Já que existem limitações que nos impede de criar uma aplicação que seja realmente única. De fato, meu caro leitor, o MetaTrader 5, foi pensado para ser uma plataforma muito estável e segura. Por conta disto, existem mecanismos, que iremos ver no futuro, que nos permite uma comunicação entre aplicações diferentes. Nos dando assim, a possibilidade de criar algo realmente muito interessante e que seja fácil de manter no logo prazo.

Muito bem, dada esta primeira e breve introdução sobre o assunto. Vamos começar vendo como eventos são capturados. Por hora não vamos nos preocupar em tratar os mesmos apenas capturar. Para isto, iremos inicialmente utilizar um indicador. Este pode ser visto logo abaixo, em seu código mínimo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. int OnInit()
05. {
06.    return INIT_SUCCEEDED;
07. };
08. //+------------------------------------------------------------------+
09. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
10. {
11.    return rates_total;
12. };
13. //+------------------------------------------------------------------+

Código 01

Estamos começando com o código mínimo, justamente para que o conceito de evento possa ser realmente bem compreendido. Pois nada adianta você simplesmente ficar copiando código, sem de fato entender por que ele precisa ser implementado daquela forma.

Muito bem, então no momento em que este indicador, for colocado no gráfico, algumas coisas irão ocorrer em uma certa sequência lógica. Entender isto é muito importante, para você conseguir se libertar, e começar a criar seus próprios códigos. Aqui, neste código 01, temos dois eventos sendo capturados. E como o MetaTrader 5 irá trabalhar em conjunto com estes eventos, irá direcionar como devemos tratar estes eventos. Sei que isto parece um tanto quanto confuso inicialmente. Mas, podemos fazer nossa aplicação interagir e fazer coisas não imaginadas, quando os desenvolvedores pensaram em como implementar o MetaTrader 5. Porém para conseguir fazer isto, precisamos entender como e quando, cada evento será disparado.

Claro, que aqui, como estamos em uma fase inicial e focados apenas na didática. Não irei mostrar como você pode "forçar" o MetaTrader 5 a fazer coisas que muitos consideram impossível. Mas se você estudar, e praticar bastante, conseguirá fazer praticamente qualquer coisa usando o MQL5 junto com o MetaTrader 5. Como por exemplo um editor de vídeo ou imagem. Coisas pelas quais o MetaTrader 5 não se destina. Já que o seu objetivo principal é nos permitir comprar e vender ativos negociados em um mercado eletrônico.

Muito bem, então agora podemos pegar aquela imagem 01 e expandir a mesma. De forma que este código 01, que é um indicador venha a aparecer. Com isto temos o seguinte fluxo de mensagens sendo criado.

Imagem 02

Nesta imagem 02, temos a extensão do que seria a imagem 01. Se bem, que o que estamos vendo nesta imagem 02, seria o que estaria acontecendo internamente dentro do que é o último ponto onde eventos são tratados. Pois bem, como aqui iremos tratar das coisas seguindo uma certa direção. Talvez seja interessante para você, entender um pouco mais sobre outros tipos de eventos que não irei abordar aqui nos artigos.

Para isto, sugiro que você dê uma olhada na documentação do MQL5 em: Funções de manipulação de Evento. Pois ali você terá uma ideia bem mais detalhada de quantos eventos existem e são cobertos pelo MQL5. Sendo que cada um deles tem um propósito e objetivo.

Mas voltando a nossa questão. Vamos entender quando cada um destes eventos visto no código 01, será disparado. Para entender isto, tudo que precisamos fazer será adicionar um pequeno comando já bastante utilizado aqui nos artigos. Assim, aquele mesmo código 01, agora irá ficar como mostrado logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. int OnInit()
05. {
06.    Print(__FUNCTION__);
07. 
08.    return INIT_SUCCEEDED;
09. };
10. //+------------------------------------------------------------------+
11. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
12. {
13.    Print(__FUNCTION__);
14. 
15.    return rates_total;
16. };
17. //+------------------------------------------------------------------+

Código 02

Legal, agora já temos como saber o que se passa por debaixo dos panos. Mas olhando este código 02, você pode estar pensando: Cara, mas este código não faz absolutamente nada de útil. Por que criar algo assim? Bem, meu caro leitor, na verdade este código 02 é extremamente útil para o que queremos fazer. Observe o seguinte: A única coisa que este código fará será o trabalho de imprimir uma mensagem no terminal dizendo que evento está sendo capturado. Isto é feito pelas linhas seis e treze. No entanto, veja o que acontece quando o colocamos em um gráfico qualquer.

Animação 01

Nesta animação 01, podemos ver quando o MetaTrader 5, disparou um evento que foi capturado pelo nosso indicador mostrado no código 02. E é isto mesmo que você está percebendo meu caro leitor. Apesar do nosso singelo código 02, aparentemente ser completamente inútil. Ele foi capaz de nos mostrar como um evento disparado pelo MetaTrader 5, fez algo acontecer, e que foi programado por nós. No caso, o tratamento que estamos dando aos eventos capturados é o de imprimir uma simples mensagem no terminal. Algo que a princípio, aparentemente não iria ocorrer. No entanto, note a sequência dos disparos. Mas também note o fato de que, a linha 13 foi impressa duas vezes. Sendo que a primeira ocorreu assim que o indicador foi posto no gráfico e a segunda quando a cotação do ativo mudou.

Entender este tipo de coisa é extremamente importante e nos será de grande utilidade. Já que agora, pelo fato de estamos tratando de eventos vindos do MetaTrader 5. Passará a implicar que iremos precisar mudar a forma de implementar os códigos. Isto quando estivemos trabalhando com indicadores e Expert Advisores, que são os únicos que respondem a eventos disparados pelo MetaTrader 5.

Legal. Mas vamos fazer uma nova mudança no código 02. Isto para adicionar mais um tratador de eventos. Agora, o código a ser executado é o que podemos ver logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. int OnInit()
05. {
06.    Print(__FUNCTION__);
07. 
08.    return INIT_SUCCEEDED;
09. };
10. //+------------------------------------------------------------------+
11. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
12. {
13.    Print(__FUNCTION__);
14. 
15.    return rates_total;
16. };
17. //+------------------------------------------------------------------+
18. void OnDeinit(const int reason)
19. {
20.    Print(__FUNCTION__);
21. };
22. //+------------------------------------------------------------------+

Código 03

Novamente temos um código muito singelo e que aparentemente não fará nada de útil. Porém ao executar ele, veja o que iremos enfrentar.

Animação 02

Da mesma forma como aconteceu no primeiro caso, onde procurávamos observar como nossa aplicação iria responder aos eventos disparados pelo MetaTrader 5. Aqui temos um outro tipo de captura sendo feita. Quero que você procure entender o seguinte meu caro leitor. O indicador se encontrava no gráfico, e este estava utilizando um determinado tempo gráfico. Assim que mudamos o tempo gráfico, é disparado um evento, que por sua vez está sendo capturado pelo indicador, visto no código 03.

Agora vem a parte que nos interessa. Quando acontecia a troca de tempo gráfico, quando o indicador visto no código 02, estava presente no gráfico. Nós simplesmente perdíamos este evento. Ou melhor dizendo, ignorávamos o fato de que o MetaTrader 5, o iria disparar, e simplesmente dizíamos o seguinte:

Olha MetaTrader 5, faça o que for preciso para que tudo continue funcionando. Pois não tenho nenhum problema com isto.

Então, o MetaTrader 5, disparava o evento, mas o código 02, o ignorava. Sendo assim, tínhamos a impressão de que o indicador, simplesmente saberia como agir naquele tipo de situação. No entanto, nem sempre isto é o que queremos que de fato aconteça. Nestes tipos de situação, podemos fazer uso de um procedimento que é visto na linha 18 no código 03, a fim de capturar este evento. E desta forma tomar as devidas providências para que nenhum outro evento estranho possa vir a acontecer.

Sei que muitos de vocês, ainda mais quem já tem alguma intimidade com programação em MQL5, pensa que não precisamos nos preocupar com muitos eventos acontecendo em um indicador. Porém, existem situações em que se você simplesmente ignorar certos eventos, poderá vir a experimentar falhas estranhas sendo reportadas pelo MetaTrader 5. Visto que uma vez que sua aplicação não tome as devidas medidas, o MetaTrader 5 irá tomar a liberdade de fazer o que for preciso, para garantir que problemas no seu código, não venham a interferir com o funcionamento geral da plataforma.

Apesar de muitos acharem difícil que erros possam existir em indicadores. Eles de fato acontecem, e quando isto, ocorre, e o MetaTrader 5 dispara um evento, que o nosso código ignora. Pode ser, que venhamos a ter problemas de performance da plataforma. Como lentidão, ou mesmo travamentos. Mas a culpa não é do MetaTrader 5, mas sim da sua aplicação, que não está respondendo de maneira adequada aos eventos disparados.

Para demonstrar este tipo de coisa. Vamos implementar, um código bem simples e bastante simpático. Com um objetivo bem simples, porém muito interessante, que seria nos dizer, quantas vezes o evento OnCalculate foi disparado durante um dado período de tempo. Este código pode ser visto logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. uint gl_Counter;
05. //+------------------------------------------------------------------+
06. int OnInit()
07. {
08.    gl_Counter = 0;
09. 
10.    Print(__FUNCTION__);
11. 
12.    return INIT_SUCCEEDED;
13. };
14. //+------------------------------------------------------------------+
15. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
16. {
17.    if (!gl_Counter)
18.    {
19.       uint arr[];
20. 
21.       if (FileLoad(_Symbol, arr) > 0)
22.          gl_Counter = arr[0];
23.    }
24.    
25.    Print(__FUNCTION__, " :: ", ++gl_Counter);
26. 
27.    return rates_total;
28. };
29. //+------------------------------------------------------------------+
30. void OnDeinit(const int reason)
31. {
32.    uint arr[1];
33. 
34.    arr[0] = gl_Counter;
35.    FileSave(_Symbol, arr);
36. 
37.    Print(__FUNCTION__);
38. };
39. //+------------------------------------------------------------------+

Código 04

Neste código não existe absolutamente nada que ainda não foi visto e comentado. Sendo perfeitamente compreendido por qualquer pessoa que esteja estudando e praticando o que tem sido mostrado nestes artigos. Talvez, e muito provavelmente, a única parte que pode gerar alguma dúvida, é o que esteja relacionado as funções FileLoad e FileSave. Como elas já são muito bem explicadas na própria documentação, não vejo motivo para dar maiores detalhes aqui, neste artigo.

No entanto, quando executado, este código 04, irá gerar algo parecido com o que é visto logo abaixo.

Animação 03

Observe que apesar, de estarmos mudando o tempo gráfico, o contador continua sendo incrementado. Isto justamente por conta do fato de que, na linha 30, deste código 04, estamos capturando o evento que o MetaTrader 5 dispara quando algo precisa ser feito por nosso código. No caso, não estamos tratando nenhuma das causas que fez o MetaTrader 5 disparar o evento. Apenas estamos dizendo ao MetaTrader 5, que salve em disco, uma dada variável. Poderíamos fazer isto de diversas outras maneiras. Como iremos discutir isto em breve. Mas o objetivo aqui, é justamente mostrar que pode haver situações em que precisamos tratar um evento, enquanto em outras situações, podemos ignorar aquele mesmo evento. Tudo depende, do que, e como pretendemos atingir nosso objetivo final.

Agora note que se, o procedimento da linha 30 não existisse, ou se não fazermos o tratamento da maneira adequada. Toda vez que mudarmos o tempo gráfico, o contador irá iniciar do zero. Isto por conta do que está acontecendo na linha oito. Onde começamos a contagem de quantas vezes OnCalculate foi executada. Bem legal este código, não é mesmo? Algo simples, porém que nos permite entender diversas questões relacionadas a eventos gerados pelo MetaTrader 5.

Considerações finais

Neste artigo, começamos a nos divertir de maneira muito mais intensa. Isto por que, este foi o primeiro de uma série de artigos, em que iremos ver sobre tratamento de eventos. Tentarei abordar este tema, de maneira lúdica, simples e didática. Mostrando a você, meu caro e estimado leitor, que nem sempre devemos utilizar a solução proposta por outro programador. Isto por quem, em uma ampla e vasta gama de vezes. A solução proposta por uma pessoa, pode não ser a solução ideal para você, naquele momento específico.

Sei que muitos podem estar ansiosos para o que será visto nos próximos artigos. Mas antes de tentar mergulhar de cabeça em algo, que irá ficar cada vez mais complicado. Tente praticar e estudar o que foi visto neste artigo. Garanto que irá valer muito a pena, praticar e procurar entender o que foi visto aqui. Como dica e até mesmo, incentivo para que você possa pensar o que pode ser praticado. Tente modificar o código 04, que estará no anexo, a fim de conseguir, fazer com que o valor do contador, seja armazenado, apenas e somente se houver um evento de troca de tempo gráfico. Em qualquer outro tipo de evento que o MetaTrader 5, venha a disparar, o contador deverá reiniciar sua contagem do zero novamente.

No próximo artigo, irei mostrar como você poderia fazer isto, de maneira bastante segura e simples. Então mãos à obra e bons estudos.