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
• 1 módulo Driver motor com Ponte H;
• 1 shield MH Electronics Ponte H;
• 1 motor de passo;
• 1 servo motor;
• 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, ou outro componente de chaveamento. 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.

Funcionamento da ponte H com motores CC

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.

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.

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 L298N

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:

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);
  //Pára 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

A shield, ao contrário do módulo, já vem com os slots prontos para conexão direta com o Arduino, prescindindo de toda fiação para as ligações do circuito:

Na imagem acima, pode-se observar que além de dois L293D, os quais permitem o acionamento de até 4 motores DC, o Motor Shield constitui-se também de um CI 74HC595, um registrador de deslocamento que possibilita uma saída paralela de 8 bits através de uma entrada digital, entrada esta que constitui-se de três pinos: clock, latch e data.

A alimentação do Motor Shield Arduino obedece os limites de tensão estabelecidos pelo Driver L293D e por mais que seja um shield com contato direto no Arduino, a alimentação do Arduino normalmente não é suficiente para o funcionamento dos motores, por isto é necessária uma alimentação externa.

Através do esquema exibido abaixo, podemos observar o borne para para alimentação externa e como dito, este possui limite de alimentação de 4,5 a 36V, ao lado tem-se o jumper de seleção para fonte de alimentação. Quando esse jumper estiver inserido, a alimentação utilizada para os motores é o do próprio Arduino.

Se utilizarmos uma fonte externa é fundamental a retirada deste jumper.

Abaixo, vemos o esquema de ligação possível utilizando-se os 4 motores DC conectados ao Motor Shield Arduino, porém vale ressaltar que nestes casos a corrente máxima por porta pode ser de 600mA. Assim, ao utilizarmos as quatro portas teremos um total de 2,4A e a fonte de alimentação externa utilizada através dos Bornes deve suprir esta necessidade para o total desempenho dos motores (sem o jumper):

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.

Acionamento de um único motor, usando Motor Shield

Observação: A biblioteca Adafruit de controle do Motor Shield foi descontinuada, mas como a shield ainda é muito comercializada, a biblioteca continua sendo disponibilizada através do link Adafruit Motor Shield Library GITHUB ou deste: Adafruit Motor Shield Library USINAINFO. Você terá que baixar os arquivos e copiá-los para as pastas LIB e HEADER, ou incluir o arquivo *.ZIP através do menu Sketch > Incluir biblioteca > Adicionar biblioteca .ZIP"

Código:

#include <AFMotor.h>    // Inclui a Biblioteca AFMotor.h
AF_DCMotor motor(4);    // Define M4 como posição de controle para motor. Poderia ser 1-4
void setup() {
  motor.setSpeed(200);    // Define velocidade inicial do motor
  motor.run(RELEASE);     // Define a função Stop
}
  
void loop() {
   uint8_t i;
   motor.run(FORWARD);           // Liga o Motor
   for (i=0; i<255; i++)   {     // Acelera de 0 até a velocidade máxima
       motor.setSpeed(i);
       delay(10);
    }
   
   for (i=255; i!=0; i--)   {    // Diminui da velocidade máxima até 0
       motor.setSpeed(i);
       delay(10);
    }
   
    motor.run(BACKWARD);          // Inverte a direção do motor
     
   for (i=0; i<255; i++)   {     // Acelera de 0 até a velocidade máxima
       motor.setSpeed(i);
       delay(10);
   }
   
   for (i=255; i!=0; i--)   {    // Diminui da velocidade máxima até 0
       motor.setSpeed(i);
       delay(10);
    }
    
   motor.run(RELEASE);           // Desliga o Motor
   delay(1000);
 }

Acionamento dois motores DC, usando Motor Shield

Agora, faremos a ligação de dois motores DC: um na posição M1 e outro na posição M4.

O motor 1 vai ficar variando sua velocidade, sentido de rotação e vai parar, a cada ciclo.

Já o motor 2 vai girar no mesmo sentido e velocidade, enquanto estiver alimentado.

Código:

#include <AFMotor.h>    // Inclui a Biblioteca AFMotor.h. Ver observação acima
 
AF_DCMotor motor1(1), motor2(4);    // Define M1 e M4 como posições de controle para motor
 
void setup() {
  motor1.setSpeed(200);    // Define velocidade inicial do motor
  motor1.run(RELEASE);     // Define a função Stop
  motor2.setSpeed(250);    // Define velocidade inicial do motor
  motor2.run(RELEASE);     // Define a função Stop
 }
 
 void loop() 
 {
    uint8_t i;
    motor1.run(FORWARD);           // Liga o Motor 1, em M1
    motor2.run(FORWARD);           // Liga o Motor 2, em M4
  
    for (i=0; i<255; i++)   {     // Acelera de 0 até a velocidade máxima
       motor1.setSpeed(i);
       delay(10);
   }
   
   for (i=255; i!=0; i--)   {    // Diminui da velocidade máxima até 0
      motor1.setSpeed(i);
      delay(10);
 }
 
  motor1.run(BACKWARD);          // Inverte a direção do motor
 
  for (i=0; i<255; i++)   {     // Acelera de 0 até a velocidade máxima
    motor1.setSpeed(i);
    delay(10);
  }
  
  for (i=255; i!=0; i--)   {    // Diminui da velocidade máxima até 0
    motor1.setSpeed(i);
    delay(10);
  }
 
  motor1.run(RELEASE);           // Desliga o Motor
  delay(1000);
}

Acionamento motor de passo, usando Motor Shield

O terceiro projeto consiste em controlar um motor de passo com o Motor Shield. Será utilizada um fonte externa de 5V.

Motores de passo são ótimos para um controle mais preciso, por exemplo, em robótica, ou projetos CNC.

Este motor shield suporta até 2 motores de passo. A biblioteca funciona da mesma forma para motores uni, ou bipolares.

Para motores UNIPOLARES: para conectar o motor de passo, primeiro defina quais pinos serão conectados a qual bobina e quais pinos são os taps centrais. Se for um motor de 5 enrolamentos, então um pino será o tap central para ambas as bobinas. Os taps centrais deverão estar conectados juntos ao terminal GND da motor shield. Então, a bobina 1 deverá ser conectada a um born de motor (M1 ou M3) e a bobina 2, ao outro borne (M2 ou M4).

Para motores BIPOLARES: será igual ao anterior, exceto que não haverá um quinto enrolamento para se conectar ao terra. O código é exatamente o mesmo.

"Single" significa que uma única bobina foi ativada. "Double" significa que as 2 bobinas foram ativadas, para maior torque.

Código:

StepsPerRevolution indica quantos passos por volta o motor tem. Um motor de passo com 7,5 graus tem 360/7,5 = 48 passos.

#include <AFMotor.h>                      // Inclui a Biblioteca AFMotor.h
const int stepsPerRevolution = 48;        // Número de etapas por volta
AF_Stepper motor(stepsPerRevolution, 2);  // Define M3 e M4 como local de instalação (Se 1 -> M1 e M2)
void setup() {
   motor.setSpeed(100);                    // Define a velocidade do Motor
}
 
void loop() {
  motor.step(648, FORWARD, SINGLE);       // Movimenta o Motor para uma Direção
  motor.step(648, BACKWARD, SINGLE);      // Inverte a direção do Motor
  
  motor.step(648, FORWARD, MICROSTEP);    // Movimenta o Motor em uma Direção com passos suaves
  motor.step(648, BACKWARD, MICROSTEP);   // Inverte a direção do Motor
 }

Altere o parâmetro stepsPerRevolution de acordo com as especificações do seu motor antes de tentar o esboço. Por exemplo, para NEMA 17 defina-o para 200 e para 28BYJ-48 defina-o para 48.

A figura abaixo ilustra como seria a ligação da shield em um motor de passo tipo NEMA17.

Código:

#include <AFMotor.h>
// Número de passos por rotação de saída
// Se preciso, mude esta especificação de acordo com seu motor
const int stepsPerRevolution = 200;
// Conecta o motor a porta #2 (M3 and M4)
AF_Stepper motor(stepsPerRevolution, 2);
void setup() {
  Serial.begin(9600);
  Serial.println("Teste do Motor de Passos!");
  motor.setSpeed(10);  // 10 rpm   
}
void loop() {
  Serial.println("Passo única da bobina");
  motor.step(100, FORWARD, SINGLE); 
  motor.step(100, BACKWARD, SINGLE); 
  Serial.println("Passo duplo da bobina");
  motor.step(100, FORWARD, DOUBLE); 
  motor.step(100, BACKWARD, DOUBLE);
  Serial.println("Passos intercalados da bobina");
  motor.step(100, FORWARD, INTERLEAVE); 
  motor.step(100, BACKWARD, INTERLEAVE); 
  Serial.println("Micropassos da bobina");
  motor.step(100, FORWARD, MICROSTEP); 
  motor.step(100, BACKWARD, MICROSTEP); 
}

Acionamento servomotor, usando Motor Shield

O último projeto consiste em controlar um servo motor com o Motor Shield.

Abaixo, serão descritos o diagrama do projeto, o código implementado e o resultado obtido.

Código

#include <Servo.h> 
Servo myservo;  // Cria servo objeto para controlar um servo
int pos = 0;  // Variável para guardar a posição do servo
void setup() 
{
  // Conecta o servo no pino 10 para o servo objeto
  myservo.attach(10);   
}
void loop() 
{
  // Aumenta o ângulo de 0 graus até 180 graus
  for(pos = 0; pos <= 180; pos += 1) 
  {
     myservo.write(pos);
     delay(15);
  }
  // Diminui o ângulo de 180 graus até 0 graus
  for(pos = 180; pos>=0; pos-=1)
  {
    myservo.write(pos);
     delay(15);
  }
}

Outras shields para motores:

---

<< Página do curso

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