O controle de mecanismos é normalmente feito com motores e, portanto, é importante saber como os programas podem ser feitos para controlar os motores. Neste artigo, aprenderemos a controlar servomotores, motores de corrente contínua e motores de passo. A plataforma Arduino fornece bibliotecas prontas para serem usadas no controle de motores. Isso facilita o uso e o rápido desenvolvimento de qualquer projeto em que seja necessário o uso de motores.
MIC027S
A Figura 1 mostra a placa Arduino Uno e seu Ambiente de Desenvolvimento (IDE), que podem ser baixados do site do Arduino. Este cartão contém um microcontrolador ATmega328P, que tem uma memória de programa FLASH 32 Kbytes, 2KB RAM, EEPROM 1 Kbytes e 14 de entrada / saída para usos gerais (GPIOs). A Figura 2 mostra as entradas analógicas, saídas analógicas (PWM) e entradas / saídas digitais. Note que as saídas com PWM são marcadas com o símbolo ~. Neste artigo vamos controlar servo motores com a placa Arduino, motores DC e motores de passo. Veja a figura 3.
CONTROLE DE UM SERVO MOTOR COM A PLACA ARDUINO UNO
Um servo é um motor que permite um giro de posicionamento, normalmente entre 0 e 180 graus. Sua precisão é muito alta e é por isso é usado em uma série de aplicações como robôs, brinquedos, aeromodelos etc. Nesta prática, vamos conectar um servo à placa Arduino para ser controlado pelo software. Como dito acima, a plataforma do Arduino tem uma biblioteca ou listagem pronta para o servo-controle. Então o programador só tem que incluí-lo no projeto e usá-lo. Para incluir a biblioteca servo no projeto, é necessário ir ao Menu: Programa-> Incluir Biblioteca-> Servo. Na Figura 4 podemos ver como chegar a esse menu.
Depois de incluir a biblioteca Servo é o projeto, é possível usar suas funções como mostrado na prática a seguir, encontrado no Arduino IDE. O código de exemplo pode ser encontrado no Menu: File-> Examples-> Servo-> Knob. Veja a Figura 5. Nesta prática, controlaremos a posição do servo de acordo com um potenciômetro.
Na Figura 6 você pode ver como conectar o servo à placa Arduino. O fio preto está conectado ao terra (GND).
O fio vermelho está conectado a positivo (Vcc). O fio amarelo ou branco está conectado a uma saída digital. Para o caso desta prática, foi selecionado o pino 9. Os pulsos enviados por este pino têm uma largura de 20 milissegundos e, dependendo da posição, essa largura varia. O código para esta prática é o seguinte:
#include // cria objeto servo para controle servo Servo myservo; // pino analógico usado para conectar o potenciômetro int potpin = 0; // variável para ler o valor do pino analógico int val; void setup() { // liga o servo no pino 9 ao objeto servo myservo.attach(9); } void loop() { // lê o valor do potenciômetro(valor entre 0 e 1023) val = analogRead(potpin); // escala para usá-lo com o servo(valor entre 0 e 180) val = map(val, 0, 1023, 0, 180); // define a posição do servo de acordo com o valor escalado myservo.write(val); // espera que o servo chegue lá delay(15); }
No início do programa, encontramos a linha de código:
#include
que diz ao compilador para usar a biblioteca ou biblioteca para o servo. Todas as funções que podem ser usadas para controlar servos, estão em um arquivo chamado Servo.h e o compilador procura por este arquivo para usá-lo no projeto.
Então criamos um objeto Servo com a linha de código:
Servo myservo;
Esta linha de código informa ao compilador que a variável myservo associará um conjunto de variáveis e funções. Este estilo de programação vem da linguagem C ++ e é muito semelhante às estruturas em C. Se você quiser saber mais sobre o código da classe Servo, você pode ir para a pasta: D:\bibliotecas\arduino-noturnos\Servo\ src . No caso do caminho anterior, o arduino é instalado no disco rígido ou na partição D:
Na Figura 7 você pode ver o diagrama de classes para a classe Servo e o código para declarar a classe Servo, que é encontrado no arquivo Servo.h, é o seguinte:
Class servo
{
public:
Servo();
uint8_t attached(int pin);
uint8_t attached(int pin, int min, int max);
void detach();
void write(valor int);
void writeMicroseconds(int valor);
int read();
int readMicroseconds();
bool attached();
private:
uint8_t servoIndex;
int8_t min;
int8_t max;
};
Depois disso, definimos em qual pino o potenciômetro será conectado. No nosso caso, vamos conectá-lo ao canal '0' do conversor analógico para digital(ADC). A linha de código para isso é o seguinte:
int potpin = 0;
Depois disso, definimos uma variável para armazenar o valor de leitura do canal analógico '0'. Para isso usamos a seguinte linha de código:
int val;
Então, encontramos neste programa de exemplo a função setup(), na qual atribuímos o pino 9 para controlar o servo. Isso é feito com a linha de código:
myservo.attach(9);
Observe que a função attach() pertence à classe Servo. O código para a função setup() é:
void setup() {
myservo.attach(9);
}
Finalmente encontramos a função loop(), onde a primeira coisa que fazemos é ler o canal analógico '0', onde o potenciômetro está conectado. Este valor, que varia de 0 a 1023, é armazenado na variável val. Então, escalamos ou mapeamos este valor entre 0 e 180 para ser usado pelo servo. Em seguida, usamos a função myservo.write(val); para posicionar o servo de acordo com o valor escalado. E finalmente damos um atraso de 15 milissegundos. O diagrama de fluxo para este programa pode ser visto na Figura 8. O código para a função loop() é:
void loop() {
val = analogRead(potpin);
val = map(val, 0, 1023, 0, 180);
myservo.write(val);
delay(15);
}
No Arduino IDE, também encontramos outro código de exemplo para o servo motor. Este exemplo pode ser obtido através de Menu: Arquivo-> Exemplos-> Servo-> Sweep. Neste exemplo, o que ele faz é girar o servo de um modo em 180 graus e, em seguida, fazê-lo na direção oposta. A Figura 9 mostra como conectar o servo à placa Arduino. O código para este exemplo é:
#include Servo myservo; // cria objeto servo para controle servo // doze objetos servo podem ser criados na maioria das placas int pos = 0; // variável para armazenar a posição do servo void setup() { myservo.attach(9); // liga o servo no pino 9 ao objeto servo } void loop() { for(pos = 0; pos <= 180; pos + = 1) {// passa de 0 graus para 180 graus // em etapas de 1 grau myservo.write(pos); // diz ao servo para ir para a posição na variável 'pos' delay(15); // espera 15ms para o servo alcançar a posição } for(pos = 180; pos> = 0; pos - = 1) {// passa de 180 graus para 0 graus myservo.write(pos); // diz ao servo para ir para a posição na variável 'pos' delay(15); // espera 15ms para o servo alcançar a posição } }
Neste programa usamos uma função for(), muito útil quando precisamos criar loops ou repetir algum código. A função:
for(pos = 0; pos <= 180; pos + = 1)
Aumente a variável pos até atingir 180. E para cada incremento execute o código que está entre o {}. Nesse caso, seria:
{
myservo.write(pos);
delay(15);
}
O mesmo vale para a função:
for(pos = 180; pos> = 0; pos - = 1)
Mas neste caso a variável pos é inicializada com um valor de 180 e decrementa(down counter) por cada passo através do loop for(). Desta forma, nós controlamos que o servo gira em uma direção e depois na outra direção. A Figura 10 mostra o fluxograma para essa prática.
CONTROLE DE MOTORES DE CORRENTE CONTÍNUA COM A PLACA ARDUINO UNO
O controle de motores CC normalmente é feito com pontes H. Esses circuitos permitem o controle do sentido de rotação e fornecem corrente e potência suficientes para operar o motor corretamente. Nesta prática, usaremos o circuito integrado L293, que possui 2 pontes H para controlar 2 motores CC. A Figura 11 mostra como conectar um motor ao circuito integrado L293 e isso à placa Arduino. 2 saídas digitais da placa Arduino Uno são necessárias para controlar o motor.
Como dito anteriormente, o L293 possui 2 canais para 2 motores. Veja a Figura 12. As entradas digitais para o canal 1 são pinos 2 e 7, rotulados como INPUT 1 e 2. Esses pinos controlam a direção de rotação e desligamento do motor. As saídas da ponte H para o canal 1 são os pinos 3 e 6, rotulados como OUTPUT 1 e 2.
O motor está conectado a esses pinos. O pino 1 é usado para inibir a ponte H do canal 1. Esse pino também pode ser usado para aplicar um sinal PWM e controlar a velocidade do motor. As entradas digitais para o canal 2 são pinos 10 e 15, rotulados como INPUT 3 e 4. As saídas onde o motor está conectado são os pinos 11 e 14, rotulados como OUTPUT 3 e 4. Os pinos 4, 5, 12 e 13, eles são terra e devem ser conectados ao GND. Não esqueça de conectar esta terra ao ground da placa Arduino. O pino 8 é a fonte de tensão que pode ser de 10 a 15 volts dependendo do motor. O pino 16 vai para 5 volts. Este circuito integrado gerencia correntes de até 600 miliampères. O circuito integrado L298 pode lidar com correntes de até 2 ampères.
Para controlar o motor, você pode ver a tabela lógica de operação de cada canal na Figura 13. Observe que, para desligar o motor, é necessário colocar as duas entradas no nível lógico baixo ou alto.
A seguir, um código de exemplo para controlar um motor CC:
// pinos de entrada da H-Bridge const int in1Pin = 10; const int in2Pin = 11; void setup() { pinMode(in1Pin, OUTPUT); pinMode(in2Pin, OUTPUT); } loop void() { digitalWrite(in1Pin, HIGH); digitalWrite(in2Pin, LOW); delay(4000); digitalWrite(in1Pin, LOW); digitalWrite(in2Pin, LOW); delay(2000); digitalWrite(in1Pin, LOW); digitalWrite(in2Pin, HIGH); delay(4000); digitalWrite(in1Pin, LOW); digitalWrite(in2Pin, LOW); delay(2000); }
Este código é muito simples. Primeiro, configuramos os pinos 10 e 11 como saídas digitais. Fazemos isso no início do programa e na função setup(). O código para fazer isso é:
const int in1Pin = 10;
const int in2Pin = 11;
pinMode(in1Pin, OUTPUT);
pinMode(in2Pin, OUTPUT);
Então, na função loop(), giramos o motor em uma direção e atrasamos por 4 segundos. Então desligamos o motor por 2 segundos. Em seguida, ligamos o motor na outra direção e atrasamos mais 4 segundos. Finalmente, desligamos o motor por 2 segundos e repetimos o loop. O fluxograma para esta prática pode ser visto na Figura 14.
CONTROLE DE UM MOTOR DE PASSO UNIPOLAR OU BIPOLAR COM A PLACA ARDUINO.
Os motores de passo permitem um alto grau de precisão em seu posicionamento. Usado amplamente em impressoras, scanners, robôs, mecanismos, etc. Basicamente, existem 2 tipos de motores de passo. O bipolar tem apenas 4 fios e a maneira de conectá-los à placa Arduino pode ser vista na Figura 15.
Aqui usamos o circuito integrado L293 para controlar a potência do motor. Se o motor é unipolar, tem 5 ou 6 cabos. A Figura 16 mostra como conectar este motor à placa Arduino, usando um circuito integrado ULN2003, como um amplificador de potência. Este motor tem 2 pares de bobinas e cada bobina tem uma conexão com o centro.
É possível identificar os pares usando um multímetro. Meça a resistência através de pares de fios, para encontrar os 2 pares de fios que têm resistência máxima. O fio central deve ter metade da resistência de toda a bobina. Motores com apenas 5 cabos têm os centros das bobinas conectados a um único cabo.
Na Figura 17 podemos ver o menu, por exemplo, código para motores de passo. O menu para esta prática é: Files-> Examples-> Stepper-> stepper_oneRevolution. O código a seguir pode ser usado para controlar qualquer motor de passo:
#include // mude isto para ajustar o número de passos por revolução para o seu motor const int stepsPerRevolution = 200; // inicializa a biblioteca de passo nos pinos 8 a 11: Stepper myStepper(stepsPerRevolution, 8, 9, 10, 11); void setup() { // define a velocidade a 60 rpm: myStepper.setSpeed(60); // inicializa a porta serial: Serial.begin(9600); } void loop() { // passo uma revolução em uma direção: Serial.println("no sentido horário"); myStepper.step(stepsPerRevolution); delay(500); // passo uma revolução na outra direção: Serial.println("anti-horário"); myStepper.step(-stepsPerRevolution); delay(500); }
O programa anterior o que faz é girar o motor em uma direção e depois de um atraso, ele gira na outra direção. A Figura 18 mostra o diagrama de fluxo para essa prática. O programa pode ser usado para acionar tanto um motor de passo bipolar quanto um motor unipolar.
O motor está ligado aos pinos 8, 9, 10 e 11 Arduino UNO Dependendo do número de passos do motor, que são utilizados na prática este é necessário para definir a linha de código .:
const int stepsPerRevolution = 200;
Para este exemplo, usamos um mecanismo com 200 passos por volta.
O Arduino IDE tem uma classe pronta para controlar motores de passo chamados Stepper. Assim como na classe Servo, a única coisa que temos que fazer para usá-lo é incluí-lo no projeto. Para fazer isso, vá ao menu: Programa-> Incluir Biblioteca-> Stepper. A Figura 19 mostra o menu para incluir a biblioteca. A próxima linha de código, declara uma variável myStepper, e os pinos usados para o mecanismo, são 8, 9, 10 e 11.
Stepper myStepper(stepsPerRevolution, 8, 9, 10, 11);
Como podemos ver, os motores de acionamento são muito fáceis com a placa Arduino. Leve em conta as potências dos motores e a potência do circuito controlador (driver).
