SM1 - Parobé
Sistemas Microcontrolados 1 – Parobé É nela que vamos escrever os codigos e compila-los
Introdução a Programação para PIC18F4550
1. O microcontrolador:
Um microcontrolador (também denominado MCU) é
um computador-num-chip, contendo um processador,
memória e periféricos de entrada/saída.
É um microprocessador que pode ser programado para
funções específicas, em contraste com outros
microprocessadores de propósito geral (como os
utilizados nos PCs). Eles são embarcados no interior
de algum outro dispositivo (geralmente um produto
comercializado) para que possam controlar as funções
ou ações do produto. Um outro nome para o
microcontrolador, portanto, é controlador embutido.
2. O microcontrolador PIC:
Os PIC são uma família
de microcontroladores fabricados pela Microchip
Technology, que processam dados de 8 bits, de 16 bits
e, mais recentemente, de 32 bits. Seu nome é oriundo
de "Programmable Interface Controller" (Controlador de
Interface Programável). Contam com extensa
variedade de modelos e periféricos internos.
3. A IDE:
Utilizamos na disciplina a IDE MPLAB X, da Microchip,
que podemos obter gratuitamente atravez do site da
propria fabricante.
IDE significa Integrated Development Evironment, ou
seja Ambiente de Desenvolvimento Integrado.
IC Salgado
para que depois possamos testa-lo no PIC.
4. O Compilador:
O nome "compilador" é usado principalmente para os
programas que traduzem o código fonte de
uma linguagem de programação de alto nível para
uma linguagem de programação de baixo nível.
Utilizamos o XC8, também da Microchip, por ser
gratuito e de fácil utilização.
5. Arquivos de Cabeçalho ou Bibliotecas:
São arquivos .h com codigos criados para implementar
algumas funções ou ativa-las no microcontrolador.
Muitos destes arquivos ja estão disponíveis quando
instalamos o compilador, mas podemos criar funções e
utilizalas como arquivos de cabeçalho.
Uma destas funções é a de configuração do PIC para
utilização. Esta função foi disponibilizada pelo
professor da disciplina e encontra-se disponível em seu
blog e também no meu.
#include "C:\headers\fuses\config_PIC18F4550.h"
//configura os fuses do pic
Deve ser indicado o endereço onde se encontra a
função.
#include <stdio.h> // entradas e saidas padrão do C
#include <stdlib.h> // não lembro quais funções são
liberadas
Estas outras duas bibliotecas são mais conhecidas
pois também as utilizamos em Informática Básica.
#include <p18f4550.h>// header especifico do 4550
#include <pic18.h>// header da familia 18

Já estas são bibliotecas especificas para que o
compilador indentifique qual o modelo de
microcontrolador estamos utilizado e aplique as
configurações necessárias, além de disponibilizar
algumas funções que utilizaremos.
6. PORTs:
O PIC18F4550 possui 5 ports, que são blocos de
terminais destinados a entradas e saidas, podendo ser
digitais ou analógicas, conforme a necessidade e a
configuração desejada.
Os PORTs são divididos sequencialmente em ordem
alfabetica:
PORTA – 7 terminais utilizáveis;
PROTB – 7 terminais utilizáveis;
PORTC – 6 terminais utilizáveis;
PORTD – 8 terminais utilizáveis;
PORTE – 3 terminais utilizáveis;
Na verdade podemos reparar no Datasheet que estes
PORTs possuem mais terminais do que eu indiquei
porém, alguns destes terminais ja são utilizados para
outras funções em nossa placa, então é melhor deixa-
los de fora.
7. Definindo ‘apelidos’ para os terminais:
O compilador ja define um nome para cada terminal de
nosso PIC, mas para facilitar a programação e
leiturado codigo e uma possível alteração de terminais,
utilizaremos a função #define que define um apelido
para o terminal que podemos utilizar em todo nosso
programa.
IC Salgado
SM1 - Parobé
Sintaxe:
#define apelido PORTXbits.RXY
Onde X indica o PORT desejado (A, B, C, D ou E) e Y
indica o terminal deste PORT (varia de 0 a 7)
Neste caso estou atribuindo a palavra apelido ao
terminal Y do PORTX
Exemplo:
#define power PORTCbits.RC0 //define RC0
como led indicador de maquina ligada
8. Definindo entradas e saidas - TRIS:
Chamamos de entradas todas as informações que o
microcontrolador irá receber de um meio externo, como
por exemplo um botão que pode enviar nivel lógico alto
ou baixo.
As saidas são informações que o microcontrolador
processa e emite por meio de seus terminais, como por
exemplo um Led que pode receber nivel lógico alto ou
baixo.
Precisamos informar ao nosso compilador quais
terminais ou PORTs desejamos configurar como
entradas ou saidas.
Definindo todo o PORT como entrada ou saida:
TRISA = 0x00; //saida
TRISB = 0xFF; //entrada
No primeiro exemplo configuramos todo o PORTA
como saida, ou seja, ele não recebe informações,
apenas as emite. E no segundo exemplo configuramos
o PORTB como entrada, ou seja, recebe informações.
Nestes dois exemplos utilizamos a configuração em
hexadecimal (0x00).
Definindo terminais específicos como entrada ou saida:
 SM1 - Parobé

TRISA = 0b00000000; While(1)

TRISAbits.RA0 = 0x00; {
TRISB = 0b11111111; //sequencia de comandos
TRISBbits.RB0 = 0xFF; }
Nos dois primeiros exemplos temos maneiras de
configurar os terminais como saidas. O primeiro Quando o PIC for iniciado o programa entrará neste
exemplo indica em binário, bit a bit, a configuração de while e verificará se 1 é verdadeiro, como não existe
cada um e no segundo configuramos o terminal RA0 nenhum outro parametro para ser verificado, o
do PORTA como saida. Nos outros dois exemplos resultado será sempre verdadeiro, obrigando o
configuramos o PORTB e o terminal RB0 de forma programa a executar infinitamente os camandos dentro
semelhante, porém, os definimos como entrada. do bloco.
Para definir os terminais de um PORT como entrada ou Estrutura do programa até agora
saida usando a configuração em binário (0b00000000),
devemos considerar a sequencia do bit menos #includes
significativo até o bit mais significativo. #defines

9. Loop Infinito: int main()

A linguagem C trabalha de forma sequencial, ou seja, {
executa as funções linha por linha de cima para baixo, TRISxxxxxxxx;
e no fim do codigo ela encerra a excução. Para while(1)
utilizarmos a linguagem de forma eficiente no {
microcontrolador devemos escrever nosso codigo
dentro de um loop infinito, para que o PIC possa }
executar todas as funções e no fim voltar ao inicio e }
executa-las novamente.
O loop infinito é um comando de repetição que verifica 10. Criando um novo projeto:
uma condição que sempre dará verdadeira. A maneira Vamos a prática:
mais comum de implementarmos este loop é utilizando Para criar um novo projeto no MPLAB X devemos
o comando while() da seguinte forma: seguir os seguintes passos, alem de abrir o programa
claro:

IC Salgado
 SM1 - Parobé

File>New Project>Microchip Embedded>Standalone Eu costumo fazer algumas alterações iniciais e ja

Project>Advanced 8-bit MCUs incluo alguns arquivos de cabeçalho que talvez
(PIC18)>PIC18F4550>ID3>XC8>”nome”>finish. precise.
/*
Vou colocar no blog e junto com a pasta compactada * File: tutorial.c
os prints deste processo. * Author: ICSalgado
Agora vamos criar, dentro deste projeto o nosso *
programa principal, onde vamos escrever nosso * Created on 16 de Novembro de 2013, 04:38
codigo. */

Source Files>New>C Main File #include <stdio.h> // entradas e saidas padrão do C

#include <stdlib.h> // não lembro quais funções são
Clicar com o botão direito do mouse em Source Files. liberadas

Esta é a cara inicial do programa #include <p18f4550.h>// header especifico do 4550

/* #include <pic18.h>// header da familia 18
* File: tutorial.c
* Author: ICSalgado #include <delays.h>//Aciona a biblioteca de delay real
*
* Created on 16 de Novembro de 2013, 04:38 #include "adc.h" //conversor analógico digital
*/ #include "C:\headers\fuses\config_PIC18F4550.h"
//configura os fuses do pic
#include <stdio.h> #include "C:\headers\lcd\biblioteca_lcd_2x16.h"
#include <stdlib.h> //biblioteca padrão do lcd no PORTD

/* #include <xc.h> //não sei pq, mas tava no exemplo do

* professor de interrupções
*/
int main(int argc, char** argv) { #define Fosc 20 //define frequencia do oscilador

return (EXIT_SUCCESS); /*
} * Tentativa de ajuda
IC Salgado
 SM1 - Parobé

*/ 11. Prática 1 – Liga Led:

Criei o seguinte codigo para ser compilado e testado
posteriormente. O objetivo é ligar um LED no pino RA0
int main() do PORTA:
{ OBS: Como não vamos utilizar entradas analógicas
OpenADC (0x00, 0x00, ADC_0ANA);//Algo do nesta disciplina devemos desligar esta função par que
conversor analógico digital possamos utilizar os pinos AN como entradas e saidas
CloseADC ( );//só consigo usar os pinos AN com digitais. Observe os comentarios nos codigos:
isso /*
while(1) * File: tutorial.c
{ * Author: ICSalgado
*
} * Created on 16 de Novembro de 2013, 04:38
*/
return (EXIT_SUCCESS);
} #include <stdio.h> // entradas e saidas padrão do C
Podemos perceber que o MPLAB facilita um pouco a #include <stdlib.h> // não lembro quais funções são
nossa vida, abrindo e fechando os blocos de funções e liberadas
com cores diferentes.
#include <p18f4550.h>// header especifico do 4550
Bom este é o incio e todo programa que eu faço para #include <pic18.h>// header da familia 18
PIC segue este mesmo roteiro com este codigo, vem
dando certo até agora. #include <delays.h>//Aciona a biblioteca de delay real

Outra mania que tenho, e que acho válida é compilar o
programa toda hora, para saber se tem algo errado no
codigo que escrevi, fica mais facil de achar um erro se
você precisar verificar menos alterações entre cada
compilação.
Para compilar um programa no MPLAB podemos clicar
no martelinho na barra superior de ferramentas ou no
martelinho com a vassoura, ao lado do anterior.
IC Salgado
#include "adc.h" //conversor analógico digital
#include "C:\headers\fuses\config_PIC18F4550.h"
//configura os fuses do pic
#include "C:\headers\lcd\biblioteca_lcd_2x16.h"
//biblioteca padrão do lcd no PORTD
#include <xc.h> //não sei pq, mas tava no exemplo do
professor de interrupções
 SM1 - Parobé

12. Simulação:
#define Fosc 20 //define frequencia do oscilador Para simularmos esse programa na prática usaremos o
Software ISIS – PROTEUS, esse programa não é
#define led PORTAbits.RA0 //atribui a palavra led ao gratuito então é preciso compra-lo ou procurar
pino RA0 ‘soluções’ na internet.
- Em ‘devices’ clicamos no botão ‘P’ e procuramos pelo
/* PIC18F4550 e um LED – BLUE, ou de outra cor
* Tentativa de ajuda qualquer;
*/ - Clique duas vezes no componente encontrado e ele
aparecerá na barra de ferramentas lateral, depois
feche a janela de busca de componentes;
int main() - Clique em cima do componente desejado e depois
{ clique na area quadriculada o componente ira aparecer
TRISAbits.RA0 = 0x00; //define o pino RA0 como como sombra e com mais um clique ele fica onde for
saida desejado;
OpenADC (0x00, 0x00, ADC_0ANA);//Algo do - Posicione os componentes dentro do bloco quadrado
conversor analógico digital que aparece;
CloseADC ( );//só consigo usar os pinos AN com - Em ‘Terminals’ selecione ‘POWER’ e coloque proximo
isso do pino 1 do PIC (MCLR) e ‘GROUND’ proximo do
while(1) catodo do LED;
{ - Agora ligue os pontos entre os terminais;
led = 1; //atribui o valor 1 ao led que esta - Após, clique com o botão direito no POWER e em
conectado no pino RA0, este valor significa nivel alto string digite +5v;
} - Na simulação não é necessário o uso de resistores
limitadores de corrente para o led, mas na prática é
return (EXIT_SUCCESS); obrigatório o uso.
} - Agora vamos colocar o codigo HEX compilado dentro
do PIC clicando com o botão direito em cima do PIC,
Agora tente alterar os pinos e os ports para ligar este em Edit Properties, na pastinha ao lado de Program
led. File, depois encontre o programa com extensão .hex,
selecione e pronto, é só dar OK;
- Clique no Play e o LED deverá Acender.
IC Salgado

13. Função de Tempo:
O compilador XC8 traz uma biblioteca que trabalha
com os ciclos de funcionamento do PIC, que podemos
utilizar como delay.
Esta biblioteca é a <delays.h>.
Criei a segunte função que gera 1 segundo de delay:
int tempo(int t)// função gera delay de t segundos
{ //configura os fuses do pic
int i;//variavel de controle
for(i=0;i<t;i++)//contador de vezes de execução
{
Delay10KTCYx(500); // gera 1 segundo de delay
} professor de interrupções
}
Ao chamar a função mandamos o parametro t
indicando quantos segundos desejamos para delay.
14. Prática 2 – Pisca Led:
O seguinte codigo faz piscar o led na mesma
simulação anterior:
/*
* File: tutorial.c
* Author: ICSalgado
* int i;//variavel de controle
* Created on 16 de Novembro de 2013, 04:38
*/
#include <stdio.h> // entradas e saidas padrão do C
#include <stdlib.h> // não lembro quais funções são
liberadas
IC Salgado
SM1 - Parobé
#include <p18f4550.h>// header especifico do 4550
#include <pic18.h>// header da familia 18
#include <delays.h>//Aciona a biblioteca de delay real
#include "adc.h" //conversor analógico digital
#include "C:\headers\fuses\config_PIC18F4550.h"
#include "C:\headers\lcd\biblioteca_lcd_2x16.h"
//biblioteca padrão do lcd no PORTD
#include <xc.h> //não sei pq, mas tava no exemplo do
#define Fosc 20 //define frequencia do oscilador
#define led PORTAbits.RA0 //atribui a palavra led ao
pino RA0
/*
* Tentativa de ajuda
*/
int tempo(int t)// função gera delay de t segundos
{
for(i=0;i<t;i++)//contador de vezes de execução
{
Delay10KTCYx(500); // gera 1 segundo de delay
}
}
 SM1 - Parobé

int main() #include <stdio.h> // entradas e saidas padrão do C

{ #include <stdlib.h> // não lembro quais funções são
TRISAbits.RA0 = 0x00; //define o pino RA0 como liberadas
saida
OpenADC (0x00, 0x00, ADC_0ANA);//Algo do #include <p18f4550.h>// header especifico do 4550
conversor analógico digital #include <pic18.h>// header da familia 18
CloseADC ( );//só consigo usar os pinos AN com
isso #include <delays.h>//Aciona a biblioteca de delay real
while(1)
{ #include "adc.h" //conversor analógico digital
led = 1; //atribui o valor 1 ao led que esta #include "C:\headers\fuses\config_PIC18F4550.h"
conectado no pino RA0, este valor significa nivel alto //configura os fuses do pic
tempo(1); //gera um delay de 1 seundo #include "C:\headers\lcd\biblioteca_lcd_2x16.h"
led = 0; //desliga o led //biblioteca padrão do lcd no PORTD
tempo(1); //gera um delay de 1 seundo
} #include <xc.h> //não sei pq, mas tava no exemplo do
professor de interrupções
return (EXIT_SUCCESS);
} #define Fosc 20 //define frequencia do oscilador

15. Prática 3 – Liga led com botão: #define led PORTAbits.RA0 //atribui a palavra led ao
O seguinte codigo liga o led quando o botão está pino RA0
ligado. Lembrando que o LED deve ser configurado #define botao PORTAbits.RA1 // atribui a palavra botão
como saida e o botão deve ser configurado como ao pino RA1
entrada. /*
/* * Tentativa de ajuda
* File: tutorial.c */
* Author: ICSalgado
* int main()
* Created on 16 de Novembro de 2013, 04:38 {
*/ TRISAbits.RA0 = 0x00; //define o pino RA0 como
saida
IC Salgado
 SM1 - Parobé

TRISAbits.RA1 = 0xFF; // define RA1 como entrada * Created on 16 de Novembro de 2013, 04:38
OpenADC (0x00, 0x00, ADC_0ANA);//Algo do */
conversor analógico digital
CloseADC ( );//só consigo usar os pinos AN com #include <stdio.h> // entradas e saidas padrão do C
isso #include <stdlib.h> // não lembro quais funções são
while(1) liberadas
{
while(botao == 1) #include <p18f4550.h>// header especifico do 4550
{ #include <pic18.h>// header da familia 18
led = 1; //atribui o valor 1 ao led que esta
conectado no pino RA0, este valor significa nivel alto #include <delays.h>//Aciona a biblioteca de delay real
}
led = 0; // desliga o led #include "adc.h" //conversor analógico digital
} #include "C:\headers\fuses\config_PIC18F4550.h"
//configura os fuses do pic
return (EXIT_SUCCESS); #include "C:\headers\lcd\biblioteca_lcd_2x16.h"
} //biblioteca padrão do lcd no PORTD

16. Interrupções:
As interrupções são funções que tem prioridade maior
do que o codigo que esta rodando, quando ela é
chamado o programa para a execução do codigo
principal e executa a rotina de interrupção, ao fim desta
o programa volta ao codigo principal.
Elas podem ser de alta e baixa prioridade e existem
pinos especificos para as interrupções externas.
O seguinte programa implementa interrupções de alta
e baixa prioridade.
/*
* File: tutorial.c
* Author: ICSalgado
* de interrupção
IC Salgado
#include <xc.h> //não sei pq, mas tava no exemplo do
professor de interrupções
#define Fosc 20 //define frequencia do oscilador
#define led PORTAbits.RA0 //atribui a palavra led ao
pino RA0
#define ledint1 PORTAbits.RA1 // atribui a palavra
ledint1 ao pino RA1
#define ledint2 PORTAbits.RA2 // atribui a palavra
ledint2 ao pino RA2
#define int1 PORTBbits.RB1 // define RB1 como botão
 SM1 - Parobé

#define int2 PORTBbits.RB2 // define RB2 como botão {

de interrupção while(int2 == 0)
/* {
* Tentativa de ajuda //pisca led 2 quando a interrupção é ativada
*/ ledint2 = 1;
tempo(1);
int tempo(int t)// função gera delay de t segundos ledint2 = 0;
{ tempo(1);
int i;//variavel de controle }
for(i=0;i<t;i++)//contador de vezes de execução INTCON3bits.INT2IF = 0; // Limpa o flag bit da
{ interrupção externa INT1
Delay10KTCYx(500); // gera 1 segundo de delay }
}
} void config_int(void) {
RCONbits.IPEN = 1; // Habilita interrupção com nível
void interrupt int_alta(void) // interrupção de alta de prioridade. End 0x08 - alta e 0x18 - baixo
prioridade - botão liga desliga INTCONbits.GIEH = 1; // Habilita todas as
{ interrupções de alta prioridade
while(int1 == 0) INTCONbits.GIEL = 1; // Habilita todas as
{ interrupções de baixa prioridade
// pisca led 1 quando a interrupção é acionada }
ledint1 = 1;
tempo(1); void config_int1(void) {
ledint1 = 0; INTCON3bits.INT1IE = 1; // Ativa a inerrupção
tempo(1); externa INT1 (RB1)
} INTCON3bits.INT1IF = 0; // Limpa o flag bit da
INTCON3bits.INT1IF = 0; // Limpa o flag bit da interrupção externa INT1
interrupção externa INT1 INTCON3bits.INT1IP = 1; // Define como "Alta
} prioridade"
INTCON2bits.INTEDG1 = 0; // Interrupção externa
void interrupt low_priority int_baixa(void) // interrupção INT1 na borda de descida
de baixa prioridade - tampa }
IC Salgado
 SM1 - Parobé

void config_int2(void) {
INTCON3bits.INT2IE =
externa INT2 (RB2)
INTCON3bits.INT2IF =
interrupção externa INT2
INTCON3bits.INT2IP =
prioridade"
INTCON2bits.INTEDG2
INT2 na borda de descida
}
led = 0;
tempo(1);
1; // Ativa a inerrupção }
0; // Limpa o flag bit da return (EXIT_SUCCESS);
}
0; // Define como "Baixa
= 0; // Interrupção externa

int main()
{
TRISA = 0x00; //define PORTA como saida
TRISB = 0xFF; //define PORTB como entrada

config_int(); // configura os tipo de interrupção

config_int1(); // configura e incializa a int 1
config_int2(); // configura e incializa a int 2

ei(); // inicializa o serviço de interrupções

OpenADC (0x00, 0x00, ADC_0ANA);//Algo do

conversor analógico digital
CloseADC ( );//só consigo usar os pinos AN com
isso
while(1)
{
//pisca led
led = 1;
tempo(1);
IC Salgado