Envio de notificação para grupo do telegram.

 

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;
  }
//+------------------------------------------------------------------+
Bots: An introduction for developers
  • core.telegram.org
Bots are third-party applications that run inside Telegram. Users can interact with bots by sending them messages, commands and inline requests. You control your bots using HTTPS requests to our Bot API. 1. What can I do with bots? To name just a few things, you could use bots to: Get customized notifications and news . A bot can act as a smart...
 
Rapaz, tive o  mesmo problema  hoje, eu resolvi escrevendo um codigo proprio para envio de mensagens e abandonando a biblioteca do telegram.
 

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

Razão: