MetaTrader 5 / Probador
English Русский Deutsch 日本語
preview
Introducción a MQL5 (Parte 9): Comprensión y uso de objetos en MQL5

Introducción a MQL5 (Parte 9): Comprensión y uso de objetos en MQL5

MetaTrader 5 — Probador | 9 abril 2025, 08:39
223 0
Israel Pelumi Abioye
Israel Pelumi Abioye

Introducción

¡Bienvenido nuevamente a nuestra serie MQL5! Discutiremos un tema fascinante en este capítulo que creo que encontrará muy útil y fascinante. Comenzaremos un proyecto en el que trabajaremos con diferentes objetos gráficos en MQL5, que serán una base esencial para nuestros proyectos futuros. Este punto de partida será especialmente útil cuando nos adentremos en proyectos más complejos, como el uso de diversos patrones armónicos. Los objetos de gráfico en MQL5 son elementos gráficos que se pueden colocar en los gráficos de trading para representar visualmente varios tipos de datos, incluyendo niveles de precios, zonas de trading y anotaciones de texto. Estos objetos ofrecen a los comerciantes y desarrolladores la flexibilidad de crear imágenes personalizadas que mejoran el análisis de gráficos, lo que facilita la identificación de tendencias del mercado, niveles de precios clave y oportunidades comerciales.

Hay diferentes objetos gráficos disponibles en MQL5, desde líneas y formas básicas hasta componentes complejos como texto, flechas e indicadores personalizados. Se puede crear un entorno comercial altamente personalizado modificando el color, el tamaño, la posición y otros atributos de cada objeto. Los objetos gráficos son más que simples acentos decorativos; son instrumentos eficaces para producir representaciones visuales claras y comprensibles de datos del mercado. Por ejemplo, puede ser más sencillo identificar posibles puntos de reversión si los niveles de soporte y resistencia se resaltan con rectángulos. A través de un proyecto práctico, este artículo le introducirá en la idea de los objetos de gráfico en MQL5 y le mostrará cómo utilizarlos.

En este proyecto, desarrollaremos un Asesor Experto (EA) que mejora el trading al mostrar visualizaciones claras directamente en el gráfico. El EA mostrará automáticamente la ruta desde el punto de entrada hasta las zonas de stop loss y take profit, lo que le proporcionará una evaluación visual rápida del riesgo y la recompensa de su operación. Sin necesidad de consultar otras fuentes de datos, el EA se actualizará en tiempo real para reflejar sus ganancias o pérdidas actuales a medida que el mercado se mueve. Además, proporcionará información precisa de un vistazo al mostrar los precios de entrada, stop loss y take profit para la posición actual bajo observación.

La adaptabilidad de este EA a las modificaciones en su configuración comercial es una de sus características principales. Tus señales visuales siempre estarán actualizadas porque el EA actualizará instantáneamente el gráfico cuando modifiques tus niveles de take profit o stop loss. El EA también se ajusta a la duración de su operación. A medida que mantiene la operación durante más tiempo, el EA se ajustará gradualmente para que los elementos visuales se vuelvan más visibles. Esto le permitirá monitorear el comercio de manera efectiva con varios marcos de tiempo, aunque al principio puede que no sean muy notorios en marcos de tiempo más altos. Ahora es más sencillo gestionar operaciones de marcos temporales más bajos y realizar un seguimiento de ellas a medida que cambian gracias a esta adaptación dinámica.

El EA le permite examinar operaciones anteriores, lo que proporciona un análisis histórico detallado. Le ayuda a evaluar su desempeño comercial y a tomar decisiones inteligentes al mostrarle cuánto ganó o perdió en posiciones anteriores. Puede ver datos históricos directamente en el gráfico definiendo el rango de fechas. Esto le brinda una descripción general completa de su historial comercial y la opción de ampliar operaciones específicas para realizar un análisis más profundo.

Visualización comercial actual:

Figura 1. El EA muestra información sobre la posición actual.

Perspectivas comerciales históricas:

Figura 2. El EA muestra información sobre operaciones cerradas.


En este artículo aprenderás:

  • Creación y modificación de objetos de gráficos para un análisis visual mejorado.
  • Recorrer posiciones para gestionar y mostrar operaciones de forma eficiente en el gráfico.
  • Utilización de datos históricos de transacciones para orientar la ubicación de los objetos del gráfico.
  • Visualización de ganancias y pérdidas históricas de transacciones en el gráfico para el seguimiento del rendimiento.
  • Uso de conversiones de fecha y hora para cronometrar con precisión la creación de objetos gráficos.
  • Anotación de detalles de entrada, Take Profit (TP) y Stop Loss (SL) en el gráfico.
  • Uso de parámetros de entrada para personalizar su asesor experto.

Este proyecto tiene como objetivo familiarizarlo con las aplicaciones útiles de los objetos gráficos en MQL5. Este enfoque práctico le enseñará cómo administrar operaciones, mejorar el análisis visual y mostrar datos comerciales importantes directamente en sus gráficos integrando y modificando de manera eficiente los objetos de gráficos dentro de su Asesor Experto (Expert Advisor, EA). Para ayudarlo a comprender mejor cómo usar estas herramientas para tomar decisiones comerciales y realizar el seguimiento del rendimiento, este proyecto lo guiará a través del proceso de creación, modificación y administración de varios objetos gráficos.


1.Objetos gráficos en MQL5

1.1. ¿Qué son los objetos gráficos?

Los objetos gráficos en MQL5 son componentes visuales que los operadores pueden incluir en sus gráficos para mejorar el análisis y la toma de decisiones. Estos objetos pueden ser elementos más complejos, como canales o flechas, o pueden ser formas, líneas y textos más simples. Los objetos gráficos se utilizan principalmente para representar visualmente datos importantes, lo que ayuda a los operadores a planificar operaciones, evaluar las condiciones del mercado y realizar un seguimiento de las posiciones abiertas. Los objetos gráficos le permiten resaltar niveles de precios significativos y dibujar líneas de tendencia en el gráfico que indican la dirección del mercado. Al visualizar estos datos en el gráfico, los operadores pueden tomar decisiones comerciales bien informadas y evaluar rápidamente las condiciones del mercado en lugar de depender únicamente de datos numéricos.

1.2. ¿Por qué es importante personalizar los objetos gráficos?

Puede mejorar la claridad visual de sus gráficos comerciales y ayudarse a tomar mejores decisiones personalizando los objetos gráficos. Al modificar el color, el tamaño o la posición de estos objetos, puede hacer que el gráfico se adapte mejor a sus preferencias y estilo comerciales. Puede utilizar esta personalización para hacer que la información más importante se destaque a simple vista enfatizándola.

Si su atención está centrada en los niveles de soporte y resistencia, es posible que desee utilizar líneas gruesas y llamativas que se destaquen en colores vivos y sean fáciles de ver incluso al escanear rápidamente el gráfico. Al hacer esto, reduce la posibilidad de pasar por alto señales cruciales durante una sesión de negociación agitada. De manera similar, hacer que las anotaciones de texto se destaquen más puede servir como una señal visual para ayudarlo a recordar decisiones comerciales importantes o estrategias planificadas.

1.3. Objetos gráficos que utilizaremos para el proyecto

En este proyecto se utilizarán varios objetos gráficos MQL5 importantes para mejorar nuestro análisis comercial. Los objetos gráficos que utilizaremos son los siguientes:

1.3.1. Líneas de tendencia

Una herramienta esencial en nuestro proyecto es la línea de tendencia, que se utiliza principalmente para rastrear el precio actual del mercado con respecto a niveles de tendencia importantes e identificar el punto de entrada. Para determinar la dirección general del mercado, trazaremos una línea de tendencia entre puntos de precio importantes. A medida que el precio de mercado cambia (o «ticks»), la línea de tendencia se actualiza en tiempo real, por lo que se extenderá continuamente desde el precio de entrada inicial hasta el precio de mercado más reciente.

Esto garantiza que la línea de tendencia siempre refleje los datos de precios más recientes, lo que ayuda a realizar un seguimiento preciso del rendimiento de la operación y a tomar decisiones sobre la gestión de la posición. La línea de tendencia a menudo comienza en el precio al que se abrió la posición, lo que refleja el punto de inicio de la operación. La línea se extiende hasta el precio de mercado actual o el precio de venta. Esto muestra cómo se ha movido el precio desde que se abrió la operación.

Figura 3. Línea de tendencia

1.3.2. Etiquetas de texto

Como lo muestran los comentarios en el gráfico, las etiquetas de texto ofrecen detalles claros y comprensibles sobre las diferentes facetas de una operación. En ellos se puede mostrar información importante como puntos de entrada, niveles de stop-loss, objetivos de take-profit y cualquier otra nota pertinente para la estrategia comercial. Al agregar etiquetas de texto a áreas importantes del gráfico, puede recuperar fácilmente información vital sin usar notas externas ni su memoria. Esta ayuda visual facilita tener a mano toda la información necesaria a la hora de tomar decisiones.

Con cada tick aparecerá una etiqueta de texto indicando la ganancia o pérdida actual de la posición abierta. Con esta actualización en tiempo real, puede vigilar el rendimiento de su operación a medida que se mueve el mercado y puede obtener una idea instantánea de si la operación va en la dirección correcta. Con una etiqueta como +$100 o -$50 junto a la operación, la ganancia o pérdida actual se mostrará en tiempo real a medida que avanza el mercado. Esto le permite supervisar el rendimiento de su operación y realizar los ajustes necesarios.

Figura 4. Etiquetas de texto

1.3.3. Objetos rectangulares

Los objetos rectangulares se pueden utilizar para indicar niveles de soporte y resistencia en un gráfico, entre otras cosas. Pero en este proyecto, su uso se limitará a identificar zonas ganadoras y perdedoras en una operación. Cuando una posición está perdiendo dinero actualmente, dibujaremos un rectángulo desde el punto de entrada hasta el nivel de stop-loss. Esto nos ayuda a reconocer rápidamente cuando la posición se está acercando al stop-loss al representar visualmente el área donde la operación va en una dirección negativa. Se dibujará un rectángulo desde el punto de entrada hasta el nivel de toma de ganancias una vez que la posición esté en ganancias. Esto nos ayuda a seguir el progreso de la operación hacia el objetivo de toma de ganancias resaltando las áreas en las que tiene un buen desempeño.


Figura 5. Rectángulo

Hay muchos objetos gráficos diferentes disponibles en MQL5, y cada uno está destinado a mejorar el análisis de comercio de una manera particular. Sería demasiado cubrir todos estos temas en un solo artículo. Debido a esto, he reducido el enfoque a sólo los elementos que se utilizarán en nuestro proyecto. Estos objetos elegidos, que incluyen rectángulos, líneas de tendencia y etiquetas de texto, no sólo son esenciales para esta estrategia específica, sino que también tienen procesos de creación y modificación que son comparables a los de otros objetos MQL5. Adquirirá los conocimientos fundamentales necesarios para trabajar con diversos objetos gráficos en MQL5, utilizando métodos comparables para crearlos y modificarlos de acuerdo con sus necesidades de trading, comprendiendo los conceptos y estrategias de estos objetos en particular.


2. Creación y personalización de objetos

En esta sección nos concentraremos en la creación y modificación de diferentes objetos gráficos en MQL5. Se mostrará cómo crear objetos como rectángulos, líneas de tendencia y etiquetas de texto, y cómo ajustar su color, estilo y anchura para adaptarlos a su plan de negociación. 

2.1. Pseudocódigo

En este proyecto, el pseudocódigo es esencial porque, antes de escribir cualquier código, ofrece un resumen bien organizado y conciso del razonamiento y los procedimientos necesarios para cumplir nuestros objetivos. Ayuda a descomponer las tareas difíciles en componentes más pequeños y manejables, lo que facilita la planificación, ayuda a detectar posibles problemas y garantiza que el código que escribimos sea eficiente y esté bien organizado. El pseudocódigo nos permite visualizar todo el flujo del Asesor Experto, lo que facilita la implementación de objetos gráficos y otras funciones.

Este es el pseudocódigo básico de nuestro EA:

1. Inicialización:

  • Defina colores para la zona SL, la zona TP y la línea de tendencia.
  • Establece el índice de posición.
  • Especifique si desea mostrar datos históricos.
  • Defina las fechas de inicio y fin de los datos históricos.
  • Ajuste la hora de cierre de la zona.
  • Obtén el ID del gráfico actual.
  • Inicializar variables para almacenar los detalles de la posición (precio de apertura, stop loss, take profit, beneficio, hora de apertura).

    2.  2. En cada tick:

    • Convierte la cadena de tiempo (string) en un objeto de fecha y hora para la zona de cierre.
    • Obtener el precio de compra actual.
    • Recorrer todas las posiciones.
    • Obtener el número de ticket de la posición.
    • Comprueba si la posición coincide con el símbolo del gráfico.
    • Recuperar detalles: precio de apertura, stop loss, take profit, hora de apertura y beneficio.
    • Si la posición coincide con el índice especificado.
    • Crear y configurar el rectángulo de zona SL.
    • Establezca las propiedades (color, estilo, anchura, relleno).
    • Crear y configurar el rectángulo de zona TP.
    • Establezca las propiedades (color, estilo, anchura, relleno).
    • Crear y configurar línea de tendencia.
    • Establecer las propiedades (color, estilo, ancho).
    • Calcular y mostrar el beneficio de la posición.
    • Formatear y mostrar las ganancias como texto.
    • Crear y configurar objetos de texto para Entrada, TP y SL:
    • Establecer las propiedades (color, tamaño de fuente).

    3. Si la visualización de datos históricos está habilitada:

    • Borrar comentarios anteriores.
    • Seleccione y recorra las transacciones históricas dentro del rango de fechas especificado:
    • Obtenga detalles de cada transacción (precio de apertura, precio de cierre, SL, TP, beneficio, tiempos).
    • Mostrar información de ganancias/pérdidas.
    • Cree y configure la zona SL, la zona TP y la línea de tendencia para transacciones históricas:
    • Establecer las propiedades (color, estilo, ancho).

    2.2. Aplicación práctica: creación y personalización de objetos

    2.2.1 Creación de objetos gráficos

    Una herramienta esencial en MQL5 que le permite crear diferentes tipos de objetos en su gráfico de trading es la función ObjectCreate(). Estos objetos, que ayudan a los operadores a visualizar mejor los datos del mercado, analizar tendencias y marcar puntos importantes en el gráfico, pueden incluir líneas de tendencia, rectángulos, etiquetas de texto, flechas, etc.

    Más allá de la mera creación: especificar la ubicación de los objetos

    No sólo puede crear objetos en el gráfico utilizando ObjectCreate(), sino que sus parámetros también le dan un control exacto sobre dónde aparecen estos objetos. Puede orientar y mejorar la eficacia de su análisis colocando estos objetos en lugares específicos de su gráfico y especificando parámetros concretos. El tiempo y el precio son los dos factores principales que determinan dónde se colocan los artículos en el gráfico. Estos elementos sirven como ancla para el objeto en el gráfico en esa ubicación específica.

    Sintaxis:

    ObjectCreate(chart_id, object_name, object_type, sub_window, time1, price1, time2, price2, time3, price3);

    La relación entre el tiempo y el precio en la colocación de objetos

    Cada punto de un gráfico comercial en MQL5 está determinado por la interacción del precio (el eje vertical) y el tiempo (el eje horizontal). Estas dos dimensiones se utilizan para especificar la ubicación exacta del objeto en el gráfico cuando lo crea utilizando ObjectCreate.

    Comprender los puntos de anclaje: time1, price1, time2, price2, time3, price3

    Es común necesitar definir uno o más puntos de anclaje cuando se utiliza ObjectCreate() para crear objetos. La ubicación precisa del objeto en el gráfico se establece mediante estos puntos de anclaje. Estos puntos de anclaje son los parámetros time1, price1, time2, price2, time3, and price3.

    Figura 6. Puntos de anclaje del objeto de línea de tendencia


    Figura 7. Puntos de anclaje del objeto rectángulo

    • time1 y price1: Estos parámetros establecen el punto de anclaje inicial del objeto. Si estuviera dibujando una línea de tendencia, por ejemplo, time1 indicaría el tiempo del punto de inicio (una vela concreta, por ejemplo), y price1 indicaría el nivel de precios en ese punto.
    • time2 y price2: Especifica el segundo punto de anclaje del objeto. Este sería el punto final de la línea en el ejemplo de la línea de tendencia. Price2 indica el nivel de precios en ese momento, y time2 indica la hora del segundo punto.

    • time3 y price3: Es necesario un tercer punto de anclaje para determinados objetos más intrincados, como canales o triángulos. Puede especificar este tercer punto mediante time3 y price3, lo que puede ser necesario al dibujar algunas formas que requieren tres coordenadas.

    Ejemplo:
     
    // Get the ID of the current chart
long chart_id = ChartID();

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
// Define the first anchor point for the trendline
// 'time1' is the datetime for the first point, and 'price1' is the price at that time
   datetime time1  = D'2024.08.21 16:00';
   double   price1 = 8766.01;

// Define the second anchor point for the trendline
// 'time2' is the datetime for the second point, and 'price2' is the price at that time
   datetime time2  = D'2024.08.28 08:00';
   double   price2 = 8854.51;

// Create a trendline object on the chart
// 'chart_id' is the ID of the chart where the object will be placed
// "Trend Line" is the name of the trendline object
// 'OBJ_TREND' specifies that the object is a trendline
// The last four parameters (0, time1, price1, time2, price2) specify the anchor points of the trendline
   ObjectCreate(chart_id, "Trend Line", OBJ_TREND, 0, time1, price1, time2, price2);
  }

    Salida:

    Figura 8. Colocando objetos con tiempo y precio

    Las etiquetas de texto (OBJ_TEXT) se pueden colocar en el gráfico con un solo punto de anclaje. El punto de anclaje indica la ubicación del texto en función de las coordenadas de precio y tiempo que se proporcionan. Una etiqueta de texto en el gráfico que dice "Buy Here" en un momento y precio determinados.

    Ejemplo:

    // Get the ID of the current chart
long chart_id = ChartID();

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
// Define the time for the text label's position (August 21, 2024, at 16:00)
   datetime time1  = D'2024.08.21 16:00';

// Define the price level for the text label's position (8766.01)
   double   price1 = 8766.01;

// Create a text object named "Text" on the chart at the specified time and price
   ObjectCreate(chart_id, "Text", OBJ_TEXT, 0, time1, price1);

// Set the text content of the object to display "Buy Here"
   ObjectSetString(chart_id, "Text", OBJPROP_TEXT, "Buy Here");
  }

    Salida:

    Figura 9. Etiqueta de texto

    2.3. Personalización de objetos

    Puede personalizar los componentes visuales de los objetos del gráfico para adaptarlos a su estilo comercial. Para tu deleite, también puedes modificar su tamaño, color y estilo. Para que una línea de tendencia destaque entre otros elementos del gráfico, por ejemplo, puede cambiar su color, grosor y ubicación para asegurarse de que coincida con los niveles importantes del mercado. De igual forma, las etiquetas de texto se pueden modificar modificando la fuente y el esquema de colores para destacar detalles cruciales como los objetivos de ganancias o los puntos de entrada.

    Ejemplo: 

    // Define the time for the text label's position (August 21, 2024, at 16:00)
datetime time1  = D'2024.08.21 16:00';

// Define the price level for the text label's position (8766.01)
double   price1 = 8766.01;

// Create a text object named "Text" on the chart at the specified time and price
ObjectCreate(chart_id, "Text", OBJ_TEXT, 0, time1, price1);

// Set the text content of the object to display "Buy Here"
ObjectSetString(chart_id, "Text", OBJPROP_TEXT, "Buy Here");

// Set the color of the text object to Medium Blue
ObjectSetInteger(chart_id, "Text", OBJPROP_COLOR, clrMediumBlue);

    Este código muestra el texto "Buy Here", agrega una etiqueta de texto al gráfico en un momento y precio determinados, y cambia el color del texto a azul medio.

    Salida:

    Figura 10. Personalización de la etiqueta de texto


    2.3.1. Funciones de objeto para personalizar objetos gráficos en MQL5

    Los objetos gráficos en MQL5 se pueden personalizar utilizando varias funciones de objeto. Con la ayuda de estas funciones, puede modificar el aspecto, el tacto y la ubicación de los objetos gráficos para adaptarlos mejor a sus necesidades concretas.

    ObjectSetInteger()

    Se utiliza para establecer propiedades de tipo entero de un objeto gráfico, como el color, la anchura y el estilo.

    Ejemplo: 
    // Get the ID of the current chart
long chart_id = ChartID();

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {

   datetime time1  = D'2024.08.21 16:00';
   double   price1 = 8766.01;

// Define the second anchor point for the trendline
// 'time2' is the datetime for the second point, and 'price2' is the price at that time
   datetime time2  = D'2024.08.28 08:00';
   double   price2 = 8854.51;

// Create a trend line object on the chart with the name "Trend Line"
// The trend line will be drawn from time1/price1 to time2/price2
   ObjectCreate(chart_id, "Trend Line", OBJ_TREND, 0, time1, price1, time2, price2);

// Set the style of the trend line to a dashed line
   ObjectSetInteger(chart_id, "Trend Line", OBJPROP_STYLE, STYLE_DASH);

// Set the width of the trend line to 2
   ObjectSetInteger(chart_id, "Trend Line", OBJPROP_WIDTH, 2);
  }

    Salida:

    Figura 11. Línea de tendencia

    ObjectSetDouble()

    Fija atributos de tipo doble, frecuentemente sobre precio o tiempo. Ejemplo: Ajuste de las coordenadas de los puntos de anclaje en una línea de tendencia.

    ObjectSetString()

    Se utiliza para establecer propiedades de tipo string, como el texto que se muestra en una etiqueta de texto.

    Ejemplo: Añadir anotaciones o notas directamente en el gráfico.

    // Create a text object named "Text" on the chart at the specified time and price
ObjectCreate(chart_id, "Text", OBJ_TEXT, 0, time1, price1);

// Set the text content of the object to display "Buy Here"
ObjectSetString(chart_id, "Text", OBJPROP_TEXT, "Buy Here");

    Se pueden utilizar diferentes tipos de objetos gráficos para construir, personalizar y gestionar utilizando varias de las funciones de objeto disponibles en MQL5. Estas características son cruciales para mejorar la forma en que los datos comerciales se muestran visualmente en sus gráficos. ObjectCreate y ObjectSetInteger son dos funciones importantes que hemos discutido en nuestro proyecto, pero hay muchas más. Puedes consultar la documentación de MQL5, que ofrece detalles exhaustivos sobre todas las funciones de gráfico disponibles, para entender más a fondo las funciones adicionales.


    3. Implementando objetos gráficos en nuestro proyecto

    3.1. Creación de objetos gráficos para las posiciones actuales

    Esta sección se concentrará en configurar los objetos del gráfico para manejar y presentar datos sobre las posiciones actuales en el gráfico. Para representar visualmente datos comerciales en tiempo real, esto implica crear y modificar rectángulos, líneas de tendencia y etiquetas de texto.

    3.1.1. Uso de rectángulos para resaltar áreas

    Vamos a utilizar dos rectángulos diferentes para enfatizar visualmente las zonas críticas en su gráfico donde se establecen los niveles de Stop Loss (SL) y Take Profit (TP). Estos rectángulos representarán dinámicamente las zonas SL y TP, para que pueda controlar fácilmente los niveles de riesgo y recompensa de un vistazo.

    a. Resaltar la zona SL:

    • Anchor 1: El primer ancla del rectángulo de la zona SL se colocará al precio de entrada de la operación y a la hora exacta de apertura de la posición.
    • Anchor 2: La segunda ancla se situará en el precio SL y se extenderá horizontalmente hasta las 23:59 del día en curso. Esta extensión asegura que el rectángulo se actualice dinámicamente cada día, expandiéndose para cubrir la zona SL visualmente hasta que la operación se cierre o termine el día.
    • Propósito: Este rectángulo marca el área de riesgo en el gráfico, permitiéndole identificar rápidamente cuán cerca está el precio actual del nivel SL.

    b. Resaltar la zona TP:

    • Anchor 1: La primera ancla del rectángulo de la zona TP también comenzará a partir del precio de entrada de la operación.
    • Anchor 2: La segunda ancla, que se extiende horizontalmente hasta las 23:59 del día en curso, se situará en el precio TP de la posición actual. Al igual que la zona SL, el área de recompensa potencial se resaltará continuamente mediante este rectángulo en expansión cada día.

    Figura 12. Puntos de anclaje para los dos cuadrados

    Los rectángulos que resaltan las zonas SL y TP sólo pueden hacerse después de que recuperemos programáticamente la información necesaria para cada posición. Esto incluye el precio de apertura, el nivel de stop loss (SL), el nivel de take profit (TP) y la hora de apertura de la operación. Nos aseguramos de que los rectángulos estén colocados adecuadamente en el gráfico, coincidiendo con los niveles y tiempos apropiados para cada posición, recuperando estos valores mediante programación. Los rectángulos también pueden actualizarse dinámicamente con nuevas posiciones gracias a este método automatizado, que mantiene la representación visual actualizada y pertinente en todo momento.

    Ejemplo:

    // Variables to store position details
double open_price;          // Variable to store the entry price of the position
double stop_loss;           // Variable to store the Stop Loss level of the position
double take_profit;         // Variable to store the Take Profit level of the position
datetime position_open_time; // Variable to store the open time of the position

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
// Loop through all open positions
   for(int i = 0; i < PositionsTotal(); i++)
     {
      // Get the ticket number of the position at index 'i'
      ulong ticket = PositionGetTicket(i);

      // Retrieve and store the entry price of the position
      open_price = PositionGetDouble(POSITION_PRICE_OPEN);

      // Retrieve and store the Stop Loss level of the position
      stop_loss = PositionGetDouble(POSITION_SL);

      // Retrieve and store the Take Profit level of the position
      take_profit = PositionGetDouble(POSITION_TP);

      // Retrieve and store the open time of the position
      position_open_time = (int)PositionGetInteger(POSITION_TIME);

      // Print the retrieved values for debugging or verification
      Print("Open Price index ",i,": ",open_price);
      Print("SL index ",i,": ",stop_loss);
      Print("TP index ",i,": ",take_profit);
      Print("Open time index ",i,": ",position_open_time);
     }
  }

    Explicación:

    Cada vez que el precio del instrumento de negociación se mueve, o cambia, la función OnTick ejecuta el código. Se recupera información importante sobre cada posición abierta en la cuenta de negociación. Todas las posiciones abiertas en la cuenta de negociación se ejecutan en bucle. La función PositionsTotal() devuelve información específica sobre cada posición en función de su índice en la lista total de posiciones. Utilice las funciones PositionGetDouble y PositionGetInteger para recuperar estos detalles. Para depuración o verificación, los datos recuperados se imprimen en el terminal antes de añadir elementos visuales al gráfico, como rectángulos que resalten las zonas SL y TP. Esto garantiza que se recopilen datos precisos.

    La implementación actual planteará dos problemas:

    • Identificar la posición exacta: Tal como está, el EA no sabe qué posición precisa está haciendo un bucle para obtener los datos de tiempo y precio. Esto significa que cuando sólo queramos información de una posición concreta, el código extraerá datos de todas las posiciones abiertas, lo que podría provocar confusión o que se utilizaran datos incorrectos.
    • Datos específicos del instrumento gráfico: La información que se está recuperando tiene que estar relacionada con las posiciones abiertas y las operaciones relacionadas con el instrumento que se muestra actualmente en el gráfico. El EA podría extraer datos de las posiciones de otros instrumentos que no serían relevantes para el gráfico actual si no se filtrara el símbolo del gráfico, lo que podría dar lugar a representaciones visuales inexactas o engañosas.

    La solución a este problema es proporcionar una entrada donde el usuario pueda elegir de qué índice de posición desea recuperar datos. Con esta información, el EA podrá concentrarse en el rol específico que el usuario está buscando. El código también debe garantizar que la posición elegida coincida con el instrumento que está visible actualmente en el gráfico, garantizando que solo se utilicen datos pertinentes para la representación visual.

    Ejemplo: 

      // Variables to store position details
double open_price;          // Variable to store the entry price of the position
double stop_loss;           // Variable to store the Stop Loss level of the position
double take_profit;         // Variable to store the Take Profit level of the position
datetime position_open_time; // Variable to store the open time of the position

// Define the position index for the first position
input int position_index  = 0; // POSITION INDEX (Index starts from 0)

// Get the ID of the current chart
long chart_id = ChartID();


//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {


// Loop through all open positions
   for(int i = 0; i < PositionsTotal(); i++)
     {
      // Get the ticket number of the position at index 'i'
      ulong ticket = PositionGetTicket(i);

      if(PositionGetInteger(POSITION_TICKET) == PositionGetTicket(position_index) && PositionGetString(POSITION_SYMBOL) == ChartSymbol(chart_id))
        {

         // Retrieve and store the entry price of the position
         open_price = PositionGetDouble(POSITION_PRICE_OPEN);

         // Retrieve and store the Stop Loss level of the position
         stop_loss = PositionGetDouble(POSITION_SL);

         // Retrieve and store the Take Profit level of the position
         take_profit = PositionGetDouble(POSITION_TP);

         // Retrieve and store the open time of the position
         position_open_time = (int)PositionGetInteger(POSITION_TIME);

         // Print the retrieved values for debugging or verification
         Print("Open Price index ",i,": ",open_price);
         Print("SL index ",i,": ",stop_loss);
         Print("TP index ",i,": ",take_profit);
         Print("Open time index ",i,": ",position_open_time);

        }
     }

  }

      El algoritmo itera sobre cada posición abierta, determina si corresponde al índice y símbolo gráfico elegidos y, a continuación, obtiene la información pertinente. Ahora podemos hacer los dos rectángulos que indicarán las zonas SL (Stop Loss) y TP (Take Profit) después de recuperar con éxito los datos de precio y tiempo para la posición dada. Para garantizar que estos rectángulos representan adecuadamente las regiones SL y TP en el gráfico, los datos adquiridos se utilizarán como entradas para la función ObjectCreate().

      Ejemplo: 
      // Variables to store position details
double open_price;          // Variable to store the entry price of the position
double stop_loss;           // Variable to store the Stop Loss level of the position
double take_profit;         // Variable to store the Take Profit level of the position
datetime position_open_time; // Variable to store the open time of the position

// Define the position index for the first position
input int position_index  = 1; // POSITION INDEX (Index starts from 0)

// Get the ID of the current chart
long chart_id = ChartID();  // Store the ID of the current chart

string time = "23:59";      // Define a specific time as a string

// Define the color for the losing zone
input color sl_zonez_color   = clrPink; // Choose a color for Losing Zone

// Define the color for the winning zone
input color tp_zonez_color   = clrSpringGreen; // Choose a color for Winning Zone


//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {

// Convert the string time to datetime
   datetime close_zone = StringToTime(time);

// Loop through all open positions
   for(int i = 0; i < PositionsTotal(); i++)
     {
      // Get the ticket number of the position at index 'i'
      ulong ticket = PositionGetTicket(i);

      // Check if the position matches the specified index and symbol of the current chart
      if(PositionGetInteger(POSITION_TICKET) == PositionGetTicket(position_index) && PositionGetString(POSITION_SYMBOL) == ChartSymbol(chart_id))
        {

         // Retrieve and store the entry price of the position
         open_price = PositionGetDouble(POSITION_PRICE_OPEN);

         // Retrieve and store the Stop Loss level of the position
         stop_loss = PositionGetDouble(POSITION_SL);

         // Retrieve and store the Take Profit level of the position
         take_profit = PositionGetDouble(POSITION_TP);

         // Retrieve and store the open time of the position
         position_open_time = (int)PositionGetInteger(POSITION_TIME);

         // Print the retrieved values for debugging or verification
         Print("Open Price index ",i,": ",open_price);
         Print("SL index ",i,": ",stop_loss);
         Print("TP index ",i,": ",take_profit);
         Print("Open time index ",i,": ",position_open_time);

         // Create a rectangle to represent the Stop Loss (SL) zone on the chart
         ObjectCreate(chart_id, "SL Zone", OBJ_RECTANGLE, 0, position_open_time, open_price, close_zone, stop_loss);

         // Create a rectangle to represent the Take Profit (TP) zone on the chart
         ObjectCreate(chart_id, "TP zone", OBJ_RECTANGLE, 0, position_open_time, open_price, close_zone, take_profit);

         // Set properties for the SL zone rectangle
         ObjectSetInteger(chart_id, "SL Zone", OBJPROP_COLOR, sl_zonez_color); // Set color to the selected SL zone color
         ObjectSetInteger(chart_id, "SL Zone", OBJPROP_STYLE, STYLE_SOLID);    // Set style to solid
         ObjectSetInteger(chart_id, "SL Zone", OBJPROP_WIDTH, 1);              // Set the width of the rectangle border
         ObjectSetInteger(chart_id, "SL Zone", OBJPROP_FILL, sl_zonez_color);  // Fill the rectangle with the selected SL zone color
         ObjectSetInteger(chart_id, "SL Zone", OBJPROP_BACK, true);            // Set the rectangle to appear behind the chart objects

         // Set properties for the TP zone rectangle
         ObjectSetInteger(chart_id, "TP zone", OBJPROP_COLOR, tp_zonez_color); // Set color to the selected TP zone color
         ObjectSetInteger(chart_id, "TP zone", OBJPROP_STYLE, STYLE_SOLID);    // Set style to solid
         ObjectSetInteger(chart_id, "TP zone", OBJPROP_WIDTH, 1);              // Set the width of the rectangle border
         ObjectSetInteger(chart_id, "TP zone", OBJPROP_FILL, tp_zonez_color);  // Fill the rectangle with the selected TP zone color
         ObjectSetInteger(chart_id, "TP zone", OBJPROP_BACK, true);            // Set the rectangle to appear behind the chart objects

        }
     }

  }

      Explicación:

      Este código obtiene la hora de apertura de la posición, el SL, el TP y el precio de apertura para cada posición. Utiliza esta información para dibujar dos rectángulos visibles en el gráfico: uno para el área de posible pérdida y otro para el área de ganancia potencial. Por otro lado, no especificar los niveles de TP o SL podría generar problemas con los puntos de anclaje de estos rectángulos, lo que podría afectar la forma en que se posicionan o se muestran en el gráfico. Para garantizar una visualización precisa, implementaré código para rectificar este comportamiento.

      if(stop_loss > 0)
  {
// Create a rectangle to represent the Stop Loss (SL) zone on the chart
   ObjectCreate(chart_id, "SL Zone", OBJ_RECTANGLE, 0, position_open_time, open_price, close_zone, stop_loss);
  }


if(take_profit > 0)
  {
// Create a rectangle to represent the Take Profit (TP) zone on the chart
   ObjectCreate(chart_id, "TP zone", OBJ_RECTANGLE, 0, position_open_time, open_price, close_zone, take_profit);
  }

      Explicación:

      Antes de crear los rectángulos correspondientes en el gráfico, el fragmento de código verifica que los niveles Stop Loss y Take Profit sean mayores que cero. Si el SL está configurado (es decir, es mayor que 0), se dibuja un rectángulo para representar la zona SL, marcando el área de pérdida potencial; si el TP está configurado, se crea otro rectángulo para representar la zona TP, indicando el área de ganancia potencial. Al evitar la creación de rectángulos con puntos de anclaje no válidos, estas comprobaciones garantizan una visualización precisa del gráfico.

      Salida:

      Figura 13. Creación de objetos cuadrados con datos de posiciones abiertas

      3.1.2. Creación de líneas de tendencia

      Para ilustrar el movimiento de precios desde que se abrió la operación, nos concentraremos en dibujar una línea de tendencia en esta parte desde el precio de apertura de la posición hasta el precio actual. Es fácil ver cómo ha cambiado el mercado alrededor de estos dos lugares de entrada, lo que facilita un examen más profundo del desarrollo del comercio.

      Ejemplo: 
      // Get the current ask price
double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
// Create a trend line object on the chart from the position's open time and price to the current time and ask price
ObjectCreate(chart_id, "Trend Line", OBJ_TREND, 0, position_open_time, open_price, TimeCurrent(), ask);

// Set the color of the trend line
ObjectSetInteger(chart_id, "Trend Line", OBJPROP_COLOR, clrYellow);

// Set the style of the trend line to dashed
ObjectSetInteger(chart_id, "Trend Line", OBJPROP_STYLE, STYLE_DASH);

// Set the width of the trend line
ObjectSetInteger(chart_id, "Trend Line", OBJPROP_WIDTH, 2);

      Salida:

      Figura 14. Línea de tendencia con datos de posiciones abiertas

      3.1.3. Agregar etiquetas de texto

      En esta fase le daremos al gráfico cuatro etiquetas de texto distintas. El precio de entrada, el take-profit (TP), el stop-loss (SL) y el beneficio actual se mostrarán en estas etiquetas. Estos parámetros comerciales cruciales tendrán referencias visuales distintas para cada etiqueta en el gráfico, lo que hará más sencillo controlar el estado de la transacción directamente desde el gráfico.

      Ejemplo: 
      // Variables to store position details
double open_price;          // Variable to store the entry price of the position
double stop_loss;           // Variable to store the Stop Loss level of the position
double take_profit;         // Variable to store the Take Profit level of the position
datetime position_open_time; // Variable to store the open time of the position


// Define the position index for the first position
input int position_index  = 1; // POSITION INDEX (Index starts from 0)

// Get the ID of the current chart
long chart_id = ChartID();  // Store the ID of the current chart

string time = "23:59";      // Define a specific time as a string

// Define the color for the losing zone
input color sl_zonez_color   = clrPink; // Choose a color for Losing Zone

// Define the color for the winning zone
input color tp_zonez_color   = clrSpringGreen; // Choose a color for Winning Zone

// Define the color for the trend line
input color line_zonez_color = clrYellow; // Choose a color for the line


//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {

// Get the current ask price
   double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);

// Convert the string time to datetime
   datetime close_zone = StringToTime(time);

// Loop through all open positions
   for(int i = 0; i < PositionsTotal(); i++)
     {
      // Get the ticket number of the position at index 'i'
      ulong ticket = PositionGetTicket(i);

      // Check if the position matches the specified index and symbol of the current chart
      if(PositionGetInteger(POSITION_TICKET) == PositionGetTicket(position_index) && PositionGetString(POSITION_SYMBOL) == ChartSymbol(chart_id))
        {

         // Retrieve and store the entry price of the position
         open_price = PositionGetDouble(POSITION_PRICE_OPEN);

         // Retrieve and store the Stop Loss level of the position
         stop_loss = PositionGetDouble(POSITION_SL);

         // Retrieve and store the Take Profit level of the position
         take_profit = PositionGetDouble(POSITION_TP);

         // Retrieve and store the open time of the position
         position_open_time = (int)PositionGetInteger(POSITION_TIME);



         if(stop_loss > 0)
           {
            // Create a rectangle to represent the Stop Loss (SL) zone on the chart
            ObjectCreate(chart_id, "SL Zone", OBJ_RECTANGLE, 0, position_open_time, open_price, close_zone, stop_loss);
           }

         if(take_profit > 0)
           {
            // Create a rectangle to represent the Take Profit (TP) zone on the chart
            ObjectCreate(chart_id, "TP zone", OBJ_RECTANGLE, 0, position_open_time, open_price, close_zone, take_profit);
           }

         // Set properties for the SL zone rectangle
         ObjectSetInteger(chart_id, "SL Zone", OBJPROP_COLOR, sl_zonez_color); // Set color to the selected SL zone color
         ObjectSetInteger(chart_id, "SL Zone", OBJPROP_STYLE, STYLE_SOLID);    // Set style to solid
         ObjectSetInteger(chart_id, "SL Zone", OBJPROP_WIDTH, 1);              // Set the width of the rectangle border
         ObjectSetInteger(chart_id, "SL Zone", OBJPROP_FILL, sl_zonez_color);  // Fill the rectangle with the selected SL zone color
         ObjectSetInteger(chart_id, "SL Zone", OBJPROP_BACK, true);            // Set the rectangle to appear behind the chart objects

         // Set properties for the TP zone rectangle
         ObjectSetInteger(chart_id, "TP zone", OBJPROP_COLOR, tp_zonez_color); // Set color to the selected TP zone color
         ObjectSetInteger(chart_id, "TP zone", OBJPROP_STYLE, STYLE_SOLID);    // Set style to solid
         ObjectSetInteger(chart_id, "TP zone", OBJPROP_WIDTH, 1);              // Set the width of the rectangle border
         ObjectSetInteger(chart_id, "TP zone", OBJPROP_FILL, tp_zonez_color);  // Fill the rectangle with the selected TP zone color
         ObjectSetInteger(chart_id, "TP zone", OBJPROP_BACK, true);            // Set the rectangle to appear behind the chart objects

         // Create a trend line object on the chart from the position's open time and price to the current time and ask price
         ObjectCreate(chart_id, "Trend Line", OBJ_TREND, 0, position_open_time, open_price, TimeCurrent(), ask);

         // Set Trend Line properties
         ObjectSetInteger(chart_id, "Trend Line", OBJPROP_COLOR, line_zonez_color);
         ObjectSetInteger(chart_id, "Trend Line", OBJPROP_STYLE, STYLE_DASH);
         ObjectSetInteger(chart_id, "Trend Line", OBJPROP_WIDTH, 2);



         // Calculate the profit of the current position
         double profit = PositionGetDouble(POSITION_PROFIT);

         // Variables to store the formatted profit text
         string curent_profits;
         string profit_to_string;

         // Check if the profit is positive or zero
         if(profit >= 0)
           {
            // Convert the profit to a string with 2 decimal places
            profit_to_string = DoubleToString(profit, 2);
            // Format the profit as a positive amount with a '+' sign
            curent_profits = StringFormat("+$%s", profit_to_string);
           }
         // Check if the profit is negative
         else
            if(profit < 0)
              {
               // Convert the negative profit to a positive number
               double profit_to_positive = MathAbs(profit);
               // Convert the positive profit to a string with 2 decimal places
               profit_to_string = DoubleToString(profit_to_positive, 2);
               // Format the profit as a negative amount with a '-' sign
               curent_profits = StringFormat("-$%s", profit_to_string);
              }

         // Create a text label on the chart to display the current profit
         string text_object_name = "Profit";
         ObjectCreate(chart_id, text_object_name, OBJ_TEXT, 0, TimeCurrent(), ask);
         ObjectSetString(chart_id, text_object_name, OBJPROP_TEXT, curent_profits);

         // Set the color of the profit text based on whether the profit is positive or negative
         if(profit > 0)
           {
            ObjectSetInteger(chart_id, text_object_name, OBJPROP_COLOR, clrMediumBlue); // Positive profit in blue
           }
         else
            if(profit < 0)
              {
               ObjectSetInteger(chart_id, text_object_name, OBJPROP_COLOR, clrRed); // Negative profit in red
              }

         // Display the Take Profit (TP) level on the chart
         string tp_display = "TP";
         string t_display = StringFormat("Take Profit: %.5f", take_profit);
         ObjectCreate(chart_id, tp_display, OBJ_TEXT, 0, close_zone, take_profit);
         ObjectSetString(chart_id, tp_display, OBJPROP_TEXT, t_display);
         ObjectSetInteger(chart_id, tp_display, OBJPROP_COLOR, clrBlue); // TP text in blue
         ObjectSetInteger(chart_id, tp_display, OBJPROP_FONTSIZE, 8); // Set font size for TP

         // Display the Stop Loss (SL) level on the chart
         string sl_display = "SL";
         string s_display = StringFormat("Stop Loss: %.5f", stop_loss);
         ObjectCreate(chart_id, sl_display, OBJ_TEXT, 0, close_zone, stop_loss);
         ObjectSetString(chart_id, sl_display, OBJPROP_TEXT, s_display);
         ObjectSetInteger(chart_id, sl_display, OBJPROP_COLOR, clrRed); // SL text in red
         ObjectSetInteger(chart_id, sl_display, OBJPROP_FONTSIZE, 8); // Set font size for SL

         // Display the Entry Price on the chart
         string en_display = "Entry Price";
         string e_display = StringFormat("Entry Point: %.5f", open_price);
         ObjectCreate(chart_id, en_display, OBJ_TEXT, 0, close_zone, open_price);
         ObjectSetString(chart_id, en_display, OBJPROP_TEXT, e_display);
         ObjectSetInteger(chart_id, en_display, OBJPROP_COLOR, clrPaleVioletRed); // Entry Price text in pale violet red
         ObjectSetInteger(chart_id, en_display, OBJPROP_FONTSIZE, 8); // Set font size for Entry Price


        }
     }

  }

      Explicación:

      Este fragmento de código pretende mostrar datos comerciales importantes directamente en el gráfico. Calcula la ganancia posicional actual y la presenta como una etiqueta de texto, mostrando la ganancia en rojo para una ganancia negativa y azul para una ganancia positiva. Para distinguir visualmente el nivel TP, el nivel SL y el precio de entrada, también inserta etiquetas de texto para cada uno. Estas etiquetas tienen diferentes colores. Las etiquetas se han colocado en el gráfico para facilitar que los operadores identifiquen rápidamente los niveles fundamentales y el estado de ganancias actual de su posición.

      Salida:

      Figura 15. Creación de etiquetas de texto con datos de puestos vacantes

      3.2. Creación de objetos de gráfico para datos históricos

      El capítulo 3 ha cubierto hasta ahora la creación de objetos gráficos que simbolizan la posición actual. Ahora nos centraremos en el tratamiento de registros históricos, lo que nos permitirá ver las tendencias y los datos comerciales históricos en el gráfico. Esto nos permitirá examinar transacciones anteriores y aplicar el conocimiento histórico a los planes comerciales actuales.

      Ejemplo: 
      // Define the position index for the first position
input int position_index  = 1; // POSITION INDEX (Index starts from 0)

// Get the ID of the current chart
long chart_id = ChartID();  // Store the ID of the current chart

string time = "23:59";      // Define a specific time as a string

// Define the color for the losing zone
input color sl_zonez_color   = clrPink; // Choose a color for Losing Zone

// Define the color for the winning zone
input color tp_zonez_color   = clrSpringGreen; // Choose a color for Winning Zone

// Define the color for the trend line
input color line_zonez_color = clrYellow; // Choose a color for the line

// Define whether to show past history or not
input string show_history = "no"; // Type yes to show past history

// Define the start date to show history
input datetime date1 = D'1970.08.10 00:00:00'; // Show history from this date

// Define the end date to show history
input datetime date2 = D'2024.08.15 00:00:00'; // To this date


//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {

// Check if history display is enabled
   if(show_history == "yes")
     {
      Comment(""); // Clear previous comments

      // Select deal history within the specified date range
      bool deal_history = HistorySelect(date1, date2);

      // Variables to store deal details
      double deal_close_price = 0.0;
      double deal_open_price = 0.0;
      double deal_sl = 0.0;
      double deal_tp = 0.0;
      double deal_profit = 0.0;
      datetime deal_close_time = 0;
      datetime deal_open_time = 0;

      // Check if deal history is available
      if(deal_history)
        {
         // Loop through all history deals
         for(int i = 0; i < HistoryDealsTotal(); i++)
           {
            ulong ticket = HistoryDealGetTicket(i);

            // Check for deal entry in
            if(HistoryDealGetInteger(ticket, DEAL_ENTRY) == DEAL_ENTRY_IN)
              {
               if(HistoryDealGetString(ticket, DEAL_SYMBOL) == ChartSymbol(chart_id))
                 {
                  deal_open_price = HistoryDealGetDouble(ticket, DEAL_PRICE);
                  deal_open_time = (datetime)HistoryDealGetInteger(ticket, DEAL_TIME);
                 }
              }

            // Check for deal entry out
            if(HistoryDealGetInteger(ticket, DEAL_ENTRY) == DEAL_ENTRY_OUT)
              {
               deal_profit = HistoryDealGetDouble(ticket, DEAL_PROFIT);
               deal_close_price = HistoryDealGetDouble(ticket, DEAL_PRICE);
               deal_sl = HistoryDealGetDouble(ticket, DEAL_SL);
               deal_tp = HistoryDealGetDouble(ticket, DEAL_TP);
               deal_close_time = (datetime)HistoryDealGetInteger(ticket, DEAL_TIME);

               if(HistoryDealGetString(ticket, DEAL_SYMBOL) == ChartSymbol(chart_id))
                 {
                  string deal_string;
                  string current_deal_profit;
                  string object_name;

                  // Display deal profit/loss
                  if(deal_profit > 0)
                    {
                     deal_string = DoubleToString(deal_profit, 2);
                     current_deal_profit = StringFormat("YOU WON +$%s", deal_string);
                     object_name = StringFormat("PROFIT %d", i);
                     ObjectCreate(chart_id, object_name, OBJ_TEXT, 0, deal_close_time, deal_close_price);
                     ObjectSetString(chart_id, object_name, OBJPROP_TEXT, current_deal_profit);
                     ObjectSetInteger(chart_id, object_name, OBJPROP_COLOR, clrMediumBlue);
                     ObjectSetInteger(chart_id, object_name, OBJPROP_FONTSIZE,8);
                    }
                  else
                     if(deal_profit < 0)
                       {
                        double deal_to_positive = MathAbs(deal_profit);
                        deal_string = DoubleToString(deal_to_positive, 2);
                        object_name = StringFormat("PROFIT %d", i);
                        current_deal_profit = StringFormat("YOU LOST -$%s", deal_string);
                        ObjectCreate(chart_id, object_name, OBJ_TEXT, 0, deal_close_time, deal_close_price);
                        ObjectSetString(chart_id, object_name, OBJPROP_TEXT, current_deal_profit);
                        ObjectSetInteger(chart_id, object_name, OBJPROP_COLOR, clrRed);
                        ObjectSetInteger(chart_id, object_name, OBJPROP_FONTSIZE,8);
                       }

                  // Display deal SL zone
                  string sl_obj_name = StringFormat("SL ZONE %d", i);
                  if(deal_sl > 0)
                    {
                     ObjectCreate(chart_id, sl_obj_name, OBJ_RECTANGLE, 0, deal_open_time, deal_open_price, deal_close_time, deal_sl);
                    }
                  ObjectSetInteger(chart_id, sl_obj_name, OBJPROP_COLOR, sl_zonez_color);
                  ObjectSetInteger(chart_id, sl_obj_name, OBJPROP_STYLE, STYLE_SOLID);
                  ObjectSetInteger(chart_id, sl_obj_name, OBJPROP_WIDTH, 1);
                  ObjectSetInteger(chart_id, sl_obj_name, OBJPROP_FILL, sl_zonez_color);
                  ObjectSetInteger(chart_id, sl_obj_name, OBJPROP_BACK, true);

                  // Display deal TP zone
                  string tp_obj_name = StringFormat("TP ZONE %d", i);
                  if(deal_tp > 0)
                    {
                     ObjectCreate(chart_id, tp_obj_name, OBJ_RECTANGLE, 0, deal_open_time, deal_open_price, deal_close_time, deal_tp);
                    }
                  ObjectSetInteger(chart_id, tp_obj_name, OBJPROP_COLOR, tp_zonez_color);
                  ObjectSetInteger(chart_id, tp_obj_name, OBJPROP_STYLE, STYLE_SOLID);
                  ObjectSetInteger(chart_id, tp_obj_name, OBJPROP_WIDTH, 1);
                  ObjectSetInteger(chart_id, tp_obj_name, OBJPROP_FILL, tp_zonez_color);
                  ObjectSetInteger(chart_id, tp_obj_name, OBJPROP_BACK, true);

                  // Display deal trend line
                  string line_obj_name = StringFormat("line %d", i);
                  ObjectCreate(chart_id, line_obj_name, OBJ_TREND, 0, deal_open_time, deal_open_price, deal_close_time, deal_close_price);
                  ObjectSetInteger(chart_id, line_obj_name, OBJPROP_COLOR, line_zonez_color);
                  ObjectSetInteger(chart_id, line_obj_name, OBJPROP_STYLE, STYLE_DASH);
                  ObjectSetInteger(chart_id, line_obj_name, OBJPROP_WIDTH, 2);


                 }
              }
           }
        }
     }

  }

      Explicación:

      Esta sección de código evalúa inicialmente la variable show_history para ver si la funcionalidad de visualización del historial está activada. Si se selecciona «yes», el código utiliza Comment(«») para eliminar cualquier comentario anterior del gráfico, dejando visibles sólo los datos más recientes. Luego, el resultado se almacena en la variable booleana deal_history. A continuación, se utiliza el método HistorySelect(date1, date2) para elegir las operaciones históricas dentro del intervalo de fechas indicado. Podemos utilizar datos históricos de negociación con esta selección. Los datos relativos a cada acuerdo anterior se almacenan entonces en varias variables. Los precios de cierre y apertura de la operación se registran en deal_close_price y deal_open_price. Los valores «deal_sl» y «deal_tp» se utilizan para registrar los valores de Take Profit y Stop Loss. Los datos «deal_close_time» y «deal_open_time» documentan los periodos de cierre y apertura de la operación, así como «deal_profit», que hace un seguimiento de los beneficios o pérdidas de la operación.

      El código determina si se puede acceder al historial de operaciones. En caso afirmativo, inicia un bucle que utiliza HistoryDealGetTicket(i) para recuperar el número de ticket de cada trato mientras recorre todos los tratos posibles. Diferencia entre ofertas de entrada y de salida para cada ticket. Mientras que las operaciones de salida ofrecen los valores de precio de cierre, beneficio, stop loss y take profit, las operaciones de entrada se utilizan para registrar el precio y la hora de apertura. Estos datos específicos se utilizan para generar varios elementos gráficos, como líneas de tendencia que muestran el movimiento del precio durante la transacción, etiquetas de texto que indican ganancias o pérdidas, y rectángulos que representan las zonas de toma de beneficios y stop-loss. Este método garantiza que los datos comerciales históricos se muestren en la pantalla de manera eficiente, brindando información importante sobre el rendimiento anterior.

      Salida:

      Figura 16. Historia


      Conclusión

      En este artículo, exploramos el trabajo con objetos en MQL5, centrándonos en la construcción y modificación de elementos de gráficos para mejorar el análisis comercial. Hemos tratado la creación de rectángulos para las zonas de toma de beneficios y stop-loss, líneas de tendencia para seguir los cambios de precios y etiquetas de texto para los datos de negociación importantes. También examinamos cómo mostrar las operaciones anteriores mediante etiquetas y ayudas visuales, ofreciendo una imagen clara del rendimiento histórico.

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

      Archivos adjuntos |
      Descargar ZIP
      MQL5OBJECTS_PROJECT3.mq5 (14.86 KB)
      Advertencia: todos los derechos de estos materiales pertenecen a MetaQuotes Ltd. Queda totalmente prohibido el copiado total o parcial.

      Otros artículos del autor

      Pasar a la discusión en el foro de los operadores
      Optimización del búfalo africano - African Buffalo Optimization (ABO) Optimización del búfalo africano - African Buffalo Optimization (ABO)
      El artículo se centra en el algoritmo de optimización del búfalo africano (ABO), un enfoque metaheurístico desarrollado en 2015 y basado en el comportamiento único de estos animales. El artículo detalla los pasos de implementación del algoritmo y su eficacia a la hora de encontrar soluciones a problemas complejos, lo cual lo convierte en una valiosa herramienta en el campo de la optimización.
      Redes neuronales en el trading: Segmentación guiada Redes neuronales en el trading: Segmentación guiada
      Hoy proponemos al lector familiarizarse con el método de análisis multimodal complejo de interacción y comprensión de características.
      Características del Wizard MQL5 que debe conocer (Parte 37): Regresión de procesos gaussianos con núcleos Matérn y lineales Características del Wizard MQL5 que debe conocer (Parte 37): Regresión de procesos gaussianos con núcleos Matérn y lineales
      Los núcleos lineales son la matriz más simple de su tipo utilizada en el aprendizaje automático para regresión lineal y máquinas de vectores de soporte. Por otro lado, el kernel Matérn es una versión más versátil de la función de base radial que analizamos en un artículo anterior, y es apto para mapear funciones que no son tan suaves como asumiría la RBF. Creamos una clase de señal personalizada que utiliza ambos núcleos para pronosticar condiciones largas y cortas.
      Predicción de tipos de cambio mediante métodos clásicos de aprendizaje automático: Modelos Logit y Probit Predicción de tipos de cambio mediante métodos clásicos de aprendizaje automático: Modelos Logit y Probit
      Hoy hemos intentado construir un experto comercial para predecir las cotizaciones de los tipos de cambio. El algoritmo se basa en modelos de clasificación clásicos: la regresión logística y probit. Como filtro para las señales comerciales, hemos utilizado el criterio de la razón de verosimilitud.