RuiViana

NovoTeste_IDE.ino

Jul 10th, 2020
1,408
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 "driver/ledc.h"
  11. #include "esp_attr.h"
  12. #include "esp_log.h"
  13. #include "esp_timer.h"
  14. #include "sdkconfig.h"
  15.  
  16. #define PCNT_COUNT_UNIT       PCNT_UNIT_0                                 // Unidade 0 do pcnt
  17. #define PCNT_COUNT_CHANNEL    PCNT_CHANNEL_0                              // Canal 0 do pcnt
  18. #define PCNT_INPUT_SIG_IO     34                                          // Freq Meter Input GPIO 34
  19. #define PCNT_INPUT_CTRL_IO    35                                          // Count Control GPIO HIGH=count up, LOW=count down GPIO 25
  20. #define OUTPUT_CONTROL_GPIO   GPIO_NUM_32                                  // Saida do timer GPIO 2
  21.  
  22. #define PCNT_H_LIM_VAL        overflow                                    // Limite superior de contagem
  23.  
  24. esp_timer_create_args_t create_args;                                      // Argumentos do timer
  25. esp_timer_handle_t timer_handle;                                          // Instancia de timer
  26.  
  27. unsigned long overflow = 20000;                                           // Valor maximo para overflow de pcnt
  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 1 segundo para a contagem de pulsos
  32.  
  33. portMUX_TYPE timerMux = portMUX_INITIALIZER_UNLOCKED;
  34.  
  35. // Parametro do ledc
  36. //#define LEDC_HS_TIMER          LEDC_TIMER_0
  37. //#define LEDC_HS_CH0_GPIO       GPIO_NUM_25                                 // Saida da frequencia gerada pelo LEDc
  38. //#define MODE                   LEDC_HIGH_SPEED_MODE
  39.  
  40. #define LEDC_HS_CH0_CHANNEL    LEDC_CHANNEL_0
  41. #define LEDC_HS_CH0_GPIO       (25)
  42. #define LEDC_HS_MODE           LEDC_HIGH_SPEED_MODE
  43. #define LEDC_HS_TIMER          LEDC_TIMER_0
  44.  
  45. uint32_t  freque = 5000;                                                     // Frequencia em Hz
  46. //----------------------------------------------------------------------------
  47. void ledcInit ()
  48. {
  49.   ledc_timer_config_t ledc_timer = {};
  50.   ledc_timer.duty_resolution = LEDC_TIMER_13_BIT; // resolution of PWM duty
  51.   ledc_timer.freq_hz = freque;                      // frequency of PWM signal
  52.   ledc_timer.speed_mode = LEDC_HS_MODE;           // timer mode
  53.   ledc_timer.timer_num = LEDC_HS_TIMER;            // timer index
  54.  
  55.   ledc_timer_config(&ledc_timer);
  56.  
  57.   ledc_channel_config_t ledc_channel = {};
  58.  
  59.   ledc_channel.channel    = LEDC_HS_CH0_CHANNEL;
  60.   ledc_channel.duty       = 50;
  61.   ledc_channel.gpio_num   = LEDC_HS_CH0_GPIO;
  62.   ledc_channel.speed_mode = LEDC_HS_MODE;
  63.   ledc_channel.hpoint     = 16;
  64.   ledc_channel.timer_sel  = LEDC_HS_TIMER;
  65.  
  66.   ledc_channel_config(&ledc_channel);
  67.  
  68. }
  69. //----------------------------------------------------------------------------------
  70. void tempo_controle(void *p)                                              // Fim de tempo de leitura de pulsos
  71. {
  72.   gpio_set_level(OUTPUT_CONTROL_GPIO, LOW);                               // Controle do PCount - stop count
  73.   pcnt_get_counter_value(PCNT_COUNT_UNIT, &pulses);                       // Obtem o valor contado
  74.   flag = true;                                                            // Informa que ocorreu interrupt de controle
  75. }
  76.  
  77. //----------------------------------------------------------------------------------
  78. static void IRAM_ATTR pcnt_intr_handler(void *arg)                        // Overflow de contagem de pulsos
  79. {
  80.   portENTER_CRITICAL_ISR(&timerMux);                                      // Desabilita interrupção ?
  81.   multPulses++;                                                           // Incrementa contador de overflow
  82.   PCNT.int_clr.val = BIT(PCNT_COUNT_UNIT);                                // Limpa indicador de interrupt
  83.   portEXIT_CRITICAL_ISR(&timerMux);                                       // Libera novo interrupt
  84. }
  85.  
  86. //----------------------------------------------------------------------------------
  87. void pcnt_init(void)                                                      // Rotina de inicializacao do pulse count
  88. {
  89.   pcnt_config_t pcnt_config = { };                                        // Instancia pulse config
  90.   pcnt_config.pulse_gpio_num = PCNT_INPUT_SIG_IO;                         // Port de entrada dos pulsos
  91.   pcnt_config.ctrl_gpio_num = PCNT_INPUT_CTRL_IO;                         // Controle da contagem
  92.   pcnt_config.unit = PCNT_COUNT_UNIT;                                     // Unidade de contagem
  93.   pcnt_config.channel = PCNT_COUNT_CHANNEL;                               // Canal de contagem
  94.   pcnt_config.counter_h_lim = PCNT_H_LIM_VAL;                             // Limite maximo de contagem
  95.   pcnt_config.pos_mode = PCNT_COUNT_INC;                                  // Conta na subida do pulso
  96.   pcnt_config.neg_mode = PCNT_COUNT_INC;                                  // Conta na descida do pulso
  97.   pcnt_config.lctrl_mode = PCNT_MODE_DISABLE;                             // Nao usado
  98.   pcnt_config.hctrl_mode = PCNT_MODE_KEEP;                                // Se HIGH conta incrementando
  99.   pcnt_unit_config(&pcnt_config);                                         // Inicializa PCNT
  100.  
  101.   pcnt_counter_pause(PCNT_COUNT_UNIT);                                    // Inicializa o contador PCNT
  102.   pcnt_counter_clear(PCNT_COUNT_UNIT);                                    // Zera o contador PCNT
  103.  
  104.   pcnt_event_enable(PCNT_COUNT_UNIT, PCNT_EVT_H_LIM);                     // Limite superior de contagem
  105.   pcnt_isr_register(pcnt_intr_handler, NULL, 0, NULL);                    // Rotina de Interrupt de pcnt
  106.   pcnt_intr_enable(PCNT_COUNT_UNIT);                                      // Habilita interrup de pcnt
  107.  
  108.   pcnt_counter_resume(PCNT_COUNT_UNIT);                                   // inicia a contagem
  109. }
  110. //----------------------------------------------------------------------------------
  111. void myInit()
  112. {
  113.   ledcInit();
  114.   pcnt_init();                                                            // Inicializa o pulse count
  115.   gpio_pad_select_gpio(OUTPUT_CONTROL_GPIO);                              // Define o port decontrole
  116.   gpio_set_direction(OUTPUT_CONTROL_GPIO, GPIO_MODE_OUTPUT);              // Define o port de controle como saida
  117.  
  118.   create_args.callback = tempo_controle;                                  // Instancia o tempo de controle
  119.   esp_timer_create(&create_args, &timer_handle);                          // Cria parametros do timer
  120. }
  121. //---------------------------------------------------------------------------------
  122. void app_main(void)
  123. {
  124. //  myInit();
  125. //  while (1)
  126. //  {
  127.     if (flag == true)                                                       // Se a contagem tiver terminado
  128.     {
  129.       flag = false;                                                         // Impede nova impresao
  130.       float frequencia = 0;                                                 // Variavel para calculo de frequencia
  131.       frequencia = (pulses + (multPulses * overflow))  ;                    // Calcula qtos pulsos ocorreram
  132.       //    Serial.print("  Frequencia: ");                                       // Print
  133.       //    Serial.println ((frequencia / 2 ), 0);                                // Print
  134.       printf("frequencia :%f\n", frequencia / 2);                             // Print
  135.  
  136.       multPulses = 0;                                                       // Zera contador de overflow
  137.  
  138.       // Aqui pode rodar qq funcao                                          // Espaco para qualquer função
  139.       //delay(50);                                                            // Espaco para qualquer função
  140.       vTaskDelay(1);
  141.       // Aqui pode rodar qq funcao                                          // Espaco para qualquer função
  142.  
  143.       pcnt_counter_clear(PCNT_COUNT_UNIT);                                  // Zera o contador PCNT
  144.       esp_timer_start_once(timer_handle, janela);                           // Inicia contador de tempo de 1 segundo
  145.       gpio_set_level(OUTPUT_CONTROL_GPIO, 1);                            // Porta de controle habilita contagem dos pulsos
  146.     }
  147.   }
  148. //}
  149. //---------------------------------------------------------------------------------
  150. void setup()
  151. {
  152.   Serial.begin(115200);                                                   // Inicializa a serial
  153.   myInit();
  154. }
  155. //---------------------------------------------------------------------------------
  156. void loop()
  157. {
  158.   app_main();
  159. }
RAW Paste Data