aula pwm arduino

PWM

Prof. Ilton L Barbacena

2012.2

PWM

• Modulação de Largura de pulso, ou PWM, é uma técnica para obter sinais

analógicos utilizando sinais digitais. Um conversor Digital-Analógico barato;

• O controle digital é usado para criar uma onda retangular, formado por um

sinal alternado entre ligado e desligado. Este padrão on-off pode simular

tensões analógicas entre 5 Volts e 0 volts, alterando a porção de tempo que o

sinal esteja alto em comparação com o tempo em que o sinal esteja baixo.

• A duração do "tempo" é chamado de largura de impulso. Para obter diferentes

valores analógicos, muda-se a largura de pulso. Se repetir este padrão on-off

com rapidez suficiente, com um LED por exemplo, o resultado é obter o

controle da luminosidade do LED;

• Esta duração do tempo ou período é o inverso da frequência de PWM.

2/59

PWM

• A técnica de PWM consiste em manipularmos a razão cíclica de um sinal, o

duty cycle, afim de transportar informação ou controlar a potência de algum

outro circuito.

• Com isso, teremos um sinal digital que oscila entre 0v e 5v com determinada

frequência (o Arduino trabalha com um padrão próximo a 500Hz).

• O duty cycle é a razão do tempo em que o sinal permanece em 5v sobre o

tempo total de oscilação, como está ilustrado abaixo:

3/59

PWM – Pulse Width Modulation

• Com PWM pode-se obter uma tensão analógica a partir de

um sinal digital (DAC), com utilização de filtros na saída;

4 /59

PWM

• A tensão média é diretamente proporcional ao duty cycle ouciclo ativo.

5 /59

Onde: V(t) = Vpulsos para 0<= t

<=tpV(t) = 0 para tp < t

<= T

A tensão média será:

PWM• Para se obter um conversor digital analógico a partir de

um pino digital, basta implementar um sinal PWM eadicionar em sua saída um filtro passa baixa comfrequência de corte menor que a própria frequência doPWM.

– Supor um filtro RC, onde fcorte = 1 / (2*pi*R*C);

– Neste caso, deve-se adotar sempre o seguinte:

6 /59

• Quando não é necessária obter uma tensão média contínua, a

implementação do filtro é descartada;

• No caso de resistores de aquecimento ou motores DC o filtro é

dispensável, uma vez que estes componentes já atuam como

filtros, desde que a frequência do PWM não seja muito baixa.

PWM - DAC

7 /59

PWM com filtro RC

8 /59

1 – Escolhe p/ gerar pulsos 2- Tensão de pico (5V)3 – duty = 10% 4 – freq. Do PWM

Etapas:

PWM com filtro RC

9 /59

Duty = 10% Duty = 70%

Veja alguns exemplos em:http://ww1.microchip.com/downloads/en/AppNotes/00655a.pdfhttp://aquaticus.info/pwm-sine-wavehttp://www.wpi.edu/Pubs/E-project/Available/E-project-042711-190851/unrestricted/PWM_Techniques_final.pdf

PWM com filtro RC

10 /59

Veja o resultado da simulação com um sinal PWM aplicado em utilizandoum filtro RC com 2 estágios, para geração de um sinal senoidal.

Filtro RC com 2 polos Sinal de entrada pwm de 19kHz e duty de 70%

PWM com filtro LC

11 /59

• Veja o resultado da simulação com um sinal PWM aplicado emutilizando um filtro LC com 2 estágios, para geração de um sinalsenoidal.

• Em não havendo necessidade de obter tensão média contínua, utiliza-se o PWM sem filtros (aquecimento e acionamento de motores), desdeque a frequência do PWM não seja muito baixa.

Filtro LC com 2 polosSinal de entrada pwm de 19kHz e duty de 80%

PWM gerado com 555

12/59

x1

X2

X2

X1R3

1k

Q1BD136

+88.8

M1

D1

1N4148

BAT112V

A

B

C

D

SW1SW-DPDT HH duplo

C3100n

SW1 Controla o sentido de rotação

RV1 Controla a velocidade (PWM)

Controle de Velocidade de motor DC (PWM)Prof Ilton BarbacenaIFPB - Maio - 2012

42%

RV1

47k

R11k

R4

DC7

Q3

GN

D1

VC

C8

TR2

TH6

CV5 U1

555

C1

0.01u

C20.1u

D21N4148

D31N4148

Volts

rpm

Componentes fora da PCI:

- Potenciômetro

- Chave reversora (H-H dupla)

- Fonte de alimentação

- Motor DC (12V)

Nota: Usar conectores KRE para ligações da PCI aos componentes fora da PCI (chassis)

PWM trivial com Arduino

• Esta técnica tem a vantagem de que se pode usar qualquer pino de saída digital.

Além disso, tem-se o controle completo do ciclo de trabalho e da frequência.

• Uma grande desvantagem é que quaisquer interrupções irá afetar o tempo, o

que pode causar instabilidade considerável a menos que você se desabilite

todas as interrupções.

• Nesta fonte de PWM é difícil determinar as constantes apropriadas para um

ciclo de trabalho particular e frequência, a menos que você queira contar os

ciclos cuidadosamente, enquanto observa no osciloscópio.

13/59

void setup(){pinMode(13, OUTPUT);

}void loop(){digitalWrite(13, HIGH);delayMicroseconds(100); // aproximadamente 10% duty cycle @ 1KHzdigitalWrite(13, LOW);delayMicroseconds(1000 - 100);

}

PWM trivial com filtro no Arduino

14/59Implementação do exemplo anterior

PWM com uso de analogWrite() no Arduino

• PWM no arduíno é fácil de utilizar, com a função: analogWrite(pin, dutyCycle),

onde dutyCycle is um valor de 0 a 255, e o pin é uma das saídas analógicas

(pinos 3, 5, 6, 9, 10, ou 11).

• A função analogWrite fornece uma interface simples, mas não fornece qualquer

controle sobre frequência. (Note-se que, apesar do nome da função, a saída é

um sinal digital, muitas vezes referenciada como uma onda quadrada.)

• Provavelmente 59% dos leitores pode parar aqui, e usar apenas analogWrite

para PWM, mas há outras opções que oferecem mais flexibilidade.15/59

#define ledPin 5 // Pinos de pwm: 3, 5, 6, 9, 10, e 11 #define analogPin A3 // Leitura de potenciometro, tensao analogica

int val = 0, val1=0, val2=1;

void setup(){

pinMode(ledPin, OUTPUT); // saída do PWM

Serial.begin(9600);while(!Serial) {};

Serial.println("IFPB - Prof. Ilton");Serial.println("PWM com analogWrite()");Serial.println("Plataforma Arduino ");Serial.println("Jan / 2013");Serial.println(" ");delay(4000);

}

void loop()

{

val = analogRead(analogPin); // Le ADC: 0 ... 1023

val1= val/4; // máximo 255

if (val != val2) // se houver mudancas

{

analogWrite(ledPin, val1); // gerar PWM em ledPin

Serial.print("ADC = ");

Serial.print(val, DEC);

Serial.print(" duty = ");

Serial.print(100*val1/256, DEC);

Serial.println("% ");

}

val2 = val;

}

// val varia de 0 a 1023

// val1 varia de 0 a 255

PWM com uso de analogWrite() no Arduino

16/59Implementação do exemplo anterior

PWM com uso de registradores no Arduíno

• O microcontrolador ATMEGA328, do arduíno UNO, possui 3 temporizadores que podem controlar

até 6 saídas PWM diretamente, obtendo-se mais controle, do que a função analogWrite()

proporciona. A tabela abaixo resume os timers existentes na linha arduíno:

17/59

timer bits CanalPino no

UNO (CI)

Pino no

MEGA

timer0 8 A 6(12) 13

timer0 8 B 5(11) 4

timer1 16 A 9 (15) 11

timer1 16 B 10(16) 12

timer2 8 A 11 (17) 10

timer2 8 B 3(5) 9

timer3 16 A - 5

timer3 16 B - 2

timer3 16 C - 3

timer4 16 A - 6

timer4 16 B - 7

timer4 16 C - 8

timer5 16 A - 44

timer5 16 B - 45

timer5 16 C - 46

• No reset, o bootloader doArduíno configura os timerspara uso em PWM pelafunção analogWrite ();

• Os timers são configuradospara o modo “phase-

correct 8-bit” e com orelógio preescaleado por 64.

• No entanto, o timer0 éconfigurado para o modofast PWM, para uso dasfunções millis() / micros().


18/59Pinos do ATMEGA328 em vermelho relacionados a PWM

Timer output Arduino output Chip pin Pin name

OC0A 6 12 PD6

OC0B 5 11 PD5

OC1A 9 15 PB1

OC1B 10 16 PB2

OC2A 11 17 PB3

OC2B 3 5 PD3


• Timers no arduino:

– Timer0

• Timer0 é um temporizador de 8 bits. Na plataforma arduino o timer0 estásendo utilizado para as funções de tempo, como delay(), Millis() emicros(). Se houver alteração nos registradores do uC do arduíno, relativoa timer0, isso pode influenciar nas funções de temporizador. Então, vocêdeve saber o que está fazendo.

– Timer1

• Timer1 é um temporizador de 16 bits. Na plataforma Arduíno, a bibliotecaServo usa timer1 do Arduíno Uno e timer5 no Arduíno Mega.

– Timer2

• Timer2 é um temporizador de 8 bits como timer0. A função Tone() usatimer2.

– Timer3, Timer4, Timer5:

• Temporizador 3,4,5 estão disponíveis apenas em placas Arduino Mega.Estes temporizadores são todos os temporizadores de 16 bits.

19/59


• O controlador do arduino UNO é o AVR Atmel ATmega168 ouATmega328. Estes uCs são compatíveis pino a pino e apenas diferemno tamanho da memória interna. Ambos têm 3 temporizadores, chamadotimer0, timer1 e timer2. O Timer0 e timer2 são temporizador de 8 bits, eo timer1 é um temporizador de 16 bits.

• Um timer é um bloco de hardware embutido no controlador do arruíno eem outros uC. É como um relógio, e pode ser utilizado para medireventos de tempos.

• A diferença mais importante entre temporizador de 8 bits e 16 bits é aresolução do temporizador: 8bits significa 256 valores e 16bit significa65536 valores para maior resolução.

• O temporizador é programado por alguns registradores especiais. Pode-se configurar o prescaler para o timer, o modo de operação, e muitasoutras coisas.

20/59


• Os temporizadores também podem gerar interrupções no overflow (finalde contagem) como também, comparar valores de registradores, quandousados em CCR (capture e Compare);

• O controlador para a série arduino Mega é o AVR Atmel ATmega1280 ouo ATmega2560. Este é semelhante ao ATmega328 do UNOdiferenciando-se apenas no tamanho da memória. Estes controladorestêm 6 temporizadores. O timer0, timer1 e timer2 são idênticos aos doATmega168/328. O timer3, timer4 e timer5 são todos os temporizadoresde 16 bits, semelhante ao timer1.

• Todos os temporizadores depende do relógio do sistema.

• Normalmente, o relógio do sistema é 16MHz, mas para o Arduino Pro,3,3 V, é 8MHz. Portanto, deve-se ter cuidado ao escrever funçõesutilizando os timers.

• O hardware do temporizador pode ser configurado usando algunsregistradores especiais da CPU. No firmware do arduíno todos ostemporizadores foram configurados para uma frequência de 1kHz einterrupções são geralmente habilitadas.

21/59


22/59

• Cada um dos temporizadores tem um contador que é incrementado a cada instante do relógio do timer;

• A contagem interrompe quando o contador chegar a um valor final (especificado para a comparação);

• Uma vez que um contador atingiu este valor máximo, o contador é zerado;

• Ao escolher o valor máximo para a comparação pode-se controlar a freqüência de interrupções do timer.

• O primeiro parâmetro a ser considerado é a velocidade com que o temporizador incrementa o contador.

Como o clock do Arduino é de 16MHz, esta é a maior velocidade que os temporizadores podem

incrementar seus contadores.

• Em 16MHz cada tique-taque do contador representa 1/16, 000.000 de um segundo =~ 63ns:

• Para uma contagem de 0 a 9 => T = 10/16000000s (tempo p/ fazer a contagem)

• Para uma contagem de 0 a 99 => T = 100/16000000s;

• Para uma contagem de 0 a 255 => T = 256/16000000s =~ 16uS / máx para timer0 e timer2;

• Para uma contagem de 0 a 65535 => T = 65536/16000000 = ~ 4 ms / máximo para timer1 (16bits);

• Prescaler => Aumenta o tempo de contagem. Todos os timers pode selecionar o prescaler de 1, 8, 64, 256 e

1024;

Prescaler nos Timers:

Ftimer (Hz) = (Fclock ) / prescaler

Valor_registrador = (16 MHz) / (prescaler * tempo) ) – 1

Exemplo: tempo=1s / prescaler = 1024 => valor_do registrador = 15624 => (apenas o timer1)

Timers no Arduino

23/42

• Diagrama de blocos dos TImers

• count Incrementa e decrement TCNTn por 1;• direction Seleciona incremento ou decremento;• clear limpa TCNTn;• clkTn clock do timer• top indica que TCNTn atingiu valor máximo;• bottom indica que TCNTn atingiu valor mínimo (0)

O bit flag TOVn é setadode acordo com o modo deoperação em WGMn2:0,podendo ser usado paragerar uma interrupção.

Modos de Operação:

Os bits WGM (WaveformGeneration Mode)controlam os vários modosde funcionamento dostimers.

Timers no Arduino

24/42

• Waveform Generation Mode bits (WGM) – Timer0 (8 bits)

Modos:

• Normal• PWM - Phase

Correct• PWM – Fast• CTC• Desligado

Timers no Arduino

25/42


Modos:

• Normal• PWM – fase Correta• PWM – fase Correta – 8bits• PWM – fase Correta – 9bits• PWM – fase Correta – 10bits• PWM – fase e frequência

Correta• PWM – Fast• PWM – Fast, 8 bits• PWM – Fast, 9 bits• PWM – Fast, 10 bits• CTC• Desligado

Timers no Arduino

26/42


Modos:

• Normal• PWM – Phase Correct

• Fast PWM

• CTC

Timers no Arduino

27/42

• Timer/Counter Prescaler – Timer1

Timers no Arduino

28/42

• Timer/Counter Prescaler – Timer2

Timers no Arduino

29/42

8-b

it T

ime

r/C

ou

nte

r2 w

ith

PW

M a

nd

As

yn

ch

ron

ou

s O

pe

rati

on • O ATMEGA328 tem 3

timers e 6 saídasPWM;

• O Arduino usa oTimer0, 8bits,

internamente para asfunções millis() edelay();

• Portanto, mudando osregistradores destetimer, pode afetar ouso destas funções;

• A biblioteca de PWMusa estas funçõesinternamente:analogWrite(pin, duty_cycle)

Timer0 => Pinos de saída: PD6 (6) e PD5(5)Timer1 => Pinos de saída: PB1(9) e PB2(10)Timer2 => Pinos de saída: PB3(11) e PD3(3)

Timers no Arduino

30/42

• Cada temporizador tem 2 registradores para comparar osvalores de contagem com o valor limite ou programado (0xFFou OCRnA), e controlar a largura PWM;

• Quando o registrador de contagem chega no valorprogramado, a CPU é avisada através de um bit flag, quepode causar uma interrupção, se previamente programada.

• O Temporizador/Contador pode ser sincronizadointernamente, através do prescaler (AS2=0, default), ou deforma assíncrona com clock nos pinos TOSC (TOSC1 eTOSC2 / AS2=1, neste caso).

• A operação assíncrona (externa/Tn) é controlada pelo EstadoAssynchronous Register (RAEE).

Timers no Arduino

31/42

• Cada um dos timers tem um contador que é incrementado oudecrementado a cada pulso de clock;

• A interrupção do timer ocorre quando o contador atingir 0xFF ouchegar a um valor especificado previamente no registrador decomparação do timer (OCR2A – Output Compare Register A ouOCR2B – Output Compare Register B);

• Neste momento o valor do contador é zerado e inicia novamente anova contagem;

• A frequência PWM gerada pode ser controlado de 2 modos: (b)frequência de PWM, usando o prescaler; (b) limite superior docontador (0xFF ou OCRnA);

• Ao escolher o valor para a comparação, junto com o valor dafrequência de clock (usando o prescaler), que sincroniza oincremento no contador, pode-se controlar a frequência deinterrupções do timer, quando habilitada, bem como, a geração doPWM.

Timers no Arduino

32/42

• Timer1 - Output Unit (16 bits)

• O contador de 16-bit é formado por dois registradoresde 8-bit: TCNT1H e TCNT1L. O Registro TCNT1H sópode ser acessada indiretamente pela CPU;

• Quando a CPU precisa acessar TCNT1H I, usa oregistro temporário (TEMP).

• O registo temporário é atualizado com o valor TCNT1Hquando o TCNT1L é lido, e TCNT1H com o valor doregistrador temporário, quando escreve em TCNT1L.Isso permite a CPU a ler ou escrever todo o valor de16 bits dentro um ciclo de clock através do barramentode dados de 8 bits.

• Dependendo do modo de operação utilizado, ocontador é limpo, incrementado ou decrementado acada relógio temporizador (clkT1).

• O sinal clkT1 pode ser gerada a partir de uma fonte derelógio externo ou interno, selecionado pelos bitsRelógio Select (CS12: 0). Quando não há fonte declock é selecionado (CS12: 0 = 0) e o cronômetro éparado.

• No entanto, o valor TCNT1 pode ser acessada pelaCPU, independentemente de clkT1 está presente ounão.

Timers no Arduino

33/42

• Timer2 - Output Compare Unit (8 bits)

• O comparador de 8 bits que comparacontinuamente TCNT2 com a saída doRegistrador (OCR2A ou OCR2B).

• Sempre que TCNT2 for igual a OCR2A ouOCR2B, o comparador seta o flagcorrespondente (OCF2A ou OCF2B) paraavisar o timer e reiniciar a contagem;

• Se a interrupção correspondente estiverativada, é acionada a rotina de atendimentoa interrupção, onde o flag éautomaticamente limpo;

• Como alternativa, o flag pode ser limpo porsoftware, escrevendo 1 diretamente noregistrador correspondente;

• O PWM gerado utiliza o flag para gerar umasaída OC2A ou OC2B, de acordo com omodo de funcionamento definido porWGM22:0 e COM2x1:0.

Pinos de saída: 3 (OC2B) e 11 (OC2A)

Timers no Arduino

34/42

• Modos de operação do Timer2 (8 bits)

• Modo Normal– O timer conta normalmente até o MAX, 0xFF, quando reinicia a contagem, setando flag de

interrupção (TOP = MAX);– Não gera PWM automático, podendo ser gerado na rotina de interrupção;

• Modo Clear Timer on Compare Match (CTC)– O timer conta normalmente até atingir o limite o TOP de contagem:OCR2A ou OCR2B, quando

reinicia a contagem, setando flag de interrupção;– Não gera PWM automático, podendo ser gerado na rotina de interrupção;

• Modo: Fast PWM– Um modo de geração automática de PWM nos pinos 11 e/ou 3, onde ocorre o incremento do

MIN ao TOP (neste caso, MIN=0);• Modo: Phase Corrected PWM

– Um modo de geração automática de PWM nos pinos 3 e/ou 11, onde o contador incrementa deMIN até o TOP e, em seguida, decrementa até o valor mínimo (0).

– Melhor opção para acionamento de certas cargas, como motores.

• Modo: Phase and Frequency Corrected PWM

• Diferencia-se do anterior apenas no momento em que o registrador OCRnx é atualizado com onovo buffer. Como o nome sugere, a vantagem do Phase and Frequency correct PWM é ser maisapropriado para alterar a frequência do PWM, por estar os sinais PWM em fase.

Para qualquer um dos modos, existem 3 bits no registrador TCCR2B, que alteram oprescaler ou o relógio do contador. Valores do prescaler: 1, 8, 32, 64, 128, 256 e 1024.

Timers no Arduino

35/42

• Fast PWM no Timer2

• O timer conta até OCR2x, e nesse momento atualiza o pino OC2x (se o liga ou desligadepende da configuração dos bits COM1x0 e COM1x1).

• Depois continua a contar até TOP, e nesse momento volta ao BOTTOM e atualiza o pino OC2x,alterando o seu estado;

Pino OC2A – duty de 66,66% Pino OC2B – duty de 33,66%

Timers no Arduino

36/42

• Phase Corrected PWM no Timer2

• O timer conta até OCR2x, e nesse momento atualiza o pino OC2x (se o liga ou desligadepende da configuração dos bits COM1x0 e COM1x1).

• Depois decrementa até chegar ao BOTTOM (0). Ao passar por OCR2x atualiza o pino OC2x,alterando o seu estado;

Timers no Arduino

37/42

• Timer2 – Modos de Operação

• Fast PWM Mode (WGM22:0 = 3 ou 7)

• Usado para gerar frequencias maiores para o PWM;• No modo de PWM rápido, o contador é incrementado até que o valor do contador atingir ao valor

TOP, aí o contador é então limpo no ciclo seguinte do relógio temporizador.• O valor TCNT2 e o diagrama de temporização estão ilustrads na figura a seguir;• O diagrama inclui saídas PWM não invertida e invertida;• As pequenas marcas vistas na linha horizontal na TCNT2 representam a comparação entre

OCR2x e TCNT2;• No modo de PWM rápido, a unidade de comparação permite a geração de formas de onda PWM

no pino OC2x;• Definindo os bits COM2x1:0 para 2 será produzido um PWM não invertida e uma saída PWM

invertido;• Definindo a COM2x1:0 para 3, TOP é definido como 0xFF quando WGM2:0 = 3, e quando

MGM2:0 = 7 em OCR2A ;• O valor OC2x real só será visível no pino da porta se a direção de dados para o pino da porta for

definido como saída.• A forma de onda PWM é gerada ajustando-se o Registrador OC2x equando entre OCR2x for

igual a TCNT2;• A frequência de saída de PWM pode ser calculada pela seguinte equação:

N = prescaler = (1, 8, 32, 64, 128, 256, ou 1024)

Timers no Arduino

38/42


• Fast PWM Mode (WGM22:0 = 3 ou 7)

N = prescale = (1, 8, 32, 64, 128, 256, ou 1024)

Duty = (OCR2A *N * 256 / clk I/O)

• O flag de estouro do timer, TOV2, é setado a cadaestouro de contagem (TOP). Se a interrupção estiverativada, a rotina de tratamento de interrupção pode serutilizada para atualizar o valor de comparação,permitindo gerar o PWM no pino OC2x;

• Definindo os bits COM2x1:0 = 2 irá produzir um PWMnão invertido, e uma saída PWM invertido pode sergerado, definindo a COM2x1:0 = 3;

• O TOP é definido como 0xFF, quando WGM2:0 = 3, equando em OCR2A, MGM2: 0 = 7;

• O valor OC2x somente estará visível no pino da porta sea direção de dados para o pino da porta estiver definidacomo saída.

• A forma de onda PWM é gerada no registrador OC2x (1ou 0), durante a comparação entre OCR2x e TCNT2, ena transição lógica de durante os pulsos de alto para

baixo;;A frequência de PWM da saída pode ser calculada pelaseguinte equação:

Neste modo o timer conta de 0 a 255. A saída liga quando o timer é 0, e desligaquando o valor do timer corresponder ao valor do registrador OCR2A. Quantomaior o valor da saída de comparação, maior o ciclo de serviço (duty).Os valores extremos para o Registrador OCR2A representam casos especiais aogerar um PWM de saída neste modo. Se o OCR2A = BOTTOM, a saída será umpico estreito para cada ciclo de clock (MAX+1). Se OCR2A=MAX+1, resultaránuma saída constante, alto ou baixo, dependendo da polaridade da saídadefinido nos bits COM2A1: 0.

Timers no Arduino

39/42


• Clear Timer on Compare Match (CTC) Mode

(WGM22:0 = 2)

• Neste modo, o registrador OCR2A é usado para configurar a resolução do timer;• No modo CTC o contador é zerado quando o timer atingir o valor do contador

(TCNT2) for igual ao valor no registrador OCR2A;• O OCR2A define o topo da contagem, portanto, a resolução do timer;• Este modo permite maior controle na comparação e no frequência do sinal de saída;• Este modo simplifica a operação com evento externo;

1. Para gerar uma de forma de onda nasaída no CTC modo, a saída OC2A podeser definido para alternar o nível lógico emcada partida comparação definindo acomparar bits de modo de saída paraalternar o modo de (COM2A1: 0 = 1).

2. A frequência da forma de onda é definidopela seguinte equação:

N = prescaler ={1, 8, 32, 64, 128, 256, ou 1024}

Timers no Arduino

40/42


• Phase-Correct PWM (WGM22:0 = 1 ou 5)

• O TOP é definido como 0xFF quando WGM2:0 = 3, e quando em OCR2A, MGM2:0 = 7;• A saída da comparação (OC2x) é zerada enquanto o timer estiver com valores acima do TOP de

comparação e setado para valores abaixo, execeto na primeiro ciclo, que inicia setada;• A operação de inclinação dupla tem menor freqüência de operação que a de inclinação única. No

entanto, devido à característica simétrica dos modos de dupla inclinação PWM, estes modos sãopreferidos para aplicações de controle do motores;

• Neste modo o timer é incrementado até o TOP e, então, muda a direção de contagem. O valor deTCNT2 será igual ao TOP uma vez no ciclo do timer;

• O flag TOV2 é setado toda vez que o timer igualar ao valor BOTTOM (mais baixo);• Neste modo é gerado um sinal PWM no pino OC2x, fazendo-se COM2x1:0=2, produz o PWM

invertido;• Um PWM invertido pode ser gerado fazendo-se COM2x1:0=3;• O TOP é definido como 0xFF quando WGM2:0 = 3, e em OCR2A, MGM2:0 = 7;

Neste modo, o timer conta de 0 a 255e, em seguida, de volta para 0.Este modo baseia-se numa operaçãode dupla inclinação;

Timers no Arduino

41/42


• Phase-Correct PWM (WGM22:0 = 1 ou 5)

O valor OC2x somente ficará visível no pino da porta se a direção de dados para o pino da porta for definida como saída;A frequência de PWM na saída pode ser calculada pela seguinte equação:

N = prescale ={1, 8, 32, 64, 128, 256, ou 1024}

Timers no Arduino

42/42

TCCR2A –

Timer/Counter Control

Register A

TCCR2B –

Timer/Counter

Control Register B

TCNT2 –

Timer/Counter

Register

OCR2A – Output

Compare Register A

OCR2B – Output

Compare Register B

Registradores para TIMER2:

Timers no Arduino

43/42

TIMSK2 – Timer/Counter2

Interrupt Mask Register

TIFR2 – Timer/Counter2

Interrupt Flag Register

ASSR – Asynchronous

Status Register

GTCCR–General Timer/Counter

Control Register

Registradores para TIMER2:

Timers no Arduino

44/42

Detalhes dos registradores para TIMER2: TCCR2A

Timers no Arduino

45/42

Detalhes dos registradores para TIMER2:

• TCCR2A – Timer/Counter Control Register A• TCCR2B – Timer/Counter Control Register B

• Bit 7 de TCCR2B – FOC2A: Force Output Compare A• Ativo somente quando WGM configurar modo de não PWM / não gera interrupção / Sempre lido como 0;

• Bit 6 de TCCR2B – FOC2B: Force Output Compare A• Ativo somente quando WGM configurar modo de não PWM / não gera interrupção / Sempre lido como 0;

• TCNT2 – Timer/Counter Register• Contador do timer2 de 8 bits / Usado para comparar valores com o registrador OCR2x;

• OCR2A – Output Compare Register A• Registrador 8 bits com valor para comparar com TCNT2. O resultado pode gerar interrupção e gerar sinal no pino OC2A;

• OCR2B – Output Compare Register B• Registrador 8 bits com valor para comparar com TCNT2. O resultado pode gerar interrupção e gerar sinal no pino OC2B;

• TIMSK2 – Timer/Counter2 Interrupt Mask Register• Bit 2 – OCIE2B: Timer/Counter2 Output Compare Match B Interrupt Enable

• Se 1, habilita interrupção quando TCNT2 = OCR2B levando o flag OCF2B= 1, em TIFR2, e desviando o programa p/ atender a interrupção;

• Bit 1 – OCIE2A: Timer/Counter2 Output Compare Match A Interrupt Enable• Se 1, habilita interrupção quando TCNT2 = OCR2A levando o flag OCF2A= 1, em TIFR2, e desviando o programa p/ atender a

interrupção;• Bit 0 – TOIE2: Timer/Counter2 Overflow Interrupt Enable

• Se 1, habilita interrupção quando ocorrer overflow no timer2 levando o flag TOV2=1, em TIFR2, e desviando o programa p/ atender a interrupção;

• TIFR2 – Timer/Counter2 Interrupt Flag Register• Bit 2 – OCF2B: Output Compare Flag 2 B

• Se 1, indica houve uma interrupção decorrente de quando TCNT2 = OCR2B;• Bit 1 – OCF2A: Output Compare Flag 2 A

• Se 1, indica houve uma interrupção decorrente de quando TCNT2 = OCR2A;• Bit 0 – TOV2: Timer/Counter2 Overflow Flag

• Se 1, indica que houve uma interrupção decorrente do estouro de timer2;

Timers no Arduino

46/42

Detalhes dos registradores para TIMER2:

• ASSR – Asynchronous Status Register• Bit 7 – Reserved• Bit 6 – EXCLK: Enable External Clock Input

• Se 1, clock assíncrono (externo) é selecionado para um clock de 32 KHz no pino TOSC1;• Bit 5 – AS2: Asynchronous Timer/Counter2

• Se 0, indica clock interno clkI/O e se 1, clock externo em TOSC1 ;• Bit 4 – TCN2UB: Timer/Counter2 Update Busy

• Se 0, indica que TCNT2 está pronto para atualização;• Bit 3 – OCR2AUB: Output Compare Register2 Update Busy

• Se 0, indica que OCR2A está pronto para atualização;• Bit 2 – OCR2BUB: Output Compare Register2 Update Busy

• Se 0, indica que OCR2B está pronto para atualização;• Bit 1 – TCR2AUB: Timer/Counter Control Register2 Update Busy

• Se 0, indica que TCCR2A está pronto para atualização;• Bit 0 – TCR2BUB: Timer/Counter Control Register2 Update Busy

• Se 0, indica que TCCR2B está pronto para atualização;

Os mecanismos para a leitura TCNT2, OCR2A, OCR2B, TCCR2A e TCCR2B são diferentes. Ao ler TCNT2, o valor atual é lido. Ao ler OCR2A, OCR2B, CCR2A e TCCR2B o valor no registrador é lido.

• GTCCR – General Timer/Counter Control Register• Bit 1 – PSRASY: Prescaler Reset Timer/Counter2

• Se 1, o prescaler é resetado. Não pode ser zerado por hardware, se TSM=1.


47/59

#define TOGGLE_PIN 13#define pot A3

int ler=0, ler1=2, ler3;

void setup() {

// Setup Timer2 overflow to fire every 8ms (125Hz)// period [sec] = (1 / f_clock [sec]) * prescale * (255-count)// (1/16000000) * 1024 * (255-130) = .008 secSerial.begin(9600);while(!Serial) {};

TCCR2B = 0x00; // Disable Timer2 while we set it up

TCNT2 = 130; // Reset Timer Count (255-130) = execute ev 125-th T/C clockTIFR2 = 0x00; // Timer2 INT Flag Reg: Clear Timer Overflow FlagTIMSK2 = 0x01; // Timer2 INT Reg: Timer2 Overflow Interrupt EnableTCCR2A = 0x00; // Timer2 Control Reg A: Wave Gen Mode normalTCCR2B = 0x07; // Timer2 Control Reg B: Timer Prescaler set to 1024

Serial.println("IFPB - Prof. Ilton");Serial.println("PWM com Timer2 Normal");Serial.println("Plataforma Arduino ");Serial.println("Jan / 2013");Serial.println(" ");delay(2000);

}

void loop(){

ler = analogRead(pot); // ler potenciometroler3 = map(ler, 0, 1023, 0, 255);

if (ler != ler1){

Serial.print("ler = ");Serial.print(ler, DEC);Serial.print(" ler3 = ");Serial.println(ler3, DEC);

}

ler1=ler;

}

ISR(TIMER2_OVF_vect) {static unsigned int led_state = 0; // LED state

led_state = !led_state; // toggles the LED state

digitalWrite(TOGGLE_PIN, led_state);

//TCNT2 = 130; // 8mSTCNT2 = ler3; TIFR2 = 0x00; // timer2 int flag reg: clear overflow flag

};

Neste exemplo temos o uso do estouro de timer2, para gerar um pwm de duty de 50%


48/59

PWM normal com uso de registradores do timer2

Geração do PWM descrito no exemplo anterior, onde observa-se que mesmo mudando o valor do estouro de contagem, o duty fica em 50%


49/59

#define pwm1 3 // OC2B#define pwm2 11 // OC2A#define pot A3int ler=0, ler1=2, ler3;

void setup() {

// Setup Timer2 overflow to fire every 8ms (125Hz)// period [sec] = (1 / f_clock [sec]) * prescale * (255-count)// (1/16000000) * 1024 * (255-130) = .008 secSerial.begin(9600);while(!Serial) {};

pinMode(pwm1, OUTPUT);pinMode(pwm2, OUTPUT);pinMode(pot, INPUT);

TCCR2A = _BV(COM2A1) | _BV(COM2B1) | _BV(COM2B0) |_BV(WGM22) | _BV(WGM21)| _BV(WGM20);

// COM2A=10 => Fast pwm no pino OC2A (não invertido)// COM2B=11 => Fast pwm no pino OC2B (invertido)// WGM=7 => Fast PWM com MAX em OCR2A

TCCR2B = _BV(CS22); // CS22=1 => prescaler 64 para timer2 OCR2A = 180;OCR2B = 50; Serial.println("IFPB - Prof. Ilton");Serial.println("PWM Fast - timer2");Serial.println("Plataforma Arduino ");Serial.println("Jan / 2013");Serial.println(" ");delay(2000);

}

void loop(){

ler = analogRead(pot); // ler potenciometroler3 = map(ler, 0, 1023, 0, 255);

OCR2A = ler3;OCR2B = 256-ler3;

if (ler != ler1) // mostra mudancas{

Serial.print("ler3 = ");Serial.print(ler3, DEC);Serial.print(" ORR2A = ");Serial.print(ler3, DEC); Serial.print(" OCR2B = ");Serial.println(256-ler3, DEC);

}

ler1=ler;delay(100);

}

Exemplo: Fast PWM em timer2


50/59

Geração do PWM descrito no exemplo anterior, com o duty variável


51/59

Driver para Motor DC ou servo: L293D

Fonte: http://www.societyofrobots.com/member_tutorials/node/164

• Controla 2 motores DC deforma independente;

• Para cada motor é possívelcontrolar o sentido derotação e a velocidade comum sinal de PWM;

• Limitado a até 1,2 A / 12Vpor motor DC.


52/59

Driver para Motor DC: SN754410

http://www.sparkfun.com/datasheets/IC/SN754410.pdf


53/59

Funcionamento dos drivers L293D ou SN754410

Características:• Controlam até 2 motores DC ou servos• Para cada motor: (a) controle de sentido de rotação; (b) Controle de velocidade; (c ) Alimentação independente;


54/59

Funcionamento dos drivers L293D ou SN754410#define pwm1 3 // OC2B#define pwm2 11 // OC2A#define pot A3 // controla velocidade (PWM)#define led1 4 // pino do led que sinaliza qdo botao acionado#define in1 A0 // controla sentido rotação do motor

int ler=0, ler1=2, ler3;boolean inv1=0, inv=0, ss=0; //

void setup() {Serial.begin(9600);while(!Serial) {};

pinMode(pwm1, OUTPUT);pinMode(pwm2, OUTPUT);pinMode(pot, INPUT);pinMode(led1, OUTPUT); // pisca led qdo muda o sentidopinMode(in1, OUTPUT); // muda o sentido de rotacao attachInterrupt(0, muda_sentido, RISING); // interrupção no botao

TCCR2A = _BV(COM2A1)| _BV(COM2B1) | _BV(COM2B0) | _BV(WGM22) | _BV(WGM21)| _BV(WGM20);

// COM2A=10 => Fast pwm no pino OC2A (não invertido)// COM2B=11 => Fast pwm no pino OC2B (invertido)// WGM=7 => Fast PWM com MAX em OCR2A

TCCR2B = _BV(CS22); // CS22=1 => prescaler 64 para timer2 OCR2A = 180; OCR2B = 50; Serial.println("IFPB - Prof. Ilton");Serial.println("PWM Fast - L293D");Serial.println("Plataforma Arduino ");Serial.println("Jan / 2013"); Serial.println(" "); ss=1; delay(500);

} // setup

void loop(){ler = analogRead(pot); // ler potenciometroler3 = map(ler, 0, 1023, 0, 255); OCR2B = ler3;OCR2A = 256-ler3;

if (ler != ler1){

Serial.print("ler3 = "); Serial.print(ler3, DEC);Serial.print(" INV= ");if (inv) Serial.println(" 1"); else Serial.println(" 0");

} ler1=ler;delay(100);

} // loop

void muda_sentido(){inv1 = ~inv1;inv = ~inv; // liga motor

digitalWrite(led1, inv1); // inverte leddigitalWrite(in1, inv); // inverte sentidoif (ss){Serial.print(" INV= "); if (inv)Serial.println(" 1");

elseSerial.println(" 0");

}}

Uso do driver L293 p/ motor DC

55/59

Usando o driver L293D (O CI L293DD possui 4 drivers):

• Para controlar os motores, utiliza-se os pinos 2 e 7 para motor 1 e os pinos 10 e 15 para motor 2.• Os pinos de ligação aos motores são os pinos 3 e 6 para um dos motores e 11 e 14 para o outro. Os aterramentos são

os pinos 4 e 13 e 5 e 12 para os motores 1 e 2;• Os pinos 1 e 9 habilitam os canais; para utilizar 1 motor sinalize 1 ou 9. Para utilizar 2 motores, sinalize ambos. Para tal,

basta liga-los à 5v;

• O pino 16 é a alimentação do circuito lógico, onde que deve ser conectada a 5v;• O pino 8 é a entrada de energia para alimentação dos motores. Essa entrada suporta até 36v, ou seja, podemos

tranquilamente alimentar 2 motores de impressora;


56/59

Usando o driver L293D:

Ligando e mudando o sentido de rotação do motor DC com L293D


57/59

const int L293_ENA2 = 8; // D8const int L293_INP3 = 9; // D9const int L293_INP4 = 10; // D10#define led1 4 // pino do led que sinaliza qdo botao acionado

int inv=0, ss=0;boolean inv1=0;

void setup() { Serial.begin(9600);while(!Serial) {};

pinMode (L293_ENA2, OUTPUT); pinMode (L293_INP3, OUTPUT); pinMode (L293_INP4, OUTPUT); pinMode (led1, OUTPUT); attachInterrupt(0, muda_sentido, RISING);

digitalWrite (L293_ENA2, LOW); digitalWrite (L293_INP3, LOW); digitalWrite (L293_INP4, LOW);

Serial.println("IFPB - Prof. Ilton");Serial.println("L293D sem PWM");Serial.println("Plataforma Arduino ");Serial.println("Jan / 2013 - inv=1"); Serial.println(" "); ss=1;

digitalWrite (L293_ENA2, HIGH);digitalWrite (L293_ENA2, LOW);digitalWrite (L293_INP4, HIGH); digitalWrite (L293_INP3, LOW);digitalWrite (L293_ENA2, HIGH); delay(1000);

}

void loop () { }

void muda_sentido(){inv1 = ~inv1; digitalWrite(led1, inv1); // inverte led

switch(inv){case 0: // esquerdadigitalWrite (L293_ENA2, LOW);digitalWrite (L293_INP4, LOW); digitalWrite (L293_INP3, HIGH);digitalWrite (L293_ENA2, HIGH); break;

case 1: // direitadigitalWrite (L293_ENA2, LOW);digitalWrite (L293_INP4, HIGH); digitalWrite (L293_INP3, LOW);digitalWrite (L293_ENA2, HIGH); break;

case 2: // paradodigitalWrite (L293_ENA2, LOW);digitalWrite (L293_INP3, LOW); digitalWrite (L293_INP4, LOW);digitalWrite (L293_ENA2, LOW); break;

}

if (ss){Serial.print(" INV= "); Serial.println(inv, DEC);

}inv++;if (inv >= 3) inv=0;

}

PWM no ARDUINOFontes de Consulta:

http://arduino.cc/en/Tutorial/PWMhttp://arduino.cc/en/Tutorial/SecretsOfArduinoPWMhttp://www.eletronica.org/arq_apostilas/apostila_pwm.pdfhttp://jaktek.com/wp-content/uploads/2011/12/HC-SR04.pdfhttp://www.instructables.com/id/Easy-ultrasonic-4-pin-sensor-monitoring-hc-sr04/http://playground.arduino.cc/Main/PWMallPinshttp://www.fiz-ix.com/2012/01/how-to-configure-arduino-timer-2-registers-to-drive-an-ultrasonic-transducer-with-a-square-wave/http://blipbox.org/blog/2011/05/23/arduino-squarewave-generation/https://sites.google.com/site/qeewiki/books/avr-guide/pwm-on-the-atmega328http://lusorobotica.com/index.php?topic=2838.120http://www.mythic-beasts.com/~markt/ATmega-timers.htmlhttp://www.societyofrobots.com/member_tutorials/book/export/html/228http://electronics.stackexchange.com/questions/26363/how-do-i-create-a-timer-interrupt-with-arduinohttp://bluepichu.wordpress.com/2012/07/16/fast-pwm-with-arduino-fast/http://www.cursodearduino.com.br/apostila/apostila-rev4.pdfhttp://www.societyofrobots.com/member_tutorials/node/159http://labdegaragem.com/profiles/blogs/tutorial-motor-de-passo-parte-3-circuitos-de-acionamentohttp://itp.nyu.edu/physcomp/Labs/DCMotorControlhttp://web.ics.purdue.edu/~fwinkler/616/sn754410_Arduino.pdfhttp://www.tigoe.net/pcomp/code/circuits/motors/stepper-motors/http://www.societyofrobots.com/member_tutorials/node/228http://www.logicaprogrammabile.it/shift-register-arduino-74595/

58/59

Obrigado

[email protected]

aula pwm arduino

Documents