INSTITUTO FEDERAL SUL-RIO-GRANDENSE

Campus Pelotas
ENGENHARIA ELÉTRICA

SISTEMAS DIGITAIS

PROFESSORO Dr. ADÃO ANTÔNIO DE SOUZA JÚNIOR

PROJETO DE SISTEMAS DIGITAIS

REGULADOR DE LUMINOSIDADE POR CONTROLADOR PWM

Integrantes:

Júlio César Burlamaqui Vianna

Mikael Silva

Pelotas

2009
Resumo—Atualmente, umas das formas mais utilizadas de controle na
indústria é a PWM (Pulse Width Modulation), a qual se destina controlar um
circuito analógico por meio de um circuito digital. Existem basicamente duas
técnicas para esse procedimento: a conversão D/A (digital/analógica) e a
modulação por largura de pulso (PWM). Nosso projeto utilizará como base de
controle a técnica PWM.

I. INTRODUÇÃO

A técnica de modulação por largura de pulso PWM tem sido de grande

aplicação na indústria atualmente, já que permite o controle de variáveis ou
parâmetros extremamente presentes nos processos industriais como:
freqüência de alimentação, tensão e corrente de partidas em motores CA
(corrente alternada), monitoramento de tensão de fornecimento em fontes
chaveadas, além de reguladores de luminosidade (dimmer’s). Essa técnica
possui a enorme vantagem de executar o controle sem a perda de potência no
circuito, pois basicamente funciona a partir do chaveamento sucessivo do sinal
entregue à carga, diferentemente os esquemas tradicionais.

II. FUNDAMENTAÇÃO TEÓRICA

A. Princípio básico de funcionamento da técnica PWM

A técnica PWM consiste no monitoramento do chaveamento de sinal

aplicado em uma carga, modulando assim a largura de pulso. Para um melhor
entendimento, considera-se o circuito ideal da (fig.1), onde a tensão entregue
ao dispositivo é controlada por uma chave de comutação rápida.

Fig. 1 Controle tradicional de potência através de potenciômetro conectado em série.

Quando o interruptor está aberto, não existe corrente circulando na carga1 e

a sua luminosidade é nula (potência entregue vale zero). No instante em que o
1
Para a análise do circuito ideal acima, considera-se como a carga se tratando de um led,
conforme a proposta do projeto.
interruptor é fechado, a carga ou led recebe tensão, assim possuindo uma
potência entregue máxima.

Considerando a onda de sinal entregue à carga com um período ou

freqüência constante, regulando o tempo em que esta chave fica acionada,
estaremos modulando a largura do pulso dessa onda, que apresenta a forma
quadrada devido a seu acionamento se por comutação rápida. Dessa forma,
controlaremos o valor médio da tensão fornecida à carga. Este controle do
tempo de chaveamento dentro de um dado ciclo (freqüência constante)
executará uma variação analógica da intensidade luminosa. A carga ou led
“enxergará” não uma onda quadrada em seu fornecimento de tensão, mas sim
uma variação gradual do valor médio de tensão, o que refletirá no brilho do led.

B. Análise do comportamento ondulatório

Considerando que a freqüência do sinal entregue é constante, quando

estipulamos a largura do pulso dessa onda simplesmente estamos informando
quanto tempo, desse período, essa onda estará em nível alto. Se, por exemplo,
for decidido que uma onda permanecerá metade de seu tempo em nível alto e
a outra metade em nível baixo (50% do período em alta), o valor de tensão
médio entregue à carga, o longo dos ciclos, será 50% do valor da tensão na
fonte.

Vemos então que a potência entregue ao dispositivo (no caso um led)

também será 50% do seu valor máximo (figura 2), de acordo com a fórmula 1:

P=V x I (1).

Fig. 2 Comportamento da onda em um controle PWM.

Dessa forma, definimos a largura de pulso pelo tempo em que o sinal de
entrega permanece em alta e o intervalo entre esses pulsos pelo tempo em que
esse mesmo sinal fica em baixa (figura 3).

Fig. 3 Controlador PWM regulado para 1% e 99% da potência máxima, respectivamente.

C. Justificativa da aplicação de um controle PWM comparativamente a um

controle convencional

Controladores de carga convencionais apresentam a desvantagem de

acrescentar uma resistência ao circuito, pois geralmente tratam-se de
resistores variáveis (reostatos ou potenciômetros) conectados em série ao
dispositivo. Neste ponto é que está o problema: essa resistência em série
causa uma dissipação de energia e redução da potência entregue à carga
(figura 4).

Fig. 4 Controlador de carga convencional. O potenciômetro conectado em série a carga gera

um grande perda de energia por efeito térmico.
 D. Registrador: o componente básico de um projeto RTL

O registrador é o componente básico de um projeto RTL. É através dele que

é permitido armazenar valores nas variáveis. Compõe-se de vários flip-flops e
podem armazenar dados com uma quantidade “n” de bits, neste exemplo o
registrador pode armazenar quatro bits [1].

Fig.5 Estrutura interna de um registrador de quatro bits.

Um exemplo é a utilização da variável “a”, no código vhdl deste projeto.

Neste caso, há a necessidade de armazenar valores que variam entre 0 e 100,
necessitando de um registrador de 7 bits.A descrição deste registrador de 7 bits
em vhdl (trecho do código deste projeto) pode ser observada na figura 6.

Fig.6 Descrição do registrador “a” do código vhdl (pequeno trecho do código completo).

III. OBJETIVOS: COMO O DISPOSITIVO DEVERÁ SE COMPORTAR

A implementação pretende utilizar como linguagem de descrição de

hardware (estrutura para a descrição dos circuitos digitais) o código VHDL. A
dinâmica do sistema consiste de um dispositivo capaz de controlar a largura de
pulso de tensão aplicado na carga (no caso um led) sem variar o valor de
freqüência do sinal.

A variação de luminosidade irá depender de um valor médio de tensão

aplicado ao led. Haverá dez valores de tensão média utilizados, sendo o
primeiro referente a 10% de intensidade de luz, o segundo 20% e assim
sucessivamente até 100% (intensidade máxima).

O incremento e decremento destes valores médios será efetuado através

de dois botões (chaves) conectados às entradas do dispositivo. Para
incrementar a voltagem, a chave “inc” deverá efetuar um disparo (borda de
subida) sobre o dispositivo. Já para o decremento o procedimento será
semelhante: ao se efetuar uma borda de subida, agora na entrada “dec”, o
valor de tensão irá reduzir-se em 10%, a partir de um valor atual até o
percentual mínimo de zero.

IV. METODOLOGIA

O fluxo de trabalho deste projeto se baseia no método de projeto mais

difundido atualmente. Este procedimento trabalha no nível de transferência
entre registradores e seu método é conhecido por projeto em nível de
transferência entre registradores ou projeto RTL (Register Transfer Level).
A idéia é especificar todas as operações que serão realizadas com os dados de
entrada e saída, que registradores serão utilizados e quais os seus papéis na
forma de funcionamento do circuito ou que papéis assumem no algoritmo [1].
Dentro desse método de projeto RTL, este fluxo de projeto intenciona seguir
uma sequência de passos comumente utilizados em tal técnica: especificação,
comportamento, detalhamento do projeto (estrutura e interfaces interna),
detalhamento dos blocos e determinação de um algoritmo (neste caso FSMD).

A. Especificação

As interfaces de entrada e saída utilizadas são: inc, dec, reset, clk e s

(saída), de acordo com a figura 7.

Fig. 7 Especificação das interfaces de entrada e saída do controlador PWM. A descrição

sintetizada das funções de todas as interfaces é informada no item III.

Para descrever o comportamento do dispositivo, utilizou-se o seguinte

algoritmo (figura 8).
Fig. 8 Descrição comportamental do regulador de luminosidade PWM: algoritmo.

B. Detalhamento do projeto
Aqui se pretende executar um detalhamento da estrutura interna do
projeto. Para isso devem ser criadas as estruturas do bloco operacional
e de controle bem como as conexões entre as interfaces utilizadas.

A parte operativa, de acordo com o próprio nome, é representada no

bloco operacional (figura 9).
Fig. 9 Bloco operacional.

Para o bloco de controle se indica as conexões de entrada e saída (figura 10).

Fig. 10 Bloco de controle, juntamente com o bloco dos botões síncronos e diagrama FSMD
(anexo A).

As conexões entre os blocos de controle e operacional representam a

estrutura interna (figura 11):

Fig. 11 Estrutura interna: conexões entre bloco de controle e operacional.

 C. Formalizando a parte comportamental: diagrama de estados finitos
Após se descrever a especificação, o comportamento (algoritmo) assim
como os blocos operacional e de controle, o próximo passo é executar o
diagrama de estados finitos ou FSMD (Finite state machine datapath) 2, figura
12.

X0 reset
0

reset’ clk

X1
j<b’ 0
inc
dec clk

clk
clk X5
X2 a>100 0
0 clk clk
a<0’
a<0 a>100’
clk clk
clk X6
clk
0
X3 X7
X9 X4
clk clk 0
1
0 0 clk
j<b dec’ and inc’
clk
X8 i<a
1

clk i<a’

Fig. 12 Diagrama de estados da figura 8, segue a tabela de transição de estado. O símbolo

“ ‘ “, após as notações indica negação.

2
O símbolo “ ‘ “, após as notações indica negação.
 Estado atual Próximo estado Ação
reset’, x1 i=0; j=0; a=a; b=b; s=0;
x0
reset, x0 i=0; j=0; a=0; b=100; s=0;
inc, x5 i=0; j=0; a=a+10; b=100-a; s=0;
x1 dec’ and inc’, x7 i=i+1; j=0; a=a; b=1; s=0;
dec, x2 i=i; j=j; a=a-10; b=100-a; s=0
a<o’, x4 i=i; j=j+1; a=a; b=b; s=0
x2
a<o, x3 i=i; j=j; a=a; b=b; s=0
x3 x4 i=i; j=j+1; a=a; b=b; s=0
x4 j<b, x1 i=0; j=0; a=a; b=b; s=0;
a>100, x6 i=0; j=0; a=100; b=0; s=0;
x5
a>100’, x7 i=i+1; j=0; a=a; b=1; s=0;
x6 x7 i=i+1; j=0; a=a; b=1; s=0;
i<a, x8 i=i; j=0; a=a; b=b; s=1;
x7
i<a’, x4 i=i; j=j+1; a=a; b=b; s=0
x8 x7 i=i+1; j=0; a=a; b=1; s=0;
x9 x4 i=i; j=j+1; a=a; b=b; s=0
Tabela 1 Tabela de transição de estados.

V. RESULTADOS OBTIDOS
A simulação apresentou o comportamento esperado no que se refere aos
incrementos e decrementos dos valores dos registradores “a”, “b”, “i”, e “j”. A
largura do pulso de alta também obedeceu aos incrementos e decrementos
perfeitamente.
Na definição da largura do pulso de baixa, os registradores armazenaram
corretamente os valores, porém ao entrar no estado x4, ocorreu um “loop”
infinito com o estado x9. Dessa forma, não ocorreu a transição para o estado
x1 e, consequentemente, o nível alto na saída não se repetiu. Portanto, as
transições de estados, referente aos pulsos em nível alto, ocorreram
corretamente.
VI. CONSIDERAÇÕES FINAIS
Esta atividade se mostrou extremamente válida, especialmente no que
se refere ao desenvolvimento de um projeto com transferência entre
registradores (RTL).

VII. REFERÊNCIAS BIBLIOGRÁFICAS

[1] VAHID,Frank. Sistemas Digitais Projeto Otimização e HDLS.1 ed. São Paulo: Artmed, 2008. 560p.
 Anexo A

--Sistemas Digitais
--Código vhdl para controle de luminosidade de led por controle pwm

library ieee;
use ieee.std_logic_1164.all;
--use ieee.numeric_std.all;
use ieee.std_logic_arith.all;

entity codigo2 is

port
(
clk : in std_logic;
reset : in std_logic;
inc : in std_logic;
dec : in std_logic;
s : out std_logic
);

end entity;

architecture rtl of codigo2 is

type algo_type is (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9);
type botao_inc_type is (ea,ac,el);
type botao_dec_type is (ae,ca,le);

-- Register to hold the current state

signal estado_para_algo: algo_type;
signal estado_botao_inc: botao_inc_type;
signal estado_botao_dec: botao_dec_type;

signal s_inc: std_logic; --nó interno para botao inc

signal s_dec: std_logic; --nó interno para botao dec
signal a : unsigned(6 downto 0);
signal b : unsigned(6 downto 0);
signal i : unsigned(6 downto 0);
signal j : unsigned(6 downto 0);
-- signal reg_s:std_logic;

begin

process (clk)--processo para botao inc

begin

if clk'event and clk='1' then

case(estado_botao_inc) is
when ea=>
if inc='0' then

estado_botao_inc<=ac;
 end if;
when ac=>

estado_botao_inc<=el;
when el=>
if inc='1' then

estado_botao_inc<=ea;
end if;
end case;
end if;

end process;

process(estado_botao_inc)
begin

if estado_botao_inc=ac then
s_inc<='1';
else s_inc<='0';
end if;

end process;
---------------------------------------------------------------------------

process (clk)--processo para botao dec

begin

if clk'event and clk='1' then

case(estado_botao_dec) is
when ae=>
if dec='0' then

estado_botao_dec<=ca;
end if;
when ca=>

estado_botao_dec<=le;
when le=>
if dec='1' then

estado_botao_dec<=ae;
end if;
end case;
end if;

end process;

process(estado_botao_dec)
begin

if estado_botao_dec=ca then
s_dec<='1';
else s_dec<='0';
end if;
 end process;
-----------------------------------------------------------------------------------

process (clk) --algorítmo: mostrando como ocorre a transição de estados

begin

if reset = '1' then

estado_para_algo <= x0;

elsif (rising_edge(clk)) then

case(estado_para_algo) is
when x0 =>
estado_para_algo <= x1;
when x1=>
if s_inc = '1' then
estado_para_algo <= x5;
elsif s_dec='1' then
estado_para_algo <= x2;
elsif (s_dec='0'and s_inc='0') then
estado_para_algo <= x7;
else
estado_para_algo <= x1;
end if;
when x2=>
if (a<0) then --(a<0) (b>0)
estado_para_algo <= x3;
else
estado_para_algo <= x4;
end if;
when x3=>
estado_para_algo <= x4;
when x4=>
if (j<b) then
estado_para_algo <= x9;
else
estado_para_algo <= x1;
end if;
if s_dec='1' then estado_para_algo <= x2; end if;
when x5=>
if not (a(6) = '1' and a(5) = '1' and a(4) = '0' and
a(3) = '1') then --CONV_UNSIGNED(100,7)
estado_para_algo <= x7;
else
estado_para_algo <= x6;
end if;
when x6=>
estado_para_algo<= x7;
when x7=>
if i >= a then
estado_para_algo <= x4;
else
estado_para_algo <= x8;
end if;
if s_inc='1' then estado_para_algo <= x5; end if;
 when x8=>
estado_para_algo <= x7;

when x9=>
estado_para_algo <= x4;

end case;

end if;
end process;

--processo para i:
process(clk)
begin
if clk'event and clk='1' then
if estado_para_algo = x0 or
estado_para_algo = x1 or
estado_para_algo = x2 or
estado_para_algo = x3 or
estado_para_algo = x5 or
estado_para_algo = x6 then
i<=CONV_UNSIGNED(0,7);
elsif estado_para_algo=x7 then
i<=i+CONV_UNSIGNED(1,7);
end if;
end if;
end process;

--processo para j:
process(clk)
begin
if clk'event and clk='1' then
if estado_para_algo=x0 or
estado_para_algo=x1 or
estado_para_algo=x2 or
estado_para_algo=x3 or
estado_para_algo=x5 or
estado_para_algo=x6 then
j<=CONV_UNSIGNED(0,7);
elsif estado_para_algo=x4 then
j<=j+CONV_UNSIGNED(1,7);
end if;
end if;
end process;

--processo para a:
process(clk)
begin
if clk'event and clk='1' then
if estado_para_algo= x0 or
estado_para_algo= x3 then
a<=CONV_UNSIGNED(0,7);
 elsif estado_para_algo=x2 then
a<=a-CONV_UNSIGNED(10,7);
elsif estado_para_algo=x5 then
a<=a+CONV_UNSIGNED(10,7);
elsif estado_para_algo=x6 then
a<=CONV_UNSIGNED(100,7);
end if;
end if;
end process;

--processo para b:
process(clk)
begin
if clk'event and clk='1' then
if estado_para_algo = x0 then
b<=CONV_UNSIGNED(0,7); --
alterado para 100, era 0
elsif estado_para_algo=x2 then
b<=CONV_UNSIGNED(100,7)-a; --
b<=CONV_UNSIGNED(100,7)-a;b<=b+CONV_UNSIGNED(10,7);
elsif estado_para_algo=x3 then
b<=CONV_UNSIGNED(100,7);

end if;
end if;
end process;

--processo para saida s:

process (estado_para_algo)
begin
case (estado_para_algo) is
when x0=>
s<='0';
when x1=>
s<='0';
when x2=>
s<='0';
when x3=>
s<='0';
when x4=>
s<='0';
when x5=>
s<='0';
when x6=>
s<='0';
when x7=>
s<='1';
when x8=>
s<='1';
when x9=>
s<='0';

end case;
end process;
end rtl;