Desarrollo de un kit de herramientas para el análisis de la acción del precio (Parte 4): Analytics Forecaster EA

MetaTrader 5 — Integración | 8 septiembre 2025, 09:26

215

Christian Benjamin

Contenido:

Introducción

Tras pasar de un script a un Asesor Experto (Expert Advisor, EA), la herramienta anterior, Analytics Master EA, se diseñó para analizar métricas clave y proporcionar actualizaciones continuas directamente en el gráfico. Si bien funcionó como un activo fundamental, sus capacidades se limitaban a acceder a la información de análisis únicamente dentro del propio gráfico. Antes de continuar con el desarrollo de herramientas de análisis más avanzadas, creo que es esencial mejorar nuestra transmisión de información analítica.

En este artículo, nos centraremos en integrar nuestra transmisión con Telegram para garantizar un acceso más amplio a la información analizada. Elegí Telegram para este propósito debido a su popularidad y su interfaz accesible entre los traders. La integración de las actualizaciones de gráficos de MetaTrader 5 con Telegram ofrece ventajas significativas para los traders activos. Esta configuración proporciona acceso inmediato a información crucial del mercado, mejora la experiencia del usuario y mejora la comunicación. En consecuencia, puede desarrollar estrategias más efectivas y responder con rapidez en un mercado que cambia rápidamente. Con esta integración, puede aumentar sus posibilidades de éxito y tomar decisiones más informadas y oportunas.

Revisión del artículo anterior

Echemos un vistazo a nuestra herramienta anterior, Analytics Master EA, para hacer un resumen. Estamos integrando la misma información analítica de esta herramienta en Telegram. Para obtener más información al respecto, siga el enlace https://www.mql5.com/es/articles/16434. El Analytics Master EA se diseñó para analizar y calcular las siguientes métricas clave del mercado:

Apertura y cierre del día anterior
Volumen del día anterior
Volumen del día actual
Máximos y mínimos del día anterior
Niveles clave de soporte y resistencia
Balance de la cuenta
Equidad de la cuenta
Spread del mercado
Tamaño mínimo y máximo de lote
Volatilidad del mercado

Comprender estos valores métricos es crucial para los traders, ya que proporcionan información sobre el comportamiento y las tendencias del mercado. Las métricas del día anterior ayudan a establecer un contexto para las condiciones actuales del mercado, mientras que las métricas actuales ayudan a medir el rendimiento. Al identificar los niveles de soporte y resistencia, los operadores pueden tomar decisiones más informadas sobre los puntos de entrada y salida. Además, conocer el saldo de la cuenta y el capital garantiza que el riesgo comercial se gestione de manera eficaz. Conocer los diferenciales de mercado, los tamaños de los lotes y la volatilidad es esencial para optimizar la ejecución de operaciones y maximizar las ganancias potenciales y minimizar los riesgos. En general, un conocimiento sólido de estas métricas permite a los traders diseñar estrategias informadas y mejorar el rendimiento comercial general.

El EA dibujó líneas de tendencia para los niveles clave de soporte y resistencia y proporcionó una dirección anticipada del mercado basada en las métricas calculadas. Toda esta información se presentó en el gráfico en formato de tabla, actualizado regularmente cada dos horas. Vea la figura 1 a continuación.

Resultado del Analytics Master EA

Figura 1. Resultado del análisis

La sección de análisis también incluye la fecha de la última actualización para facilitar la consulta de la información más reciente. La herramienta está diseñada exclusivamente para el análisis de mercado; no ejecuta operaciones automáticamente. Los usuarios deben ejecutar manualmente sus operaciones basándose en la información analizada y las señales generadas. Para obtener resultados óptimos, es importante combinar estos datos con la propia estrategia comercial del usuario.

Descripción general del proyecto

La integración de Telegram con MetaTrader 5 implica conectar la plataforma comercial MetaTrader 5 a Telegram, un servicio de mensajería, que permite a los operadores recibir notificaciones instantáneas, alertas y análisis sobre sus actividades comerciales directamente en su chat de Telegram. Esta integración utiliza la API de Telegram, lo que permite la comunicación automatizada desde el algoritmo comercial (Asesor Experto) que se ejecuta en MetaTrader 5 a un chat de Telegram designado. El diagrama a continuación lo resume todo.

Figura 2. Itinerario de integración

Componentes clave de la integración

Bot de Telegram: Crea un bot de Telegram utilizando BotFather en Telegram, que proporciona un token de acceso necesario para autenticar las solicitudes enviadas a la API de Telegram.
Chat ID: Identifica el ID del chat al que deben enviarse los mensajes. Puede tratarse de un chat personal o un chat grupal, y se utiliza para determinar dónde se enviarán las alertas.
MetaTrader 5: Utilice el lenguaje de programación MQL5 para desarrollar o modificar el EA o scripts para que puedan conectarse con la API de Telegram. Esto suele implicar el uso de solicitudes HTTP POST para enviar mensajes.

Creación de un bot de Telegram y obtención de identificadores de gráficos

Los bots de Telegram son aplicaciones de software automatizadas que operan dentro de la plataforma de mensajería Telegram, lo que permite la interacción con los usuarios a través de tareas automatizadas. Una de sus funciones principales es agilizar la comunicación proporcionando respuestas rápidas y relevantes a las consultas de los usuarios sin intervención humana. Esta capacidad permite a las empresas y desarrolladores automatizar diversas tareas, como el envío de notificaciones y el procesamiento de comandos, lo que mejora la experiencia y la participación del usuario.

Además, los bots de Telegram se destacan en la recuperación de información; pueden extraer datos de fuentes externas, como datos de mercado o feeds de noticias, y entregárselos directamente a los usuarios. En el contexto del trading, los bots son particularmente valiosos para alertar a los usuarios sobre eventos específicos del mercado, cambios de precios o señales basadas en criterios predefinidos. Su capacidad de integrarse con API y otros servicios les permite además realizar funciones avanzadas como análisis de datos y generación de informes, lo que los convierte en herramientas versátiles para diversas aplicaciones. Sigue los siguientes pasos para crear tu bot de Telegram:

Paso 1: Abra la aplicación Telegram

Asegúrate de tener la aplicación Telegram instalada en tu dispositivo.

Paso 2: Busca al BotFather

Paso 2

Figura 3. BotFather

En la barra de búsqueda de la aplicación, escribe BotFather.

BotFather es un bot oficial de Telegram que te permite crear y administrar otros bots.

Paso 3: Iniciar un chat con BotFather

Paso 3 y 4

Figura 4. Paso 3 y 4

Haga clic en el resultado de BotFather para abrir el chat.

Haga clic en el botón Iniciar o escriba /start para iniciar la conversación.

Paso 4: Crear un nuevo bot

Escriba el comando /newbot y envíelo.

BotFather le pedirá que elija un nombre para su bot. Este es el nombre para mostrar que verán los usuarios.

Después de ingresar el nombre, se le pedirá que proporcione un nombre de usuario para su bot. El nombre de usuario debe terminar en "bot" (por ejemplo, MyCoolBot).

Paso 5: Recibe tu token de bot

Paso 4 y 5

Figura 5. Paso 5

Una vez que haya completado los pasos anteriores, BotFather creará su bot y le proporcionará un token API único. Este token es esencial para interactuar con la API de Telegram Bot, así que guárdelo en un lugar seguro.

Después de crear tu bot de Telegram, el siguiente paso es encontrar tu chat ID. Por otro lado, los ID de gráficos sirven como identificadores únicos asignados a visualizaciones de datos o gráficos específicos dentro de aplicaciones de negociación o herramientas de gráficos. Estos identificadores desempeñan un papel crucial en la identificación y recuperación de gráficos, lo que permite a los usuarios y desarrolladores consultar fácilmente visualizaciones específicas. Los identificadores de gráficos facilitan la extracción de datos actuales o históricos relacionados con gráficos concretos, lo que permite un enfoque personalizado del análisis de datos. Este aspecto es especialmente beneficioso en el trading, ya que permite a los usuarios acceder rápidamente a información relevante, lo que conduce a una toma de decisiones informada.

Además, los identificadores de gráficos permiten la personalización, lo que permite a los desarrolladores modificar parámetros y configuraciones según las preferencias individuales del usuario o las estrategias comerciales. Cuando se integran con los bots de Telegram, los identificadores de gráficos pueden mejorar significativamente la funcionalidad; permiten que los bots proporcionen a los usuarios visualizaciones de datos específicos directamente dentro de su interfaz de chat, agilizando el proceso de obtención de información y toma de decisiones comerciales. A continuación se muestran dos métodos para adquirirlo utilizando bots de Telegram.

Método 1: Uso de bots de obtención de ID

Este es un enfoque sencillo. Puedes buscar y abrir bots como @get_id_bot o @userinfobot. Una vez que inicies el bot haciendo clic en el botón Iniciar o escribiendo /start, responderá con tu ID de chat, que luego podrás anotar.

Obtener bot de identificación

Figura 6. Obtener identificación

Método 2: Usar un navegador web

Comience enviando cualquier mensaje a su bot en Telegram. A continuación, abre un navegador web e introduce la siguiente URL, sustituyendo <Tu_token_de_bot> por tu token de bot real:

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

Después de presionar Enter, examine la respuesta devuelta por la API. Su ID de chat se ubicará en la sección "resultado" de la respuesta.

Implementación de la integración de Telegram con el Asesor Experto (Expert Advisor, EA)

La implementación de la integración de Telegram en el EA implica incorporar las funciones de mensajería de Telegram en nuestro Asesor Experto en MetaTrader. Esta integración permite que el EA envíe notificaciones y alertas instantáneas directamente a una cuenta de Telegram, manteniendo a los usuarios informados sobre las condiciones del mercado, métricas clave y otra información comercial esencial. Al utilizar la API de Telegram, puedo mejorar la funcionalidad del EA, garantizando que los usuarios reciban actualizaciones importantes sin la necesidad de verificar constantemente la plataforma comercial. Esto mejora la capacidad de respuesta a los cambios del mercado, lo que en última instancia hace que la experiencia comercial sea más eficiente.

Se ha mejorado el código del Analytics Master EA incorporando comandos que le permiten transmitir métricas analizadas a la aplicación Telegram. Proporcionaré el código MQL5 completo integrado y lo guiaré paso a paso a través del proceso de integración.

Código de 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 variables de entrada:

Al comienzo de nuestro EA, debemos declarar las variables de entrada necesarias. Las variables de entrada en MQL5 permiten a los operadores personalizar el funcionamiento del EA sin tener que profundizar en el código en sí. Esto hace que sea más fácil adaptar las estrategias comerciales rápidamente. Es esencial nombrar nuestras variables de forma intuitiva. Por ejemplo, TelegramToken indica claramente su propósito. Considere utilizar valores predeterminados para sus variables que se alineen con la práctica común o la configuración en su estrategia comercial para reducir la complejidad de configuración durante las pruebas.

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

Recuerda sustituir «YOUR_BOT_API_TOKEN» y «YOUR_CHAT_ID» por los valores reales.

2. Crear la función de envío de mensajes:

La función SendTelegramMessage construye eficazmente una solicitud HTTP POST estructurada a la API de Telegram, enviando una notificación al chat especificado. Al preparar la URL de la API, configurar los encabezados, formatear los datos del mensaje como JSON, ejecutar la solicitud y manejar la respuesta, esta función permite al EA comunicar actualizaciones instantáneas a los usuarios a través de Telegram. Esta lógica optimizada permite una comunicación rápida de operaciones y alertas y mejora la funcionalidad general del EA como asistente comercial al mantener al usuario informado sin esfuerzo.

Propósito de la función: Esta función gestiona la comunicación con la API de Telegram. Encapsula la lógica necesaria para enviar un mensaje a nuestro bot de Telegram. Al crear funciones reutilizables, garantizamos la claridad del código y reducimos la duplicación.
Gestión de errores: Es fundamental incorporar la gestión de errores. Cada vez que enviamos un mensaje, debemos registrar no sólo los envíos exitosos, sino también cualquier error que surja. Esta práctica ayuda a la depuración y proporciona retroalimentación.

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());
    }
}

Comprender WebRequest: La función WebRequest es crucial, ya que permite a nuestro EA realizar solicitudes HTTP a las API. Asegúrese de que la opción «Permitir trading automatizado» esté habilitada en las propiedades del EA para un funcionamiento adecuado.

3. Activación del mensaje de Telegram

Comprobación de la hora y obtención de datos

La primera parte del código inicia una verificación de tiempo para determinar si han pasado dos horas desde la última actualización de las métricas del mercado. Mediante la función TimeCurrent(), el código recupera la hora actual y la compara con la variable lastUpdateTime. Si han transcurrido más de dos horas, el Asesor Experto (EA) procede a recopilar los datos más recientes relacionados con las condiciones del mercado. Esta comprobación es fundamental para evitar que el EA inunde el chat de Telegram con mensajes demasiado frecuentes, lo que podría ser percibido como spam por el usuario.

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

Creación de la cadena de salida

En la segunda parte, se genera una cadena de salida detallada, denominada infoStr, para consolidar las métricas de mercado recopiladas a partir de las operaciones del EA. El código recupera el símbolo comercial actual con el nombre del par y, además, formatea la hora actual para el mensaje utilizando lastUpdateStr. A continuación, se utiliza la función StringFormat para construir el mensaje, incorporando varios marcadores de posición que se sustituirán por métricas específicas, como el máximo, el mínimo, la apertura y el cierre del día anterior, el volumen del día actual, la dirección del mercado y otros detalles de la cuenta. Esta cadena formateada es fundamental para la operación, ya que presenta un resumen claro y estructurado de las condiciones actuales del mercado, que posteriormente se enviará a través de 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 y visualización de información

La tercera parte se centra en el registro y la visualización de la información construida. La llamada a la función Print (infoStr); sirve para registrar el mensaje en la pestaña Expertos de la plataforma MetaTrader, lo que permite ver la información que se envía a través de Telegram. Esto proporciona una herramienta de depuración útil para confirmar que las métricas se están formulando correctamente. Además, el comando Comment(infoStr); muestra la misma información directamente en el gráfico de operaciones, lo que ofrece a los operadores una confirmación visual de las métricas sin necesidad de consultar los registros. Estos pasos mantienen al usuario informado sobre las métricas reportadas y verifican la exactitud de los datos antes de enviarlos a 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

Envío de la notificación por Telegram

En la parte final, el código gestiona el envío real de la notificación de Telegram. La instrucción (SendTelegramAlerts) comprueba si la opción de enviar alertas está habilitada, lo que permite a los usuarios desactivar fácilmente las notificaciones sin necesidad de modificar el código. Si las alertas están habilitadas, se invoca la función SendTelegramMessage(infoStr), que envía el mensaje cuidadosamente elaborado al chat de Telegram especificado. Este paso es fundamental, ya que es el punto en el que las métricas del mercado se comunican de manera eficaz al usuario. A continuación, el código actualiza la variable lastUpdateTime con la hora actual utilizando lastUpdateTime = TimeCurrent();, lo que marca la conclusión de este ciclo de actualización y garantiza que la próxima actualización se realice en el intervalo de dos horas establecido anteriormente.

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

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

Nombre del par actual

También he agregado una función que muestra el nombre del par actual junto con las métricas analizadas, lo que facilita la identificación de qué par se está analizando.

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

A continuación se muestra cómo aparecerá la información en Telegram:

Figura 7. Resultado del par

Pruebas

Antes de realizar la prueba, es necesario realizar algunos ajustes en su MetaTrader 5 para garantizar que la información se transmita a Telegram sin problemas.

Permitir solicitudes web:

Abra MetaTrader 5 y vaya a Herramientas > Opciones > Asesores expertos.

Figura 8. Configuración de solicitudes web

Marque la casilla «Permitir WebRequest para las URL enumeradas» y añada https://api.telegram.org a la lista. Esta configuración permite al EA enviar solicitudes a la API de Telegram.

Configuración de la solicitud web

Figura 9. Configuración de la solicitud web

Para fines de prueba, también puede ajustar el tiempo de actualización a una frecuencia más baja. En este caso lo reduciré de 2 horas a 15 segundos.

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

Ahora, proceda a compilar su código MQL5 en MetaEditor y adjunte el Asesor Experto o el script a un gráfico en MetaTrader 5. Después de una compilación satisfactoria, arrastre su Asesor Experto al gráfico. A partir de ahí, deberías empezar a recibir notificaciones en tu Telegram sobre las actualizaciones enviadas desde el EA. A continuación, he ilustrado los resultados de la prueba de mi Telegram.

Resultado de Telegram

Figura 10. Resultado de Telegram

El diagrama a continuación también muestra que la información proporcionada en el gráfico de MetaTrader 5 es la misma que la información relacionada con Telegram.

Resultado

Figura 11. Resultados de la prueba

Conclusión

En conclusión, el éxito de Analytics Forecaster EA, como lo evidencian los diagramas presentados anteriormente, radica en su enfoque sofisticado del análisis de mercado y notificaciones oportunas a través de la integración de Telegram. Al utilizar diversas métricas comerciales, como datos del día anterior, comparaciones de volumen actual, dirección del mercado y principios de gestión de riesgos, el EA proporciona a los operadores información valiosa. Los niveles de soporte y resistencia calculados combinados con la determinación automatizada del tamaño de lote permiten tomar decisiones comerciales más informadas, garantizando que tanto los operadores novatos como los experimentados puedan adaptar estrategias de acuerdo con las condiciones del mercado mientras gestionan su riesgo de manera eficaz.

Además, la integración perfecta con Telegram mejora la interacción del usuario al ofrecer actualizaciones rápidas, lo que permite a los operadores actuar rápidamente en respuesta a los cambios del mercado. La capacidad de recibir información comercial crítica en una plataforma móvil mejora significativamente la conveniencia de monitorear las operaciones, al mismo tiempo que fomenta un entorno comercial más receptivo. En general, Analytics Forecaster EA demuestra capacidades notables en la automatización del análisis y la gestión de riesgos, lo que permite a los operadores optimizar su rendimiento en un mercado dinámico. Con su enfoque en la precisión de los datos y funciones fáciles de usar, este EA se destaca como una herramienta poderosa en el arsenal del comerciante, allanando el camino para futuros avances en soluciones de comercio automatizado.

Fecha	Nombre de la herramienta	Descripción	Versión	Actualizaciones	Notas
01/10/24	Chart Projector	Script para superponer la acción del precio del día anterior con efecto fantasma.	1.0	Lanzamiento inicial	Primera herramienta en Lynnchris Tool Chest
18/11/24	Analytical Comment	Proporciona información del día anterior en formato tabular y anticipa la dirección futura del mercado.	1.0	Lanzamiento inicial	Segunda herramienta en Lynnchris Tool Chest
27/11/24	Analytics Master	Actualización periódica de los indicadores del mercado cada dos horas	1.01	Segundo lanzamiento	Tercera herramienta en Lynnchris Tool Chest
02/12/24	Analytics Forecaster	Actualización periódica de las métricas del mercado cada dos horas con integración de Telegram	1.1	Tercera edición	Herramienta número 5

Traducción del inglés realizada por MetaQuotes Ltd.
Artículo original: https://www.mql5.com/en/articles/16559

Archivos adjuntos |

Descargar ZIP

Analytics_Forecaster_EA.mq5 (10.54 KB)

Advertencia: todos los derechos de estos materiales pertenecen a MetaQuotes Ltd. Queda totalmente prohibido el copiado total o parcial.

Este artículo ha sido escrito por un usuario del sitio web y refleja su punto de vista personal. MetaQuotes Ltd. no se responsabiliza de la exactitud de la información ofrecida, ni de las posibles consecuencias del uso de las soluciones, estrategias o recomendaciones descritas.

Otros artículos del autor

Pasar a la discusión en el foro de los operadores

Algoritmo de trading evolutivo con aprendizaje por refuerzo y extinción de individuos no rentables (ETARE)

Hoy le presentamos un innovador algoritmo comercial que combina algoritmos evolutivos con aprendizaje profundo por refuerzo para la negociación de divisas. El algoritmo utiliza un mecanismo de extinción de individuos ineficaces para optimizar la estrategia comercial.

Análisis de la negociación a posteriori: ajustando el TrailingStop y los nuevos stops en el simulador de estrategias

Continuamos con el tema del análisis de las transacciones completadas en el simulador de estrategias para mejorar la calidad de la negociación. Hoy veremos cómo el uso de diferentes trailings puede ayudar a cambiar los resultados comerciales ya obtenidos.

Algoritmo de viaje evolutivo en el tiempo — Time Evolution Travel Algorithm (TETA)

Se trata de un algoritmo propio. En este artículo, le presentaremos el Algoritmo de viaje evolutivo en el tiempo (TETA), inspirado en el concepto de universos paralelos y flujos temporales. La idea básica del algoritmo es que, si bien no es posible viajar en el tiempo en el sentido habitual, podemos elegir una secuencia de acontecimientos que generen realidades distintas.

Perspectivas bursátiles a través del volumen: Confirmación de tendencias

La técnica mejorada de confirmación de tendencias combina la acción del precio, el análisis del volumen y el aprendizaje automático para identificar movimientos genuinos del mercado. Requiere tanto rupturas de precios como aumentos de volumen (un 50% por encima de la media) para la validación de las operaciones, al tiempo que utiliza una red neuronal LSTM para obtener una confirmación adicional. El sistema emplea el dimensionamiento de posiciones basado en ATR y la gestión dinámica del riesgo, lo que lo hace adaptable a diversas condiciones del mercado y permite filtrar las señales falsas.