RoboTutorial4.mql5

//+------------------------------------------------------------------+
//|                                                RoboTutorial4.mq5 |
//|                                  Copyright 2021, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2021, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
#include<Trade\Trade.mqh>
//+------------------------------------------------------------------+
//| Input de parâmetros                                              |
//+------------------------------------------------------------------+
input double   Volume         = 0.1;           // Quantidade Inicial de Contratos
input string   HoraInicial    = "09:00";     // Horário de Início para novas operações
input string   HoraFinal      = "17:30";     // Horário de Término para novas operações
input string   HoraFechamento = "17:50";     // Horário de Fechamento para posições abertas
input double   LimiteGanho    = 75.0;       // Limite de ganho
input double   LimitePerda    = -50.0;       // Limite de perda
//+------------------------------------------------------------------+
//| // Classes para controle de tempo                                |
//+------------------------------------------------------------------+
MqlDateTime hora_inicial, hora_final, hora_fechamento;
//+------------------------------------------------------------------+
//| Declaração de variáveis                                          |
//+------------------------------------------------------------------+
static int OldDay = 0;
static bool isRoboLigado = false;
static int bars = 0;
enum TIPO_ORDEM { COMPRA, VENDA, NENHUM };
CTrade trade;
static int handle = 0;
static bool ordemAberta = false;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---
   // Verifica os parametros de hora inicial e de fechamento do pregao
   if (!CheckTimeParameters()) {
      Print("Os horários fornecidos estão inválidos.");
      return INIT_FAILED;
   }
   handle = iMA(_Symbol, _Period, 100, 0, MODE_SMA, PRICE_CLOSE);
   if(handle == INVALID_HANDLE) {
      Print("Erro ao capturar dados da MM100.");
      return INIT_FAILED;
   }
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---
   if(handle!=INVALID_HANDLE) 
      IndicatorRelease(handle);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//---
   if (IsNovoDia()) {
      // aqui roda uma vez no início de cada dia
      isRoboLigado = true;
   } else {
      // cada vez que uma vela terminar outra começar
      if (IsNovoCandle()) {
         if (IsHorarioPermitido() && isRoboLigado && !ordemAberta) {
            DeterminarEntrada(0.002, 0.002);
         }
         if (IsHorarioFechamento() && isRoboLigado) {
            isRoboLigado = false;
            fecharUltimaOrdem();
         }
      }
   }
  }
//+------------------------------------------------------------------+

bool CheckTimeParameters() {
   // Inicialização das variáveis de tempo
   TimeToStruct(StringToTime(HoraInicial), hora_inicial);
   TimeToStruct(StringToTime(HoraFinal), hora_final);
   TimeToStruct(StringToTime(HoraFechamento), hora_fechamento);
   // Verificação de inconsistências nos parâmetros de entrada
   return  !(hora_inicial.hour > hora_final.hour || (hora_inicial.hour == hora_final.hour && hora_inicial.min > hora_final.min))
         || hora_final.hour > hora_fechamento.hour || (hora_final.hour == hora_fechamento.hour && hora_final.min > hora_fechamento.min);
}

bool IsHorarioPermitido() {
   MqlDateTime hora_atual;
   TimeToStruct(TimeCurrent(), hora_atual); 
   if (
      hora_atual.hour >= hora_inicial.hour 
      && hora_atual.hour <= hora_final.hour
   )
   {
      if (
         (hora_inicial.hour == hora_final.hour) 
         && (hora_atual.min >= hora_inicial.min) 
         && (hora_atual.min <= hora_final.min)
      )
         return true;
      if (hora_atual.hour == hora_inicial.hour)
      {
         if (hora_atual.min >= hora_inicial.min)
            return true;
         else
            return false;
      }
      if (hora_atual.hour == hora_final.hour)
      {
         if (hora_atual.min <= hora_final.min)
            return true;
         else
            return false;
      }
      return true;
   }
   return false;
}

bool IsNovoDia() {
   MqlRates _rates[];
   ArraySetAsSeries(_rates, true);
   if(CopyRates(_Symbol,_Period,0,2,_rates) > 0) 
   {
      datetime lastbar_time = _rates[0].time;
      MqlDateTime time;
      TimeToStruct(lastbar_time, time);
      if(OldDay < time.day_of_year)
      { 
         OldDay = time.day_of_year;
         return true;
      }
   } else Print("Erro ao consultar IsNovoDia no servidor!");
   return false;
}

bool IsNovoCandle() {
   // Codigo do Deus
   int local_bars = Bars(_Symbol, _Period);
   if (local_bars == 0) Print("Erro ao consultar Bars no servidor!");
   if(bars < local_bars && local_bars > 0)
   {
      if (bars != 0) {
       bars = local_bars;
       return true;
      }
      
      bars = local_bars;
       return false;
   }
   return false;
}

void fecharUltimaOrdem() {
   ordemAberta = false;
   trade.PositionClose(_Symbol);
}
void abrirOrdem(TIPO_ORDEM s, double price, double sl, double tp) {
   ordemAberta = true;
   if (s == COMPRA) {
      trade.Buy(Volume,_Symbol,price,sl,tp,NULL);
   }
   if (s == VENDA) {
      trade.Sell(Volume,_Symbol,price,sl,tp,NULL);
   }
}

bool IsHorarioFechamento() {
   MqlDateTime hora_atual;
   TimeToStruct(TimeCurrent(), hora_atual); 
   if (hora_atual.hour > hora_fechamento.hour)
      return true;
   if ((hora_atual.hour == hora_fechamento.hour) && (hora_atual.min >= hora_fechamento.min))
      return true;
   return false;
}

void DeterminarEntrada(double sl, double tp) {
   // Primeiro pegamos os valores atuais de preço de compra e venda
   double Ask=NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_ASK),_Digits);
   double Bid=NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_BID),_Digits);
   
   double values[];
   ArraySetAsSeries(values, true);
   
   if(CopyBuffer(handle,0,0,3,values) > 0) {
   
      double indicadorMM10 = values[0];
      
      if (Ask > indicadorMM10)      
         // criando uma ordem de compra quando preço acima do indicador
         abrirOrdem(COMPRA, Ask, Ask - sl, Ask + tp);
      
      else if (Bid < indicadorMM10)      
         // criando uma ordem de venda quando preço abaixo do indicador
         abrirOrdem(VENDA, Bid, Bid + sl, Bid - tp);
   }
}