banner

Ir para o Forum

Turbina Elétrica com ESP32



Uma Turbina Elétrica com ESP32. Essa é a montagem que trago hoje, que tem parte impressa em 3D. Vou te apresentar uma função PWM do ESP32, própria para controlar motores elétricos, empregada em um motor DC. Vou ainda demonstrar em uma aplicação prática o funcionamento deste MCPWM (Motor Control PWM).


Utilizei neste projeto o ESP32 LoRa e acho importante destacar aqui que esse microcontrolador tem dentro dele dois blocos. Cada um destes blocos é capaz de controlar três motores cada. Ou seja, é possível controlar até seis motores com PWM, todos de forma independente. Isso quer dizer que o controle que vou usar aqui não é aquele padrão, parecido com o do Arduino, mas, sim, do próprio chip, o que garante ao ESP32 uma flexibilidade muito grande no que diz respeito ao controle de motores.




Demonstração






PWM de controle de motor

Diagrama Geral:


·         A função MCPWM do ESP32 pode ser usada para controlar diversos tipos de motores elétricos. Ele conta com duas unidades.
·         Cada unidade tem três pares de saída PWM.
·         Cada par A/B de saída pode ser sincronizado com um dos três Timers de sincronização 0, 1 ou 2.
·         Um mesmo Timer pode ser usado para sincronizar mais de um par de saída PWM


Diagrama completo:


·         Cada unidade também é capaz de coletar sinais de entrada como SINAIS DE SINCRONIZAÇÃO;
·         Detectar SINAIS DE FALHA como sobrecorrente ou sobretensão do motor;
·         Obter feedback com SINAIS DE CAPTURA como, por exemplo, a posição do rotor



Recursos usados

·         Jumpers para conexão
·         Heltec Wifi LoRa 32
·         Motor DC comum
·         Ponte H - L298N
·         Cabo USB
·         Protoboard
·         Fonte de alimentação





ESP 32 Dev Kit – Pinout





Montagem da turbina






Circuito – Ligações





Medida no osciloscópio




Código Fonte

Cabeçalho

#include <Arduino.h>        //Não é necessário caso use Arduino IDE
#include "driver/mcpwm.h"   //inclui a biblioteca "Motor Control PWM" nativa do ESP32
#include <Wire.h>  // Necessário apenas para o Arduino 1.6.5 e posterior
#include "SSD1306.h" // o mesmo que #include "SSD1306Wire.h"

//OLED_SDA -- GPIO4
//OLED_SCL -- GPIO15
//OLED_RST -- GPIO16

#define SDA    4
#define SCL   15
#define RST   16 

SSD1306  display(0x3c, SDA, SCL, RST); //Instanciando e ajustando os pinos do objeto "display"

#define GPIO_PWM0A_OUT 12   //Declara GPIO 12 como PWM0A
#define GPIO_PWM0B_OUT 14   //Declara GPIO 14 como PWM0B




Setup

void setup() {
  Serial.begin(115200);

  display.init();

  //display.flipScreenVertically(); //Vira a tela verticalmente
  display.clear();
  //ajusta o alinhamento para a esquerda
  display.setTextAlignment(TEXT_ALIGN_LEFT);
  //ajusta a fonte para Arial 16
  display.setFont(ArialMT_Plain_16);
  
  //mcpwm_gpio_init(unidade PWM 0, saida A, porta GPIO)     => Instancia o MCPWM0A no pino GPIO_PWM0A_OUT declarado no começo do código
  mcpwm_gpio_init(MCPWM_UNIT_0, MCPWM0A, GPIO_PWM0A_OUT);

  //mcpwm_gpio_init(unidade PWM 0, saida B, porta GPIO)     => Instancia o MCPWM0B no pino GPIO_PWM0B_OUT declarado no começo do código
  mcpwm_gpio_init(MCPWM_UNIT_0, MCPWM0B, GPIO_PWM0B_OUT); 

  mcpwm_config_t pwm_config;

  pwm_config.frequency = 1000;                          //frequência = 500Hz,
  pwm_config.cmpr_a = 0;                                //Ciclo de trabalho (duty cycle) do PWMxA = 0
  pwm_config.cmpr_b = 0;                                //Ciclo de trabalho (duty cycle) do PWMxb = 0
  pwm_config.counter_mode = MCPWM_UP_COUNTER;           //Para MCPWM assimetrico
  pwm_config.duty_mode = MCPWM_DUTY_MODE_0;             //Define ciclo de trabalho em nível alto
  //Inicia(Unidade 0, Timer 0, Config PWM)
  mcpwm_init(MCPWM_UNIT_0, MCPWM_TIMER_0, &pwm_config); //Define PWM0A & PWM0B com as configurações acima
}



Funções

//Função que configura o MCPWM operador A (Unidade, Timer, Porcentagem (ciclo de trabalho))
static void brushed_motor_forward(mcpwm_unit_t mcpwm_num, mcpwm_timer_t timer_num , float duty_cycle)
{
  //mcpwm_set_signal_low(unidade PWM(0 ou 1), Número do timer(0, 1 ou 2), Operador (A ou B));    => Desliga o sinal do MCPWM no Operador B (Define o sinal em Baixo)
    mcpwm_set_signal_low(mcpwm_num, timer_num, MCPWM_OPR_B);

  //mcpwm_set_duty(unidade PWM(0 ou 1), Número do timer(0, 1 ou 2), Operador (A ou B), Ciclo de trabalho (% do PWM));    => Configura a porcentagem do PWM no Operador A (Ciclo de trabalho)
    mcpwm_set_duty(mcpwm_num, timer_num, MCPWM_OPR_A, duty_cycle);
        
  //mcpwm_set_duty_tyoe(unidade PWM(0 ou 1), Número do timer(0, 1 ou 2), Operador (A ou B), Nível do ciclo de trabalho (alto ou baixo));    => define o nível do ciclo de trabalho (alto ou baixo)        
    mcpwm_set_duty_type(mcpwm_num, timer_num, MCPWM_OPR_A, MCPWM_DUTY_MODE_0);
    //Nota: Chame essa função toda vez que for chamado "mcpwm_set_signal_low" ou "mcpwm_set_signal_high" para manter o ciclo de trabalho configurado anteriormente
}

//Função que configura o MCPWM Do operador B (Unidade, Timer, Porcentagem (ciclo de trabalho))
static void brushed_motor_backward(mcpwm_unit_t mcpwm_num, mcpwm_timer_t timer_num , float duty_cycle)
{
    mcpwm_set_signal_low(mcpwm_num, timer_num, MCPWM_OPR_A);                    //Desliga o sinal do MCPWM no Operador A (Define o sinal em Baixo)
    mcpwm_set_duty(mcpwm_num, timer_num, MCPWM_OPR_B, duty_cycle);              //Configura a porcentagem do PWM no Operador B (Ciclo de trabalho)
    mcpwm_set_duty_type(mcpwm_num, timer_num, MCPWM_OPR_B, MCPWM_DUTY_MODE_0);  //define o nível do ciclo de trabalho (alto ou baixo)
}

//Função que para o MCPWM de ambos os Operadores
static void brushed_motor_stop(mcpwm_unit_t mcpwm_num, mcpwm_timer_t timer_num)
{
    mcpwm_set_signal_low(mcpwm_num, timer_num, MCPWM_OPR_A); //Desliga o sinal do MCPWM no Operador A
    mcpwm_set_signal_low(mcpwm_num, timer_num, MCPWM_OPR_B); //Desliga o sinal do MCPWM no Operador B
}


Loop

void loop() {
  //Move o motor no sentido horário
  brushed_motor_forward(MCPWM_UNIT_0, MCPWM_TIMER_0, 50.0);
  oled("50");
  delay(2000);

  //Para o motor
  brushed_motor_stop(MCPWM_UNIT_0, MCPWM_TIMER_0);
  oled("0");
  delay(2000);

  //Move o motor no sentido antihorário
  brushed_motor_backward(MCPWM_UNIT_0, MCPWM_TIMER_0, 25.0);
  oled("25");
  delay(2000);

  //Para o motor
  brushed_motor_stop(MCPWM_UNIT_0, MCPWM_TIMER_0);
  oled("0");
  delay(2000);

  // Aceleracao i de 1 a 100
  for(int i=10;i<=100;i++){
    brushed_motor_forward(MCPWM_UNIT_0, MCPWM_TIMER_0, i);
    oled(String(i));
    delay(200);
  }

  // Desaceleração i de 100 a 1
  delay(5000);
  for(int i=100;i>=10;i--){
    brushed_motor_forward(MCPWM_UNIT_0, MCPWM_TIMER_0, i);
    oled(String(i));
    delay(100);
  }
  delay(5000);

}






Faça o download dos arquivos


4 comentários:

  1. Vc vai disponibilizar o projeto para impressão?

    ResponderExcluir
    Respostas
    1. Olá, amigo. O link para download está aí acima, ao fim do artigo. Abraço

      Excluir
  2. o projeto fico show demais, parabéns.

    ResponderExcluir
  3. Fernando, por gentileza faça um video sobre conexão do esp8266 com o arduino wemos mega wifi, faça um exemplo usando o modo especial, pois não tem um tutorial completo sobre essa placa

    ResponderExcluir

Tecnologia do Blogger.