Aprendendo a construindo um EA que opera de forma automática (Parte 04): Gatilhos manuais (I)

Introdução

No artigo anterior, Aprendendo a construindo um EA que opera de forma automática ( Parte 03 ) - Novas funções, finalizei a implementação do sistema de ordens, então se você não o leu, ou não conseguiu assimilar o conteúdo presente lá, minha sugestão é que você volte, e procure assimilar o que está sendo explicado nos artigos anteriores, pois aqui, não irei tratar mais do sistema de ordens, de agora em diante, iremos tratar de um outro assunto. Gatilhos.

O sistema de gatilhos, é talvez a parte mais complicada, e ao mesmo tempo, a que mais gera confusão, duvidas e problemas, isto por conta, que não existe exatamente um método, 100% infalível. Todos tem algum tipo de falha, ou problema envolvido. Alguns contém, mais possibilidades de falhas, enquanto outros, menos possibilidades de falhas. Mas você sempre, e sempre, deve estar atento a estes conceito: Não confie nos gatilhos, seja ele qual for, pois pode acontecer de ele falhar no momento que você menos esperar. E uma falha no sistema de gatilho, pode lhe deixar fora de uma boa oportunidade, ou pode lhe causar muito prejuízo .. então tenha sempre cuidado com estes gatilhos.

Mas vamos entender algumas coisas sobre este sistema. Primeiro, para que server um sistema de gatilho ?!?! Um sistema de gatilho, server para diversas coisas, entre elas, dizer o momento em que um breakeven deverá acontecer, ou quando um movimento, de trailing stop deverá ser disparado. Estes são exemplos dos mais simples, mas também o sistema de gatilho, pode servir para dizer, quando o EA deve abrir uma posição, ou quando ele deverá fechar uma posição.

Todos estes eventos, acontecem de forma totalmente automática, sem que o operador, de fato, precise fazer algo, ele apenas diz para o EA, qual será o gatilho, ou ponto onde o gatilho deverá disparar o evento. Depois de ter feito isto, nenhuma intervenção humana se faz necessária, salvo o fato de o EA disparar, ou entrar em loop, neste caso, o operador deverá desligar o EA imediatamente.

Para explicar, e fixar melhor estas ideias, e conceitos, teremos que programar, ainda, um EA manual. Mas aqui, vamos fazer algo bem diferente do que normalmente temos feito, como sendo um EA manual. Isto por que, iremos adicionar no EA, que estou usando para exemplificar os artigos, uma forma de colocar ordens pendentes, e enviar ordens, a fim de abrir uma posição a mercado. Então já que este EA, é para fins de demonstração e aprendizado, aconselho a você, que for utilizar ele, o faça em uma conta de demonstração, a famosa conta DEMO, não use este EA em uma conta de produção, ou conta REAL, pois existe o risco de ele travar ou disparar loucamente.

Implementando uma forma de enviar ordens e abrir posições a mercado

Na minha visão, a melhor forma de você operar em um gráfico, é utilizando o mouse aliado ao teclado. Para lançar ordens pendentes, não existe uma forma melhor, mas para lançar ordens a mercado, apenas o uso do teclado, já será suficiente. Mas a questão, é como implementar um código, que não seja tão complicado a ponto de inviabilizar qualquer tipo de explicação. Já que um sistema de envio de ordens, usando o mouse e teclado, pode se torna algo bastante complexo de ser desenvolvido.

Bem, depois de pensar por um tempo, decidi criar um sistema ideal para ser utilizado no artigo, algo bastante simples. Então não vá querendo operar em conta real com este sistema. Ele é apenas para me ajudar a explicar algumas coisas, sobre gatilhos, para que você possa compreender como um gatilho é implementado, e como ele deve ser encarado.

O código que iremos precisar desenvolver, é o mais simples que se pode construir, mas ainda assim, suficiente para o resto desta sequencia de artigos. Então vamos ver como o código foi implementado.

Primeiramente, adicionei um novo arquivo de cabeçalho chamado: C_Mouse.mqh, e o código deste arquivo se inicia da seguinte forma:

#property copyright "Daniel Jose"
//+------------------------------------------------------------------+
#define def_MouseName "MOUSE_H"
//+------------------------------------------------------------------+
#define def_BtnLeftClick(A)     ((A & 0x01) == 0x01)
#define def_SHIFT_Press(A)      ((A & 0x04) == 0x04)
#define def_CTRL_Press(A)       ((A & 0x08) == 0x08)
//+------------------------------------------------------------------+

Aqui, foi definido um nome para o objeto que iremos criar, uma linha horizontal, para indicar a posição no preço, onde o ponteiro do mouse se encontra no gráfico. Também foi criado 3 definições, para poder nos dar um acesso mais simples a algumas informações, que um evento do mouse irá gerar. Estas são uma forma de testar os eventos de clique, e de teclas pressionadas. Estas definições de acesso, irão ser utilizadas depois no EA, já a definição do nome de objeto, irá ser finalizada no final no arquivo, utilizando a seguinte linha:

//+------------------------------------------------------------------+
#undef def_MouseName
//+------------------------------------------------------------------+

Ao adicionar esta linha acima, no final do arquivo de cabeçalho, garantimos que esta definição, não irá vazar, ou melhor dizendo, aparecer, em nenhum outro ponto do código. Ou seja, se você tentar utilizar esta definição, sem redeclarar ela, em um outro ponto que não seja neste arquivo de cabeçalho, o compilador irá gerar um erro, alertando para o fato.

Agora vamos começar a codificar a nossa classe, que será responsável por todo o trabalho com o mouse, ela começa da seguinte maneira:

class C_Mouse
{
        private :
                struct st00
                {
                        long    Id;
                        color   Cor;
                        double  PointPerTick,
                                Price;
                        uint    BtnStatus;
                }m_Infos;
//+------------------------------------------------------------------+
                void CreateLineH(void)
                        {
                                ObjectCreate(m_Infos.Id, def_MouseName, OBJ_HLINE, 0, 0, 0);
                                ObjectSetString(m_Infos.Id, def_MouseName, OBJPROP_TOOLTIP, "\n");
                                ObjectSetInteger(m_Infos.Id, def_MouseName, OBJPROP_BACK, false);
                                ObjectSetInteger(m_Infos.Id, def_MouseName, OBJPROP_COLOR, m_Infos.Cor);
                        }
//+------------------------------------------------------------------+
inline double AdjustPrice(const double value)
                        {
                                return MathRound(value / m_Infos.PointPerTick) * m_Infos.PointPerTick;
                        }
//+------------------------------------------------------------------+

Não se assuste olhando o código acima, esta parte é apenas uma pequena amostra. Tudo que estamos fazendo é declarando uma estrutura de dados, que irá conter algumas variáveis globais dentro da classe, mas estas serão privativas da classe. Depois disto, utilizamos um procedimento que irá criar um objeto gráfico na plataforma MetaTrader 5, este objeto será uma linha horizontal, ajustamos algumas de suas propriedades, e bola pra frente.

Já esta função, acredito que você já deva ter visto em um artigo anterior, se não viu, leia os artigos anteriores a estes, nesta mesma sequencia sobre o EA automático, pois eles também são importantes para o que iremos fazer.

Agora vamos ver os procedimentos, que serão públicos da nossa classe C_Mouse, começando com o constructor da classe:

                C_Mouse(const color cor)
                        {
                                m_Infos.Id = ChartID();
                                m_Infos.Cor = cor;
                                m_Infos.PointPerTick = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);
                                ChartSetInteger(m_Infos.Id, CHART_EVENT_MOUSE_MOVE, true);
                                ChartSetInteger(m_Infos.Id, CHART_EVENT_OBJECT_DELETE, true);
                                CreateLineH();
                        }

Aqui existem 2 linhas das quais podem lhe ser estranhas, caso você não tenha muito conhecimento sobre o MQL5, então vamos dar uma rápida explicada nas mesmas. Esta linha, irá informar a plataforma MT5, que o nosso código, o EA, deseja receber eventos que irão ser gerados pelo mouse, existe um outro tipo de evento também gerado pelo mouse, que é quando o mouse tem aquela rodinha ( scroll ), mas não queremos e não iremos utilizar a rodinha, então este tipo de evento aqui, já é o suficiente para nos.

Já esta linha aqui, irá dizer para a plataforma MetaTrader 5, que desejamos saber se algum objeto gráfico foi removido. Se isto acontecer, será gerado um evento para nos informar a respeito de qual foi o elemento removido do gráfico. Este tipo de evento é bastante útil, quando desejamos manter certos elementos cruciais, para uma perfeita e correta execução da tarefa. Então caso o usuário remova, de forma inadvertida, algum elemento critico, o MetaTrader 5 irá informa ao código, no caso o EA, de que um elemento foi removido, e podemos providenciar a sua recriação. Agora vamos ver o código do destructor da classe, e este pode ser visto logo abaixo:

                ~C_Mouse()
                        {
                                ChartSetInteger(m_Infos.Id, CHART_EVENT_OBJECT_DELETE, false);
                                ObjectDelete(m_Infos.Id, def_MouseName);
                        }

Neste código, iremos fazer duas coisas, a primeira é informa ao MetaTrader 5, que não queremos mais ser informados, se um elemento vier a ser removido do gráfico. É importante fazer isto antes de prosseguir, já que se tentarmos eliminar algum elemento, o MetaTrader 5, irá gerar um evento informando que alguma coisa foi removida do gráfico. E é justamente o que iremos fazer a seguir, remover a linha que criamos, para mostrar em que faixa de preço o ponteiro do mouse se encontra.

A próxima coisa que precisamos fazer, é criar uma forma de ler os dados de dentro da classe, a fim de saber em que ponto o mouse está, e qual o status dos botões dele. Para isto usaremos a seguinte função:

const void GetStatus(double &Price, uint &BtnStatus) const
                        {
                                Price = m_Infos.Price;
                                BtnStatus = m_Infos.BtnStatus;
                        }

Aqui vale explicar uma coisa, muito comum entre pessoas com menos experiência em programação orientada a objetos. Quando usamos classes, não devemos, de forma alguma, permitir que algum código de fora da classe tenha acesso direto a qualquer uma das variáveis ou procedimento da classe, sem que este, seja de fato, um ponto onde iremos testar o que estará entrando na classe.

Fazer uso, e permitir que variáveis ou procedimentos de uma classe, receba algum valor, que não foi devidamente testado, é um grave erro, pois isto irá gerar problemas no longo prazo. Você pode em algum momento modificar, em algum ponto do código, o valor de uma variável critica presente na classe, e quando esta vier a ser utilizada, pode por todo o código em risco, além do mais é extremamente complicado lidar com este tipo de situação, a fim de corrigir o problema depois.

Então tenha sempre a seguinte prática, para se tornar um bom programador: Se for ler o conteúdo de uma classe, permita que ele seja lido, mas não modificado, isto também costuma acontecer muito, principalmente quando usamos ponteiro, você pede para ler uma variável, e retorna um ponteiro. Neste momento seu código passou a correr risco, já que utilizando um ponteiro, você saberá onde escrever na memória, e isto é muito perigoso. Vejam como se faz os tais Cheats de jogos, aqueles programinhas para trapacear, em jogos eletrônicos. Você simplesmente escreve em uma posição da memória, utilizando para isto um ponteiro.

Tenha muito cuidado ao usar ponteiro. Na duvida, sempre prefira utilizar uma função a um procedimento, a diferença entre elas, é que a função normalmente retorna um valor, mas ainda assim cuidado para não devolver um ponteiro.

Mas se mesmo assim, não existir um outro meio, faça como eu fiz acima, sei que é excesso de cuidado, mas ao iniciar a declaração do procedimento, ou função com a palavra reservada const, você esta garantindo que o chamador, não poderá mudar os dados contidos nas variáveis, isto por que o compilador, irá tratar qualquer valor, como sendo uma constante, e não é permitido modificar uma constante.

Já o fato de terminar a declaração do procedimento, ou função com a palavra reservada const, irá garantir que você, como programador, não irá inadvertidamente, e muitas vezes sem perceber, modificar algum valor dentro do procedimento, ou função. Esta é talvez a melhor prática de programação que existe, apesar de parecer estranha para muitos, isto evita diversos erros de programação, principalmente quando estamos fazendo isto em OOP ( programação orientada a objetos ), mas depois iremos voltar nesta questão, já com um exemplo mais claro, a fim de você entender esta questão de terminar a declaração, com uma palavra const.

O último procedimento que precisamos, é visto logo abaixo:

                void DispatchMessage(const int id, const long &lparam, const double &dparam, const string &sparam)
                        {
                                int w;
                                datetime dt;
                                
                                switch (id)
                                        {
                                                case CHARTEVENT_OBJECT_DELETE:
                                                        if (sparam == def_MouseName) CreateLineH();
                                                        break;
                                                case CHARTEVENT_MOUSE_MOVE:
                                                        ChartXYToTimePrice(m_Infos.Id, (int)lparam, (int)dparam, w, dt, m_Infos.Price);
                                                        ObjectMove(m_Infos.Id, def_MouseName, 0, 0, m_Infos.Price = AdjustPrice(m_Infos.Price));
                                                        m_Infos.BtnStatus = (uint)sparam;
                                                        ChartRedraw();
                                                        break;
                                        }
                        }

Este procedimento é bem curioso, já que muitos programadores, irão querer colocar o código presente aqui, dentro do evento de tratamento de mensagens OnCharEvent. Mas gosto de tratar os eventos, dentro da classe objeto, isto evita muitas vezes, você se esquecer de tratar algo em particular, ou tratar algo de uma maneira diferente, que muitas vezes, lhe fará ter que verificar se o código está ou não funcionando. Fazendo este tratamento dentro da classe, ficamos mais tranquilos no longo prazo, isto por que, no momento que formos usar a classe, saberemos que o sistema de tratamento de mensagens, da mesma, está funcionando da forma como esperado. Isto agiliza muito a confecção de novos programas. Este é o caminho da reutilização, programe uma vez, e use sempre.

Então vamos entender o que está acontecendo, neste sistema de tratamento de mensagens. Bem, aqui estamos replicando, exatamente os dados que serão recebidos pelo tratador de eventos OnChartEvent, e isto é proposital, pois queremos tratar os eventos aqui, dentro da classe.

Uma vez isto definido, vamos definir quais os eventos que iremos tratar. O primeiro, é o evento de remoção de objeto gráfico, este é gerado por conta que dissemos anteriormente ao MetaTrader 5, que era desejado sermos informados caso algum objeto fosse removido do gráfico, e caso o objeto removido, tenha sido a linha do mouse, este objeto será recriado imediatamente.

O próximo evento, que iremos e queremos tratar aqui, dentro da classe, são os eventos de movimentação do mouse. Novamente, este evento será gerado, pois informamos ao MetaTrader 5, que gostaríamos de saber o que está acontecendo com o mouse. Aqui iremos simplesmente, converter os valores, que o MetaTrader 5 esta nos dando, em valores de tempo e preço. Depois disto, iremos posicionar o objeto linha horizontal na posição do preço, de forma que ela fique no ponto correto, não é um ponto no sistema de coordenadas de tela, e sim um ponto no gráfico de preço, daí armazenamos o valor dos botões, e forçamos uma repintura imediata do gráfico.

É importante que esta repintura aconteça, seja aqui no tratador de eventos da classe, seja no tratador de eventos OnChartEvent, se isto não for feito, você poderá ter a impressão de que o código, esta deixando a plataforma LENTA, já que a linha de preço, irá se mover de forma estranha.

Com isto, finalizamos a nossa classe C_Mouse, e já poderemos lançar ordens pendentes, diretamente no gráfico. Agora vamos voltar então, para dentro do código do nosso EA, e vamos adicionar a classe C_Mouse, de forma a poder gerar os eventos, de maneira a poder lançar as ordens pendentes, para fazer isto, vamos proceder da seguinte maneira:

#include <Generic Auto Trader\C_Orders.mqh>
#include <Generic Auto Trader\C_Mouse.mqh>
//+------------------------------------------------------------------+
C_Orders *manager;
C_Mouse *mouse;
//+------------------------------------------------------------------+
input int       user01   = 1;           //Fator de alavancagem
input double    user02   = 100;         //Take Profit ( FINANCEIRO )
input double    user03   = 75;          //Stop Loss ( FINANCEIRO )
input bool      user04   = true;        //Day Trade ?
input color     user05  = clrBlack;     //Color Mouse
//+------------------------------------------------------------------+
#define def_MAGIC_NUMBER 987654321
//+------------------------------------------------------------------+
int OnInit()
{
        manager = new C_Orders(def_MAGIC_NUMBER);
        mouse = new C_Mouse(user05);
        
        return INIT_SUCCEEDED;
}
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
        delete mouse;
        delete manager;
}
//+------------------------------------------------------------------+
void OnTick()
{
}
//+------------------------------------------------------------------+

No fragmento acima, temos basicamente a forma como iremos produzir as coisas, notem que estamos fazendo as coisas, de forma a depois poder remover com facilidade, a classe C_Mouse. Já que para um EA automático, ela não tem nenhuma serventia, mas precisamos, agora de uma forma, de testar o nosso EA, e a melhor forma de fazer isto, sem adicionar gatilhos, é usando a classe C_Mouse que acabamos de construir. Então, incluímos ela, para que o compilador possa adicionar o código para nos. Definimos uma cor, para ser usada na linha horizontal de preço.

Inicializamos a nossa classe C_Order, de forma que todas as ordens, terão um numero mágico igual para este EA, Aqui vale dizer uma coisa importante: Você deve sempre, colocar um numero mágico diferente, para cada um dos EA, o motivo é que se você for usar, mais de um EA, ao mesmo tempo, no mesmo ativo, a forma de separar eles, de maneira que cada um, observe apenas, e somente, a ordem que ele gerou, será através deste numero mágico. Se dois EA, tiverem o mesmo numero, você não conseguira separar eles, de forma que um, poderá interferir na ordem do outro, então cada EA, com um numero mágico diferente.

Feito isto, inicializamos a classe C_Mouse, e desta forma o EA estará pronto para o uso. Não se esqueça de chamar os destructores, no encerramento do EA. Apesar de tudo, se você se esquecer de fazer isto, o compilador, normalmente, fará isto para você, mas é sempre de boa pratica, fazer isto no código, assim todos irão saber, onde a classe deixou de ser referenciada.

Apesar de ter dito, que o EA, já está pronto para o uso, ainda falta uma coisa: O sistema de tratamento de eventos de gráfico, este agora irá ter o seguinte formado:

void OnChartEvent(const int id, const long &lparam, const double &dparam, const string &sparam)
{
        uint    BtnStatus;
        double  Price;
        static double mem = 0;
        
        (*mouse).DispatchMessage(id, lparam, dparam, sparam);
        (*mouse).GetStatus(Price, BtnStatus);
        if (def_SHIFT_Press(BtnStatus) != def_CTRL_Press(BtnStatus))
        {
                if (def_BtnLeftClick(BtnStatus) && (mem == 0)) (*manager).CreateOrder(def_SHIFT_Press(BtnStatus) ? ORDER_TYPE_BUY : ORDER_TYPE_SELL, mem = Price, user03, user02, user01, user04);
        }else mem = 0;
}

Aqui está ele, bem simples, não quero tornar um EA, que esta sendo construído para ser automático, em um EA manual. Por conta disto, as linhas de preço, que informam os limites de take profit, e stop loss, não iram ser criadas pelo EA. Mas vamos ver, como este código funciona, e apesar de tudo, ainda falta uma coisa aqui, mas mesmo assim, vamos ver como ele funciona.

Quando o MetaTrader 5, perceber que aconteceu um evento no gráfico, seja ele qual for, ele irá gerar uma chamada a este código acima. Assim que este código for disparado, e receber o processador para ser executado. Ele irá chamar o procedimento de tratamento de mensagens, da classe C_Mouse. Desta forma, os eventos ligados ao mouse, serão tratados de maneira adequada, e sempre da mesma forma.

Uma vez que o tratador de mensagens da classe C_Mouse retorne, iremos capturar o status do mouse, para poder usar aqui, nesta função.

Agora iremos testar, usando as definições, que estão presentes no arquivo de cabeçalho C_Mouse.mqh, o status das teclas Shift e Ctrl. Estas servirão para indicar, se estaremos enviando uma ordem de compra, ou de venda. Por conta disto, elas deverão ter valores diferentes, se isto estiver ocorrendo, iremos fazer um novo teste.

Mas desta vez, iremos testar se houve, ou não, um clique com o botão esquerdo do mouse. Se isto também for verdadeiro, e o preço de memória for zero, iremos enviar uma ordem pendente para o servidor, usando os dados indicados na área de interação com o usuário. Quem decidirá, se iremos compra, ou vender, é o uso das teclas Shift e Ctrl, a tecla Shift indica que iremos comprar, já a tecla Ctrl indica que iremos vender. Desta forma, poderemos pendurar quantas ordens precisarmos, para testar o sistema, mas como foi dito antes, esta faltando uma coisa aqui.

No artigo anterior, deixei um desafio para você tentar gerar um código, de forma conseguir executar uma operação a mercado. Se você não conseguiu fazer isto, tudo bem, não precisa ficar desanimado. Mas seria bom se você tivesse conseguido fazer, sem ver como seria a minha solução. Ela está logo abaixo, na atualização do código de tratamento de eventos OnChartEvent:

void OnChartEvent(const int id, const long &lparam, const double &dparam, const string &sparam)
{
        uint    BtnStatus;
        double  Price;
        static double mem = 0;
        
        (*mouse).DispatchMessage(id, lparam, dparam, sparam);
        (*mouse).GetStatus(Price, BtnStatus);
        if (TerminalInfoInteger(TERMINAL_KEYSTATE_CONTROL))
        {
                if (TerminalInfoInteger(TERMINAL_KEYSTATE_UP))  (*manager).ToMarket(ORDER_TYPE_BUY, user03, user02, user01, user04);
                if (TerminalInfoInteger(TERMINAL_KEYSTATE_DOWN) (*manager).ToMarket(ORDER_TYPE_SELL, user03, user02, user01, user04);
        }
        if (def_SHIFT_Press(BtnStatus) != def_CTRL_Press(BtnStatus))
        {
                if (def_BtnLeftClick(BtnStatus) && (mem == 0)) (*manager).CreateOrder(def_SHIFT_Press(BtnStatus) ? ORDER_TYPE_BUY : ORDER_TYPE_SELL, mem = Price, user03, user02, user01, user04);
        }else mem = 0;
}

Aqui está, uma forma de enviar ordens a mercado, para o servidor de negociação. Temos o seguinte comportamento: Quando a tecla CTRL estiver pressionada, teremos esta condição aqui com sendo verdadeira, ou seja agora poderemos testar uma segunda condição. Esta segunda condição, diz se iremos compra a mercado, ou vender a mercado. Para isto, iremos fazer uso das teclas de seta, se você pressionar CTRL + Seta para Cima, você estará comprando a mercado, seguindo as orientações presentes na área de interação com o usuário, agora se você pressionar CTRL + Seta para Baixo, você estará vendendo a mercado, seguindo as mesma orientações.

Esta orientações mencionadas acima, podem ser vista na figura 01 logo abaixo:

Figura 01 : Configurações do EA.

Conclusão

Isto que acabei de explicar, sobre o sistema de eventos, e como ele foi implementado, é um tipo de mecanismo de gatilho. Mas neste caso, o mecanismo é manual, ou seja, precisa da intervenção de um operador humano para que o pedido de abertura de posição, ou colocação de uma ordem pendente no book, seja feito por meio de uma interação do usuário do EA, com o próprio EA. Não existe neste caso, nenhum mecanismo automático, para que uma ordem seja colocada no book, ou uma posição seja aberta, tudo depende de um operador.

Mas uma vez que a ordem tenha sido apregoada no book, o sistema passará a não mais depender do operador, a ordem irá se tornar posição, assim que o preço atingir o ponto indicado na ordem, e a posição será fechada, caso um dos preços de limite seja atingido. Mas neste caso, você deverá ficar atento, já que pode acontecer um momento, de grande volatilidade, que poderá fazer com que o preço indicado seja pulado. Assim a posição continuará em aberto, até que, ou a corretora lhe estope compulsoriamente, ou o tempo limite, no caso de operações de day trade, venha a ser encerradas, isto por conta que o mercado irá fechar. Mas de uma forma ou de outra, você precisa ficar atento com uma posição que esteja aberta.

No arquivo em anexo, você terá acesso ao código atual. No próximo artigo iremos modificar este código, para facilitar o uso do EA no modo manual, já que será preciso fazer algumas mudanças. No entanto, as mesmas serão bem interessantes de serem implementadas.