Combine Estratégias de Análise Fundamental e Técnica no MQL5 Para Iniciantes

Introdução

A análise fundamental e as estratégias de seguimento de tendência são frequentemente vistas como abordagens opostas. Muitos traders que preferem a análise fundamental acreditam que a análise técnica é uma perda de tempo, pois todas as informações necessárias já estão refletidas no preço. Por outro lado, os analistas técnicos muitas vezes consideram a análise fundamental falha, pois padrões idênticos, como ombro-cabeça-ombro, podem levar a resultados diferentes no mesmo mercado.

Para qualquer novo trader, isso pode parecer avassalador, pois existem tantas opções, mas qual é a melhor? Qual estratégia deixará sua conta de negociação consistentemente lucrativa enquanto o mantém fora do mercado durante condições desfavoráveis?

Como escritor, acredito que a verdade está em algum lugar no meio. O objetivo deste artigo é explorar se podemos criar uma estratégia de negociação estável que combine os melhores aspectos da análise fundamentalista e técnica, e determinar se tal estratégia vale o investimento de tempo.

Construiremos nosso Expert Advisor do zero usando MQL5 nativo, permitindo-nos testar nossa estratégia em qualquer mercado. Ao final deste artigo, você entenderá:

1. Como construir seus próprios Expert Advisors em MQL5.
2. Como combinar um conjunto de indicadores técnicos.
3. Um framework para conceituar dados fundamentais e técnicos. 

Visão Geral da Estratégia de Negociação

Nossa estratégia de negociação é composta por dois componentes:

1. Análise fundamentalista
2. Análise técnica
   

Vamos considerar cada abordagem separadamente para entender como elas se complementam, em vez de tentar determinar qual é superior. Começaremos compreendendo os princípios fundamentais que motivam nossa estratégia.

À primeira vista, os gráficos financeiros podem parecer muito aleatórios e imprevisíveis. Os conjuntos de dados financeiros são notoriamente ruidosos e, às vezes, até instáveis. No entanto, analisar esses gráficos sob uma perspectiva fundamentalista pode levar a conclusões totalmente diferentes sobre o comportamento do mercado.

Análise fundamentalista

A análise fundamentalista é baseada na compreensão de como os mercados operam. Em nossa discussão, focaremos em pares de moedas e construiremos nosso algoritmo de negociação para aproveitar nosso entendimento dos mercados de câmbio e seus principais participantes.

Fig 1: Um exemplo de análise fundamentalista no par AUDJPY.

Os traders fundamentalistas frequentemente discutem suporte e resistência, embora não existam definições definitivas para esses conceitos. Gostaria de oferecer uma possível interpretação sob uma perspectiva fundamentalista.

Quando olhamos para a taxa de câmbio entre duas moedas, é fácil esquecer as implicações no mundo real. Por exemplo, se o gráfico USDJPY estiver subindo, isso significa que o iene japonês está se desvalorizando em relação ao dólar. Como 90% das commodities do mundo são precificadas em dólares, um gráfico ascendente indica que as exportações do Japão estão rendendo menos dinheiro no exterior.

Se a taxa de câmbio continuar subindo sem limites, o governo japonês enfrentaria desafios significativos. Suas exportações valeriam muito pouco, levando a dificuldades econômicas e a uma queda no padrão de vida. As famílias poderiam ter dificuldades para pagar itens essenciais, e o país poderia enfrentar hiperinflação e condições econômicas severas.

Para evitar esses resultados, é crucial para o bem-estar do Japão que a taxa de câmbio entre o iene e o dólar americano permaneça dentro de uma faixa tolerável. Quando a taxa de câmbio se torna muito alta, o governo japonês tem incentivo para intervir no mercado de câmbio para proteger sua economia. Por outro lado, quando a taxa de câmbio está muito baixa, o governo dos EUA pode fornecer suporte para manter o equilíbrio. É assim que suporte e resistência podem ser interpretados sob uma perspectiva fundamentalista.

Na maioria dos casos, as taxas de câmbio são definidas pelas decisões cumulativas tomadas por grandes instituições financeiras, como bancos de varejo, bancos de investimento e fundos de hedge. Essas grandes instituições controlam enormes volumes de dinheiro, e suas decisões em conjunto são o que movem os mercados.

Portanto, sob uma perspectiva fundamentalista, não gostaríamos de negociar contra esses grandes participantes do mercado. Em vez disso, preferimos encontrar oportunidades para operar na mesma direção que os principais players do mercado.

Ao analisar as mudanças de preço em prazos mais longos, como gráficos semanais ou mensais, podemos obter uma visão sobre o que os grandes investidores institucionais consideram um preço justo para o ativo analisado. Portanto, procuraremos oportunidades de negociação que estejam alinhadas com a mudança de preço no longo prazo..

Resumindo, nossa estratégia fundamentalista envolve várias etapas. Primeiro, analisamos prazos maiores para entender onde os investidores institucionais provavelmente levarão o preço. Uma vez confirmado, identificamos nossos níveis de suporte e resistência examinando os preços mais altos e mais baixos da semana anterior. Nosso objetivo é negociar configurações de alta probabilidade. Assim, se o preço ultrapassar o nível de resistência, entraremos em uma posição de compra. Por outro lado, se o preço cair abaixo do nível de suporte, entraremos em uma posição de venda.

Análise técnica

Agora, vamos definir a análise técnica envolvida em nossa estratégia de negociação. Nossa análise técnica se concentra em identificar configurações de negociação onde nossos indicadores se alinham com nossa análise fundamentalista. Isso significa que, se a tendência nos prazos mais longos for de alta, buscamos apenas configurações onde nossos indicadores técnicos sinalizem uma entrada compradora. Por outro lado, se a tendência nos prazos mais longos for de baixa, buscamos apenas configurações onde nossos indicadores sinalizem uma venda.

O primeiro indicador do nosso conjunto é o Índice de Fluxo de Dinheiro (MFI). O MFI funciona como um indicador de volume e desempenha um papel crucial em nossa estratégia. Somente consideramos negociações com suporte de volume significativo. Negociações com volume fraco ou contrário não estão dentro do nosso escopo. Em nossa estratégia, interpretamos o MFI de maneira diferente dos métodos convencionais. Centralizamos o MFI em 50: leituras abaixo de 50 indicam volume vendedor, enquanto leituras acima de 50 indicam volume comprador.

Em seguida, utilizamos o indicador MACD (Média Móvel de Convergência e Divergência). Assim como no MFI, não usamos o MACD de maneira tradicional. Em vez disso, centralizamos o MACD em 0. Se a linha de sinal do MACD estiver abaixo de 0, sinaliza uma tendência de baixa; se estiver acima de 0, indica uma tendência de alta.

Além do MFI e do MACD, nossa estratégia incorpora um método clássico de acompanhamento de tendências usando uma média móvel. Diferente de nossa abordagem com outros indicadores, interpretamos a média móvel de maneira convencional: - Se o preço estiver abaixo da média móvel, sinaliza uma venda. - Se o preço estiver acima da média móvel, sinaliza uma compra.

Além disso, integramos o Oscilador Estocástico à nossa estratégia, utilizando sua interpretação tradicional: Quando o oscilador estiver acima de 20, consideramos um sinal de compra. Quando estiver abaixo de 80, consideramos um sinal de venda.

Agora, vamos começar!

1. Primeiro, importamos as bibliotecas necessárias.
2. Neste caso, importaremos a biblioteca de trade para executar ordens de negociação.
3. A leitura do MFI deve ser maior que 50
4. O oscilador estocástico deve estar acima de 20
5. O preço deve ter se apreciado nos últimos 3 meses
6. Os níveis de preço devem estar acima do nível de suporte.

E, inversamente, para vendermos um ativo:

1. O preço deve fechar abaixo da média móvel
2. O sinal do MACD deve estar abaixo de 0
3. A leitura do MFI deve ser menor que 50
4. O oscilador estocástico deve estar abaixo de 80
5. O preço deve ter se depreciado nos últimos 3 meses
6. Os níveis de preço devem estar abaixo do nível de resistência.

Vamos começar então.

Primeiro, importamos as bibliotecas necessárias. Neste caso, importaremos a biblioteca de trade para executar ordens de negociação.

//+------------------------------------------------------------------+
//|                           Price Action & Trend Following.mq5     |
//|                        Copyright 2024, MetaQuotes Ltd.           |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Gamuchirai Zororo Ndawana"
#property link      "https://www.mql5.com"
#property version   "1.00"

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
/*
   This Expert Advisor will help us implement a combination of fundamental analysis
   and trend following principles to trade financial securities with precision
   thanks to the easy to learn MQL5 Language that gives us a blend of creative
   flexibility and technical control at the same time.

   Our Fundamental strategy follows the principles outlined below:
   1)Respect price movements on higher order time frames
   2)Enter at support levels and exit on resistance levels

   Our Trend following strategy follows principles that have been proven over time:
   1)Only enter trades backed by volume
   2)Do not trade against the dominant trend, rather wait for setups to go with the bigger trend.
   3)Use an ensemble of good confirmation indicators

   Gamuchirai Zororo Ndawana
   Selebi Phikwe
   Botswana
   11:06 Thursday 11 July 2024
*/

//+------------------------------------------------------------------+
//| Include necessary libraries                                      |
//+------------------------------------------------------------------+
#include <Trade/Trade.mqh>
CTrade Trade;

Avançando, agora precisamos definir os inputs para o nosso programa. Esses inputs irão controlar os períodos dos nossos indicadores técnicos, o tamanho do lote de negociação desejado e outras variáveis desse tipo.

//+------------------------------------------------------------------+
//| Input parameters for technical indicators                        |
//+------------------------------------------------------------------+
input int stoch_percent_k = 5; // Stochastic %K
input int stoch_percent_d = 3; // Stochastic %D
input int stoch_slowing   = 3; // Stochastic Slowing

input int macd_fast_ema = 12; // MACD Fast EMA
input int macd_slow_ema = 26; // MACD Slow EMA
input int macd_sma = 9;       // MACD SMA

input int ma_period = 60; // Moving Average Period
input int mfi_period = 14; // MFI Period

input int lot_multiple = 10; // Lot size multiplier

Agora, vamos criar variáveis globais que usaremos ao longo de nossa aplicação. Essas variáveis armazenarão nossos níveis de suporte e resistência, buffers de indicadores técnicos, preços de compra (ask) e venda (bid) e outras informações dessa natureza.

//+------------------------------------------------------------------+
//| Global variables                                                 |
//+------------------------------------------------------------------+
double ask, bid;               // Ask and Bid prices
double min_distance = 0.2;     // Minimum distance for stoploss
double min_lot_size = 0;       // Minimum lot size
double position_size;          // Actual position size

double last_week_high = 0;     // High of the previous week
double last_week_low = 0;      // Low of the previous week

string last_week_high_name = "last week high"; // Name for high level object
string last_week_low_name = "last week low";   // Name for low level object

double higher_time_frame_change = 0.0; // Change on higher time frame
string zone_location = "";             // Current zone location

int zone = 0;                // Zone indicator
string higher_time_frame_trend = ""; // Higher time frame trend
int trend = 0;               // Trend indicator

int ma_handler, stoch_handler, macd_handler, mfi_handler; // Handlers for indicators
double ma_reading[], stoch_signal_reading[], macd_signal_reading[], mfi_reading[]; // Buffers for indicator readings

Nosso objetivo agora é definir nosso manipulador OnInit(). Nesta função, inicializaremos nossos indicadores técnicos e ajustaremos adequadamente o tamanho do lote de negociação.

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- Set up handlers for technical indicators
   ma_handler = iMA(_Symbol, PERIOD_CURRENT, ma_period, 0, MODE_EMA, PRICE_CLOSE);
   macd_handler = iMACD(_Symbol, PERIOD_CURRENT, macd_fast_ema, macd_slow_ema, macd_sma, PRICE_CLOSE);
   stoch_handler = iStochastic(_Symbol, PERIOD_CURRENT, stoch_percent_k, stoch_percent_d, stoch_slowing, MODE_EMA, STO_CLOSECLOSE);
   mfi_handler = iMFI(_Symbol, PERIOD_CURRENT, mfi_period, VOLUME_TICK);

//--- Adjust lot size
   min_lot_size = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
   position_size = min_lot_size * lot_multiple;

//--- Initialization done
   return(INIT_SUCCEEDED);
  }

Agora, definiremos uma função que buscará os níveis de suporte e resistência definidos pelo histórico de negociação da semana passada.

//+------------------------------------------------------------------+
//| Function to get the previous week's high and low prices          |
//+------------------------------------------------------------------+
bool get_last_week_high_low(void)
  {
//--- Reset values
   last_week_high = 0;
   last_week_low = 0;

//--- Remove old levels if any
   ObjectDelete(0, last_week_high_name);
   ObjectDelete(0, last_week_low_name);

//--- Update high and low values
   last_week_high = iHigh(_Symbol, PERIOD_W1, 1);
   last_week_low = iLow(_Symbol, PERIOD_W1, 1);

//--- Mark current levels of support and resistance
   ObjectCreate(0, last_week_high_name, OBJ_HLINE, 0, 0, last_week_high);
   ObjectCreate(0, last_week_low_name, OBJ_HLINE, 0, 0, last_week_low);

//--- Check for valid values
   return((last_week_high * last_week_low) != 0);
  }

Seguindo em frente, precisamos entender a ação do preço nos prazos mais longos. Lembre-se de que analisaremos os últimos três meses, aproximadamente um ciclo de negócios, para inferir o que os players institucionais têm feito no mercado.

//+------------------------------------------------------------------+
//| Function to determine higher time frame price movement           |
//+------------------------------------------------------------------+
bool get_higher_time_frame_move(void)
  {
//--- Analyze weekly time frame
   higher_time_frame_change = iClose(_Symbol, PERIOD_CURRENT, 1) - iClose(_Symbol, PERIOD_W1, 12);

//--- Check for valid values
   return((iClose(_Symbol, PERIOD_W1, 12) * iClose(_Symbol, PERIOD_W1, 1)) != 0);
  }

Nosso próximo passo será interpretar os sinais de ação do preço que coletamos. Em particular, precisamos entender se estamos acima da máxima da semana passada, que indicamos como zona 1, ou se estamos abaixo da mínima da semana passada, o que significa que estamos na zona 3. Finalmente, se estivermos entre essas duas regiões, estaremos na zona 2. Em seguida, rotularemos a tendência identificada no prazo mais longo: se o preço estiver se apreciando no prazo mais longo, rotularemos a tendência como 1; caso contrário, rotularemos como -1.

//+------------------------------------------------------------------+
//| Function to interpret price action data                          |
//+------------------------------------------------------------------+
void interpet_price_action(void)
  {
//--- Determine zone location based on last week's high and low
   if(iClose(_Symbol, PERIOD_CURRENT, 0) > last_week_high)
     {
      zone = 1;
      zone_location = "We are above last week's high";
     }
   else if(iClose(_Symbol, PERIOD_CURRENT, 0) < last_week_low)
     {
      zone = 3;
      zone_location = "We are below last week's low";
     }
   else
     {
      zone = 2;
      zone_location = "We are stuck inside last week's range";
     }

//--- Determine higher time frame trend
   if(higher_time_frame_change > 0)
     {
      higher_time_frame_trend = "Higher time frames are in an up trend";
      trend = 1;
     }
   else if(higher_time_frame_change < 0)
     {
      higher_time_frame_trend = "Higher time frames are in a down trend";
      trend = -1;
     }
  }

Agora, precisaremos de uma função que atualizará os valores dos nossos indicadores técnicos e buscará os dados atuais do mercado.

//+------------------------------------------------------------------+
//| Function to update technical indicators and fetch market data    |
//+------------------------------------------------------------------+
void update_technical_indicators(void)
  {
//--- Update market prices
   ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
   bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);

//--- Copy indicator buffers
   CopyBuffer(ma_handler, 0, 1, 1, ma_reading);
   CopyBuffer(stoch_handler, 1, 1, 1, stoch_signal_reading);
   CopyBuffer(macd_handler, 1, 1, 1, macd_signal_reading);
   CopyBuffer(mfi_handler, 0, 1, 1, mfi_reading);
  }

Essa função executará nossas entradas de negociação. Se tivermos permissão da nossa função de sentimento baixista, abriremos uma operação de venda. Por outro lado, só podemos abrir posições de compra se tivermos permissão da nossa função de sentimento altista.

//+------------------------------------------------------------------+
//| Function to find entry points for trades                         |
//+------------------------------------------------------------------+
void find_entry(void)
  {
//--- Check for bullish sentiment
   if(bullish_sentiment())
     {
      Trade.Buy(position_size, _Symbol, ask, (last_week_low - min_distance), (last_week_high + min_distance));
     }
//--- Check for bearish sentiment
   else if(bearish_sentiment())
     {
      Trade.Sell(position_size, _Symbol, bid, (last_week_high + min_distance), (last_week_low - min_distance));
     }
  }

Agora, vamos definir cuidadosamente o que significa que nossos dois sistemas de negociação estejam alinhados para uma configuração de compra. Relembrando as condições que definimos anteriormente em nossa discussão, queremos ver o preço fechando acima da média móvel, nosso indicador MFI deve estar acima de 50, nossa leitura do MACD deve estar acima de 0, o oscilador estocástico deve estar acima de 20, a tendência no prazo mais longo deve ser de alta e devemos estar acima do nível de suporte.

//+------------------------------------------------------------------+
//| Function to analyze bullish signals                              |
//+------------------------------------------------------------------+
bool bullish_sentiment(void)
  {
//--- Analyze conditions for bullish sentiment
   return((mfi_reading[0] > 50) &&
          (iClose(_Symbol, PERIOD_CURRENT, 1) > ma_reading[0]) &&
          (macd_signal_reading[0] > 0) &&
          (stoch_signal_reading[0] > 20) &&
          (trend == 1) &&
          (zone < 3));
  }

O mesmo raciocínio se aplica para nossas configurações de venda, mas de maneira inversa.

//+------------------------------------------------------------------+
//| Function to analyze bearish signals                              |
//+------------------------------------------------------------------+
bool bearish_sentiment(void)
  {
//--- Analyze conditions for bearish sentiment
   return((mfi_reading[0] < 50) &&
          (iClose(_Symbol, PERIOD_CURRENT, 1) < ma_reading[0]) &&
          (macd_signal_reading[0] > 0) &&
          (stoch_signal_reading[0] < 80) &&
          (trend == -1) &&
          (zone > 1));
  }

Por fim, precisamos de um manipulador de eventos OnTick() que garantirá que o fluxo de eventos em nossa aplicação funcione conforme o esperado. Observe que começamos verificando a marcação de tempo (timestamp). Isso nos ajuda a garantir que nossa aplicação só verificará os níveis de suporte e resistência uma vez por semana. Caso contrário, se não tivermos novos candles semanais, não há motivo para verificar as mesmas informações repetidamente a cada tick! Se tudo estiver funcionando corretamente, nosso Expert Advisor então procederá para interpretar a ação do preço, atualizar nossos indicadores técnicos e buscar uma entrada de negociação.

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- Check for new candle on higher time frame
   static datetime time_stamp;
   datetime current_time = iTime(_Symbol, PERIOD_W1, 0);

   if(time_stamp != current_time)
     {
      time_stamp = current_time;

      if(!get_last_week_high_low())
        {
         Print("Failed to get historical performance of ", _Symbol);
         Print("[ERROR]: ", GetLastError());
        }
      else if(!get_higher_time_frame_move())
        {
         Print("Failed to analyze historical performance of ", _Symbol);
         Print("[ERROR]: ", GetLastError());
        }
     }
   else
     {
      interpet_price_action();
      update_technical_indicators();
      if(PositionsTotal() == 0)
        {
         find_entry();
        }
      Comment("Last week high: ", last_week_high, "\nLast week low: ", last_week_low, "\nZone: ", zone_location, "\nTrend: ", higher_time_frame_trend);
     }
  }

Fig 2: Nosso Expert Advisor negociando o par AUDJPY no período H1.

Fig 3: Os resultados do backtest do nosso algoritmo de negociação nos dados H1 do símbolo AUDJPY ao longo de 1 mês.

Conclusão

Este artigo ilustra a integração da análise fundamentalista e técnica em estratégias de negociação. Usando MQL5, mostramos como combinar perfeitamente insights dessas duas perspectivas em instruções de negociação acionáveis. Ao apresentar uma estrutura onde os dados fundamentais e técnicos se complementam, em vez de competirem, capacitamos os leitores a aproveitar ambas as abordagens de forma eficaz.