AULA 7 - Microcontroladores - Eng

<< Página do curso

MATERIAIS

Por aluno:

• 1 placa Arduino Uno
• cabo de comunicação/alimentação USB
• 1 computador PC com software Arduino IDE instalado
• 1 proto shield para montagens
• 2 motores CC de 5V;
• 1 circuito integrado L293D ou módulo Ponte H;
• cabos fêmea-macho

METODOLOGIA

• Exposição dialogada dos conteúdos disponíveis, em projetor multimídia.
• Navegação assistida em outros sites e portais, de conteúdos relacionados.
• Montagens práticas e desenvolvimento em computador de aplicativos.
• Testes de verificação e validação.

Como vimos na aula anterior, acionar um motor DC utilizando-se o Arduino exige um circuito auxiliar de controle da velocidade e proteção.

No entanto, existem componentes que facilitam esse trabalho, como é o caso da Ponte H.

Diagrama de um circuito "Ponte H"

Ponte H é um circuito de eletrônica de potência do tipo chopper de classe E, isto é, que converte uma fonte fixa de corrente contínua, em uma tensão de corrente contínua variável, abrindo e fechando diversas vezes.

Dessa forma, a ponte H pode determinar o sentido da corrente, a polaridade da tensão e a magnitude da tensão, em um dado sistema ou componente.

Seu funcionamento dá-se pelo chaveamento de componentes eletrônicos, usualmente utilizando do método de PWM, para determinar, além da polaridade, o módulo da tensão, em um dado ponto de um circuito.

Tem como principal função, o controle de velocidade e sentido de motores DC escovados, podendo também ser usado para controle da saída de um gerador DC ou como inversor monofásico.

O termo Ponte "H", é derivado da representação gráfica típica deste circuito.

Esquema de Funcionamento

A Ponte H nada mais é que um arranjo de 4 transistores. Este circuito é uma elegante solução por ser capaz de acionar simultaneamente dois motores controlando não apenas seus sentidos, como também suas velocidades. Além de seu uso ser simples no Arduino.

Mas como funciona a Ponte H? Porque este nome?

As pontes H em possuem este nome devido ao formato que é montado o circuito, semelhante a letra H.

O circuito utiliza quatro chaves (S1, S2, S3 e S4) que são acionadas de forma alternada, ou seja, (S1-S3) ou (S2-S4), conforme a figura acima.

Fechando-se em conjunto as chaves S1 e S4, o terminal direito do motor fica com uma tensão mais positiva que o esquerdo, fazendo a corrente fluir da direita para a esquerda. Deste modo, o motor adquire sentido de giro que denotaremos por Sentido 1.

Fechando-se em conjunto as chaves S3 e S2, o terminal esquerdo do motor fica com uma tensão mais positiva que o direito, fazendo a corrente fluir da esquerda para a direita. Deste modo, o motor adquire sentido de giro que denotaremos por Sentido 2, que é inverso ao Sentido 1.

Ao acionar em conjunto as chaves S1 e S3 ou S2 e S4 provocamos um curto nos terminais do motor. Isso é necessário quando deseja-se frear um motor já em movimento ou aumentar a dificuldade de giro do eixo por um fator externo.

Tal efeito é alcançado pois a máquina DC passa a se comportar com um gerador quando tem seu eixo em movimento, tanto no caso da rotação, quanto no caso do giro do eixo por fator externo. Ao criar-se um curto circuito entre os terminais da máquina nesse estado, o torque necessário para manter ou colocar o motor em giro cresce, visto a necessidade de corrente exigida da máquina para seu movimento, o que causa o efeito dito, chamado "freio motor".

As chaves S1 e S2 não podem ser fechadas simultaneamente, assim como as chaves S3 e S4, pois o fechamento em conjunto de tais chaves causaria um curto na fonte de alimentação.

Pode-se fazer o uso de PWM nas chaves para controlar a tensão média aplicada sobre o motor, e assim, controlar a velocidade da máquina DC.

Substituindo o motor por um gerador DC, teremos um funcionamento análogo ao apresentado anteriormente, apenas com a diferença de que a corrente é feita no gerador, e a ligação da chave aos pares determina a polaridade na carga para um dado sentido. A aplicação do freio motor não é desejado quando a ponte H é submetido a esse modo de operação.

Como inversor monofásico a ativação dos pares de chave ficam se alternado periodicamente gerando uma frequência definida, e aplica-se PWM a fim de obter-se uma simulação de senoide.

Circuitos auxiliares

Como dito na seção funcionamento, deve-se tomar cuidado para não acionar em conjunto duas chaves que estejam em série, pois isso causaria um curto e danificaria o sistema.

Assim, é indicado o uso de circuitos de proteção a fim de evitar que ambas as chaves sejam acionadas simultaneamente. Para isso, pode-se utilizar portas lógicas, drivers específicos, ou qualquer outro dispositivo ou circuito que não permita que tal fato aconteça.

Em alguns desses dispositivos e circuitos, ainda é possível adicionar um tempo entre a desativação de uma dessas chaves e a ativação de outra, chamado dead time (tempo morto).

Outro cuidado a se tomar é com correntes e tensões reversas que podem surgir em decorrência do acionamento do motor, que podem causar danos às chaves. Para evitar tais danos, é comum utilizar diodos de ação rápida em anti-paralelo com as chaves, e o uso de TVS.

Os circuitos amaciadores, chamados Snubbers, que são usados para tornar a comutação de estado das chaves menos danosas, e assim prolongar a vida útil do circuito.[2]

Há também, muitas vezes, a necessidade de isolar a parte de controle da parte de potência (a Ponte H em si), ou de trabalhar com tensões diferentes nas duas partes.

Para isso, usa-se circuitos ou componentes isoladores, como opto acopladores ou drivers (programa de acionamento).

O uso de drivers é comum na construção de Pontes H, principalmente nas que usam MOSFETs e IGBTs.

Isso porque, em sua maioria, os drivers condensam uma grande quantidade dos circuitos acima em um único componente, reduzindo espaço, custo e complexidade do projeto, além de facilitar a implementação de circuitos específicos, como o circuito de Bootstrap.

Circuito integrado Ponte H L2398N

O CI L298N é muito utilizado para o propósito de controle de motores, ele nada mais é que uma ponte H em um componente integrado.

Uma das vantagens do uso desse CI é o menor espaço ocupado, a baixa complexidade do circuito e o fato de ele já possuir dois circuitos H, podendo assim, controlar dois motores.

Na figura a seguir você pode conferir o diagrama de blocos do CI L298N retirado de sua folha de dados (folha de dados L298N) :

As funções dos principais pinos desse CI são descritas na tabela a seguir:

Funções dos principais pinos da Ponte H L298N

Outra vantagem do L298N é a resposta a sinais de PWM.

Se no lugar de usar sinais lógicos TTL forem usados sinais de PWM, é possível regular a tensão de saída, e dessa forma regular a velocidade dos motores.

O PWM, Pulse Width Modulation (Modulação por Largura de Pulso), consiste basicamente em aplicar uma onda quadrada de amplitude Vcc e frequência alta no lugar da tensão continua Vcc.

Ao usar um sinal de PWM nas entradas IN1 e IN2, por exemplo, teremos uma tensão de saída nos pinos OUT1 e OUT2 em PWM que será igual à Duty Cycle*Vcc. Dessa forma, podemos regular a diferença de potencial média aplicada nos motores, controlando as suas velocidades.

Existem outras opções de CI’s de ponte H no mercado, é importante consultar as especificações deles em suas folhas de dados(Datasheet) para saber qual irá lhe atender melhor. Veja algumas opções de ponte H:

L293D Folha de Dados

LMD18200 Folha de dados.

Circuito integrado Ponte H L293 e L293D

O L293 e L293D são drivers ponte H quádruplos de alta corrente.

O L293 é projetado para prover correntes bidirecionais de até 1 A, às tensões de 4,5V a 36V. O L293D é projetado para prover correntes bidirecionais de até 600 mA, às tensões de 4,5V a 36V.

Ambos os dispositivos são projetados para acionar cargas indutivas, tais como relés, solenóides, motores CC, bem como outras cargas de alta tensão/alta corrente.

Todas as entradas são compatíveis com níveis TTL.

Os drivers são habilitados em pares, com driver 1 e 2 habilitado por 1,2EN e drivers 3 e 4, por 3,4EN. Quando uma entrada de Enable está alta, o driver associado será habilitado e suas saídas estarão ativas e em fase com suas entradas.

Quando a entrada de Enable estiver baixa, esses drivers estarão desabilitados, e suas saídas estarão desligadas, em estado de alta-impedância. Com as entradas apropriadas de dados, cada par de drivers forma um driver Ponte H reversível adequado para as aplicações de solenóide ou motor.

Conexões com o Arduino

• M1 PWM (Enable) - conecte esse pino a um pino PWM do Arduino
• M1 direção 0/1 and M1 direção 1/0 - conecte esses dois a dois pinos digitais do Arduino. Quando a saída um estiver HIGH, e a outra saída, LOW, o motor vai girar em uma direção. Reverter estas saídas para LOW e HIGH vai inverter o motor, que girará na direção contrária.

Código

/************************
 Acionando o motor usando o L2935D
 ************************/
 #define ENABLE 5
 #define DIRA 3
 #define DIRB 4

 int i;
 
 void setup() {
  pinMode(ENABLE,OUTPUT);
  pinMode(DIRA,OUTPUT);
  pinMode(DIRB,OUTPUT);
  Serial.begin(9600);
 }
 
 void loop() {
 //---acionando o motor pra frente e pra trás
  Serial.println("Motor pra frente e pra trás");
  digitalWrite(ENABLE,HIGH); // enable on
  for (i=0;i<5;i++) {
    digitalWrite(DIRA,HIGH); //primeiro sentido de rotação
    digitalWrite(DIRB,LOW);
    delay(500);
    digitalWrite(DIRA,LOW);  //reverte
    digitalWrite(DIRB,HIGH);
    delay(500);
  }
  digitalWrite(ENABLE,LOW); // desabilita o motor
  delay(2000);
  
  Serial.println("exemplo rápido-devagar");
  //---exemplo rápido/devagar/parar
  digitalWrite(ENABLE,HIGH); //enable on
  digitalWrite(DIRA,HIGH); //primeiro sentido de rotação
  digitalWrite(DIRB,LOW);
  delay(3000);
  digitalWrite(ENABLE,LOW); //parada lenta
  delay(1000);
  digitalWrite(ENABLE,HIGH); //enable on
  digitalWrite(DIRA,LOW); //reversão
  digitalWrite(DIRB,HIGH);
  delay(3000);
  digitalWrite(DIRA,LOW); //parada rápida
  delay(2000);
  
  Serial.println("PWM a velocidade plena e depois lenta");
  //---exemplo PWM example, vel máxima, depois lenta
  analogWrite(ENABLE,255); //enable on
  digitalWrite(DIRA,HIGH); //primeiro sentido de rotação
  digitalWrite(DIRB,LOW);
  delay(2000);
  analogWrite(ENABLE,180); //veloc alta
  delay(2000);
  analogWrite(ENABLE,128); //veloc média
  delay(2000);
  analogWrite(ENABLE,50); //veloc baixa
  delay(2000);
  analogWrite(ENABLE,128); //veloc média
  delay(2000);
  analogWrite(ENABLE,180); //veloc alta
  delay(2000);
  analogWrite(ENABLE,255); //veloc máxima
  delay(2000);
  digitalWrite(ENABLE,LOW); //parar
  delay(10000);
}

Módulos Driver motor com Ponte H

Esses módulos são muito utilizados em aplicações de robótica.

Possuem dimensões pequenas e já possuem o circuito básico para o uso do CI, o que facilita na acomodação do módulo no robô ou em outros projetos e a sua utilização.

Existem varias opções disponíveis no mercado, com tamanhos e especificações diferentes.

Algumas especificações são importantes ao escolher seu módulo, são elas:

• Especificação de potência máxima fornecida;
• Tensão máxima suportada;
• Corrente máxima suportada;
• Tensão lógica.

Um exemplo desses módulos é o Ci L298N:

• Tensão para os motores: 5 – 35V;
• Corrente máxima para os motores: 2A;
• Potencia máxima: 25W;
• Tensão lógica: 5V;
• Corrente lógica: 0-36mA;
• Dimensões: 43x43x27 mm
• Peso: 30g.

Permite controlar até 2 motores DC ou 1 motor de passo.

Esse módulo é projetado para controlar cargas indutivas como relés, solenóides, motores DC e motores de passo, permitindo o controle não só do sentido de rotação do motor, como também da sua velocidade, utilizando os pinos PWM do Arduino.

• (Motor A) e (Motor B) se referem aos conectores para ligação de 2 motores DC ou 1 motor de passo
• (Ativa MA) e (Ativa MB) – são os pinos responsáveis pelo controle PWM dos motores A e B. Se estiver com jumper, não haverá controle de velocidade, pois os pinos estarão ligados aos 5v. Esses pinos podem ser utilizados em conjunto com os pinos PWM do Arduino
• (Ativa 5v) e (5v) – Este Driver Ponte H L298N possui um regulador de tensão integrado. Quando o driver está operando entre 6-35V, este regulador disponibiliza uma saída regulada de +5v no pino (5v) para um uso externo (com jumper), podendo alimentar por exemplo outro componente eletrônico. Portanto não alimente este pino (5v) com +5v do Arduino se estiver controlando um motor de 6-35v e jumper conectado, isto danificará a placa. O pino (5v) somente se tornará uma entrada caso esteja controlando um motor de 4-5,5v (sem jumper), assim poderá usar a saída +5v do Arduino.
• (6-35v) e (GND) – Aqui será conectado a fonte de alimentação externa quando o driver estiver controlando um motor que opere entre 6-35v. Por exemplo se estiver usando um motor DC 12v, basta conectar a fonte externa de 12v neste pino e (GND).
• (Entrada) – Este barramento é composto por IN1, IN2, IN3 e IN4. Sendo estes pinos responsáveis pela rotação do Motor A (IN1 e IN2) e Motor B (IN3 e IN4).

A tabela abaixo mostra a ordem de ativação do Motor A através dos pinos IN1 e IN2. O mesmo esquema pode ser aplicado aos pinos IN3 e IN4, que controlam o Motor B

Conectando Ponte H ao Arduino

Vamos mostrar dois esquemas de ligação deste módulo ao Arduino Uno R3, que utilizarão o mesmo programa mostrado no final do post.

O primeiro circuito utiliza a alimentação do próprio Arduino, e deve ser feito sem o Jumper em (Ativa 5V). Utilizamos 2 motores DC 5V.

O segundo circuito utiliza alimentação externa e 2 motores DC de 12V. Nesse caso precisamos colocar o jumper em Ativa 5v:

Programando Ponte H com Arduino

Teste o seu módulo carregando o programa abaixo, que vai servir para os 2 circuitos que mostramos anteriormente.

O programa gira o motor A no sentido horário, depois desliga esse motor e gira o motor B no mesmo sentido. Depois, repete esse procedimento no sentido anti-horário.

CÓDIGO:

//Programa : Controle 2 motores DC usando Ponte H L298N
//Autor : FILIPEFLOP
 
//Definicoes pinos Arduino ligados a entrada da Ponte H
int IN1 = 4;
int IN2 = 5;
int IN3 = 6;
int IN4 = 7;
  
void setup()
{
  //Define os pinos como saida
 pinMode(IN1, OUTPUT);
 pinMode(IN2, OUTPUT);
 pinMode(IN3, OUTPUT);
 pinMode(IN4, OUTPUT);
}
  
void loop()
{
  //Gira o Motor A no sentido horario
  digitalWrite(IN1, HIGH);
  digitalWrite(IN2, LOW);
  delay(2000);
  //Para o motor A
  digitalWrite(IN1, HIGH);
  digitalWrite(IN2, HIGH);
  delay(500);
  //Gira o Motor B no sentido horario
  digitalWrite(IN3, HIGH);
  digitalWrite(IN4, LOW);
  delay(2000);
  //Para o motor B
  digitalWrite(IN3, HIGH);
  digitalWrite(IN4, HIGH);
  delay(500);
  
  //Gira o Motor A no sentido anti-horario
  digitalWrite(IN1, LOW);
  digitalWrite(IN2, HIGH);
  delay(2000);
  //Para o motor A
  digitalWrite(IN1, HIGH);
  digitalWrite(IN2, HIGH);
  delay(500);
  //Gira o Motor B no sentido anti-horario
  digitalWrite(IN3, LOW);
  digitalWrite(IN4, HIGH);
  delay(2000);
  //Para o motor B
  digitalWrite(IN3, HIGH);
  digitalWrite(IN4, HIGH);
  delay(500);
 }

Shield Motor Drive L293D Ponte H

Motor Shield Ponte H para Arduino

Especificações:
– Chip: 293D (Datasheet)
– Pode controlar 4 Motores DC, 2 Motores de Passo ou 2 Servos.
– Tensão de saída: 4,5-16V
– Corrente de saída: 600mA por canal
– Até 4 motores DC bi-direcional com seleção individual de velocidades de 8 bits (cerca de 0,5% de resolução).
– Até 2 Motores de Passo (Unipolar ou Bipolar) com bobina unica, dupla ou passos interlaçados.
– 4 Pontes H: 0,6A por Ponte (1,2A de pico) com proteção térmica e diodos de proteção contra retro-alimentação.
– Resistores Pull Down mantem motores desativos durante a entrada de alimentação.
– Botão de Reset Arduino disponível no topo da placa.
– Terminais em bloco de 2 pinos e jumper para conexão de alimentação externa.

 /*
   Aula 69 - Controle do Motor Shield L293D sem Biblioteca
    
   Autor: Eng. Wagner Rambo  Data: Junho de 2016
*/

// --- Mapeamento de Hardware ---
#define   dir_clk      4     //clock do registrador no digital  4
#define   dir_ser      8     //dados do registrador no digital  8
#define   dir_latch   12     //latch do registrador no digital 12
#define   dir_en       7     //enable do registrador no digital 7
#define   pwm2a       11     //pwm motor1
#define   pwm2b        3     //pwm motor2
#define   pwm0a        6     //pwm motor3
#define   pwm0b        5     //pwm motor4
  
// --- Protótipo das Funções Auxiliares ---
void sendCommand(unsigned char value);   //Função para enviar o byte para saída do registrador

// --- Configurações Iniciais ---
void setup() 
{
  pinMode(dir_clk,   OUTPUT);    //saída para clock
 pinMode(dir_ser,   OUTPUT);    //saída para dados
 pinMode(dir_latch, OUTPUT);    //saída para latch
 pinMode(dir_en,    OUTPUT);    //saída para enable
 pinMode(pwm2a,     OUTPUT);    //saída para pwm motor1
 pinMode(pwm2b,     OUTPUT);    //saída para pwm motor2
 pinMode(pwm0a,     OUTPUT);    //saída para pwm motor3
 pinMode(pwm0b,     OUTPUT);    //saída para pwm motor4
 
 digitalWrite(dir_en, LOW);
 analogWrite(pwm2a, 0xFF);
 analogWrite(pwm2b, 0xFF);
 analogWrite(pwm0a, 0xFF);
 analogWrite(pwm0b, 0xFF);

} //end setup

// --- Loop Infinito ---
void loop() 
{
 
 sendCommand(0b10101100);
 delay(2000);
 sendCommand(0b01010011);
 delay(2000);

} //end loop

// --- Desenvolvimento das Funções Auxiliares ---
void sendCommand(unsigned char value)
{

   boolean verify;                  //bit de controle

   digitalWrite(dir_latch, LOW);    //desliga latch
   digitalWrite(dir_clk,   LOW);    //desabilita o clock
  
   for(unsigned char i=0x0; i<0x08; i++)    //loop finito para enviar os 8 bits
   {
      digitalWrite(dir_clk, LOW);   //clock em low
       
      if(value & (1<<i)) verify = HIGH;
      else verify = LOW;
       
      digitalWrite(dir_ser, verify); //Habilita saída de dados conforme condição acima
      digitalWrite(dir_clk, HIGH);
 
   } //end for
 
   digitalWrite(dir_clk, LOW);
 
   digitalWrite(dir_latch, HIGH);

}

---

<< Página do curso

PWM e Acionamento de motores	AULA 7 - Ponte H	Projeto 1 >>