Aprendendo a construindo um EA que opera de forma automática (Parte 01): Conceitos e estruturas

Introdução

A algum tempo, diversas pessoas lendo meus artigos sobre como construir um EA do zero, tem me procurado para que fosse feito um EA para eles, ou que lhes dê-se algum tipo de assessória, a fim de que possam fazer isto. Mas no entanto tenho repetido em todos estes requerimentos, que a programação de um EA que opere sozinho, não é nem de longe a tarefa das mais complicadas, que existem na programação. Tenho sempre motivado e dado as devidas orientações aqueles que de fato querem aprender, procurando estudar sobre o assunto, sejam eles entusiastas, ou mesmo pessoas que querem de fato criar um EA, que siga um determinado operacional e assim este possa operar sozinho, de forma automática.

Tenho notado que muitas destas pessoas tem, no geral, o mesmo tipo recorrente de duvida sobre como proceder a parte da programação. Mas o que mais me chama a atenção é o fato de que muitas destas tem, por um motivo ou outro, uma ideia totalmente errada de como fazer este tipo EA, e outras não tem a devida noção dos riscos envolvidos no processo, de se criar e utilizar um sistema automático, entenda-se neste caso, um sistema de EA automático, aqueles que opere sem nenhum tipo de supervisão, comprando e vendendo sem nenhum tipo de intervenção do operador, de uma maneira direta ou indireta.

Desta forma surgiu a ideia de explicar tais pontos, de forma que todos possam compreender, e mesmo abrir um leque de debate sobre o tema, irei mostrar o passo a passo de como você, entusiasta ou mesmo aquele que pretende estudar sobre o assunto, como fazer para programar um EA de negociação automático do ZERO, e de forma muito que seja o mais simples quanto for possível ser feito, mas ao mesmo tempo que seja o mais seguro possível, principalmente utilizando, apenas e somente, MQL5 puro e nativo, nada de soluções mirabolantes ou algo do tipo.

Não irei, neste primeiro momento entrar em detalhes complicados, e cheios de gráficos lindos e chamativos, tentando iludir, você que talvez não tenha o devido conhecimento em matemática estatística, de que os EAs que irei apresentar são, e serão o seu ganha pão, como se fossem escravos operadores. Longe disto, criar um EA automático, é uma tarefa muito longa, que exige muito tempo de estudo e dedicação, a fim de criar algo que possa realmente ser rentável, isto não por conta da programação, mas sim por conta do operacional e outras questões que irei abordar.

O grande problema, não é a parte da programação em si, como muitos erroneamente pensam, o grande e real problema, quando se deseja criar um EA automático.  Em muitos dos casos, teremos mais prejuízo do que realmente lucro. E volto a repetir, o problema não esta na programação, é a falta de experiência da pessoa que projeta o tipo de sistema operacional que será executado pelo EA.  O defeito nunca esta no programador, se bem, que se ele achar que é um grande programador e as pessoas confiarem nele cegamente, irão com certeza ter grande problemas.  Mas se a pessoa de fato conhece e sabe o que esta fazendo, ele estará completamente tranquilo com relação a seu trabalho.  Dado o fato de que o problema não estará na programação, mas sim no sistema operacional desejado pela pessoa que pediu para desenvolver o EA automático.

Como se divide um EA automático ?  Como de fato ele funciona ?

Bem, uma vez que você tenha um sistema de ordens, montado, e funcionando da maneira como você deseja e espera que ele funcione, podemos passar para a próxima etapa. Esta é consideravelmente mais simples, mas no entanto nem por isto você deverá negligenciar os cuidados necessários ao se trabalhar nela. Estou falando do sistema de gatilhos.

Entendendo o sistema de gatilhos

O sistema de gatilhos, talvez seja a parte que muitos, que não fazem a menor ideia de programação, ou matemática, mais se empolguem ao começar a estudar e acompanhar o mercado financeiro, afim de tentar ganhar algum dinheiro ali. Pois bem, o sistema de gatilho é a parte que uma vez ligado a um sistema de ordens, faz com que a " mágica " aconteça, dando a impressão que o EA é um verdadeiro escravo operador, e pode ficar ali, operando 24 horas por dia, 7 dias na semana, 52 semanas por ano, sem se cansar ou sofrer algum tipo de stress, ficando com medo de entrar ou sair de uma operação.

O sistema de gatilho de fato, é algo muitas vezes bem interessante, nem pela parte da programação em si, mas pelo que matematicamente ele pode representar. Todos que acompanham o mercado, já deve ter ouvido falar de operadores ( Traders ) que tem sistemas operacionais super bacanas, e que são extremamente ganhadores e rentáveis, quem não conhece a história do Larry Richard Willians, e também deseja se tornar um ?!?!

Lamento informar, mas hoje o mercado conta com uma infinidade de algoritmos que trabalham, muito melhor do que o algoritmo que o Larry Willians utilizou para ganhar dinheiro e reconhecimento, não que o sistema de gatilho que ele utilizou tenha perdido viabilidade, pelo contrário, ele ainda é bastante rentável e se você tiver um controle de risco adequado, irá conseguir ganhar bastante dinheiro com aquele mesmo algoritmo, não precisa de toda aquela complicação que muitos fazem por ai. Lembre-se o sistema de gatilho tem que ser simples, para o o EA de fato consiga tirar proveito dele, e você consiga testá-lo de forma adequada.

Nada irá adiantar você criar um sistema de gatilho, o tal setup, todo complicado, cheio de regras bizarras e analise extravagante, se você não conseguir colocar isto, em uma formula matemática simples e plausível de ser programada. Então esqueça aquelas bizarrices de olhar um indicador Z, ligado a um ativo X, para poder operar o ativo Y, no momento K, seguindo o nível de agressão P, analisando o book de ofertas, buscando a incidência de intenção W, para assim poder entrar vendendo ou comprando. Esqueça isto. Este tipo de coisa não irá funcionar, ou no mínimo irá apenas deixar a coisa tão bizarramente complicada, que você não vai conseguir de fato testar o algoritmo.

Lembre-se: Simplicidade SEMPRE . Tente deixar a coisa sempre o mais simples possível, isto para que o numero de possíveis falhas caia a um nível, que o sistema de gatilho não irá gerar um efeito de disparo, onde ele começa a enviar para o sistema de ordens, uma serie enorme de chamadas para comprar ou vender, que lhe acabe quebrando não somente a conta, mas destrua todo o seu patrimônio.

Existe um cuidado aqui, que de fato merece ser mencionado neste momento. Evite, ao máximo, gerar um sistema de gatilho em que o EA comece a comprar ou a vender, aumentando a posição, isto é fazendo preço médio, seja para cima, seja para baixo, este tipo de gatilho costuma dar muitos problemas. O ideal, e preferencialmente, você deve fazer com que o EA, entre em uma posição, comprando ou vendendo, e saia dela antes de tentar abrir uma nova posição.

Além do mais, existem diversas formas de travar o envio de ordens durante um período de tempo, ou fazer com que o EA não envie uma ordem, se já existir uma posição aberta. Pense nisto no momento que estiver criando e projetando o sistema de gatilho, pois muitos EA acabam, vez ou outra entrando em modo de loop, e quando isto acontece, ele começa a destruir totalmente o seu patrimônio em questão me poucos minutos, isto quando não acontece em segundos.

Nesta questão do gatilho, também pode ser mencionado um outro fato, e este histórico: Se você não estudou, aconselho a faze-lo. Você já ouviu falar do crash de 1987 ?!?! Mais conhecida como a segunda feira negra ?!?! Não ?!?!

Pois bem, antes de se aventurar de cabeça em criar um EA automático, procure saber sobre este crash. Pois ele foi causado justamente por conta deste mecanismo : O sistema de Gatilho. Então estude antes, pois você não é melhor do que ninguém que veio antes de você, no mínimo você é apenas mal informado e não tem todo o conhecimento de como e por que as coisas são como são. E fica ali se iludindo. Vendo algumas pessoas dizerem maravilhas sobre Trading Quanti e que os EA irão dominar o mercado, e o futuro é operar usando EA Quanti.

Pare e pense um pouco: Você, eu, ou qualquer outro programador ou entusiasta, será mesmo, que se a coisa fosse como muitos falam por ai, grandes instituições, com todo o seu poder econômico e interesse em se tornarem ainda mais lucrativas, não usariam tais mecanismos ?!?! Por que eles contratariam programadores, matemáticos, estatísticos, todos de primeira linha, se realmente a coisa fosse como alguns querem e dizem ser ?!?! Eles simplesmente pagariam estes profissionais para produzir um sistema de gatilho, que nunca perdesse e colocariam uma clausula contratual que impediria qualquer um de replicar tal mecanismo, e fim de jogo. Então estude bem, antes de realmente achar que descobriu o cálice sagrado, pois todos que fazem estudos sérios, sabem que tal mecanismo simplesmente não existe.

Muito bem, agora que já dei estes alertas, e mostrei a você como, e o que será preciso fazer para gerar um EA automático, vamos passar para a parte interessante: O CÓDIGO.

Iniciando o planejamento.

Agora vamos partir finalmente para o código. Certo ?!?! Não. Ainda não. Calma. Mas você já pode abrir o editor ( MetaEditor ) e a primeira coisa que você deverá fazer é criar um EA do zero. Código limpo, nada de começar com aquele código de um amigo, ou que você baixou da Internet sem saber de fato o que aquilo faz. Vamos começar do zero.

Para quem não sabe como fazer isto, uma vez com o MetaEditor aberto, no canto esquerdo irá aparecer uma janela chamada navegador, ali você terá uma estrutura de diretórios, todos eles irão começar em MQL5. Entenda esta janela como se fosse o seu explorador de arquivos. assim ficará mais simples de você acompanhar a explicação.

Nesta mesma janela existe uma pasta chamada Experts. Nela é que iremos colocar os códigos de todo e qualquer EA que estivermos criando, existem outras pastas, cada uma serve para um proposito, mas o nosso foco aqui e agora é somente a pasta Experts. Clicando nesta pasta, você irá poder abrir ela e ver os códigos presentes ali, muito provavelmente eles estarão organizados em termos de outras pastas, cada uma representando um EA diferente, acostume com esta estrutura, é importante manter uma certa organização, caso contrário você irá ficar totalmente perdido no meio de todos os arquivos presentes ali, e não conseguirá achar o seu quando for preciso.

Vamos então efetuar os primeiros passos, são bem simples, então bastará seguir a sequencia de imagens mostradas abaixo:

Figura 02 - Escolhendo o que vamos criar

Figura 03 - Indicando o diretório onde ficará nosso código

Figura 04 - Dando um nome ao nosso EA ( você não precisa indicar a extensão )

Figura 05 - Apenas clique em Avançar

Figura 06 - Apenas clique em Concluir

Feitos estes passos entre a figura 02 e a figura 06, o MetaEditor irá criar um código para nos, totalmente limpo e seguro, você deverá ver algo do tipo mostrado abaixo:

#property copyright "Daniel Jose"
#property link      "https://www.mql5.com/pt/articles/11216"
#property version   "1.00"
//+------------------------------------------------------------------+
int OnInit()
{
        return INIT_SUCCEEDED;
}
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
}
//+------------------------------------------------------------------+
void OnTick()
{
}
//+------------------------------------------------------------------+

Não se preocupe com as diretivas de compilação #property. Elas não irão afetar em nada o que iremos fazer, elas estão ali apenas para configurar a janela, que será aberta quando você for colocar o EA no gráfico, por isto não se preocupe com elas, mas você deverá se preocupar é com as demais coisas aqui.

Veja que o MetaEditor, criou 3 procedimentos, estes são OnInit, OnDeInit e OnTick. Estes procedimentos são na verdade funções de tratamento de eventos. Sim, isto mesmo nos não programados da mesma forma no MQL5 que em outras linguagem, o MQL5 é uma linguagem de tratamentos de eventos, diferente de outras linguagens onde trabalhamos de forma processual. Linguagens baseadas em eventos, podem ser confusas no começo, mas com o tempo você acaba entendendo como fazer as coisas nelas.

Aqui, e sem entrar muito nos detalhes, você de fato irá trabalhar da seguinte forma: A plataforma MetaTrader 5 gera um evento e você responde a este evento, ou seja quanto você coloca o EA no gráfico, o MetaTrader 5 irá disparar um evento, o evento Init que irá fazer com que a plataforma procure no seu código, a função OnInit, para que o EA ( no caso ) seja carregado e inicializado, uma vez feito isto, esta função não será novamente chamada. Isto de uma forma meio que generalista, já que sim, ela será chamada toda a vez que a plataforma MetaTrader 5 for colocar o EA no gráfico, lembre-se deste fato.

Pois aqui temos também a função OnDeInit, esta será chamada pela plataforma MetaTrader 5 quando for gerado um evento DeInit, que diz a todas as coisas, EA, Indicadores que aconteceu algo e ele será retirado do gráfico, seja momentaneamente, seja definitivamente, para saber o motivo bastará olhar o valor reason que é informado pela plataforma MetaTrader 5, assim você saberá o motivo da remoção do programa.

E por último temos a função presente OnTick, esta será chamada pela plataforma MetaTrader 5, sempre que um evento de tick acontecer, e este evento acontece, sempre que ocorre o surgimento de um novo ticket, ou seja aconteceu um novo negócio, não importando qual no servidor de negociação, um evento Tick é gerado, assim a função OnTick é disparada, e o código vai para ela.

Como você pode imaginar, a função OnTick é primordial para nosso sistema, ela é muitas vezes o calcanhar de aquiles de muitos EA, isto por conta que por inexperiência, ou mesmo negligencia, muitos programadores acabam colocando todo o código dentro desta função, o que acaba sobrecarregando o seu funcionamento, deixando o EA menos seguro, e bastante sujeito a falhas e erros críticos, e o pior dos erros é o erro de RUN TIME, ou seja não é um erro que você irá conseguir corrigir com facilidade, pois ele pode ser gerado por conta de interações muito complexas e difíceis de serem replicadas, mas isto será visto em mais detalhes em um outro artigo nesta sequencia.

Então por conta disto, a plataforma, e consequentemente a sua linguagem MQL5, promove outras forma de você trabalhar as funções, de maneira a manter a coisa dentro de um nível mínimo de segurança e confiabilidade, temos outros tipos de eventos também, que podemos usar para melhorar a coisa de uma forma geral, mas isto nos veremos depois, já que não quero gerar nenhuma grande confusão na cabeça de que está vendo isto pela primeira vez, e não fazia ideia de que no MQL5 você trabalha tratando de eventos, que são disparados pela plataforma MetaTrader 5, e não tentando criar um código processual, onde temos um ponto de entrada, e um ponto ponto de saída, e todas as coisas entre estes dois pontos devem ser gerenciadas pelo programa, e tratadas pelo programador.

Aqui no MQL5, iremos tratar apenas e somente os eventos que queremos e precisamos, então um EA, e para ser considerando um EA, deverá obrigatoriamente ter 2 eventos, um que trata de sua inicialização, o chamado OnInit e outro que trata um evento de tick, chamado OnTick, já o evento OnDeInit pode ou não existir, mas você acabará por entender, que as vezes é bom usar ele em alguns casos especiais.

Para que você inicie o aprendizado, de como ler a documentação, e passe a se interessar em estudar o que a documentação estará explicando, veja o que ela diz sobre os eventos, que podem ser gerados, mas principalmente sobre estes 3 eventos que foram criados de forma automática, pelo MetaEditor ao iniciarmos a construção do EA: OnInit depois OnDeInit e por último OnTick. Não se esqueça também de dar uma olhada na diretiva de compilação property ...

É muito importante, que você compreenda esta primeira etapa, vista neste artigo, caso contrário, você irá ficar completamente perdido na explicação, dos demais artigos desta serie.

No próximo artigo, irei mostrar como você faz para criar um sistema de ordens, bem simples e direto, que lhe permite enviar ordens de compra e venda diretamente pelo gráfico, então não se esqueça de acompanhar o próximo artigo, pois o assunto será bastante interessante, para quem deseja construir um EA que opere de forma automática.