Envio de notificação para grupo do telegram.

[Guilherme Schutz Leite]

Olá a todos como estão?

Criei um robo para enviar  sinal para um channel no telegram porem o meu robo não envia as notificações;
A lógica de compra e venda está funcionando no backtest.
Na plataforma em ferramentas, opções, EA adicionei o link https://api.telegram.org/

Quem puder me ajudar ficaria muito grato.

Segue o código:

#property copyright "Guilherme Leite"
#property link      "http://mql5.com"
#property version   "1.00"

// Inclusão de bibliotecas utilizadas
#include <Trade/Trade.mqh>
#include <Trade/SymbolInfo.mqh>
#include <Telegram.mqh>

input group              "Configuração Telegram" 
input string             InpChannelName="@SinalBB";//Nome do Canal em que o robo é adm.
input string             InpToken="0000000000:AAAAAAAAAAAAAAAA";//Token gerado pelo robo pai, escondido
input group              "Configurações gerais"
input ulong              Magic          = 123456;      // Número mágico
input group              "Configurações operacionais"
input double             SL             = 500;         // Stop Loss
input double             TP             = 500;         // Take Profit
input double             Volume         = 1;           // Volume
input group              "Configurações do indicador"
input int                PeriodoMediaM  = 100;         // Média Movel 100 EMA
input int                Periodo        = 20;          // Período
input double             Desvio         = 2;           // Desvio
input int                Deslocamento   = 0;           // Deslocar
input ENUM_APPLIED_PRICE Preco          = PRICE_CLOSE; // Preço Aplicado
input group              "Configurações de horários"
input string             inicio         = "00:00";     // Horário de Início (entradas)
input string             termino        = "23:00";     // Horário de Término (entradas)
input string             fechamento     = "23:30";     // Horário de Fechamento (posições)

int         handle;
int         mmHandle = INVALID_HANDLE;
string      shortname;

CTrade      negocio; // Classe responsável pela execução de negócios
CSymbolInfo simbolo; // Classe responsãvel pelos dados do ativo
CCustomBot bot;      // Calsse responsavel pelo bot 


// Estruturas de tempo para manipulação de horários
MqlDateTime horario_inicio, horario_termino, horario_fechamento, horario_atual;

int getme_result;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- configuração token
   bot.Token(InpToken);
//--- checagem token
   getme_result=bot.GetMe();
//--- executando o timer
   EventSetTimer(3);
   OnTimer();
   
// Definição do símbolo utilizado para a classe responsável
   if(!simbolo.Name(_Symbol))
     {
      printf("Ativo Inválido!");
      return INIT_FAILED;
     }

// Criação dos manipulador
   handle = iBands(_Symbol, _Period, Periodo, Deslocamento, Desvio, Preco);
   mmHandle = iMA (_Symbol, _Period, 100 , 0, MODE_EMA, PRICE_CLOSE);

   
// Verificação do resultado da criação dos manipuladores
   if(handle == INVALID_HANDLE)
     {
      Print("Erro na criação dos manipuladores");
      return INIT_FAILED;
     }

   if(!ChartIndicatorAdd(0, 0, handle))
     {
      Print("Erro na adição do indicador ao gráfico");
      return INIT_FAILED;
     }
     
   shortname = ChartIndicatorName(0, 0, ChartIndicatorsTotal(0, 0)-1);
//---

// Criação das structs de tempo
   TimeToStruct(StringToTime(inicio), horario_inicio);
   TimeToStruct(StringToTime(termino), horario_termino);
   TimeToStruct(StringToTime(fechamento), horario_fechamento);

// Verificação de inconsistências nos parâmetros de entrada
   if(horario_inicio.hour > horario_termino.hour || (horario_inicio.hour == horario_termino.hour && horario_inicio.min > horario_termino.min))
     {
      printf("Parâmetros de Horário inválidos!");
      return INIT_FAILED;
     }

// Verificação de inconsistências nos parâmetros de entrada
   if(horario_termino.hour > horario_fechamento.hour || (horario_termino.hour == horario_fechamento.hour && horario_termino.min > horario_fechamento.min))
     {
      printf("Parâmetros de Horário inválidos!");
      return INIT_FAILED;
     }

   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---
   ChartIndicatorDelete(0, 0, shortname);
   
// Motivo da desinicialização do EA
   printf("Deinit reason: %d", reason);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//---
// Atualização dos dados do ativo
   if(!simbolo.RefreshRates())
      return;

// EA em horário de entrada em novas operações
   if(HorarioEntrada())
     {
      // EA não está posicionado
      if(SemPosicao())
        {
         // Verificar estratégia e determinar compra ou venda
         int resultado = Sinal();

         // Estratégia indicou compra
         if(resultado  == 1)
            Compra();
         // Estratégia indicou venda
         if(resultado  == -1)
            Venda();
        }
     }

// EA em horário de fechamento de posições abertas
   if(HorarioFechamento())
     {
      // EA está posicionado, fechar posição
      if(!SemPosicao())
         Fechar();
     }

  }
  void OnTimer()
  {
//--- mostrar mensagem de erro 
   if(getme_result!=0)
     {
      Comment("Error: ",GetErrorDescription(getme_result));
      return;
     }
//--- mostrar Nome do bot
   Comment("Bot name: ",bot.Name());

//---{ insert your code here }
  }
//+------------------------------------------------------------------+
//| Checar se horário atual está dentro do horário de entradas       |
//+------------------------------------------------------------------+
bool HorarioEntrada()
  {
   TimeToStruct(TimeCurrent(), horario_atual); // Obtenção do horário atual

// Hora dentro do horário de entradas
   if(horario_atual.hour >= horario_inicio.hour && horario_atual.hour <= horario_termino.hour)
     {
      // Hora atual igual a de início
      if(horario_atual.hour == horario_inicio.hour)
         // Se minuto atual maior ou igual ao de início => está no horário de entradas
         if(horario_atual.min >= horario_inicio.min)
            return true;
      // Do contrário não está no horário de entradas
         else
            return false;

      // Hora atual igual a de término
      if(horario_atual.hour == horario_termino.hour)
         // Se minuto atual menor ou igual ao de término => está no horário de entradas
         if(horario_atual.min <= horario_termino.min)
            return true;
      // Do contrário não está no horário de entradas
         else
            return false;

      // Hora atual maior que a de início e menor que a de término
      return true;
     }

// Hora fora do horário de entradas
   return false;
  }
//+------------------------------------------------------------------+
//| Checar se horário atual está dentro do horário de fechamento     |
//+------------------------------------------------------------------+
bool HorarioFechamento()
  {
   TimeToStruct(TimeCurrent(), horario_atual); // Obtenção do horário atual

// Hora dentro do horário de fechamento
   if(horario_atual.hour >= horario_fechamento.hour)
     {
      // Hora atual igual a de fechamento
      if(horario_atual.hour == horario_fechamento.hour)
         // Se minuto atual maior ou igual ao de fechamento => está no horário de fechamento
         if(horario_atual.min >= horario_fechamento.min)
            return true;
      // Do contrário não está no horário de fechamento
         else
            return false;

      // Hora atual maior que a de fechamento
      return true;
     }

// Hora fora do horário de fechamento
   return false;
  }
//+------------------------------------------------------------------+
//| Realizar compra com parâmetros especificados por input           |
//+------------------------------------------------------------------+
void Compra()
  {
   double price = simbolo.Ask();
   double stoploss = simbolo.NormalizePrice(price - SL); // Cálculo normalizado do stoploss
   double takeprofit = simbolo.NormalizePrice(price + TP); // Cálculo normalizado do takeprofit
   negocio.Buy(Volume, NULL, price,0,0, "Compra"); // Envio da ordem de compra pela classe responsável
   
   string msg=StringFormat("Name: Bolling Band Sinal\nSymbol: %s\nTimeframe: %s\nType: Buy",
                                 _Symbol,
                                 StringSubstr(EnumToString(_Period),7));
         bot.SendMessage(InpChannelName,msg);
         int res;
         if(res!=0)
            Print("Errouuu: ",GetErrorDescription(res));
  }
//+------------------------------------------------------------------+
//| Realizar venda com parâmetros especificados por input            |
//+------------------------------------------------------------------+
void Venda()
  {
   double price = simbolo.Bid();
   double stoploss = simbolo.NormalizePrice(price + SL); // Cálculo normalizado do stoploss
   double takeprofit = simbolo.NormalizePrice(price - TP); // Cálculo normalizado do takeprofit
   negocio.Sell(Volume, NULL, price,0,0, "Venda"); // Envio da ordem de compra pela classe responsável
  
   string msg=StringFormat("Name: Bolling Band Sinal\nSymbol: %s\nTimeframe: %s\nType: Sell",
                                 _Symbol,
                                 StringSubstr(EnumToString(_Period),7));
         bot.SendMessage(InpChannelName,msg);
         int res;
         if(res!=0)
            Print("Errouuu: ",GetErrorDescription(res));
  }
//+------------------------------------------------------------------+
//| Fechar posição aberta                                            |
//+------------------------------------------------------------------+
void Fechar()
  {
// Verificação de posição aberta
   int total = PositionsTotal();
   for(int i=total-1; i>=0; i--)
     {
      ulong ticket = PositionGetTicket(i);
      if(!PositionSelectByTicket(ticket))
         continue;
      if(PositionGetString(POSITION_SYMBOL)!=_Symbol || PositionGetInteger(POSITION_MAGIC)!=Magic)
         continue;
      negocio.PositionClose(ticket);
     }
  }
//+------------------------------------------------------------------+
//| Verificar se há posição aberta                                   |
//+------------------------------------------------------------------+
bool SemPosicao()
  {
   int total = PositionsTotal();
   for(int i=total-1; i>=0; i--)
     {
      ulong ticket = PositionGetTicket(i);
      if(!PositionSelectByTicket(ticket))
         continue;
      if(PositionGetString(POSITION_SYMBOL)!=_Symbol || PositionGetInteger(POSITION_MAGIC)!=Magic)
         continue;
      return false;
     }
     
   return true;
  }
//+------------------------------------------------------------------+
//| Estratégia                                                       |
//+------------------------------------------------------------------+
int Sinal()
  {
  
   double priceC = simbolo.Ask();
   double priceV = simbolo.Bid();
   double superior[], inferior[];
   double mediamovel[];
   
   ArraySetAsSeries(mediamovel, true);
   ArraySetAsSeries(superior, true);
   ArraySetAsSeries(inferior, true);
   
   CopyBuffer(mmHandle,0,0,3,mediamovel);
   CopyBuffer(handle, 1, 0, 2, superior);
   CopyBuffer(handle, 2, 0, 2, inferior);
   
   double close_atual = iClose(_Symbol, _Period, 0);
   double close_anterior = iClose(_Symbol, _Period, 1);
   
   if(close_anterior >= inferior[1] && priceC < inferior[0] && inferior[0] > mediamovel[0])
      return 1;
   if(close_anterior <= superior[1] && priceV > superior[0] && superior[0] < mediamovel[0])
      return -1;
   
   return 0;
  }
//+------------------------------------------------------------------+

[Cesar Afif rezende Oaquim]

Rapaz, tive o  mesmo problema  hoje, eu resolvi escrevendo um codigo proprio para envio de mensagens e abandonando a biblioteca do telegram.

[Eduardo Oliveira]

A biblioteca do telegram está funcionando, mas toda vez que vc ligar o EA no MT5 vc precisa enviar uma mensagem de /start pelo telegram, assim o bot acorda e funciona, sem esse /start ou \start não lembro agora, ele não responde mesmo.

No MT5 eu ví que vc deixou no comment o nome do bot, está aparecendo? Se tiver quer dizer que está ocorrendo a comunicação, então só precisará acordar o bot, batendo o olho no seu código, ví que não existe esse \start