Desenvolvimento do Conjunto de Ferramentas de Análise de Price Action – Parte (4): Analytics Forecaster EA

Conteúdo:

• Introdução
• Revisão do artigo anterior
• Visão geral do projeto
• Construindo um bot do Telegram e obtendo IDs de gráficos
• Implementando a integração do Telegram ao EA (Expert Advisor)
• Teste 
• Conclusão

Introdução

Tendo passado de um script para um Expert Advisor (EA), a ferramenta anterior, Analytics Master EA, foi projetada para analisar métricas-chave e fornecer atualizações contínuas diretamente no gráfico. Embora tenha servido como um ativo fundamental, suas capacidades eram limitadas ao acesso das informações analíticas apenas dentro do próprio gráfico. Antes de prosseguirmos com o desenvolvimento de ferramentas de análise mais avançadas, acredito ser essencial aprimorar a forma como transmitimos nossas informações analíticas.

Neste artigo, focaremos na integração da nossa transmissão com o Telegram, para garantir um acesso mais amplo às informações analisadas. Escolhi o Telegram para esse propósito devido à sua popularidade e interface acessível entre os traders. Integrar as atualizações do gráfico do MetaTrader 5 com o Telegram oferece vantagens significativas para traders ativos. Essa configuração proporciona acesso imediato a informações cruciais do mercado, aprimora a experiência do usuário e melhora a comunicação. Consequentemente, você pode desenvolver estratégias mais eficazes e responder rapidamente em um mercado em constante mudança. Com essa integração, é possível aumentar suas chances de sucesso e tomar decisões mais informadas e oportunas.

Revisão do artigo anterior

Vamos dar uma olhada em nossa ferramenta anterior, Analytics Master EA, para uma recapitulação. Estamos integrando as mesmas informações analíticas dessa ferramenta ao Telegram. Para saber mais sobre ela, siga o link https://www.mql5.com/pt/articles/16434 . O Analytics Master EA foi projetado para analisar e calcular as seguintes métricas-chave do mercado:

• Abertura e fechamento do dia anterior
• Volume do Dia Anterior
• Volume do Dia Atual
• Máxima e mínima do dia anterior
• Níveis-chave de suporte e resistência
• Saldo da conta
• Equity da conta
• Spread de Mercado
• Tamanho mínimo e máximo de lote
• Volatilidade de Mercado

Compreender esses valores de métricas é fundamental para os traders, pois fornecem percepções sobre o comportamento e as tendências do mercado. As métricas do dia anterior ajudam a estabelecer um contexto para as condições atuais do mercado, enquanto as métricas atuais auxiliam na avaliação do desempenho. Ao identificar níveis de suporte e resistência, os traders podem tomar decisões mais informadas sobre pontos de entrada e saída. Além disso, conhecer o saldo e a equity da conta garante que o risco de negociação seja gerenciado de forma eficaz. Percepções sobre o spread, os tamanhos de lote e a volatilidade são essenciais para otimizar a execução das negociações e maximizar os lucros potenciais, minimizando riscos. No geral, uma boa compreensão dessas métricas capacita os traders a desenvolver estratégias informadas e aprimorar o desempenho geral de suas operações.

O EA traçava linhas de tendência para os níveis-chave de suporte e resistência e fornecia a direção de mercado prevista com base nas métricas calculadas. Todas essas informações eram apresentadas no gráfico em formato de tabela, atualizadas regularmente a cada duas horas. Veja a Fig 1 abaixo.

Fig 1. Resultado da Análise

A seção de análise também incluía o horário da última atualização, facilitando a referência às informações mais recentes.A ferramenta foi projetada exclusivamente para análise de mercado; ela não executa negociações automaticamente. Os usuários devem executar manualmente suas operações com base nas informações e sinais gerados. Para obter resultados ideais, é importante combinar esses dados com a própria estratégia de negociação do usuário.

Visão geral do projeto

A integração com o Telegram no MetaTrader 5 envolve conectar a plataforma de negociação MetaTrader 5 ao Telegram, um serviço de mensagens, permitindo que os traders recebam notificações, alertas e análises instantâneas sobre suas atividades de negociação diretamente no chat do Telegram. Essa integração utiliza a API do Bot do Telegram, permitindo a comunicação automatizada entre o algoritmo de negociação ou Expert Advisor (EA) em execução no MetaTrader 5 e um chat específico no Telegram. O diagrama abaixo resume tudo.

Fig 2. Caminho de Integração

Componentes-Chave da Integração

• Bot do Telegram: Crie um bot no Telegram usando o BotFather, que fornecerá um token de acesso necessário para autenticar as solicitações enviadas à API do Telegram.
• ID do Chat: Identifique o ID do chat para onde as mensagens devem ser enviadas. Esse chat pode ser pessoal ou em grupo, e é usado para definir o destino dos alertas.
• MetaTrader 5: Utilize a linguagem MQL5 para desenvolver ou modificar EAs ou scripts que possam se conectar à API do Telegram. Isso geralmente envolve o uso de requisições HTTP POST para enviar mensagens.

Construindo um bot do Telegram e obtendo IDs de gráficos 

Bots do Telegram são aplicativos de software automatizados que operam dentro da plataforma de mensagens Telegram, permitindo interação com os usuários por meio de tarefas automáticas. Uma de suas principais funções é agilizar a comunicação, fornecendo respostas rápidas e relevantes às solicitações dos usuários sem intervenção humana. Essa capacidade permite que empresas e desenvolvedores automatizem várias tarefas, como envio de notificações e processamento de comandos, melhorando a experiência e o engajamento dos usuários.

Além disso, os bots do Telegram se destacam na recuperação de informações; eles podem obter dados de fontes externas, como dados de mercado ou feeds de notícias, e entregá-los diretamente aos usuários. No contexto de negociação, os bots são particularmente valiosos para alertar os usuários sobre eventos específicos do mercado, variações de preços ou sinais baseados em critérios predefinidos. Sua capacidade de integração com APIs e outros serviços lhes permite executar funções avançadas como análise de dados e geração de relatórios, tornando-os ferramentas versáteis para diversas aplicações. Siga as etapas abaixo para criar seu bot do Telegram:

Etapa 1: Abra o aplicativo Telegram

Certifique-se de ter o aplicativo Telegram instalado em seu dispositivo.

Etapa 2: Pesquise pelo BotFather

Fig 3. Botfather

Na barra de pesquisa do aplicativo, digite BotFather.

O BotFather é um bot oficial do Telegram que permite criar e gerenciar outros bots.

Etapa 3: Inicie uma conversa com o BotFather

Fig 4. Etapas 3 e 4

Clique no resultado do BotFather para abrir o chat.

Clique no botão Start ou digite /start para iniciar a conversa.

Etapa 4: Crie um novo bot

Digite o comando /newbot e envie.

O BotFather solicitará que você escolha um nome para o seu bot. Esse será o nome exibido aos usuários.

Após inserir o nome, será solicitado que você forneça um nome de usuário para o seu bot. O nome de usuário deve terminar com “bot” (por exemplo, MyCoolBot).

Etapa 5: Receba o token do seu bot

Fig 5. Etapa 5

Após concluir as etapas anteriores, o BotFather criará seu bot e fornecerá um token exclusivo de API. Esse token é essencial para interagir com a API do Bot do Telegram, portanto, salve-o em local seguro.

Após criar o seu bot do Telegram, o próximo passo é encontrar seu ID do chat. Os Chart IDs, por outro lado, são identificadores exclusivos atribuídos a visualizações ou gráficos específicos dentro de aplicativos ou ferramentas de negociação. Esses IDs desempenham um papel fundamental na identificação e recuperação de gráficos, permitindo que usuários e desenvolvedores façam referência a visualizações específicas com facilidade. Os Chart IDs facilitam a extração de dados atuais ou históricos relacionados a determinados gráficos, permitindo uma abordagem personalizada de análise de dados. Esse aspecto é especialmente benéfico no trading, pois capacita os usuários a acessar rapidamente informações relevantes, resultando em decisões mais informadas.

Além disso, os Chart IDs permitem personalização, permitindo que os desenvolvedores modifiquem parâmetros e configurações de acordo com as preferências individuais dos usuários ou estratégias de negociação. Quando integrados aos bots do Telegram, os Chart IDs podem aprimorar significativamente a funcionalidade; eles permitem que os bots forneçam aos usuários visualizações de dados específicas diretamente no chat, simplificando o processo de obtenção de insights e tomada de decisões. Abaixo estão dois métodos para obtê-los usando bots do Telegram.

Método 1: Usando bots de identificação (Get ID Bots)

Essa é uma abordagem simples. Você pode procurar e abrir bots como @get_id_bot ou @userinfobot. Ao iniciar o bot clicando em Start ou digitando /start, ele responderá com o seu chat ID, que você poderá anotar.

Fig 6. Get ID

Método 2: Usando um navegador da web

Comece enviando qualquer mensagem para o seu bot no Telegram. Em seguida, abra um navegador e insira o seguinte URL, substituindo <YourBotToken> pelo token real do seu bot: 

https://api.telegram.org/bot<YourBotToken>/getUpdates

Após pressionar Enter, examine a resposta retornada pela API. Seu chat ID estará localizado na seção “result” da resposta.

Implementando a integração do Telegram ao EA (Expert Advisor)

A implementação da integração do Telegram no EA envolve incorporar os recursos de mensagens do Telegram em nosso Expert Advisor (EA) no MetaTrader. Essa integração permite que o EA envie notificações e alertas instantâneos diretamente para uma conta do Telegram, mantendo os usuários informados sobre condições de mercado, métricas-chave e outras informações essenciais de negociação. Ao utilizar a API do Telegram, é possível aprimorar a funcionalidade do EA, garantindo que os usuários recebam atualizações importantes sem a necessidade de verificar constantemente a plataforma de negociação. Isso melhora a capacidade de resposta às mudanças do mercado, tornando a experiência de negociação mais eficiente.

O código do Analytics Master EA foi aprimorado com a incorporação de comandos que permitem retransmitir as métricas analisadas para o aplicativo Telegram. Eu fornecerei o código completo em MQL5 com a integração e guiarei você passo a passo por todo o processo.

Código do Analytics Forecaster (EA)

//+-------------------------------------------------------------------+
//|                                        Analytics Forecaster EA.mq5|
//|                                 Copyright 2024, Christian Benjamin|
//|                                               https://www.mql5.com|
//+-------------------------------------------------------------------+
#property copyright   "2024, MetaQuotes Software Corp."
#property link        "https://www.mql5.com/en/users/lynnchris"
#property description "EA for market analysis,commenting and Telegram Integeration"
#property version     "1.1"
#property strict

// Inputs for risk management
input double RiskPercentage = 1.0;        // Percentage of account balance to risk per trade
input double StopLossMultiplier = 1.0;    // Multiplier for determining the stop loss distance
input int ATR_Period = 14;                // Period for ATR calculation

// Telegram configuration
input string TelegramToken = "YOUR BOT TOKEN"; // Your Telegram bot token
input string ChatID = "YOUR CHART ID"; // Your chat ID
input bool SendTelegramAlerts = true; // Option to enable/disable Telegram notifications

// Global variables for storing values
datetime lastUpdateTime = 0;
double previousDayOpen, previousDayClose, previousDayHigh, previousDayLow;
double previousDayVolume;
double currentDayVolume;
double support, resistance;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   lastUpdateTime = 0; // Set the initial update time
   return INIT_SUCCEEDED;
  }

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   ObjectsDeleteAll(0); // Clean up any drawn objects on the current chart
  }

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   UpdateMetrics(); // Call to the function that fetches and displays the metrics
  }

//+------------------------------------------------------------------+
//| Update metrics and display them                                  |
//+------------------------------------------------------------------+
void UpdateMetrics()
  {
// Check if 2 hours have passed since the last update
   if(TimeCurrent() - lastUpdateTime >= 2 * 3600)
     {
      // Fetch previous day's data
      datetime prevDay = iTime(NULL, PERIOD_D1, 1);
      previousDayOpen = iOpen(NULL, PERIOD_D1, 1);
      previousDayClose = iClose(NULL, PERIOD_D1, 1);
      previousDayHigh = iHigh(NULL, PERIOD_D1, 1);
      previousDayLow = iLow(NULL, PERIOD_D1, 1);
      previousDayVolume = iVolume(NULL, PERIOD_D1, 1);

      // Fetch current day's volume
      currentDayVolume = iVolume(NULL, PERIOD_D1, 0); // Volume for today

      // Calculate support and resistance
      support = previousDayLow - (previousDayHigh - previousDayLow) * 0.382; // Fibonacci level
      resistance = previousDayHigh + (previousDayHigh - previousDayLow) * 0.382; // Fibonacci level

      // Determine market direction
      string marketDirection = AnalyzeMarketDirection(previousDayOpen, previousDayClose, previousDayHigh, previousDayLow);

      // Calculate possible lot size based on risk management
      double lotSize = CalculateLotSize(support, resistance);

      // Retrieve account metrics
      double accountBalance = AccountInfoDouble(ACCOUNT_BALANCE);
      double accountEquity = AccountInfoDouble(ACCOUNT_EQUITY);

      // Calculate market spread manually
      double marketBid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
      double marketAsk = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
      double marketSpread = marketAsk - marketBid; // Calculate spread

      double minLotSize = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
      double maxLotSize = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);

      // Calculate market volatility using ATR
      int atrHandle = iATR(NULL, PERIOD_H1, ATR_Period); // Get the ATR handle
      double atrValue = 0.0;

      if(atrHandle != INVALID_HANDLE)   // Check if the handle is valid
        {
         double atrBuffer[]; // Array to hold the ATR values
         if(CopyBuffer(atrHandle, 0, 0, 1, atrBuffer) > 0)   // Copy the latest ATR value
           {
            atrValue = atrBuffer[0]; // Retrieve the ATR value from the buffer
           }
         IndicatorRelease(atrHandle); // Release the indicator handle
        }

      // Create the output string, including pair name and last update time
      string pairName = Symbol(); // Get the current symbol name
      string lastUpdateStr = TimeToString(TimeCurrent(), TIME_DATE | TIME_MINUTES);
      string infoStr = StringFormat("Pair: %s\nPrev Day Open: %.2f\nPrev Day Close: %.2f\nPrev Day High: %.2f\nPrev Day Low: %.2f\n"
                                    "Prev Day Volume: %.0f\nCurrent Day Volume: %.0f\nMarket Direction: %s\n"
                                    "Support: %.2f\nResistance: %.2f\nAccount Balance: %.2f\nAccount Equity: %.2f\n"
                                    "Market Spread: %.2f\nMin Lot Size: %.2f, Max Lot Size: %.2f\n"
                                    "Market Volatility (ATR): %.2f\nLast Update Time: %s\nPossible Lot Size: %.2f",
                                    pairName, previousDayOpen, previousDayClose, previousDayHigh, previousDayLow,
                                    previousDayVolume, currentDayVolume, marketDirection,
                                    support, resistance, accountBalance, accountEquity, marketSpread,
                                    minLotSize, maxLotSize, atrValue, lastUpdateStr, lotSize);

      // Log the information
      Print(infoStr);

      // Display information on the chart
      Comment(infoStr);

      // Send Telegram notification
      if(SendTelegramAlerts)
         SendTelegramMessage(infoStr);

      // Remove old trend lines and create new ones for previous day's high/low
      ObjectsDeleteAll(0);

      // Draw continuous trend lines
      DrawContinuousTrendLine("PrevDayHigh", previousDayHigh);
      DrawContinuousTrendLine("PrevDayLow", previousDayLow);

      // Update last update time
      lastUpdateTime = TimeCurrent();
     }
  }

//+------------------------------------------------------------------+
//| Analyze market direction                                         |
//+------------------------------------------------------------------+
string AnalyzeMarketDirection(double open, double close, double high, double low)
  {
   string direction;

   if(close > open)
     {
      direction = "Bullish";
     }
   else
      if(close < open)
        {
         direction = "Bearish";
        }
      else
        {
         direction = "Neutral";
        }

// Include current trends or patterns based on high and low for further analysis
   if(high > open && high > close)
     {
      direction += " with bullish pressure"; // Example addition for context
     }
   else
      if(low < open && low < close)
        {
         direction += " with bearish pressure"; // Example addition for context
        }

   return direction;
  }

//+------------------------------------------------------------------+
//| Draw a continuous trend line to the left on the chart            |
//+------------------------------------------------------------------+
void DrawContinuousTrendLine(string name, double price)
  {
   datetime startTime = TimeCurrent() - 720 * 3600; // Extend 24 hours into the past
   ObjectCreate(0, name, OBJ_TREND, 0, startTime, price, TimeCurrent(), price);
   ObjectSetInteger(0, name, OBJPROP_COLOR, (StringFind(name, "High") >= 0) ? clrRed : clrBlue);
   ObjectSetInteger(0, name, OBJPROP_WIDTH, 2); // Set thickness of the line
   ObjectSetInteger(0, name, OBJPROP_XSIZE, 0); // Set this property to extend the line infinitely to the left
  }

//+------------------------------------------------------------------+
//| Calculate the lot size based on risk management                  |
//+------------------------------------------------------------------+
double CalculateLotSize(double support, double resistance)
  {
   double stopLossDistance = MathAbs((support - resistance) * StopLossMultiplier);
   double riskAmount = AccountInfoDouble(ACCOUNT_BALANCE) * (RiskPercentage / 100.0);

// Get the tick size for the current symbol
   double tickSize = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);

// Calculate the lot size based on the stop loss and tick size
   double lotSize = riskAmount / (stopLossDistance / tickSize); // Adjusted for the correct pip size
   lotSize = NormalizeDouble(lotSize, 2); // Normalize the lot size to two decimal places

// Ensure lot size is above minimum lot size allowed by broker
   double minLotSize = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
   if(lotSize < minLotSize)
      lotSize = minLotSize;

   return lotSize;
  }

//+------------------------------------------------------------------+
//| Send message to Telegram API                                     |
//+------------------------------------------------------------------+
void SendTelegramMessage(string message)
  {
   string url = StringFormat("https://api.telegram.org/bot%s/sendMessage", TelegramToken);
   string headers = "Content-Type: application/json\r\n"; // Content type for JSON
   int timeout = 1000; // Timeout in milliseconds

// Format the data as JSON
   string postData = StringFormat("{\"chat_id\":\"%s\",\"text\":\"%s\"}", ChatID, message);

// Convert the string to a char array
   char dataArray[];
   StringToCharArray(postData, dataArray);

// Prepare the result buffer and response headers
   char result[];
   string responseHeaders;

// Perform the web request
   int responseCode = WebRequest("POST", url, headers, timeout, dataArray, result, responseHeaders);
   if(responseCode == 200)   // HTTP 200 OK
     {
      Print("Message sent successfully!");
     }
   else
     {
      PrintFormat("Error sending message. HTTP Response Code: %d. Error: %s", responseCode, GetLastError());
     }
  }

//+------------------------------------------------------------------+
//+------------------------------------------------------------------+

1. Declarar variáveis de entrada:

No início do nosso EA, devemos declarar as variáveis de entrada necessárias. As variáveis de entrada em MQL5 permitem que os traders personalizem o funcionamento do EA sem alterar o código. Isso facilita a adaptação rápida de estratégias de negociação. É essencial nomear as variáveis de forma intuitiva. Por exemplo, TelegramToken indica claramente sua finalidade. Considere usar valores padrão que estejam alinhados com práticas comuns ou com as configurações da sua estratégia de negociação, reduzindo a complexidade de configuração durante os testes.

input string TelegramToken = "YOUR_BOT_API_TOKEN"; // Replace with your actual bot token
input string ChatID = "YOUR_CHAT_ID"; // Replace with your actual chat ID
input bool SendTelegramAlerts = true; // Control whether alerts are sent

 Lembre-se de substituir "YOUR_BOT_API_TOKEN" e "YOUR_CHAT_ID" pelos valores reais.

2. Criar a função de envio de mensagem:

A função SendTelegramMessage constrói de forma eficaz uma requisição HTTP POST estruturada para a API do Telegram, enviando uma notificação ao chat especificado. Ao preparar a URL da API, definir os cabeçalhos, formatar os dados da mensagem em JSON, executar a requisição e lidar com a resposta, essa função permite que o EA envie atualizações instantâneas aos usuários via Telegram. Essa lógica simplificada possibilita comunicação rápida de operações e alertas, aprimorando a funcionalidade geral do EA como assistente de negociação ao manter o usuário informado com facilidade.

• Propósito da Função: Essa função lida com a comunicação com a API do Telegram. Ela encapsula a lógica necessária para enviar uma mensagem ao nosso bot do Telegram. Ao criar funções reutilizáveis, garantimos clareza no código e reduzimos duplicações.
• Tratamento de Erros: Incorporar tratamento de erros é fundamental. Sempre que enviarmos uma mensagem, devemos registrar não apenas os envios bem-sucedidos, mas também quaisquer erros que ocorrerem. Essa prática auxilia na depuração e fornece feedback.

void SendTelegramMessage(string message)
{
    string url = StringFormat("https://api.telegram.org/bot%s/sendMessage", TelegramToken);
    string headers = "Content-Type: application/json\r\n";
    int timeout = 1000;

    string postData = StringFormat("{\"chat_id\":\"%s\",\"text\":\"%s\"}", ChatID, message);

    char dataArray[];
    StringToCharArray(postData, dataArray);

    char result[];
    string responseHeaders;

    int responseCode = WebRequest("POST", url, headers, timeout, dataArray, result, responseHeaders);
    if (responseCode == 200)
    {
        Print("Message sent successfully! Response: ", CharArrayToString(result));
    }
    else
    {
        PrintFormat("Error sending message. HTTP Response Code: %d. Error: %s", responseCode, GetLastError());
    }
}

• Compreendendo o WebRequest: A função WebRequest é crucial, pois permite que nosso EA faça requisições HTTP para APIs. Certifique-se de que a opção “Allow automated trading” esteja habilitada nas propriedades do EA para garantir o funcionamento adequado.

Disparo da mensagem no Telegram

• Verificação de tempo e obtenção de dados

A primeira parte do código inicia uma verificação de tempo para determinar se se passaram duas horas desde a última atualização das métricas de mercado. Usando a função TimeCurrent(), o código obtém a hora atual e a compara com a variável lastUpdateTime. Se mais de duas horas tiverem se passado, o Expert Advisor (EA) prossegue para coletar os dados mais recentes das condições de mercado. Essa verificação é crucial para evitar que o EA envie mensagens em excesso no chat do Telegram, o que poderia ser percebido como spam pelo usuário.

// Check if 2 hours have passed since the last update
if (TimeCurrent() - lastUpdateTime >= 2 * 3600)
{
    // ... [Code that fetches data and calculates support/resistance, etc.]
}

• Criação da string de saída

Na segunda parte, uma string detalhada de saída, chamada infoStr, é gerada para consolidar as métricas de mercado coletadas pelas operações do EA. O código obtém o símbolo de negociação atual com o nome do par e, adicionalmente, formata o horário atual da mensagem usando lastUpdateStr. A função StringFormat é então usada para construir a mensagem, incorporando vários marcadores de posição que serão substituídos pelas métricas específicas — como máxima, mínima, abertura e fechamento do dia anterior, volume do dia atual, direção de mercado e outros detalhes da conta. Essa string formatada é essencial para a operação, pois apresenta um resumo claro e estruturado das condições atuais do mercado, que será posteriormente enviada via Telegram.

// Create the output string, including pair name and last update time
string pairName = Symbol(); // Get the current symbol name
string lastUpdateStr = TimeToString(TimeCurrent(), TIME_DATE | TIME_MINUTES);
string infoStr = StringFormat("Pair: %s\nPrev Day Open: %.2f\nPrev Day Close: %.2f\n"
                               "Prev Day High: %.2f\nPrev Day Low: %.2f\n"
                               "Prev Day Volume: %.0f\nCurrent Day Volume: %.0f\n"
                               "Market Direction: %s\nSupport: %.2f\nResistance: %.2f\n"
                               "Account Balance: %.2f\nAccount Equity: %.2f\n"
                               "Market Spread: %.2f\nMin Lot Size: %.2f, Max Lot Size: %.2f\n"
                               "Market Volatility (ATR): %.2f\nLast Update Time: %s\nPossible Lot Size: %.2f",
                               pairName, previousDayOpen, previousDayClose, previousDayHigh,
                               previousDayLow, previousDayVolume, currentDayVolume,
                               marketDirection, support, resistance, accountBalance,
                               accountEquity, marketSpread, minLotSize, maxLotSize,
                               atrValue, lastUpdateStr, lotSize);

•  Registro e Exibição das Informações

A terceira parte foca no registro e na exibição das informações construídas. A chamada da função Print (infoStr); serve para registrar a mensagem na aba Experts da plataforma MetaTrader, permitindo visibilidade sobre as informações que estão sendo enviadas ao Telegram. Isso fornece uma ferramenta útil de depuração para confirmar se as métricas estão sendo formuladas corretamente. Além disso, o comando Comment(infoStr); exibe as mesmas informações diretamente no gráfico de negociação, oferecendo aos traders uma confirmação visual das métricas sem a necessidade de consultar os logs. Essas etapas mantêm o usuário informado sobre as métricas reportadas e verificam a precisão dos dados antes de enviá-los ao Telegram.

// Log the information
Print(infoStr); // Here the information is logged for debugging

// Display information on the chart
Comment(infoStr); // Display the same information on the chart

• Envio da Notificação para o Telegram

Na parte final, o código gerencia o envio real da notificação para o Telegram. A instrução (SendTelegramAlerts) verifica se a opção de envio de alertas está habilitada, permitindo que os usuários desativem facilmente as notificações sem necessidade de modificar o código. Se os alertas estiverem habilitados, a função SendTelegramMessage(infoStr) é chamada, enviando a mensagem cuidadosamente construída para o chat especificado no Telegram. Essa etapa é crítica, pois é o ponto em que as métricas de mercado são comunicadas efetivamente ao usuário. Em seguida, o código atualiza a variável lastUpdateTime para o horário atual, usando lastUpdateTime = TimeCurrent();, marcando assim a conclusão desse ciclo de atualização e garantindo que o tempo até a próxima atualização siga o intervalo de duas horas estabelecido anteriormente.

// Send Telegram notification
if (SendTelegramAlerts) // Check if sending alerts is enabled
    SendTelegramMessage(infoStr); // Send the constructed message

// Update last update time
lastUpdateTime = TimeCurrent();

• Nome do Par Atual

Também adicionei um recurso que exibe o nome do par atual junto às métricas analisadas, facilitando a identificação de qual par está sendo avaliado.

// Create the output string, including pair name and last update time
      string pairName = Symbol(); // Get the current symbol name

Abaixo está como a informação aparecerá no Telegram:

Fig 7. Resultado do Par

Teste 

Antes de testar, é necessário realizar alguns ajustes no seu MetaTrader 5 para garantir que as informações sejam enviadas ao Telegram corretamente.

Permitir Requisições Web:

• Abra o MetaTrader 5 e vá até Tools > Options > Expert Advisors.

Fig 8. Configuração de Web Requests

• Marque a caixa "Allow WebRequest for listed URL" e adicione https://api.telegram.org à lista. Essa configuração permite que o EA envie requisições para a API do Telegram.

Fig 9. Configuração de Web Requests

Para fins de teste, você também pode ajustar o tempo de atualização para uma frequência menor. Neste caso, reduzi o intervalo de 2 horas para 15 segundos.

//+------------------------------------------------------------------+
//| Update metrics and display them                                  |
//+------------------------------------------------------------------+
void UpdateMetrics()
  {
// Check if 15 seconds have passed since the last update
   if(TimeCurrent() - lastUpdateTime >= 15)

Agora, prossiga para compilar seu código MQL5 no MetaEditor e anexe o Expert Advisor ou script a um gráfico no MetaTrader 5. Após uma compilação bem-sucedida, arraste o seu EA para o gráfico. A partir daí, você deverá começar a receber notificações no seu Telegram sobre as atualizações enviadas pelo EA. Abaixo, estão ilustrados os resultados do teste feitos em meu Telegram.

Fig 10. Resultado no Telegram

O diagrama abaixo também mostra que as informações exibidas no gráfico do MetaTrader 5 são as mesmas enviadas para o Telegram.

Fig 11. Resultados dos Testes

Conclusão

Em conclusão, o sucesso do Analytics Forecaster EA, conforme demonstrado nos diagramas acima, reside em sua abordagem sofisticada de análise de mercado e notificações pontuais através da integração com o Telegram. Ao utilizar diversas métricas de negociação, como dados do dia anterior, comparações de volume atual, direção de mercado e princípios de gerenciamento de risco, o EA fornece aos traders percepções valiosas. Os níveis de suporte e resistência calculados, combinados com a determinação automática do tamanho do lote, permitem decisões de negociação mais informadas, garantindo que tanto traders iniciantes quanto experientes possam adaptar suas estratégias de acordo com as condições do mercado, enquanto gerenciam o risco de forma eficaz.

Além disso, a integração fluida com o Telegram aprimora a interação do usuário, fornecendo atualizações rápidas e permitindo que os traders reajam prontamente às mudanças do mercado. A capacidade de receber informações críticas de negociação em uma plataforma móvel melhora significativamente a conveniência no monitoramento das operações, além de promover um ambiente de negociação mais dinâmico e responsivo. No geral, o Analytics Forecaster EA demonstra capacidades notáveis na automação da análise e do gerenciamento de risco, capacitando os traders a otimizar seu desempenho em um mercado em constante movimento. Com foco na precisão dos dados e em recursos de fácil uso, este EA se destaca como uma ferramenta poderosa no arsenal de qualquer trader, abrindo caminho para futuros avanços em soluções automatizadas de negociação.

Data	Nome da Ferramenta	Descrição	Versão	Atualizações	Notas
01/10/24	Projetor de Gráficos	Script para sobrepor a ação de preço do dia anterior com efeito fantasma.	1.0	Lançamento Inicial	A primeira ferramenta do Lynnchris Tools Chest
18/11/24	Comentário Analítico	Ele fornece informações do dia anterior em formato tabular, bem como antecipa a direção futura do mercado.	1.0	Lançamento Inicial	Segunda ferramenta no Lynnchris Tool Chest
27/11/24	Mestre em Análise	Atualização Regular das métricas de mercado a cada duas horas	1.01	Segundo Lançamento	Terceira ferramenta no Lynnchris Tool Chest
02/12/2024	Analytics Forecaster	Atualização regular das métricas de mercado a cada duas horas com integração ao Telegram	1.1	Terceira Edição	Ferramenta número 5