Desenvolvendo um sistema de Replay (Parte 37): Pavimentando o Terreno (I)

Introdução

Neste artigo irei abordar um tema de suma importância. É bom que foque ao máximo em compreender o conteúdo deste artigo. E não estou dizendo isto, apenas para que você o leia apenas por ler. Quero e preciso enfatizar que se você não entender este artigo especifico. Poderá abandonar completamente qualquer esperança em compreender o conteúdo dos próximos.

Tudo que irei mostrar, explicar e falar neste artigo. Será extremamente necessário para que você consiga entender, e isto minimamente, os próximos.

E não estou brincando. Pois acredito que muitos não tem a menor noção do que podemos de fato fazer. Isto usando o MQL5 a fim de fazer as coisas terem um dado comportamento no MetaTrader 5.

Durante todo este tempo, escrevendo artigos a fim documentar a você, caro leitor, como fazer algumas coisas no MetaTrader 5. Tenho evitado, ou procrastinado falar de um certo assunto. Tenho feito diversos rodeios. Tentando ao máximo falar de algo, que a muito tempo venho fazendo em meus programas.

Tais coisas me permitem modular o meu sistema de tal forma, que muitas das vezes, tenho mais trabalho em modificar o código original, do que simplesmente mostra-lo. Isto usando apenas e somente o MQL5.

Todos os códigos que vocês tem visto, ao longo de todo este tempo, na verdade são códigos modificados. Não são nem de longe, o que de fato uso originalmente. Mas agora cheguei em uma encruzilhada, onde não vejo como fazer a coisa de uma maneira diferente. Ou trago o código original, ou melhor dizendo, muito próximo do que de fato uso. Ou não irei conseguir dar prosseguimento no projeto do sistema de replay / simulador.

O problema em si, não é nem a codificação em si. Ela, ao meu ver é bem simples e bastante fácil de ser efetuada. O problema é que desejo levar a você o conhecimento necessário, a ponto que você consiga, não só usar, mas também modificar o sistema. Isto para que ele tenha um comportamento, que seria desejado e necessário, a ponto de você conseguir gerar estudos, ou analises próprias.

Quero que cada um, aprenda a andar com as próprias pernas, e não ficar dependendo de muletas. Esperando alguém lhe trazer uma solução. Seja ela qual for.

O que preciso fazer, e irei fazer neste artigo. É mostrar como você pode, usando indicadores e algum EA. Ter um comportamento bastante especifico, e uma programação bastante modular. Isto a ponto de criar algum tipo de sistema complexo. Mas, e aqui é que mora a questão. Você irá compilar o mínimo possível de coisas.

Para você ter uma noção. Atualmente o sistema de replay / simulador, conta com 3 executáveis, sendo eles: Um EA; Um serviço e um indicador. E no entanto, isto se quer ainda nos permite desenvolver o sistema de ordens. Lembrando que tal sistema seria o substituto do servidor de negociação. Isto para que possamos gerar estudo, operando como se estivéssemos em uma conta demo ou conta real.

Visto que ainda precisaremos trazer algumas coisas do passado, para dentro do sistema de replay / simulação. Entre ela o Chart Trader. Precisamos de alguma forma, mas precisa ser ao mesmo tempo sustentável e simples de se trabalhar. Apesar de ter feito isto no artigo Desenvolvendo um EA de negociação do zero (Parte 30): CHART TRADE agora como indicador ?!, ela não é adequada para o que precisamos.

Precisamos que as coisas sejam feitas de uma maneira bem mais transparente, e que não nos cause aborrecimentos.

Existe uma maneira, onde realmente podemos fazer as coisas, de uma forma bem mais adequada. Mas é preciso que ela seja mostrada em um exemplo mais simples. Caso partamos direto para a implementação desejada. Tenho quase total e absoluta certeza de que pouco, ou quase ninguém irá de fato conseguir acompanhar. Ficando totalmente a ver navios. E não quero isto. Desta forma, vamos ver como faremos as coisas a partir de agora. Então prepare-se para entrar no meu UNIVERSO.

Começando a construir o indicador

Já o que iremos fazer aqui, é algo extremamente complexo. Isto pelo ponto de vista de quem não conhece como o MetaTrader 5 funciona. Não irei postar nenhum anexo no final. Quero que você acompanhe a explicação. Assim saberei que você, caso venha a experimentar o que será visto aqui. Fique de fato sabendo como a coisa funciona em seus mínimos detalhes.

Para começar, vamos criar um indicador. Então usando o MetaEditor, você deverá fazer as coisas da seguinte forma:

Figura 01 - Selecionando o que iremos criar.

Figura 02 - Crie um diretório desta forma.

Figura 03 - Dê um nome ao indicador.

Figura 04 - Vamos manter as coisas no básico.

Até neste momento, que pode ser visto na figura 04, logo acima. Temos a criação basicamente igual, para todo e qualquer tipo de indicador que você for de fato fazer. Neste ponto da figura 04, poderemos ter em alguns momentos um ou outro caminho. Mas de qualquer forma, podemos depois, caso precise, adicionar, ou modificar as funções de tratamento de evento. Então não se preocupe. Você pode continuar a criar o indicador normalmente.

Figura 05 - Apenas clique em concluir.

Finalmente chegará o momento em que você irá ver a imagem da figura 05. Neste ponto você deverá criar apenas em concluir.

A ideia aqui, é criar um indicador que será lançado na janela ZERO. Mas os mesmos conceitos poderão ser utilizados, para lançar o indicador em qualquer janela. Mas novamente, não se preocupem com isto. Atentem-se a ideia principal que estará sendo colocada no artigo.

No final de todo este processo, na janela do MetaEditor, você irá ver o seguinte código:

#property copyright "Daniel Jose"
#property link      ""
#property version   "1.00"
#property indicator_chart_window
//+------------------------------------------------------------------+
//| Custom indicator initialization function                     |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- indicator buffers mapping
   
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                           |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const int begin,
                const double &price[])
  {
//---
   
//--- return value of prev_calculated for next call
   return(rates_total);
  }
//+------------------------------------------------------------------+

Sei que muitos não gostam, ou preverem usar a formatação feita pelo próprio MetaEditor. Tudo bem, mas para mim, esta formatação é menos agradável de ser utilizada. Mas isto é uma questão pessoal. O que realmente importa é que você consiga ler facilmente o seu código e o entenda.

Então vamos começar a modificar este código padrão, para o que realmente precisamos.

Se você tentar compilar este código padrão, irá receber um aviso.

Figura 06 - Saída do compilador.

Apesar de na figura 06, você poder notar que o código foi compilado. Ele não foi totalmente criado, de maneira correta. Muitos programadores, simplesmente ignoram o fato do compilador está alertando para uma falha. Esta pode ser vista na SETA VERMELHA.

O fato de ter acontecido uma falha, mesmo uma aparentemente não catastrófica, pode vim a colocar o código em RISCO. Então você não deve, em hipótese alguma, usar um código que foi notificado pelo compilador, como tendo uma falha. NUNCA faça isto.

Para corrigir esta falha, iremos fazer algo bem simples. Dizer ao compilador que estamos cientes do que o indicador estará fazendo.

#property copyright "Daniel Jose"
#property link      ""
#property version   "1.00"
#property indicator_chart_window
#property indicator_plots 0
//+------------------------------------------------------------------+
int OnInit()
{
        return INIT_SUCCEEDED;
}
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
{
        return rates_total;
}
//+------------------------------------------------------------------+

Ao adicionarmos a linha em destaque. Estaremos informando ao compilador que estamos cientes do que estamos de fato fazendo. Com isto o resultado será o que é visto na figura 07.

Figura 07 - Resultado de uma compilação perfeita.

Sempre que você compilar um código, preste atenção e veja se o compilador está lhe informando exatamente a mesma coisa da figura 07. Somente assim você estará com um código perfeitamente compilado e sem problemas grosseiros.

Você pode pensar: Mas tudo isto já sabíamos. Ok. Mas quero deixar claro isto. Não quero ninguém reclamando que o sistema não estará funcionando, ou tendo um funcionamento inadequado por conta de alguma modificação. Quero incentivar a todos a modificarem e adaptarem o sistema a suas necessidades. E para fazer isto, você deve saber primeiro o básico. Ter uma base sólida e bem montada em termos de conhecimento e conceitos.

Agora que já temos o indicador basicão. Vamos criar o EA também basicão.

Começando a construir o Expert Advisor

Agora vamos fazer o seguinte, vamos construir um EA para que possamos colocar em prática o que precisamos. Para fazer isto, vamos seguir o passo a passo.

Figura 08 - Indicando o que iremos construir.

Figura 09 - Definindo o diretório a ser usado.

Figura 10 - Definindo o nome do executável.

Como você pode notar, estamos fazendo o mesmo passo a passo que foi feito na fase do indicador. A única diferença é com relação a escolha que fizemos no inicio da criação.

Figura 11 - Deixaremos tudo como padrão.

Figura 12 - Aqui apenas clicamos em Concluir.

Quando este passo a passo estiver sido executado, você irá ter no MetaEditor um arquivo como mostrado abaixo:

#property copyright "Daniel Jose"
#property link      ""
#property version   "1.00"
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---
   
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---
   
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//---
   
  }
//+------------------------------------------------------------------+

Da mesma forma que foi feito no indicador, aqui também irei fazer algumas mudanças na formatação. Mas diferente do indicador, ao pedir para o MetaEditor compilar este código, você irá receber a seguinte informação vinda do compilador.

Figura 13 - Resultado do pedido de compilação.

Você pode estar pensando: Mas onde você quer chegar com isto ?!?! Calma, meu caro leitor. Calma. Você logo irá entender o que iremos fazer. Calma.

Agora que já temos um sistema básico, tanto para o Indicador, quanto para o EA. Vamos começar a fazer o que viemos fazer neste artigo. Os interligar.

Muito mais importante do que saber como criar um indicador, ou criar um EA. Saber como fazer os dois conversarem entre si, e trabalharem juntos, faz toda a diferença. Muitas pessoas sabem o básico, do básico. Isto permite você usar um indicador a fim de que o EA possa utilizar os dados calculados pelo indicador. 

Se você não sabe como fazer isto, sugiro fortemente, que primeiro procure aprender como fazer isto. Um ponto de partida pode ser olhar este artigo: Desenvolvendo um EA de negociação do zero (Parte 10): Acessando indicadores personalizados. Nele é abordado de uma maneira bastante simples, como você faz para acessar os valores calculados pelo indicador. Ao mesmo tempo, mostro como você faz para inicializar o indicador de uma forma bem simples. Antes mesmo de poder acessar qualquer tipo de informação que foi calculada, com base no que você pretende fazer.

Tudo isto é muito lindo e simples, pois usando a ideia da figura 14 você pode ler o conteúdo de um indicador. Agora usando a figura 15 você pode criar o indicador, usando para isto o EA.

Figura 14 - EA lendo o indicador.

Figura 15 - Criando o indicador pelo EA.

Mas apesar disto, esta forma de se trabalhar não funciona quando precisamos fazer algo como foi feito usando o Chart Trader. Quando fizemos a transformação do Chart Trader em um indicador, tivemos que utilizar um outro caminho. Isto na época, e mesmo lá, já havia menção de que aquilo iria ser modificado no futuro. Lá usamos algo que pode ser visto na figura 16.

Figura 16 - Comunicação bidirecional.

Quando existe a necessidade de transferir informações entre partes diferentes, ou melhor dizendo, processos diferentes, precisamos de algum meio para isto. No MetaTrader 5 podemos, em primeira instância, fazer uso de variáveis globais de terminal. Este mesmo conceito está sendo utilizado, e isto de longa data no sistema de replay / simulação. Isto a fim de poder fazer com que o serviço possa de alguma maneira se comunicar com o indicador.

Existem outras formas de promover esta mesma comunicação. Mas não quero, e não pretendo fazer uso de técnicas, que não me favoreça poder usufruir integralmente, do que o MQL5 e o MetaTrader 5 tem a oferecer. Quando fazemos uso da plataforma e da linguagem da mesma de maneira bastante profunda, podemos nos beneficiar com qualquer melhoria que elas venha no futuro a sofrer. Se você começar a inventar soluções, que não usem de forma completa o que nos é ofertado, como pode vim a se beneficiar, caso o MQL5, ou mesmo o MetaTrader 5, venham a ficar melhores ?!?!

Apesar do sistema visto na figura 16, ser bastante adequado em diversas situações. O mesmo não nos favorece muito.

Para entender isto, vamos tentar entender o seguinte fato: Quantos indicadores de fato iremos precisar colocar no gráfico, de modo a ter uma boa, e adequada experiência no sistema de replay / simulador ?!?! Um. Dois. Cinco. A verdade é que de fato não é possível saber. Mas já sabemos o seguinte: Precisaremos de no mínimo dois indicadores. E isto é pra já. Não é para depois. É para agora. Precisamos de no mínimo dois indicadores, no sistema de replay / simulador.

Você pode estar se indagando: Mas como assim ?!?! Bem, o primeiro indicador é o usado para controlar o replay / simulador. Este vem nos acompanhando já a um bom tempo. Agora precisaremos de outro: O Chart Trader. Isto para nos permitir enviar ordens diretamente. E o motivo de precisarmos do Chart Trader, é que diferente do mercado físico, aqui no replay / simulador. Aqueles botões que ficam no canto superior ( figura 17 ), são completamente inúteis, para nos.

Figura 17 - Botões de Trader Rápido.

Precisamos de fato de alguma forma de enviar ordens. Mas precisamos que ela seja igual, tanto no replay / simulador, quanto no caso de você estiver utilizando uma conta DEMO ou REAL. A forma de interagir com a plataforma tem que ser a mesma.

Então apesar da figura 16, nos permitir fazer uma comunicação entre o EA e o Indicador, a fim de poder enviar ordens. Ela está longe de ser a melhor das forma. O principal fato, é o de que precisamos manter variáveis globais de terminal. Estas podem ser melhor utilizadas para outras coisas. Podemos fazer um caminho bastante diferente, a fim de promover esta mesma comunicação que precisamos.

Com isto em mente, partimos para um nova abordagem. Esta pode ser vista na figura 18.

Figura 18 - Novo protocolo de comunicação.

Observando esta figura você logo pensa: " Tu tá maluco ?!?! Como você irá fazer com que o EA e o Indicador se comuniquem diretamente ?!?! Onde está a pegadinha nesta história ?!?! ". Não, não existe pegadinha. E não, não estou maluco. O fato é que existem formas e meios de se fazer esta comunicação diretamente. Isto pode ser visto nas figuras 14 e 15. Mas além daqueles meios, ainda temos outro a nossa disposição. O que precisamos de fato é entender como fazer o melhor uso possível destes mesmo meios.

Antes de prosseguirmos, deixe-me perguntar uma coisa: Você já tentou, ou experimentou o MetaTrader 5, de uma forma fora do que todos costumam usá-lo ?!?! Você já tentou, ou experimentou a linguagem MQL5 a ponto de falar o seguinte: Ela bem que poderia permitir fazer isto. Se para qualquer uma destas duas perguntas a resposta foi NÃO. Então lhe convido a ver e a entender até onde vai a toca do coelho.

Iniciando a comunicação entre processos.

Como deve ter ficado claro, nos tópicos anteriores. Aqui iremos construir uma forma de efetuar a comunicação entre um indicador e um EA, de maneira que eles não precisam, salvo em casos especiais, fazer uso das variáveis globais de terminal. Isto para que possam trocar informações.

A ideia não é complicada. O conceito menos ainda. No entanto, sem compreender alguns detalhes, você não, e repito: NÃO irá ter sucesso. É preciso que você compreenda muito bem o que irei explicar. Não fique apenas imaginando que já sabe como programar em MQL5. Pois o que irei explicar, extrapola os limites de uso normal e convencional, tanto do MetaTrader 5, quanto da linguagem MQL5.

Para começar precisamos, e devemos seguir algumas coisas. Estas seriam como se fossem um protocolo. Não importa o que você ache, ou imagine. Siga o caminho, e os resultados serão obtidos. Desvie do mesmo e você fatalmente irá fracassar, miseravelmente.

Então no código do indicador, iniciamos adicionando as primeiras linhas conforme pode ser visto abaixo.

 1. #property copyright "Daniel Jose"
 2. #property link      ""
 3. #property version   "1.00"
 4. #property indicator_chart_window
 5. #property indicator_plots 0
 6. //+------------------------------------------------------------------+
 7. #define def_ShortName       "SWAP MSG"
 8. #define def_ShortNameTmp    def_ShortName + "_Tmp"
 9. //+------------------------------------------------------------------+
10. input double user00 = 0.0;
11. //+------------------------------------------------------------------+
12. long m_id;
13. //+------------------------------------------------------------------+
14. int OnInit()
15. {
16.     m_id = ChartID();
17.     IndicatorSetString(INDICATOR_SHORTNAME, def_ShortNameTmp);
18.     if (ChartWindowFind(m_id, def_ShortName) != -1)
19.     {
20.              ChartIndicatorDelete(m_id, 0, def_ShortNameTmp);
21.             Print("Only one instance is allowed...");
22.             return INIT_FAILED;
23.     }
24.     IndicatorSetString(INDICATOR_SHORTNAME, def_ShortName);
25.     
26.     return INIT_SUCCEEDED;
27. }
28. //+------------------------------------------------------------------+
29. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
30. {
31.     return rates_total;
32. }
33. //+------------------------------------------------------------------+

Você deve estar pensando: Mas que grande confusão é esta ?!?! Mas não. Não é nenhuma confusão. Aqui estou, forçando e obrigando o MetaTrader 5 a garantir, apenas e um único indicador no gráfico. Como ?!?! Simples. Estou testando vendo se o indicador já está ou não no gráfico.

Sempre que você desejar, forçar e obrigar o MetaTrader 5, a manter apenas e somente um único indicador no gráfico. Você deverá usar o código acima. Mas vamos entender como ele funciona. Para facilitar a explicação as linhas estão enumeradas. Assim irá ficar fácil acompanhar toda a explicação.

Na linha 7 definimos o nome que o nosso indicador irá de fato ter. Este nome será mantido pelo MetaTrader 5 durante todo o tempo que o indicador estiver no gráfico.

Para que este nome seja definido, usamos a rotina presente na linha 24. Aqui é que de fato definimos o nome que será usado pelo indicador. Mas por que definimos a linha 8 ?!?! O motivo é o fato de como o MetaTrader 5 trabalha.

Muitos talvez não tenha a devida ideia, de que o MetaTrader 5, é uma plataforma baseada em eventos. Já falei sobre isto em outros artigos. Então quando qualquer tipo de evento acontece. Seja um movimento no preço, a troca do tempo gráfico, um movimento do mouse, o pressionar de uma tecla, adicionar ou remover algo do gráfico. Não importa, eles irão fazer com que o MetaTrader 5, dispare algum tipo de evento. Cada tipo de evento tem um destino e uma consequência.

Quando o MetaTrader 5, dispara um evento de atualização. Todo e qualquer objeto, indicador, EA, entre outras coisa que podem esta presentes no gráfico, irão e deverão ser de alguma forma atualizados. No caso de scripts, eles são simplesmente expulsos do gráfico. No caso de indicadores e EA, estes tem uma nova chamada a função OnInit. Então caso qualquer coisa aconteça, e o indicador precise ser reatualizado do inicio. O MetaTrader 5 irá forçar uma chamada a linha 14. Qual o problema aqui ?!?! O problema é que, precisamos que o indicador tenha um nome curto, que seja reconhecido pelo MetaTrader 5. Caso contrário, não iremos poder fazer o teste visto na linha 18.

Você pode pensar: Então bastaria colocar a linha 24 antes da linha 18. Mas é justamente ai que mora o problema. Se você adicionar a linha 24 antes da linha 18, quando o código for verificar na linha 18, se o indicador se encontra no gráfico. Você terá um resultado positivo. Então ao executar a linha 20, o MetaTrader 5 iria expulsar o indicador do gráfico, quando na verdade queremos de fato que ele permaneça no gráfico. Mas queremos que apenas e somente uma instancia esteja presente.

Não sei se você está de fato conseguindo acompanhar o raciocínio. Mas justamente pelo motivo que foi explicado acima, precisamos de um nome temporário. Este nome é definido na linha 8, onde fazemos uma leve mudança no nome curto do indicador. Então antes de testar, na linha 18, se o indicador já se encontra no gráfico. Usamos a linha 17, para definir um nome temporário para o indicador. NOTA: Este nome deve ser de alguma forma único, caso contrário, teremos problemas.

Caso o indicador esteja presente no gráfico. A linha 18 irá permitir que a linha 20 seja executada, removendo assim, o indicador que está tentando entrar no gráfico. Para que o usuário saiba da falha, temos a linha 21, que irá imprimir uma mensagem na caixa de mensagem do MetaTrader 5. E na linha 22, o indicador irá retornar, indicando que não foi possível que ele fosse lançado no gráfico.

Caso o indicador de fato consiga ser lançado no gráfico, a linha 24 irá corrigir o nome do indicador. Assim não será possível lançar um novo indicador no gráfico. Isto a principio. Pois existe uma " brecha ". Tal brecha, na verdade não é bem uma brecha. Felizmente o MetaTrader 5, consegue diferenciar as coisas, a ponto de saber se estamos adicionando ou não um novo indicador no gráfico. Para entender isto, foi adicionado ao código, a linha 10.

Caso o usuário, NÃO MODIFIQUE, o valor da variável no momento de lançar o indicador no gráfico. E esta variável é declarada na linha 10. O MetaTrader 5 irá entender que o indicador é o mesmo que já está presente no gráfico. Isto se já houver algum presente. Se o usuário mudar o valor, o MetaTrader 5 poderá tomar duas decisões totalmente distintas:

• A primeira, é quando não existe um indicador, este será lançado no gráfico.
• A segunda, é quando já existe um indicador. Neste caso, se o valor indicado na variável, for diferente, do que se encontra no indicador já presente no gráfico. O MetaTrader 5 irá entender isto como sendo um outro indicador. Caso o valor seja idêntico, o MetaTrader 5 irá entender isto como sendo o mesmo indicador.

Desta forma você consegue travar o número de indicadores, com o mesmo nome, no gráfico. Isto para que o numero, seja de apenas e somente um. Caso você deseje colocar, e permitir que o numero máximo de indicadores, com o mesmo nome seja outro. Bastará modificar o teste que está sendo feito na linha 18. Desta maneira, você pode obrigar e forçar o MetaTrader 5, a aceitar, por exemplo 3 indicadores com o mesmo nome. Entretanto, se o usuário tentar colocar um quarto indicador, com o mesmo nome. O MetaTrader 5 irá proibir isto, mas não exatamente o MetaTrader 5, mas sim o código do Indicador. Pois ele irá impedir esta tentativa de colocar um quarto indicador.

Então como você pode ver, é sim possível travar e bloquear o sistema, a ponto de impedir que tenhamos indicadores duplicados no gráfico. Isto é importante e será bastante explorado depois. Nesta mesma sequencia sobre replay / simulador.

Neste código do indicador, existem algumas coisas que depois irei explicar com mais calma. Isto para que você possa entender como efetuar a comunicação entre o EA e o indicador, sem usar variáveis globais de terminal. Tais pontos são a linha 5 e a linha 10. Mas vamos com calma para que você de fato consiga entender, toda a lógica por de traz deste tipo de programação.

Para que você possa compreender o que de fato está acontecendo. Você pode criar o código que foi explicado acima em detalhes e colocar ele para rodar na plataforma MetaTrader 5.

Conclusão

Aqui, neste artigo mostrei como você faz para travar, ou bloquear o lançamento de mais de um indicador no gráfico. Você pode usar este conhecimento para promover diversas outras coisas. Isto além de facilitar e muito a sua vida, tanto como operador, quanto como usuário da plataforma MetaTrader 5. Também irá lhe trazer uma melhor experiência no uso da plataforma.

O motivo talvez não tenha fica de todo claro, neste artigo. Mas acredite, o conhecimento presente neste artigo. Se for bem usado e usado de uma maneira adequada irá permitir você fazer muito mais coisas. Evitando uma serie de dores de cabeça, por conta de ter indicadores duplicados, ou mesmo desnecessários no gráfico.

Não é raro um usuário menos experiente no uso do MetaTrader 5, colocar o mesmo indicador diversas vezes no gráfico. Tornando assim o uso, e configuração de tais indicadores duplicados algo extremamente desagradável. E tudo isto pode ser evitado usando um código, que como você viu é bastante simples, porém extremamente capaz de cumprir o que foi proposto a ele.

Espero que este conhecimento lhe ajude, e que você tenha o assimilado. Pois no próximo artigo, irei mostrar como podemos efetuar o próximo passo no que tange pavimentar a comunicação direta entre o EA e o Indicador. Algo indispensável para o que iremos precisar fazer no nosso sistema de replay / simulação.