Creación de un modelo de restricción de tendencia de velas (Parte 5): Sistema de notificaciones (Parte I)

Contenido

• Introducción
• Notificaciones del terminal
• Notificaciones push
• Notificaciones por correo electrónico
• Depuración de Trend Constraint V1.04
• Integrando los canales de las redes sociales (por ejemplo, Telegram y WhatsApp).
• Integración de Telegram
• Integración de WhatsApp
• El poder de la red privada virtual (VPS, Virtual Private Server) en nuestro sistema de notificaciones
• Conclusión

Introducción

MetaTrader 5 ofrece varias opciones de notificación para informar a los usuarios sobre eventos comerciales, como terminal, correo electrónico y notificaciones push. Integrarlo con plataformas sociales como Telegram y WhatsApp para compartir señales puede ser muy beneficioso. La configuración de notificaciones en MetaTrader 5 le permite mantenerse informado sobre sus actividades comerciales independientemente de su ubicación. Al utilizar los métodos de acceso a notificaciones mencionados anteriormente, puede seleccionar la opción que mejor se adapte a sus necesidades. Esta guía lo guiará a través de la configuración y personalización de las notificaciones de MetaTrader 5, incluida la integración con Telegram y otras plataformas de redes sociales. Se centrará en los detalles de configuración y los pasos iniciales para la integración, allanando el camino para una exploración más profunda en la Parte II de esta serie.

Notificaciones del terminal

Las notificaciones de terminal son alertas internas en la plataforma MetaTrader 5. Cubren todos los eventos de alerta activados dentro de MetaTrader 5. Puede configurar manualmente alertas en MetaTrader 5 para que se activen cuando se cumplan condiciones específicas. Las configuraciones de alerta normalmente se encuentran en la pestaña de herramientas en la parte inferior de la ventana predeterminada de MetaTrader 5.

• Símbolo: Seleccione el instrumento comercial para el cual desea configurar la alerta.
• Condición: Elija la condición que activará la alerta (por ejemplo, Bid >, Ask <, Time =, etc.).
• Valor: Especifique el valor con el que se comparará la condición (por ejemplo, un nivel de precio específico).
• Fuente: Seleccione el tipo de alerta (por ejemplo, sonido, archivo, correo electrónico, etc.). Para las notificaciones del terminal, puedes elegir "sonido".
• Acción: Seleccione la acción que se realizará cuando se active la alerta (por ejemplo, reproducir un sonido, enviar una notificación, etc.).
• Sonido: Elija un archivo de sonido que se reproducirá cuando se active la alerta.
• Tiempo de espera: Establezca el intervalo de tiempo después del cual se verificará nuevamente la alerta.
• Iteraciones máximas: Especifique el número de veces que se debe activar la alerta.

A continuación se muestra un ejemplo de cómo configurar una alerta utilizando el índice sintético Step Index. Los valores que se muestran en la tabla se pueden ajustar según sus necesidades. Después de configurar los ajustes, haga clic en Aceptar para crear la alerta y estará lista para su activación. Vea la imagen de demostración animada debajo de la tabla para obtener un resumen rápido. Para comenzar, haga clic derecho en la pestaña de alerta en la ventana de herramientas, seleccione crear en el menú que aparece y se abrirá un cuadro de diálogo con las configuraciones descritas en la tabla.

Configuración	Valor
Símbolo	Step Index
Condición	Bid>
Valor	9666
Fuente	Sonido
Acción	Selecciona un archivo de sonido (alert2.wav)
Tiempo de espera	Establecer en 60 segundos
Iteraciones máximas	Establecer en 5

 

Notificaciones push

Es una característica de MetaTrader 5 que permite que las notificaciones generadas en la plataforma, ya sea internamente o por un indicador o asesor experto, se envíen a una plataforma MetaTrader 5 de teléfono móvil a través de la ID MetaQuotes del dispositivo móvil. Para que el dispositivo móvil reciba notificaciones push, MetaTrader 5 debe estar instalado desde Google Play para Android o Apple Store para IOS. En la versión de escritorio de MetaTrader 5, las notificaciones push deben estar habilitadas para recibir la alerta en el teléfono móvil. Se creara una ID MetaQuotes única en el teléfono móvil poco después de la instalación de MetaTrader 5 móvil. 

A la izquierda, puede encontrar una imagen que ilustra cómo encontrar el ID de MetaQuotes. A la derecha, hay una imagen que demuestra cómo activar las notificaciones push en la plataforma de escritorio MetaTrader 5, junto con el campo para ingresar la ID de MetaQuotes. Al marcar la casilla e ingresar la ID de su plataforma móvil, podrá comenzar a recibir instantáneamente notificaciones en la sección de mensajes de su plataforma móvil MetaTrader 5. Puede agregar muchos ID de MetaQuotes desde varios dispositivos móviles separándolos.

       

Notificaciones por correo electrónico

El correo electrónico sigue siendo una herramienta de comunicación poderosa y versátil debido a su conveniencia, eficiencia y amplia gama de funcionalidades. Ya sea para uso personal, correspondencia comercial o contactos profesionales, el correo electrónico proporciona un medio fiable y eficaz de mantenerse conectado e intercambiar información. La configuración de notificaciones por correo electrónico en MetaTrader 5 le permite recibir alertas por correo electrónico para diversas actividades comerciales, como movimientos de precios, ejecuciones de órdenes y eventos personalizados.

La ventaja de los correos electrónicos es su entrega casi instantánea, lo que permite un rápido intercambio de información y una difusión eficiente a grandes grupos. Los servicios de correo electrónico a menudo proporcionan cifrado para proteger el contenido y la información confidencial. La entrega directa a las bandejas de entrada de los destinatarios minimiza los riesgos de interceptación en comparación con otras formas de comunicación.

Aquí tienes una guía paso a paso para configurar notificaciones por correo electrónico:

• Inicie la plataforma MetaTrader 5 en su computadora.
• Vaya a Herramientas > Opciones > Correo electrónico.
• Marque la casilla Habilitar.
• Complete los detalles del servidor SMTP:

Configuración	Complete los detalles
Servidor SMTP	La dirección del servidor SMTP de su proveedor de correo electrónico (por ejemplo, smtp.gmail.com para Gmail).
Inicio de sesión SMTP	Su dirección de correo electrónico (por ejemplo, su-correo-electró[e-mail]).
Contraseña SMTP	Su contraseña de correo electrónico o contraseña específica de la aplicación si usa Gmail.
De	Su dirección de correo electrónico (por ejemplo, su-correo-electró[e-mail]).
A	La dirección de correo electrónico donde desea recibir notificaciones (puede ser la misma que la dirección 'De' o diferente).

¿Qué es el servidor SMTP?

Según mi investigación, un servidor Simple Mail Transfer Protocol (SMTP) es un servidor de correo que utiliza el protocolo (SMTP) para enviar, recibir y retransmitir correos electrónicos salientes. Funciona junto con Mail Transfer Agent (MTA) para dirigir los correos electrónicos desde el cliente de correo electrónico del remitente al servidor de correo electrónico del destinatario. Aquí hay una lista de proveedores de correo con servidores SMTP:

• Gmail
• Yahoo
• Hotmail
• Zoho
• iCloud

Depuración de Trend Constraint V1.04

Hemos integrado con éxito el estilo Draw_Line en las tendencias de nuestro sistema. Sin embargo, descubrí que se activaban numerosas alertas después de cada barra debido a esta nueva función. Por ejemplo, cuando un gráfico estaba configurado para un marco de tiempo de un minuto, se generaban alertas en cada cierre de vela de un minuto, lo cual es bastante abrumador.

Nuestro objetivo es obtener señales óptimas, centrándonos sólo en unas pocas seleccionadas. Para atajar este problema, he contemplado la posibilidad de resolver el asunto eliminando myalert() de los buffers quinto y sexto. Es esencial que se rectifique este código para la perfecta integración de Telegram y WhatsApp, tal y como se comenta en este artículo. A continuación figura la versión revisada de nuestro código:

Modificación del Buffer 5:

// --- Buffer5 (Buy Trend)
      if(MA5[i] > MA6[i])
        {
         Buffer5[i] = Low[i] - 15 * myPoint;
         // Disabled myAlert from Buffer 5
         // myAlert("indicator", "BUY TREND | MA Fast: " + DoubleToString(MA5[i], 2) + " | MA Slow: " + DoubleToString(MA6[i], 2));
        }

Modificación del Buffer 6:

// --- Buffer6 (Sell Trend)
      if(MA5[i] < MA6[i])
        {
         Buffer6[i] = High[i] + 15 * myPoint;
         // Disabled myAlert from Buffer 6
         // myAlert("indicator", "SELL TREND | MA Fast: " + DoubleToString(MA5[i], 2) + " | MA Slow: " + DoubleToString(MA6[i], 2));
        }

Modificación de Trend Constraint V1.04:

///Indicator Name: Trend Constraint
#property copyright "Clemence Benjamin"
#property link      "https://mql5.com"
#property version   "1.04"
#property description "A model that seek to produce sell signal when D1 candle is Bearish only and  buy signal when it is Bullish"
//--- indicator settings
#property indicator_chart_window
#property indicator_buffers 6
#property indicator_plots 6

#property indicator_type1 DRAW_ARROW
#property indicator_width1 5
#property indicator_color1 0xFF3C00
#property indicator_label1 "Buy"

#property indicator_type2 DRAW_ARROW
#property indicator_width2 5
#property indicator_color2 0x0000FF
#property indicator_label2 "Sell"

#property indicator_type3 DRAW_ARROW
#property indicator_width3 2
#property indicator_color3 0xE8351A
#property indicator_label3 "Buy Reversal"

#property indicator_type4 DRAW_ARROW
#property indicator_width4 2
#property indicator_color4 0x1A1AE8
#property indicator_label4 "Sell Reversal"

#property indicator_type5 DRAW_LINE
#property indicator_style5 STYLE_SOLID
#property indicator_width5 2
#property indicator_color5 0xFFAA00
#property indicator_label5 "Buy Trend"

#property indicator_type6 DRAW_LINE
#property indicator_style6 STYLE_SOLID
#property indicator_width6 2
#property indicator_color6 0x0000FF
#property indicator_label6 "Sell Trend"

#define PLOT_MAXIMUM_BARS_BACK 5000
#define OMIT_OLDEST_BARS 50

//--- indicator buffers
double Buffer1[];
double Buffer2[];
double Buffer3[];
double Buffer4[];
double Buffer5[];
double Buffer6[];

input double Oversold = 30;
input double Overbought = 70;
input int Slow_MA_period = 200;
input int Fast_MA_period = 100;
datetime time_alert; //used when sending alert
input bool Audible_Alerts = true;
input bool Push_Notifications = true;
double myPoint; //initialized in OnInit
int RSI_handle;
double RSI[];
double Open[];
double Close[];
int MA_handle;
double MA[];
int MA_handle2;
double MA2[];
int MA_handle3;
double MA3[];
int MA_handle4;
double MA4[];
double Low[];
double High[];
int MA_handle5;
double MA5[];
int MA_handle6;
double MA6[];

void myAlert(string type, string message)
  {
   if(type == "print")
      Print(message);
   else if(type == "error")
     {
      Print(type+" | Trend Constraint V1.04 @ "+Symbol()+","+IntegerToString(Period())+" | "+message);
     }
   else if(type == "order")
     {
     }
   else if(type == "modify")
     {
     }
   else if(type == "indicator")
     {
      if(Audible_Alerts) Alert(type+" | Trend Constraint V1.04 @ "+Symbol()+","+IntegerToString(Period())+" | "+message);
      if(Push_Notifications) SendNotification(type+" | Trend Constraint V1.04 @ "+Symbol()+","+IntegerToString(Period())+" | "+message);
     }
  }

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {   
   SetIndexBuffer(0, Buffer1);
   PlotIndexSetDouble(0, PLOT_EMPTY_VALUE, EMPTY_VALUE);
   PlotIndexSetInteger(0, PLOT_DRAW_BEGIN, MathMax(Bars(Symbol(), PERIOD_CURRENT)-PLOT_MAXIMUM_BARS_BACK+1, OMIT_OLDEST_BARS+1));
   PlotIndexSetInteger(0, PLOT_ARROW, 241);
   SetIndexBuffer(1, Buffer2);
   PlotIndexSetDouble(1, PLOT_EMPTY_VALUE, EMPTY_VALUE);
   PlotIndexSetInteger(1, PLOT_DRAW_BEGIN, MathMax(Bars(Symbol(), PERIOD_CURRENT)-PLOT_MAXIMUM_BARS_BACK+1, OMIT_OLDEST_BARS+1));
   PlotIndexSetInteger(1, PLOT_ARROW, 242);
   SetIndexBuffer(2, Buffer3);
   PlotIndexSetDouble(2, PLOT_EMPTY_VALUE, EMPTY_VALUE);
   PlotIndexSetInteger(2, PLOT_DRAW_BEGIN, MathMax(Bars(Symbol(), PERIOD_CURRENT)-PLOT_MAXIMUM_BARS_BACK+1, OMIT_OLDEST_BARS+1));
   PlotIndexSetInteger(2, PLOT_ARROW, 236);
   SetIndexBuffer(3, Buffer4);
   PlotIndexSetDouble(3, PLOT_EMPTY_VALUE, EMPTY_VALUE);
   PlotIndexSetInteger(3, PLOT_DRAW_BEGIN, MathMax(Bars(Symbol(), PERIOD_CURRENT)-PLOT_MAXIMUM_BARS_BACK+1, OMIT_OLDEST_BARS+1));
   PlotIndexSetInteger(3, PLOT_ARROW, 238);
   SetIndexBuffer(4, Buffer5);
   PlotIndexSetDouble(4, PLOT_EMPTY_VALUE, EMPTY_VALUE);
   PlotIndexSetInteger(4, PLOT_DRAW_BEGIN, MathMax(Bars(Symbol(), PERIOD_CURRENT)-PLOT_MAXIMUM_BARS_BACK+1, OMIT_OLDEST_BARS+1));
   SetIndexBuffer(5, Buffer6);
   PlotIndexSetDouble(5, PLOT_EMPTY_VALUE, EMPTY_VALUE);
   PlotIndexSetInteger(5, PLOT_DRAW_BEGIN, MathMax(Bars(Symbol(), PERIOD_CURRENT)-PLOT_MAXIMUM_BARS_BACK+1, OMIT_OLDEST_BARS+1));
   //initialize myPoint
   myPoint = Point();
   if(Digits() == 5 || Digits() == 3)
     {
      myPoint *= 10;
     }
   RSI_handle = iRSI(NULL, PERIOD_CURRENT, 14, PRICE_CLOSE);
   if(RSI_handle < 0)
     {
      Print("The creation of iRSI has failed: RSI_handle=", INVALID_HANDLE);
      Print("Runtime error = ", GetLastError());
      return(INIT_FAILED);
     }
   
   MA_handle = iMA(NULL, PERIOD_CURRENT, 7, 0, MODE_SMMA, PRICE_CLOSE);
   if(MA_handle < 0)
     {
      Print("The creation of iMA has failed: MA_handle=", INVALID_HANDLE);
      Print("Runtime error = ", GetLastError());
      return(INIT_FAILED);
     }
   
   MA_handle2 = iMA(NULL, PERIOD_CURRENT, 400, 0, MODE_SMA, PRICE_CLOSE);
   if(MA_handle2 < 0)
     {
      Print("The creation of iMA has failed: MA_handle2=", INVALID_HANDLE);
      Print("Runtime error = ", GetLastError());
      return(INIT_FAILED);
     }
   
   MA_handle3 = iMA(NULL, PERIOD_CURRENT, 100, 0, MODE_EMA, PRICE_CLOSE);
   if(MA_handle3 < 0)
     {
      Print("The creation of iMA has failed: MA_handle3=", INVALID_HANDLE);
      Print("Runtime error = ", GetLastError());
      return(INIT_FAILED);
     }
   
   MA_handle4 = iMA(NULL, PERIOD_CURRENT, 200, 0, MODE_SMA, PRICE_CLOSE);
   if(MA_handle4 < 0)
     {
      Print("The creation of iMA has failed: MA_handle4=", INVALID_HANDLE);
      Print("Runtime error = ", GetLastError());
      return(INIT_FAILED);
     }
   
   MA_handle5 = iMA(NULL, PERIOD_CURRENT, Fast_MA_period, 0, MODE_SMA, PRICE_CLOSE);
   if(MA_handle5 < 0)
     {
      Print("The creation of iMA has failed: MA_handle5=", INVALID_HANDLE);
      Print("Runtime error = ", GetLastError());
      return(INIT_FAILED);
     }
   
   MA_handle6 = iMA(NULL, PERIOD_CURRENT, Slow_MA_period, 0, MODE_SMA, PRICE_CLOSE);
   if(MA_handle6 < 0)
     {
      Print("The creation of iMA has failed: MA_handle6=", INVALID_HANDLE);
      Print("Runtime error = ", GetLastError());
      return(INIT_FAILED);
     }
   
   return(INIT_SUCCEEDED);
  }

//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime& time[],
                const double& open[],
                const double& high[],
                const double& low[],
                const double& close[],
                const long& tick_volume[],
                const long& volume[],
                const int& spread[])
  {
   int limit = rates_total - prev_calculated;
   //--- counting from 0 to rates_total
   ArraySetAsSeries(Buffer1, true);
   ArraySetAsSeries(Buffer2, true);
   ArraySetAsSeries(Buffer3, true);
   ArraySetAsSeries(Buffer4, true);
   ArraySetAsSeries(Buffer5, true);
   ArraySetAsSeries(Buffer6, true);
   //--- initial zero
   if(prev_calculated < 1)
     {
      ArrayInitialize(Buffer1, EMPTY_VALUE);
      ArrayInitialize(Buffer2, EMPTY_VALUE);
      ArrayInitialize(Buffer3, EMPTY_VALUE);
      ArrayInitialize(Buffer4, EMPTY_VALUE);
      ArrayInitialize(Buffer5, EMPTY_VALUE);
      ArrayInitialize(Buffer6, EMPTY_VALUE);
     }
   else
      limit++;
   datetime Time[];
   
   int RSIBuffer;
   int MABuffer;
   int RSIPeriod = 14;
   ArrayResize(RSI, rates_total);
   ArrayResize(Open, rates_total);
   ArrayResize(Close, rates_total);
   CopyOpen(NULL, 0, 0, rates_total, Open);
   CopyClose(NULL, 0, 0, rates_total, Close);
   if(CopyBuffer(RSI_handle, 0, 0, rates_total, RSI) < 0)
     {
      Print("Getting RSI values failed, not enough bars!");
     }
   ArrayResize(MA, rates_total);
   if(CopyBuffer(MA_handle, 0, 0, rates_total, MA) < 0)
     {
      Print("Getting MA values failed, not enough bars!");
     }
   ArrayResize(MA2, rates_total);
   if(CopyBuffer(MA_handle2, 0, 0, rates_total, MA2) < 0)
     {
      Print("Getting MA values failed, not enough bars!");
     }
   ArrayResize(MA3, rates_total);
   if(CopyBuffer(MA_handle3, 0, 0, rates_total, MA3) < 0)
     {
      Print("Getting MA values failed, not enough bars!");
     }
   ArrayResize(MA4, rates_total);
   if(CopyBuffer(MA_handle4, 0, 0, rates_total, MA4) < 0)
     {
      Print("Getting MA values failed, not enough bars!");
     }
   ArrayResize(Low, rates_total);
   if(CopyLow(NULL, 0, 0, rates_total, Low) < 0)
     {
      Print("Getting LOW values failed, not enough bars!");
     }
   ArrayResize(High, rates_total);
   if(CopyHigh(NULL, 0, 0, rates_total, High) < 0)
     {
      Print("Getting HIGH values failed, not enough bars!");
     }
   ArrayResize(MA5, rates_total);
   if(CopyBuffer(MA_handle5, 0, 0, rates_total, MA5) < 0)
     {
      Print("Getting MA values failed, not enough bars!");
     }
   ArrayResize(MA6, rates_total);
   if(CopyBuffer(MA_handle6, 0, 0, rates_total, MA6) < 0)
     {
      Print("Getting MA values failed, not enough bars!");
     }
   
   for(int i=limit-1; i>=0; i--)
     {
      if(i < rates_total-1 && time[i] != time[i+1]+PeriodSeconds())
        {
         continue;
        }
      Buffer1[i] = EMPTY_VALUE;
      Buffer2[i] = EMPTY_VALUE;
      Buffer3[i] = EMPTY_VALUE;
      Buffer4[i] = EMPTY_VALUE;
      Buffer5[i] = EMPTY_VALUE;
      Buffer6[i] = EMPTY_VALUE;

      // --- Indicator calculations
      // --- Buffer1 (Buy)
      if((Close[i] > MA[i] && MA[i] > MA2[i] && RSI[i] < Oversold) || (RSI[i] < Oversold && Close[i] > MA3[i]))
        {
         Buffer1[i] = Low[i] - 5 * myPoint;
         myAlert("indicator", "BUY OPPORTUNITY | RSI: " + DoubleToString(RSI[i], 2) + " | MA: " + DoubleToString(MA[i], 2));
        }
      
      // --- Buffer2 (Sell)
      if((Close[i] < MA[i] && MA[i] < MA2[i] && RSI[i] > Overbought) || (RSI[i] > Overbought && Close[i] < MA3[i]))
        {
         Buffer2[i] = High[i] + 5 * myPoint;
         myAlert("indicator", "SELL OPPORTUNITY | RSI: " + DoubleToString(RSI[i], 2) + " | MA: " + DoubleToString(MA[i], 2));
        }
      
      // --- Buffer3 (Buy Reversal)
      if(RSI[i] < Oversold && Close[i] > MA[i])
        {
         Buffer3[i] = Low[i] - 10 * myPoint;
         myAlert("indicator", "BUY REVERSAL | RSI: " + DoubleToString(RSI[i], 2) + " | MA: " + DoubleToString(MA[i], 2));
        }
      
      // --- Buffer4 (Sell Reversal)
      if(RSI[i] > Overbought && Close[i] < MA[i])
        {
         Buffer4[i] = High[i] + 10 * myPoint;
         myAlert("indicator", "SELL REVERSAL | RSI: " + DoubleToString(RSI[i], 2) + " | MA: " + DoubleToString(MA[i], 2));
        }
      
      // --- Buffer5 (Buy Trend)
      if(MA5[i] > MA6[i])
        {
         Buffer5[i] = Low[i] - 15 * myPoint;
         //Disabled myAlert from Buffer 5
         // myAlert("indicator", "BUY TREND | MA Fast: " + DoubleToString(MA5[i], 2) + " | MA Slow: " + DoubleToString(MA6[i], 2));
        }
      
      // --- Buffer6 (Sell Trend)
      if(MA5[i] < MA6[i])
        {
         Buffer6[i] = High[i] + 15 * myPoint;
         // Disabled myAlert from Buffer 6
         // myAlert("indicator", "SELL TREND | MA Fast: " + DoubleToString(MA5[i], 2) + " | MA Slow: " + DoubleToString(MA6[i], 2));
        }
     }
   return(rates_total);
  }

Integración de las redes sociales (por ejemplo, Telegram y WhatsApp)

Esta sección del artículo mostrará la integración de Telegram y WhatsApp en MetaTrader 5 específicamente para nuestro indicador Trend Constraint. Este proceso aumenta significativamente las capacidades de MetaTrader 5 al ofrecer notificaciones en tiempo real, seguras y cómodas. Estas integraciones mejoran la eficiencia, la capacidad de respuesta y la eficacia de las actividades de negociación, sirviendo como valiosas herramientas para los operadores de hoy en día. Con una amplia base de usuarios en estas plataformas, compartir señales con estas comunidades puede ser beneficioso. Profundicemos en cómo podemos transmitir las señales generadas por nuestro indicador a las plataformas de las redes sociales. Lo he investigado y probado para confirmar su funcionalidad.

Requisitos: 

• Última versión de la plataforma MetaTrader 5 de escritorio.
• Cuentas verificadas en WhatsApp y/o Telegram (disponibles para descargar en Google Play para Android y en la App Store para iOS).
• Navegador web, por ejemplo Google Chrome.
• Un servidor para alojar scripts de middleware.

Integración de Telegram

Paso 1: Crear un bot de Telegram

Crea el Bot:

• Abre Telegram y busca el bot «BotFather».
• Inicia un chat con BotFather y utiliza el comando /newbot para crear un nuevo bot.
• Sigue las instrucciones para establecer un nombre y un nombre de usuario para tu bot.
• BotFather proporcionará un token, que utilizarás para interactuar con la API de Telegram.

Obtener la ID de chat:

• Añade tu bot a un grupo de Telegram o inicia un chat con él.
• Utiliza la siguiente URL en tu navegador para obtener actualizaciones y encontrar tu ID de chat: https://api.telegram.org/bot<SuToken>/getUpdates
• Envía un mensaje en el chat y vuelve a comprobar la URL para encontrar la ID del chat.

Para una guía más completa sobre cómo obtener la ID del chat, visita Github.

Paso 2: Crear un script de middleware

Necesita un script para enviar mensajes a través de la API de Telegram.

Para crear un script de middleware vamos a utilizar el lenguaje Python según la investigación que realicé. Este script de Python utiliza la biblioteca de solicitudes para enviar un mensaje a un chat de Telegram a través de un bot. Aquí hay una explicación de cada línea del script:

Solicitudes de importación

Importa la biblioteca de solicitudes utilizada para realizar solicitudes HTTP en Python. En este script, se utilizará para enviar una solicitud POST a la API del bot de Telegram.

def send_telegram_message(chat_id, message, bot_token):

Define una función llamada send_telegram_message: Esta función toma tres parámetros:

1. chat_id: El identificador único para el chat de destino o nombre de usuario del canal de destino.
2. message: El mensaje de texto que se enviará.
3. bot_token: El token para el bot de Telegram, que es proporcionado por @BotFather al crear el bot.

    url = f"https://api.telegram.org/bot{bot_token}/sendMessage"

Esta línea construye la URL para el método sendMessage de la API del bot de Telegram usando el bot_token proporcionado.

    payload = {
        'chat_id': chat_id,
        'text': message
    }

Crea la información para la petición POST. Este diccionario contiene los parámetros requeridos por el método sendMessage:

• chat_id: ID del chat al que se enviará el mensaje.
• text: El contenido del mensaje.

    response = requests.post(url, data=payload)

Esta línea envía la solicitud HTTP POST a la URL construida con los datos de carga útil utilizando el método requests.post. La respuesta de la API se almacena en la variable "response".

    return response.json()

Esta línea convierte la respuesta a formato JSON y la devuelve. Esta respuesta JSON suele contener información sobre el mensaje enviado, incluido el ID del mensaje, el remitente, los detalles del chat, etc.

Combinando todas las piezas de código esto es lo que obtenemos:

import requests

def send_telegram_message(chat_id, message, bot_token):
    url = f"https://api.telegram.org/bot{bot_token}/sendMessage"
    payload = {
        'chat_id': chat_id,
        'text': message
    }
    response = requests.post(url, data=payload)
    return response.json()

Paso 3: Configurar MetaTrader 5 para utilizar el middleware.

Cree un script MQL5 para enviar alertas a través de peticiones HTTP a su script middleware.

Veamos el desglose del código para comprender cada línea:

void SendTelegramMessage(string chat_id, string message, string bot_token)

 Define una función llamada SendTelegramMessage.

Parámetros dentro de la función:

• chat_id: Una cadena que representa la ID del chat de Telegram donde se enviará el mensaje.
• message: Cadena que contiene el mensaje a enviar.
• bot_token: Una cadena que representa el bot token requerido para la autorización con la API de Telegram.

Llave de apertura del cuerpo de la función:

{
    string url = "http://your-server-url/send_telegram_message";

 Asigna la URL del punto final del servidor a la variable "url". Esta URL es la dirección del servidor que se encarga de reenviar el mensaje a Telegram.

    char postData[];
    StringToCharArray("chat_id=" + chat_id + "&message=" + message + "&bot_token=" + bot_token, postData);

Array "postData":

• Declaración: Declara un array postData de tipo char para contener los datos de la petición POST.
• Conversión de cadena a matriz de caracteres: Convierte una cadena concatenada de los parámetros chat_id, message y bot_token en una matriz de caracteres y la almacena en postData. La cadena concatenada forma el cuerpo de la petición POST en el formato requerido por el servidor.

    char result[];

Declara un array result de tipo char para contener la respuesta de la petición web.

    int res = WebRequest("POST", url, "", NULL, 0, postData, 0, result, NULL);

Web Request:

• Método HTTP: "POST" indica el tipo de petición.
• URL: "url" es el punto final para enviar la petición.
• Cabeceras: Una cadena vacía "" significa que no hay cabeceras adicionales.
• Cookies: NULL indica que no hay cookies.
• Tiempo de espera: 0 especifica que no hay tiempo de espera.
• postData: Son los datos que se enviarán en la petición POST.
• result: Es donde se almacenará la respuesta.
• La función devuelve un entero llamado "res" que es el código de estado HTTP de la respuesta.

    if (res != 200)

Verificar el código de respuesta: Compara el código de respuesta "res" con 200 (HTTP OK) para asegurar que la solicitud fue exitosa. Si no es 200, indica un error.

Controlador de errores:

    {
        Print("Error sending message: ", GetLastError());
    }

Imprimir mensaje de error: Si el código de respuesta no es 200, este bloque imprime un mensaje de error junto con el último código de error utilizando GetLastError().

Controlador de éxito:

    else
    {
        Print("Message sent successfully.");
    }

Imprimir mensaje de éxito: Si el código de respuesta es 200, este bloque imprime un mensaje de éxito indicando que el mensaje se ha enviado correctamente.

Esta línea termina la función SendTelegramMessage con llave de cierre.

 Código MQL5 para enviar mensajes de Telegram:

void SendTelegramMessage(string chat_id, string message, string bot_token)
{
    string url = "http://your-server-url/send_telegram_message";
    char postData[];
    StringToCharArray("chat_id=" + chat_id + "&message=" + message + "&bot_token=" + bot_token, postData);
    
    char result[];
    int res = WebRequest("POST", url, "", NULL, 0, postData, 0, result, NULL);
    if (res != 200)
    {
        Print("Error sending message: ", GetLastError());
    }
    else
    {
        Print("Message sent successfully.");
    }
}

El script MQL5 anterior está diseñado para enviar un mensaje a un chat de Telegram realizando una solicitud web a un punto final del servidor. El ejemplo de uso muestra cómo utilizar la función SendTelegramMessage dentro del evento OnStart, que se ejecuta cuando se inicia el script. Nos fijamos en la integración de WhatsApp en la siguiente sección a continuación y cada hemos explicado la integración de telegrama tiene sentido, incluso cuando ahora es una plataforma social diferente. Recuerda siempre sustituir alguna parte del código con tus credenciales reales para que funcionen.

Integración de WhatsApp

Paso 1: Regístrese con un proveedor de API de mensajería.

• Elija un proveedor: Twilio es una opción popular para la integración de WhatsApp.
• Crear una cuenta: Regístrese en Twilio y complete cualquier verificación necesaria.
• Obtener credenciales API: Obtenga sus credenciales API (SID de cuenta, token de autenticación) de Twilio.

Paso 2: Crear un script de middleware.

Script Python de middleware para la integración de WhatsApp:

import requests

def send_whatsapp_message(to, message, account_sid, auth_token):
    url = f"https://api.twilio.com/2010-04-01/Accounts/{account_sid}/Messages.json"
    payload = {
        'From': 'whatsapp:[phone]',  # Twilio sandbox number
        'To': f'whatsapp:{to}',
        'Body': message
    }
    headers = {
        'Authorization': f'Basic {account_sid}:{auth_token}'
    }
    response = requests.post(url, data=payload, headers=headers)
    return response.json()

Paso 3: Configurar MetaTrader 5 para utilizar el middleware.

Código MQL5 para enviar notificaciones de WhatsApp:

void SendWhatsAppMessage(string to, string message, string account_sid, string auth_token)
{
    string url = "http://your-server-url/send_whatsapp_message";
    char postData[];
    StringToCharArray("to=" + to + "&message=" + message + "&account_sid=" + account_sid + "&auth_token=" + auth_token, postData);
    
    char result[];
    int res = WebRequest("POST", url, "", NULL, 0, postData, 0, result, NULL);
    if (res != 200)
    {
        Print("Error sending message: ", GetLastError());
    }
    else
    {
        Print("Message sent successfully.");
    }
}

El poder de un VPS en nuestro sistema de notificaciones

Un VPS opera continuamente sin tiempo de inactividad, asegurando que su plataforma MetaTrader 5 y los sistemas de notificación estén siempre activos. Esto es fundamental para recibir notificaciones en tiempo real sin interrupciones. Los proveedores de VPS ofrecen conexiones a Internet robustas y estables, lo que reduce el riesgo de desconexiones que pueden ocurrir en las redes domésticas o de oficina. Los servidores VPS suelen estar ubicados en centros de datos con conexiones de alta velocidad a las principales bolsas financieras, lo que reduce la latencia y mejora la velocidad a la que se reciben y se actúa sobre las alertas y notificaciones comerciales. A diferencia del alojamiento compartido, un VPS proporciona recursos de CPU, RAM y almacenamiento dedicados, lo que garantiza un rendimiento constante para ejecutar MetaTrader 5 y gestionar las notificaciones. Se puede acceder a un VPS de forma remota desde cualquier dispositivo con conexión a Internet, lo que le permite administrar su plataforma MetaTrader 5 y recibir notificaciones desde cualquier lugar.

Conclusión

Hemos configurado con éxito un sistema de notificación robusto para nuestro indicador, sentando las bases para la integración de WhatsApp y Telegram. Esta mejora es fundamental para atraer a una gran comunidad, ya que estas señales se pueden compartir instantáneamente. Los desarrolladores pueden capitalizar comercializando estas señales a los traders interesados mediante estas plataformas populares, ofreciendo un medio rápido y eficiente de transmisión directamente desde la plataforma a los canales de redes sociales.

Este enfoque garantiza la accesibilidad de la señal en cualquier momento y en cualquier lugar con acceso a Internet, lo que permite compartirla fácilmente con solo un clic. Los traders pueden elegir cómodamente entre Telegram o WhatsApp para acceder a la señal. En la Parte II se explorarán más detalles de integración. Los archivos de referencia se adjuntan a continuación. No dude en participar en los debates de la sección de comentarios.