AULA 6 - Microcontroladores - Engenharia

<< 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
• 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

• 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

(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%).

Arquivo:Dutycicleanim.gif

Arquivo:Dutycicleanim2.gif

Usos do PWM

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

Fonte: Eletronics Hub - 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.

O esquema de montagem é:

Fotografia:

O led RGB obedece à codificação RGB de cores, que permite usar 8 bits para a quantidade de vermelho, 8 bits para a quantidade de verde e 8 bits para a quantidade de azul.

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(1000);
 }
}

---

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 especiais, chamados Darlingtons", os quais, na verdade são dois transistores, um alimentando a base do outro, de forma a amplificar a corrente com alto ganho, e alimentar adequadamente o motor.

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 ( Datasheet TIP120 ) !!!!!
• 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:

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 de 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

---

<< Página do curso

Leitura e escrita nas portas analógicas	AULA 6 - PWM e acionamento motores	Ponte H >>