Trabalho com datas e horas no MQL5

Introdução

Ninguém no mercado financeiro esconde a importância do tempo e como ele pode afetar as decisões de negociação e os resultados. MQL5 (MetaQuotes Language 5) oferece uma solução para trabalhar efetivamente com datas e horas. Podemos abordar este importante tópico com a ajuda de diversos complementos que podem ser programados como parte de nosso sistema de negociação, mas primeiro vamos examinar os aspectos mais importantes deste tópico na linguagem de programação MQL5.

Neste artigo, examinaremos os seguintes tópicos:

• Tipo datetime
• Estrutura MqlDateTime
• Evento OnTimer
• Uso de NewBar
• Uso de filtro de tempo
• Uso de tradeAtTime
• Considerações finais

Após ler este artigo, você será capaz de usar dados do tipo datetime no MQL5 durante o desenvolvimento de seus aplicativos. Espero que o artigo seja útil para você.

Atenção! Todo o conteúdo deste artigo é fornecido "como está", destinado apenas para fins educacionais e não constitui uma recomendação de negociação. O artigo não oferece garantias de resultados. Tudo o que você aplica na prática com base neste artigo é feito exclusivamente por sua conta e risco, o autor não garante quaisquer resultados.

Tipo datetime

O tipo de variável datetime no MQL5 é usado para armazenar dados de data e hora no formato Unix. O tempo Unix representa o número de segundos passados desde 1º de janeiro de 1970. Para melhor compreensão, se convertermos a data de 01 de janeiro de 2023 às 00:00:00 GMT para o tempo Unix, descobriremos que ela é igual a 1672531200 segundos. Por esse motivo, o rótulo de tempo (timestamp) é a quantidade de segundos entre uma data específica e a época Unix, ou seja, 1º de janeiro de 1970. Também podemos ver o tempo em segundos em comparação com um tempo legível conhecido da seguinte forma:

Tempo legível conhecido	Segundos
1 ano	31.556.926 segundos
1 mês	2.629.743 segundos
1 semana	604.800 segundos
1 dia	86.400 segundos
1 hora	3.600 segundos

Você pode saber mais sobre a hora do Unix neste artigo da Wikipedia.

Podemos facilmente definir uma data e hora específicas usando a constante datetime, que começa com o símbolo D seguido da data e hora entre aspas simples:

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

Ou assim:

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

Os seguintes exemplos do manual MQL5 podem ser úteis para nós:

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__

Aqui estão os resultados após a compilação:

O tipo datetime armazena valores de data e hora em segundos. Isso facilita a comparação e o gerenciamento de valores de data e hora. A seguir, alguns exemplos do que podemos fazer ao trabalhar com valores de datas e horas:

• Comparação de valores de datas e horas.
• Adição ou subtração de valores de datas e horas.
• Conversão de tempo em string ou de string em tempo para diferentes propósitos.

Comparação de valores de data e hora:

Se temos dois valores de tempo e data e precisamos compará-los, podemos fazer isso no MQL5, criando uma variável para cada valor e, em seguida, comparando-os um com o outro para realizar uma ação com base no resultado. Veja um exemplo:

Se um usuário insere dois valores de data e hora, um sendo mais antigo que o outro, e queremos obter um resultado específico, como exibir dados, no caso de um valor de entrada ser maior que o outro, precisamos receber a mensagem "Input one is a recent time" (o primeiro valor de entrada é o mais recente), mas se o primeiro valor de entrada for menor que o segundo, precisamos receber a mensagem "Input two is a recent time" (o segundo valor de entrada é o mais recente).

Abaixo está o código que permite fazer isso:

//+------------------------------------------------------------------+
//|                                              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");
        }
  }
//+------------------------------------------------------------------+

Se após compilar o código, estabelecermos os valores de entrada de data e hora da seguinte maneira:

Como podemos ver, o primeiro valor de entrada é mais antigo que o segundo. Então, podemos encontrar um resultado semelhante ao seguinte:

Se mudarmos o primeiro valor de entrada para uma data mais recente, então o segundo será semelhante ao seguinte:

De acordo com as configurações anteriores dos parâmetros de entrada, deveríamos encontrar um resultado semelhante ao seguinte:

O exemplo de código anterior é um exemplo de como podemos manipular datas e horas.

Adição ou subtração de valores de datas e horas:

Também podemos adicionar e subtrair valores de datas e horas. Suponha que temos dois valores de data e hora:

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

Agora, precisamos adicionar um dia ao primeiro valor e subtrair um dia do segundo valor. Um dia em segundos é igual a 86.400. Assim, após essas duas transações, podemos encontrar os novos valores:

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

O seguinte código descreve como codificar essas transações:

//+------------------------------------------------------------------+
//|                                           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);
  }
//+------------------------------------------------------------------+

O resultado da execução deste software será o mesmo que já mencionamos:

Conversão de tempo em string ou string em tempo para diferentes propósitos:

Podemos precisar converter o tipo de valores de data e hora. Atualmente, temos duas funções que podem realizar a conversão de string para tempo e vice-versa. TimeToString ou StringToTime. Aqui, veremos um exemplo de como podemos tratar de tal caso:

//+------------------------------------------------------------------+
//|                                              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);
  }
//+------------------------------------------------------------------+

Executando este código no terminal de negociação, podemos encontrar os valores retornados para cada função: o primeiro para a conversão de TimeToString e o segundo para a conversão de StringToTime:

Se quisermos conhecer e entender todas as operações com o tipo datetime no MQL5,

• currentTime retorna o tempo atual.
• Comparação de valores: logicamente, usamos essa operação para verificar a comparação de tempo.
• Manipulações com dados de data e hora - adição e subtração.
• Formatação de data e hora.

Estrutura MqlDateTime

Nesta parte, estudaremos a estrutura MqlDateTime. Ela contém variáveis que podem armazenar dados de data e hora ou valores de data e hora. A seguir, a estrutura semelhante à que podemos encontrar no manual 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 vemos, ela contém oito campos de variáveis do tipo int.

Usamos a função (TimeToStruct) com essa estrutura para converter um valor datetime em uma variável MqlDateTime. Parâmetros da função:

• dt - data e hora
• dt_struct - estrutura para receber valores

A função retorna um valor lógico.

Também podemos usar a função (StructToTime) para converter uma variável de estrutura MqlDateTime de volta para um valor de data e hora. Seu único parâmetro é dt_struct. Ele retorna o tipo datetime, contendo a quantidade de segundos.

Podemos ver um exemplo desta estrutura MqlDateTime, semelhante ao seguinte:

Se temos uma data e hora D'2023.10.10 07:07:07' ou qualquer outro valor de entrada, precisamos usar isso com MqlDateTime. Podemos fazer isso com o seguinte código:

//+------------------------------------------------------------------+
//|                                                  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);
  }
//+------------------------------------------------------------------+

Após executar este Expert Advisor (EA), podemos encontrar mensagens impressas, como as seguintes:

Aqui é útil notar que o valor padrão do mês ou dia é igual a 01, se você usar menos de 1 como entrada. O valor máximo padrão para o mês é 12, e o dia é 31, se o parâmetro de entrada usado exceder esse valor máximo. Os valores padrão para a hora são mínimo 0 ou máximo 23, para os minutos - mínimo 0 ou máximo 59.

Evento OnTimer()

Nesta parte, aprenderemos o que é o manipulador de eventos OnTimer() e como usá-lo. Ele pode ser usado quando você precisa executar seu código ou estratégia de negociação a cada quantidade definida de segundos. Então, se você quer que seu código execute uma ação específica após um intervalo de tempo definido, você pode colocar seu código no manipulador de eventos OnTimer().

O manipulador de eventos OnTimer() é um tipo void sem parâmetros, e pode ser adicionado ao seu código, se necessário. Para usá-lo, você precisa definir o intervalo do timer na parte OnInit(), usando a função EventSetTimer() com um parâmetro de segundos, como no seguinte exemplo:

int OnInit()
{
EventSetTimer(60);
}

O exemplo anterior significa que o código do manipulador de eventos OnTimer() será executado a cada 60 segundos.

Agora, se precisarmos parar a execução do código dentro do evento OnTimer(), podemos fazer isso usando a função void EventKillTimer() no manipulador de eventos onDeinit() ou no destrutor da classe.

Uso de NewBar

Neste complemento, criaremos um arquivo incluível que contém classes e funções que podem ser usadas em outros arquivos, como EAs. O complemento informa se temos uma nova barra, imprimindo a mensagem "A new bar painted" (uma nova barra foi desenhado).

Primeiramente, os seguintes passos são destinados à criação do arquivo incluível. A ideia principal de criar um arquivo incluível aqui é aprender a criar arquivos que possam ser usados em muitos projetos e trabalhar como um desenvolvedor profissional, especialmente se você for um iniciante.

Vamos declarar a classe CNewBar, que terá duas variáveis privadas - time[] para armazenar o tempo da barra atual e LastTime para armazenar o tempo da última barra. Incluiremos o construtor da função booleana newBarCheck com dois parâmetros:

• tipo string do símbolo
• tipo timeFrame ENUM_TIMEFRAMES

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

Configuração do array de tempo como uma série

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

Criação da função newBarCheck com dois parâmetros (símbolo e timeframe) para verificar a presença ou ausência de uma nova barra. A função retornará um valor do tipo bool.

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

O corpo da função verifica a presença de uma nova barra. Duas variáveis lógicas, first e newBar, são criadas com o valor padrão false.

   bool firstCheck = false;
   bool newBar = false;

Use a função CopyTime com opções de chamada para a primeira posição para obter dados históricos de time_array do tempo de abertura da barra do par de símbolos-período especificado na quantidade especificada. Parâmetros:

• symbol_name - nome do símbolo na forma de uma string específica na função.
• timeframe - intervalo de tempo como ENIM_TIMEFRAMES definido na função.
• start_pos - posição de início é igual a 0.
• count - dados para copiar são iguais a 2.
• time_array[] - o array de onde copiar o tempo de abertura será o array de tempo.

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

Verificamos a variável da classe LastTime. Se esta for a primeira verificação, então o valor da variável LastTime será 0, então a variável firstCheck será verdadeira.

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

Verificamos se o valor de time[0] excede o valor de LastTime e, em seguida, verificamos se o valor de firstCheck é false; portanto, newBar será true, então LastTime será o mesmo valor que time[0].

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

Retornaremos o valor de newBar, que será um valor lógico.

return(newBar);

A seguir, o código completo em um único bloco:

//+------------------------------------------------------------------+
//|                                                       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);
  }
//+------------------------------------------------------------------+

Se você quer aprender mais sobre programação orientada a objetos e classes no MQL5, você pode ler meu artigo anterior "Programação Orientada a Objetos (POO) no MQL5". Espero que ele seja útil para você.

Agora, após criar o arquivo incluído, vamos criar nosso EA, que detectará a nova barra e exibirá a mensagem "A new bar painted, you can trade" (Uma nova barra foi pintada, você pode negociar). Primeiro, incluímos o arquivo criado no código do EA usando o pré-processor #include.

#include <dateTime.mqh>

Declaramos um objeto da classe CNewBar.

CNewBar NewBar;

Criaremos uma variável bool como entrada para escolher se vamos negociar ao pintar uma nova barra (true) ou não (false).

bool newBarTrade=true;

Depois disso, na parte OnTick(), criaremos uma variável bool newBar com o valor padrão true e outra variável inteira barShift com o valor padrão 0.

   bool newBar=true;
   int barShift=0;

Verificamos se o valor de newBarTrade é true, então newBar será igual a Newbarobject.newBarCheck com os parâmetros do símbolo atual e timeframe, e barShift será igual a 1.

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

Para garantir que newBar seja true, isso significa que foi gerada uma nova barra, portanto, precisamos receber a mensagem "A new bar painted, you can trade".

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

Aqui está o código completo deste complemento:

//+------------------------------------------------------------------+
//|                                                       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");
     }
  }
//+------------------------------------------------------------------+

Depois de executar este EA, podemos obter o seguinte resultado após a criação de uma nova barra:

O código pode ser desenvolvido para mudar a ação ao desenhar uma nova barra de acordo com sua estratégia, como abrir um trade ou algo mais, mas neste artigo compartilhamos um código simples para entender a ideia principal.

Uso de filtro de tempo

Neste complemento, precisamos criar um complemento para permitir ou proibir a negociação com base em um filtro de tempo ou um período de tempo especificado. Adicionaremos ao arquivo incluído criado um novo classe CTimeFilter e criaremos uma função lógica pública timeCheck com três parâmetros (startTime, endTime, localTime com valor padrão false).

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

Vamos criar o corpo da função timeCheck, verificando se os dados inseridos estavam incorretos ao obter o valor de startTime maior ou igual a endTime, e então retornaremos um aviso de erro "Erro: "Invalid Time input" (Erro: entrada de tempo inválida) e false.

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

Criaremos uma variável datetime para currentTime e então verificaremos se localTime é true. TimeLocal() será atribuído a currentTime ou TimeCurrent() será atribuído a currentTime.

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

Criaremos uma variável lógica chamada timeFilterActive com valor padrão false e então verificaremos se currentTime é maior ou igual a startTime e, ao mesmo tempo, menor que endTime, então retornaremos true para timeFilterActive. Retornaremos o valor de timeFilterActive.

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

Aqui está o código completo no arquivo incluído:

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

Após criar o arquivo incluído, criaremos nosso EA timeFilterApp, seguindo o próximo passo:

Incluiremos o arquivo dateTime para usar seu conteúdo.

#include <dateTime.mqh>

 Criaremos duas variáveis de data e hora como valores de entrada com nomes StartTime e EndTime.

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

Criaremos um objeto chamado filter na área de escopo global.

CTimeFilter filter;

Na parte OnTick(), criaremos timeFilterActive e atribuiremos a ele filter.timeCheck com os parâmetros.

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

Para verificar se o valor de timeFilterActive é true, precisaremos receber a mensagem "Trading is active based on time filter" (A negociação está ativa com base no filtro de tempo) ou "Trading is inactive based on time filter" (A negociação está inativa com base no filtro de tempo).

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

O código completo é o seguinte:

//+------------------------------------------------------------------+
//|                                                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");
  }

Após a execução deste complemento, veremos um dos três resultados, dependendo do tempo inserido.

No caso do tempo ativo:

No caso de tempo inativo:

No caso de parâmetros de entrada incorretos:

Existe outro método que podemos usar sem um arquivo incluído. Aqui estão os passos para fazer isso:

Criamos quatro variáveis de entrada int para as horas e minutos iniciais e finais em escopo global.

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

Na parte OnTick(), criamos uma variável structTime, usando a função MqlDateTime, que contém dados de data e hora.

MqlDateTime structTime;

Passamos a variável structTime criada para a função TimeCurrent.

TimeCurrent(structTime);

Ajustamos os segundos para 0 e defina as horas e minutos para o tempo de início.

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

Criamos uma variável datetime chamada timeStart e passe structTime para a função StructToTime, que converte a variável estrutural MqlDateTime em um valor do tipo datetime e, em seguida, atribui-a à variável timeStart.

datetime timeStart = StructToTime(structTime);

Definimos as horas e minutos do tempo de término.

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

Criamos uma variável timeEnd da mesma forma que fizemos com timeStart.

datetime timeEnd = StructToTime(structTime);

Criamos uma variável lógica isTime para determinar o tempo permitido para negociação.

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

Criamos uma mensagem de erro em caso de entrada incorreta.

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

Estabelecemos as condições para o tempo de negociação.

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

O código completo é o seguinte:

//+------------------------------------------------------------------+
//|                                               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");
  }
//+------------------------------------------------------------------+

Após executar o código, veremos os seguintes resultados:

No caso do tempo ativo:

No caso de tempo inativo para negociação:

No caso de valores de entrada incorretos:

Uso de tradeAtTime

Digamos que precisemos definir um horário específico para negociar, precisaremos definir esse horário como um horário permitido para negociar e abaixo estão as etapas necessárias para fazer isso.

Criamos uma variável de entrada string chamada openTime com o valor padrão "10:00".

input string openTime="10:00";

Criamos uma variável datetime para LastTime.

datetime lastTime;

Na parte OnTick(), criamos uma variável datetime dtOpenTime para atribuir a ela os valores de StringToTime para openTime.

datetime dtOpenTime=StringToTime(openTime);

Verificamos a condição de tempo permitido. Se o último tempo permitido não for igual a dtOpenTime e, ao mesmo tempo, timeCurrent() for maior que dtOpenTime, precisamos atualizar o valor de LastTime com dtOpenTime e imprimir a mensagem "Now is the allowed time to trade" (Agora é o tempo permitido para negociar). Esta mensagem aparecerá uma vez no tempo especificado.

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

Aqui está o 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");
     }
  }
//+------------------------------------------------------------------+

Após a execução do código, encontramos seu sinal:

Considerações finais

Examinamos o que é data e hora e como podemos trabalhar com elas no MQL5 ao criar nossos aplicativos. Aplicamos nosso conhecimento ao criar aplicativos simples. Cobrimos os seguintes tópicos:

• Tipo datetime
• Estrutura MqlDateTime
• Evento OnTimer
• Uso de NewBar
• Uso de filtro de tempo
• Uso de tradeAtTime

Existem muitos aplicativos que trabalham com data e hora, e não podemos listar todos eles, mas, entendendo os fundamentos, podemos aplicar o conhecimento adquirido ao criar nossos próprios aplicativos.

Nos links abaixo, você pode explorar outros artigos meus. Em particular, você pode encontrar uma série de artigos sobre a criação de sistemas de negociação baseados nos indicadores técnicos mais populares. Espero que eles sejam úteis.