Média Móvel - expert para MetaTrader 5

O EA de média móvel está incluído no pacote padrão do terminal do cliente MetaTrader 5 e é um exemplo da EA que negocia com o indicador de Média Móvel.

O arquivo EA Moving Average.mq5 está localizado na pasta "terminal_data_folder\MQL5\Experts\Examples\Moving Average\". Este EA é um exemplo da utilização de indicadores técnicos, histórico de negociações e funções classes de negociação da biblioteca padrão. Além disso, o AE inclui um sistema de gestão de dinheiro que é baseado nos resultados das negociações

Vamos considerar a estrutura do Expert Advisor e como ele funciona.

1. Propriedades do EA

//+------------------------------------------------------------------+
//|                                              Moving Averages.mq5 |
//|                   Copyright 2009-2013, MetaQuotes Software Corp. |
//|                                              https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2009-2013, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00

As primeiras 5 linhas contêm um comentário, as três linhas seguintes definem as propriedades do programa MQL5 (copyright, link, versão) utilizando as diretivas de pré-processamento #Property.

Quando você executa o Expert Advisor eles são exibidos na aba "Common":

Figura 1. Parâmetros comuns de EA Média Móvel

1.2. Arquivos de include

Em seguida, a diretiva #Include diz ao compilador para incluir o arquivo "Trade.mqh".

Este arquivo é parte da Biblioteca Padrão, que contém a classe CTrade para facilitar o acesso as funções de negociação.

#include <Trade\Trade.mqh>

O nome do arquivo de inclusão é mostrado entre parênteses "<>;", de modo que o caminho está definido em relação ao diretório: "terminal_data_folder\Include\".

1.3 Entradas

Vai-se o tipo, nome, valores padrão e um comentário. O seu papel é mostrado na fig. 2.

input double MaximumRisk        = 0.02;    // Risco máximo em porcentagem
input double DecreaseFactor     = 3;       // Fator de rebaixamento
input int    MovingPeriod       = 12;      // Período da Média Móvel
input int    MovingShift        = 6;       // Deslocamento da Média Móvel

Os parâmetros MaximumRisk e DecreaseFactor serão utilizados para o gerenciamento de dinheiro, MovingPeriod e MovingShift definem o período e o deslocamento do indicador técnico Média Móvel que será usado ou verificará as condições de negociação.

O texto no comentário na linha de parâmetro de entrada, juntamente com os valores padrão, são exibidos na aba "Options" em vez do nome do parâmetro de entrada:

Fig. 2. Parâmetros de entrada do EA Média Móvel

1.4. Variáveis ​​globais

Em seguida, a variável global ExtHandle é declarada. Ela será usada para armazenar o manipulador do indicador Média Móvel.

//---
int   ExtHandle=0;

Ele é seguido por seis funções. A finalidade de cada um deles está descrito no comentário antes do corpo da função:

1. TradeSizeOptimized() - Calcula o tamanho ideal do lote;
   
2. CheckForOpen() - Verifica as condições para abertura de posição;
   
3. CheckForClose() - Verifica as condições de fechamento da posição;
   
4. OnInit() - função de inicialização do Expert;
   
5. OnTick() - Função tick do Expert;
   
6. OnDeinit() - Função de desinicialização do Expert;

As três últimas funções são funções de manipulação de evento; as três primeiras funções de serviço são chamadas em seu código.

2. Funções de manipulação de eventos

2.1. A função de inicialização OnInit()

A função OnInit() é chamada uma vez durante a inicialização do Expert Advisor. Geralmente no manipulador de eventos OnInit() a EA está preparada para a operação: os parâmetros de entrada são verificados, os indicadores e parâmetros são inicializados, etc No caso de erros críticos, quando o funcionamento não faz sentido, a função é encerrada com um código de retorno INIT_FAILED.

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit(void)
  {
//---
   ExtHandle=iMA(_Symbol,_Period,MovingPeriod,MovingShift,MODE_SMA,PRICE_CLOSE);
   if(ExtHandle==INVALID_HANDLE)
     {
      printf("Erro ao criar o indicador MA");
      return(INIT_FAILED);
     }
//---
   return(INIT_SUCCEEDED);
  }

Desde que a negociação do EA é baseada no indicador de média móvel, chama-se IMA() e o indicador de Média Móvel é criado e seu manipulador é salvo na variável global ExtHandle.

No caso de um erro, OnInit() é encerrado com um código de retorno INIT_FAILED - É uma maneira correta para completar a operação EA/indicador no caso de uma inicialização mal sucedida.

2.2. A função OnTick()

A função OnTick() é chamada cada vez que uma nova cotação é recebida para o símbolo do gráfico, em que a EA é executada.

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick(void)
  {
//---
   if(PositionSelect(_Symbol))
      CheckForClose();
   else
      CheckForOpen();
//---
  }

A função PositionSelect() é usada para definir se existe uma posição em aberto para o símbolo atual.

Se houver posições em aberto, a função CheckForClose() é chamada, ela analisa o estado atual do mercado e fecha a posição em aberta, caso contrário CheckForOpen() é chamado, ela verifica as condições de entrada no mercado e abre uma nova posição, se tais condições ocorrerem.

2.3. A função de desinicialização OnDeInit()

OnDeInit () é chamada quando um EA é removido a partir do gráfico. Se um programa coloca os objectos gráficos durante a operação, eles podem ser removidos a partir do gráfico.

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
  }
//+------------------------------------------------------------------+

Neste caso, não há a realização de nenhuma ação durante a desinicialização do Expert Advisor.

3. Funções de serviço

3.1. Função TradeSizeOptimized()

Esta função calcula e retorna o valor do tamanho do lote ideal para a posição de abertura com o nível de risco especificado e os resultados das negociações.

//+------------------------------------------------------------------+
//| Calcular o tamanho ideal do lote                                 |
//+------------------------------------------------------------------+
double TradeSizeOptimized(void)
  {
   double price=0.0;
   double margin=0.0;
//--- Calcula o tamanho do lote
   if(!SymbolInfoDouble(_Symbol,SYMBOL_ASK,price))
      return(0.0);
   if(!OrderCalcMargin(ORDER_TYPE_BUY,_Symbol,1.0,price,margin))
      return(0.0);
   if(margin<=0.0)
      return(0.0);

   double lot=NormalizeDouble(AccountInfoDouble(ACCOUNT_FREEMARGIN)*MaximumRisk/margin,2);
//--- Calcular o comprimento da série de operações consecutivas de perda
   if(DecreaseFactor>0)
     {
      //--- Pedido de todo o histórico de negociação
      HistorySelect(0,TimeCurrent());
      //--
      int    orders=HistoryDealsTotal();  // O número total de ofertas
      int    losses=0;                    // O número de ofertas de perda na série

      for(int i=orders-1;i>=0;i--)
        {
         ulong ticket=HistoryDealGetTicket(i);
         if(ticket==0)
           {
            Print("HistoryDealGetTicket failed, no trade history");
            break;
           }
         //--- verificando o símbolo de negociação
         if(HistoryDealGetString(ticket,DEAL_SYMBOL)!=_Symbol)
            continue;
         //--- verificando o lucro
         double profit=HistoryDealGetDouble(ticket,DEAL_PROFIT);
         if(profit>0.0)
            break;
         if(profit<0.0)
            losses++;
        }
      //---
      if(losses>1)
         lot=NormalizeDouble(lot-lot*losses/DecreaseFactor,1);
     }
//--- Normalizando e verificando os valores permitidos para o volume de negociações
   double stepvol=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_STEP);
   lot=stepvol*NormalizeDouble(lot/stepvol,0);

   double minvol=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_MIN);
   if(lot<minvol)
      lot=minvol;

   double maxvol=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_MAX);
   if(lot>maxvol)
      lot=maxvol;
//--- retorna o valor do volume de negociação
   return(lot);
  }

A função SymbolInfoDouble() é utilizada para verificar a disponibilidade de preços para o símbolo atual, em seguinda, a função OrderCalcMargin() é utilizada para solicitar a margem necessária para colocar uma ordem (neste caso uma ordem de compra). O tamanho inicial do lote é determinado a partir do valor da margem requerida para colocar uma ordem, a margem livre da conta (AccountInfoDouble(ACCOUNT_FREEMARGIN)) e o valor máximo permitido de risco especificadas no parâmetro de entrada MaximumRisk.

Se o valor do parâmetro de entrada DecreaseFactor é positivo, as ordens históricas são analisadas ​e o tamanho do lote é ajustado tendo em conta as informações sobre a série máxima de negócios com perda: o tamanho inicial do lote é multiplicado pelo tamanho (1-perdas/DecreaseFactor).

Em seguida, o volume de negociação é "arredondado" para o valor que é múltiplo do passo mínimo permitido do volume (stepvol) para o símbolo atual. Além disso, os valores máximos (maxvol) e mínimos (minvol) possíveis do volume de negociação são solicitados, e se o valor do lote sair dos limites desejados, ele é ajustado. Como resultado, a função retorna o valor calculado do volume de negóciação.

3.2. Função CheckForOpen()

CheckForOpen() é usado para verificar as condições das posições de abertura ela abre-a quando ocorrem as condições de negociação (neste caso, quando o preço cruza a média móvel).

//+------------------------------------------------------------------+
//| Verificar a existência das condições de abertura de posição      |
//+------------------------------------------------------------------+
void CheckForOpen(void)
  {
   MqlRates rt[2];
//--- Copia os valores do preço
   if(CopyRates(_Symbol,_Period,0,2,rt)!=2)
     {
      Print("CopyRates of ",_Symbol," failed, no history");
      return;
     }
//--- Negocia somento no primeiro tick da barra
   if(rt[1].tick_volume>1)
      return;
//--- Obtém o valor atual do indicador de média móvel 
   double   ma[1];
   if(CopyBuffer(ExtHandle,0,0,1,ma)!=1)
     {
      Print("CopyBuffer from iMA failed, no data");
      return;
     }
//--- verifica os sinais
   ENUM_ORDER_TYPE signal=WRONG_VALUE;

   if(rt[0].open>ma[0] && rt[0].close<ma[0])
      signal=ORDER_TYPE_SELL;    // condição de venda
   else
     {
      if(rt[0].open<ma[0] && rt[0].close>ma[0])
         signal=ORDER_TYPE_BUY;  // condição de compra
     }
//--- verificações adicionais
   if(signal!=WRONG_VALUE)
      if(TerminalInfoInteger(TERMINAL_TRADE_ALLOWED))
         if(Bars(_Symbol,_Period)>100)
           {
            CTrade trade;
            trade.PositionOpen(_Symbol,signal,TradeSizeOptimized(),
                               SymbolInfoDouble(_Symbol,signal==ORDER_TYPE_SELL ? SYMBOL_BID:SYMBOL_ASK),
                               0,0);
           }
//---
  }

Ao negociar usando o movimento, você precisa verificar se o preço cruza a média móvel. Usando a função CopyRates(), dois valores dos preços atuais são copiados no array de estruturas rt[], rt[1] corresponde à barra atual, rt[0] - barra completa.

Um nova barra é iniciada através da verificação do volume de escala da barra atual se ele for igual a 1, uma nova barra se iniciou Deve-se notar que este método de detecção de um nova barra pode falhar em alguns casos (quando as cotações vêm em pacotes), então o fato do início da formação de uma nova barra deve ser feita através do armazenamento e da comparação do tempo da cotação atual (ver IsNewBar).

O valor atual do indicador de média móvel é solicitado usando a função CopyBuffer() e ela é salva no array ma[] que contém apenas um valor. O programa verifica se o preço cruzou a média móvel e faz verificações adicionais (se a negociação com o EA é possível e se há a presença de barras no histórico). Se for bem sucedido, uma posição adequada para o símbolo é aberto chamando o método PositionOpen() do objeto de negociação (uma instância de CTrade).

O preço da abertura da posição é definida através da função SymbolInfoDouble() que retorna o preço de Bid ou Ask, dependendo do valor da variável de sinal. O volume da posição é determinada pela chamada de TradeSizeOptimized() descrito acima.

3.3. Função CheckForClose()

CheckForClose() verifica as condições para o fechamento da posição e fecha se as condições para fechamento ocorrer.

//+------------------------------------------------------------------+
//| Verifica a existência de condições de fechamento da posição      |
//+------------------------------------------------------------------+
void CheckForClose(void)
  {
   MqlRates rt[2];
//--- Copy price values
   if(CopyRates(_Symbol,_Period,0,2,rt)!=2)
     {
      Print("CopyRates of ",_Symbol," failed, no history");
      return;
     }
//--- Negocia somento no primeiro tick da nova barra
   if(rt[1].tick_volume>1)
      return;
//--- Obtêm o valor atual do indicador Média Móvel
   double   ma[1];
   if(CopyBuffer(ExtHandle,0,0,1,ma)!=1)
     {
      Print("CopyBuffer from iMA failed, no data");
      return;
     }
//--- Obter o tipo de posição selecionada anteriormente usando PositionSelect()
   bool signal=false;
   long type=PositionGetInteger(POSITION_TYPE);

   if(type==(long)POSITION_TYPE_BUY   && rt[0].open>ma[0] && rt[0].close<ma[0])
      signal=true;
   if(type==(long)POSITION_TYPE_SELL  && rt[0].open<ma[0] && rt[0].close>ma[0])
      signal=true;
//--- verificações adicionais
   if(signal)
      if(TerminalInfoInteger(TERMINAL_TRADE_ALLOWED))
         if(Bars(_Symbol,_Period)>100)
           {
            CTrade trade;
            trade.PositionClose(_Symbol,3);
           }
//---
  }

O algoritmo da função CheckForClose() é semelhante ao algoritmo CheckForOpen(). Dependendo da direção das posições atuais em aberto, as condições de seus fechamento são verificadas novamente (o preço cruza a MA para baixo para comprar ou para cima, para vender). Uma posição em aberto é fechada chamando o método PositionClose() do objeto de negociação (instância CTrade).

4. Backtesting

Os melhores valores dos parâmetros podem ser encontrados usando o Strategy Tester do terminal MetaTrader 5.

Por exemplo, quando se otimizar o parâmetro MovingPeriod no intervalo 2012.01.01-2013.08.01, os melhores resultados são obtidos com MovingPeriod = 45:

Resultados do Backtesting do Expert Advisor da média móvel

Conclusões:

O Expert Advisor de média móvel está incluído no pacote padrão do terminal MetaTrader 5 é um exemplo da utilização de indicadores técnicos, histórico de negociação, funções classes de negociação da biblioteca padrão. Além disso, o AE inclui um sistema de gestão de dinheiro que é baseado nos resultados das negociações