English Русский Español Deutsch 日本語
preview
Do iniciante ao especialista: negociação com níveis de Fibonacci após a divulgação do NFP

Do iniciante ao especialista: negociação com níveis de Fibonacci após a divulgação do NFP

MetaTrader 5 — Exemplos |
18 0
Clemence Benjamin
Clemence Benjamin

Seções


Introdução

Perder o momento de divulgação de notícias econômicas importantes, como o NFP (relatório de emprego não agrícola dos Estados Unidos), frequentemente provoca FOMO (medo de perder uma oportunidade). Isso geralmente acontece porque os traders tentam aproveitar um movimento mesmo depois que ele já terminou. Na maioria dos casos, o impulso inicial dura menos de um minuto e provoca um deslocamento de muitos pips em uma direção favorável. Entrar no mercado tardiamente nessas situações é extremamente arriscado, pois o movimento inicial já terminou e o preço pode reverter rapidamente, causando perdas significativas.

Os traders profissionais, por outro lado, não perseguem esses movimentos bruscos. Em vez disso, preparam-se antecipadamente para entrar no mercado mais cedo e com menor risco ou aguardam pacientemente que o mercado se recupere e ofereça novas oportunidades em níveis de entrada cuidadosamente definidos. Sua vantagem está em compreender os princípios das retrações de Fibonacci e manter a disciplina necessária para esperar até que as condições adequadas se apresentem.

Neste artigo, examinaremos os desafios da negociação após movimentos bruscos provocados por notícias econômicas, aplicando os princípios de Fibonacci de forma algorítmica. Antes de avançarmos para o desenvolvimento e a implementação da estratégia, apresentaremos uma breve introdução ao conceito de Fibonacci para os leitores que ainda não estão familiarizados com ele.

Breve introdução à retração de Fibonacci

Desenvolvida há muitos séculos pelo matemático italiano Leonardo Bonacci, amplamente conhecido como Fibonacci, a sequência de Fibonacci tornou-se uma das ferramentas mais influentes da análise técnica moderna. Matematicamente, a sequência é simples: cada número corresponde à soma dos dois anteriores (1, 1, 2, 3, 5, 8, 13, ...). Ainda assim, sua presença na natureza, na arquitetura e até mesmo no comportamento humano fascina estudiosos há gerações.

Nos mercados financeiros, a sequência é aplicada por meio dos níveis de retração de Fibonacci (Fibonacci retracement), um método utilizado pelos traders para identificar possíveis zonas de reversão ou continuação da tendência durante as correções do mercado. As proporções de retração mais utilizadas são 23,6%, 38,2%, 50%, 61,8% e 78,6%, associadas às relações numéricas da sequência de Fibonacci. Esses níveis funcionam como referências psicológicas que ajudam os traders a antecipar possíveis reações do preço, como uma pausa no movimento, um repique ou uma reversão.

O princípio fundamental das retrações é que os mercados nunca se movem em linha reta. Após um movimento acentuado de alta ou de baixa, os preços geralmente apresentam uma retração antes de retomar a tendência predominante. A ferramenta de retração de Fibonacci (Fibonacci retracement) oferece uma estrutura para medir a provável profundidade desses movimentos. Por exemplo:

  • Uma retração de 38,2% geralmente indica um pequeno recuo dentro de uma tendência forte.
  • Uma retração de 50% (embora não corresponda a uma proporção derivada diretamente da sequência de Fibonacci) é amplamente utilizada como nível de correção correspondente ao ponto médio.
  • Uma retração de 61,8%, conhecida como "proporção áurea", é considerada o nível mais crítico, no qual frequentemente ocorrem reversões significativas.

Na prática, os níveis de Fibonacci raramente são utilizados isoladamente. Sua eficácia aumenta quando combinados com a ação do preço, níveis de suporte e resistência, médias móveis ou movimentos de mercado associados a eventos específicos, como as retrações que ocorrem logo após movimentos bruscos provocados por notícias importantes.

Nesta estratégia, nosso foco é a negociação após a divulgação do NFP, utilizando as retrações de Fibonacci para filtrar o ruído provocado pelo impulso inicial e orientar os traders na identificação de pontos de entrada bem definidos e com maior probabilidade de sucesso. Em vez de ceder ao FOMO, o trader aprende a "esperar pela retração" e entrar no mercado em níveis de preço mais estáveis. A MQL5 Community disponibiliza uma ampla variedade de conteúdos sobre Fibonacci para quem deseja aprofundar seus conhecimentos.

Disponibilidade no terminal MetaTrader 5

Na interface padrão do MetaTrader 5, a barra de ferramentas de desenho dos gráficos está organizada por prioridade e pronta para uso, com os objetos analíticos mais utilizados já disponíveis para aplicação direta nos gráficos. As ferramentas de desenho, como o objeto Fibonacci Retracement, possuem pontos de ancoragem que podem ser arrastados até máximas e mínimas de oscilação para representar visualmente os níveis de preço. Os traders utilizam esses objetos tanto para analisar como o preço reagiu a determinados níveis no passado quanto para identificar possíveis zonas de retração em correções futuras.

Dicas práticas:

  • Arraste a ferramenta entre uma máxima e uma mínima de oscilação bem definidas (ou vice-versa), ancorando a retração em pontos de referência significativos.
  • Utilize as alças de controle dos pontos de ancoragem para ajustar o posicionamento com precisão, alinhando os níveis aos preços de fechamento ou às sombras dos candles, conforme o critério adotado.
  • Salve seus templates ou perfis mais utilizados para ter acesso imediato às configurações de Fibonacci e à disposição dos elementos gráficos de sua preferência em todos os gráficos.

A Figura 1 abaixo mostra uma retração de Fibonacci aplicada ao gráfico.

Aplicação da ferramenta de retração de Fibonacci no terminal MetaTrader 5

Figura 1. Aplicação da ferramenta de retração de Fibonacci no terminal MetaTrader 5

Análise conceitual com base na divulgação dos dados de emprego não agrícola de 5 de setembro de 2025:

A análise manual dos movimentos de preço após a divulgação do NFP em 5 de setembro de 2025 reforça a ideia de que os níveis de retração de Fibonacci podem influenciar significativamente os pontos de entrada após o evento. As ilustrações a seguir utilizam a ferramenta Fibonacci Retracement para mostrar como o preço testou e respeitou determinados níveis após o impulso inicial, ajudando a distinguir zonas de reentrada com maior probabilidade de sucesso do ruído do mercado.

Essas observações permitem desenvolver regras mais disciplinadas para o posicionamento de ordens e a gestão de riscos, com base nas faixas de retração e em dois preços de referência próximos: o nível anterior ao impulso e o extremo atingido durante o movimento inicial. Para facilitar a compreensão, analisamos os gráficos de três pares de moedas que incluem o dólar americano, pois esses pares geralmente apresentam movimentos mais intensos e consistentes em resposta à divulgação de importantes indicadores econômicos dos Estados Unidos.

Nossa análise utiliza as divulgações mais recentes do relatório NFP disponíveis no momento da elaboração deste artigo. Como exemplo, examinamos três pares que incluem o dólar americano, GBP/USD, USD/JPY e EUR/USD, antes de transformar o conceito em um algoritmo. As capturas de tela dos gráficos a seguir ilustram o funcionamento do método em cada caso.

EURUSD após o NFP de 05/09/25

Figura 2. EURUSD, M5, ação do preço após a divulgação do relatório NFP

Na Figura 2 (EUR/USD, M5), o preço demonstra claramente o comportamento esperado de uma retração. Os pontos A e B representam, respectivamente, o nível de referência anterior ao impulso e o extremo alcançado após a divulgação do NFP. A ferramenta de retração de Fibonacci é traçada do ponto A (nível de referência) até o ponto B (máxima do impulso), tomando como referência a vela M5 cujo fechamento é o primeiro após a divulgação. Em seguida, o preço recuou para testar as faixas de Fibonacci, respeitando claramente os níveis de retração. Nesse exemplo, o preço atingiu o nível de 50%, que funcionou como um importante ponto de reação. Posteriormente, voltou a recuar para testar a retração de 61,8%, ultrapassando ligeiramente esse nível, mas sem retornar completamente ao ponto de referência inicial (100%). Após esse pequeno salto de preço, o impulso de alta foi retomado e o mercado atingiu uma nova máxima, superando o extremo alcançado durante o impulso inicial e confirmando a continuidade da tendência de alta.

Figura 2: GBPUSD, M5, ação do preço após a divulgação do relatório NFP

Figura 3. GBPUSD, M5, ação do preço após a divulgação do relatório NFP.

O par EUR/USD apresenta uma forte correlação com o GBP/USD, que registrou uma reação de alta semelhante, embora não idêntica, à divulgação do relatório. A Figura 3 (acima) apresenta o par GBP/USD com a mesma sobreposição de linhas de Fibonacci utilizada na Figura 2, ilustrando a reação do preço à notícia e reforçando a consistência do comportamento das retrações entre os dois pares.

USDJPY, M5

Figura 4. USDJPY, M5, ação do preço após a divulgação do relatório NFP.

A Figura 4 (USD/JPY) mostra uma clara reação de baixa à divulgação do relatório NFP. Após o impulso inicial de queda (pontos A→B), o preço apresentou um movimento de retorno até aproximadamente o nível de retração de 50% de Fibonacci, antes de retomar a trajetória descendente e atingir novas mínimas. Em conjunto, os três gráficos (EUR/USD, GBP/USD e USD/JPY) indicam que o retorno do preço às zonas de Fibonacci continua sendo uma possibilidade recorrente após movimentos bruscos provocados por notícias, mesmo quando a direção do movimento varia entre os pares.

Implicações e abordagem geral (antes da implementação em código)

Com base nos três exemplos analisados (EUR/USD, GBP/USD e USD/JPY), podemos elaborar um plano geral e conciso para transformar essa ideia em um algoritmo:

Definições
  • P_base: nível de referência anterior ao movimento brusco (preço a partir do qual o movimento rápido começou).
  • P_spike: extremo do impulso inicial (preço máximo em um movimento de alta ou mínimo em um movimento de baixa).
  • Direção do impulso: de alta, se P_spike > P_base (movimento brusco ascendente); de baixa, se p_spike < P_base (movimento brusco descendente).
Lógica de entrada (para ambas as direções)
1. Trace os níveis de retração de Fibonacci entre P_base e P_spike após o fechamento da primeira vela de referência posterior ao evento. 2. Aguarde uma retração estruturada até a zona-alvo (por exemplo, entre 38,2% e 61,8%), acompanhada do critério de confirmação escolhido, como fechamento de vela, rejeição pela sombra do candle ou normalização do volume de ticks. 3. Para um movimento brusco de alta (o preço sobe rapidamente e depois apresenta uma retração):
  • Entrada: abra uma posição comprada quando o preço retornar à zona de Fibonacci selecionada e houver confirmação do sinal.
  • Take-profit (TP): estabeleça o TP principal em P_spike (máxima do impulso inicial). Alvos secundários ou estendidos podem utilizar extensões de Fibonacci ou múltiplos do ATR.
  • Stop-loss (SL): posicione o SL em P_base ou ligeiramente abaixo desse nível (base do impulso ou início do movimento rápido). Acrescente uma pequena margem de segurança (por exemplo, spread + X pips) para evitar que a posição seja encerrada por pequenas oscilações de preço.
4. Para um movimento brusco de baixa (o preço cai rapidamente e depois apresenta uma retração):
  • Entrada: abra uma posição vendida quando o preço retornar à zona de Fibonacci selecionada e houver confirmação do sinal.
  • Take-profit (TP): estabeleça o TP principal em P_spike (mínima do impulso inicial de baixa).
  • Stop-loss (SL): posicione o SL em P_base ou ligeiramente acima desse nível (início do movimento rápido de baixa), acrescentando uma pequena margem de segurança.
Por que associar esses níveis?
  • Utilizar P_spike como TP alinha o objetivo da operação ao extremo mais recente e claramente identificado. A intenção é aproveitar um novo teste do extremo atingido durante o impulso inicial, ou seja, um retorno ao extremo do movimento brusco.
  • Utilizar P_base como SL estabelece o ponto de origem do movimento rápido como referência lógica para invalidar a hipótese de negociação. Se o preço retornar ao ponto inicial, a premissa de continuação do movimento após a retração deixa de ser válida.

Ajustes práticos e controle de riscos

Adicionaremos uma pequena margem ao SL (por exemplo, alguns pips ou o spread multiplicado por 1,5) e calcularemos o tamanho do lote com base no percentual de risco da conta e na distância entre o SL e o preço de entrada, mantendo o risco financeiro absoluto em um nível baixo (meta de risco de 0,5% da conta). Se o nível P_base resultar em um SL excessivamente distante, ofereceremos como parâmetro configurável uma alternativa mais próxima do preço de entrada, baseada no próximo nível de Fibonacci ou no ATR de 5 minutos multiplicado por um coeficiente. O EA permitirá realizar saídas parciais em P_spike, encerrar a posição remanescente, cancelar automaticamente ordens limitadas pendentes após M minutos e ativar, opcionalmente, a confirmação por pares de moedas correlacionados.

Planejamento da estratégia com Fibonacci

Figura 5. Visão geral da estratégia de reentrada com Fibonacci após a divulgação do NFP

A Figura 5 (acima) apresenta uma representação conceitual da estratégia. Para uma tendência de alta, posicione o stop-loss ligeiramente abaixo do ponto A (base do movimento brusco) e o take-profit acima do ponto B (extremo do impulso). Para uma tendência de baixa, posicione o stop-loss acima de A e o take-profit abaixo de B, como no exemplo típico do par USDJPY apresentado na Figura 4. Acrescente uma pequena margem de segurança ao stop-loss (por exemplo, alguns pips ou o spread multiplicado por 1,5) para reduzir os acionamentos indevidos provocados por pequenas oscilações de preço.

Casos-limite

Se o preço apresentar uma retração completa de 100% (ou seja, retornar a P_base) e continuar avançando além desse nível, considere invalidar a hipótese inicial. Nesse caso, a retração foi concluída e o movimento pode estar se invertendo.

Se a direção do impulso inicial não estiver clara ou se a amplitude do movimento não atingir o mínimo estabelecido em barras ou pips, descarte a operação devido ao excesso de ruído.


Implementação da estratégia

Para simplificar o desenvolvimento, implementei um arquivo de cabeçalho que define uma classe no MetaEditor 5, responsável por gerenciar as marcas de tempo das divulgações do relatório de emprego não agrícola (NFP) e convertê-las corretamente entre o horário do leste dos Estados Unidos (ET), o UTC e o horário do servidor da corretora. Esse arquivo centraliza o tratamento das mudanças de horário de verão, o cálculo do deslocamento em relação ao horário ET e as funções auxiliares de conversão, permitindo que os demais módulos funcionem independentemente dos fusos horários.

Com base nesse arquivo de cabeçalho, desenvolvi um EA que:

  • Identifica a primeira vela M5 que fecha após a divulgação do relatório NFP.
  • Traça os níveis de retração de Fibonacci com base nessa vela.
  • Posiciona ordens pendentes nos níveis de 38,2%, 50,0% e 61,8%.
  • Realiza verificações rigorosas das restrições da corretora, incluindo distâncias mínimas para níveis de stop e ordens pendentes, normalização de valores e prazos de expiração.
  • Gerencia o ciclo de vida dos objetos gráficos e das ordens pendentes, realizando a limpeza dos recursos monitorados após a execução de uma ordem ou a expiração da configuração.

Nas próximas duas etapas, apresentaremos explicações detalhadas do código, voltadas aos desenvolvedores. Primeiro, examinaremos o arquivo de cabeçalho NFPTimeManager, incluindo as decisões de projeto, a API e a lógica de tratamento dos fusos horários e do horário de verão. Em seguida, analisaremos o EA, abordando o fluxo de dados, o gerenciamento de ordens e as verificações de segurança. Essas explicações mostrarão como o sistema foi projetado, implementado e testado em MQL5.

Etapa 1: arquivo de cabeçalho NFPTimeManager

1.1. Cabeçalho do arquivo e metadados

O arquivo começa com um bloco de cabeçalho padrão e as diretivas #property do MQL5. O cabeçalho contém informações de autoria e controle de versão, permitindo que outros desenvolvedores, ou você mesmo no futuro, identifiquem imediatamente a finalidade e a origem do arquivo. As diretivas de propriedade permitem que o sistema de compilação do MQL5 apresente os metadados no MetaEditor 5.

//+------------------------------------------------------------------+ 
//|                                               NFPTimeManager.mqh  |
//|                        Copyright 2025, Clemence Benjamin  |
//|                                       https://www.mql5.com/ru/users/billionaire2024/seller|
//+------------------------------------------------------------------+
#property copyright "Clemence Benjamin"
#property version   "1.0"

1.2. Declaração da classe e campos privados de fuso horário

Encapsulamos todas as funções auxiliares relacionadas ao NFP na classe CNFPTimeManager. Dois campos inteiros privados armazenam as configurações de fuso horário do trader, que são opcionais, e do servidor da corretora. Manter esses valores internamente garante um comportamento determinístico das funções de conversão e evita que a lógica de tratamento dos fusos horários fique dispersa por toda a base de código.

class CNFPTimeManager
{
private:
   int      m_traderTimeZone; // Trader time zone offset from UTC (hours) - optional
   int      m_serverTimeZone; // Server time zone offset from UTC (hours)

1.3. GetETOffset: cálculo do deslocamento do horário ET considerando o horário de verão (DST)

O relatório NFP é divulgado em um horário fixo do leste dos Estados Unidos (08h30 ET). A função GetETOffset determina se, na data informada, está em vigor o horário padrão do leste (UTC−5) ou o horário de verão do leste (UTC−4). Para isso, aplica as regras de horário de verão dos Estados Unidos, que vigora do segundo domingo de março ao primeiro domingo de novembro, e retorna o deslocamento inteiro em relação ao UTC. Isso permite manter a precisão dos cálculos de datas e horários ao longo do ano.

   // returns ET offset (-4 for EDT, -5 for EST) for a given datetime (trader time context)
   int GetETOffset(datetime time)
   {
      MqlDateTime dt;
      TimeToStruct(time, dt);
      int year = dt.year;

      // DST: 2nd Sunday of March to 1st Sunday of November (US rules)
      datetime dst_start = GetNthDayOfWeek(year, 3, 0, 2); // 2nd Sunday of March
      datetime dst_end   = GetNthDayOfWeek(year, 11, 0, 1); // 1st Sunday of November
      // Note: We interpret the DST boundaries as local US/Eastern dates at 02:00 local time,
      // but for our purpose using whole-day thresholds is acceptable (NFP at 8:30 ET).
      if(time >= dst_start && time < dst_end)
         return -4; // EDT
      return -5;    // EST
   }

1.4. GetNthDayOfWeek: cálculo confiável de datas no calendário mensal

Cálculos de calendário, como determinar o "segundo domingo de março", podem ser surpreendentemente propensos a erros. A função GetNthDayOfWeek obtém a data do primeiro dia do mês, identifica o dia da semana correspondente e calcula o deslocamento necessário para encontrar a N-ésima ocorrência do dia da semana solicitado. A função retorna um valor datetime preciso para a data desejada e é reutilizada no cálculo das marcas de tempo relacionadas ao horário de verão e às divulgações do NFP.

   // correctly compute the N-th day_of_week (0=Sunday..6=Saturday) in given month/year
   datetime GetNthDayOfWeek(int year, int month, int day_of_week, int n)
   {
      MqlDateTime dt;
      // build date for the 1st of month
      dt.year = year;
      dt.mon  = month;
      dt.day  = 1;
      dt.hour = 0;
      dt.min  = 0;
      dt.sec  = 0;
      datetime first = StructToTime(dt);
      MqlDateTime dt2;
      TimeToStruct(first, dt2);
      int dow_first = dt2.day_of_week; // 0..6
      int delta = (day_of_week - dow_first + 7) % 7;
      int days_to_nth = delta + (n - 1) * 7;
      return first + days_to_nth * 86400;
   }

1.5. Construtor e métodos de configuração dos fusos horários

Um construtor simples inicializa os campos de fuso horário com zero. Dois métodos públicos de configuração (setters) permitem que o código que utiliza a classe defina explicitamente o fuso horário do trader ou do servidor. Isso é útil quando a detecção automática não é desejável ou quando é necessário sobrescrever os valores detectados para realizar testes ou trabalhar com servidores remotos.

public:
   CNFPTimeManager()
   {
      m_traderTimeZone = 0;
      m_serverTimeZone = 0;
   }

   // set trader timezone if you need to convert between trader/local and server
   void SetTraderTimeZone(int timezone_hours)
   {
      m_traderTimeZone = timezone_hours;
   }

   void SetServerTimeZone(int timezone_hours)
   {
      m_serverTimeZone = timezone_hours;
   }

1.6. DetectServerTimeZone e GetServerTime: funções auxiliares para identificação do horário do servidor

DetectServerTimeZone é uma função auxiliar que compara TimeCurrent() (horário do servidor) com TimeLocal() (horário local do computador) e armazena a diferença em horas como um valor inteiro. Já GetServerTime encapsula uma chamada a TimeCurrent(), permitindo que os demais módulos utilizem uma única fonte para obter a marca de tempo atual do servidor.

   // attempt to auto-detect server timezone (difference between server and local)
   int DetectServerTimeZone()
   {
      datetime local = TimeLocal();
      datetime server = TimeCurrent();
      int offset_seconds = (int)(server - local);
      int offset_hours = offset_seconds / 3600;
      m_serverTimeZone = offset_hours;
      return offset_hours;
   }

   datetime GetServerTime()
   {
      return TimeCurrent();
   }

1.7. GetNFPTimestampTrader: horário local de divulgação do NFP no fuso ET

Esse método retorna um valor datetime que representa a divulgação do NFP às 08h30, no horário do leste dos Estados Unidos, na primeira sexta-feira do mês e ano especificados. A função trabalha com a hora local do fuso ET, conforme indicada pelo relógio, deixando a conversão para o horário do servidor a cargo de outra função. Essa separação de responsabilidades mantém o funcionamento do método simples e previsível.

   // NFP candidate time in trader (ET) zone: first Friday of month at 08:30 ET
   datetime GetNFPTimestampTrader(int year, int month)
   {
      // first Friday (5) of the month
      datetime first_friday = GetNthDayOfWeek(year, month, 5, 1);
      MqlDateTime dt;
      TimeToStruct(first_friday, dt);
      dt.hour = 8; dt.min = 30; dt.sec = 0;
      return StructToTime(dt); // this is in server timescale semantics but represents the ET timestamp
   }

1.8. TraderETtoServer: conversão de uma marca de tempo ET para o horário do servidor

Essa função de conversão é fundamental. Ela recebe uma marca de tempo expressa na hora local do fuso ET (por exemplo, 2025-09-05, às 08h30 ET), determina se o horário de verão está em vigor nessa data, converte a marca de tempo para UTC e, em seguida, aplica o deslocamento correspondente ao fuso horário configurado para o servidor. O resultado é o instante correspondente no horário do servidor, que o EA deve utilizar como referência para o planejamento temporal e a indexação das barras.

   // Convert a trader ET timestamp to server absolute time using ET offset and server tz
   datetime TraderETtoServer(datetime nfp_trader_time)
   {
      int et_offset = GetETOffset(nfp_trader_time); // UTC offset for ET at that date (-4/-5)
      // nfp_trader_time is interpreted in ET (i.e., wall-clock ET). To get UTC we add -ET offset:
      // UTC = ET - ET_offset_hours
      // Server local = UTC + server_tz
      int server_tz = m_serverTimeZone;
      datetime nfp_server_time = nfp_trader_time - et_offset * 3600 + server_tz * 3600;
      return nfp_server_time;
   }

1.9. GetNextNFPServerTime e GetLastNFPServerTime: busca cronológica para frente e para trás

Essas funções auxiliares procuram a próxima marca de tempo de divulgação do NFP ou a mais recente, expressa no horário do servidor, examinando um intervalo de até 13 meses. Elas convertem as datas e os horários candidatos, inicialmente expressos no fuso ET, para o horário do servidor e os comparam com TimeCurrent(). As funções também tratam corretamente os casos-limite relacionados à passagem de um ano para outro, ajustando o mês e o ano conforme a busca avança ou retrocede.

   // Return the next NFP server datetime strictly greater than now (search up to 13 months)
   datetime GetNextNFPServerTime()
   {
      datetime server_time = GetServerTime();
      MqlDateTime sd; TimeToStruct(server_time, sd);
      int year = sd.year, month = sd.mon;
      for(int i=0;i<13;i++)
      {
         datetime nfp_trader = GetNFPTimestampTrader(year, month);
         datetime nfp_server = TraderETtoServer(nfp_trader);
         if(nfp_server > server_time) return(nfp_server);
         month++; if(month>12){ month=1; year++; }
      }
      return(0);
   }

   // Return most recent NFP server datetime <= now (search backwards)
   datetime GetLastNFPServerTime()
   {
      datetime server_time = GetServerTime();
      MqlDateTime sd; TimeToStruct(server_time, sd);
      int year = sd.year, month = sd.mon;
      for(int i=0;i<13;i++)
      {
         datetime nfp_trader = GetNFPTimestampTrader(year, month);
         datetime nfp_server = TraderETtoServer(nfp_trader);
         if(nfp_server <= server_time) return(nfp_server);
         month--; if(month<1){ month=12; year--; }
      }
      return(0);
   }

1.10. IsNFPEventActive: verificação rápida da janela de atividade

Essa função auxiliar booleana verifica se a divulgação mais recente do NFP ocorreu dentro de uma janela de tempo configurável (por padrão, ±1 hora). Isso é útil quando se deseja que o código adote um comportamento específico durante a janela do NFP, como suspender as negociações ou registrar eventos.

   // Detect if an NFP event is currently within ±window_seconds of server time (default ±3600s)
   bool IsNFPEventActive(int window_seconds = 3600)
   {
      datetime server_time = GetServerTime();
      datetime last_nfp = GetLastNFPServerTime();
      if(last_nfp == 0) return(false);
      if(MathAbs((long)(server_time - last_nfp)) <= window_seconds) return(true);
      return(false);
   }

1.11. FirstM5OpenAfterNFP: associação do horário do evento à abertura de uma vela M5

A lógica de negociação reage ao fechamento da primeira vela M5 após a divulgação do NFP. Essa função auxiliar retorna o horário de abertura da vela M5 que contém o evento, cujo fechamento corresponde ao primeiro fechamento após a marca de tempo da divulgação. Utilizamos um cálculo simples de arredondamento para baixo até o múltiplo de 300 segundos mais próximo (marca de tempo / 300 * 300, com divisão inteira), garantindo uma operação rápida e sem ambiguidades.

   // Utility: compute the M5 open time for the bar that contains the NFP or the first bar after it.
   // Returns the M5 open time for the bar whose close is the first > nfp_server_time.
   datetime FirstM5OpenAfterNFP(datetime nfp_server_time)
   {
      if(nfp_server_time <= 0) return(0);
      // PeriodSeconds for M5 = 300
      int period = PERIOD_M5;
      int psec = 60 * 5;
      // floor open time:
      long open_floor = (long)(nfp_server_time / psec) * psec;
      // if the event falls exactly at an open boundary, then the bar with open=open_floor is the one that includes event
      // its close = open_floor + psec -> that is the first close after event
      return (datetime)open_floor;
   }

1.12. GetM5BarIndexByOpenTime: conversão do horário de abertura em índice da barra

Por fim, essa função auxiliar utiliza iBarShift para obter o índice da barra na série temporal M5 correspondente a um horário de abertura específico, considerando que a barra atual possui índice 0. A função retorna -1 quando não encontra uma correspondência exata. Isso é útil quando o EA precisa chamar CopyRates ou acessar barras históricas por meio de seus índices.

   // Convenience: compute the M5 bar index (iBarShift) for an M5 open time (exact match)
   int GetM5BarIndexByOpenTime(string symbol, datetime m5_open_time)
   {
      if(m5_open_time <= 0) return(-1);
      // prefer exact match - returns index where rates[].time == m5_open_time
      int idx = iBarShift(symbol, PERIOD_M5, m5_open_time, true);
      return idx; // -1 if not found
   }
};

Etapa 2: EA de negociação com Fibonacci após a divulgação do NFP

2.1. Cabeçalho, diretivas include e parâmetros de entrada

Esse bloco inicial declara os metadados do EA e importa a biblioteca auxiliar de negociação e o arquivo de cabeçalho NFPTimeManager. Os parâmetros de entrada correspondem às opções de configuração disponibilizadas ao trader: cores, nomes, ativação do posicionamento automático de ordens, tamanho do lote, margens adicionais para SL/TP, rigor dos critérios de Fibonacci e período de validade da configuração de Fibonacci. Durante os testes em conta de demonstração, mantenha essas configurações simples e ajuste-as posteriormente para cada instrumento.

//+------------------------------------------------------------------+
//|             Post-NFP Fibonacci Trader EA                        |
//|  Post-NFP fib + pending orders with robust SL/TP buffer & object |
//|  lifecycle: destroy object when any order fills OR after expiry  |
//+------------------------------------------------------------------+
#property copyright "Clemence Benjamin"
#property version   "1.0"
#property strict

#include <Trade\Trade.mqh>
#include <NFPTimeManager.mqh>

// --- visual / fib inputs
input color  InpFiboColor = clrDodgerBlue;
input string InpPrefix = "FIBO_NFP_";
input bool   InvertFiboOrientation = true;
input bool   InpRayRight = true;

// Trading inputs
input double InpLots = 0.01;
input int    InpSlippage = 10;
input ulong  InpMagic = 123456;
input int    InpOrderExpirationMinutes = 0;
input bool   InpAutoPlaceOrders = true;
input bool   InpRequireStrictSLAt100 = false; // strict mode
input double InpSLBufferPoints = 20.0; // SL moved away from 100% by this many points
input double InpTPBufferPoints = 20.0; // TP moved away from 0% by this many points
input int    InpFibExpiryHours = 3;    // how many hours before fib auto-deletes

2.2. Estado global: armazenamento dos dados de execução

Essas variáveis globais armazenam o estado que o EA precisa preservar entre as chamadas de suas funções: pontos de ancoragem da retração de Fibonacci, indicação de que a barra inicial era de alta, tickets das ordens pendentes monitoradas, nome do objeto de Fibonacci atual e seu horário de criação (para controle de expiração), níveis fixos de Fibonacci e informações de acompanhamento das barras M5. Essas variáveis são declaradas pelo desenvolvedor e atualizadas durante a execução.

// --- internal
CTrade trade;
CNFPTimeManager nfpManager;

double g_price0 = 0.0;
double g_price100 = 0.0;
bool   g_fibBullish = false;

ulong g_pendingTickets[];                  // tracked pending tickets
string g_currentFibName = "";              // current fib object name
datetime g_fibCreateTime = 0;              // server time when fib created

static const double S_levels[] = {38.2, 50.0, 61.8};

datetime lastM5Open = 0;
datetime lastProcessedNFP = 0;

2.3. OnInit(): inicialização e integração com NFPTimeManager

Quando o EA é anexado ao gráfico, OnInit determina o fuso horário do servidor por meio do arquivo de cabeçalho NFPTimeManager, garantindo a conversão correta entre o horário ET e o horário do servidor. Em seguida, configura os parâmetros padrão de CTrade, incluindo o número mágico e o desvio máximo de preço permitido (slippage), limpa os arrays de tickets anteriores e registra o horário de abertura da vela M5 atual. Essa inicialização prepara o EA para detectar o próximo fechamento de uma vela M5 após a divulgação do NFP.

int OnInit()
{
   // initialize NFP manager tz
   int detected = nfpManager.DetectServerTimeZone();
   PrintFormat("EA: Detected server timezone UTC%+d", detected);

   trade.SetExpertMagicNumber(InpMagic);
   trade.SetDeviationInPoints(InpSlippage);

   ArrayFree(g_pendingTickets);

   // initialize last M5 open time
   MqlRates r[];
   if(CopyRates(_Symbol, PERIOD_M5, 0, 1, r) == 1) lastM5Open = r[0].time;
   else lastM5Open = 0;

   Print("EA: Initialized v1.50 — monitoring NFP, will create fib on first M5 close after NFP.");

   return(INIT_SUCCEEDED);
}

2.4. OnDeinit(): encerramento e limpeza de recursos

A função OnDeinit garante que, ao remover o EA, não permaneçam ordens pendentes sem gerenciamento nem objetos gráficos associados à sua execução. Ela cancela todas as ordens pendentes monitoradas que ainda estiverem ativas, remove o objeto de Fibonacci atual, caso exista, e libera os recursos do array de tickets. Essa etapa de limpeza é fundamental para garantir a segurança dos testes e da utilização do EA em condições reais de negociação.

void OnDeinit(const int reason)
{
   // cleanup: cancel tracked pending orders and delete fib
   CancelExistingPendingOrders();
   DeleteCurrentFibIfExists();
   ArrayFree(g_pendingTickets);
}

2.5. OnTradeTransaction(): detecção de execuções de ordens e resposta imediata

Esse callback monitora os eventos do sistema de negociação. Quando um negócio executado (deal) é adicionado, o EA verifica se a ordem executada corresponde a algum dos tickets de ordens pendentes monitorados. Em caso afirmativo, remove o objeto de Fibonacci, cancela as ordens pendentes restantes e limpa a lista de tickets. Também deixa de monitorar os tickets de ordens removidas externamente. Isso mantém o objeto gráfico de Fibonacci e as ordens pendentes monitoradas sincronizados com as execuções efetivamente registradas pelo sistema de negociação.

void OnTradeTransaction(const MqlTradeTransaction &trans, const MqlTradeRequest &request, const MqlTradeResult &result)
{
   // We care about deals added (fills) and order deletions possibly made externally
   if(trans.type == TRADE_TRANSACTION_DEAL_ADD)
   {
      ulong orderTicket = trans.order;
      if(orderTicket == 0) return;

      for(int i = ArraySize(g_pendingTickets)-1; i >= 0; i--)
      {
         if(g_pendingTickets[i] == orderTicket)
         {
            PrintFormat("EA: Detected fill for tracked order %I64u -> destroying fib and cancelling remaining pending orders.", orderTicket);
            ArrayRemove(g_pendingTickets, i);
            CancelExistingPendingOrders();
            DeleteCurrentFibIfExists();
            ArrayFree(g_pendingTickets);
            return;
         }
      }
   }
   else if(trans.type == TRADE_TRANSACTION_ORDER_DELETE)
   {
      ulong orderTicket = trans.order;
      if(orderTicket == 0) return;
      for(int i = ArraySize(g_pendingTickets)-1; i>=0; i--)
      {
         if(g_pendingTickets[i] == orderTicket)
         {
            ArrayRemove(g_pendingTickets, i);
            PrintFormat("EA: Tracked order %I64u was deleted externally — removed from internal list.", orderTicket);
            break;
         }
      }
   }
}

2.6. OnTick(): rotina principal de monitoramento, verificação de expiração e detecção do fechamento de velas M5

OnTick é executada a cada tick e realiza duas verificações principais: (A) verifica se o objeto de Fibonacci atual existe e se seu prazo de validade (por exemplo, 3 horas) expirou. Nesse caso, remove o objeto e cancela as ordens pendentes; (B) detecta a abertura de uma nova barra M5, indicando que a barra anterior foi concluída. Quando ocorre esse fechamento, a função consulta o arquivo de cabeçalho para obter o horário da divulgação mais recente do NFP no fuso do servidor, verifica se a barra M5 recém-fechada é a primeira após o NFP e, em caso afirmativo, executa as rotinas de criação do objeto de Fibonacci e posicionamento das ordens. Essa estrutura garante que a retração de Fibonacci seja traçada com base em uma vela M5 concluída após a divulgação do NFP.

void OnTick()
{
   // 1) Check for fib expiry by time
   if(StringLen(g_currentFibName) > 0 && g_fibCreateTime > 0)
   {
      datetime now = TimeCurrent();
      if(now >= (datetime)(g_fibCreateTime + InpFibExpiryHours * 3600))
      {
         PrintFormat("EA: Fib '%s' expired after %d hours -> deleting object and cancelling pending orders.",
                     g_currentFibName, InpFibExpiryHours);
         CancelExistingPendingOrders();
         DeleteCurrentFibIfExists();
      }
   }

   // 2) Detect M5 new bar open (previous M5 bar closed)
   MqlRates m5rt[];
   if(CopyRates(_Symbol, PERIOD_M5, 0, 1, m5rt) != 1) return;
   datetime currentM5Open = m5rt[0].time;
   if(currentM5Open == lastM5Open) return;

   // previous M5 open is the bar that just closed
   datetime prevOpen = lastM5Open;
   lastM5Open = currentM5Open;

   // find last NFP server time (the release to react to)
   datetime lastNFP = nfpManager.GetLastNFPServerTime();
   if(lastNFP == 0) return;

   // if already processed this NFP skip
   if(lastProcessedNFP == lastNFP) return;

   // compute bar open floor (M5) that contains the event
   int psec = 60*5;
   long floorOpen = (long)(lastNFP / psec) * psec;
   datetime firstM5OpenAfterNFP = (datetime)floorOpen;

   // we want prevOpen == firstM5OpenAfterNFP (i.e. the bar that closed is that target)
   if(prevOpen != firstM5OpenAfterNFP) return;

   // find M5 index of that open time
   int m5Index = iBarShift(_Symbol, PERIOD_M5, prevOpen, true);
   if(m5Index < 0)
   {
      PrintFormat("EA: Could not find M5 index for open time %s", TimeToString(prevOpen, TIME_DATE|TIME_MINUTES));
      return;
   }

   // update fib using that M5 bar and create pending orders
   if(!UpdateFibFromM5Bar(m5Index)) { Print("EA: UpdateFibFromM5Bar failed."); return; }
   if(InpAutoPlaceOrders) PlaceOrRefreshPendingOrders();

   // mark processed
   lastProcessedNFP = lastNFP;
   PrintFormat("EA: Processed NFP at %s (server time). Used M5 open %s as anchor.",
               TimeToString(lastNFP, TIME_DATE|TIME_MINUTES), TimeToString(prevOpen, TIME_DATE|TIME_MINUTES));
}

2.7. UpdateFibFromM5Bar(): leitura da barra M5, cálculo dos pontos de ancoragem e desenho da retração de Fibonacci

Essa função utiliza CopyRates para obter os dados da barra M5 selecionada e determina se a vela é de alta ou de baixa, comparando os preços de fechamento e abertura. Em seguida, calcula os pontos de ancoragem correspondentes aos níveis de 0% e 100%, de acordo com a configuração de exibição adotada, invertendo-os quando necessário para atender às preferências de visualização. A função armazena esses pontos para utilização na lógica de negociação, remove objetos antigos identificados pelo prefixo correspondente e cria um objeto OBJ_FIBO com nome exclusivo para essa vela. Também registra a marca de tempo de criação para controlar a expiração do objeto.

bool UpdateFibFromM5Bar(int m5Index)
{
   if(m5Index < 0) return(false);

   MqlRates r[];
   int copied = CopyRates(_Symbol, PERIOD_M5, m5Index, 1, r);
   if(copied != 1)
   {
      PrintFormat("EA: CopyRates for M5 index %d failed (copied=%d).", m5Index, copied);
      return(false);
   }

   double bar_high = r[0].high;
   double bar_low  = r[0].low;
   double bar_open = r[0].open;
   double bar_close= r[0].close;
   datetime bar_time = r[0].time;

   bool bullish = (bar_close > bar_open);
   g_fibBullish = bullish;

   // user's mapping:
   double price0 = bullish ? bar_high : bar_low;   // 0% anchor
   double price100= bullish ? bar_low  : bar_high; // 100% anchor

   if(InvertFiboOrientation) { double t = price0; price0 = price100; price100 = t; }

   // store anchors for trading
   g_price0 = price0;
   g_price100 = price100;

   // delete any existing prefix objects to avoid clutter
   int tot = ObjectsTotal(0);
   for(int i = tot-1; i >= 0; i--)
   {
      string nm = ObjectName(0, i);
      if(StringFind(nm, InpPrefix) == 0) ObjectDelete(0, nm);
   }

   // create a unique name for this fib
   g_currentFibName = InpPrefix + _Symbol + "_" + IntegerToString((int)bar_time);
   bool created = ObjectCreate(0, g_currentFibName, OBJ_FIBO, 0, bar_time, price0, (datetime)(bar_time + PeriodSeconds(PERIOD_M5)), price100);
   if(!created)
   {
      PrintFormat("EA: Failed to create Fibo '%s' (err=%d)", g_currentFibName, GetLastError());
      g_currentFibName = "";
      return(false);
   }

   ObjectSetInteger(0, g_currentFibName, OBJPROP_COLOR, InpFiboColor);
   ObjectSetInteger(0, g_currentFibName, OBJPROP_RAY_RIGHT, InpRayRight ? 1 : 0);
   ObjectSetInteger(0, g_currentFibName, OBJPROP_SELECTABLE, true);
   ObjectSetInteger(0, g_currentFibName, OBJPROP_HIDDEN, false);

   string desc = bullish ? "Fibo anchored to bullish M5 bar" : "Fibo anchored to bearish M5 bar";
   if(InvertFiboOrientation) desc += " (inverted)";
   if(InpRayRight) desc += " (ray-right)";
   ObjectSetString(0, g_currentFibName, OBJPROP_TEXT, desc);

   g_fibCreateTime = TimeCurrent();

   PrintFormat("EA: Drew Fibo '%s' on M5 index %d (open=%s) high=%.5f low=%.5f",
               g_currentFibName, m5Index, TimeToString(bar_time, TIME_DATE|TIME_MINUTES), bar_high, bar_low);

   return(true);
}

2.8. DeleteCurrentFibIfExists(): função centralizada para remoção do objeto de Fibonacci

Essa pequena função auxiliar remove o objeto de Fibonacci atual, caso exista, e limpa as informações correspondentes armazenadas no estado do EA. Centralizar essa operação reduz a duplicação de código e evita pequenos erros, como deixar o nome de um objeto removido armazenado nas variáveis do sistema.

void DeleteCurrentFibIfExists()
{
   if(StringLen(g_currentFibName) == 0) return;
   if(ObjectFind(0, g_currentFibName) >= 0)
   {
      ObjectDelete(0, g_currentFibName);
      PrintFormat("EA: Deleted fib object '%s'.", g_currentFibName);
   }
   g_currentFibName = "";
   g_fibCreateTime = 0;
}

2.9. CancelExistingPendingOrders(): monitoramento e cancelamento de ordens pendentes

O EA armazena em g_pendingTickets os tickets das ordens que cria. Essa rotina percorre a lista e chama trade.OrderDelete para cada ticket. Utilizar os tickets monitorados é mais seguro do que cancelar ordens com base no símbolo ou no comentário, pois permite atuar exclusivamente sobre as ordens criadas durante a execução atual do EA, a menos que um mecanismo de persistência seja implementado posteriormente.

void CancelExistingPendingOrders()
{
   if(ArraySize(g_pendingTickets) == 0) return;

   for(int i = ArraySize(g_pendingTickets)-1; i >= 0; i--)
   {
      ulong ticket = g_pendingTickets[i];
      if(ticket == 0) { ArrayRemove(g_pendingTickets, i); continue; }
      bool del = trade.OrderDelete(ticket);
      if(!del) PrintFormat("EA: Failed to delete pending ticket %I64u (err=%d)", ticket, GetLastError());
      else PrintFormat("EA: Deleted pending ticket %I64u", ticket);
      ArrayRemove(g_pendingTickets, i);
   }
}

2.10. PlaceOrRefreshPendingOrders(): cálculo dos pontos de entrada, SL/TP e posicionamento das ordens (núcleo da lógica de negociação)

Essa função concentra a principal lógica de negociação do EA. Para cada nível de Fibonacci (38,2%, 50% e 61,8%), ela:

  • Calcula o preço de entrada por interpolação linear entre g_price0 e g_price100.
  • Calcula os valores desejados de SL e TP, vinculados aos níveis de 100% e 0%, respectivamente, e aplica os ajustes definidos por InpSLBufferPoints / InpTPBufferPoints em relação ao preço de entrada, considerando se a barra M5 inicial era de alta ou de baixa. (Isso garante que, em uma tendência de alta, o SL fique abaixo do nível de 100% e o TP acima do nível de 0%, com a disposição inversa em uma tendência de baixa.)
  • Normaliza os preços de acordo com o número de casas decimais do instrumento.
  • Consulta as restrições da corretora (SYMBOL_TRADE_STOPS_LEVEL, SYMBOL_POINT) e aplica as distâncias mínimas exigidas para os níveis de stop e as ordens pendentes. Quando necessário, ajusta o SL/TP ou ignora o nível caso o modo estrito esteja ativado.
  • Para cada nível, determina se a ordem adequada é BUY_LIMIT (entrada abaixo do preço atual de mercado) ou SELL_LIMIT (entrada acima do preço atual de mercado). Em seguida, posiciona a ordem pendente por meio de CTrade, utilizando o tipo e o prazo de expiração configurados, quando aplicável, registra o sucesso ou a falha no log e armazena o ticket para posterior limpeza.

Essa abordagem minimiza as rejeições de ordens pela corretora e mantém a coerência lógica entre os níveis de preço.

void PlaceOrRefreshPendingOrders()
{
   // clear previously tracked tickets first
   CancelExistingPendingOrders();

   if(g_price0 == 0.0 || g_price100 == 0.0)
   {
      Print("EA: anchors not set - skipping placement");
      return;
   }

   trade.SetExpertMagicNumber(InpMagic);
   trade.SetDeviationInPoints(InpSlippage);

   double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
   double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
   double point = SymbolInfoDouble(_Symbol, SYMBOL_POINT);

   long stops_level = 0;
   if(!SymbolInfoInteger(_Symbol, SYMBOL_TRADE_STOPS_LEVEL, stops_level)) stops_level = 0;
   double min_stop_distance = (double)stops_level * point;
   if(min_stop_distance < point) min_stop_distance = point;
   double min_pending_distance = min_stop_distance;

   // compute buffer values in price units (points * point)
   double sl_buffer_price = InpSLBufferPoints * point;
   double tp_buffer_price = InpTPBufferPoints * point;

   ENUM_ORDER_TYPE_TIME place_time_type = (InpOrderExpirationMinutes > 0) ? ORDER_TIME_SPECIFIED : ORDER_TIME_GTC;
   datetime place_expiration = (InpOrderExpirationMinutes > 0) ? (TimeCurrent() + InpOrderExpirationMinutes * 60) : 0;

   int digits = (int)SymbolInfoInteger(_Symbol, SYMBOL_DIGITS);
   int levelsCount = ArraySize(S_levels);

   for(int i=0;i<levelsCount;i++)
   {
      double pct = S_levels[i] / 100.0;
      double entry = g_price0 + pct * (g_price100 - g_price0);
      // base desired SL and TP anchored at 100% and 0%
      double sl_desired = g_price100;
      double tp_desired = g_price0;

      // Apply buffers depending on the original fib bullish/bearish orientation
      if(g_fibBullish)
      {
         sl_desired = (g_price100 - sl_buffer_price);
         tp_desired = (g_price0 + tp_buffer_price);
      }
      else
      {
         sl_desired = (g_price100 + sl_buffer_price);
         tp_desired = (g_price0 - tp_buffer_price);
      }

      // normalize values
      entry = NormalizeDouble(entry, digits);
      sl_desired = NormalizeDouble(sl_desired, digits);
      tp_desired = NormalizeDouble(tp_desired, digits);

      // decide pending type by comparing entry price with market and min_pending_distance
      bool wantBuy = false, wantSell = false;
      if(entry <= (ask - min_pending_distance)) wantBuy = true;
      else if(entry >= (bid + min_pending_distance)) wantSell = true;
      else
      {
         PrintFormat("EA: Skipping level %.2f: entry(%.5f) too close to market (Ask=%.5f Bid=%.5f) min_pending_dist=%.5f",
                     S_levels[i], entry, ask, bid, min_pending_distance);
         continue;
      }

      ENUM_ORDER_TYPE otype = (wantBuy ? ORDER_TYPE_BUY_LIMIT : ORDER_TYPE_SELL_LIMIT);
      bool adjusted = false;

      // Validate/adjust stops unless strict mode requested
      if(otype == ORDER_TYPE_BUY_LIMIT)
      {
         // For BUY_LIMIT we need sl < entry < tp
         if(!(sl_desired < entry - min_stop_distance))
         {
            if(InpRequireStrictSLAt100)
            {
               PrintFormat("EA: Strict mode: skipping level %.2f because SL would be adjusted (desired SL %.5f not < entry-%.5f).",
                           S_levels[i], sl_desired, (entry - min_stop_distance));
               continue;
            }
            double old = sl_desired;
            sl_desired = NormalizeDouble(entry - min_stop_distance, digits);
            adjusted = true;
            PrintFormat("EA: Adjusted SL BUY level %.2f old=%.5f -> new=%.5f", S_levels[i], old, sl_desired);
         }
         if(!(tp_desired > entry + min_stop_distance))
         {
            if(InpRequireStrictSLAt100)
            {
               PrintFormat("EA: Strict mode: skipping level %.2f because TP would be adjusted (desired TP %.5f not > entry+%.5f).",
                           S_levels[i], tp_desired, (entry + min_stop_distance));
               continue;
            }
            double old = tp_desired;
            tp_desired = NormalizeDouble(entry + min_stop_distance, digits);
            adjusted = true;
            PrintFormat("EA: Adjusted TP BUY level %.2f old=%.5f -> new=%.5f", S_levels[i], old, tp_desired);
         }
      }
      else // SELL_LIMIT
      {
         // For SELL_LIMIT we need tp < entry < sl
         if(!(sl_desired > entry + min_stop_distance))
         {
            if(InpRequireStrictSLAt100)
            {
               PrintFormat("EA: Strict mode: skipping level %.2f because SL would be adjusted (desired SL %.5f not > entry+%.5f).",
                           S_levels[i], sl_desired, (entry + min_stop_distance));
               continue;
            }
            double old = sl_desired;
            sl_desired = NormalizeDouble(entry + min_stop_distance, digits);
            adjusted = true;
            PrintFormat("EA: Adjusted SL SELL level %.2f old=%.5f -> new=%.5f", S_levels[i], old, sl_desired);
         }
         if(!(tp_desired < entry - min_stop_distance))
         {
            if(InpRequireStrictSLAt100)
            {
               PrintFormat("EA: Strict mode: skipping level %.2f because TP would be adjusted (desired TP %.5f not < entry-%.5f).",
                           S_levels[i], tp_desired, (entry - min_stop_distance));
               continue;
            }
            double old = tp_desired;
            tp_desired = NormalizeDouble(entry - min_stop_distance, digits);
            adjusted = true;
            PrintFormat("EA: Adjusted TP SELL level %.2f old=%.5f -> new=%.5f", S_levels[i], old, tp_desired);
         }
      }

      // final relation sanity
      bool valid = true;
      if(otype == ORDER_TYPE_BUY_LIMIT) valid = (sl_desired < entry && tp_desired > entry);
      else valid = (sl_desired > entry && tp_desired < entry);
      if(!valid)
      {
         PrintFormat("EA: Skipping level %.2f due to invalid final SL/TP relation entry=%.5f SL=%.5f TP=%.5f",
                     S_levels[i], entry, sl_desired, tp_desired);
         continue;
      }

      // build order comment
      string comment = InpPrefix + DoubleToString(S_levels[i], 2);

      // Place pending with proper signature (includes time type and expiration)
      bool placed = false;
      if(otype == ORDER_TYPE_BUY_LIMIT)
         placed = trade.BuyLimit(InpLots, entry, _Symbol, sl_desired, tp_desired, place_time_type, place_expiration, comment);
      else
         placed = trade.SellLimit(InpLots, entry, _Symbol, sl_desired, tp_desired, place_time_type, place_expiration, comment);

      if(!placed)
      {
         int err = GetLastError();
         PrintFormat("EA: Failed to place %s at %.5f (lvl %.2f) err=%d ret=%d",
                     (otype==ORDER_TYPE_BUY_LIMIT ? "BUY_LIMIT":"SELL_LIMIT"),
                     entry, S_levels[i], err, (int)trade.ResultRetcode());
      }
      else
      {
         ulong ticket = trade.ResultOrder();
         PrintFormat("EA: Placed %s ticket=%I64u lvl=%.2f entry=%.5f SL=%.5f TP=%.5f adjusted=%s",
                     (otype==ORDER_TYPE_BUY_LIMIT ? "BUY_LIMIT":"SELL_LIMIT"),
                     ticket, S_levels[i], entry, sl_desired, tp_desired, (adjusted ? "yes":"no"));

         // track ticket for cleanup and fill detection
         ArrayResize(g_pendingTickets, ArraySize(g_pendingTickets) + 1);
         g_pendingTickets[ArraySize(g_pendingTickets)-1] = ticket;
      }
   } // levels loop
}

2.11. Como o EA utiliza o arquivo de cabeçalho NFPTimeManager: principais pontos de chamada

O arquivo de cabeçalho concentra as operações relacionadas a datas e horários. O EA chama DetectServerTimeZone() em OnInit() para configurar a conversão de fusos horários e GetLastNFPServerTime() a cada fechamento de uma vela M5 para identificar a marca de tempo da divulgação mais recente do NFP no horário do servidor. Com essa referência, o EA determina o horário de abertura da vela M5 cujo fechamento é o primeiro após a divulgação do NFP e reage quando essa vela é concluída. Essa separação mantém a lógica principal do EA mais simples e garante o tratamento correto das diferenças entre fusos horários.

// example header calls in OnInit/OnTick
int detected = nfpManager.DetectServerTimeZone();
datetime lastNFP = nfpManager.GetLastNFPServerTime();


Resultados

Graças à classe NFPTimeManager, o EA consegue identificar de forma confiável as divulgações do relatório de emprego não agrícola (NFP), inclusive em dados históricos. Isso permite executar e avaliar a estratégia no testador de estratégias após a compilação bem-sucedida do código. As animações a seguir ilustram a execução dos testes no testador de estratégias.

metatester64_nDEhinFAuB

Figura 6. 7 de junho de 2024, divulgação do NFP

A Figura 6 mostra que, durante a divulgação do NFP em 7 de junho de 2024, o EA identificou corretamente a data do evento e converteu o horário da publicação para o horário local do servidor, conforme confirmado no testador de estratégias. A ferramenta de retração de Fibonacci foi traçada e aplicada ao gráfico conforme o planejado. No entanto, as ordens pendentes não foram acionadas porque a retração foi pouco profunda e o preço não alcançou os níveis de entrada.

Outro problema identificado foi o posicionamento incorreto dos níveis de stop-loss e take-profit nas ordens pendentes, que não correspondeu integralmente às especificações previstas. Esse problema pode ser corrigido por meio de alterações no código ou de ajustes nos parâmetros de entrada.

Apesar dessas limitações, o resultado mais importante foi a capacidade do EA de identificar o evento, realizar corretamente as conversões entre fusos horários e automatizar o posicionamento de ordens com base nos níveis de Fibonacci. Esses resultados estabelecem uma base sólida para a estratégia, que poderá receber novos aprimoramentos em versões futuras. A seguir, apresentamos outra imagem referente ao evento de 1º de novembro de 2024.

metatester64_lfPG2lDG5m

Figura 7. 1º de novembro de 2024, divulgação do NFP



Conclusão

A ferramenta de retração de Fibonacci pode ser aplicada de forma algorítmica à negociação após a divulgação do relatório de emprego não agrícola (NFP), por meio de uma abordagem estruturada e baseada em regras. Em vez de tentar aproveitar o impulso inicial, esse método permite operar no mercado alguns minutos após a divulgação, durante a fase natural de retração. Em teoria, é possível obter um lucro equivalente a 30% a 60% da amplitude do movimento brusco ocorrido nos primeiros cinco minutos, mesmo que o trader tenha perdido a oportunidade de entrada inicial. Isso é possível graças às proporções de Fibonacci, que tomam a amplitude total do movimento como referência de 100% e permitem calcular níveis precisos de retração para posicionar as ordens.

Entre esses níveis, a retração de Fibonacci de 38,2% frequentemente apresenta a maior probabilidade de proporcionar um lucro equivalente a 38,2% da amplitude do impulso inicial. No entanto, é importante destacar que o mercado nem sempre apresenta esse comportamento e que nenhuma configuração garante resultados. Nossos testes apresentaram resultados promissores em diversos cenários, embora essa abordagem deva ser encarada como uma estratégia estruturada baseada em probabilidades, e não como uma certeza.

Neste estudo, não realizamos uma avaliação abrangente do desempenho do EA. Nosso foco foi demonstrar o conceito por meio de simulações práticas no testador de estratégias. O protótipo ainda oferece oportunidades de aprimoramento e otimização, seja por meio de melhorias no gerenciamento de ordens, validação estatística ou adaptação a outros pares de moedas e cenários de negociação não relacionados à divulgação de notícias.

As lições aprendidas durante o desenvolvimento da estratégia foram igualmente valiosas: começar do zero, adotar uma arquitetura modular para manter o código organizado e reutilizável e considerar desde o início possíveis expansões futuras. Esses princípios constituem uma base sólida que, com novos aperfeiçoamentos, poderá dar origem a uma ferramenta de negociação mais robusta e flexível.

Compartilhe suas ideias e opiniões na seção de comentários abaixo! Consulte também os arquivos-fonte anexados e nossa tabela-resumo dos principais aprendizados para conhecer as conclusões práticas.


Principais aprendizados

Principal aprendizado Descrição:
Divida a lógica em módulos Organize as funcionalidades em componentes pequenos e com responsabilidades bem definidas, como classes ou funções. Por exemplo, uma classe NFPTimeManager dedicada ao tratamento de horários e do horário de verão (DST) mantém o código principal do EA legível e reutilizável.
Trate explicitamente os fusos horários e o horário de verão Converta o horário do evento (ET) para o horário do servidor utilizando regras determinísticas. Erros nessa conversão podem deslocar os pontos de ancoragem tanto nos testes históricos quanto na execução em condições reais. Por isso, centralize essa lógica e teste-a cuidadosamente.
Utilize barras fechadas como referência Baseie sempre os cálculos em velas concluídas, como a primeira vela M5 cujo fechamento ocorre após a divulgação do NFP. Isso evita a instabilidade provocada por recálculos durante a formação da barra e permite reproduzir os resultados no testador de estratégias.
Respeite as restrições da corretora Consulte SYMBOL_TRADE_STOPS_LEVEL, SYMBOL_POINT e SYMBOL_DIGITS durante a execução e verifique se os níveis de SL/TP e os preços das ordens pendentes respeitam as distâncias mínimas exigidas pela corretora, evitando rejeições de ordens.
Normalize os preços e utilize a precisão correta Ajuste sempre os valores de entry, SL e TP à precisão decimal do instrumento. Pequenos erros de arredondamento podem facilmente levar à rejeição de ordens pela corretora.
Implemente alternativas seguras para situações que exigem ajustes Disponibilize os modos estrito e adaptativo: no modo estrito, ignore os níveis que exigiriam alterações nos stops; no modo adaptativo, ajuste automaticamente os níveis de stop para atender às regras da corretora. Registre ambas as decisões no log.
Utilize APIs confiáveis para o posicionamento de ordens Utilize os métodos auxiliares de CTrade com as assinaturas corretas, incluindo os parâmetros de tipo e prazo de expiração (expiration/time), para evitar alterações posteriores no código e simplificar o tratamento de erros.
Monitore e gerencie os tickets das próprias ordens Mantenha uma lista interna dos tickets criados pelo EA para que ele possa monitorar ou cancelar com segurança apenas as ordens que efetivamente criou, evitando a exclusão de ordens independentes inseridas pelo usuário.
Gerencie o ciclo de vida dos objetos e mantenha a interface organizada Atribua nomes curtos e exclusivos aos objetos gráficos, como fib_SYMBOL_YYMMDDhhmm, armazene informações detalhadas em OBJPROP_TEXT e remova os objetos quando as ordens forem executadas ou seus prazos de validade expirarem.
Utilize OnTradeTransaction para detectar execuções de ordens Identifique negócios executados (deals) e exclusões externas de ordens por meio dos eventos de transações de negociação. Isso permite reagir imediatamente, realizando a limpeza dos recursos e o registro das ocorrências no log, sem os atrasos associados às verificações periódicas.
Mantenha logs detalhados para facilitar o rastreamento Registre todas as ações importantes, como criação, configuração, níveis ignorados, posicionamento de ordens, falhas e exclusões. Logs claros são essenciais para depuração, testes históricos e para fins regulatórios e de auditoria.
Teste primeiro no testador de estratégias e em conta de demonstração Valide a lógica com datas históricas de divulgação do NFP no testador de estratégias, em condições determinísticas, antes de executar o EA em uma conta de demonstração. Utilize pontos de ancoragem determinísticos, baseados em barras fechadas, para garantir a reprodução dos resultados.



Anexos

Nome do arquivo Versão Descrição
NFPTimeManager.mqh
1.0 Classe auxiliar de gerenciamento de datas e horários com tratamento do horário de verão, que centraliza todos os cálculos das marcas de tempo relacionadas à divulgação do relatório de emprego não agrícola (NFP) e as conversões entre o horário do leste dos Estados Unidos (ET), UTC e o horário do servidor da corretora. Suas principais funcionalidades incluem a detecção do fuso horário do servidor, o cálculo do horário de divulgação do NFP (primeira sexta-feira do mês, às 08h30 ET), a conversão de horários ET para o horário do servidor, a identificação das marcas de tempo da divulgação anterior e da próxima divulgação do NFP no horário do servidor, além de funções auxiliares para associar os horários de divulgação do NFP às aberturas das velas M5 e aos índices das barras. A classe foi desenvolvida para facilitar a reutilização e os testes unitários, permitindo que o EA funcione independentemente das particularidades dos fusos horários.
Post-NFP Fibonacci Trader EA.mq5
1.0 EA completo que utiliza NFPTimeManager para identificar a vela M5 cujo fechamento é o primeiro após a divulgação do NFP, traçar a retração de Fibonacci ancorada nessa vela e posicionar ordens pendentes nos níveis de retração de 38,2%, 50% e 61,8%. Entre suas funcionalidades estão as margens adicionais para SL/TP, o tratamento dos níveis de stop nos modos estrito e adaptativo, a verificação das restrições da corretora (SYMBOL_TRADE_STOPS_LEVEL, SYMBOL_POINT e digits, a precisão decimal do instrumento), o monitoramento de tickets, a limpeza automática dos recursos após a execução das ordens ou o término do prazo de validade configurável, além do registro detalhado de eventos em log para facilitar o rastreamento. O EA pode ser personalizado por meio dos parâmetros de entrada e testado tanto no testador de estratégias quanto em ambiente de demonstração.

Traduzido do Inglês pela MetaQuotes Ltd.
Artigo original: https://www.mql5.com/en/articles/19496

Pipelines de processamento de dados em MQL5 Pipelines de processamento de dados em MQL5
Neste artigo, vamos explorar uma etapa fundamental da preparação de dados para machine learning, cuja importância vem crescendo rapidamente: os pipelines de pré-processamento de dados. Em essência, eles consistem em uma sequência simplificada de etapas de transformação que preparam os dados brutos antes de sua entrada no modelo. Embora essa "padronização dos dados" possa parecer pouco interessante para quem não está familiarizado com o assunto, ela não apenas reduz o tempo de treinamento e os custos de execução, como também contribui significativamente para melhorar a capacidade de generalização do modelo. Vamos nos concentrar em algumas funcionalidades de pré-processamento do SCIKIT-LEARN. Embora não utilizemos o Assistente MQL5 neste artigo, voltaremos a abordá-lo nas próximas publicações.
Desenvolvimento de ferramentas para análise de Price Action (Parte 40): Perfil de DNA do mercado Desenvolvimento de ferramentas para análise de Price Action (Parte 40): Perfil de DNA do mercado
Este artigo analisa o perfil único de cada par de moedas com base no histórico de seus movimentos de preço. Inspirados no conceito de DNA, que contém o código genético exclusivo de cada ser vivo, aplicamos uma abordagem semelhante aos mercados, considerando a dinâmica dos preços como o "DNA" de cada par de moedas. Ao analisar características estruturais como volatilidade, swings, retrações, picos de preço e particularidades das sessões de negociação, a ferramenta identifica um perfil que distingue cada par dos demais. Essa abordagem permite compreender melhor o comportamento do mercado e ajuda os traders a alinhar sistematicamente suas estratégias aos padrões de comportamento de cada instrumento.
Desenvolvimento de um indicador personalizado de matriz de desempenho da conta de negociação Desenvolvimento de um indicador personalizado de matriz de desempenho da conta de negociação
Esse indicador funciona como uma ferramenta de controle da disciplina operacional, monitorando em tempo real a situação da conta, os lucros e prejuízos e o drawdown, além de apresentar um painel com indicadores de desempenho. Ele pode ajudar os traders a manter a consistência, evitar o excesso de operações e cumprir as regras de avaliação estabelecidas pelas empresas de prop trading.
Automatização de estratégias de negociação em MQL5 (Parte 32): Desenvolvimento de um sistema de reconhecimento do padrão harmônico "5 Drives" com Price Action Automatização de estratégias de negociação em MQL5 (Parte 32): Desenvolvimento de um sistema de reconhecimento do padrão harmônico "5 Drives" com Price Action
Neste artigo, desenvolveremos em MQL5 um sistema de reconhecimento do padrão harmônico "5 Drives", capaz de identificar formações de alta e de baixa por meio de pontos de reversão e proporções de Fibonacci. O sistema executará operações com níveis configuráveis de entrada, stop-loss e take-profit, de acordo com os parâmetros definidos pelo usuário. Também facilitaremos a análise dos traders por meio de recursos visuais, utilizando objetos gráficos como triângulos, linhas de tendência e rótulos para representar claramente a estrutura A-B-C-D-E-F do padrão.