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
- 1 potenciômetro de 10kΩ;
- 1 led vermelho;
- 1 resistor de 200 Ω
- 3 resistores de 1kΩ
- 1 led RGB anodo comum;
- 1 diodo 1N4148
- 1 diodo 1N4001
- 1 motor CC de 5V;
- 1 transistor TIP120 ou um transistor BC548 e um BD137;
- 1 bateria de 9V para o motor;
- cabos fêmea-macho
METODOLOGIA[editar]
- 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.
Sinal PWM – Pulse Width Modulation[editar]
(Modulação por Largura de Pulso)
PWM (Pulse Width Modulation - Modulação por largura de pulso) é uma técnica para obter resultados analógicos por meios digitais.
Essa técnica consiste na geração de uma onda quadrada em uma frequência muito alta em que pode ser controlada a porcentagem do tempo em que a onda permanece em nível lógico alto.
Esse tempo é chamado de Duty-cycle (Ciclo de trabalho) e sua alteração provoca mudança no valor médio da onda, indo desde 0V (0% de Duty Cycle) a 5V (100% de Duty Cycle) no caso do Arduino.
O Arduino UNO possui 6 (seis) portas PWM, 3, 5, 6, 9, 10 e 11.
O sinal PWM pode variar de 0 a 255 e para ativá-lo basta usar a seguinte instrução em uma das portas PWM:
analogWrite(pin, sinal_pwm);
Note que as portas PWM são todas digitais, porém o sinal é modulado “como se fosse” um sinal analógico.
Ciclo de Trabalho – Duty-Cicle
O sinal PWM possui um ciclo de trabalho que determina com que frequência o sinal muda do nível lógico HIGH para o nível lógico LOW e vice versa.
No Arduino a frequência do PWM pode ser definida entre 32Hz até 62kHz.
Duty cicle = (100% * largura do pulso) / período
O valor do Duty Cycle usado pelo Arduino é um inteiro armazenado em 8 bits, de forma que seu valor vai de 0 (0%) a 255 (100%).
Usos do PWM[editar]
Geração de tensão analógica de 0 a 5V:
Para um sinal PWM de valor 200 temos:
Se 255 é 100%, 200 é aproximadamente 78,4%.
Como a tensão máx de saída do Arduino é 5V a tensão média do sinal PWM será:
Vmédio = Vmax*Duty Cycle(%)
Vmédio=5*78,4%
Vmédio=3,92V
Acionamento analógico de atuadores:
Controlando a intensidade de um led
Neste exemplo, a intensidade de um led de alto brilho, que depende da tensão sobre o LED, será alterada com sinal PWM
Controlando a cor de um led RGB[editar]
Fonte:Eletronic Hubs - LED RGB com arduino
O led RGB, que na verdade são 3 leds (um vermelho, um verde e um azul) no mesmo encapsulamento, tem a seguinte pinagem:
O led pode ser catodo comum, ou anodo comum.
Fotografia:
E o código:
const int pinoVerm = 6;
const int pinoVerde = 5;
const int pinoAzul = 3;
void setup()
{
pinMode(pinoVerm,OUTPUT);
pinMode(pinoVerde,OUTPUT);
pinMode(pinoAzul,OUTPUT);
}
void loop()
{
delay(1000);
coresPrimarias(255,0,0); // Red
delay(2000);
coresPrimarias(0,255,0); // Green
delay(2000);
coresPrimarias(0,0,255); // Blue
delay(2000);
coresPrimarias(255,255,0); // Yellow
delay(2000);
coresPrimarias(255,0,255); // Magenta
delay(2000);
coresPrimarias(0,255,255); // Cyan
delay(2000);
coresPrimarias(255,255,255); // White
delay(2000);
DegradeRGB();
}
void coresPrimarias(int valorVerm, int valorVerde, int valorAzul)
{
analogWrite(pinoVerm, valorVerm);
analogWrite(pinoVerde, valorVerde);
analogWrite(pinoAzul, valorAzul);
}
void DegradeRGB()
{
int x;
int brilhoVerm;
int brilhoVerde;
int brilhoAzul;
for (x = 0; x < 768; x++)
{
if (x <= 255)
{
brilhoVerm= 255 - x;
brilhoVerde= x;
brilhoAzul= 0;
}
else if (x <= 511)
{
brilhoVerm= 0;
brilhoVerde= 255 - (x - 256);
brilhoAzul= (x - 256);
}
else
{
brilhoVerm= (x - 512);
brilhoVerde= 0;
brilhoAzul= 255 - (x - 512);
}
analogWrite(pinoVerm, brilhoVerm);
analogWrite(pinoAzul, brilhoAzul);
analogWrite(pinoVerde, brilhoVerde);
delay(10);
}
}
Controle de velocidade de motor CC de 5V
Na maioria das abordagens em robótica faz-se necessária a utilização de motores DC em diversos tipos de locomoção de robôs, movimentação de braços mecânicos, etc.
Os motores DC (direct current ou corrente continua) são cargas indutivas que, em geral, demandam uma quantidade de corrente superior à que as portas do Arduino conseguem fornecer.
Sendo assim, não devemos ligar estes motores diretamente nas portas do Arduino, pois se o motor demandar uma corrente acima de 40 mA nas portas digitais (máxima fornecida pelo Arduino) pode queimar a porta e danificar a placa.
Um micromotor CC de 5V normalmente utiliza correntes da ordem de 70 mA, a vazio e que podem chegar até 1,70 A, com carga plena!!!
O arduino, porém, só consegue fornecer até 40 mA por pino digital.
Nessa aula, para solucionar a questão da alta corrente vamos usar transistores, os quais amplificam a corrente, permitindo alimentar o motor DC.
Porém, pode ser que seja necessário controlar o sentido de giro do motor, o que veremos na aula subsequente.
Regulador de velocidade simples para motores CC de 5V:
Componentes:
- Arduino
- protoboard e fios
- 1 resistência de 220Ω
- 1 transistor TIP120 ou TIP122
- !!!!!
- 1 diodo 1N4148
- 1 potenciômetro de 10 KΩ
- 1 micro motor de 5V
O potênciometro envia a informação da velocidade para o pino analógico 0.
Na indisponibilidade dos transistores Darlington da Texas, pode-se fazer:
As pinagens destes transistores são:
* Na verdade, foram utilizados um BC548 e BD137, ligados pelo emissor do primeiro na base do segundo, e pelos coletores (Darlington).
link para o vídeo: Acionando motor 5V com arduino
Código:
int potPin = 0; // Pino analógico 0 conectado no potênciometro
int transistorPin = 9; // Base do transistor conectada pelo pino digital 9
int potValue = 0; // Valor lido no potênciometro
/*** FUNÇÃO setup() ***/
void setup() { // Seta o transistor (pino 9) como saída
pinMode(transistorPin, OUTPUT);
}
/*** FUNÇÃO loop() ***/
void loop() {
potValue = analogRead(potPin) / 4; // lê o potênciometro, e converte para valor [0,255]
//para usar na saída PWM
analogWrite(transistorPin, potValue); //potValue altera a alimentação do motor
}
Para indicar a faixa de velocidade do motor, com algumas modificações no circuito e no código, pode-se acionar também um bargraph:
Código 2:
int potPin = 0; // Pino analógico 0 conectado no potênciometro
int transistorPin = 11; // Base do transistor conectada ao arduino pelo pino digital 11
int potValue = 0; // Valor lido no potênciometro
int potValuePWM = 0;
int LED1 = 3, LED2 = 5, LED3 = 6, LED4 = 9;
/*** FUNÇÃO setup() ***/
void setup() { // Seta o transistor (pino 9) como saída
pinMode(transistorPin, OUTPUT);
pinMode(LED1, OUTPUT);
pinMode(LED2, OUTPUT);
pinMode(LED3, OUTPUT);
pinMode(LED4, OUTPUT);
}
/*** FUNÇÃO loop() ***/
void loop() {
potValue = analogRead(potPin); // lê o potênciometro
potValuePWM = potValue/4; //converte a leitura para valor [0,255] p/saída PWM
analogWrite(transistorPin, potValuePWM); //potValue altera a alimentação do motor
if(potValue<255){ //acende só o primeiro led do bargraph
analogWrite(LED1,potvalue);
analogWrite(LED2,0);
analogWrite(LED3,0);
analogWrite(LED4,0);
}
if(potValue>255 and potValue<511){ //acende dois leds do bargraph
analogWrite(LED1,255);
analogWrite(LED2,potvalue - 256);
analogWrite(LED3,0);
analogWrite(LED4,0);
}
if(potValue>511 and potValue<765){ //acende três leds do bargraph
analogWrite(LED1,255);
analogWrite(LED2,255);
analogWrite(LED3,potvalue - 512);
analogWrite(LED4,0);
}
if(potValue>765){ //acende todos os leds do bargraph
analogWrite(LED1,255);
analogWrite(LED2,255);
analogWrite(LED3,255);
analogWrite(LED4,potvalue - 766);
}
}
Controle de velocidade de motor CC de 12V, com bargraph:[editar]
Regulador de velocidade simples para motores CC de 12V:
Componentes:
- Arduino
- protoboard e fios
- 4 leds
- 4 resistências de 220ohm
- 1 resistência de 1 K
- 1 transistor TIP122
- 1 diodo 1N4001
- 1 capacitor de 1 microF
- 1 potenciômetro de 10 K
- 1 motor de 12v
- 1 fonte de 12v
link para o vídeo: Acionando motores 12V com arduino
Código:
/*variáveis globais */
int led1=6;
int led2=9;
int led3=10;
int led4=11;
int trimpot=5;
int motor=3;
/* Função setup() de inicialização */
void setup(){
pinMode(led1,OUTPUT);
pinMode(led2,OUTPUT);
pinMode(led3,OUTPUT);
pinMode(led4,OUTPUT);
pinMode(trimpot,INPUT);
}
/* Função loop() */
void loop(){
int value = analogRead(trimpot); //lê valor de velocidade no potenciômetro
analogWrite(motor,value/4); //envia sinal PWM para motor pelo pino 3
if(value<254){ //acende só o primeiro led do bargraph
analogWrite(led1,value);
analogWrite(led2,0);
analogWrite(led3,0);
analogWrite(led4,0);
}
if(value>254 and value<511){ //acende dois leds do bargraph
analogWrite(led1,255);
analogWrite(led2,value - 254);
analogWrite(led3,0);
analogWrite(led4,0);
}
if(value>511 and value<765){ //acende três leds do bargraph
analogWrite(led1,254);
analogWrite(led2,254);
analogWrite(led3,value - 512);
analogWrite(led4,0);
}
if(value>765){ //acende todos os leds do bargraph
analogWrite(led1,254);
analogWrite(led2,254);
analogWrite(led3,254);
analogWrite(led4,value - 765);
}
}
Acionamento de motor de passo com drive ULN2003
#include "Stepper.h"
const int stepsPerRevolution = 200; // change this to fit the number of steps per revolution
// for your motor
// initialize the stepper library on pins 8 through 11:
Stepper myStepper(stepsPerRevolution, 8, 9, 10, 11);
int stepCount = 0; // number of steps the motor has taken
void setup() {
// initialize the serial port:
Serial.begin(9600);
}
void loop() {
// step one step:
myStepper.step(1);
Serial.print("steps:");
Serial.println(stepCount);
stepCount++;
delay(5);
}
Outro exemplo: Robocore
