Trabajamos con fechas y horas en MQL5

Introducción

Nadie en el mercado financiero oculta la importancia del tiempo y cómo este puede influir en las decisiones y los resultados comerciales. MQL5 (MetaQuotes Language 5) ofrece una solución para trabajar eficazmente con la fecha y la hora. Podemos abordar este importante tema con una amplia variedad de aplicaciones que se pueden programar como parte de nuestro sistema comercial, pero primero veremos los aspectos más importantes de este tema en el lenguaje de programación MQL5.

En este artículo abarcaremos los siguientes temas:

• Tipo datetime
• Estructura MqlDateTime
• Evento OnTimer
• Aplicación de NewBar
• Aplicación de un filtro temporal
• Aplicación de tradeAtTime
• Conclusión

Después de leer el artículo, podrá usar los datos de fecha y hora en mql5 para desarrollar sus aplicaciones. Espero que encuentre útil el artículo.

¡Atención! Toda la información del presente artículo se ofrece «tal cual», únicamente con fines ilustrativos, y no supone ningún tipo de recomendación. El artículo no garantiza ningún resultado en absoluto. Todo lo que ponga en práctica usando este artículo como base, lo hará bajo su propia cuenta y riesgo; el autor no garantiza resultado alguno.

Tipo datetime

El tipo de variable datetime en mql5 se usa para clasificar los datos de fecha y hora en formato Unix. El tiempo Unix es el número de segundos que han pasado desde el 1 de enero de 1970. Dicho de otra forma: si convertimos la fecha 01 de enero de 2023 a las 00:00:00 GMT en hora Unix, encontraremos que es igual a 1672531200 segundos. Como consecuencia, la marca temporal será el número de segundos entre una fecha determinada y la época Unix, es decir, el 1 de enero de 1970. También podemos ver el tiempo en segundos comparado con el tiempo legible conocido de esta forma:

Tiempo de lectura conocido	Segundos
1 año	31 556 926 segundos
1 mes	2 629 743 segundos
1 semana	604 800 segundos
1 día	86 400 segundos
1 hora	3600 segundos

Podrá obtener más información sobre la hora de Unix en el artículo correspondiente de la Wikipedia.

Podemos determinar fácilmente una fecha y hora específicas utilizando la constante de fecha y hora, que comienza con el carácter D con la fecha y hora entre comillas simples:

D'yyyy.mm.dd hh:mm:ss'

O así:

D'dd.mm.yyyy hh:mm:ss'

Podemos encontrar útiles los siguientes ejemplos de la guía de mql5:

datetime NY=D'2015.01.01 00:00';     // Time of beginning of year 2015
datetime d1=D'1980.07.19 12:30:27';  // Year Month Day Hours Minutes Seconds
datetime d2=D'19.07.1980 12:30:27';  // Equal to D'1980.07.19 12:30:27';
datetime d3=D'19.07.1980 12';        // Equal to D'1980.07.19 12:00:00'
datetime d4=D'01.01.2004';           // Equal to D'01.01.2004 00:00:00'
datetime compilation_date=__DATE__;             // Compilation date
datetime compilation_date_time=__DATETIME__;    // Compilation date and time
datetime compilation_time=__DATETIME__-__DATE__;// Compilation time
//--- Examples of declarations after which compiler warnings will be returned
datetime warning1=D'12:30:27';       // Equal to D'[date of compilation] 12:30:27'
datetime warning2=D'';               // Equal to __DATETIME__

A continuación le mostramos los resultados después de la compilación:

El tipo datetime almacena los valores de fecha y hora en segundos. Esto facilita la comparación y gestión de valores de fecha y hora. A continuación veremos algunos ejemplos de lo que podemos hacer cuando trabajamos con valores de fecha y hora:

• Comparación de los valores de fecha y hora.
• Adición o resta de valores de fecha y hora.
• Convierta una fecha y hora en cadena o una cadena en fecha y hora para diferentes propósitos.

Comparación de valores de fecha y hora:

Si tenemos dos valores de fecha y hora y necesitamos compararlos, podemos hacerlo en MQL5 creando una variable para cada valor y luego comparándolos entre sí para efectuar una acción basada en el resultado. A continuación le ofrecemos un ejemplo:

Si el usuario introduce dos valores de fecha y hora, uno será más antiguo que el otro y queremos obtener un resultado específico, por ejemplo, los datos de salida; si el valor de entrada es mayor que el segundo, deberemos obtener el mensaje Input one is a recent time (el primer valor de entrada es una hora reciente), pero si el primer valor de entrada es menor que el segundo, deberemos obtener el mensaje Input two is a recent time.

A continuación le mostramos el código para hacer esto:

//+------------------------------------------------------------------+
//|                                              dateTimeCompare.mq5 |
//+------------------------------------------------------------------+
input datetime inpDate1 = D'2023.09.01 00:00';
input datetime inpDate2 = D'2023.09.30 00:00';
//+------------------------------------------------------------------+
void OnTick()
  {
   if(inpDate1>inpDate2)
     {
      Print("Input one is a recent time");
     }
   else
      if(inpDate1<inpDate2)
        {
         Print("Input two is a recent time");
        }
  }
//+------------------------------------------------------------------+

Si después de compilar el código configuramos los valores de fecha y hora de entrada de la siguiente forma:

Como podemos ver, el primer valor de entrada es anterior al segundo. Así podremos encontrar un resultado similar al siguiente:

Si cambiamos el primer valor de entrada por uno posterior, el segundo será similar al que sigue:

Según la configuración de los parámetros de entrada anteriores, deberíamos encontrar un resultado similar a este:

El ejemplo de código anterior es un ejemplo de cómo podemos gestionar la fecha y la hora.

Suma o resta de valores de fecha y hora:

También podemos sumar y restar valores de fecha y hora. Digamos que tenemos dos valores de fecha y hora:

D'2023.09.01 00:00'
D'2023.09.30 00:00'

Ahora necesitamos sumar un día al primer valor y restar un día al segundo. Un día en segundos equivale a 86 400. Entonces después de estas dos transacciones podremos encontrar los nuevos valores:

D'2023.09.02 00:00'
D'2023.09.29 00:00'

El siguiente código describe cómo codificar estas transacciones:

//+------------------------------------------------------------------+
//|                                           dateTimeManipulate.mq5 |
//+------------------------------------------------------------------+
input datetime oldDate = D'2023.09.01 00:00';
input datetime newDate = D'2023.09.30 00:00';
//+------------------------------------------------------------------+
void OnTick()
  {
   datetime addToDate =   oldDate+86400;
   Print("Result of date addition - ",addToDate);
   datetime subtractFromDate =   newDate-86400;
   Print("Result of date subtraction - ",subtractFromDate);
  }
//+------------------------------------------------------------------+

El resultado de la ejecución de este software será el mismo que ya mencionamos:

Conversión de tiempo en cadena o de una cadena en tiempo para diferentes propósitos:

Es posible que necesitemos convertir el tipo de valores de fecha y hora. Por el momento disponemos de dos funciones que pueden ejecutar la conversión de cadena a tiempo y viceversa. TimeToString o StringToTime. Aquí veremos un ejemplo de cómo podemos gestionar un caso así:

//+------------------------------------------------------------------+
//|                                              dateTimeConvert.mq5 |
//+------------------------------------------------------------------+
input datetime oldDate = D'2023.09.01 00:00';
input string newDate = "2023.09.30 00:00";
//+------------------------------------------------------------------+
void OnTick()
  {
   string newOldDate = TimeToString(oldDate);
   datetime newNewDate = StringToTime(newDate);
   Print("Time To String - ",newOldDate);
   Print("String To Time - ",newNewDate);
  }
//+------------------------------------------------------------------+

Al ejecutar este código en el terminal comercial, podemos encontrar los valores de retorno para cada función, el primero para la conversión de TimeToString y el segundo para la conversión de StringToTime:

Si queremos conocer y comprender todas las operaciones con el tipo datetime en MQL5,

• currentTime retorna la hora actual.
• Comparación de valores: lógicamente utilizamos esta operación para comprobar la comparación de fechas y horas.
• Gestión de los datos de fecha y hora: suma y resta.
• formateo de fecha y hora.

Estructura MqlDateTime

En esta parte analizaremos la estructura de MqlDateTime. Contiene variables que pueden almacenar los datos de fecha y hora o los valores de fecha y hora. A continuación le mostramos una estructura similar a la que podemos encontrar en la guía de MQL5:

struct MqlDateTime
  {
   int year;           // Year
   int mon;            // Month
   int day;            // Day
   int hour;           // Hour
   int min;            // Minutes
   int sec;            // Seconds
   int day_of_week;    // Day of week (0-Sunday, 1-Monday, ... ,6-Saturday)
   int day_of_year;    // Day number of the year (January 1st is assigned the number value of zero)
  };

Como podemos ver, contiene ocho campos de variables de tipo int.

Usaremos la función (TimeToStruct) con esta estructura para convertir el valor de fecha y hora en la variable MqlDateTime. Parámetros de la función:

• dt - fecha y hora
• dt_struct - estructura para aceptar los valores

La función retorna un valor booleano.

También podemos usar la función (StructToTime) para convertir la variable de estructura MqlDateTime en un valor de fecha y hora. Su único parámetro será dt_struct. Retorna un tipo de fecha y hora que contendrá el número de segundos.

Podemos ver un ejemplo de esta estructura MqlDateTime similar al siguiente:

Si tenemos datetime D'2023.10.10 07:07:07' o cualquier otro valor de entrada, necesitaremos usar MqlDateTime con él. Podemos hacer esto con el código que sigue:

//+------------------------------------------------------------------+
//|                                                  MqlDateTime.mq5 |
//+------------------------------------------------------------------+
input datetime dtData = D'2023.10.10 07:07:07';
void OnTick()
  {
   MqlDateTime timeStruct;
   TimeToStruct(dtData,timeStruct);
   int year = timeStruct.year;
   Print("year: ",year);
   Print("=====================");
   int month = timeStruct.mon;
   Print("month: ",month);
   Print("=====================");
   int day = timeStruct.day;
   Print("day: ",day);
   Print("=====================");
   int hour = timeStruct.hour;
   Print("hour: ",hour);
   Print("=====================");
   int minute = timeStruct.min;
   Print("minute: ",minute);
   Print("=====================");
   int second = timeStruct.sec;
   Print("second: ",second);
   Print("=====================");
   int dayofWeek = timeStruct.day_of_week;
   Print("dayofWeek: ",dayofWeek);
   Print("=====================");
   int dayofYear = timeStruct.day_of_year;
   Print("dayofYear: ",dayofYear);
  }
//+------------------------------------------------------------------+

Al ejecutar este asesor podemos encontrar mensajes impresos como los siguientes:

Aquí resulta útil tener en cuenta que el valor predeterminado de mes o día será 01 si utilizamos menos de 1 como entrada. El valor de mes máximo predeterminado es 12, mientras que el valor de día predeterminado es 31, si el parámetro de entrada utilizado es mayor que este valor máximo. Los valores por defecto para la hora serán un mínimo de 0 o un máximo de 23, y para los minutos un mínimo de 0 o un máximo de 59.

Evento OnTimer()

En esta parte, veremos qué es el manejador de eventos OnTimer() y cómo usarlo. Podemos utilizarlo cuando necesitemos ejecutar nuestro código o estrategia comercial cada cierto número de segundos. Entonces, si deseamos que nuestro código realice una determinada acción después de un cierto intervalo temporal, podemos colocar nuestro código en el manejador de eventos OnTimer().

El manejador de eventos OnTimer() es un tipo void sin parámetros y podemos añadirlo a nuestro código si lo necesitamos. Para usarlo, necesitaremos configurar el intervalo del temporizador en la parte OnInit() usando la función EventSetTimer() con el parámetro segundos, como en el ejemplo siguiente:

int OnInit()
{
EventSetTimer(60);
}

El ejemplo anterior implica que el código del manejador de eventos OnTimer() se ejecutará cada 60 segundos.

Ahora, si necesitamos detener la ejecución de código dentro del evento OnTimer(), podremos hacerlo usando la función void EventKillTimer() en el manejador de eventos o el destructor de clases onDeinit().

Aplicación de NewBar

En esta aplicación, crearemos un archivo de inclusión que contendrá las clases y funciones que se pueden usar en otros archivos, tales como los asesores. La aplicación nos indicará si tenemos una barra nueva imprimiendo el mensaje "A new bar painted" (se ha pintado una nueva barra).

Primero, los siguientes pasos serán para crear un archivo de inclusión. Aquí, la idea principal de crear un archivo de inclusión consiste en aprender a crear archivos que puedan usarse en muchos proyectos y trabajar como un desarrollador profesional si usted es un principiante.

Así, ahora vamos a declarar la clase CNewBar, que tendrá dos variables privadas: time[] para almacenar la hora de la barra actual y LastTime para almacenar la hora de la barra más reciente. Luego declararemos un método booleano de la clase newBarCheck con dos parámetros:

• el tipo string del símbolo
• el tipo timeframe ENUM_TIMEFRAMES

class CNewBar
  {
private:
   datetime          time[], lastTime;
public:
   void              CNewBar();
   bool              newBarCheck(string symbol, ENUM_TIMEFRAMES timeFrame);
  };

Establecemos un array de fecha y hora como una serie

void CNewBar::CNewBar(void)
  {
   ArraySetAsSeries(time,true);
  }

Creamos una función newBarCheck con dos parámetros (símbolo y marco temporal) para verificar la presencia o ausencia de una nueva barra. La función retornará un valor de tipo bool.

bool CNewBar::newBarCheck(string symbol, ENUM_TIMEFRAMES timeFrame)

El cuerpo de la función comprobará la presencia de una nueva barra. Se crearán dos variables booleanas para first y newBar con el valor predeterminado false.

   bool firstCheck = false;
   bool newBar = false;

Asimismo, usaremos la función CopyTime con opciones de llamada en la primera posición para obtener los datos históricos de time_array del tiempo de apertura de la barra del par símbolo-periodo especificado en la cantidad especificada. Parámetros:

• symbol_name - nombre del símbolo como una línea específica en la función.
• timeframe - marco temporal timeFrame definido por ENIM_TIMEFRAMES en la función.
• start_pos - la posición inicial es 0.
• count - los datos a copiar son iguales a 2.
• time_array[] - el array desde el que se debe copiar la hora de apertura será un array de tiempo.

CopyTime(symbol,timeFrame,0,2,time);

Vamos a comprobar la variable de clase LastTime. Si esta es la primera verificación, entonces el valor de la variable LastTime será igual a 0, entonces, la variable firstCheck será igual a true.

   if(lastTime == 0)
     {
      firstCheck = true;
     }

Después comprobaremos si el valor de time[0] es mayor que el valor de LastTime y comprobaremos si el valor de firstCheck es false, por lo que newBar será igual a true, entonces LastTime tendrá el mismo valor que time[0]

   if(time[0] > lastTime)
     {
      if(firstCheck == false)
      {
         newBar = true;
      }
      lastTime = time[0];
     }

Retornaremos el valor newBar, que será un valor booleano.

return(newBar);

A continuación mostraremos el código completo en un bloque:

//+------------------------------------------------------------------+
//|                                                       newBar.mqh |
//+------------------------------------------------------------------+
class CNewBar
  {
private:
   datetime          time[], lastTime;
public:
   void              CNewBar();
   bool              newBarCheck(string symbol, ENUM_TIMEFRAMES timeFrame);
  };
//+------------------------------------------------------------------+
void CNewBar::CNewBar(void)
  {
   ArraySetAsSeries(time,true);
  }
//+------------------------------------------------------------------+
bool CNewBar::newBarCheck(string symbol, ENUM_TIMEFRAMES timeFrame)
  {
   bool firstCheck = false;
   bool newBar = false;
   CopyTime(symbol,timeFrame,0,2,time);
   if(lastTime == 0)
     {
      firstCheck = true;
     }
   if(time[0] > lastTime)
     {
      if(firstCheck == false)
      {
         newBar = true;
      }
      lastTime = time[0];
     }
   return(newBar);
  }
//+------------------------------------------------------------------+

Si quiere aprender más sobre la programación orientada a objetos y las clases en MQL5, puede leer mi artículo anterior"Programación orientada a objetos (POO) en MQL5". Espero que le sea útil.

Ahora, tras crear el archivo de inclusión, crearemos nuestro asesor, que detectará una nueva barra y mostrará el mensaje "A new bar painted, you can trade" (se ha dibujado una nueva barra, puede comerciar). Primero, incluiremos el archivo de inclusión creado en el código del asesor usando el preprocesador #include.

#include <dateTime.mqh>

Luego declararemos un objeto de la clase CNewBar.

CNewBar NewBar;

Crearemos una variable bool como entrada para seleccionar si comerciaremos al dibujar una nueva barra (true) o no (false).

bool newBarTrade=true;

Después de eso, en la parte de OnTick(), crearemos la variable bool newBar con un valor predeterminado true y otra variable entera barShift con el valor predeterminado 0.

   bool newBar=true;
   int barShift=0;

Luego verificaremos si el valor de newBarTrade es true, entonces newBar será igual a Newbarobject.newBarCheck con los parámetros del símbolo y marco temporal actuales, y barShift será igual a 1.

   if(newBarTrade==true)
     {
      newBar = NewBar.newBarCheck(Symbol(),Period());
      barShift=1;
     }

Nos aseguraremos de que newBar sea true. Esto significará que se ha generado una nueva barra, por lo que deberemos obtener el mensaje "A new bar painted, you can trade".

   if(newBar==true)
     {
      Print("A new bar painted, you can trade");
     }

A continuación le mostramos el código completo de esta aplicación de código

//+------------------------------------------------------------------+
//|                                                       newBar.mq5 |
//+------------------------------------------------------------------+
#include <dateTime.mqh>
CNewBar NewBar;
bool newBarTrade=true;
//+------------------------------------------------------------------+
void OnTick()
  {
   bool newBar=true;
   int barShift=0;
   if(newBarTrade==true)
     {
      newBar = NewBar.newBarCheck(Symbol(),Period());
      barShift=1;
     }
   if(newBar==true)
     {
      Print("A new bar painted, you can trade");
     }
  }
//+------------------------------------------------------------------+

Después de ejecutar este asesor podremos obtener el siguiente resultado después de crear una nueva barra

El código se puede desarrollar para cambiar la acción al dibujar una nueva barra según nuestra estrategia, como abrir una operación o cualquier otra cosa, pero en este artículo compartiremos un código simple para comprender la idea básica.

Aplicación de un filtro temporal

En esta aplicación, necesitaremos crear una aplicación para permitir o no permitir el comercio según un filtro de tiempo o un periodo de tiempo específico. Así, añadiremos una nueva clase CTimeFilter al archivo de inclusión creado y crearemos una función lógica pública timeCheck con tres parámetros (startTime, endTime, localTime con el valor predeterminado false).

class CTimeFilter
  {
public:
   bool timeCheck(datetime startTime, datetime endTime, bool localTime = false);
  };

Luego crearemos el cuerpo de la función timeCheck, verificaremos si los datos de entrada se han introducido de forma incorrecta haciendo que startTime sea mayor o igual que endTime y luego retornaremos la advertencia de error "Error: Invalid Time input" ("Error: entrada de tiempo no válida") y false

   if(startTime >= endTime)
     {
      Alert("Error: Invalid Time input");
      return(false);
     }

Crearemos una variable de fecha y hora para hora actual y luego verificaremos si localTime es true. TimeLocal() se asignará a currentTime o TimeCurrent() se asignará a currentTime

   datetime currentTime;
   if(localTime == true)
     {
      currentTime = TimeLocal();
     }
   else
      currentTime = TimeCurrent();

Crearemos una variable booleana llamada timeFilterActive con un valor predeterminado de false, luego verificaremos si currentTime es mayor o igual que startTime y al mismo tiempo menor que endTime, luego retornaremos true para timeFilterActive. Retornaremos el valor de timeFilterActive

   bool timeFilterActive = false;
   if(currentTime >= startTime && currentTime < endTime)
     {
      timeFilterActive = true;
     }
   return(timeFilterActive);

A continuación le mostramos el código completo en el archivo de inclusión

class CTimeFilter
  {
public:
   bool timeCheck(datetime startTime, datetime endTime, bool localTime = false);
  };
bool CTimeFilter::timeCheck(datetime startTime, datetime endTime, bool localTime = false)
  {
   if(startTime >= endTime)
     {
      Alert("Error: Invalid Time input");
      return(false);
     }
   datetime currentTime;
   if(localTime == true)
     {
      currentTime = TimeLocal();
     }
   else
      currentTime = TimeCurrent();
   bool timeFilterActive = false;
   if(currentTime >= startTime && currentTime < endTime)
     {
      timeFilterActive = true;
     }
   return(timeFilterActive);
  }

Después de crear el archivo de inclusión, crearemos nuestro asesor timeFilterApp realizando el siguiente paso:

Incluiremos el archivo dateTime para usar su contenido.

#include <dateTime.mqh>

 Y crearemos dos variables de fecha y hora como valores de entrada con el nombre StartTime y EndTime.

input datetime StartTime = D'2023.10.10 10:00';
input datetime EndTime = D'2023.10.10 17:00';

Asimismo, crearemos un objeto llamado filter en el ámbito global.

CTimeFilter filter;

En la parte OnTick(), crearemos timeFilterActive y le asignaremos filter.timeCheck con los parámetros.

bool timeFilterActive = filter.timeCheck(StartTime,EndTime,false);

Para verificar si timeFilterActive es true, deberemos recibir el mensaje "Trading is active based on time filter" ("El comercio está activo según el filtro de tiempo") o "Trading is inactive based on time filter" ("El comercio está inactivo según el filtro de tiempo").

   if(timeFilterActive == true)
     {
      Print("Trading is active based on time filter");
     }
     else Print("Trading is inactive based on time filter");

El código completo se verá así:

//+------------------------------------------------------------------+
//|                                                timeFilterApp.mq5 |
//+------------------------------------------------------------------+
#include <dateTime.mqh>
input datetime StartTime = D'2023.10.10 10:00';
input datetime EndTime = D'2023.10.10 17:00';
CTimeFilter filter;
void OnTick()
  {
   bool timeFilterActive = filter.timeCheck(StartTime,EndTime,false);
   if(timeFilterActive == true)
     {
      Print("Trading is active based on time filter");
     }
     else Print("Trading is inactive based on time filter");
  }

Tras ejecutar esta aplicación veremos uno de tres resultados dependiendo del tiempo introducido.

En el caso del tiempo activo:

En caso de tiempo inactivo:

Si los parámetros de entrada son falsos:

Existe otro método que podemos usar sin un archivo de inclusión. A continuación detallaremos los pasos que nos ayudarán a hacer esto.

Crearemos cuatro variables de entrada int para las horas y minutos iniciales y finales a escala global.

input int TimeStartHour = 
10 ;
input int TimeStartMin = 0;
input int TimeEndHour = 17;
input int TimeEndMin = 
0 ;

En la parte OnTick(), crearemos una variable structTime utilizando la función MqlDateTime, que contiene datos de fecha y hora.

MqlDateTime structTime;

Luego transmitiremos la variable structTime creada a la función TimeCurrent

TimeCurrent(structTime);

Y estableceremos los segundos en 0 horas y minutos para la hora de inicio

   structTime.sec = 0;
   structTime.hour = TimeStartHour;
   structTime.min = TimeStartMin;

Después crearemos una variable de fecha y hora para timeStart y transmitiremos structTime a la función StructToTime, que convierte la variable de estructura MqlDateTime en un valor de tipo fecha y hora y luego lo asigna a la variable timeStart.

datetime timeStart = StructToTime(structTime);

Asimismo, estableceremos las horas y minutos de la hora de finalización

   structTime.hour = TimeEndHour;
   structTime.min = TimeEndMin;

Y crearemos la variable timeEnd de la misma manera que hicimos con timeStart.

datetime timeEnd = StructToTime(structTime);

Luego crearemos la variable lógica isTime para determinar el tiempo permitido para comerciar.

bool isTime = TimeCurrent() >= timeStart && TimeCurrent() < timeEnd;

Después crearemos un mensaje de error en caso de entrada incorrecta

   if(TimeStartHour >= TimeEndHour)
     {
      Print("Error: Invalid Time input");
     }

Y estableceremos las condiciones del tiempo comercial

   if(isTime==true)
     {
      Print("Trading is active based on time filter");
     }
   else
      Print("Trading is inactive based on time filter");

El código completo se verá así:

//+------------------------------------------------------------------+
//|                                               timeFilterApp2.mq5 |
//+------------------------------------------------------------------+
input int TimeStartHour = 10;
input int TimeStartMin = 0;
input int TimeEndHour = 17;
input int TimeEndMin = 0;
//+------------------------------------------------------------------+
void OnTick()
  {
   MqlDateTime structTime;
   TimeCurrent(structTime);
   structTime.sec = 0;
   structTime.hour = TimeStartHour;
   structTime.min = TimeStartMin;
   datetime timeStart = StructToTime(structTime);
   structTime.hour = TimeEndHour;
   structTime.min = TimeEndMin;
   datetime timeEnd = StructToTime(structTime);
   bool isTime = TimeCurrent() >= timeStart && TimeCurrent() < timeEnd;
   if(TimeStartHour >= TimeEndHour)
     {
      Print("Error: Invalid Time input");
     }
   if(isTime==true)
     {
      Print("Trading is active based on time filter");
     }
   else
      Print("Trading is inactive based on time filter");
  }
//+------------------------------------------------------------------+

Después de ejecutar el código, veremos los siguientes resultados:

En el caso del tiempo activo:

En caso del tiempo comercial inactivo

En el caso de los valores de entrada no válidos

Aplicación de tradeAtTime

Digamos que necesitamos establecer un tiempo específico en el que solo necesitamos comerciar, así, deberemos establecer este tiempo como el tiempo permitido para comerciar: a continuación detallaremos los pasos necesarios para ello.

Crearemos una variable de entrada de cadena openTime con el valor predeterminado "10:00"

input string openTime="10:00";

Luego crearemos una variable de fecha y hora para LastTime

datetime lastTime;

En la parte de OnTick(), crearemos una variable datatime dtOpenTime para asignarle los valores StringToTime para openTime.

datetime dtOpenTime=StringToTime(openTime);

Después comprobaremos la condición de tiempo permitido. Si el último tiempo permitido no es igual a dtOpenTime y al mismo tiempo timeCurrent() es mayor que dtOpenTime, necesitaremos actualizar el valor de LastTime con dtOpenTime e imprimir el mensaje "Now is the allowed time to trade" ("Ahora es el momento permitido para comerciar"). Este mensaje aparecerá una vez a la hora establecida.

   if(lastTime !=dtOpenTime && TimeCurrent()>dtOpenTime)
     {
      lastTime=dtOpenTime;
      Print("Now is the allowed time to trade");
     }

A continuación le mostramos el código completo:

//+------------------------------------------------------------------+
//|                                                  tradeAtTime.mq5 |
//+------------------------------------------------------------------+
input string openTime="10:00";
datetime lastTime;
//+------------------------------------------------------------------+
void OnTick()
  {
   datetime dtOpenTime=StringToTime(openTime);
   if(lastTime !=dtOpenTime && TimeCurrent()>dtOpenTime)
     {
      lastTime=dtOpenTime;
      Print("Now is the allowed time to trade");
     }
  }
//+------------------------------------------------------------------+

Tras ejecutar el código, encontramos su señal:

Conclusión

Hoy hemos analizado qué son la fecha y la hora y cómo podemos gestionarlas en MQL5 al crear nuestras aplicaciones. Asimismo, hemos aplicado nuestro conocimiento para crear aplicaciones simples. Hemos abarcado los siguientes temas:

• Tipo datetime
• Estructura MqlDateTime
• Evento OnTimer
• Aplicación de NewBar
• Aplicación de un filtro temporal
• Aplicación de tradeAtTime

Existen muchas aplicaciones que funcionan con fecha y hora y no podemos enumerarlas todas, pero si comprendemos los conceptos básicos, podremos aplicar lo aprendido al crear nuestras propias aplicaciones.

Clicando en los enlaces que verá a continuación, podrá leer mis otros artículos. En concreto, encontrará una serie de artículos sobre la creación de sistemas comerciales basados ​​en los indicadores técnicos más populares. Espero que los encuentre útiles.