Desenvolvendo um sistema de Replay (Parte 38): Pavimentando o Terreno (II)

Introdução

No artigo anterior, Desenvolvendo um sistema de Replay (Parte 37): Pavimentando o Terreno (I). Expliquei e mostrei como você pode, de uma maneira super simples, evitar que o usuário possa duplicar um indicador no gráfico. Lá no artigo, mostrei que usando um código bastante simples e com poucas linhas. A plataforma MetaTrader 5 iria nos ajudar a evitar que um indicador, que desejamos ter apenas e somente um no gráfico. De fato não viesse a ser duplicado.

É importante que você tenha compreendido, aquele conteúdo. Mas o principal é que você entenda como foi conseguido obter o resultado que era desejado. O de não permitir em hipótese alguma que um indicador fosse duplicado.

Mas o simples fato, de forçar, e obrigar o MetaTrader 5 a não permitir que um indicador seja duplicado. Não nos dá de maneira alguma meios de efetivar uma comunicação bilateral entre o indicador e o EA. Ainda estamos um pouco longe disto. Mas o simples fato de que o indicador não estará duplicado no gráfico, já nos garante uma certa tranquilidade. Isto por conta que quando ocorrer a interação entre o indicador e o EA, saberemos que estaremos tratando do indicador correto.

Neste artigo vamos começar a ver a coisa pelos olhos do EA. Mas também iremos precisar fazer algumas coisas no indicador. Pois aquele que está no artigo anterior, infelizmente, não consegue de forma alguma responder ao EA. Isto quando o EA desejar saber algo.

Criando a primeira comunicação entre processos.

Para que você de fato consiga compreender o que estará acontecendo. Precisamos criar alguns pontos de verificação. Vamos começar com o código do indicador, mas não se preocupe, tais pontos serão simples de serem compreendidos.

O código do indicador pode ser visto na integra logo abaixo:

01. #property copyright "Daniel Jose"
02. #property link      ""
03. #property version   "1.00"
04. #property indicator_chart_window
05. #property indicator_plots 0
06. //+------------------------------------------------------------------+
07. #define def_ShortName       "SWAP MSG"
08. #define def_ShortNameTmp    def_ShortName + "_Tmp"
09. //+------------------------------------------------------------------+
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.     Print("Indicator configured with the following value:", user00);
26.     
27.     return INIT_SUCCEEDED;
28. }
29. //+------------------------------------------------------------------+
30. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
31. {
32.     return rates_total;
33. }
34. //+------------------------------------------------------------------+

Observe que a única adição ao código, é justamente a linha 25. Esta é que será a nossa linha de verificação. Pelo menos neste primeiro momento. O nosso interesse neste momento é verificar como o EA estará, e poderá enviar informações ou dados para dentro do indicador.

Um detalhe a ser notado: Observem que na linha 10, o tipo de informação esperado pelo indicador é um tipo double. Isto é feito de forma proposital, já que a intenção é de fato criar um mecanismo, que venha e possa, substituir o sistema de variáveis globais de terminal. Isto para fins de comunicação entre o EA e o indicador. Caso tal meio que está sendo desenvolvido, ou implementado, se mostre inadequado. Não teremos um grande trabalho, para substituir este modelo, que esta sendo implementado, pelo modelo de variáveis globais de terminal.

Mas nada impede, e de maneira alguma que você possa utilizar outros tipos de dados a fim de promover a comunicação. Pelo menos no que rege a transferência de dados do EA para o Indicador.

Agora que já modificamos o código do indicador. Podemos passar para o código do EA, este pode ser visto na integra logo abaixo:

01. #property copyright "Daniel Jose"
02. #property link      ""
03. #property version   "1.00"
04. //+------------------------------------------------------------------+
05. input double user00 = 2.0;
06. //+------------------------------------------------------------------+
07. int m_handle;
08. long m_id;
09. //+------------------------------------------------------------------+
10. int OnInit()
11. {
12.     m_id = ChartID();
13.     if ((m_handle = ChartIndicatorGet(m_id, 0, "SWAP MSG")) == INVALID_HANDLE)
14.     {
15.             m_handle = iCustom(NULL, PERIOD_CURRENT, "Mode Swap\\Swap MSG.ex5", user00);
16.             ChartIndicatorAdd(m_id, 0, m_handle);
17.     }
18.     Print("Indicator loading result:", m_handle != INVALID_HANDLE ? "Success" : "Failed");
19.     
20.     return INIT_SUCCEEDED;
21. }
22. //+------------------------------------------------------------------+
23. void OnDeinit(const int reason)
24. {
25.     ChartIndicatorDelete(m_id, 0, "SWAP MSG");
26.     IndicatorRelease(m_handle);
27. }
28. //+------------------------------------------------------------------+
29. void OnTick()
30. {
31. }
32. //+------------------------------------------------------------------+

Para muitos este código do EA pode ser algo bem estranho. Então vamos dar uma olhada com calma no como ele funciona. Prestem atenção, pois esta é a primeira fase do que realmente precisamos fazer.

Na linha 05, damos ao usuário uma forma, ou meio de ajustar o valor a ser repassado para o indicador. Lembre-se: Queremos testar e entender como a comunicação estará se dando. Já a linha 07 e 08 são duas variáveis globais internas do código do EA. Normalmente não gosto de usar variáveis globais. Mas neste caso posso abrir uma exceção. O conteúdo destas variáveis será definido dentro do código que trata do evento OnInit, que se inicia na linha 10.

Deste ponto em diante, muitos irão dizer: "Chegou a hora da porca torcer o rabo.". E o motivo é que neste ponto precisamos compreender algumas coisas.

Na linha 12 inicializamos de maneira adequada, a variável que irá indicar o index da janela gráfica onde o EA se encontra. Mas na linha 13, começa os problemas por parte de quem está iniciando. Muitas pessoas, simplesmente não adicionam esta linha 13 em seus código. O que de certa forma é um erro. Não que seja um dos graves, que irá quebrar o seu código logo de cara. Não, mas o fato de você colocar a linha 13 no código, evita que tenhamos alguns tipos de falhas. E muitas destas falhas são do tipo RUN-TIME, ou seja em tempo de execução. Podem acontecer a qualquer momento. O que as torna complicadas de serem corrigidas.

O fato de usarmos este código na linha 13, faz com que caso o MetaTrader 5, já conte com o indicador que queremos no gráfico. Este retorne para nos o handle ( manipulador ) deste mesmo indicador. Assim não precisamos executar responsável por colocar o indicador no gráfico.

Mas caso a linha 13 indique que o gráfico não contenha o indicador desejado. Passaremos a executar o código que irá adicionar o indicador no gráfico. Lembrando do seguinte fato: O indicador que queremos e iremos usar é um indicador customizado. Por este motivo iremos utilizar a chamada iCustom, isto pode ser visto na linha 15.

Agora vem a parte complicada de toda esta história. Por que iCustom, presente na linha 15, está sendo declarada daquela forma ?!?! Você tem alguma ideia do motivo ?!?! Pois bem, para entender vamos ver o que a documentação nos diz:

int  iCustom(
                 string            symbol,   // símbolo nome
                 ENUM_TIMEFRAMES   period,   // período
                 string            name      // folder/nome_do_indicador_personalizado
                 ...                         // lista de parâmetros de entrada do indicador
             );

Você pode notar, com base no quadro acima, de que o primeiro parâmetro da função, é no nome do símbolo. Mas na linha 15 do código, o primeiro parâmetro é um valor NULL. Por que disto ?!?! Por que não usei a constante _Symbol ?!?! O motivo é que para o compilador, ambos dados, tanto NULL, quando _Symbol, são a mesma coisa. Desta forma o indicador irá ser criado usando o mesmo símbolo, ou ativo que estiver no gráfico do EA.

O próximo parâmetro da lista é o tempo, ou período gráfico. Mais uma vez temos algo diferente do que muitos esperariam. Na linha 15, usamos o valor PERIOD_CURRENT, mas por que ?!?! O motivo é que quero que o indicador permaneça sincronizado com o mesmo período do EA. Um detalhe: Caso você queira o indicador observando outro período gráfico, bastará indicar o período desejado aqui, neste parâmetro. Assim o indicador irá ficar travado em um período especifico, enquanto o EA poderá fluir entre períodos diferentes.

Quando se trata de indicadores customizados, acredito que o bicho realmente pega, é neste terceiro parâmetro. Muitos não sabem o que colocar aqui, em outros momentos acabam desistindo por não entender, ou indicar um local errado. Se você colocar um local errado, o MetaTrader 5, não irá conseguir encontrar o indicador que você está desejando utilizar.

Observem o que esta sendo declarando na linha 15, neste terceiro parâmetro. Estou indicando, não apenas um nome, mas um nome com um caminho. De onde vem esta informação ?!?! Para saber isto é preciso retornar no artigo anterior, a fim de saber de onde está vindo esta informação. Observem a figura 01.

Figura 01 - Criando o indicador

Nesta figura 01, você pode ver de onde veio a informação que se encontra no terceiro parâmetro. Observem que é praticamente a mesma coisa. Com as seguintes modificações: Primeiro suprimimos o diretório raiz, neste caso: Indicators. Isto por conta que o MetaTrader 5 irá primeiramente procurar o indicador justamente neste diretório. O segundo ponto é que adicionamos a extensão .ex5. Assim temos a correta localização do arquivo executável. Quando o MetaTrader 5 for lançar o EA no gráfico, e executar a linha 15, o MetaTrader 5 saberá onde, e qual o indicador a ser usado.

Depois iremos ver algumas questões relacionadas a isto, e problemas também que podem acontecer. Mas primeiro vamos nos ater ao básico.

A partir deste terceiro parâmetro, qualquer outro parâmetro, será opcional. Caso você queira usar, ou enviar algum valor para o indicador, deverá fazer isto a partir do quarto parâmetro. Mas você deve tocar o cuidado e fazer isto na mesma sequencia que os parâmetros aparecem no indicador. Tomando também o cuidado de que eles sejam do mesmo tipo. Você não deve colocar um valor double, quando o indicador espera receber um valor float, ou long. Se fizer isto, o MetaTrader 5 irá disparar um erro assim que o indicador for lançado.

Existe outra forma de enviar os parâmetros para dentro do indicador. Mas por enquanto, e para simplicidade, vamos usar a chamada iCustom. Então se você olhar no código do indicador, irá ver que na linha 10, é esperado um valor double. Este valor é lançado para o indicador via EA, no quarto parâmetro da linha 15 do código do EA.

Agora um questão importante. Porém negligenciada por muitos, e que faz todo sistema ter problemas. Isto é a linha 16, do código do EA. Por que esta linha é tão importante ?!?!

Existem casos em que esta linha pode ser ignorada. Mas quando estamos tratando de indicadores customizados. Mas principalmente, de indicadores que queremos e desejamos, forçar e obrigar o MetaTrader 5, a manter apenas e somente uma única instancia do mesmo sendo colocada no gráfico. Não podemos de forma, ou maneira alguma ignorar ou negligenciar a linha 16, e quando a linha 16 estiver presente, você obrigatoriamente também terá que adicionar a linha 25.

Estas duas linhas evitam que tenhamos problemas. A linha 16, irá jogar o indicador no gráfico. Desta forma, caso o usuário tente jogar mais um instância do indicador no mesmo gráfico. O MetaTrader 5, juntamente com o código do indicador, irá proibir que uma nova instancia seja de fato lançada. Se a linha 16 for removida do código do EA. O usuário irá poder inadvertidamente lançar uma nova instancia do indicador no gráfico, ficando assim, não o EA, mas o usuário confusos quanto as questões envolvidas nos cálculos executados pelo indicador.

No caso de um indicador de cálculo, você terá um tipo de problema. No entanto, no caso de um indicador como o Chart Trader, o problema será ainda mais complicado. Já que neste caso estaremos tratando de objetos gráficos. Mas vamos com calma, iremos chegar ainda neste ponto. Vamos primeiro entender como fazer as coisas de maneira correta. E de forma adequada. Assim você irá de fato entender como fazer coisas mais complexas.

Então tudo bem, acredito que você tenha compreendido, pelo menos por hora, a importância da linha 16. E a linha 25, o que ela faz ?!?! Esta linha 25, ela irá remover do gráfico o indicador que estamos informando. Observem uma coisa: Você precisa saber o nome do indicador a ser removido. Este nome é colocado no indicador na linha 24 do código do indicador. Estes nomes tem que ser idênticos, caso contrário o MetaTrader 5, não saberá qual indicador remover. Além deste fato, em alguns casos precisamos também informar qual é a sub janela. Como não estamos usando uma sub janela, este valor é deixado como sendo ZERO.

Agora na linha 26, removemos, ou melhor dizendo, destruímos o handle do indicador. Isto por que não precisamos mais dele de forma alguma.

Vamos então ver como o MetaTrader 5 lida com este esquema de comunicação entre o Expert Advisor e o Indicador. Para entender isto, será preciso que você faça algumas coisas. Então preste bastante atenção aos detalhes do que deverá ser feito. E a cada modificação teste e experimente os código gerados. Pois cada uma das mudanças trará uma forma diferente do MetaTrader 5 lidar com elas. Muito mais do que simplesmente ler as explicações acima, está a necessidade de você compreender o que está acontecendo. Existem três situações a serem vistas. Isto para que você entenda o que acontece, quando você o código do Expert Advisor é feito de uma dada maneira. Ou quando você programa o mesmo Expert Advisor de criado de uma outra maneira. O código usado, tanto no Expert Advisor quanto no indicador, são os mesmo que estou explicando até este momento. A única diferença está no conteúdo, ou melhor, na presença ou ausência de alguma linha de código do Expert Advisor.

Vamos então faça o seguinte:

• Primeiro, compile o código com todas a linhas. E veja como o sistema trabalha no MetaTrader 5.
• Depois, retire as linha 16 e 25, e volte a experimentar o sistema no MetaTrader 5.
• E finalmente, remova apenas a linha 16, e mantenha a linha 25. Volte a testar o sistema.

Você pode estar pensando que tudo isto é bobagem. Que você sendo um programador experiente não irá de modo algum, cometer tais falhas. Mas saber o que cada uma das linhas de código fazem, e provocam quando executadas pelo MetaTrader 5. Talvez seja muito mais importante do que parece.

Se você chegou neste ponto, e conseguiu compreender esta segunda fase, onde já temos como passar dados do EA para dentro do Indicador. E isto sem usar as variáveis globais de terminal. Você estará fazendo um ótimo progresso, em direção a se tornar um programador de qualidade. Se você ainda não compreendeu, não desanime. Retorne ao começo, deste ou do artigo anterior e tente entender esta etapa. Pois agora a coisa irá realmente complicar pra valer. E não estou brincando. De fato ela irá complicar pra valer. Pois agora iremos fazer com que o Indicador envie dados para dentro do EA.

Esta parte onde o indicador envia dados para dentro do EA. Pode ser simples em alguns casos. Isto é verdade. Mas quem vem acompanhando meus artigos, já deve ter notado que gosto de levar as coisas a um extremo. Gosto de fazer o computador suar e implora para que as coisas sejam feitas de uma outra maneira. Mas sou bastante ferrenho em fazer, tanto a linguagem, quanto a plataforma trabalhar no limite do que é possível.

IndicadorCreate ou iCustom. Qual usar ?!?!

Existe uma questão que assombra muitos iniciantes. Esta questão se relaciona ao que utilizar para chamar seus indicadores customizados. Existem duas formas de se fazer isto. A primeira foi vista no tópico anterior, onde expliquei o uso da chamada iCustom. Mas existe também uma outra forma. E não poderia negligenciar a mesma, dada a sua igual importância. Isto por conta que em alguns tipos de modelagem, ela é mais atraente. Enquanto em outros o uso da chamada iCustom já nos será o bastante.

A questão aqui, não é, e nem será dizer para você usar um método, ou outro. A questão é mostrar como você pode fazer uso da chamada IndicadorCreate, a fim de conseguir também carregar seus indicadores customizados.

Antes de começarmos, vamos entender uma coisa, e isto de forma definitiva. A função IndicadorCreate, não é uma função especial. Não, ela na verdade é uma função base. E o que isto quer de fato dizer ?!?! Uma função base, é aquela que em essência serve para promover outra funções. Mas com um detalhe: As funções "derivadas" fazem uso da função base, mas tornando o uso da função base mais simples.

Este tipo de coisa é conseguida, ao não ser preciso modelar a chamada, como seria esperado pela função base. Você pode usar uma modelagem mais simples, e agradável. Desta forma surge outras funções. Estas podem ser vista na documentação como sendo os Indicadores técnicos. Entre estes indicadores está o iCustom, que seria de fato uma função derivada, a fim de tornar a modelagem mais simples.

Mas então com ficaria o código do fonte do EA visto no inicio deste artigo, se ao invés de usar iCustom, usamos a IndicadorCreate ?!?! Bem, o código pode ser visto logo abaixo:

01. #property copyright "Daniel Jose"
02. #property link      ""
03. #property version   "1.00"
04. //+------------------------------------------------------------------+
05. input double user00 = 2.2;
06. //+------------------------------------------------------------------+
07. int m_handle;
08. long m_id;
09. //+------------------------------------------------------------------+
10. int OnInit()
11. {
12.     MqlParam params[];
13.     
14.     m_id = ChartID();       
15.     if ((m_handle = ChartIndicatorGet(m_id, 0, "SWAP MSG")) == INVALID_HANDLE)
16.     {
17.             ArrayResize(params, 2);
18.             params[0].type = TYPE_STRING;
19.             params[0].string_value = "Mode Swap\\SWAP MSG";
20.             params[1].type = TYPE_DOUBLE;
21.             params[1].double_value = user00;
22.             m_handle = IndicatorCreate(NULL, PERIOD_CURRENT, IND_CUSTOM, ArraySize(params), params);
23.             ChartIndicatorAdd(m_id, 0, m_handle);
24.     }
25.     Print("Indicator loading result:", m_handle != INVALID_HANDLE ? "Success" : "Failed");
26.     
27.     return INIT_SUCCEEDED;
28. }
29. //+------------------------------------------------------------------+
30. void OnDeinit(const int reason)
31. {
32.     ChartIndicatorDelete(m_id, 0, "SWAP MSG");
33.     IndicatorRelease(m_handle);
34. }
35. //+------------------------------------------------------------------+
36. void OnTick()
37. {
38. }
39. //+------------------------------------------------------------------+

Código fonte do Expert Advisor

Observem e comparem as diferenças entre este código acima, com o visto no inicio do artigo. Ambos fazem exatamente a mesma coisa. A grande questão é: Por que este código usando a chamada IndicadorCreate, precisa ser feita desta forma ?!?!

No bem da verdade, a função iCustom, oculta justamente o que precisamos fazer. Mas vamos entender então o que está acontecendo.

Primeiramente precisamos declarar uma variável. Esta é declarada na linha 12, sendo um array. Notem que precisamos que seja feita desta forma. Caso o indicador não se encontre presente no gráfico, precisamos criá-lo. Para fazer isto precisamos dizer de alguma forma a função IndicadorCreate, o que e como deverá ser feita as coisas.

Independentemente do numero de parâmetros que iremos usar no indicador. Precisaremos dizer a função IndicadorCreate, qual o nome do indicador. Então se iremos informar apenas e somente o nome do indicador. A função ArrayResize, presente na linha 17, deverá alocar não duas, mas uma posição. Se tivermos que passar 5 parâmetros para o indicador, teríamos que alocar 6 posições. Será sempre assim. Olhe quantos parâmetros teremos que enviar, e aloque uma posição a mais.

Uma vez entendido isto, vamos então configurar o array. Por conta que na linha 22, estamos informado a função IndicadorCreate, que iremos usar um indicador customizado. Isto é feito usando a enumeração IND_CUSTOM. Precisaremos e devemos fazer algumas coisas. Na linha 18, vemos como deveremos proceder para a primeira posição do array. Lembre-se MQL5 deriva do C++, então começamos a contar a partir do ZERO. O tipo de informação, presente na primeira posição, deverá ser do tipo STRING. Por conta disto que a declaração é feita daquela forma vista na linha 18.

Já na linha 19, iremos informar o nome do indicador customizado a ser utilizado. Atenção: Observem que o nome do indicador é o mesmo que seria utilizado, caso você fosse usar a chamada iCustom. A diferença aqui, é que não estamos indicando a extensão do arquivo. É pressuposto que o arquivo será um executável, assim a extensão será .ex5. Desta maneira, indicar a extensão é opcional.

IMPORTANTE: O que foi feito na linha 18 e 19, deverá sempre ser feito caso você esteja usando um indicador customizado. Caso você esteja utilizando qualquer outro indicador, seja ele qual for. Você já deverá, a partir do inicio da configuração dos dados do array, indicar os parâmetros conforme será visto a partir de agora. Ou seja, a partir da linha 20.

Agora que já expressamos para a função IndicadorCreate, qual será o indicador customizado a ser usado. Vamos começar a preencher os parâmetros, a serem passados para ele. Estes parâmetros deve, obrigatoriamente, serem declarado na ordem correta. Independente do indicador que você irá usar. Trocar tipos, ou declarar tipos errados, irá gerar erros de RUN-TIME. Então tenha bastante atenção e calma ao preencher estes dados.

Na linha 20, indicamos que o primeiro parâmetro será do tipo double. Mas ele poderia ser qualquer um entre os tipos definidos na enumeração ENUM_DATATYPE. Qualquer um, entre eles pode ser utilizado, mas existe alguns cuidados.

De forma simplificada, e isto simplificando bem as coisas. Os tipos TYPE_DOUBLE e o TYPE_FLOAT, irão usar, no caso isto seria feito na linha 21, double_value.

Caso na linha 20, fosse usado o tipo TYPE_STRING, na linha 21, iriamos lançar o valor na variável string_value. Para qualquer outro tipo, dentre os possíveis, que vier a ser declarado na linha 20. Você iria lançar o valor na linha 21, usando a variável integer_value.

E já que isto é importante, e quero deixar bem claro esta informação. Veja a tabela abaixo para compreender melhor.

Identificador usado	Tipo de dado	Onde lançar o valor
TYPE_BOOL	Boolean	integer_value
TYPE_CHAR	Char	integer_value
TYPE_UCHAR	Unsigned Char	integer_value
TYPE_SHORT	Short	integer_value
TYPE_USHORT	Unsigned Short	integer_value
TYPE_COLOR	Color	integer_value
TYPE_INT	Integer	integer_value
TYPE_UINT	Unsigned Integer	integer_value
TYPE_DATETIME	DateTime	integer_value
TYPE_LONG	Long	integer_value
TYPE_ULONG	Unsigned Long	integer_value
TYPE_FLOAT	Float	double_value
TYPE_DOUBLE	Double	double_value
TYPE_STRING	String	string_value

Tabela de correspondência.

Esta tabela acima, mostra claramente o que você estará utilizando na linha 20 ( Identificador a ser usado ). E qual será a variável que irá receber o valor, isto na linha 21. Você deverá fazer isto para cada um dos parâmetros a serem passados para o seu indicador customizado. Já que aqui estamos usando, e iremos passar apenas um parâmetro, então iremos trabalhar somente com ele.

Notem com é bem mais trabalhoso, usar a chamada IndicadorCreate, do que usar a sua derivada, que é a iCustom. Isto para no nosso caso especifico.

Uma vez que todos os parâmetros, que queremos definir, tenham recebido as devidas definições. Chegaremos na linha 22, onde de fato iremos fazer a chamada a função. Observem que faço isto de uma maneira que poderei, aumentar ou reduzir as coisas muito facilmente. Todos os campos são preenchidos de maneira que não irei precisar reeditar esta linha 22. Isto caso, precise trocar o indicador, ou mudar o numero de parâmetros.

A ideia é sempre simplificar as coisas e nunca as complicar.

Por conta deste trabalho maior, a fim de conseguir estabelecer o mesmo tipo de execução por parte do MetaTrader 5. Nos códigos de fato, você não irá me ver usando frequentemente, a função IndicadorCreate. Mas nada impede de você fazer uso da mesma.

Antes de terminamos este artigo. Gostaria de falar rapidamente sobre uma outra função: IndicatorParameters. Esta função, IndicatorParameters, serve para nos ajudar a verificar, por assim dizer, algo sobre um indicador desconhecido. Para entender, vamos supor que você tenha no seu gráfico diversos indicadores diferentes. Cada um sendo inicializado de uma determinada forma. Pode ser que você deseje automatizar algum tipo de estratégia, baseada em indicadores. Mas por conta que o mercado mude de forma repentina, você pode vim a demorar alguns minutos até ajustar todos os indicadores de maneira correta.

Para agilizar um pouco as coisas, fazemos uso da função IndicatorParameters. Uma vez que executemos a chamada a esta função. O MetaTrader 5, irá preencher esta função de maneira que possamos saber, como especificamente, um dado indicador está configurado. Com base em algumas outras analises, você então usando uma outra função, normalmente a IndicadorCreate, modifica a forma com um dado indicador está configurado. Se o EA, estiver usando este indicador para efetuar compra ou venda, ele imediatamente irá saber o que fazer. Isto por conta que teremos um gatilho sendo executado.

Esta questão foi amplamente explorada, e demonstrada. Isto dentro do possível, na sequencia sobre automação. Para ser mais especifico no artigo Aprendendo a construindo um EA que opera de forma automática (Parte 15) - Automação (VII), demonstro como fazer o uso de um indicador, como forma de disparar o gatilho de compra ou venda.

Mas como acabei de falar, você pode usar a função IndicadorParameters, como uma forma de tornar, aquele mesmo tipo de EA, ainda mais interessante. No entanto não iremos explorar o uso da função IndicadorParameters. Pelo menos não nesta sequencia sobre o sistema de replay / simulador. Apenas gostaria de ter mencionado a real utilidade desta função. Isto para aqueles que desconhecem a sua finalidade.

Conclusão

Aqui neste artigo, demonstrei da forma que fosse o mais simples possível, como enviar dados para o indicador. Apesar de ter feito isto usando um EA, você pode usar outros tipos de processos, como por exemplo: Scripts. Se bem que seria muito bom, mas até o presente momento, em que escrevo este artigo, não ser possível. Ter a possibilidade de usar Serviços como uma forma de fazer este mesmo trabalho. Isto dada as características envolvidas na questão de serviços.

Mas tudo bem. Temos que trabalhar com o que temos em mãos. No entanto, este assunto ainda não foi totalmente finalizado. Ainda é preciso ver como enviar dados do indicador para o EA. Isto no nosso caso. Mas diferente do que você possa estar imaginando. Isto não será assim como você normalmente vê, ou já conhece. Lembre-se: Queremos uma forma de usar o Chart Trader no sistema de replay / simulação. Mas não queremos precisar usar para isto variáveis globais de terminal. E tão pouco queremos compilar diversos programas, correndo o risco de esquecer de compilar algum.

Para saber como iremos chegar, próximos do que precisamos para o Chart Trader, iremos precisar de um outro artigo. E este será o tema principal do próximo artigo. Entender como nos aproximar do que precisamos, para poder criar o Chart Trader.

Não perca o próximo artigo. Pois o assunto será bem interessante e empolgante, se ser visto e explicado.