Negociando com o Calendário Econômico do MQL5 (Parte 1): Dominando as Funções do Calendário Econômico do MQL5

Introdução

Neste artigo, exploramos os poderosos recursos do MetaQuotes Language 5 (MQL5) Economic Calendar e como eles podem ser integrados ao trading algorítmico. O Calendário Econômico, incorporado no terminal de negociação MetaTrader 5, é uma ferramenta crucial para os traders, fornecendo notícias e dados essenciais que podem impactar significativamente os movimentos do mercado. Ao entender como recuperar e interpretar essas informações, podemos ganhar uma vantagem na previsão das reações do mercado a eventos econômicos e ajustar nossas estratégias de negociação de acordo.

Começaremos com uma visão geral do Calendário Econômico do MQL5, cobrindo seus principais componentes e como ele funciona. Em seguida, focaremos na implementação em MQL5, demonstrando como acessar e exibir eventos de notícias no gráfico de forma programática. Por fim, concluiremos resumindo os insights obtidos e os benefícios de incorporar o Calendário Econômico em sistemas de negociação. Aqui estão os subtópicos que abordaremos no artigo:

1. Visão geral do Calendário Econômico do MQL5
2. Implementação em MQL5
3. Conclusão

Ao final deste artigo, você estará capacitado com o conhecimento necessário para desenvolver um Expert Advisor em MQL5 que utilize efetivamente o calendário econômico do MQL5 em suas estratégias de negociação. Vamos começar então!

Visão geral do Calendário Econômico do MQL5

O Calendário Econômico do MQL5 é uma excelente ferramenta que fornece aos traders informações atuais e consistentes sobre os principais eventos econômicos capazes de causar um impacto significativo nos mercados financeiros. É uma ferramenta útil e ainda mais acessível por estar incorporada à plataforma MetaTrader 5.

O calendário econômico fornece uma boa visão geral dos diversos eventos futuros que podem afetar os mercados financeiros. Ele mostra desde datas de decisões de taxa de juros, relatórios de inflação e números de Produto Interno Bruto (PIB), até estatísticas de emprego e muito mais. Como cada um desses pode movimentar os mercados de maneira significativa — especialmente em moedas, commodities e ações — o calendário é uma ferramenta indispensável tanto para traders de curto quanto de longo prazo.

Para abrir o calendário, vá até a barra de tarefas e selecione "Exibir", depois "Caixa de Ferramentas". Segue a ilustração:

Depois que a janela da caixa de ferramentas for aberta, navegue até a guia "Calendário" e clique nela. Isso abrirá a janela do calendário, que deve se parecer com a mostrada abaixo.

Vale destacar que o Calendário Econômico do MQL5 lista os eventos futuros relevantes para os mercados de forma organizada, classificados pelo impacto esperado. Cada evento é caracterizado por um rótulo claro e inequívoco de "baixo", "médio" ou "alto" em relação ao seu nível de potencial influência. Assim, é muito fácil perceber rapidamente quais eventos futuros são altamente significativos e quais não são. O calendário também filtra os eventos conforme sua relevância para cada moeda. Embora os eventos sejam organizados e codificados por cores para relevância, não são tantos a ponto de sobrecarregar o trader. Esse mecanismo de filtragem garante que os traders não sejam bombardeados com dados irrelevantes, permitindo que se concentrem nas notícias que podem afetar diretamente suas posições abertas ou estratégias de negociação.

Uma das principais vantagens do MQL5 Economic Calendar é sua integração com o MQL5, que permite aos traders acessarem programaticamente os dados econômicos e incorporá-los em seus Expert Advisors (EAs) ou sistemas de negociação automatizados. Usando suas funções predefinidas, podemos recuperar dados como o nome do evento, horário agendado, país e valor previsto ou real. Essa funcionalidade permite que traders desenvolvam sistemas que reajam automaticamente a grandes eventos de notícias, seja fechando posições para evitar volatilidade, abrindo negociações com base em previsões ou ajustando níveis de stop-loss e take-profit. Esse nível de automação garante que as estratégias de negociação estejam sempre responsivas aos últimos acontecimentos econômicos, sem exigir intervenção manual. Para concluir as principais funcionalidades do MQL5 Economic Calendar, aqui está uma representação visual detalhada.

Pela imagem, podemos ver que há 8 colunas na representação dos dados. A primeira contém o horário do evento, a segunda contém o símbolo da moeda, a terceira contém o nome do evento, a quarta contém o nível de prioridade ou importância da notícia, a quinta contém o período do dado, enquanto a sexta, sétima e oitava contêm, respectivamente, o valor real, o previsto e o anterior ou revisado.

É claro que nem todos os dados são de grande importância para o trader, e por isso é possível filtrar as informações em quatro maneiras. Uma delas é por tempo, por exemplo, ignorando dados já divulgados. A segunda é filtrando por moeda, e a terceira por país. Por exemplo, se estiver negociando o par "AUDUSD", as notícias de maior impacto serão aquelas que afetam diretamente a Austrália ou os Estados Unidos. Assim, notícias da China não terão efeito significativo sobre esse par.

Por fim, existe o filtro de importância ou prioridade, que ajuda a classificar as notícias por nível de impacto. Para aplicar qualquer filtro, basta clicar com o botão direito dentro do campo do calendário e aplicar o filtro desejado. Isso está ilustrado novamente abaixo.

Assim, ao usar o Calendário Econômico do MQL5, os traders podem formular melhor seus planos de negociação antes de eventos de grande influência no mercado. Eles podem fazer isso tanto consultando manualmente o calendário no MetaTrader 5 quanto através de estratégias automatizadas que agem sobre os dados do calendário. Esse conjunto abre caminho para compreender claramente o Calendário Econômico do MQL5 e para descobrir como aplicá-lo dentro do sistema de negociação do MetaTrader 5, a fim de obter operações mais claras e uma estratégia mais consistente.

Implementação em MQL5

Para criar um Expert Advisor (EA), no seu terminal MetaTrader 5, clique na aba Ferramentas e selecione MetaQuotes Language Editor, ou simplesmente pressione F4 no seu teclado. Como alternativa, você pode clicar no ícone IDE (Ambiente de Desenvolvimento Integrado) na barra de ferramentas. Isso abrirá o ambiente MetaQuotes Language Editor, que permite escrever robôs de negociação, indicadores técnicos, scripts e bibliotecas de funções.

Depois que o MetaEditor estiver aberto, na barra de ferramentas, vá até a aba Arquivo e selecione Novo Arquivo, ou simplesmente pressione CTRL + N, para criar um novo documento. Como alternativa, você pode clicar no ícone Novo na barra de ferramentas. Isso resultará em uma janela pop-up do MQL Wizard.

No assistente (Wizard) que abrir, marque Expert Advisor (template) e clique em Next.

Nas propriedades gerais do Expert Advisor, na seção de nome, forneça o nome do arquivo do seu EA. Note que, para especificar ou criar uma pasta caso ela não exista, você deve usar a barra invertida antes do nome do EA. Por exemplo, aqui temos "Experts" por padrão. Isso significa que nosso EA será criado na pasta Experts e poderemos encontrá-lo lá. As outras seções são bastante diretas, mas você pode seguir o link na parte inferior do assistente para saber exatamente como realizar o processo.

Depois de fornecer o nome desejado para o arquivo do Expert Advisor, clique em Next, depois Next novamente e, por fim, em Finish. Após fazer tudo isso, estaremos prontos para codificar e programar nossa estratégia.

Primeiro, começamos definindo alguns metadados sobre o Expert Advisor (EA). Isso inclui o nome do EA, as informações de copyright e um link para o site da MetaQuotes. Também especificamos a versão do EA, que é definida como "1.00".

//+------------------------------------------------------------------+
//|                                    MQL5 NEWS CALENDAR PART 1.mq5 |
//|      Copyright 2024, ALLAN MUNENE MUTIIRIA. #@Forex Algo-Trader. |
//|                                     https://forexalgo-trader.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2024, ALLAN MUNENE MUTIIRIA. #@Forex Algo-Trader"
#property link      "https://forexalgo-trader.com"
#property description "MQL5 NEWS CALENDAR PART 1"
#property version   "1.00"

Neste ponto, a primeira coisa que precisamos entender são as estruturas para trabalhar com o calendário econômico. Existem três delas: MqlCalendarCountry, que define as descrições de países; MqlCalendarEvent, que define as descrições de eventos; e MqlCalendarValue, que define os valores dos eventos. Os métodos de suas estruturas estão abaixo.

Estrutura do país do calendário:

struct MqlCalendarCountry 
  { 
   ulong                               id;                    // country ID (ISO 3166-1) 
   string                              name;                  // country text name (in the current terminal encoding) 
   string                              code;                  // country code name (ISO 3166-1 alpha-2) 
   string                              currency;              // country currency code 
   string                              currency_symbol;       // country currency symbol 
   string                              url_name;              // country name used in the mql5.com website URL 
  };

Estrutura dos eventos do calendário:

struct MqlCalendarEvent 
  { 
   ulong                               id;                    // event ID 
   ENUM_CALENDAR_EVENT_TYPE            type;                  // event type from the ENUM_CALENDAR_EVENT_TYPE enumeration 
   ENUM_CALENDAR_EVENT_SECTOR          sector;                // sector an event is related to 
   ENUM_CALENDAR_EVENT_FREQUENCY       frequency;             // event frequency 
   ENUM_CALENDAR_EVENT_TIMEMODE        time_mode;             // event time mode 
   ulong                               country_id;            // country ID 
   ENUM_CALENDAR_EVENT_UNIT            unit;                  // economic indicator value's unit of measure 
   ENUM_CALENDAR_EVENT_IMPORTANCE      importance;            // event importance 
   ENUM_CALENDAR_EVENT_MULTIPLIER      multiplier;            // economic indicator value multiplier 
   uint                                digits;                // number of decimal places 
   string                              source_url;            // URL of a source where an event is published 
   string                              event_code;            // event code 
   string                              name;                  // event text name in the terminal language (in the current terminal encoding) 
  };

Estrutura de valores do calendário:

struct MqlCalendarValue 
  { 
   ulong                               id;                    // value ID 
   ulong                               event_id;              // event ID 
   datetime                            time;                  // event date and time 
   datetime                            period;                // event reporting period 
   int                                 revision;              // revision of the published indicator relative to the reporting period 
   long                                actual_value;          // actual value multiplied by 10^6 or LONG_MIN if the value is not set 
   long                                prev_value;            // previous value multiplied by 10^6 or LONG_MIN if the value is not set 
   long                                revised_prev_value;    // revised previous value multiplied by 10^6 or LONG_MIN if the value is not set 
   long                                forecast_value;        // forecast value multiplied by 10^6 or LONG_MIN if the value is not set 
   ENUM_CALENDAR_EVENT_IMPACT          impact_type;           // potential impact on the currency rate 
  //--- functions checking the values 
   bool                         HasActualValue(void) const;   // returns true if actual_value is set 
   bool                         HasPreviousValue(void) const; // returns true if prev_value is set 
   bool                         HasRevisedValue(void) const;  // returns true if revised_prev_value is set 
   bool                         HasForecastValue(void) const; // returns true if forecast_value is set 
  //--- functions receiving the values 
   double                       GetActualValue(void) const;   // returns actual_value or nan if the value is no set 
   double                       GetPreviousValue(void) const; // returns prev_value or nan if the value is no set 
   double                       GetRevisedValue(void) const;  // returns revised_prev_value or nan if the value is no set 
   double                       GetForecastValue(void) const; // returns forecast_value or nan if the value is no set 
  };

Agora, a primeira coisa que precisamos fazer é reunir todos os valores disponíveis dentro de um intervalo de tempo de nossa escolha e classificá-los especificamente pelos valores que vimos — oito deles —, além de aplicar os filtros. Para obter os valores, aplicamos a seguinte lógica.

MqlCalendarValue values[];
datetime startTime = TimeTradeServer() - PeriodSeconds(PERIOD_D1);
datetime endTime = TimeTradeServer() + PeriodSeconds(PERIOD_D1);

int valuesTotal = CalendarValueHistory(values, startTime, endTime, NULL, NULL);

Print("TOTAL VALUES = ", valuesTotal, " || Array size = ", ArraySize(values));

Aqui, declaramos um array chamado "values" do tipo estrutura MqlCalendarValue, que armazenará os dados do calendário econômico recuperados do Calendário Econômico do MQL5. Em seguida, configuramos duas variáveis datetime, "startTime" e "endTime", que definem o intervalo de tempo para a extração dos dados. Calculamos o tempo inicial como um dia antes do horário atual do servidor, recuperado usando a função TimeTradeServer e a função PeriodSeconds para criar um deslocamento de 24 horas em segundos. A lógica de um dia é obtida usando a constante "PERIOD_D1". Da mesma forma, "endTime" é definido como um dia após o horário atual do servidor, permitindo capturar eventos econômicos que ocorrem em dois dias centrados no momento presente.

Em seguida, usamos a função CalendarValueHistory para preencher o array "values" com eventos econômicos dentro do intervalo de tempo especificado. Essa função retorna o número total de eventos, que armazenamos na variável "valuesTotal". Os parâmetros de CalendarValueHistory incluem o array "values", "startTime" e "endTime", além de dois filtros NULL para país e tipo de moeda (que deixamos como NULL aqui para recuperar todos os eventos). Por fim, usamos a função Print para imprimir a contagem total de valores e o tamanho do array usando a função ArraySize, confirmando o número total de eventos obtidos e verificando se o array contém os dados esperados para uso posterior em nossa lógica de negociação. Ao compilar isso, obtemos a seguinte saída.

Em seguida, podemos imprimir esses valores no log para confirmar o que temos.

if (valuesTotal >=0 ){
   Print("Calendar values as they are: ");
   ArrayPrint(values);
}

Aqui, primeiro verificamos se o total de valores é maior ou igual a zero, indicando que a função CalendarValueHistory recuperou com sucesso alguns eventos do calendário econômico ou retornou zero sem erros. Se essa condição for atendida, usamos a função Print para exibir a mensagem "Calendar values as they are:", como cabeçalho para nos informar que os valores serão exibidos em seguida. Depois disso, chamamos a função ArrayPrint, que imprime todo o conteúdo do array "values" no log. Ao executar, obtemos os seguintes dados.

Na imagem, vemos que registramos todos os eventos disponíveis dentro do intervalo de tempo selecionado. No entanto, percebemos que os recursos do evento são representados apenas por números, que são identificadores específicos, mas não fornecem muitas informações. Portanto, precisamos selecionar um valor específico e, a partir daí, obter as características detalhadas de cada evento de forma estruturada. Isso significa que precisamos percorrer cada valor selecionado em um loop.

for (int i = 0; i < valuesTotal; i++){

//---

}

Aqui, criamos um for loop que percorre cada elemento do array "values", que contém os dados do calendário econômico O loop inicializa uma variável inteira "i" em zero, representando o índice inicial, e roda enquanto "i" for menor que o total de valores, que é o número de eventos recuperados pela função CalendarValueHistory. A cada iteração, incrementamos "i" em um, permitindo acessar cada evento econômico no array "values" de forma sequencial. Dentro do loop, podemos processar ou analisar os dados de cada evento, o que oferece flexibilidade para tarefas como filtrar eventos, aplicar lógica de negociação baseada em detalhes do evento ou imprimir informações individuais. Aqui está a lógica que precisamos usar.

MqlCalendarEvent event;
CalendarEventById(values[i].event_id,event);

Declaramos uma variável "event" do tipo MqlCalendarEvent, que armazenará as informações detalhadas de um evento econômico específico. Em seguida, chamamos CalendarEventById, passando dois parâmetros. O primeiro parâmetro recupera o ID único do evento econômico atual no array "values" (com base no índice atual i), enquanto o segundo, "event", atua como um contêiner para armazenar os detalhes completos do evento. Usando a função CalendarEventById, acessamos dados completos sobre cada evento específico, como nome, país, previsão e valores reais, que podem ser usados para análise adicional ou decisões de negociação. Para confirmar isso, podemos imprimir o ID do evento da seguinte forma.

Print("Event ID ",values[i].event_id);

No entanto, isso imprimirá muitos dados no log, então vamos reduzir o intervalo de tempo de seleção para uma hora antes e depois do horário atual. Tudo o que precisamos mudar é a seção de período. Destacamos isso em amarelo para fácil referência.

datetime startTime = TimeTradeServer() - PeriodSeconds(PERIOD_H1);
datetime endTime = TimeTradeServer() + PeriodSeconds(PERIOD_H1);

Quando executamos o programa, obtemos a seguinte saída:

Agora podemos prosseguir para obter os valores reais do evento específico selecionado, em vez apenas dos números dos valores do evento. Para isso, basta digitar a palavra-chave do evento e usar o "operador ponto" para acessar todos os métodos e objetos dessa classe ou estrutura. Aqui está o que você deve obter.

Usando o mesmo método, podemos recuperar todas as informações preenchidas e armazenadas na estrutura "event" que criamos.

Print("Event ID ",values[i].event_id);
Print("Event Name = ",event.name);
Print("Event Code = ",event.event_code);
Print("Event Type = ",event.type);
Print("Event Sector = ",event.sector);
Print("Event Frequency = ",event.frequency);
Print("Event Release Mode = ",event.time_mode);
Print("Event Importance = ",EnumToString(event.importance));
Print("Event Time = ",values[i].time);
Print("Event URL = ",event.source_url);

Comment("Event ID ",values[i].event_id,
        "\nEvent Name = ",event.name,
        "\nEvent Code = ",event.event_code,
        "\nEvent Type = ",event.type,
        "\nEvent Sector = ",event.sector,
        "\nEvent Frequency = ",event.frequency,
        "\nEvent Release Mode = ",event.time_mode,
        "\nEvent Importance = ",EnumToString(event.importance),
        "\nEvent Time = ",values[i].time,
        "\nEvent URL = ",event.source_url);
}

Aqui, usamos funções Print para exibir os detalhes de cada evento econômico no array "values" e mostrar essas informações na guia Experts para fácil revisão. Primeiro, imprimimos o ID do evento de values[i], que identifica exclusivamente o evento. Em seguida, recuperamos e imprimimos detalhes específicos do evento da variável "event", incluindo seu nome, código do evento, tipo, setor, frequência, modo de tempo (indicando o modo de divulgação), importância (convertida para string legível usando a função EnumToString) e o horário real agendado. Por fim, imprimimos a fonte Uniform Resource Locator (URL), que fornece um link para informações adicionais.

Junto com essas instruções de impressão, usamos a função Comment para exibir os mesmos detalhes no gráfico para referência imediata. A função Comment exibe cada linha na área de comentários do gráfico, facilitando para o trader visualizar atualizações em tempo real diretamente no gráfico. Após executar o programa, obtemos a seguinte saída.

Isso foi um sucesso. Para obter acesso aos dados de país e moeda, incorporamos outra estrutura que lida com os valores do país. Aqui está a lógica que precisamos adotar, que é idêntica às outras que usamos.

MqlCalendarCountry country;
CalendarCountryById(event.country_id,country);

Aqui, declaramos uma variável "country" do tipo MqlCalendarCountry, que pretendemos usar para armazenar as informações específicas do país relacionadas ao evento econômico. Em seguida, usamos a função CalendarCountryById para recuperar os detalhes do país, passando dois parâmetros.

O primeiro parâmetro fornece o identificador exclusivo do país associado ao evento econômico atual, enquanto o segundo parâmetro, que é "country", serve como o contêiner para os dados desse país. Ao chamar a função CalendarCountryById, populamos nossa variável "country" com informações relevantes, como o nome do país, código e outras características, permitindo-nos usar esses dados para uma análise mais contextualizada e exibir detalhes específicos do país junto com cada evento econômico.

Para exibir isso, novamente imprimimos as informações do país.

Print("Country ID ",country.id);
Print("Country Name ",country.name);
Print("Country Code ",country.code);
Print("Country Currency ",country.currency);
Print("Country Currency Symbol ",country.currency_symbol);
Print("Country URL ",country.url_name);

Este é o resultado quando executamos o programa.

Isso foi um sucesso. Agora temos uma introdução completa às funções necessárias no MQL5 que nos dão acesso aos dados do calendário. Agora, podemos prosseguir para aplicar filtros ao nosso bloco de código para negociar dados específicos de país, prioridade, moeda, bem como notícias específicas de tempo. Para conseguir isso dinamicamente, podemos deslocar nossa lógica para uma função que podemos usar para esse propósito mencionado.

//+------------------------------------------------------------------+
//|       FUNCTION TO GET NEWS EVENTS                                |
//+------------------------------------------------------------------+
bool isNewsEvent(){
   int totalNews = 0;
   bool isNews = false;
   
   //---
   
   return (isNews);
}

Definimos uma função boolean chamada "isNewsEvent", que determinará se há algum evento de notícias econômicas disponível. A função retorna um valor bool para indicar se um evento de notícias está presente (true) ou não (false). Dentro da função, declaramos uma variável inteira "totalNews" e a inicializamos com zero. Pretendemos usar essa variável para armazenar o número total de eventos de notícias relevantes, que recuperaremos posteriormente na função. Também declaramos uma variável bool, "isNews", e a definimos como false. Essa variável atuará como um sinalizador, mudando para true se detectarmos quaisquer eventos de notícias relevantes durante a execução da função.

Atualmente, a função simplesmente retorna o valor de "isNews", que é false por padrão, já que nenhum evento de notícias está sendo processado dentro da função ainda. Essa estrutura de função fornece uma base para implementar a lógica que pode, mais tarde, recuperar e verificar eventos de notícias, definindo "isNews" como true se os eventos forem detectados. É a essa função que adicionamos nossa lógica previamente já definida no manipulador de evento OnInit. No entanto, chamamos a função no manipulador de eventos para afetar a lógica da função.

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit(){
//---   
   if (isNewsEvent()){
      Print("______ ALERT: WE HAVE NEWS EVENT ___");
   }
   else if (isNewsEvent()==false){
      Print("______ ALERT: WE DON'T ANY HAVE NEWS EVENT ___");
   }
//---
   return(INIT_SUCCEEDED);
}

Aqui, dentro do manipulador de eventos OnInit, começamos chamando a função "isNewsEvent". Se a função retornar true, indicando que um evento de notícias está disponível, o bloco if é acionado, e imprimimos a mensagem "______ ALERTA: TEMOS EVENTO DE NOTÍCIA ___". Essa mensagem nos alerta que um evento econômico foi detectado, o que podemos usar para ajustar estratégias de negociação, se desejado.

Se retornar false, significando que nenhum evento de notícias está presente, o bloco else if é acionado, e imprimimos "______ ALERTA: NÃO TEMOS NENHUM EVENTO DE NOTÍCIA ___". Essa mensagem nos alerta que nenhum evento de notícias atual foi identificado, o que pode indicar que a negociação pode prosseguir sem interrupções esperadas das notícias. Finalmente, a função retorna INIT_SUCCEEDED, uma constante que indica que a inicialização do EA foi bem-sucedida. Agora, após essa chamada do manipulador de eventos, podemos continuar a aplicar filtros para o tipo de notícia que é de importância para nós. Atualmente, temos o programa anexado ao símbolo "AUDUSD". Vamos desenvolver uma lógica para garantir que apenas notícias dos Estados Unidos sejam consideradas.

string currency_filter = "USD";
string currency_base = SymbolInfoString(_Symbol,SYMBOL_CURRENCY_BASE);
string currency_quote = StringSubstr(_Symbol,3,3);
if (currency_base != currency_filter && currency_quote != currency_filter){
   Print("Currency (",currency_base," | ",currency_quote,
         ") is not equal equal to ",currency_filter);
   return false;
}

Começamos definindo duas variáveis string, "currency_filter" e "currency_base", para facilitar a verificação se o símbolo atual é relevante para o filtro de moeda especificado, "USD". A variável "currency_filter" é inicializada com o valor "USD", representando a moeda-alvo que estamos interessados em monitorar. Em seguida, recuperamos a moeda base do símbolo atual (por exemplo, AUD no par AUDUSD) usando a função SymbolInfoString e armazenamos em "currency_base".

Depois, definimos "currency_quote", extraindo a moeda de cotação do símbolo atual ao pegar os últimos três caracteres usando a função StringSubstr, já que não há uma forma direta de acessar a moeda de cotação. Por exemplo, no par AUDUSD, a função StringSubstr recuperará "USD", a moeda de cotação.

Em seguida, verificamos se tanto a moeda base quanto a moeda de cotação são diferentes da moeda do filtro. Se não corresponderem à moeda-alvo do filtro (USD, neste caso), imprimimos uma mensagem indicando que as moedas do símbolo não correspondem ao filtro de moeda. A função então retorna false, encerrando efetivamente o processamento posterior se o símbolo for irrelevante para a moeda especificada. Se executarmos isso em diferentes símbolos, teremos a seguinte saída.

A partir da visualização, podemos ver que, quando carregamos o programa nos gráficos "AUDUSD" e "USDJPY", não obtemos nenhum erro, mas quando carregamos no gráfico "EURJPY", recebemos um erro, indicando que nenhuma das moedas corresponde à moeda de filtro predefinida. Agora podemos continuar a aplicar vários filtros dinamicamente por importância do evento e tempo.

if (StringFind(_Symbol,country.currency) >= 0){
   if (event.importance == CALENDAR_IMPORTANCE_MODERATE){
      if (values[i].time <= TimeTradeServer() && values[i].time >= timeBefore){
         Print(event.name," > ", country.currency," > ", EnumToString(event.importance)," Time= ",values[i].time," (ALREADY RELEASED)");
         totalNews++;
      }
            
      if (values[i].time >= TimeTradeServer() && values[i].time <= timeAfter){
         Print(event.name," > ", country.currency," > ", EnumToString(event.importance)," Time= ",values[i].time," (NOT YET RELEASED)");
         totalNews++;
      }
   }
}

Implementamos uma série de condições aninhadas para identificar eventos de notícias relevantes para uma moeda específica, focando em eventos categorizados como "importância moderada" e que se enquadram em um determinado intervalo de tempo. Primeiro, verificamos se o nome do símbolo de negociação atual (representado por _Symbol) contém a moeda associada ao evento. Fazemos isso usando a função StringFind, que garante que consideremos apenas eventos vinculados à moeda do símbolo de negociação.

Isso é semelhante à outra lógica que usamos, apenas que é dinâmica ao verificar automaticamente a disponibilidade da moeda no símbolo selecionado. Se essa verificação for atendida, passamos para a próxima condição para confirmar que o nível de importância do evento corresponde a CALENDAR_IMPORTANCE_MODERATE, significando que estamos focando apenas em eventos com impacto moderado, excluindo aqueles de baixa ou alta importância.

Uma vez que identificamos um evento de importância moderada, avaliamos seu horário em relação ao horário atual do servidor (TimeTradeServer) usando duas verificações separadas. Na primeira verificação, determinamos se o horário do evento é anterior ou igual ao horário atual, mas posterior a "timeBefore". Se for assim, isso significa que o evento já foi divulgado dentro do período de tempo especificado. Em seguida, usamos a função Print para registrar os detalhes sobre o evento, incluindo seu nome, moeda associada, importância e horário, marcando-o como "(JÁ DIVULGADO)". Também incrementamos a variável "totalNews" para acompanhar os eventos que correspondem aos nossos critérios. Na segunda verificação, determinamos se o horário do evento é posterior ou igual ao horário atual, mas anterior ou igual a "timeAfter", indicando que o evento está por vir, mas ainda dentro do período de tempo especificado.

Novamente, registramos detalhes semelhantes do evento usando a função Print, marcando-o como "(AINDA NÃO DIVULGADO)" para indicar seu status pendente, e incrementamos a variável "totalNews" para esse evento adicional relevante. Você pode ter notado que usamos algumas variáveis de tempo diferentes na lógica. Estas servem apenas para garantir que o evento esteja dentro do intervalo de tempo para ação, e aqui está a lógica delas.

datetime timeRange = PeriodSeconds(PERIOD_D1);
datetime timeBefore = TimeTradeServer() - timeRange;
datetime timeAfter = TimeTradeServer() + timeRange;
   
Print("FURTHEST TIME LOOK BACK = ",timeBefore," >>> CURRENT = ",TimeTradeServer());

Declaramos essas lógicas logo antes do for loop para estabelecer um intervalo de tempo em torno do horário atual do servidor e definir até onde queremos olhar para trás e para frente em relação aos eventos de notícias. Primeiro, declaramos uma variável datetime "timeRange" e atribuímos a duração de um dia usando a função PeriodSeconds. Isso nos permite trabalhar com um intervalo de tempo padronizado de 24 horas, no entanto, você pode ajustá-lo para seu intervalo desejado, digamos, 15 minutos antes e depois da divulgação da notícia. Em seguida, definimos duas variáveis datetime adicionais: "timeBefore" e "timeAfter".

Calculamos a variável "timeBefore" subtraindo o intervalo de tempo do horário atual do servidor, o que nos dá o ponto de tempo mais distante que queremos observar no passado. Da mesma forma, "timeAfter" é determinado adicionando "timeRange" ao horário atual do servidor, fornecendo o ponto de tempo mais distante que queremos considerar no futuro. Juntos, "timeBefore" e "timeAfter" criam uma janela de 24 horas centralizada no horário atual, o que nos ajuda a capturar eventos que acabaram de ocorrer ou que são esperados em breve. Aqui está uma ilustração.

Pela imagem, podemos ver que quando a hora atual, ou melhor, a data, já que estamos considerando uma varredura de um dia, é 25, temos o “look-back” na data 24 e o “look-fore” em 26, que é apenas um dia antes e depois da data atual. Nós os destacamos em azul para maior clareza. Finalmente, podemos analisar o número de notícias registradas a partir do loop e retornar os respectivos flags booleanos. Adotamos a seguinte lógica para alcançar isso.

if (totalNews > 0){
   isNews = true;
   Print(">>>>>>> (FOUND NEWS) TOTAL NEWS = ",totalNews,"/",ArraySize(values));
}
else if (totalNews <= 0){
   isNews = false;
   Print(">>>>>>> (NOT FOUND NEWS) TOTAL NEWS = ",totalNews,"/",ArraySize(values));
}

Aqui, avaliamos se algum evento de notícia relevante foi identificado com base no total de notícias registradas. Se o total de notícias for maior que zero, isso indica que pelo menos um evento de notícia que corresponde aos nossos critérios foi encontrado. Nesse caso, definimos a variável "isNews" como true e imprimimos uma mensagem exibindo o número total de eventos de notícias correspondentes e o tamanho do array "values". A mensagem, rotulada como "(FOUND NEWS)", também inclui o total de notícias identificadas e todas as notícias consideradas inicialmente, fornecendo uma contagem de quantos eventos relevantes foram encontrados em relação ao total de eventos recuperados.

Por outro lado, se o total de notícias for igual ou menor que zero, isso implica que nenhum evento de notícia relevante foi encontrado. Nesse cenário, definimos "isNews" como false e imprimimos uma mensagem rotulada como "(NOT FOUND NEWS)", mostrando que o total de notícias é zero junto com o tamanho do array "values". Essa estrutura nos ajuda a rastrear se algum evento de notícia correspondente aos nossos critérios foi encontrado e fornece um log dos resultados, útil para verificar o resultado do processo de checagem de notícias. Após a compilação, obtemos a seguinte saída.

Pela imagem, podemos ver que não há notícias relevantes no momento. Assim, podemos aumentar nossa busca expandindo o intervalo de tempo ou o intervalo de pesquisa de eventos, neste caso, para um dia.

datetime startTime = TimeTradeServer() - PeriodSeconds(PERIOD_D1);
datetime endTime = TimeTradeServer() + PeriodSeconds(PERIOD_D1);

Se retornarmos o intervalo de notícias para um dia, obtemos a seguinte saída.

Pela imagem, podemos ver que temos 5 notícias relevantes de um total de 81 e imprimimos que existem eventos de notícias relevantes, os quais podemos usar para tomar decisões de negociação, isto é, entrar no mercado ou sair dele. Isso é tudo para esta parte, e a função completa responsável pela identificação e filtragem de notícias do calendário do MQL5 está no seguinte trecho de código:

//+------------------------------------------------------------------+
//|       FUNCTION TO GET NEWS EVENTS                                |
//+------------------------------------------------------------------+
bool isNewsEvent(){
   int totalNews = 0;
   bool isNews = false;
   
   MqlCalendarValue values[];
   
   datetime startTime = TimeTradeServer() - PeriodSeconds(PERIOD_D1);
   datetime endTime = TimeTradeServer() + PeriodSeconds(PERIOD_D1);
   
   //string currency_filter = "USD";
   //string currency_base = SymbolInfoString(_Symbol,SYMBOL_CURRENCY_BASE);
   //string currency_quote = StringSubstr(_Symbol,3,3);
   //if (currency_base != currency_filter && currency_quote != currency_filter){
   //   Print("Currency (",currency_base," | ",currency_quote,
   //         ") is not equal equal to ",currency_filter);
   //   return false;
   //}
   
   int valuesTotal = CalendarValueHistory(values,startTime,endTime,NULL,NULL);
   
   Print("TOTAL VALUES = ",valuesTotal," || Array size = ",ArraySize(values));
   
   //if (valuesTotal >=0 ){
   //   Print("Calendar values as they are: ");
   //   ArrayPrint(values);
   //}
   
   datetime timeRange = PeriodSeconds(PERIOD_D1);
   datetime timeBefore = TimeTradeServer() - timeRange;
   datetime timeAfter = TimeTradeServer() + timeRange;
   
   Print("Current time = ",TimeTradeServer());
   Print("FURTHEST TIME LOOK BACK = ",timeBefore," >>> LOOK FORE = ",timeAfter);
   
   for (int i = 0; i < valuesTotal; i++){
      MqlCalendarEvent event;
      CalendarEventById(values[i].event_id,event);
      
      
      MqlCalendarCountry country;
      CalendarCountryById(event.country_id,country);
      
      if (StringFind(_Symbol,country.currency) >= 0){
         if (event.importance == CALENDAR_IMPORTANCE_MODERATE){
            if (values[i].time <= TimeTradeServer() && values[i].time >= timeBefore){
               Print(event.name," > ", country.currency," > ", EnumToString(event.importance)," Time= ",values[i].time," (ALREADY RELEASED)");
               totalNews++;
            }
            
            if (values[i].time >= TimeTradeServer() && values[i].time <= timeAfter){
               Print(event.name," > ", country.currency," > ", EnumToString(event.importance)," Time= ",values[i].time," (NOT YET RELEASED)");
               totalNews++;
            }
         }
      }
      
   }
   
   if (totalNews > 0){
      isNews = true;
      Print(">>>>>>> (FOUND NEWS) TOTAL NEWS = ",totalNews,"/",ArraySize(values));
   }
   else if (totalNews <= 0){
      isNews = false;
      Print(">>>>>>> (NOT FOUND NEWS) TOTAL NEWS = ",totalNews,"/",ArraySize(values));
   }
   
   return (isNews);
}

Conclusão

Resumindo, colocamos em prática as etapas iniciais necessárias para explorar o MQL5 Economic Calendar. Trata-se de extrair informações e então julgá-las de acordo com a importância das moedas e a relevância dos eventos. Desenvolvemos um processo estruturado que nos permite puxar dados do Economic Calendar, filtrá-los por critérios importantes como moeda e relevância do evento, e identificar se os eventos são iminentes ou já ocorreram. Essa abordagem é essencial para automatizar sistemas de negociação que possam responder a desenvolvimentos econômicos impactantes, nos dando uma vantagem para navegar em flutuações do mercado.

Na próxima parte desta série, ampliaremos nossa funcionalidade para exibir os dados econômicos filtrados diretamente na janela do gráfico, aumentando sua visibilidade para decisões de negociação em tempo real. Também vamos melhorar nosso Expert Advisor para que ele use essas informações para abrir posições de negociação com base em grandes eventos econômicos. Com esses recursos integrados, passaremos da análise das notícias econômicas para o real aproveitamento dessas notícias nas negociações. Tornaremos nossos sistemas mais responsivos projetando-os em torno de uma estrutura em tempo real e usando as informações aprendidas a partir dos eventos do calendário econômico para disparar negociações na esteira desses eventos. Fique atento.