Sistemas Microcontrolados

RELATÓRIO DE
PRÁTICA LABORATORIAL
Instruções para o preenchimento do Quadro Descritivo de Prática

 Ler atentamente as orientações complementares disponíveis no AVA, na sala de
aula da disciplina;
 O número da prática laboratorial estará disponível no Roteiro de Práticas no título da
prática a ser realizada;
 A quantidade de Quadros Descritivos a serem preenchidos estará vinculada à
quantidade de práticas realizadas de cada disciplina. Para cada prática realizada,
um quadro deverá ser preenchido; replique-os quando necessário.
 Os textos devem estar formatados seguindo as normas da ABNT, digitados na cor
preta, utilizando fonte Times New Roman ou Arial, tamanho 12, com espaçamento
entre linhas de 1,5, no formato Justificado. A identificação das figuras e ilustrações
caso existam, deve aparecer na parte superior, precedida da palavra designativa,
seguida de seu número de ordem de ocorrência no texto, em algarismos arábicos e
do respectivo título, usando a mesma fonte utilizada no relatório. Após a ilustração,
na parte inferior, indicar obrigatoriamente a fonte (mesmo que seja de autoria
própria), utilizando fonte tamanho 10, estilo regular e espaçamento simples.
 Toda atividade que exige no resultado, a exposição escrita, é uma oportunidade para
o exercício da atividade intelectual e o fortalecimento de habilidades de
argumentação, análise, síntese, entre outros. Neste sentido, o relato da atividade
prática, deverá ser de “sua autoria”, e construído de maneira individual. Aos
relatórios que contenham “plágio” serão atribuídos nota ZERO. O plágio acadêmico
configura-se quando um aluno retira dе livros, artigos dа Internet, ideias, conceitos,
frases dе outro autor sеm lhe dаr о devido crédito, sеm citá-lo como fonte de
pesquisa. Quando utilizar trechos idênticos de autores lidos (seja de um único autor
ou recortes de autores diversos), inclua como citação direta ou indireta (entre aspas
e citando a fonte entre parênteses). Ao contrário, é sempre necessário parafrasear,
ou seja, escrever o que o(s) autor(es) lido(s) disse(ram) com as suas próprias
palavras. Copiar trechos sem inseri-los como citação, é plágio, independentemente
se foram recortes de trechos da mesma fonte ou de fontes diversas.
 Utilizar a norma culta e linguagem impessoal.
 Composição da nota para avaliação:
o 5% formatação segundo as normas da ABNT
o 10% linguagem
o 85% conteúdo do relatório
 O aluno que obtiver nota igual ou superior a 60% será considerado habilitado. Notas
iguais ou inferiores a 59% resultarão na inabilitação do aluno.
 Não se esqueça, em caso de dúvidas, utilize a ferramenta Tira-dúvidas.
ALUNO: Hudson Gaspar da Silva RA: 1116870

PÓLO: Maringá
CURSO: Engenharia Elétrica - EAD ETAPA: 7º

DATA: 26/06/2020 CARGA HORÁRIA:
DISCIPLINA: Sistemas digitais Microcontrolados
PROFESSOR: EDUARDO MANGUCCI DE OLIVEIRA
QUADRO DESCRITIVO DE PRATICA

C.H.: DATA:
PRATICA LABORATORIAL Nº: 919061-1
___2____h 26/06/2020
INTRODUÇÃO: Iniciando com a programação, função Master Clear, whatchdog nos
microcontroladores PIC.
OBJETIVOS: Familiarizar com o software de programação do microcontrolador e visualizar o
funcionamento do botão de reset presente nos microcontroladores PIC para reiniciar o sistema
quando pressionado.
MATERIAL:
Item Quant. Descrição
1 01 Microcomputador com acesso à internet, software mikroC e PicsimLab.
METODOLOGIA: A rotina de programação é abrir o MikroC e configurar um novo projeto com o
microcontrolador PIC16F628A com clock de 4MHz e realizar a programação com o whatchdog
desabilitado
Após a programação, realizar a compilação e eliminar os erros.
Para executar o programa no PICSIMLAB basta abrir o programa e ir em file -> Load Hex e
abrir o arquivo com o nome da pratica que você salvou.
No próximo passo da pratica ativaremos o whatchdog e habilitaremos o reset no código
fonte para não ter estouro na contagem.
RESULTADOS E DISCUSSÃO: No experimento, verificamos a simulação sem e com o
whatchdog, sem o whatchdog mantem um loop infinito, e com o whatchdog tem um estouro no
tempo e a comutação do led reinicia. E posteriormente respondemos um questionário com
algumas perguntas recorrentes ao PIC.
a) Escrever qual deve ser o valor do resistor instalado em série com o pino Master Clear,
justificando a sua resposta.
O resistor precisa ser compatível com a corrente suportada na porta do
microcontrolador que deve ser menor que 80mA para não ocorrer o travamento do
mesmo. Segundo o datasheet do PIC16F628A, a tensão de operação varia de -0,3V a 14V.
Assim, devemos usar um resistor em série de 50 a 100Ω para aplicar um nível "baixo" ao
pino do MCLR, em vez de puxar esse pino diretamente para o VSS. Convencionalmente
utilizamos 1K Ω e trabalhamos com uma corrente bem baixa nesta porta.
b) Escrever qual é a vantagem do reset pelo pino Master Clear sobre o reset por corte de energia
na alimentação.
O reset pelo MCLR garante uma reinicialização mais rápida do PIC pois zera o contador
de programa. Enquanto o reset por corte de energia leva mais tempo para voltar a
funcionar pois esse tempo pode demorar de acordo com o modelo do PIC, e após a
inicialização que irá executar as instruções contidas no código.
c) Escrever o que acontece se não for inserido o resistor em série com a alimentação no pino
Master Clear.
O resistor pull-up garante que o sinal lido seja de nível alto (5v) enquanto o botão ou a
chave não forem pressionados. E caso seja pressionado, não feche um curto entre o
VCC e o GND.
d) Preencher a Tabela 3 com os valores calculados.

Tabela 3 – Complete as colunas de acordo com os valores do oscilador.
Frequência do Oscilador Capacitores Período do Clock
4 MHz 15pF
10 MHz 15 a 33pF
32 MHz 10 a 16pF
20 MHz 0 a 15pF
200 KHz 47 a 68pF
e) Qual vantagem de utilizar o Whatchdog? Quais cuidados devem ser tomados ao habilitá-lo?
É um reset automatico quando algum contador chegar a um valor determinado de contagem a
alguns milissegundos. O microcontrolador entende como algum problema e o reset acontece
automaticamente.
CONCLUSÃO: Nesta pratica ficou claro a funcionalidade do whatchdog no PIC, e que ao habilita-
lo é preciso tomar cuidado com as parametrizações pois uma pausa prolongada ele pode
entender como uma falha na programação e reiniciar no meio do processo.
REFERÊNCIAS BIBLIOGRÁFICAS:
Microchip Technology Inc., PIC16F87XA, Data Sheet, http://ww1.microchip.com/downloads/
en/DeviceDoc/39582b.pdf
MikroElektronika d.o.o., https://www.mikroe.com/mikroc-pic
C.H.: DATA:
___2____h 06/07/2020
INTRODUÇÃO: Utilização do Timer0, entrada digital e de interrupção eterna no microcontrolador
PIC com display 7 segmentos.
OBJETIVOS: Familiarizar com o software de programação do microcontrolador, conhecer o
funcionamento da entrada e saída digital implementando com um display de 7 segmentos e com
uma interrupção externa.
MATERIAL:
METODOLOGIA: A rotina de programação é abrir o MikroC e configurar um novo projeto com o
microcontrolador PIC16F877A com clock de 4MHz e realizar a programação com o whatchdog
desabilitado.
1 #define TRUE 1
#define FALSE 0
2 #define BT_ORDEM PORTA.RA1
unsigned char Vetor_const[] = {238,40,205,109,43,103,231,44,239,47};
3 char ordem = 0, flag =0;
unsigned int timer0cnt = 0;
4 int valor_contagem = 0;
5
void interrupt(){ //função para interrupção
6 if(INTCON.TMR0IF ==1){
timer0cnt++;
7 if(timer0cnt == 500){
if(ordem.f3 == FALSE)
8 valor_contagem++;
else
9 valor_contagem--;
if(valor_contagem > 9 &&ordem.f3 == FALSE)
10 valor_contagem = 0;
else if(valor_contagem < 0 &&ordem.f3 == TRUE)
PORTB = vetor_const[valor_contagem];
12 RA0_bit = ~RA0_bit;
timer0cnt = 0;
13
}
14 INTCON.TMR0IF = 0;
INTCON.TMR0IE = 1;
15 TMR0 = 131;
}
}
void main() {
TRISA = 0b11111110;
TRISB = 0b00000000;
PORTA = PORTB = 0x00;
OPTION_REG.T0CS = 0; // FONTE DE REFERENCIA - CLOCK INTERNO

(CLKO)
OPTION_REG.T0SE = 0; // TRANSIÇÃO DO TIMER O BAIXA PARA ALTA
OPTION_REG.PSA = 0; //SELECIONA PRESCALER PARA TIMERP
OPTION_REG.PS2 = 0;
OPTION_REG.PS1 = 1; //PS2, PS1 E P0 BITS DE PRESCALER
OPTION_REG.PS0 = 0;
TMR0 = 131;
//REGISTROS DE INTERRUPÇÃO
INTCON = 0; //LIMPA O REGISTRO DE CONTROLE DE
INTERRUPÇÃO
INTCON.TMR0IE = 1; //HABILITA A INTERRUPÇÃO DO TIMER0
OVERFLOW
INTCON.TMR0IF = 0; //LIMPA O SINALIZADOR DE INTERRUPÇÃO DO
TIMER0
INTCON.GIE = 1; //HABILITA INTERRUPÇÃO GLOBAL
INTCON.INTF = 0; //LIMPA AS FLAGS DE INTERRUPÇÃO
while(1){
if(BT_ORDEM == 0 && flag == 0){
ordem.F3 = ~ordem.F3;
flag = 1;
}
else if (BT_ORDEM == 1)
flag = 0;
}
Após a programação, realizar a compilação e eliminar os erros.

Para executar o programa no PICSIMLAB basta abrir o programa e ir em file -> Load Hex e abrir o
arquivo com o nome da pratica que você salvou.
No próximo passo da pratica ativaremos o whatchdog e alterar o código fonte para suportar as
interrupções externas.
1 //OPTION_REG.INTEDG = 0;
#define TRUE 1
2 #define FALSE 0
#define BT_ORDEM PORTA.RA1
3 unsigned char Vetor_const[] = {63,6,91,79,102,109,125,7,127,103};
char ordem = 0, flag =0;
4 unsigned int timer0cnt = 0;
int valor_contagem = 0;
5
6 void interrupt(){ //função para interrupção

if(INTCON.INTF == 1){
7 ordem.F3 = ~ordem.F3;
INTCON.INTF = 0;
8 }
if(INTCON.TMR0IF ==1){
9 timer0cnt++;
if(timer0cnt == 500){
10 if(ordem.f3 == FALSE)
valor_contagem++;
11 else
valor_contagem--;
12 if(valor_contagem > 9 &&ordem.f3 == FALSE)
valor_contagem = 0;
else if(valor_contagem < 0 &&ordem.f3 == TRUE)
valor_contagem = 9;
PORTD = vetor_const[valor_contagem];
RA0_bit = ~RA0_bit;
timer0cnt = 0;
}
INTCON.TMR0IF = 0;
INTCON.TMR0IE = 1;
TMR0 = 131;
}
}
void main() {
TRISD = 0b00000000;
TRISB = 0b00001111;
PORTA = PORTB = PORTD = 0x00;
OPTION_REG.INTEDG = 1; //conf. borda de INT
OPTION_REG.T0CS = 0; // FONTE DE REFERENCIA - CLOCK INTERNO

(CLKO)
OPTION_REG.T0SE = 0; // TRANSIÇÃO DO TIMER O BAIXA PARA ALTA
OPTION_REG.PSA = 0; //SELECIONA PRESCALER PARA TIMERP
OPTION_REG.PS2 = 0;
OPTION_REG.PS1 = 1; //PS2, PS1 E P0 BITS DE PRESCALER
OPTION_REG.PS0 = 0;
TMR0 = 131;
//REGISTROS DE INTERRUPÇÃO
INTCON = 0; //LIMPA O REGISTRO DE CONTROLE DE
INTERRUPÇÃO
INTCON.TMR0IE = 1; //HABILITA A INTERRUPÇÃO DO TIMER0
OVERFLOW
INTCON.TMR0IF = 0; //LIMPA O SINALIZADOR DE INTERRUPÇÃO DO
TIMER0
INTCON.GIE = 1; //HABILITA INTERRUPÇÃO GLOBAL
INTCON.INTE = 1; //habilita a interrupção
INTCON.INTF = 0; //LIMPA AS FLAGS DE INTERRUPÇÃO
while(1){
PORTB.RB7 = PORTB.RB6 = PORTB.RB5 = PORTB.RB4 = 1;
}
}
RESULTADOS E DISCUSSÃO: No experimento, verificamos a simulação sem e com o a i, sem o

whatchdog mantem um loop infinito, e com o whatchdog tem um estouro no tempo e a comutação
do LED reinicia. E posteriormente respondemos um questionário com algumas perguntas
recorrentes ao PIC.
a) Escrever quais são as instruções necessárias para configurar a interrupção externa do
microcontrolador PIC para trabalhar com inversão de estado 0 para 1.
A interrupção externa ocorre quando o PINO RB0 sobre inversão de estado (0 para 1 ou 1
para 0) comando é INTCON.TMRIE = 1;
b) Qual a diferença de fazermos o incremento da contagem utilizando o timer0 e utilizando o
comando de atraso (delay_ms)?
O timer0 é um recurso do microcontrolador que permite executar alguma instrução quando
este chega a um determinado valor. Já o delay_ms ele pausa a execução do programa até
atingir o tempo inserido.
c) Com base nos conhecimentos adquiridos sobre interrupção externa, escrever uma breve
descrição como ocorreu o funcionamento da lógica antes da alteração da linha 1 e após a
alteração da linha 1. Comando: "OPTION_REG.INTEDG".
Antes da alteração da linha 1, ao ficar pressionado o botão S1, o programa já invertia seu sinal de
contagem de crescente para decrescente e vice-versa. Ao alterar o comando, a contagem inverte
sua ordem somente quando soltava o botão S1. Resumindo tudo isso, OPTION_REG.INTEDG=0
altera a contagem com a mudança de estado. E OPTION_REG.INTEDG=1 muda a contagem
após o pulso que é apertar e soltar o botão S1.
d) Sabendo que os temporizadores podem ser utilizados para diversas aplicações, descrever
uma aplicação para o Timer0.
O timer nos dá a opção de manipular o tempo de execução das instruções. Logo posso
definir em determinados períodos para minha rotina de sistema executar alguma instrução
em função deste temporizador. Um exemplo seria uma rampa PWM onde em
determinados segundos minha rotina formaria uma rampa de aceleração para partida de
algum motor.
e) Utilizando a fórmula do intervalo de chamada interrupção do TIMER0 vista na parte teórica
desse roteiro de prática, calcule e preencha a primeira coluna da Tabela 2 de acordo com os
parâmetros das demais colunas.
Tabela 2 – Cálculo do Intervalo de chamada da interrupção do Timer0
Intervalo de Chamada da Frequência Iniciar Contagem

Prescaler
Interrupção do Timer0 (s) do Clock em:
0,001 4 4 MHz 6
0,00016 8 20 MHz 156
0,00051 2 4 MHz 0
0,00064 8 10 MHz 56
0,00050 4 8 MHz 6
CONCLUSÃO: Nesta pratica observamos o funcionamento do display de 7 segmentos e também
as interrupções externas para inverter a contagem. Um comando interessante foi o
OPTION_REG.INTEDG onde quando igual a 0, a inversão da contagem acontece só de
pressionar o botão, e quando está igual a 1, a contagem só inverte quando ocorre um pulso na
porta que apertar e depois soltar.
C.H.: DATA:
___2____h 10/07/2020
INTRODUÇÃO: Utilizar memoria EEPROM, sensor de temperatura e display LCD no
microcontrolador PIC
OBJETIVOS: Familiarizar com o software de programação do microcontrolador e visualizar o
funcionamento do botão de reset presente nos microcontroladores PIC para reiniciar o sistema
quando pressionado.
MATERIAL:
METODOLOGIA:
Procedimentos experimentais
a) O primeiro experimento desse roteiro, iremos realizar a manipulação da memória EEPROM

utilizando a segunda parte do projeto do segundo roteiro. Será necessário armazenar na
memória EEPROM o valor do contador e a ordem da contagem a cada segundo. Para
testarmos, basta desligarmos a energia da placa e energizá-la novamente. A contagem deve
continuar na sequência antes da interrupção da energia.
b) Para a segunda parte, vamos começar desenvolvendo a lógica em um novo projeto através do
software mikroC. Para tanto, deve-se criar um projeto utilizando o microcontrolador PIC
16F877A, com um clock de 4 MHz. Na parte inicial do programa, escreveremos as linhas de
configuração do display LCD, indicando os pinos do microcontrolador que serão ligados a ele.
c) Dentro do laço infinito (loop) do programa, iremos nos preocupar em escrever, no display LCD,
os textos que irão rotular os dados convertidos da entrada analógica.
d) Outra funcionalidade a ser implementada será o acionamento de uma saída, caso a
temperatura exceda o valor de 100 °C. Essa saída pode acionar um LED, uma sirene ou um
relé para acionar outra carga externa. Caso utilize um relé, é importante lembrar que a saída do
PIC não consegue alimentar a bobina, sendo necessário utilizar um transistor como chave para
realizar essa função.
e) Não esquecer de habilitar as bibliotecas necessárias para utilizar os recursos dessa prática,
conforme ilustrado na Figura 3. São elas: ADC, Convertions, C_String, Lcd e Lcd_Constants.
Figura 3 – Bibliotecas a serem ativadas.

f) Após o desenvolvimento da lógica, conforme ilustrado no Quadro 1, compilar e realizar a
simulação utilizando a placa McLab2.
Quadro 1 - Sugestão para programação da prática 03 (entrada analógica com display LCD).
1 // UNIUBE - Prática 3, trabalhando com Entrada Analógica e display LCD
2 // Conexão com móduo LCD
3 sbit LCD_RS at RE0_bit;
4 sbit LCD_EN at RE1_bit;
5 sbit LCD_D4 at RD4_bit;
10 sbit LCD_RS_Direction at TRISE0_bit;
11 sbit LCD_EN_Direction at TRISE1_bit;
12 sbit LCD_D4_Direction at TRISD4_bit;
16 // Fim da Conexão com móduo LCD
17
18 unsigned int entradaAnalogica = 0;

19 float temperatura;
20
21 unsigned int timer0cnt = 0, valor_contagem = 0;
22 char texto_LCD[15];
23
24 void interrupt(){ // Função para Interrupção Externa e TMR0
25 if (INTCON.TMR0IF == 1) { // -- -- INTERRUPÇÃO DO TIMER0 -- --
26 timer0cnt++; // Incrementa 1 unidade a cada 0,001 segundos
27 if(timer0cnt == 1000) { // Contabiliza 0,5 segundo para inverter valor do bit
28 timer0cnt = 0; // Zera o contador
29 RD0_bit = ~RD0_bit;
30 }
31 if (timer0cnt%2){
32 RA5_bit = ~RA5_bit;
33 }
34 INTCON.TMR0IF = 0; // Limpa o sinalizador
35 INTCON.TMR0IE = 1; // Habilita novamente a Interrupção
36 TMR0 = 131; // Inicia o contador Timer0 no valor 131
37 }
38 }
39
40 void main() {
41 int a;
42
43 TRISD = 0b00000000; // Configura o Grupo A, C e D como saída
44 TRISB = 0b00001111; // Configura apenas o portB.BO como entrada
45 PORTA = PORTB = PORTD = 0x00; // Inicializa os valores para A, B, C e D
46
47 ADCON0 = 0b00001001; // Habilita A/D e seleciona a entrada AN1
48 ADCON1 = 0b00000100; // Seleciona apenas os pinos AN0, AN1 e AN3 como

A/D
49 ADC_Init();// Inicializa o módulo conversor A/D
50 CMCON = 0b00000111; // Desabilita os comparadores internos
51
52 // Interrupcao (Timer0): Freq = 1000,00 Hz - Periodo = 0,001000 segundos
53 OPTION_REG.T0CS = 0; // bit 5 Fonte de referência - Clock Interno (CLKO)
54 OPTION_REG.T0SE = 0; // bit 4 Transição do Timer0 baixa-para-alta
55 OPTION_REG.PSA = 0; // bit 3 Seleciona o Prescaler para o Timer0
56 OPTION_REG.PS2 = 0; //
57 OPTION_REG.PS1 = 1; // bits 2-0 PS2:PS0: Taxa do Prescaler 010 (1:8)
60
61 // Registros de Interrupção
62 INTCON = 0; // Limpa o registro de controle de Interrupção
63 INTCON.TMR0IE = 1; // bit5 Habilita a Interrupção do Timer0 Overflow
64 INTCON.TMR0IF = 0; // bit2 Limpa o sinalizador de Interrupção do timer 0
65 INTCON.GIE = 1; // bit7 Habilita Interrupção Global
66
67 Lcd_Init(); // Tela LCD (Inicialização)
68 delay_ms(100);
69
70 adc_init(); // Inicializa Conversor Analógico Digital
71 delay_ms(100);
72
73 Lcd_Cmd(_LCD_CURSOR_OFF); // Comando LCD (Cursor desligado)
74 Lcd_Cmd(_LCD_CLEAR); // Comando LCD (limpar tela)
75
76 while(1) {
77 entradaAnalogica = ADC_Get_Sample(1); //Lê o valor da porta AN1
78 delay_ms(200);
79 temperatura = (entradaAnalogica * 5.0 * 100.0)/1022.0;
80
81 if(temperatura > 100.0)
82 {
83 RD1_bit = 1;
84 }else{
85 RD1_bit = 0;
86 }
87 FloatToStr(temperatura,texto_LCD);
88 Ltrim(texto_LCD);
89 Lcd_Cmd(_LCD_CLEAR);
90 Lcd_Out(1,1,"Temp.: ");
91 Lcd_Out(1,8,texto_LCD);
92 Lcd_Out(1,14," gC");
93 delay_ms(200);
94
95 PORTB.RB7 = 1;
96 }
97 }
g) Com o protótipo funcionando, manipular o slider (Pot. P2) simulando um sensor de

temperatura. Observar os valores indicados no display LCD.
RESULTADOS E DISCUSSÃO: No experimento, verificamos a simulação sem e com o

whatchdog, sem o whatchdog mantem um loop infinito, e com o whatchdog tem um
estouro no tempo e a comutação do led reinicia. E posteriormente respondemos um
questionário com algumas perguntas recorrentes ao PIC.
a) Qual a função e o motivo de utilizar o transistor 2N2222? Por que utilizar um diodo ligado junto
ao relê? Qual o limite de tensão e corrente da carga que esse relê poderá acionar?
A função dele é acionar uma carga que consome mais de 25mA, pois este é o limite do
microcontrolador. Já o transistor pode suportar até 800mA, este transistor aciona o relê
que tem um limite de até 15ª (SRA-12VCD-CL)
b) Quantas portas analógicas possui o PIC 16F877A?

possui 8 portas analógicas
c) Qual a resolução do conversor analógico / digital do PIC 16F877A? Com isso, qual é mínima
tensão de variação detectada por essa entrada?
É utilizado 10 bits de comprimento para a conversão analógico em digital. Para encontrar a
resolução basta dividir o fundo de escala (variação da tensão aplicada no pino) divido por
2^10 – 1
d) Anexar fotos da montagem da prática.

CONCLUSÃO: Nesta pratica observamos o funcionamento do sensor de temperatura configurado
na porta 2 onde ao ajustarmos a temperatura, e informado em tempo real no visor de led. O
transistor e o relê para funcionar como uma chave liga e desliga, pois, o PIC trabalha com baixa
corrente.
C.H.: DATA:
___2____h 26/06/2020
INTRODUÇÃO: Comunicação através da porta serial UART, I2C e controlar a rotação de um
motor através de uma saída PWM de um microcontrolador PIC.
OBJETIVOS:
Estabelecendo comunicação serial UART e a comunicação I2C entre um microcontrolador e uma

CI de memória EEPROM
Simular a operação de um sensor analógico e realizar o controle da saída PWM que poderia
controlar a rotação de um motor.
MATERIAL:
METODOLOGIA:
Inicialmente iremos trabalhar com a comunicação I2C com o CI “24C04” realizando escrita e leitura
de áreas de memória. E realizaremos uma comunicação serial RS-232.
Para isso seguiremos os seguintes procedimentos:
a) Vamos começar desenvolvendo a lógica através do software mikroC. Criar um projeto utilizando o
microcontrolador PIC 16F877A, com um clock de 4 MHz.
b) Ativar as bibliotecas do MikroC que serão necessárias para essa lógica: I2C e UART.
c) Observar a sugestão da lógica no Quadro 1. Compilar e realizar a simulação no PICSimLab utilizando a
placa McLab2.
Para realizar a comunicação serial, precisaremos de um outro software para gerar duas portas seriais
virtuais interconectadas. Utilizaremos o “VIRTUAL SERIAL PORTS EMULATOR” que pode ser baixado
gratuitamente pelo endereço: http://www.eterlogic.com/Downloads.html
No site há duas opções de instalação, uma para sistemas operacionais 32 bits e outra para sistemas
operacionais 64 bits.
Execute a opção de acordo com o seu sistema. Durante a instalação, avance as etapas e concorde com
os termos de instalação. No final será preciso reiniciar o computador.
Após a instalação, execute-o e realize a

seguinte configuração:
 No
menu
“Device” clique em “Create”;

 Selecione o tipo “Pair”
Abra o PICSimLab e selecione uma das portas seriais virtuais pelo
menu “File” -> “Configure”.
Carregue a sua aplicação (.HEX) para iniciar a execução do código

do microcontrolador. E na sequência abra um comunicador serial, presente
no menu “Tools” -> “Serial Terminal”.
No terminal serial deixaremos a configuração de comunicação

padrão:
 Velocidade de transmissão: 9600
 Flow Control: None
 Data Bit: 8
 Paridade: Nenhuma
 Bit de parada: 1
Para iniciar a comunicação realize o

seguinte passo:
 Em device selecione a outra porta

serial virtual, no exemplo, COM2.
 Clique em “Open” e a comunicação
serial iniciará.
Caso o seu sistema operacional seja o Linux, pode-se utilizar o programa tty0tty. Esse software pode
ser encontrado no endereço: https://github.com/lcgamboa/tty0tty/
Quadro 1 - Sugestão de programação para comunicação I2C.
1 //Vetor com valores constantes para os números do Display -> Catodo comum
2 unsigned char Vetor_Const_Disp[] = {63, 6, 91, 79, 102, 109, 125, 7, 127, 103}; //0,1,2,3,4,5,6,7,5,9
3 unsigned int timer0cnt = 0;
4 unsigned short valor_contagem, ordem = 0, flag = 0;
5 char temp[] = "O contador esta 00", uart_rd;
8 if(INTCON.INTF == 1){// -- -- INTERRUPÇÃO EXTERNA -- --
9 if(ordem == 0) ordem = 1; else ordem = 0; // Sentido do contador (crescente / decrescente)
10 INTCON.INTF = 0; // Limpa as Flags de interrupção
11 }
12
16 if(ordem == 0) // Determina o sentido da contagem (crescente/descrescente)
17 valor_contagem++;
18 else
19 valor_contagem--;
20 if(valor_contagem > 10 && ordem == 0) //Reinicia a contagem crescente
22 else if(valor_contagem < 1 && ordem == 1) //Reinicia a contagem decrescente
24 PORTD = Vetor_Const_Disp[valor_contagem-1]; //Liga ou desliga as saídas do grupo D
25 flag = 1;
27 }
29 INTCON.TMR0IE = 1; // Habilita novamente a interrupção
31 }
32 }
33
34 void main() {
37 TRISC = 0b10000000;
38 PORTA = PORTB = PORTC = PORTD = 0x00; // Inicializa os valores para A, B, C e D
39
40 OPTION_REG.INTEDG = 1; // Conf. borda de INT (Rising Edge): 0= H_TO_L, 1= L_TO_H
41
42 // Interrupção (Timer0): Freq = 1000,00 Hz - Período = 0,001000 segundos
44 OPTION_REG.T0SE = 0; // bit 4 Transição do Timer0 baixa-para-alta
50
52 INTCON = 0; // Limpa o registro de controle de interrupção
53 INTCON.TMR0IE = 1; // bit 5 Habilita a Interrupção do Timer0 Overflow
54 INTCON.TMR0IF = 0; // bit2 Limpa o sinalizador de interrupção do timer0
56 INTCON.INTE = 1; // Habilita a INTERRUPÇÃO EXTERNA
57 INTCON.INTF = 0; // Limpa as Flags de interrupção
58
59 // Comunicação Serial
60 UART1_Init(9600); // Inicializa o módulo UART em 9600 bps
61 delay_ms(100); // Aguarda a estabilização do módulo UART
62
63 I2C1_Init(100000); //Inicializa comunicação I2C
64 I2C1_Start(); //Inicia I2C
65 I2C1_Wr(0xA0); //Envia o byte por I2C (endereço do dispositivo)

66 I2C1_Wr(0x00); //Envia o valor da posição de memória
67 I2C1_Repeated_Start(); //Restart I2C
68 I2C1_Wr(0xA1); //Envia byte endereço do dispositivo + R (Read)
69 valor_contagem = I2C1_Rd(0u); //Lê o dado e armazena em valor_contagem
70 I2C1_Stop();
71
72 I2C1_Start(); //Inicia I2C
73 I2C1_Wr(0xA0); //Envia o byte por I2C (endereço do dispositivo)
74 I2C1_Wr(0x01); //Envia o valor da posição de memória
75 I2C1_Repeated_Start(); //Restart I2C
76 I2C1_Wr(0xA1); //Envia byte endereço do dispositivo + R (Read)
77 ordem = I2C1_Rd(0u); //Lê o dado e armazena em ordem
78 I2C1_Stop();
79
80 if(valor_contagem < 1 || valor_contagem > 10)
81 valor_contagem = ordem = 1;
82
83 PORTB.RB7 = PORTB.RB6 = PORTB.RB5 = PORTB.RB4 = 1;
84
while(1){
85
if (flag == 1){
86
I2C1_Start(); //Iniciar I2C
87
I2C1_Wr(0xA0); //Enviar o byte por I2C (endereço do dispositivo + Write)
88
I2C1_Wr(0x00); //Enviar o valor da posição de memória a ser escrita
89
I2C1_Wr(valor_contagem); //Escrever o valor atual do contador
90
I2C1_Wr(ordem); //Escrever o sentido da contagem
91
I2C1_Stop(); //Parar I2C
92
delay_ms(100); //aguarda 100ms
93
flag = 0;
94
95
temp[16] = ((valor_contagem-1)%100)/10 + 48;
96
temp[17] = (valor_contagem-1)%10 + 48;
97
98 UART1_Write_Text(temp);
99 UART1_Write(10); UART1_Write(13);
100 }
101
102 if (UART1_Data_Ready()) { // If data is received,
103 uart_rd = UART1_Read(); // read the received data,
104 if(uart_rd == 'i' || uart_rd == 'I')
if(ordem == 0) ordem = 1; else ordem = 0; // Sentido do contador (crescente / decrescente)

105
}
106
}
107
}
Com a lógica em funcionamento é possível realizar o desligamento da energia e o restabelecimento

dela e acompanhar a continuidade da contagem de onde parou. Inclusive o modo de contagem (crescente ou
decrescente).
No meio da contagem clique sobre o CI “24C04” e você poderá observar a abertura de um arquivo de
texto com os valores escritos na memória quando o clique do mouse foi executado.
No terminal serial é possível acompanhar a contagem e caso envie a letra “i”, o sentido de contagem
é invertido.
2ª parte:
Para trabalharmos com entrada analógica utilizaremos entrada (Port. 2) e a saída PWM do
microcontrolador PIC, faremos um processo de controle de temperatura. O valor da entrada analógica é
digitalizado e processado, gerando um sinal pela saída PWM para a placa Ponte-H, que receberá esse sinal e
será responsável por controlar a rotação do motor DC. Caso não tenha a Ponte-H com o motor, é possível
colocar um LED no pino da saída PWM e acompanhar a intensidade da iluminação do LED. Essas
informações poderão ser acompanhadas através de um dispositivo, recebendo esses dados via display LCD e
até mesmo uma comunicação serial.
Primeiramente vamos realizar os seguintes procedimentos:

d) Vamos começar desenvolvendo a lógica através do software mikroC. Criar um projeto utilizando o
microcontrolador PIC 16F877A, com um clock de 4 MHz.
e) A leitura da temperatura do sensor é feita de forma cíclica, de modo que ele consiga manipular a rotação
do motor, que simulará um sistema de refrigeração.
f) Para a configuração do PWM, de acordo com o manual do PIC 16F877A e o nosso roteiro de prática,
podemos aproveitar o exemplo fornecido na parte teórica, pois ele já foi feito para as condições de nossa
prática.
g) Ativar as bibliotecas do MikroC que serão necessárias para essa lógica: ADC e PWM.
h) Observar a sugestão da lógica, conforme representado no quadro abaixo. Compilar e realizar a gravação
da mesma no microcontrolador PIC.
Quadro 2 - Sugestão de programação para entrada analógica e Saída PWM.

1 // UNIUBE - Prática 4, trabalhando com Entrada Analógica, saída PWM e UART
2 unsigned int entradaAnalogica = 0, saida_PWM = 0, timer0cnt = 0, temperatura = 0;
3 unsigned short current_duty, k, flag;
4 char temp[] = "Temperatura eh 000 C";
5 char pwm_txt[] = "Saida PWM 000 de 255.";
12 flag = 1;
13 PORTD.RD7 = ~PORTD.RD7;
14 }
16 INTCON.TMR0IE = 1; // Habilita novamente a Interrupção
18 }
19 }
20
21 void main() {
24 TRISC = 0b10000000;
25 PORTA = PORTB = PORTC = PORTD = 0x00; // Inicializa os valores para A, B, C e

D
26
27
ADCON0 = 0b00001001; // Habilita A/D e seleciona a entrada AN1
28
ADCON1 = 0b00000100; // Seleciona apenas os pinos AN0, AN1 e AN3 como A/D
29
ADC_Init();// Inicializa o módulo conversor A/D
30
31 delay_ms(100);
32 CMCON = 0b00000111; // Desabilita os comparadores internos
33
34 // Interrupcao (Timer0): Freq = 1000,00 Hz - Periodo = 0,001000 segundos
36 OPTION_REG.T0SE = 0; // bit 4 Transição do Timer0 biaxa-para-alta
42
44 INTCON = 0; // Limpa o registro de controle de Interrupção
45 INTCON.TMR0IE = 1; // bit5 Habilita a Interrupção do Timer0 Overflow
46 INTCON.TMR0IF = 0; // bit2 Limpa o sinalizador de Interrupção do timer 0
48
49 // Configuração do PWM
50 PR2 = 255; // 1. Configura o período do PWM
51 CCPR1L = 0; // 2. Configure o Duty Cycle
52 CCP1CON = 0b00000101; // 2. Configure o Duty Cycle
53 TMR2 = 0; // Initialize Timer2 register
54 TRISC = 0x00; // 3. Configura o pino CCP1 como saída e limpe o bit TRISC
(feito inicio da função main)
55
T2CON = 0b00000100; // 4. TR2 settings- postscale 1:1, TMR2 ON, prescale 1:16
56
PIE1 = 0b00000100; // 5. Configura o módulo CCP1 para funcionar como PWM
57
58
PWM1_Init(3906); // Initializa módulo PWM1 em 3,906KHz
59
delay_ms(100);
60
61 current_duty = 16; // Valor inicial para current_duty
62 PWM1_Set_Duty(current_duty); // Atribui a taxa atual ao PWM1
63 PWM1_Start(); // Inicia o PWM1
64
65 UART1_Init(9600); // Inicializa o módulo UART em 9600 bps
66 delay_ms(100); // Aguarda a estabilização do módulo UART
67
68 PORTB.RB7 = PORTB.RB6 = PORTB.RB5 = PORTB.RB4 = 1;
69
70 while(1) {
71 entradaAnalogica = ADC_Get_Sample(1); //Lê o valor da porta AN1
72 temperatura = (entradaAnalogica*999.0)/1022.0;
73
74 // Armazenar temperatura lida
75 temp[15] = temperatura/100 + 48;
76 temp[16] = (temperatura%100)/10 + 48;
77 temp[17] = temperatura%10 + 48;
78
79 // Esses valores devem ser ajustados para cada região
80 if(temperatura > 25)
81 saida_PWM = (temperatura*255.0) / 999.0;
82 else
83 saida_PWM = 0;
84
85 if(saida_PWM > 255) // Bloqueia o valor em 100% (255) caso passe dos 255
86 saida_PWM = 255;
87
88 pwm_txt[10] = saida_PWM/100 + 48;
89 pwm_txt[11] = (saida_PWM%100)/10 + 48;
90 pwm_txt[12] = saida_PWM%10 + 48;

91
92 if(flag == 1){
93 UART1_Write_Text(temp);
95 UART1_Write_Text(pwm_txt);
98 flag = 0;
99 }
100 PWM1_Set_Duty(saida_PWM); // Atribui a taxa atual ao PWM1
101 delay_ms(100);
102 }
103 }
i) Após o desenvolvimento da lógica, conforme sugerido no Quadro 1, compilar e realizar a gravação no

microcontrolador PIC.
j) Agora, manipule a barra “Port. P2” do lado esquerdo e acompanhar a variação da saída PWM pela barra
de progresso do “Heater”.
k) Abra o “Osciloscópio” dentro do menu “Modules” e acompanhe a saída PWM.
RESULTADOS E DISCUSSÃO: No experimento, verificamos o funcionamento da logica e

também da comunicação serial das atividades propostas neste experimento e respondemos
alguns questionamentos quanto a alguns componentes e particularidades do PIC.
a) Qual faixa de tensão que o CI “24C04” pode ser alimentado? Qual a máxima frequência (SCL) que
ele consegue operar?
A tensão pode variar de 1,8 (1,8 a 5 V) ou 2,7( 2,7 a 5V), já a frequência máxima seria de
2,7(400KHz) e 1,8(100 KHz)
b) Quantas portas PWM o PIC 16F877A possui? Qual a resolução (em bits)?
Possui 2 módulos PWM e sua largura de pulso é de 10 BITS
b) Anexar fotos da montagem da prática.

Pratica parte 1:
Pratica Parte 2:
Pratica parte 2, osciloscopio

CONCLUSÃO: Nesta pratica conseguimos chegar nos objetos propostos e observamos o
funcionamento da comunicação serial e que a informação ela pode vir e podemos enviar
comandos desde ligar e desligar como parâmetros de funcionamento. Quando ao PWM
conseguimos ver tanto seu range pela porta serial conforme mudávamos os parâmetros, como
também pelo osciloscópio, colocando em pratica bastaria integrar um modulo de potencia para
acionar a carga por PWM.

Sistemas Microcontrolados

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Sistemas Microcontrolados

Enviado por

Direitos autorais:

Formatos disponíveis

RELATÓRIO DE

Instruções para o preenchimento do Quadro Descritivo de Prática

ALUNO: Hudson Gaspar da Silva RA: 1116870

CURSO: Engenharia Elétrica - EAD ETAPA: 7º

QUADRO DESCRITIVO DE PRATICA

d) Preencher a Tabela 3 com os valores calculados.

OPTION_REG.T0CS = 0; // FONTE DE REFERENCIA - CLOCK INTERNO

Após a programação, realizar a compilação e eliminar os erros.

6 void interrupt(){ //função para interrupção

OPTION_REG.INTEDG = 1; //conf. borda de INT

OPTION_REG.T0CS = 0; // FONTE DE REFERENCIA - CLOCK INTERNO

RESULTADOS E DISCUSSÃO: No experimento, verificamos a simulação sem e com o a i, sem o

Tabela 2 – Cálculo do Intervalo de chamada da interrupção do Timer0

Intervalo de Chamada da Frequência Iniciar Contagem

0,00016 8 20 MHz 156

a) O primeiro experimento desse roteiro, iremos realizar a manipulação da memória EEPROM

Figura 3 – Bibliotecas a serem ativadas.

1 // UNIUBE - Prática 3, trabalhando com Entrada Analógica e display LCD

2 // Conexão com móduo LCD

3 sbit LCD_RS at RE0_bit;

4 sbit LCD_EN at RE1_bit;

5 sbit LCD_D4 at RD4_bit;

6 sbit LCD_D5 at RD5_bit;

7 sbit LCD_D6 at RD6_bit;

8 sbit LCD_D7 at RD7_bit;

10 sbit LCD_RS_Direction at TRISE0_bit;

11 sbit LCD_EN_Direction at TRISE1_bit;

12 sbit LCD_D4_Direction at TRISD4_bit;

13 sbit LCD_D5_Direction at TRISD5_bit;

14 sbit LCD_D6_Direction at TRISD6_bit;

15 sbit LCD_D7_Direction at TRISD7_bit;

16 // Fim da Conexão com móduo LCD

18 unsigned int entradaAnalogica = 0;

21 unsigned int timer0cnt = 0, valor_contagem = 0;

24 void interrupt(){ // Função para Interrupção Externa e TMR0

25 if (INTCON.TMR0IF == 1) { // -- -- INTERRUPÇÃO DO TIMER0 -- --

26 timer0cnt++; // Incrementa 1 unidade a cada 0,001 segundos

27 if(timer0cnt == 1000) { // Contabiliza 0,5 segundo para inverter valor do bit

28 timer0cnt = 0; // Zera o contador

34 INTCON.TMR0IF = 0; // Limpa o sinalizador

35 INTCON.TMR0IE = 1; // Habilita novamente a Interrupção

36 TMR0 = 131; // Inicia o contador Timer0 no valor 131

43 TRISD = 0b00000000; // Configura o Grupo A, C e D como saída

44 TRISB = 0b00001111; // Configura apenas o portB.BO como entrada

45 PORTA = PORTB = PORTD = 0x00; // Inicializa os valores para A, B, C e D

47 ADCON0 = 0b00001001; // Habilita A/D e seleciona a entrada AN1

48 ADCON1 = 0b00000100; // Seleciona apenas os pinos AN0, AN1 e AN3 como

50 CMCON = 0b00000111; // Desabilita os comparadores internos

52 // Interrupcao (Timer0): Freq = 1000,00 Hz - Periodo = 0,001000 segundos

53 OPTION_REG.T0CS = 0; // bit 5 Fonte de referência - Clock Interno (CLKO)

54 OPTION_REG.T0SE = 0; // bit 4 Transição do Timer0 baixa-para-alta

55 OPTION_REG.PSA = 0; // bit 3 Seleciona o Prescaler para o Timer0

57 OPTION_REG.PS1 = 1; // bits 2-0 PS2:PS0: Taxa do Prescaler 010 (1:8)

59 TMR0 = 131; // Inicia o contador Timer0 no valor 131

62 INTCON = 0; // Limpa o registro de controle de Interrupção

63 INTCON.TMR0IE = 1; // bit5 Habilita a Interrupção do Timer0 Overflow

64 INTCON.TMR0IF = 0; // bit2 Limpa o sinalizador de Interrupção do timer 0

65 INTCON.GIE = 1; // bit7 Habilita Interrupção Global

67 Lcd_Init(); // Tela LCD (Inicialização)

70 adc_init(); // Inicializa Conversor Analógico Digital

73 Lcd_Cmd(_LCD_CURSOR_OFF); // Comando LCD (Cursor desligado)

74 Lcd_Cmd(_LCD_CLEAR); // Comando LCD (limpar tela)

77 entradaAnalogica = ADC_Get_Sample(1); //Lê o valor da porta AN1

81 if(temperatura > 100.0)