ESP32_FreqMeter_0.38.0.ino

// Atual ESP32_FreqMeter_0.33.0.ino    Antigo NovoTeste08.ino

// V01 Teste com pcnt
// V02 teste com timer
// V03 Teste de interrupt
// V04 Definicao com escala baseada no prescaler
// V05 Calculos com interrupt
// V06 Versão inicial do frequeciimetro com ESP32 nao esta preciso , Seleciona a escala.
// V07 Modificacoes no loop pra melhorar a escala  funcionou bem
// V07_A Fixando o valor de prescaler em 80   Criada 5a escala
// V07_B teste de erro na rotina pcnt
// V08 Sem escala, fixando o prescaler e o timer e contando os overflows
// V09 Limpando a V08
// V10 Testes com rotina de contagem de overflow
// V11 Teste de overflow de pcnt e timer  funciona  teste com frequenci DE 10 khZ  Copia do frequencimetro 2 modificado
// V12 Resumir e limpar V11  enroscou a partir de 300 KHz
// V13 Consegui bom resultado deste aqui até 20MHz Usando RMT com referencia de tempo
// V14 Interrupt de pcnt e contar tempo de RMT
// V15 Novo teste com RMT
// V16 Qtde de pulsos entre ocorrencias de interrupt
// V17 Outro teste de ocorrencias de interrupt
// V18 Teste com rotina de interrupt com poucas funcoes
// V19 Teste com esp-timer  e interrupt no fim do pulso do esp-timer
// V20 Teste = V19
// V20a Preparada para IDF
// V20aGustavo Sem interrupt de esp-timer
// V21 Inclusao de LCD com diretivas de compilacao
// 0.0.21 = V21
// 0.0.22  Pontuação do numero
// V23 Teste com 2 rotinas de pontuacao
// V24 Parametros de ledc calculados   Diretivas de compilacao para ARDUINO e IDF
// V25 Nova rotina de pontuação
// V26 Usando printf na rotina de pontuacao
// V27 Teste com IDF  Compilou com a IDF do CEI
// V28 Teste com nova rotina de pontuacao e printf
// V30 Rotina de teste depois de erro no IDF e limpeza de variaveis desnecessarias e organização
// V31 Nova Diretiva de compilação  ARDUINO   Inclusão de LCD  ok
// V32 Novamente com rotinas de LCD Mudanca do formato dos port GPIO
// V33 Calculo de Resolucao com base na frequencia e duty de 50%, inclusao de LCD I2C com diretiva e teste gpio matrix incluido
// V34 medir o Duty do pulso recebido até 50HKz funcionou mas não ficou boa Removi
// V35 testar LCD com IDF   Funcionou muito bem Necessita 1 blilioteca hd44780.h.   https://github.com/UncleRus/esp-idf-lib
// V36  testar com LCD I2C IDF   teste Necessita 3 bliliotecas i2cdev.h, pcf8574.h, hd44780.h.  https://github.com/UncleRus/esp-idf-lib
// V37  testar com LCD I2C IDF   Funcionou muito bem   Necessita 3 bliliotecas i2cdev.h, pcf8574.h, hd44780.h.  https://github.com/UncleRus/esp-idf-lib

// V38 = V37 reorganizado e com diretivas  Necessita 3 bliliotecas i2cdev.h, pcf8574.h, hd44780.h.  https://github.com/UncleRus/esp-idf-lib
//                                                          comentadas as linhas  #include "esp_idf_lib_helpers.h" nas 3 blibliotecas


/*

  Desenvolvedores: Rui Viana e Gustavo Murta   08/jul/2020

  Para desenvolver este projeto, foram aproveitadas partes de códigos dos desenvolvedores
  abaixo referenciados.

  O Projeto:
  Um frequencímetro usando ESP32, sem necessidade de escalas e mostrando até 8 dígitos,
  medindo com precisão até 20MHz ou mais.
  Este projeto pode ser compilado com a IDE do arduino ou com o IDF

  Definições:

  #define PCNT_INPUT_SIG_IO     GPIO_NUM_34                                 // Freq Meter Input GPIO 34
  #define LEDC_HS_CH0_GPIO      GPIO_NUM_25

  #define PCNT_INPUT_CTRL_IO    GPIO_NUM_35                                 // Count Control GPIO HIGH=count up, LOW=count down GPIO 25
  #define OUTPUT_CONTROL_GPIO   GPIO_NUM_32                                 // Saida do timer GPIO 2

  PORT de entrada do frequencímetro PCNT_INPUT_SIG_IO (GPIO 34)
  PORT de entrada de controle PCNT_INPUT_CTRL_IO      (GPIO 35)
  PORT de saída do timer OUTPUT_CONTROL_GPIO          (GPIO 32)
  O PORT de entrada de controle (GPIO 35) deve ser ligado ao PORT de saída do timer (GPIO 32).
  Estes são os ports usados no projeto, mas podem ser modificados para sua melhor conveniência.

  O frequencímetro é dividido em 5 partes:
    1. Contador de pulsos;
    2. Controle de tempo de contagem;
    3. Impressão do resultado;
    4. Espaço para outras funções.
    5. Gerador de sinais programado para 2  Hz  (ou 50.000)

  1. O contador de pulso usa o pcnt do ESP32.
     O pcnt tem os seguintes parâmetros:
      a. port de entrada;
      b. canal de entrada;
      c. port de controle;
      d. contagem na subida do pulso;
      e. contagem na descida do pulso;
      f. contagem só com o controle em nível elevado;
      g. limite máximo de contagem.

  2. O Controle de tempo de contagem usa o esp-timer.
     O esp-timer tem o seguinte parâmetro:
      a. controle do tempo;

  5. Gerador de frequncias para testes usa o ledc
     O ledc tem o seguinte parâmetro:
      a. port de saida;
      b. canal de lcd;
      c. frequencia;
      d. resolucao do ledc;
      e. duty cycle em 5;


  Funcionamento:
    O port de controle de contagem em nível alto, libera o contador para contar os pulsos que chegam no port de entrada de pulsos.
  Os pulsos são contado tanto na subida quanto na descida do pulso, para melhorar a media de contagem.
  O tempo de contagem é definido pelo esp-timer, e esta' definido em 1 segundo, na variável janela.
  Se a contagem for maior que 20000 pulsos durante o tempo de contagem, ocorre overflow e a cada overflow que ocorre
  e' contabilizado na variável multPulses, e o contador de pulso retorna a zero continuando a contar.
    Quando o tempo de leitura termina, uma rotina é chamada e o valor do no contador de pulsos e' lido e salvo,
    um flag e' ligado indicando que terminou a leitura dos pulsos

    No loop, ao verificar que o flag indica que terminou a leitura dos pulsos, o valor é calculado multiplicando
  o numero de overflow por 20000 e somando ao numero de pulsos restantes e dividindo por 2, pois contou 2 vezes.
  Como o pulsos são contados na subida e na descida, a contagem e´ o dobro da frequência.
    Na frequência é insserido pontos e impressa no serial monitor.
  Os registradores são resetados e o port de controle de entrada é novamente elevado para nível alto e a contagem de
  pulsos se inicia.

  Tem também um gerador de sinais que gera 50.000 Hz, e pode ser usado para testes.
  Este gerador pode ser alterado para gerar frequencias até 40 MHz.
  Usamos o recurso ledc do ESP32 para gerar frequencia que pode ser usada como teste.
    O valor da frequencia base é 2 (ou 50.000) Hz, mas pode ser digitavo outo valor no serial monitor
    O duty foi fixado como 50%
    A resulução é calculada.
  O Port de saida deste gerador é definido na linha #define LEDC_GPIO.
  Atualmente está definido como GPIO 25.

  Internamente usando GPIO matrix,o pulso de entrada foi direcionado para o LED nativo do ESP32,
  assim o LED piscara na frequencia de entrada.

  O compilador usa as diretivas de compilacaoo para selecionar:
   Compilador Arduino ou IDF    automatico
   Uso de LCD                   LCD_ON ou LCD_OFF
   Uso de LCD I2C               LCD_I2C_ON ou LCD_I2C_OFF

  Referências:
  author=krzychb https://github.com/espressif/esp-idf/tree/master/examples/peripherals/pcnt
  resposta by Deouss » Thu May 17, 2018 3:07 pm no tópico https://esp32.com/viewtopic.php?t=5734
  Gerador de sinais Gustavo https://github.com/Gustavomurta/ESP32_frequenceMeter/blob/master/ESP32OscilatorV03.ino
  Formatação de numero https://arduino.stackexchange.com/questions/28603/the-most-effective-way-to-format-numbers-on-arduino
  https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/system/esp_timer.html
  https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/peripherals/pcnt.html
  Bibliotecas LCD e LCD I2C  https://github.com/UncleRus/esp-idf-lib
*/

#define LCD_ON                                                            // Define LCD_ON, para usar LCD, se não, defina LCD_OFF
#define LCD_I2C_OFF                                                       // Define LCD_I2C_ON, para usar LCD I2C, se não, defina LCD_I2C_OFF

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/portmacro.h"
#include "freertos/task.h"
#include "freertos/queue.h"
#include "driver/periph_ctrl.h"
#include "driver/ledc.h"
#include "driver/gpio.h"
#include "driver/pcnt.h"
#include "driver/ledc.h"
#include "esp_attr.h"
#include "esp_log.h"
#include "esp_timer.h"
#include "sdkconfig.h"
#include "math.h"

#include "driver/i2c.h"
#include "hd44780.h"
#include "pcf8574.h"

#define PCNT_COUNT_UNIT       PCNT_UNIT_0                                 // Unidade 0 do pcnt
#define PCNT_COUNT_CHANNEL    PCNT_CHANNEL_0                              // Canal 0 do pcnt

//                 Para usar teste jumper GPIO 25 com GPIO 34
//                 Port de entrada do frequencimetro  GPIO 34
#define PCNT_INPUT_SIG_IO     GPIO_NUM_34                                 // Freq Meter Input GPIO 34
#define LEDC_HS_CH0_GPIO      GPIO_NUM_25                                 // Saida do ledc gerador de pulsos

//                  Necessario jumper entre GPIO 32 e GPIO 35
#define PCNT_INPUT_CTRL_IO    GPIO_NUM_35                                 // Count Control GPIO HIGH = count up, LOW = count down
#define OUTPUT_CONTROL_GPIO   GPIO_NUM_32                                 // Saida do timer GPIO 32 Controla a contagem

#define IN_BOARD_LED          (gpio_num_t)2                               // LED nativo ESP32 GPIO 2

#define LEDC_HS_CH0_CHANNEL   LEDC_CHANNEL_0                              // LEDC no canal 0
#define LEDC_HS_MODE          LEDC_HIGH_SPEED_MODE                        // LEDC em high speed
#define LEDC_HS_TIMER         LEDC_TIMER_0                                // Usar timer0 do ledc

uint32_t         overflow  =  20000;                                      // Valor maximo para overflow de pcnt
#define PCNT_H_LIM_VAL        overflow                                    // Limite superior de contagem

esp_timer_create_args_t create_args;                                      // Argumentos do esp-timer
esp_timer_handle_t timer_handle;                                          // Instancia de esp-timer

//  Calculo do ajustes para cada faixa de frequencia
//  Resolucao = log2(Clock(80MHz)/f) + 1   ex: 50.000 HZ = 80.0000/50.000 = 1.600 log2(1600) = 10 + 1 = 11
//  Duty 50%  = (2**Resolucao)/2       ex: 2**11 = 2048   2048/2 = 1024

bool            flag          = true;                                     // Indicador de fim de contagem libera impressao
int16_t         pulses        = 0;                                        // Contador de pulsos de entrada
uint32_t        multPulses    = 0;                                        // Contador de overflows de pcnt
uint32_t        janela        = 1000000;                                  // Janela de 1 segundo para a contagem de pulsos
uint32_t        oscilator     = 2;                                        // Frequencia em Hz
uint32_t        mDuty         = 0;                                        // Valor calculado do duty
uint32_t        resolucao         = 0;                                    // Valor calculado da resolucao

#ifdef LCD_I2C_ON                                                         // Se tem LCD I2C
#define SDA_GPIO gpio_num_t(16)                                           // GPIO I2C SDA para o LCD
#define SCL_GPIO gpio_num_t(17)                                           // GPIO I2C SCL para o LCD
#define I2C_ADDR 0x38                                                     // Endereco I2C do PCF8574
static i2c_dev_t pcf8574;                                                 // Instancia PCF8574
#endif                                                                    // LCD I2C

#if defined LCD_ON || defined LCD_I2C_ON                                  // Se tem LCD
hd44780_t lcd = {};                                                       // Instancia LCD
#endif                                                                    // LCD

portMUX_TYPE timerMux = portMUX_INITIALIZER_UNLOCKED;                     // variavel tipo portMUX_TYPE para sincronismo
//----------------------------------------------------------------------------------------
#ifdef LCD_I2C_ON                                                         // Se tem LCD I2C

void configI2C() {                                                        // Configuracao LCD i2c
  i2c_config_t conf;                                                      // Cria o confif
  conf.mode = I2C_MODE_MASTER;                                            // Mode de operacao
  conf.sda_io_num = SDA_GPIO;                                             // GPIO SDA
  conf.scl_io_num = SCL_GPIO;                                             // GPIO SCL
  conf.sda_pullup_en = GPIO_PULLUP_ENABLE;                                // Pullup no SDA
  conf.scl_pullup_en = GPIO_PULLUP_ENABLE;                                // Pullup no SCL
  conf.master.clk_speed = 100000;                                         // Clock do i2s
  i2c_param_config(I2C_NUM_0, &conf);                                     //  Configura

  i2c_driver_install(I2C_NUM_0, I2C_MODE_MASTER, 0, 0, 0);                // Inicia o i2c
}
//----------------------------------------------------------------------------------------
static esp_err_t write_lcd_data(const hd44780_t *lcd, uint8_t data)
{
  return pcf8574_port_write(&pcf8574, data);                              // Grava dados no PCF8574
}
//----------------------------------------------------------------------------------------
void lcd_test()
{
  //  hd44780_t lcd = {};
  lcd.write_cb = write_lcd_data,                                          // Chama rotina de gravar dados no PCF8574
      lcd.font = HD44780_FONT_5X8,                                        // Define formato do caracter
          lcd.lines = 2,                                                  // Numero de linhas do LCD
  lcd.pins = {                                                            // Pinos do LCD no PCF8574
    .rs = 0,                                                              // RS
    .e  = 2,                                                              // Enable
    .d4 = 7,                                                              // D4
    .d5 = 6,                                                              // D5
    .d6 = 5,                                                              // D6
    .d7 = 4,                                                              // D7
    .bl = 3                                                               // LEd de iluminacao do LCD
  };

  memset(&pcf8574, 0, sizeof(i2c_dev_t));                                 // Aloca espaco na memoria para o PCF8574
  ESP_ERROR_CHECK(pcf8574_init_desc(&pcf8574, i2c_port_t(0), I2C_ADDR, SDA_GPIO, SCL_GPIO)); // Inicializa o  PCF8574
  ESP_ERROR_CHECK(hd44780_init(&lcd));                                    // Inicialisa o hd44780
  hd44780_switch_backlight(&lcd, true);                                   // Liga o LED
}
#endif                                                                    // LCD I2C
//----------------------------------------------------------------------------------------
#ifdef LCD_ON                                                             // Se tem LCD DIRETO

void lcd_init()                                                           // Rotina para inicialisar o LCD DIRETO
{
  lcd.font = HD44780_FONT_5X8,                                            // Define formato do caracter
      lcd.lines = 2;                                                      // Numero de linhas do DIRETO
  lcd.pins = {                                                            // Pinos do LCD DIRETO
    .rs = GPIO_NUM_5,                                                     // RS
    .e  = GPIO_NUM_18,                                                    // Enable
    .d4 = GPIO_NUM_19,                                                    // D4
    .d5 = GPIO_NUM_21,                                                    // D5
    .d6 = GPIO_NUM_22,                                                    // D6
    .d7 = GPIO_NUM_23,                                                    // D7
    .bl = HD44780_NOT_USED                                                // LEd de iluminacao do LCD DIRETO
  };
  ESP_ERROR_CHECK(hd44780_init(&lcd));                                    // Inicialisa o hd44780
}
#endif                                                                    // LCD DIRETO
//----------------------------------------------------------------------------------------
// Sem comentarios originais  https://arduino.stackexchange.com/questions/28603/the-most-effective-way-to-format-numbers-on-arduino
char *ultos_recursive(unsigned long val, char *s, unsigned radix, int pos)
{
  int c;
  if (val >= radix)
    s = ultos_recursive(val / radix, s, radix, pos + 1);
  c = val % radix;
  c += (c < 10 ? '0' : 'a' - 10);
  *s++ = c;
  if (pos % 3 == 0) *s++ = '.';
  return s;
}
//----------------------------------------------------------------------------------------
// Sem comentarios originais  https://arduino.stackexchange.com/questions/28603/the-most-effective-way-to-format-numbers-on-arduino
char *ltos(long val, char *s, int radix)
{
  if (radix < 2 || radix > 36) {
    s[0] = 0;
  } else {
    char *p = s;
    if (radix == 10 && val < 0) {
      val = -val;
      *p++ = '-';
    }
    p = ultos_recursive(val, p, radix, 0) - 1;
    *p = 0;
  }
  return s;
}
//----------------------------------------------------------------------------
void ledcInit ()
{
  resolucao = log((80000000 / oscilator) + 1) / log(2);                   // Calculo da resolucao para ledc
  if (resolucao > 20) resolucao = 20;                                     // Maxima resolucao é 20
  //  Serial.println(resolucao);                                          // Print
  mDuty = (pow(2, resolucao)) / 2;                                        // Calculo do duty para ledc
  //  Serial.println(mDuty);                                              // Print

  ledc_timer_config_t ledc_timer = {};                                    // Instancia a configuracao do timer do ledc

  ledc_timer.duty_resolution =  ledc_timer_bit_t(resolucao);              // Configura resolucao
  //ledc_timer.duty_resolution = (ledc_timer_bit_t) + resolucao;          // Configura resolucao
  ledc_timer.freq_hz    = oscilator;                                      // Frequencia de oscilacao
  ledc_timer.speed_mode = LEDC_HIGH_SPEED_MODE;                           // Mode de operacao em high speed
  ledc_timer.timer_num = LEDC_TIMER_0;                                    // Usar timer0 do ledc
  ledc_timer_config(&ledc_timer);                                         // Configurar o timer do ledc

  ledc_channel_config_t ledc_channel = {};                                // Instancia a configuracao canal do ledc

  ledc_channel.channel    = LEDC_HS_CH0_CHANNEL;                          // Configura canal0
  ledc_channel.duty       = mDuty;                                        // Valor calculado do duty em %
  ledc_channel.gpio_num   = LEDC_HS_CH0_GPIO;                             // Saida no GPIO defino no inicio
  ledc_channel.intr_type  = LEDC_INTR_DISABLE;                            // Desabilita interrupt de ledc
  ledc_channel.speed_mode = LEDC_HIGH_SPEED_MODE;                         // Mode de operacao do canal em high speed
  ledc_channel.timer_sel  = LEDC_TIMER_0;                                 // Usar timer0 do ledc

  ledc_channel_config(&ledc_channel);                                     // Configurar o canal do ledc
}
//----------------------------------------------------------------------------------
void tempo_controle(void *p)                                              // Fim de tempo de leitura de pulsos
{
  gpio_set_level(OUTPUT_CONTROL_GPIO, 0);                                 // Controle do PCount - stop count
  pcnt_get_counter_value(PCNT_COUNT_UNIT, &pulses);                       // Obtem o valor contado
  flag = true;                                                            // Informa que ocorreu interrupt de controle
}
//----------------------------------------------------------------------------------
static void IRAM_ATTR pcnt_intr_handler(void *arg)                        // Overflow de contagem de pulsos
{
  portENTER_CRITICAL_ISR(&timerMux);                                      // Desabilita interrupção ?
  multPulses++;                                                           // Incrementa contador de overflow
  PCNT.int_clr.val = BIT(PCNT_COUNT_UNIT);                                // Limpa indicador de interrupt
  portEXIT_CRITICAL_ISR(&timerMux);                                       // Libera novo interrupt
}
//----------------------------------------------------------------------------------
void pcnt_init(void)                                                      // Rotina de inicializacao do pulse count
{
  pcnt_config_t pcnt_config = { };                                        // Instancia pulse config

  pcnt_config.pulse_gpio_num = PCNT_INPUT_SIG_IO;                         // Port de entrada dos pulsos
  pcnt_config.ctrl_gpio_num = PCNT_INPUT_CTRL_IO;                         // Controle da contagem
  pcnt_config.unit = PCNT_COUNT_UNIT;                                     // Unidade de contagem
  pcnt_config.channel = PCNT_COUNT_CHANNEL;                               // Canal de contagem
  pcnt_config.counter_h_lim = PCNT_H_LIM_VAL;                             // Limite maximo de contagem
  pcnt_config.pos_mode = PCNT_COUNT_INC;                                  // Conta na subida do pulso
  pcnt_config.neg_mode = PCNT_COUNT_INC;                                  // Conta na descida do pulso
  pcnt_config.lctrl_mode = PCNT_MODE_DISABLE;                             // Nao usado
  pcnt_config.hctrl_mode = PCNT_MODE_KEEP;                                // Se HIGH conta incrementando
  pcnt_unit_config(&pcnt_config);                                         // Inicializa PCNT

  pcnt_counter_pause(PCNT_COUNT_UNIT);                                    // Inicializa o contador PCNT
  pcnt_counter_clear(PCNT_COUNT_UNIT);                                    // Zera o contador PCNT

  pcnt_event_enable(PCNT_COUNT_UNIT, PCNT_EVT_H_LIM);                     // Limite superior de contagem
  pcnt_isr_register(pcnt_intr_handler, NULL, 0, NULL);                    // Rotina de Interrupt de pcnt
  pcnt_intr_enable(PCNT_COUNT_UNIT);                                      // Habilita interrup de pcnt

  pcnt_counter_resume(PCNT_COUNT_UNIT);                                   // inicia a contagem
}
//----------------------------------------------------------------------------------
void myInit()
{
#ifdef LCD_ON                                                             // LCD direto
  lcd_init();                                                             // LCD direto
#endif                                                                    // LCD direto

#ifdef LCD_I2C_ON                                                         // LCD  I2C
  configI2C();                                                            // LCD  I2C
  ESP_ERROR_CHECK(i2cdev_init());                                         // LCD  I2C
  lcd_test();                                                             // LCD  I2C
#endif                                                                    // LCD  I2C

  ledcInit();                                                             // Inicializa o ledc
  pcnt_init();                                                            // Inicializa o pulse count
  gpio_pad_select_gpio(OUTPUT_CONTROL_GPIO);                              // Define o port decontrole
  gpio_set_direction(OUTPUT_CONTROL_GPIO, GPIO_MODE_OUTPUT);              // Define o port de controle como saida

  create_args.callback = tempo_controle;                                  // Instancia o tempo de controle
  esp_timer_create(&create_args, &timer_handle);                          // Cria parametros do timer

  gpio_set_direction(IN_BOARD_LED, GPIO_MODE_OUTPUT);                     // Port LED como saida

  gpio_matrix_in(PCNT_INPUT_SIG_IO, SIG_IN_FUNC226_IDX, false);           // Direciona a entrada de pulsos
  gpio_matrix_out(IN_BOARD_LED, SIG_IN_FUNC226_IDX, false, false);        // Para o LED do ESP32
}
//---------------------------------------------------------------------------------
void app_main(void)
{
#ifndef ARDUINO                                                           // IDF
  myInit();                                                               // IDF
  while (1)                                                               // IDF
  {
#endif                                                                    // IDF
    if (flag == true)                                                     // Se a contagem tiver terminado
    {
      flag = false;                                                       // Impede nova impresao
      float frequencia = 0;                                               // Variavel para calculo de frequencia
      frequencia = (pulses + (multPulses * overflow)) / 2  ;              // Calcula qtos pulsos ocorreram
      char buf[32];                                                       // Buffer para guardar a pontuacao
      printf("frequencia: %s", (ltos(frequencia, buf, 10)));              // Imprime pontuado
      printf(" Hz \n");                                                   // Sufixo
#if defined LCD_ON || defined LCD_I2C_ON                                                        // LCD
      hd44780_gotoxy(&lcd, 2, 0);                                         // Posiciona cusros na posicao 2 da linha 0
      hd44780_puts(&lcd, "frequencia:");                                  // Print
      hd44780_gotoxy(&lcd, 2, 1);                                         // Posiciona cusros na posicao 2 da linha 1
      hd44780_puts(&lcd, (ltos(frequencia, buf, 10)));                    // Print
      hd44780_puts(&lcd, " Hz              ");                            // Print
#endif
      multPulses = 0;                                                     // Zera contador de overflow
      // Aqui pode rodar qq funcao                                        // Espaco para qualquer função
      vTaskDelay(1);
      // Aqui pode rodar qq funcao                                        // Espaco para qualquer função
      pcnt_counter_clear(PCNT_COUNT_UNIT);                                // Zera o contador PCNT
      esp_timer_start_once(timer_handle, janela);                         // Inicia contador de tempo de 1 segundo
      gpio_set_level(OUTPUT_CONTROL_GPIO, 1);                             // Porta de controle habilita contagem dos pulsos
    }
#ifndef ARDUINO                                                           // IDF
  }                                                                       // IDF
#endif                                                                    // IDF
}
//---------------------------------------------------------------------------------
#ifdef ARDUINO                                                            // Arduino
void setup()                                                              // Arduino
{
  Serial.begin(115200);                                                   // Inicializa a serial
  myInit();                                                               // Chaama inicializacao
}                                                                         // Arduino
//---------------------------------------------------------------------------------
void loop()                                                               // Arduino
{
  app_main();                                                             // Roda rotina principal
  String inputString = "";                                                // Temporaria transformar o valor da frequencia
  oscilator = 0;                                                          // Limpa valor original
  while (Serial.available())                                              // Enquanto tiver dados na serial
  { //
    char inChar = (char)Serial.read();                                    // Le um byte:
    inputString += inChar;                                                // Adicione na string:
    if (inChar == '\n')                                                   // Se new line:
    {
      oscilator = inputString.toInt();                                    // Transforma a string em inteiro
      inputString = "";                                                   // Limpa a string
    }
  }
  if (oscilator != 0)                                                     // Se foi digitado algum valor
  {
    ledcInit();                                                           // Reconfigura ledc
  }
}
#endif                                                                    // Arduino