I need to add a function in a new Expert, just created, based on hilo

I would like for each new hilo signal to check how many signals there were in a range of X previous bars closed, and if the number of previous signals in this range is equal to Y, then it enables trading as a filter, with the type filter bool. This filter, once activated, must be deactivated when a trade reaches the take profit line, then returning to check the number of signals again for a new entry.

The function must only consider bars, regardless of time. Thanks!

//+------------------------------------------------------------------+
//|                                                     Canais01.mq5 |
//|                                  Copyright 2023, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2023, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"

#include <Trade\Trade.mqh>
#include <Trade\SymbolInfo.mqh>
CTrade trade;
CSymbolInfo simbolo; 



input int      Periodo   = 20;       // Período Média
//input int      PeriodoCurto   = 20;       // Período Média Curta
input double   SL             = 0.0;      // Stop Loss
input double   TP             = 0.0;      // Take Profit
input double   lotes  = 1;        // Volume Inicial
input string   inicio         = "09:00";  // Horário de Início (entradas)
input string   termino        = "17:00";  // Horário de Término (entradas)
input string   fechamento     = "17:30";  // Horário de Fechamento (posições)
input int      periodo_verificacao = 10; // verifica
input int      alternanciaMinima = 1;

bool HabilitarVenda = true;
bool HabilitarCompra = true;
int count_above_ma = 0;

int handleHilo; // Manipuladores dos dois indicadores de média móvel
      double hilo[];

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


//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---

   if(!simbolo.Name(_Symbol))
   {
      printf("Ativo Inválido!");
      return INIT_FAILED;
   }

      // Criação dos manipuladores com Períodos curto e longo
      


   
      // Criação das structs de tempo
   TimeToStruct(StringToTime(inicio), horario_inicio);
   TimeToStruct(StringToTime(termino), horario_termino);
   TimeToStruct(StringToTime(fechamento), horario_fechamento);
   
   
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---
   
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
      handleHilo = iCustom(Symbol(), Period(), "GannHilo", Periodo);
           // Cópia dos buffers dos indicadores de média móvel com períodos curto e longo

      ArraySetAsSeries(hilo, true);
      ArraySetAsSeries(rates, true);

       
    CopyBuffer(handleHilo, 0, 0, 3, hilo);
    CopyRates(Symbol(), Period(), 0, 3, rates);
  
//---
      if(HorarioEntrada())
   {
      // Compra em caso de cruzamento da média curta para cima da média longa
   if(rates[1].close > hilo[1] && rates[2].close < hilo[2] && HabilitarCompra == true){
      
               //double ma_value = hilo[0];

               

               
                  // Verificar quantas vezes os últimos 10 candles fecharam acima da média móvel
                  //count_above_ma = 0;
                  

        
                  CloseAllSellPositions();
                  Compra();
                  HabilitarCompra = false;
                  HabilitarVenda = true;
                  
            }
   
   // Venda em caso de cruzamento da média curta para baixo da média longa
   else if(rates[1].close < hilo[1] && rates[2].close > hilo[2] && HabilitarVenda == true){
         CloseAllBuyPositions();
         Venda();
         HabilitarVenda = false;
         HabilitarCompra = true;
         }


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

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

void Compra()
{           
      if(trade.Buy(lotes, NULL, 0, 0, 0, "Compra CruzamentoMediaEA")) // Envio da ordem de compra pela classe responsável
            {
                AddTakeStop(SL, TP);
            }
}

void Venda()
{     
      if(trade.Sell(lotes, NULL, 0, 0, 0, "venda CruzamentoMediaEA")) // Envio da ordem de compra pela classe responsável
                     {
                AddTakeStop(SL, TP);
            }
}

void AddTakeStop(double p_sl, double p_tp)
{
    for (int i = PositionsTotal() - 1; i >= 0; i--)
    {
        string symbol = PositionGetSymbol(i);

        if (symbol == Symbol())
        {
            ulong ticket = PositionGetInteger(POSITION_TICKET);
            double precoEntrada = PositionGetDouble(POSITION_PRICE_OPEN);

            double novoSL;
            double novoTP;

            if (PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY)
            {
                novoSL = NormalizeDouble(precoEntrada - (p_sl * _Point), _Digits);
                novoTP = NormalizeDouble(precoEntrada + (p_tp * _Point), _Digits);

                trade.PositionModify(ticket, novoSL, novoTP);
            }
            else if (PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL)
            {
                novoSL = NormalizeDouble(precoEntrada + (p_sl * _Point), _Digits);
                novoTP = NormalizeDouble(precoEntrada - (p_tp * _Point), _Digits);

                trade.PositionModify(ticket, novoSL, novoTP);
            }
        }
    }
}

//+------------------------------------------------------------------+
//| Fechar posição aberta                                            |
//+------------------------------------------------------------------+
void Fechar()
{  
    for (int i = PositionsTotal() - 1; i >= 0; i--)
    {
        if (PositionGetSymbol(i) == _Symbol && PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY)
        {
            ulong ticket = PositionGetTicket(i);
            trade.PositionClose(ticket);
        }
    }
    

    for (int i = PositionsTotal() - 1; i >= 0; i--)
    {
        if (PositionGetSymbol(i) == _Symbol && PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL)
        {
            ulong ticket = PositionGetTicket(i);
            trade.PositionClose(ticket);
        }
    }

}

void CloseAllBuyPositions()
{  
    for (int i = PositionsTotal() - 1; i >= 0; i--)
    {
        if (PositionGetSymbol(i) == _Symbol && PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY)
        {
            ulong ticket = PositionGetTicket(i);
            trade.PositionClose(ticket);
        }
    }
 }
    
void CloseAllSellPositions()
{
    for (int i = PositionsTotal() - 1; i >= 0; i--)
    {
        if (PositionGetSymbol(i) == _Symbol && PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL)
        {
            ulong ticket = PositionGetTicket(i);
            trade.PositionClose(ticket);
        }
    }

}

//+------------------------------------------------------------------+
//| Verificar se há posição aberta                                   |
//+------------------------------------------------------------------+
bool SemPosicao()
{  
   return !PositionSelect(_Symbol);
   //return resultado;
}

//+------------------------------------------------------------------+
//| Estratégia de cruzamento de médias                               |
//+------------------------------------------------------------------+
/*int Cruzamento()
{
   // Cópia dos buffers dos indicadores de média móvel com períodos curto e longo
   double MediaCurta[], MediaLonga[];
   ArraySetAsSeries(MediaCurta, true);
   ArraySetAsSeries(MediaLonga, true);
   CopyBuffer(handlemediacurta, 0, 0, 2, MediaCurta);
   CopyBuffer(handlemedialonga, 0, 0, 2, MediaLonga);
   
   // Compra em caso de cruzamento da média curta para cima da média longa
   if(MediaCurta[1] <= MediaLonga[1] && MediaCurta[0] > MediaLonga[0]){
      CloseAllBuyPositions();
      return 1;
      tradar = 1;
            }
   
   // Venda em caso de cruzamento da média curta para baixo da média longa
   if(MediaCurta[1] >= MediaLonga[1] && MediaCurta[0] < MediaLonga[0]){

      return -1;
         CloseAllSellPositions();}
      
   return 0;
}*/

//+------------------------------------------------------------------+