RuiViana

Freq_pnct_V21_IDF.c

Jul 8th, 2020
1,310
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <stdio.h>
  2. #include "freertos/FreeRTOS.h"
  3. #include "freertos/portmacro.h"
  4. #include "freertos/task.h"
  5. #include "freertos/queue.h"
  6. #include "driver/periph_ctrl.h"
  7. #include "driver/ledc.h"
  8. #include "driver/gpio.h"
  9. #include "driver/pcnt.h"
  10. #include "esp_attr.h"
  11. #include "esp_log.h"
  12. #include "esp_timer.h"
  13. #include "sdkconfig.h"
  14.  
  15. unsigned long overflow = 20000;                                           // Valor maximo para overun de pcnt
  16.  
  17. #define PCNT_COUNT_UNIT       PCNT_UNIT_0                                 // Unidade de pcnt
  18. #define PCNT_COUNT_CHANNEL    PCNT_CHANNEL_0                              // Canal pcnt
  19. #define PCNT_INPUT_SIG_IO     34                                          // Pulse Input GPIO
  20. #define PCNT_INPUT_CTRL_IO    35                                          // Control GPIO HIGH=count up, LOW=count down
  21. #define OUTPUT_CONTROL_GPIO   GPIO_NUM_32                                 // Saida de controle
  22.  
  23. #define PCNT_H_LIM_VAL      overflow                                      // Limite superior de contagem
  24.  
  25. esp_timer_create_args_t create_args;                                      // Argumentos do timer
  26. esp_timer_handle_t timer_handle;                                          // Instancia de timer
  27.  
  28. bool flag = true;                                                         // Indicador de fim de contagem libera impressao
  29. int16_t pulses = 0;                                                       // Contador de pulsos de entrada
  30. unsigned long multPulses = 0;                                             // Contador de overflows de pcnt
  31. unsigned long  janela = 1000000;                                          // Janela de contagem de pulsos
  32. portMUX_TYPE timerMux = portMUX_INITIALIZER_UNLOCKED;
  33.  
  34. //----------------------------------------------------------------------------------
  35. void tempo_controle(void *p)                                              // Fim de tempo de leitura de puslos
  36. {
  37.   gpio_set_level(OUTPUT_CONTROL_GPIO, 0);                                 // Desliga o controle do pcnt
  38.   pcnt_get_counter_value(PCNT_COUNT_UNIT, &pulses);                       // Obtem o valor contado
  39.   flag = true;                                                            // Informa que ocorreu interrupt de controle
  40. }
  41. //----------------------------------------------------------------------------------
  42. static void IRAM_ATTR pcnt_intr_handler(void *arg)                        // Overflow de contagem de pulsos
  43. {
  44.   PCNT.int_clr.val = BIT(PCNT_COUNT_UNIT);                                // Limpa indicador de interrupt
  45.   portENTER_CRITICAL_ISR(&timerMux);                                      // Bloqueia novo interrupt
  46.   multPulses++;                                                           // Incrementa contador de overflow
  47.   portEXIT_CRITICAL_ISR(&timerMux);                                       // Libera novo interrupt
  48. }
  49. //----------------------------------------------------------------------------------
  50. void pcnt_init(void)                                                      // Rotina de inicializacao do pulse count
  51. {
  52.   pcnt_config_t pcnt_config = { };                                        // Instancia pulse config
  53.   pcnt_config.pulse_gpio_num = PCNT_INPUT_SIG_IO;                         // Port de entrada dos pulsos
  54.   pcnt_config.ctrl_gpio_num = PCNT_INPUT_CTRL_IO;                         // Controle da contagem
  55.   pcnt_config.unit = PCNT_COUNT_UNIT;                                     // Unidade de contagem
  56.   pcnt_config.channel = PCNT_COUNT_CHANNEL;                               // Canal de contagem
  57.   pcnt_config.counter_h_lim = PCNT_H_LIM_VAL;                             // Limite maximo de contagem
  58.   pcnt_config.pos_mode = PCNT_COUNT_INC;                                  // Conta na subida do pulso
  59.   pcnt_config.neg_mode = PCNT_COUNT_INC;                                  // Conta na descida do pulso
  60.   pcnt_config.lctrl_mode = PCNT_MODE_DISABLE;                             // Nao usado
  61.   pcnt_config.hctrl_mode = PCNT_MODE_KEEP;                                // Se HIGH conta incrementando
  62.   pcnt_unit_config(&pcnt_config);                                         // Inicializa PCNT
  63.  
  64.   pcnt_counter_pause(PCNT_COUNT_UNIT);                                    // Inicializa o contador PCNT
  65.   pcnt_counter_clear(PCNT_COUNT_UNIT);                                    // Zera o contador PCNT
  66.   pcnt_counter_resume(PCNT_COUNT_UNIT);                                   // inicia a contagem
  67.  
  68.   pcnt_event_enable(PCNT_COUNT_UNIT, PCNT_EVT_H_LIM);                     // Limite superior de contagem
  69.   pcnt_isr_register(pcnt_intr_handler, NULL, 0, NULL);                    // Rotina de Interrupt de pcnt
  70.   pcnt_intr_enable(PCNT_COUNT_UNIT);                                      // Habilita interrup de pcnt
  71. }
  72. //----------------------------------------------------------------------------------
  73. void app_main(void)
  74. {
  75.    pcnt_init();                                                            // Inicializa o pulse count
  76.   gpio_pad_select_gpio(OUTPUT_CONTROL_GPIO);                              // Define o port decontrole
  77.   gpio_set_direction(OUTPUT_CONTROL_GPIO, GPIO_MODE_OUTPUT);              // Define como saida
  78.  
  79.   create_args.callback = tempo_controle;                                  // Instancia o tempo de controel
  80.   esp_timer_create(&create_args, &timer_handle);                          // Cria parametros do timer
  81.  
  82.   while (1)
  83.   {
  84.     if (flag == true)                                                       // Se impressa estiver liberada
  85.     {
  86.       flag = false;                                                         // Impede nova impresao
  87.       float frequencia = 0;                                                 // Variavel para calculo de frequencia
  88.       frequencia = (pulses + (multPulses * overflow))  ;                    // Calcula qtos pulsos ocorram
  89.       printf("frequencia :%f\n", frequencia);                               // Print
  90.       multPulses = 0;                                                       // Zera contador de overflow
  91.  
  92.       // Aqui pode rodar qq funcao                                          // Espaco para qualquer função
  93.       //delay(50);                                                            // Espaco para qualquer função
  94.       vTaskDelay(1);
  95.       // Aqui pode rodar qq funcao                                          // Espaco para qualquer função
  96.  
  97.       pcnt_counter_clear(PCNT_COUNT_UNIT);                                  // Zera o contador PCNT
  98.       esp_timer_start_once(timer_handle, janela);                           // Disparo unico de tempo de finido na variavel Janela
  99.       gpio_set_level(OUTPUT_CONTROL_GPIO, 1);                               // Libera port de contagem
  100.     }
  101.   }
  102. }
RAW Paste Data