Apostila de Lab ELN APL e Micro Control Adores V2_2 - 2 Sem 2009 - 1 Parte

Centro de Educação Profissional Irmão Mário Cristóvão Curso Técnico em Mecatrônica

Disciplina de Eletrônica Aplicada e Microcontroladores

Apostila de Laboratório Eletrônica Aplicada e Microcontroladores

Versão 2.3 – 2º semestre 2009 Prof. Marcelo do C.C. Gaiotto.

Aluno: ________________________________________________

Turno: _______________ Turma______

Centro de Educação Profissional Irmão Mário Cristóvão - Curso Técnico em Mecatrônica: Laboratório de Eletrônica Aplicada e Microcontroladores – Prof. Marcelo do C.C. Gaiotto

2

EXPERIÊNCIA 1 – Circuitos de Proteção Entradas não Protegidas Objetivos:

Utilizar os conceitos de Eletricidade Básica, Eletrônica Analógica e Eletrônica Digital na construção e teste de circuito;

Calcular circuitos com resistores, diodos, transistores e acopladores óptico; Tempo de Execução: ____ Aulas Início: ____/___/_____ - Término: ____/___/_____ Desenvolvimento Equipamentos e materiais necessários:

1 – Protoboard; 1 – Multímetro; 1 – Conjunto de chaves digitais; 1 – Fonte de alimentação; 1 – Chave tipo botão micro táctil; 1 – Relé 12V/10A 4 – Led; 4 – Diodo retificador 1N4007; 4 – Diodo de sinal 1N4148; 2 – Diodo Zener 4V7/500mW 2 – Transistor BC548 ou BC337 1 – Acoplador Óptico 4N25 Resistores de valores variados; Fios para montagens;


3

Projeto 1 – Entradas não isoladas com Circuito Divisor Resistivo

• Dimensionar o circuito para que na saída Vout apresente uma tensão de 5V, para uma

entrada de 18V;

• Medir as correntes e tensões dos resistores;

• Variar a tensão de entrada Vin: 14V à 24V (em passos de 0,5V) e verificar o comportamento

da tensão de saída;

• Anote o comportamento do circuito

Divisor Resistivo.


4

Projeto 2 – Entradas não isoladas – Proteção com diodo de sinal

• Tensão Vadp de 5V;

• Com uma tensão Vin de 24V, verificar a tensão Vout;

• Com uma tensão Vin de 0V (conectar ao GND), verificar a tensão Vout;

• Variar a tensão Vin de 0 à 24V (passos de 0,5V), verificando a tensão de saída Vout;


Circuito com diodo de sinal.


5

Projeto 3 – Entradas não isoladas – Proteção com diodo zener • Utilizando um Zener de 4V7/500mW ou de 5V1/500mW;

• Calcule o circuito para as condições de funcionamento;

• Com uma tensão Vin de 30V, verificar a tensão Vout;

• Com uma tensão Vin de 0V (conectar ao GND), verificar a tensão Vout;

• Sem conexão com uma fonte de tensão Vin, verificar a tensão Vout;

• Variar a tensão Vin de 0 à 30V (passos de 0,5V), verificando a tensão de saída Vout;


Circuito com entrada protegida por diodo zener.


6

Projeto 4 – Entradas isoladas – Sensor NPN e acoplamento ótico com saída e resistor de pull-up

Pinos do acoplador óptico 4N25

• Simular um sensor NPN utilizando uma chave ou botão;

• Calcular os resistores;


Sensor NPN e acoplamento óptico com saída e resistor de pull up.


7

Projeto 5 – Entradas isoladas – Sensor PNP e acoplamento óptico com saída e resistor de pull-up

• Simular um sensor PNP utilizando uma chave ou botão;



Sensor PNP e acoplamento óptico com saída e resistor de pull up.


8

Projeto 6 – Entradas isoladas – Sensor PNP e acoplamento óptico com saída e resistor de pull-up

• Simular um sensor PNP utilizando uma chave ou botão;



Sensor PNP e acoplador óptico com saída e resistor de pull down.


9

Projeto 7 – Entradas isoladas – Sensor NPN e acoplamento óptico com saída e resistor de pull-up

• Simular um sensor NPN utilizando uma chave ou botão;



Sensor NPN e acoplador óptico com saída e resistor de pull down.


10

Projeto 8 – Saída Digital não isolada – Sem Proteção • Calcular os resistores de polarização;

• Utilize uma tensão Vcc=12V, Vbe=0,7V, um relé de 12V;

• Simular o circuito lógico a partir da comutação de uma tensão de 5V e 0V;

• Anote o comportamento do circuito.

Saída não isolada e sem proteção.


11

Projeto 9 – Saída Digital não isolada – Proteção com Diodo de Sinal

• Calcular os resistores de polarização;

• Utilize uma tensão Vcc=12V, Vbe=0,7V, um relé de 12V;


• Utilizar um diodo 1N4148;


Saída não isolada protegida por diodo de sinal.


12

Projeto 10 – Saídas isoladas – Com acopladores ópticos

Pinos do acoplador óptico 4N25

• Calcular os resistores de polarização;

• Utilize uma tensão Vcc=12V, Vbe=0,7V, um relé de 12V no lugar de L1;


• Medir as tensões indicadas, Vbe, VR2, VCEsat, VCE.


Circuito com opto acoplador com acionamento da carga com nível lógico “0”.


13

Projeto 11 – Saídas isoladas – Com acopladores ópticos • Calcular os resistores de polarização;

• Utilize uma tensão Vcc=12V, Vbe=0,7V, um relé de 12V no lugar de L1;


• Medir as tensões indicadas, Vbe, VR2, VCEsat, VCE.


Circuito com opto acoplador com acionamento da carga com nível lógico “1”.


14

EXPERIÊNCIA 2 – Programação em C Objetivos:

Conhecer os softwares utilizados para efetuar as práticas; Aplicar os conhecimentos de fluxogramas;

Tempo de Execução: 14 Aulas Início: ____/___/_____ - Término: ____/___/_____ Desenvolvimento Equipamentos e materiais necessários:

1 – protoboard; 1 – Placa de montagens de ponte de terminais ou placas de circuito impresso 1 – conjunto de chaves digitais; 1 – fonte de alimentação; 1 – microcontrolador PIC 16F877A; 1 – microcontrolador PIC 12F675; 8 – Led’s; 8 – Resistores de 330Ω; 3 – Resistores de 10KΩ; 3 – relés de 12V/10A; 3 – Led’s emissores de Infravermelho; 3 – fototransistores; 3 – transistores BC548 ou BC337; 3 – Diodos 1N4007; Resistores de valores variados; Fios para montagens; 1 – gravador para microcontrolador PIC – (ICD2BR do laboratório).

Observações Gerais para os Projetos Quando solicitado, o relatório deve conter:

• Capa • Diagrama em blocos. • Esquemático • Fluxograma. • Código fonte comentado linha a linha. • Projeto completo gerado no MPLAB com as simulações

Exercício 1 FioDigital.c – primeiros contatos com o microcontrolador

Informações necessárias: Neste exercício que é o primeiro contato com o microcontrolador, serão realizadas apenas

instruções (funções) de leitura e escrita, ou seja, as informações presentes em um dos ports (portB) serão transferidas para outro (portD).

Esta transferência se dará maneira paralela, sendo assim, todos os bits serão transferidos ao mesmo tempo de um port para outro, de maneira transparente, sou seja, bit0 (RB0) de um port no bit0 do outro (RD0), e assim por diante.

A Figura 1 apresenta um esquema elétrico para este exercício.


15

Figura 1. Circuito elétrico para o projeto do FIO DIGITAL.

// ****** Código fonte para o exercício do FioDigital.C ******** #include <16f877A.h> #use delay(clock = 4000000) #fuses HS,NOWDT,PUT,NOBROWNOUT,NOPROTECT, NOLVP void main() int dados; dados = 0; output_D(0); while(true) dados = input_B(); output_D(dados);


16

Exercício 2 OnOff.c Controle de operações

Informações necessárias: Neste exercício será abordado o controle de operações, onde o programa fica travado

aguardando que um botão seja acionado para que um evento ou acionamento seja realizado, ficando novamente travado esperando agora que outro botão seja acionado, disparando uma nova tarefa.

– Lembre que os sinais PB0 e PB1 estão em “1” e quando pressionados vão a “0” A Figura 2 apresenta um esquema elétrico para este exercício.

Figura 2. Circuito elétrico para o projeto do ON OFF.

// ****** Código fonte para o exercício do OnOff.C ******** #include <12F675.h> #use delay(clock=4000000) #fuses HS,NOWDT,PUT,NOBROWNOUT,NOPROTECT, NOLVP void main() while(true) output_D(0); while(input(pin_b0)); while(!input(pin_b0)); output_D(255); while(input(pin_b1)); // while // main


17

Exercício 3A – BinOctal.c Decodificador Binário Octal

Informações necessárias: Neste exercício será abordada a decodificação de entradas para acionamento de saídas

levando em consideração operações com mascara para leitura de um número de bits determinado. Após os testes, implementar o mesmo Decodificador Binário de 3 bits para octal utilizando apenas estruturas de comando do tipo IF/ELSE . A Figura 3.a apresenta o esquema elétrico deste exercício.

// ****** Código fonte para o exercício do BinOctal.C ******** #include <16F877A.h> #use delay(clock=4000000) #fuses HS,NOWDT,PUT,NOBROWNOUT,NOPROTECT, NOLVP void main() int Entrada; PORT_B_PULLUPS(true); output_D(0); while(1) Entrada = input_B() ;// switch(Entrada) case 0: output_D(…); break; case 1: output_D(…); break; case 2: output_D(…); break; case 3: output_D(…); break; case 4: output_D(…); break; case 5: output_D(…); break; case 6: output_D(…); break; case 7: output_D(…); break; // while // void main


18

Figura 3.a. Circuito elétrico para o projeto do BIN OCTAL.

Exercício 3B – BinHexa.c Decodificador Binário Hexadecimal para Display de 7

segmentos

Informações necessárias: Neste exercício deverá ser desenvolvido um decodificador de binário para display de 7

segmentos que represente os símbolos HEXADECIMAIS. A Figura 3.b apresenta um esquema elétrico para este exercício.

Figura 3.b. Circuito elétrico para o projeto do Decodificador Binário Hexadecimal para 7 segmentos.


19

Exercício 4 PiscaPisca.c Função para realizar um “gasto de tempo” e pisca-pisca

Informações necessárias: Neste exercício será abordada a criação e utilização de funções que permitem que o

programa fique mais eficiente, modular e o código pode ser reaproveitado em diversas outras aplicações.

A primeira função – void MeuDelay( long tempo) – é responsável em gerar um gasto de tempo, e pode ser ajustada simplesmente pela passagem de um parâmetro (tempo), que possui uma faixa de 0 até 65536ms aproximadamente.

Já a segunda função neste primeiro teste – void PiscaPisca(int piscadas); – será responsável em gerar as piscadas do led de saída, a uma quantidade que pode ser ajustada através da passagem de parâmetro (piscadas), uma faixa de 0 até 65536ms aproximadamente.

A Figura 3 apresenta o esquema elétrico deste exercício. – Lembre que S1 está em pull down e S2 pull up

A Figura 4 apresenta um esquema elétrico para este exercício.

Figura 4. Circuito elétrico para o projeto do PISCA-PISCA.

// ****** Código fonte para o exercício do PiscaPisca1.C ********

#include <12F675.h> #use delay(clock=4000000)

#fuses HS,NOWDT,PUT,NOBROWNOUT,NOPROTECT, NOLVP void MeuDelay(long tempo); void PiscaPisca(int piscadas); void main() while(true)

output_D(0); if(!input(pin_b0));

PiscaPisca(1); if(!input(pin_b1));

PiscaPisca(2);


20

if(!input(pin_b2)); PiscaPisca(3); // while void MeuDelay( long tempo) while(tempo >0) delay_ms(1); tempo--; void PiscaPisca(int piscadas) while(piscadas >0) output_D(0); MeuDelay(…..); output_D(255); MeuDelay(…..); Piscadas--;

// ****** Código fonte para o exercício do PiscaPisca2.C ********

#include <12F675.h> #use delay(clock=4000000)

#fuses HS,NOWDT,PUT,NOBROWNOUT,NOPROTECT, NOLVP void MeuDelay(long tempo); void PiscaPisca(int piscadas, long Delay); void main() while(true)

output_D(0); if(!input(pin_b0));

PiscaPisca(1, 300); if(!input(pin_b1));


21

PiscaPisca(2,600); if(!input(pin_b2));

PiscaPisca(3,900); // while void MeuDelay( long tempo) while(tempo >0) delay_ms(1); tempo--; void PiscaPisca(int piscadas, long Delay) while(piscadas >0) output_D(0); MeuDelay(Delay); output_D(255); MeuDelay(Delay); Piscadas--;

Exercício 5 Sequencial.c Seqüencial com 4 funções

– Os leds devem iniciar apagados;

– Conecte agora os Botões da HEX SWITCH ao PORTA e os LEDS ao PORTB;

– Criar 4 funções:

1. Função 1: seqüencial de deslocamento: Ao apertar o botão PB0, acender

seqüencialmente de maneira crescente os leds mantendo os anteriores acesos, com

um tempo de delay de 200ms entre os acionamentos;

2. Função 2: seqüencial em anel: Ao apertar o botão PB1, fazer um led aceso se

deslocar de uma saída para outra fazendo dois ciclos completos;

3. Função 3: seqüencial cruzador: Ao apertar o botão PB2, acionar o led menos

significativo e o mais significativo, contar um tempo, desligar e acionar o próximo led,

fazendo com que o led menos significativo caminhe em sentido crescente e o led

mais significativo em sentido decrescente.


22

4. Função 4: seqüencial PingPong: Ao apertar o botão PB3, acionar o led menos

significativo contar um tempo e desligar, acionar o led mais significativo, contar um

tempo e desligar, acionar o próximo led menos significativo contar um tempo e

desligar, e assim por diante seguindo este raciocínio.

– Lembre que os sinais PB0 e PB1 estão em “1” e quando pressionados vão a “0”

Exercício 6 BoEv.c Modelagem da Bomba e Eletroválvula com controle de erro, utilizando

o PIC12F675

A B C EV BO0 0 0 1 00 0 1 1 00 1 0 1 10 1 1 1 01 0 0 X X1 0 1 X 01 1 0 0 11 1 1 0 0

Figura 5. Esboço do sistema de Bombeamento.

Sensores : com água = 1

Sem água = 0

Atuadores : Ligado = 1 desligado = 0

B O AB00 01 11 10

0 0 1 1 X1 0 0 0 0

C

BO = BC/

E V AB00 01 11 10

0 1 1 0 X1 1 1 0 X

C

EV = A/

Figura 6. Esquema do sensor de barreira óptica.


23

Pede-se: – Para cada combinação dos Sensores deve-se ter exatamente o comportamento do

controle de bombeamento apresentado na tabela verdade;

– Confirmar a leitura dos sensores A, B e C para proteger os atuadores das operações de

liga/desliga causado pela oscilação da água nos sensores (ler o sensor, contar um

tempo e realizar novamente a mesma leitura, só então acionar);

– Implementar uma saída para Sinalização de Problemas que deverá ficar piscando nos casos irrelevantes. Na tabela verdade, não estão apresentados a coluna com a saída

para este caso, nem tão pouco o mapa de Karnaugh;

Regras de defesa do projeto:

1. A montagem deve ser exemplar, ou seja, com qualidade e perfeição (fios

curtos e bem distribuídos);

2. Implementar os sensores e as etapas de relés em placa de circuito impresso

ou em ponte de terminais;

3. Acionar três relés, um para a Bomba, um para a Eletroválvula e outro para a

Lâmpada de Sinalização de Problemas;

4. Cada Relé deve acionar uma carga (lâmpadas e motor) em rede alternada

127V/60Hz;

5. Realizar os teste finais para obter o visto no hardware montado.


24

EXPERIÊNCIA 2 – INTERRUPÇÃO EXTERNA Objetivos:

Conhecer o procedimento de configuração e utilização da interrupção externa em dois modelos de microcontroladores – PIC16F877A e PIC12F675

Tempo de Execução: 2 aulas Desenvolvimento

Informações necessárias: Interrupção é um procedimento que permite a mudança do fluxo normal de execução do

programa principal que está rodando no microcontrolador, direcionado a execução para outra área de memória, onde um código de tratamento será então executado. Assim que este código de tratamento for terminado o microcontrolador retorna a execução ao código principal que estava rodando do ponto onde foi interrompido, seguindo sua execução normalmente.

O microcontrolador PIC16F877A, possui uma interrupção externa e esta direcionada ao pino RB0, no caso do PIC12F675 esta interrupção está direcionada ao pino GP2. Para habilitar esta interrupção utilizando linguagem C do compilador da CCS tem-se algumas funções que devem ser utilizadas:

port_b_pullups(true); // ativa os resistores internos de pullup // no port B

enable_interrupts(int_ext); // habilita as interrupção externa // RB0 para o PIC16F877 // A2 para o 12F675 ext_int_edge(H_TO_L); // configura a borda de sensibilidade // da interrupção: neste caso de alto para // baixo enable_interrupts(global); // habilita as chave geral de interrupções

Figura - Flags e chaves de interrupção – Livro Conectando o PIC 16F877A Recursos

Avançados


25

Após realizar os testes com o microcontrolador PIC16F877A, alterar a programação para utilizar agora o PIC 12F675.

O exercício que será realizado deverá:

1. Ao acionar um botão PB1 deve ligar o led conectado ao RD1; 2. Ao acionar um botão PB2 deve desligar o led conectado ao RD1; 3. Ao acionar o botão PB0 entra na interrupção fazendo piscar um led conectado ao

RD0. //********************************************************************************************************** // Programa exemplo para INTERRUPÇÃO EXTERNA //********************************************************************************************************** #include <16F877A.h>// configurar para o controlador a ser usado e o seu caminho #use delay(clock=4000000) // informa qual e a freq do cristal que esta sendo utilizado #fuses HS, NOWDT,PUT,NOBROWNOUT,NOLVP //********************************************************************************************************** // Área de definições de pinos de Saída //********************************************************************************************************** #define LED0 pin_d0 #define LED1 pin_d1 //**********************************************************************************************************

// Área de definições de pinos de Entrada //********************************************************************************************************** #define PB1 pin_b1 #define PB2 pin_b2 //********************************************************************************************************** // // Interrupção externa por borda de descida em rb0 // //********************************************************************************************************** #int_ext // indica interrupcao por borda de descida de rb0 void Trata_RB0(void) output_high(LED0); //liga o led em RD0 delay_ms(1000); output_low(LED0); //liga o led em RD0 delay_ms(1000); output_high(LED0); //liga o led em RD0 delay_ms(1000); output_low(LED0); //liga o led em RD0 delay_ms(1000); // fim do tratamento da interrupção //********************************************************************************************************** // // Programa principal // //********************************************************************************************************** void main() port_b_pullups(true); // hativa os resistores internos de pullup

// no port B


26

enable_interrupts(int_ext); // habilita as interrupção externa // RB0 ext_int_edge(H_TO_L); // configura a borda de sensibilidade // da interrupção: neste caso de alto // para baixo enable_interrupts(global); // habilita as chave geral de interrupções while (true) if(input(PB1)) output_high(LED1); if(input(PB2)) output_low(LED1); // while // void main A Figura 7 apresenta um esquema elétrico para este exercício.

Figura 7.a. Circuito elétrico do exercício de interrupção Externa com o PIC16F877A.


27

Figura 7.b. Circuito elétrico do exercício de interrupção Externa com o PIC12F675.


28

Projeto 1 – Cancela Eletrônica Objetivos:

Aplicar os conhecimentos de programação em C, Microcontroladores, Automação Básica e CLP;

Utilização de outros microcontroladores da família PIC da Microchip; Melhorar a interpretação de projetos e especificações; Aplicar o conhecimento de controle de motores; Implementação de dispositivos de hardware para leitura de sensores e acionamento de

cargas Data de Apresentação: ___/___/_____ Desenvolvimento Informações necessárias:

A empresa PIKARETA Sistemas Eletrônicos SA., solicitou a sua equipe o projeto de um

Portão Eletrônico. O dispositivo eletrônico deve utilizar o microcontrolador PIC 12F675 e deverá realizar as seguintes funções, seguindo as especificações do solicitante:

1. Deverão existir dois fins de curso: um para indicar que a cancela está aberta e outro para indicar que está fechada. Estes comutam uma tensão de 24V (saída do tipo PNP), sendo assim necessitam ser acopladas opticamente pois cada uma das entradas do microcontrolador opera em 5V;

2. A abertura da cancela deverá ser realizada por intermédio de um botão chamado de ABRE; 3. Um sensor óptico de barreia deverá interromper imediatamente o fechamento da cancela para

que não ocorra a colisão da haste com os veículos, abrindo-a novamente e realizando o procedimento de fechamento novamente;

4. O fechamento da cancela deverá ocorrer de forma automática 5 segundos após o sensor de

barreira informar que já houve a passagem do veículo; 5. Dois Relés em configuração de ponte H deverão ser acionados para realizar o controle de

funcionamento de um motor DC; 6. Quando o sistema for ligado, o programa deverá verificar:

• Se a cancela estiver aberta ou semi-aberta, abrir contar o tempo para fechar e realizar o procedimento para fechar;

• Se estiver fechada inicia funcionamento normal através do botão de ABRE;

Esboço das condições iniciais possíveis da Cancela


29

*obs:Convencionar estados das variáveis antes de iniciar o projeto, ligado 1, desligado 0. Facilita bastante!!!!!

Fazer relatório, um por equipe (dois alunos), em arquivo postado até a data limite estabelecida e com as seguintes características: 1 – capa 2 – Diagrama em blocos. 3 – Esquemático – no EAGLE. 4 – fluxograma. 5 – código fonte comentado linha a linha. 6 – Projeto completo gerado no MPLAB com as simulações, postado no Eureka até data limite estabelecida.

ATENÇÃO

*** CÓPIAS DE QUALQUER UM DOS ITENS DOS PROJETOS RECEBERÃO NOTA ZERO!****


30

EXPERIÊNCIA 3 – Conversor AD – 8 Bits Objetivos:

Conhecer o procedimento de configuração e utilização do conversor AD em configuração de 8 bits

Conhecer amplificador operacional em configuração não inversora Aplicar o conhecimento do conversor AD em um termômetro digital configurável


Informações necessárias: Informações Analógicas são de grande importância em sistemas de automação, pois o

mundo é analógico, as grandezas físicas são analógicas e sendo assim, para poder realizar o controle de determinados processos industriais é necessário que valores analógicos sejam lidos pelos sistemas de controle.

Um exemplo bastante simples seria o de um termostato eletrônico que controla a temperatura de um ambiente ou de um líquido. Para controlar a temperatura de aquecimento o sistema deve ter um sensor que realizara a conversão da grandeza física temperatura em outra grandeza, a elétrica, que por sua vez será convertida em uma seqüência binária.

Existem diversos modelos de circuitos conversores AD, o microcontrolador PIC16F877A, possui um conversor AD interno de aproximações sucessivas de 8 ou 10 bits configurável, e 8 canais de entrada analógicos multiplexados.

Como o PIC16F877A possui apenas um conversor AD, isto significa que apenas um canal analógico pode ser convertido (lido) por vez, então a multiplexação dos canais de entrada permite que esta tarefa de seleção seja realizada. Por uma definição do fabricante MICROCHIP, o microcontrolador PIC não pode configurar a gosto do usuário uma seqüência personalizada de canais que serão definidos como entradas analógicas, deve-se utilizar uma das definições que o fabricante expõe no datasheet do componente. A tabela 1 apresenta as combinações possíveis de utilização das entradas:

Para habilitar/configurar este módulo utilizando linguagem C do compilador da CCS tem-se algumas informações que devem ser observadas e algumas funções que devem ser utilizadas:


31

Tabela 1:Combinação das entradas para utilização do módulo AD.

Obs1: tabela do livro Microcontroladores PIC – Programação em C – Fábio Pereira

pág. 209. Editora Érica Obs2: A – analógico D – Digital

A função de configuração para os canais é: setup_adc_ports(opções); Exemplo: setup_adc_ports (RA0_ANALOG);// somente o canal 0 é analógico Outro ponto importante na configuração do módulo analógico é a freqüência do clock que

será entregue para o conversor AD. As opções disponíveis para esta configuração são: ADC_OFF ADC_CLOCK_DIV_2 ADC_CLOCK_DIV_4 ADC_CLOCK_DIV_8 ADC_CLOCK_DIV_16 ADC_CLOCK_DIV_32 ADC_CLOCK_DIV_64 ADC_CLOCK_DIV_INTERNAL A função de configuração para a freqüência é: setup_adc(opções); Exemplo: setup_adc(ADC_CLOCK_DIV_INTERNAL); A seleção do canal que será lido é realizada através da função: set_adc_channel(canal); Exemplo: set_adc_channel(0); // selecionado o canal 0 para leitura

• observação importante: quando houver a seleção de um canal para entrada analógica, deve-se aguardar em torno de 10 a 15us antes de se realizar a leitura efetiva do canal. Isso é necessário para que o capacitor interno seja carregado com a tensão que será amostrada (lida).

Exemplo: set_adc_channel(0); // selecionado o canal 0 para leitura delay_us(15); // tempo para carregamento do capacitor interno de amostragem A conversão efetiva do valor de tensão analógica presente na entrada selecionada será

realizada através da função: read_adc( );


32

Esta função retornará o valor convertido que pode ser apresentado em dois tamanhos(tipos): 1. 8 bits – valores de 0 a 255 2. 10 bits – valores de 0 a 1023

Sendo assim, a variável que receberá o valor convertido deve ser compatível com o tamanho de bits que será devolvido pela função de leitura:

Exemplo: para uma variável de 8 bits – int valor; valor = read_adc( ); // variável recebe o valor convertido em 8 bits Exemplo: para uma variável de 10 bits – long valor; valor = read_adc( ); // variável recebe o valor convertido em 10 bits O exercício que será realizado deverá:

1. Ao acionar o botão PB0 deve entrar na interrupção e realizar a leitura do canal 0 analógico que estará recebendo o valor de tensão do potenciômetro – medir com o multímetro e realizar o calculo para confirmar o valor de conversão que será apresentado no port D;

//********************************************************************************************************** // Programa exemplo para CONVERSOR AD //********************************************************************************************************** #include <16F877A.h>// configurar para o controlador a ser usado e o seu caminho #device ADC=8 // numero de bits do conversor AD - 8 bits ou 10 bits #use delay(clock=4000000) // informa qual e a freq do cristal que esta sendo utilizado #fuses HS, NOWDT,PUT,NOBROWNOUT,NOLVP //********************************************************************************************************** // Interrupção externa por borda de descida em rb0 //********************************************************************************************************** #int_ext // indica interrupcao por borda de descida de rb0 void Trata_RB0(void) int valor; set_adc_channel(0); // indica qual canal ad sera lido delay_us(15); // aguarda o circuito interno do pic se preparar para // realizar a conversao valor = read_adc(); // realiza a conversao do sinal analogico // presente no canal selecionado output_D(valor); // apresenta o valor convertido no port D delay_ms(10); //********************************************************************************************************** // Programa principal //********************************************************************************************************** void main() setup_adc_ports(RA0_ANALOG); // PORT A0 Analogica setup_adc(ADC_CLOCK_INTERNAL); // seleciona o clock interno para o // conversor AD port_b_pullups(true); // ativa os resistores internos de pullup

// no port B enable_interrupts(int_ext); // habilita as interrupção externa // RB0


33

ext_int_edge(H_TO_L); // configura a borda de sensibilidade // da interrupção: neste caso de alto para // baixo enable_interrupts(global); // habilita as chave geral de // interrupções while (true) //while //void main A Figura 8 apresenta um esquema elétrico para este exercício.

Figura 8. Circuito elétrico para o exercício com o AD.

O projeto a seguir será o de um termostato que deverá apresentar três indicadores de

temperatura: ALTA, BAIXA e NORMAL, utilizando um sensor de temperatura LM35, que devolve um tensão de 10mV/°. Informações:

1. A faixa de temperatura deverá ser de 0 a 50°C; 2. Os Ajustes de mínimo e máximo deverão ter ação quando o botão PB0 for

pressionado, ou seja, os ajustes serão realizados dentro do tratamento da interrupção externa;

3. Quando entrar na interrupção externa, deve apagar os 3 leds de limites; 4. Dentro da interrupção, para ajustar o valor mínimo deve-se proceder da seguinte

maneira: pressionar PB2 uma vez e aguardar o LED de indicação de Temperatura Baixa acender, ajustar o valor mínimo através do potenciômetro de mínimo, podendo


34

visualizar o ajuste nos leds do port D. Com a temperatura ajustada, acionar o botão PB2 novamente e aguardar o Led de indicação de Temperatura Baixa Apagar; Em seguida deve-se ajustar o valor de Temperatura Máximo, realizando o mesmo procedimento porém utilizando agora o botão PB1 e o potenciômetro de ajuste de Mínimo. Pressionando uma vez o botão PB1 o LED de Temperatura Máxima acender depois de um pequeno tempo, e só então é possível realizar o ajuste do valor para o Máximo, que também pode ser visualizado nos Leds do portD. Com a temperatura ajustada, acionar o botão PB1 novamente e aguardar o Led de indicação de Temperatura Alta Apagar;

5. Quando sair da interrupção externa, os leds de Temperatura Baixa e de Temperatura

devem se apagar, piscando duas vezes o led Indicador de temperatura Normal; 6. Se a temperatura medida for maior que a temperatura ajustada para o valor máximo,

deve acender unicamente o indicador de Temperatura Alta e ficar assim enquanto a temperatura for acima do ajustado.

7. Se a temperatura medida for menor que a temperatura ajustada para o valor mínimo,

deve acender unicamente o indicador de Temperatura Baixa e ficar assim enquanto a temperatura for abaixo do ajustado.

8. Se a temperatura medida estiver entre o valor máximo e o valor mínimo, deve

acender unicamente o indicador de Temperatura Normal e ficar assim enquanto a temperatura estiver entre os valores mínimo e máximo.

9. A temperatura medida pelo sensor LM35 será apresentada nos leds do port D

durante a operação normal do sistema. 10. Calcular os resistores do amplificador operacional.

Figura 9. Circuito elétrico para o exercício do termostato com o LM35 e o PIC16F877A.


35

//******************************************************************************************************************* // Programa exemplo para o Termômetro com termostato // usando o CONVERSOR AD em 8 bits //******************************************************************************************************************* #include <16F877A.h>// configurar para o controlador a ser usado e o seu caminho #device ADC=8 // numero de bits do conversor AD - max de 10 bits e min de 8 bits #use delay(clock=4000000) // informa qual e a freqüência do cristal que esta sendo utilizado #fuses HS, NOWDT,PUT,NOBROWNOUT,NOLVP //******************************************************************************************************************* // Área de definições de pinos de Saída //******************************************************************************************************************* #define LED_Alta pin_B7 #define LED_Normal pin_B6 #define LED_Baixa pin_B5 //*******************************************************************************************************************// Área de definições de parâmetros // canais de entrada usados: 0, 1 e 3 //******************************************************************************************************************* #define Sensor_Temperatura 0 #define Ajuste_Alta 1 #define Ajuste_Baixa 3 //******************************************************************************************************************* // Área de definições de pinos de Entrada Digitais //******************************************************************************************************************* #define Bt_Ajuste_Alta pin_b1 #define Bt_Ajuste_Baixa pin_b2 //******************************************************************************************************************* // Área de variáveis globais //******************************************************************************************************************* int Temperatura; int LimiteTempAlta; int LimiteTempBaixa; //******************************************************************************************************************* // Área com a função de tratamento da interrupção externa // Interrupção externa por borda de descida em rb0 //******************************************************************************************************************* #int_ext // esta diretiva indica ao compilador que a próxima função // será chamada quando houver uma interrupção externa em RB0 void Trata_RB0(void) output_low(LED_Alta); output_low(LED_Normal); output_low(LED_Baixa); output_D(0); while(input(Bt_Ajuste_Baixa)); delay_ms(1000); output_high(LED_Baixa); set_adc_channel(Ajuste_Baixa); // Seleciona o potenciômetro de ajuste Míninmo


36

delay_us(20);// aguarda o circuito interno do PIC se preparar para realizar a conversão while(input(Bt_Ajuste_Baixa)) LimiteTempBaixa = read_adc(); // realiza a leitura output_D(LimiteTempBaixa );// apresenta o valor Lido no port D delay_ms(10); output_low(LED_Baixa); delay_ms(500); output_D(0); while(input(Bt_Ajuste_Alta)); delay_ms(1000); output_high(LED_Alta); set_adc_channel(Ajuste_Alta); // Seleciona o Potenciômetro de ajuste de Máximo delay_us(20);// aguarda o circuito interno do PIC se preparar para realizar a conversão while(input(Bt_Ajuste_Alta)) LimiteTempAlta = read_adc();//Le o valor do Potenciômetro de Máximo output_D(LimiteTempAlta );// apresenta o valor Lido no port D delay_ms(10); output_low(LED_Alta); output_D(0); delay_ms(500); output_high(LED_Normal); delay_ms(500); output_low(LED_Normal); delay_ms(500); output_high(LED_Normal); delay_ms(500); output_low(LED_Normal); delay_ms(500); //******************************************************************************************************************* // Programa principal //******************************************************************************************************************* void main() Temperatura = 0; LimiteTempAlta = 0; LimiteTempBaixa = 0; setup_adc_ports(RA0_ANALOG); // PORT A0 Analógica setup_adc(ADC_CLOCK_INTERNAL); // seleciona o clock interno para o conversor AD port_b_pullups(true); // ativa os resistores internos de pullup // no port B enable_interrupts(int_ext); // habilita as interrupção externa // RB0 ext_int_edge(H_TO_L); // configura a borda de sensibilidade // da interrupção: neste caso de alto para // baixo


37

enable_interrupts(global); // habilita as chave geral de // interrupções while (true) // seleciona a entrada analógica para o circuito do sensor de temperatura set_adc_channel(Sensor_Temperatura); // aguarda o circuito interno do PIC se preparar para realizar a conversão delay_us(20); Temperatura = read_adc(); // realiza a leitura delay_ms(20); output_D(Temperatura); delay_ms(20); if(Temperatura<LimiteTempBaixa) output_high(LED_Baixa); output_low(LED_Alta); output_low(LED_Normal); delay_ms(20); else if((Temperatura>=LimiteTempBaixa)&(Temperatura<=LimiteTempAlta)) output_high(LED_Normal); output_low(LED_Alta); output_low(LED_Baixa); delay_ms(20); else if(Temperatura>LimiteTempAlta) output_high(LED_Alta); output_low(LED_Baixa); output_low(LED_Normal); delay_ms(20); //while(true)


38

EXPERIÊNCIA 4 – Comunicação Serial Assíncrona Objetivos:

Conhecer o procedimento de configuração e utilização do módulo de comunicação Assíncrona.

Estudar o Padrão Elétrico RS232 Aplicar o conhecimento do conversor AD agora em configuração de 10 bits


Informações necessárias: A troca de informações entre dispositivos, equipamentos e sistemas permite que um volume

de dados seja transferido para tratamento, armazenagem ou ainda monitoramento remoto. Alguns exemplos de aplicações são a USB, Ethernet, PS2 (comunicação de teclados e mouses de um microcomputador), entre outros.

A comunicação entre dispositivos pode ser realizada de duas formas, Serial e Paralela. Na comunicação Serial, cada bit é transmitido separadamente um após o outro, podendo ter ainda dois tipos de transmissão: síncrona e assíncrona

• Síncrona: Possui uma via de dados que pode ser bidirecional ou não e outra de sincronismo, clock (tipos: SPI e I2C);

• Assíncrona (sem sincronismo): possui uma duas vias para dados, uma transmite e outra recebe, e o sinal de sincronismo vem embutido nos sinais de dados (RS232, RS422 e RS485).

O microcontrolador PIC16F877A, possui dois módulos internos para comunicação serial, um para comunicação síncrona e outro para comunicação assíncrona. Nesta atividade será abordado p módulo de comunicação assíncrono. Para ativar o módulo de comunicação, deve-se utilizar algumas diretivas e funções do compilador.

A comunicação serial pode ser implementada de duas formas: • Por software: onde um código desenvolvido permite a serialização e controle dos

tempos de envio e recebimento dos bits; • Por hardware: quando uma estrutura de hardware interna do microcontrolador é

responsável pela serialização de 8 bits paralelos para transmissão e recebimento de dados serializados agrupando-os em grupos de 8 bits e disponibilizando-os de maneira paralela.

Esta diretiva permite que sejam utilizadas as funções de comunicação seja para uma interface serial criada no software ou por hardware.

Para habilitar o módulo de USART – UNIVERSAL SYNCHRONOUS ASSYNCHRONOUS RECEIVER TRANSMITTER:

#use rs232(opções) As opções a serem utilizadas são os apresentados na tabela 2:


39

Tabela 2. Opções da diretiva #use rs232(opções).

Obs1: tabela do livro Microcontroladores PIC – Programação em C – Fábio Pereira

pág. 173. Editora Érica Os pinos que implementam a interface serial por hardware são:

• Bit 7 do port C: RC7 – RX, pino de entrada de dados da serial; • Bit 6 do port C: RC6 – TX, pino de saída de dados da serial;

O exemplo a seguir apresenta uma configuração para comunicação serial: // configuração para serial RS232 #use rs232(baud=19200, xmit=pin_c6, rcv=pin_c7, bits=8) Nesta configuração de exemplo, tem-se a seguinte parametrização:

• BAUD – Velocidade de comunicação: 19200 bps, bits por segundo; • XMIT – Pino de transmissão utilizado; • RCV – Pino de recepção utilizado;

Para configurar um software de comunicação serial, por exemplo o Hyper Terminal, do

Windows apresentado na figura 4, deve-se utilizar as informações como sendo: • Bits por segundo – 19200; • Bits de dados: 8; • Paridade: Nenhum • Bits de parada: 1; • Controle de fluxo: Nenhum


40

Figura 4. Tela de configuração das portas de comunicação do Hyper Terminal.

Existem várias funções que podem ser utilizadas em um projeto com comunicação serial,

portanto serão abordadas algumas delas. Para transmitir apenas um byte ou um caractere: putc(dado); Exemplo: considere uma variável declarada anteriormente do tipo: char valor; e inicializada

com: valor = ‘A’; // será transmitido um byte, ou seja, o conteúdo da variável valor, que é o caractere A putc(valor); Para transmitir uma seqüência de bytes (string) podemos utilizar: printf(opções); Esta função possui uma variedade de opções de parametrização. Para a simples transmissão

de uma frase (string), fica: // transmite a frase pela interface serial definida anteriormente printf(“Estou vivo e falante!!”); Para utilizar um dado recebido pela interface serial, pode-se utilizar a seguinte função: getc(); Exemplo: considere uma variável declarada anteriormente do tipo: char valor; // quando for recebido um byte, ele será transferido para a variável valor = getc(); Verifique as páginas 230 à 239 do livro Microcontroladores PIC – Programação em C – Fábio

Pereira da Editora Érica, existem diversas outras funções e parametrizações para cada uma delas. O exemplo que será utilizado para se trabalhar com a interface serial será uma evolução do

projeto anterior. O Ajuste da temperatura máxima e mínima, assim como o envio do valor da temperatura serão acessados pelo microcomputador. O cabo de conexão entre a aplicação e o computador deve ser montado pino a pino, ou seja, pino 2 com pino 2, pino 3 com pino 3, pino 5 com pino 5. Os circuitos apresentados nas figuras 5 e 6 poderão ser utilizados para esta atividade.


41

Figura 5. Circuito elétrico para o exercício termômetro com o LM35, AD de 10 bits e comunicação

serial utilizando o CI MAX232.

Figura 6. Circuito elétrico para o exercício termômetro com o LM35, AD de 10 bits e comunicação

serial utilizando o módulo HEXIT 232.


42

Projeto 2 – Elevador Didático Microcontrolado Objetivos:

Aplicar os conhecimentos de programação em C, Microcontroladores, Automação Básica, CLP;

Utilização do microcontrolador PIC16F877A ou PIC18F452 da Microchip, Inversor de Freqüência, Sensores e Encoders;

Melhorar a interpretação de projetos e especificações; Aplicar o conhecimento de controle de motores AC utilizando inversor de Freqüência; Aplicar os conhecimento de amplificadores operacionais e filtros; Aplicar o conhecimento sobre PWM; Implementar supervisão remota utilizando um microcomputador via porta de comunicação

serial padrão; Utilização de display de cristal líquido.

Tempo de Execução: _____ aulas Data de Apresentação: ___/___/_____ Desenvolvimento Informações necessárias:

A empresa PIKARETA Sistemas Eletrônicos SA., solicitou a sua equipe o projeto de um

Elevador. O dispositivo eletrônico deve utilizar o microcontrolador PIC 16F877A ou PIC18F452 e deverá realizar as seguintes funções, seguindo as especificações do solicitante:

1. Todos os sinais gerados pelos sensores, chaves de fim de curso, botões e encoder’s devem ser isolados opticamente pois são alimentados em tensões diferentes da do microcontrolador;

2. Deverão existir dois fins de curso com contatos NF, um superior e outro inferior para emergência

e parametrização; 3. Deverão existir 8 botões, 1 por andar para solicitar a chamada do elevador, e 4 que representam

os botões internos da cabine(carro) do elevador; 4. Um encoder incremental deverá ser utilizados como elemento de retorno de informações da

posição da cabine do elevador ao sistema de controle e está posicionado na saída do redutor; 5. Deverão existir 4 saídas em coletor aberto para controlar o inversor de freqüência utilizando

acopladores ópticos (4N25); 6. Deverá ser implementado um circuito utilizando filtros e amplificadores operacionais para

condicionar o sinal de saída gerado pelo PWM e transformá-lo em uma variação de tensão contínua de 0 até 10V – Freqüência do PWM em 19,53KHz e com 10 bits de resolução, isolando-a da etapa de controle do condicionador;

7. Rampas de Aceleração e Freio devem ser implementas no firmware do microcontrolador para

realizar um deslocamento suave na partida e chegada de cada andar; 8. Todo o funcionamento do sistema deve ser monitorado através de um display de cristal líquido de

4 linhas e 20 colunas e de uma conexão RS232 com um computador ligado a ele, onde informações de controle e parametrização poderão ser passadas, como por exemplo:

• Velocidade de deslocamento; • Rampa de freio e aceleração;


43

• Tempo de espera para partida; 9. Regras de funcionamento do elevador:

• Ao ligar a energia do sistema, enviar msg por conexão RS232 e no display de LCD que o elevador está inicializando e indo para o primeiro andar, verificar os fins de curso e acionar o elevador em baixa velocidade até o fim de curso inferior;

• Parar ao acionar o fim de curso inferior, zerar a leitura do encoder e movimentar o carro do elevador até o primeiro andar, baseando a posição do andar (numero de pulsos) informada pelo encoder (valor do andar informado pelo professor);

• Enviar por msg por conexão RS232 e no display de LCD que o elevador está pronto para operar, e aguardar comando dos botões de andar ou do carro do elevador;

• A solicitação do deslocamento por intermédio dos botões da cabine tem prioridade na escolha do andar;

• Indicador de andar por display de 7 segmentos catodo comum 10. A equipe deverá ser de até 2 componentes, os quais deverão trabalhar em equipe, dividindo

tarefas e trocando informações para a realização do projeto. No caso de um dos integrantes não cumprir com as tarefas determinadas, este será desqualificado e o grupo deverá se responsabilizar pelo cumprimento da mesma;

Fazer um relatório por equipe de 2 alunos e entregar: Relatório em PDF postado no EUREKA até data limite estabelecida e uma cópia encadernada conforme as características abaixo, juntamente com o projeto no MPLAB e seu código fonte comentado. 1 – Capa; 2 – Diagrama em blocos; 3 – Descrição sucinta dos blocos; 3 – Esquemático – no EAGLE; 4 – Fluxograma do firmware desenvolvido; 5 – Código fonte com comentários das etapas mais importantes; 6 – Projeto completo gerado no MPLAB.


44

Projeto Elevador

Protocolo de recebimento de Relatório – esta parte fica com os alunos

Aluno: ___________________________________________________________________________ Aluno: ___________________________________________________________________________ Turno: _____________ Turma: _____________ Professor: MARCELO DO C.C. GAIOTTO Relatório entregue em: ____/____/______ Visto: ___________ ....................................................................... cortar aqui ...................................................................

Projeto Elevador

Protocolo de Entrega de Relatório – esta parte deve ser anexada ao relatório

Aluno: ___________________________________________________________________________ Aluno: ___________________________________________________________________________ Turno: _____________ Turma: _____________ Relatório recebido em: ____/____/______ Visto: ___________ Professor: MARCELO DO C.C. GAIOTTO


45

AQUI SERÃO INSERIDOS OS NOVOS CAPÍTULOS DESTE SEMESTRE

2° SEMESTRE DE 2009


46

MATERIAL DE APOIO


47

Resumo básico de funções do Compilador C da CCS para PIC Ler um pino do microcontrolador Sintaxe: input(pino) Exemplo: boolean Sensor_A; // declaração prévia da variável que neste caso é de 1 bit Sensor_A = input(pin_b0); // leitura do pino rb0 do microcontrolador obs: as mesmas dicas de se criar apelidos (#define) para os pinos são válidas aqui Exemplo: #define SensorA pin_b0 // definição prévia do pino rb0 como sendo SensorA boolean Sensor_A; // declaração prévia da variável que neste caso é de 1 bit Sensor_A = input(SensorA); // leitura do pino rb0 do microcontrolador Ler um PORT inteiro do microcontrolador Sintaxe: input_X() – X é a identificação do PORT.... A, B, C, lembrando que alguns dos microcontroladores não possuem os PORTS D, E, por isso verifique no datasheet. Exemplo: int Chaves; // declaração prévia da variável que neste caso é de 8 bits Chaves = input_D(); // leitura do PORTD inteiro do microcontrolador Colocar um PINO do microcontrolador em nível Alto - “1” – HIGH Sintaxe: output_high(pino) obs: as mesmas dicas de se criar apelidos (#define) para os pinos são válidas aqui Exemplo: #define Buzzer pin_b7 output_high(Buzzer); // coloca o pino especificado em alto “1” Colocar um PINO do microcontrolador em nível baixo - “0” – LOW Sintaxe: output_low(pino) obs: as mesmas dicas de se criar apelidos (#define) para os pinos são válidas aqui Exemplo: #define Buzzer pin_b7 output_low(Buzzer); // coloca o pino especificado em baixo “0” Escreve um PORT inteiro do microcontrolador Sintaxe: output_X() – X é a identificação do PORT.... A, B, C, lembrando que alguns dos microcontroladores não possuem os PORTS D, E, por isso verifique no datasheet.


48

Exemplo: int Atuadores; // declaração prévia da variável que neste caso é de 8 bits output_D(Atuadores); // Escreve o conteúdo da variável no PORTD // do microcontrolador


49

Circuito da Ponte H com Relés

Teste da ponte H sem motor: A ponte H pode ser testada em qualquer tensão (VCC), desde que não se utilize o motor. Para simular o funcionamento do motor e testar o sentido da corrente elétrica alimente a ponte com uma tensão VCC de 5V ou 12V e conecte o circuito com os dois led’s da figura a seguir no lugar do motor. Acionando somente o relé K1, o led D1 deverá acender o que simularia o motor Ródano em um dos sentidos. Ao acionar somente o relé K2, o led D2 deverá acender, o que representa o giro do motor para o sentido contrário. No caso dos dois relés estarem desligados ou ligados ao mesmo tempo, nenhum led deverá acender. Este procedimento ira fazer o motor ser freado, pois suas bobinas ficarão em curto. OBS: Lembre de dimensionar o resistor R1 para uma corrente de no máximo 15mA para os led’s, independente da tensão.

Circuito de teste da Ponte H com Relés sem motor – somente com Led’s

Conector do sensor – SAÍDA PNP

Obs1: lembre que este tipo de saída fornece só nível lógico “1” – ou seja – VCC


50

Configurando o TIMER 2 para gerar o Período do PWM no PIC 16F877A

O Microcontrolador PIC possui 2 canais de PWM que podem operar com resolução máxima de 1024 pontos, ou seja, o ciclo ativo pode ser configurado com até 10 bits, e possibilitar de 0 à 100% de variação. Conforme a freqüência escolhida para a operação, esta resolução pode ser alterada para menos de 10 bits. Para definir o período do PWM, devemos ajustar o TIMER 2, que é um contador de 8 bits, ou seja, pode realizar uma contagem de 0 até 255. A figura 1 apresenta o diagrama em blocos do TIMER 2.

Figura 1. Diagrama interno do TIMER 2.

Este TIMER possui uma diferença bastante interessante, sua contagem não segue de 0 até o

valor de 255, e sim de 0 até o valor que estiver armazenado no registrador PR2, ou seja, o limite de contagem será exatamente o que estiver armazenado no registrador PR2.

Toda vez que o valor do registrador TMR2 for igual ao valor do PR2, o contador será resetado e o registrador POSTSCALER é incrementado.

O sinal de incremento do TMR2 é entregue pelo PRESCALER. Este registrador/contador nada mais é que um divisor de CLOCK (freqüências) que pode ser configurado como sendo:

• 1:1 – divide o sinal de clock por 1, ou seja, o sinal (Fosc/4) é responsável pelo incremento do TMR2

• 1:4 – divide o sinal de clock por 4, ou seja, são necessários 4 ciclos completos do sinal (Fosc/4) para que ocorra um incremento do TMR2;

• 1:16 – divide o sinal de clock por 16, ou seja, são necessários 16 ciclos completos do sinal (Fosc/4) para que ocorra um incremento do TMR2. O POSTSCALER é um contador de estouros do TIMER 2, ou seja, toda vez que a contagem

do TIMER 2 chegar ao fim, ocorrerá o incremento do POSTSCALER. O valor do POSTSCALER pode ser escolhido entre 1 e 16.

A interrupção será gerada sempre que o valor escolhido para o POSTSCALER for alcançado. Tanto o POSTSCALER quanto o PRESCALER são zerados quando ocorre uma das

seguintes operações: • Operações de escrita envolvendo o TMR2; • Operação de escrita envolvendo o T2CON; • Qualquer tipo de reset do PIC;

O TIMER 2 é zerado somente em algum tipo de reset, o que o difere dos outros TIMERS. Para calcular os valores de configuração do MÓDULO PWM, deve-se determinar os valores

do PRESCALER e do POSTSCALER. Utilizando o Exemplo a seguir:


51

Calcular um PWM com freqüência de 78,125KHz, com um PIC rodando com um cristal de 20 MHz e o PRESCALER em 1:1.

PERIODO = (PR2+1)*4*(1/xtal)*PRESCALER (1/78,125KHz) = (PR2+1)*4*(1/20MHz)*1 12,8us = (PR2+1)*4*50ns*1 PR2 = 63. Utilizando agora a diretiva (função) em C para configurar o TIMER 2: SINTAXE: setup_timer2(modo,per,ps) MODO: variável ou constante de 8 bits; Opções para o MODO:

• T2_DISABLE: desliga o TIMER 2; • T2_DIV_BY_1: TIMER 2 habilitado com o PRESCALER 1:1; • T2_DIV_BY_4: TIMER 2 habilitado com o PRESCALER 1:4; • T2_DIV_BY_16: TIMER 2 habilitado com o PRESCALER 1:16;

Parâmetro: PER: corresponde ao registrador PR2, especifica o máximo valor de contagem do TIMER 2.

Parâmetro: PS: corresponde ao registrador POSTSCALER, e seu valor pode variar de 1 até 16.

A resolução define qual o valor máximo em bits que pode ser utlizado para uma configuração de TIMER. Para calcular os valores de configuração do PWM utilizamos o seguinte calculo:

TPWM = (2PWM RESOLUÇÃO )*(1/xtal)*PRESCALER (1/78,125KHz) = (2PWM RESOLUÇÃO )*(1/20MHz)*1 12,8us = (2PWM RESOLUÇÃO)*50ns*1 (2PWM RESOLUÇÃO) = 256 PWM RESOLUÇÃO * LOG(2) = LOG(256) PWM RESOLUÇÃO = 8 bits

*** todo este conteúdo desta pequena descrição do módulo do TIMER 2 foi resumido a partir de duas bibliografias: CONECATANDO O PIC – RECURSOS AVANÇADOS – Autor: David de Souza - 1° edição Editora Érica PROGRAMAÇÃO EM C MICROCONTROLADOR PIC – Autor Fábio Pereira - 1° edição Editora Érica


52

Fluxogramas - Material de apoio

Exemplo de elementos de Fluxogramas

SIMBOLOGIA DA CADA CHAVE DIGITAL


53

CONJUNTO DE CHAVES DIGITAIS COM 4 BOTÕES

DIAGRAMA ELÉTRICO DOS BOTÕES

Tabela de valores de resistores comerciais:

1.0Ω 1.1Ω 1.2Ω 1.3Ω

1.5Ω 1.6Ω 1.8Ω 2.0Ω

2.2Ω 2.4Ω 2.7Ω 3.0Ω

3.3Ω 3.6Ω 3.9Ω 4.3Ω

4.7Ω 5.1Ω 5.6Ω 6.2Ω

6.8Ω 7.5Ω 8.2Ω 9.1Ω

Outros valores podem se encontrados a partir da multiplicação destes valores base por 10, 100, 1000, 10000, 100000 e 1000000 (com resultado máximo para 10 MΩ)

Apostila de Lab ELN APL e Micro Control Adores V2_2 - 2 Sem 2009 - 1 Parte

Documents

Transcript of Apostila de Lab ELN APL e Micro Control Adores V2_2 - 2 Sem 2009 - 1 Parte