Microcontroladors PIC - Linguagem C

Índice

Introdução -------------------------------------------------------------------------- Linguagem C --------------------------------------------------------------------- Microcontrolador ---------------------------------------------------------------Estrutura Interna do 18F452 -----------------------------------------------------Função de cada pino do 18F452 ------------------------------------------------Mapa de Registradores Especiais ----------------------------------------------Princípio de Programação --------------------------------------------------------Introdução à Linguagem C -------------------------------------------------------- Representação numérica --------------------------------------------------------- Tipos de dados -------------------------------------------------------------------- Variável local e global ----------------------------------------------------------- Operadores matemáticos --------------------------------------------------------- Controle de Fluxo ----------------------------------------------------------------- Decisão IF -------------------------------------------------------------------------- Decisão IF-ELSE ------------------------------------------------------------------- Decisão SWITCH-CASE --------------------------------------------------------- Loop FOR --------------------------------------------------------------------------- Loop WHILE ----------------------------------------------------------------------- Loop DO-WHILE ------------------------------------------------------------------ Ponteiros e Matrizes --------------------------------------------------------------- Introdução ao MikroC ------------------------------------------------------------- Ambiente MikroC ------------------------------------------------------------------ Criando um Projeto ---------------------------------------------------------------- Device Flags (bits de configuração) --------------------------------------------- Primeiro Projeto -------------------------------------------------------------------- Programa 1 – Configuração das portas ------------------------------------------ Gravando o Primeiro Projeto ----------------------------------------------------- Usando o Debug no MikroC ------------------------------------------------------ Programa 2 – Uso do Define ------------------------------------------------------ Programa 3 – Acionamento de Botões ------------------------------------------- Programa 4 – Utilização do IF-ELSE -------------------------------------------- Programa 5 – Utilização do IF_ELSE -------------------------------------------- Programa 6 – Utilização do IF-ELSE-IF ----------------------------------------- Programa 7 – Função Button ------------------------------------------------------- Programa 8 – Eliminando Problema do Debounce ----------------------------- Declaração de Funções ------------------------------------------------------------- Display LCD ------------------------------------------------------------------------- Comandos do LCD ------------------------------------------------------------------ Configuração Modo 4 e Modo 8 Bits --------------------------------------------- Programa 9 – Transmissão de mensagem para LCD ------------------------- Programa 10 – Transmissão de mensagens para LCD -------------------------- Configurações do LCD em 4 Bits e 8 Bits --------------------------------------- Módulo PWM ------------------------------------------------------------------------ Programa 11 - Utilização do CCP1 ----------------------------------------------- Programa 12 - Utilização do CCP2 ----------------------------------------------- Programa 13 – Utilizando os Módulos CCP1 e CCP2 ------------------------1 3 3 4 5 6 8 10 11 11 12 13 14 14 15 15 17 18 18 19 20 21 22 23 24 29 30 32 35 39 40 41 42 43 44 45 46 48 49 50 51 52 53 54 55 55 56

- Programa 14 – Ajustando os Módulos usando botões -------------------------- Conversor A/D ----------------------------------------------------------------------- Programa 15 – Leitura do Canal AN0 (0 a 1023) ------------------------------- Programa 16 – Leitura do canal AN0 (0 a 5V) ---------------------------------- Programa 17 – Leitura do Canal A/D com ponto flutuante -------------------- Programa 18 – Controle PWM usando conversor A/D ------------------------- Comunicação Serial ----------------------------------------------------------------- Programa 19 – Transmissão de dado Serial -------------------------------------- Programa 20 – Transmissão/Recepção Serial ------------------------------------ Programa 21 – Transmissão/Recepção de Dados-------------------------------- Programa 22 - Uso de Ponteiros na Transmissão de Dados -------------------- Programa 23 – Transmissão de Dados -------------------------------------------- Programa 24 – Leitura de Temperatura e Transmissão Serial ----------------- Programa 25 – Leitura de Temperatura, Comparação e Acionamentos ------ Programa 26 – Configuração do TIMER0 em 8 bits – Temporizador ------- Programa 27 – Configuração do TIMER0 em 16 bits – Temporizador ----- Programa 28 – Configuração do TIMER0 em 8 bits – Contador ------------- Programa 29 – Memória EEPROM do PIC -------------------------------------- Introdução a Interrupção ------------------------------------------------------------ Registrador RCON ------------------------------------------------------------------ Registrador INTCON ---------------------------------------------------------------- Registrador INTCON2 ---------------------------------------------------------------- Registrador INTCON3 ---------------------------------------------------------------- Registrador PIE1 ----------------------------------------------------------------------- Registrador PIE2 ----------------------------------------------------------------------- Registrador PIR1 ----------------------------------------------------------------------- Registrador PIR2 ----------------------------------------------------------------------- Registrador IPR1 ----------------------------------------------------------------------- Registrador IPR2 ----------------------------------------------------------------------- Estrutura de Programa utilizando Alta e Baixa Prioridade ----------------------- Programa 30 – Tratamento de Interrupção INT0 ---------------------------------- Programa 31 – Tratamento de Interrupção INT0 e INT1 ------------------------ Programa 32 – Tratamento de Interrupção INT0 e INT1 com Prioridade -----

57 58 63 64 65 66 67 67 68 69 70 71 73 74 79 80 81 82 84 85 86 87 88 89 90 91 92 93 94 94 95 97 99

2

Introdução:
Linguagem C Linguagem C foi desenvolvida por Brian Kernighan e Dennis M. Ritchie na década de 70 no AT&T Bell Labs. Em pouco tempo, esta linguagem teve grande utilização em Universidades espalhadas pelo Mundo, tornando-se praticamente oficial em cursos de engenharias. É uma linguagem estruturada, eficiente, rápida e tão poderosa quanto a Linguagem Assembly. A cada ano vem aumentando o número de programadores de Microcontroladores que acabam migrando da Linguagem Assembly para o C. Os programas em C acabam ficando muito mais eficientes e mais rápidos de serem escritos pois os Compiladores de Programas em Linguagem C para Microcontroladores possuem várias bibliotecas de funções prontas como Comunicação Serial, ADC, EEPRON, I2C, PWM, LCD, etc. Existe no mercado vários compiladores para desenvolvimento de programas na Linguagem C como Hi-Tech, CCS, PICmicro C, etc. Adotamos para nosso treinamento o compilador MikroC da Microelektronika por ser bastante poderosa e fácil de trabalhar (permite Editar, Simular e Compilar programas das famílias 12, 16 e 18 da Microchip) além de também possuir uma vasta biblioteca de controle de periféricos dos Microcontroladores. Além disso, a versão estudante é gratuito para desenvolvimento de programas de até 2Kwords, o que torna bastante atraente também para uso educacional. Pode-se fazer download em www.mikroe.com. Contudo, uma das grandes vantagens de se programar em C é que o programador não precisa se preocupar com o acesso a bancos, localização de memória e periféricos dos Microcontroladores pois o Compilador é responsável por gerenciar esses controles. Toda essa eficiência da Linguagem C proporciona ao programador preocupar-se apenas com o programa em si e o compilador traduz da Linguagem C para a Linguagem de máquina (.HEX) que é a linguagem que os Microcontroladores conseguem entender.

3

Memória EEPROM – 256 bytes. sistemas de alarme e controle de acesso. 4 . . Existe também uma vasta literatura orientando profissionais e estudantes quanto às aplicações e projetos. . Conversores Analógico/Digital e Controle PWM são alguns exemplos de utilização em equipamentos suportados por microcontroladores. etc.000 de ciclos de escrita/leitura na EEPROM. Displays e matrizes de leds.Memória de Programa Flash – 32K . .8 canais A/D de 10 Bits. . .Módulo MSSP (Master Synchronous Serial Port). . médica. Agora é com você programador que têm a habilidade de verificar a necessidade e proporcionar então a funcionalidade de determinado aparelho/sistema através de um sistema microcontrolado. Microchip. Vejamos alguns exemplos de equipamentos: celulares. . compare e PWM. Comunicação Serial. .Possibilita interrupção externa através de pinos do Microcontrolador. Motorola.Retenção dos dados na memória por até 40 anos.Possibilita 1.Possibilita habilitação do Watchdog Timer. etc. Aplicaçõs com Dislays LCD (Display de Cristal Líquido). A Uptex decidiu pela Microchip pois a mesma encontra-se entre os mais utilizados mundialmente além de também oferecer muitos de seus compiladores gratuitamente.000. agricultura e muitas mais. aeroespacial. O Microcontrolador que iremos trabalhar será o 18F452 da Microchip. Atmel.Módulo USART .40 pinos podendo ter até 34 I/O (Input/Output digital). A grande vantagem é que possui memória Flash. Abaixo temos principais características do 18F452: .Possibilita até 100. possibilitando assim escrever/apagar com grande rapidez. É só verificarmos os equipamentos hoje microcontrolados e pensarmos na evolução que existe e tudo ainda que possa a vir a existir. máquinas de lavar/secar roupas.Memória RAM – 1536 bytes. USB. O programador poderá escolher entre Intel. . . Existem muitas aplicações também na área automobilística.000 ciclos de escrita/leitura na memória de programa. . iluminação residencial. brinquedos. .Microcontrolador Hoje existe uma grande quantidade de Microcontroladores utilizados em projetos de equipamentos eletroeletrônicos.02 Módulos CCP – capture.4 Temporizadores/Contadores.velocidade de processamento – até 10MIPS (milhões de instruções por segundo). Isto tudo pode ser verificado no site da Microchip em (Aplication Notes).

Estrutura Interna do PIC 18F452 5 .

UART. 32 VCC 12. Módulo CCP. Escrita da Porta Paralela e entrada do AD6 I/O digital. PORTB. Leitura da Porta Paralela e entrada do AD5 I/O digital. Saída do Cristal e saída do Clock externo I/O digital. 31 GND 13 OSC1 / CLK1 14 15 Osc2 / CLK1 / RA6 RC0/T10S0/T1Ck1 6 . I2C. entrada do AD3 e entrada de referência alta do A/D I/O digital e entrada do TMR0 I/O digital. Interrupções. entrada do AD2 e entrada baixa de referência do A/D I/O digital. Seleção da Porta Paralela e entrada do AD7 Positivo da Fonte de Alimentação Negativo da Fonte de Alimentação Entrada do Cristal e entrada do Clock externo I/O digital. entrada do AD4. saída do 2° oscilador e entrada do contador externo Timer1/Timer3 11.Função de cada pino do 18F452 O PIC 18F452 possui cinco PORTs: PORTA. PORTD e PORTE. SPI. PORTC. Pino 1 2 3 4 5 6 7 8 9 10 Função /MCLR / VPP RA0 / AN0 Tipo In-In I/O e input A/D RA1 / AN1 I/O e input A/D RA2 / AN2/ VrefI/O e input A/D RA3/AN3/ Vref+ I/O e input A/D RA4 / T0CKI I/O e Input TMR0 RA5/AN4/SS/LVDIN I/O e Inputs RE0 / RD / AN5 RE1 / WR / AN6 RE2 / CS / AN7 I/O I/O I/O Fonte Fonte Input I/O e Inputs I/O Out e In Funcionalidade Reset externo e programação ICSP I/O digital e entrada do AD0 I/O digital e entrada do AD1 I/O digital. Cada PORT possui pinos com acesso aos periféricos como Conversor Analógico/Digital. ou podem ser utilizados como I/O de uso geral. entrada do SPI e Detector de LV I/O digital.

Interrupção por Mudança de Estado e ICSP in-circuit Debuger 7 . Interrupção por Mudança de Estado e ICSP in-circuit Debuger I/O digital. entrada de Dados SPI e in/out de dados do modo I2C I/O digital e saída de dados SPI I/O digital. Interrupção por Mudança de Estado e Habilita ICSP baixa tensão I/O digital. Recepção UART e Dados do UART I/O digital e Porta de Comunicação Paralela I/O digital e Porta de Comunicação Paralela I/O digital e Porta de Comunicação Paralela I/O digital e Porta de Comunicação Paralela I/O digital e entrada de Interrupção Externa 0 I/O digital e entrada de Interrupção Externa 1 I/O digital e entrada de Interrupção Externa 2 I/O digital Módulo CCP2 I/O digital e entrada de Interrupção por Mudança de Estado I/O digital. entrada do 2° oscilador e saída do Módulo CCP2 I/O digital e saída do Módulo CCP1 I/O digital. Transmissão UART e Clock de sincronismo UART I/O digital. in e out do Clock serial para modo SPI e in/out do Clock serial para modo I2C I/O digital e Porta de Comunicação Paralela I/O digital e Porta de Comunicação Paralela I/O digital e Porta de Comunicação Paralela I/O digital e Porta de Comunicação Paralela I/O digital.16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 33 34 35 36 37 38 39 40 RC1/T10S1/CCP2 RC2 / CCP1 Rc3 / SCK / SCL RD0 / PSP0 RD1 / PSP1 RD2 / PSP2 RD3 / PSP3 RC4 / SDI / SDA RC5 / SD0 RC6 / TX / CK RC7 / RX / DT RD4 / PSP4 RD5 / PSP5 RD6 / PSP6 RD7 / PSP7 RB0 / INT0 RB1 / INT1 RB2 / INT2 RB3 / CCP2 RB4 RB5 / PGM RB6 / PGC RB7 / PGD I/O In e Out I/O e Out I/O. I/O e I/O I/O e I/O I/O e I/O I/O e I/O I/O e I/O I/O in I/O I/O e out I/O out I/O I/O in I/O I/O e I/O I/O e I/O I/O e I/O I/O e I/O I/O e in I/O e in I/O e in I/O e I/O I/O e in I/O in e in I/O in I/O I/O in I/O I/O digital.

etc. Temos também os SFR(Special Funcion Registers) que são os Registradores de uso específico que na verdade contém o SETUP do Microcontrolador – configura como irão trabalhar determinados periféricos como PWM. O Microcontrolador 18F452 possui memória RAM de 1536 bytes sendo dividido em 16 bancos de 256 bytes de memória cada um. Conversores A/D. USART. Mapa de Registradores Especiais – SFRs 8 .Nos Microcontroladores PIC temos os GPR (General Porpose Registers) que são os registradores de usos gerais que nada mais são do que variáveis criadas pelo programador – dados voláteis.

o TRISC pelo PORTC. para podermos configurar como irá trabalhar cada pino de cada porta. Vejamos um exemplo: TRISB=0b00001100. o TRISB pelo PORTB.Temos então Portas: PORTA à PORTE e cada pino de cada porta pode ser configurado como entrada ou saída. Neste caso temos todo o PORTD configurado como entrada Outro exemplo: TRISC=0b00000000. temos que fazer uso do SFR – TRIS. No entanto. Neste caso temos todo o PORTC configurado como saída Os outros Registros Especiais iremos entender conforme andamento do curso. O Registrador TRISA é responsável pela configuração do PORTA. É muito simples. 9 . Neste caso temos: RB0=saída RB1=saída RB2=entrada RB3=entrada RB4 à RB7 = saída Outro exemplo: TRISD=0b11111111. o TRISD pelo PORTD e o TRISE pelo PORTE. se colocarmos 0 no bit do TRIS estamos definindo determinado pino como saída e colocando-se 1 no bit do TRIS estamos definindo o pino do PORT como entrada.

Temos então as operações E ou AND. OU ou OR e Não ou NOT e também NAND.Princípio de Programação: A Álgebra de Boole e seus operadores são muito utilizados em sistemas digitais e também na programação em Linguagens como o Assembly e também a Linguagem C. OR A 0 0 1 1 B 0 1 0 1 S 0 1 1 1 S 0 0 0 1 AND A B 0 0 0 1 1 0 1 1 NOT A S 0 1 1 0 NOR A B 0 0 0 1 1 0 1 1 NAND A B 0 0 0 1 1 0 1 1 XOR A B 0 0 0 1 1 0 1 1 S 1 1 1 0 S 1 0 0 0 S 0 1 1 0 10 . NOR ou XOR ( OR EXCLUSIVO).

Octal: Teste=075. Portb=0xFF. Utilizamos // para comentários em apenas uma linha. no entanto. 11 . /* ------------------------------------------------abaixo temos um exemplo de estrutura Básica de um programa em Linguagem C ----------------------------------------------------. } // esta é a primeira função que será executada // inicializa a função // aqui entram os comandos que serão executados // finaliza a função Observações: Toda função deve iniciar abrindo chave e finalizar fechando-se a chave. String: Unsigned char *texto=”Uptex Tecnologia” Caracter: Usart_write(‘&’). Toda instrução deve ser finalizada com ponto e vírgula (obrigatoriamente) Logo após /* são inseridos os comentários para múltiplas linhas e deve-se Colocar */ para fechar o bloco de comentários.*/ void main() { Trisb=0x00. Hexadecimal: Variável1=0xA4.Introdução à Linguagem C Estrutura Básica de um programa: Programas em C são baseados em uma ou mais funções que serão executadas. Representação Numérica: Decimal: Contador=125. Binário: Portb=0b11010011. a função Main() é a primeira a ser executada.

Tipos de Dados: Dado: int char float e double void Tipo Void Char Int Short Long Float Double Modificadores: Tipo Char signed char unsigned char Short int signed short int unsigned short int Int signed unsigned int Short signed short unsigned short long int signed long int unsigned long int Tipo: Números inteiros Caracteres Números decimais (ponto flutuante) valores nulos Tamanho – bits Zero 8 16 16 32 32 64 Tamanho - bits 8 8 8 8 8 8 16 16 16 16 16 16 32 32 32 Valor Mínimo Sem valor -128 -32768 -32768 -231 -3,4 x 1038 -1,8 x 10308 Valor Mínimo -128 -128 0 -128 -128 0 -32768 -32768 0 -32768 -32768 0 -231 -231 0 Valor Máximo Sem valor 127 32767 32767 231-1 3,4 x 1038 1,8 x 10308 Valor Máximo 127 127 255 127 127 255 32767 32767 65535 32767 32767 65535 231-1 231-1 232-1

12

Declaração de variáveis: Podemos declarar da seguinte maneira: <qualificador> + <tipo> + <nome da variável> + <valor>; Obs: valor pode ou não necessariamente ser inicializado. Exemplos: int contador; short var1; unsigned int contagem = 30500; Observe agora como atribuir valores às variáveis: Contador = 10; Var1 = 25; Variável local: Esta é declarada dentro da função e só pode ser utilizada pela função portanto, é uma variável temporária. Exemplo: void subrotina_soma () { unsigned Int valor1, valor2; valor1=A; valor2=B; return(valor1+valor2); } Variável Global: Esta é declarada fora da função e só pode ser utilizada por qualquer função em qualquer momento. Todas as funções têm acesso às variáveis globais. Exemplo: unsigned int valor1, valor 2 void subrotina_soma () { valor1=A; valor2=B; return(valor1+valor2); } // atribui o valor 10 à variável contador // atribui o valor 25 à variável Var1

13

Operadores Matemáticos: Aritméticos: Operador + * / % ++ -Descrição Soma dos argumentos Subtração dos argumentos Multiplicação dos argumentos Divisão dos argumentos Resto da divisão Soma 1 ao argumento (a=a+1) Subtrai 1 ao argumento (a=a-1) Exemplo a+b a–b a*b a/b a%b a++ a--

Relacionais: Operador > < >= <= == != Lógicos: Operador && || ! Descrição Lógica E (AND) Lógica OU (OR) Complemento (NOT) Descrição Maior que Menor que Maior ou igual que Menor ou igual que Igual Diferente

Operadores bit a bit: Operador & | ^ ~ >> << Descrição Lógica E (AND) Lógica ou (OR) Lógica OU-Exclusivo Complemento (NOT) Deslocamento à direita Deslocamento à esquerda

14

} 15 . comando2. comando5. comando3. else comando2. A expressão é avaliada e se for verdadeiro executa o comando. comando2. Se comando for verdadeiro. comando1 é executado.Controle de Fluxo: Decisão IF: Sintaxe: if (expressão) comando. comandoN. Podemos ter também mais que um comando: Sintaxe if (expressão) { comando1. temos duas possibilidades. } else { comando4. } Exemplo: If (conta == 5) { a=a++. Podemos ter também vários comandos: if (expressão) { comando1. portc=0xFF. comando2 será executado. } Decisão IF-ELSE: Sintaxe: if (expressão) comando1. caso seja falso. Neste caso.

} else if (contador>12) { Dúzia = 0. } else { comando4. y=contador+10. y--. comando5. } 16 . } else if (contador<12) { Dúzia=0. } else if (expressão2) { comando2. comando3. } else { Valor2=x. if (expressão1) { comando1. Y=contador-5. Z++. } Exemplo: if (contador==12) { Dúzia++.Exemplo: if (a>22) { Valor1=x. X++. } Podemos ainda ter superposição de comandos if-else podendo assim ter uma escolha entre várias possibilidades.

default: comando6. break. comando2. int valor=5. break.CASE: switch (variável) { case valor1: comando1. comando4. default: valor=5. break.Decisão SWITCH . case 5: valor--. break. switch (contagem) { case 2: valor++. case valor2: comando3. } } 17 . case 10: valor=0. comando5. break. } //opcional Exemplo: void main( ) { int contagem=4.

o loop é finalizado. Podemos também ter um bloco de comandos: for (inicialização. Sintaxe: for (inicialização. } Loop While: Neste caso. 18 . o loop é repetido enquanto a expressão for verdadeira. condição (término). incremento) comando. os comandos serão executados. incremento) { comando1. Sintaxe: while (expressão) { comando1. contador++) a=a+contador. } É feita a avaliação no início do loop e. comandoN. enquanto verdadeira. for (contador=0. comando2. volta a ser testada a expressão e caso seja falsa. comando2. Ao término do último comando.Loop FOR: Este é um comando de laço (loop ou repetição). int a = 0. contador<=10. condição (término). } Exemplo: void main () { int contador.

} while (expressão).WHILE: Neste caso. diferente do loop anterior (while). } while (a<100). o do . delay_ms(100).while executa pelo menos uma vez o bloco de comando antes de fazer a avaliação se continua a executar os comandos ou sai do loop. Exemplo: void main( ) { int a=0.Exemplo: void main( ) { int a=15. Sintaxe: do { comando1. While (a>10) { a--. do { a++. delay_ms(100). } 19 . comando2. } } Loop DO .

esta matriz pode armazenar 28 valores do tipo int. Sintaxe: int notas_classe={25. Sintaxe: tipo *nome tipo é um tipo de dado e nome é o nome da variável. esta matriz pode armazenar 50 valores do tipo float.50} 20 . float velocidade[50]. Aguarde! Matrizes: É uma estrutura de dados que pode armazenar vários valores de mesmo tipo. Sintaxe: Tipo Nome [quantidade]. Tipo é o tipo de dado a ser colocado na matriz. Primeiro elemento é velocidade[0] e último elemento é velocidade[49].57. Uso de ponteiros será utilizado quando estudarmos comunicação serial. Exemplo: int notas_sala[28]. o ponteiro é um apontador para outra variável.95. Podemos também inicializar os elementos de uma matriz. Quantidade é o número de itens que serão armazenados na matriz. Exemplo: int *idade. ou seja. Obs: todos os dados devem ser do mesmo tipo. Nome identifica a matriz.Ponteiros: Podemos afirmar que um ponteiro é na verdade uma variável onde será armazenado o endereço de outra variável.68.

PWM Library . Este Software pode ser baixado no site www.com e sua versão free possui limite de 2K words.SPI Ethernet Library .14.PS2 Library .CAN Library .16 e 18 da Microchip.UART Library .I2C Library .USB Library Bibliotecas ANSI C Stardard Demais Bibliotecas .LCD Library . Caso ultrapasse este valor.One Wire Library .ADC Library . Neste compilador encontramos uma vasta biblioteca de Funções: . É composto de um IDE (Sistema Integrado de Desenvolvimento) abrangendo toda a linha dos PICs das famílias 12.Trigonometry Library .Time Library 21 .Introdução ao MikroC: O MikroC é um compilador desenvolvido e também comercializado pela empresa MikroElektroniKa. é necessário adquirir a versão full junto ao fabricante.mikroe.EEPRON Library .Ethernet Library .RS485 Library .CANSPI Library .SPI Library .

Ambiente MikroC: Abaixo segue a tela inicial do compilador MikroC onde iremos desenvolver nossos projetos. 22 .

Para isso. Device é escolhido o microcontrolador utilizado pelo projeto. Description é opcional. Teremos então a tela abaixo aberta: Project Name coloca-se o nome do projeto. Project Path coloca-se a pasta onde será gravado o projeto. Clock é informado qual a freqüência que o microcontrolador irá trabalhar.Criando um Projeto: Para iniciar o desenvolvimento necessitamos inicialmente criar um projeto pois o compilador trabalha com esta concepção. 23 . basta clicar em <Project> e em seguida <New Project>. é onde pode ser feita uma descrição sobre o que faz o projeto.

etc. Código de proteção. O PIC 18F452 pode funcionar com os seguintes tipos de clock: LP XT HS HS + PLL RC RCIO EC ECIO cristal de baixa freqüência cristal ou ressonador cristal ou ressonado de alta freqüência Cristal ou ressonador com PLL habilitado Resistor e capacitor externo Resistor e capacitor externo e liberação de 1 pino de I/O Clock externo Clock externo e liberação de 1 pino de I/O Valores de capacitores que devem ser acoplado ao cristal: 24 .Device Flags: (fusíveis ou bits de configuração) É o local onde podemos configurar várias funções através de bits de configuração. Clock: PIC 18F452 Resistor RS pode ser necessário para melhor funcionamento do cristal. habilitar WatchDog. Funções estas que podem ser tipo de oscilador.

Modo: RC externo com liberação do pino com ciclo de máquina Configuração RC Clock externo com liberação de pino de I/O 25 .

Clock externo com liberação de um pino com clock – ciclo de máquina Configuração EC Clock externo com liberação de pino de I/O – Configuração ECIO Modo: HS + PLL Neste caso. teremos a freqüência do Cristal multiplicado por 4. Por exemplo. para um cristal de 10MHz teremos a freqüência de trabalho em 40MHz. 26 .

Com isso pode-se emular o programa desenvolvido na placa de testes. o pino RA5 não poderá mais ser utilizado como I/O. 1:8. 2.5V. 27 . é possível deixar o MCLR em 5V e fazer a gravação mas.PWRTEN (system clock switch bit) É o temporizador de Power-Up que faz o microcontrolador aguardar certo tempo assim que o chip é energizado. 1:64 e 1:128. BOREN Este bit é responsável por habilitar/desabilitar o Brown-out. tempo ideal para que o circuito oscilador estabilize sua freqüência. A função do watchdog é não deixar o programa travado. BKBUG (Debug) Este bit habilita o modo Debugger do PIC.5V no pino MCLR. porém. Imagina que por algum motivo o programa trava ou entra em algum loop infinito. Um temporizador de 8 bits que não pode estourar pois caso isso ocorra o programa será resetado. WDTEN – Watchdog Timer Enable Aqui temos um recurso bastante interessante.0V. O usual é colocar tensão de 13. o programa é reiniciado. LVP (low voltage programming) Temos aqui uma opção de poder gravar o Microcontrolador com 5V. 1:2. Para CCP2MX=0 usaremos pino RC1 para CCP2 Para CCP2MX=1 usaremos pino RB3 para CCP2 STVREN (Stack Full / Underflow Reset Enable Bit) O Microcontrolador 18F452 possui 31 endereços de pilha.7V. 1:16. BROW-OUT detector É um interessante circuito para resetar o Microcontrolador caso ocorra uma queda de tensão no mesmo. No entanto. Podemos escolher os seguintes limites de tensão: 2. Restabelecido a tensão. CCP2MX Este bit tem a função de Multiplexar o módulo CCP2. Portanto. Watchdog postscale select bit O tempo padrão de estouro do watchdog é 18ms. Este tempo é de 72ms deixando assim o microcontrolador inoperante. esta função ativa faz com os pinos RB6 e RB7 deixam de funcionar como I/O. 1:4. 1:32. 4. podemos modificar este tempo modificando o fator de divisão: 1:1.2V ou 4. Este bit serve para habilitar o chip para ser resetado caso a limite da pilha seja ultrapassado.

Code Protect 0x0200 a 0x1FFF Habilitando este bit, a região de memória de 0x0200 a 0x1FFF fica protegida contra leitura. Code Protect 0x2000 a 0x3FFF Habilitando este bit, esta região de memória fica protegida contra leitura. Code Protect 0x4000 a 0x5FFF Habilitando este bit, esta região de memória fica protegida contra leitura. Code Protect 0x6000 a 0x7FFF Habilitando este bit, esta região de memória fica protegida contra leitura. Data EE Read Protect Este bit protege os 256 bits de memória EEPROM contra leitura. Code Protect Boot Este bit habilitado, protege a região de memória de boot(memória de programa – 0x0000 à 0x0FF0). Table Write Protect Cada bit habilitado protege um range contra escrita por tabela. - 0x0200 à 0x1FFF - 0x2000 à 0x3FFF - 0x4000 à 0x5FFF - 0x6000 à 0x7FFF Data Write Protect Este bit habilitado protege contra escrita os 256 bytes da EEPROM Table Write Protect Boot Este bit habilitado protege a área de boot contra escrita por tabela. Config Write Protect Este bit habilitado protege a área de boot contra escrita. Table Read Protect Cada bit habilitado protege um range contra leitura por tabela. - 0x0200 à 0x1FFF - 0x2000 à 0x3FFF - 0x4000 à 0x5FFF - 0x6000 à 0x7FFF

28

Primeiro Projeto: Inicialmente deve-se criar um projeto onde : Project Name: Pisca-Pisca Project Path: C:/Pasta_aluno Description: Programa circuito oscilador – pisca-led RD0 Device: P18F452 Clock: 004.000000 Device Flags: _XT_OSC, _PWRT_ON, _WDT_OFF, _LVP_OFF, _CP_OFF

Circuito:

29

Devemos então escrever o código e compilar o projeto para assim poder gravar o programa no Microcontrolador.

/********************************************************************** Uptex Tecnologia & Treinamento Ltda Curso de Microcontroladores PIC Linguagem C – Compilador MikroC Programa 1 Objetivo: Configuração das Portas e acesso das mesmas usando funções de tempo *********************************************************************/ void main ( ) { trisd = 0; //configura todo o portd como saída portd = 0; // todo o portd é colocado em nível zero while(1) //loop infinito { portd.f0=1; //ativa saída RD0 delay_ms(5000); //aguarda 5 segundos portd.f0=0; //desativa saída RD0 delay_1sec( ); //aguarda 1 segundo } }

30

para compilar basta pressionar “CTRL + F9” ou. 31 . clicar em Menu Project e em seguida a opção Build. conforme figura abaixo: Não apresentando nenhum erro.Uma vez escrito o programa. na tela de mensagens deverá aparecer o seguinte mensagem na cor verde: SUCCESS ( Release Build) Esta mensagem garante que o programa foi compilado e que foi gerado o código de máquina para ser gravado no Microcontrolador (arquivo.HEX).

precisamos ainda configurar o ICPROG para o correto funcionamento com a placa CUSCOPIC. 32 .Gravando o Projeto: O Programa ICPROG será utilizado para gravar o programa no Microcontrolador. Primeira coisa a se fazer é selecionar o Chip – PIC18F452 Porém. Interface Direct I/O e em comunicação deve-se Inverter o MCLR. clica-se em Configuração. opção Hardware e selecione o programador (TAIT SERIAL PROGRAMMER). Para isso.

Gravando o Programa: Para gravar o programa no Microcontrolador . clica-se em abrir e carrega o programa no ICPROG e em seguida pressionamos o botão “Programar Tudo”. Pressionamos o botão “LIMPAR TUDO” para certificarmos que não tem nada gravado no PIC.Limpar Tudo: Usado para limparmos o conteúdo gravado no Microcontrolador. Então.Ler Tudo: Usado para leitura do conteúdo gravado no Microcontrolador. 33 .Verificar: Usado para fazer uma comparação do conteúdo gravado no Microcontrolador com o programa aberto. .Programar Tudo: Usado para gravarmos o programa no Microcontrolador. .Identificação dos botões: . é necessário inicialmente limpar o conteúdo do mesmo. .

Agora é só testar.Aparece ainda a seguinte mensagem e confirmamos: Após o término da gravação. se tudo deu certo aparecerá seguinte mensagem: OK! O programa já está gravado no PIC. 34 .

Desenvolver um circuito oscilador que gere uma onda sendo Ton de 70%. Quando todos estiverem acesos segue apagando do RD7 a RD0 com intervalo agora de 250ms até apagar todos e reinicia o processo. O tempo total do ciclo será de 100 mili-segundos.Exercícios: . . . Verifique o sinal utilizando o osciloscópio.Desenvolver um programa que gere uma onda quadrada em RD5 na freqüência de 1KHz. 35 .Fazer um programa onde os leds devem ser acesos na seguência RD0 a RD7 no intervalo de 500ms.

seleciona-se o registrador que deseja visualizar e clica-se em “Add”. a janela abaixo será apresentada: Em “Select Variable from list.Usando Debug no MikroC: Ao clicar no Menu “RUN” e selecionado “START DEBUGGER”. 36 .

37 .

(Debugger). 38 .Para dar início à simulação.Step Over .Stop Debugger . deve-se clicar no botão conforme figura abaixo ou. pressionando a tecla “F9”.Run/Pause Debugger .Step Out . “F6” = inicia modo Run.Step Into (F6). se desejar. (F4). . (F7).Run to Cursor . (Ctrl + F12). (F8). Temos também as teclas: “F7” = faz simulação passo a passo. (Ctrl + F8).

led1=0./********************************************************************** Uptex Tecnologia & Treinamento Ltda Curso de Microcontroladores PIC Linguagem C – Compilador MikroC Programa 2 Objetivo: Apresentar o uso da diretiva define *********************************************************************/ #define led1 portd. delay_ms(5000). portd = 0. delay_ms(5000).f2 // define o label led2 para o pino RD2 void main ( ) { trisd = 0.f1 // define o label led1 para o pino RD1 #define led2 portd. delay_1sec( ). } } //ativa saída RD1 //aguarda 5 segundos //desativa saída RD1 //aguarda 1 segundo // ativa saída RD2 // aguarda 5 segundos // desativa saída RD2 39 . led2=0. // configura todo o portd como saída // todo o portd é colocado em nível baixo while(1) //loop infinito { led1=1. led2=1. delay_ms(5000).

f7=1. //se RD0=1 então RD7 é ativado } } 40 .f0==0) //testa de RD0 está em nível baixo portd=0.Acionamento de Botões: Abaixo temos o Hardware do nosso KIT de desenvolvimento: /********************************************************************** Uptex Tecnologia & Treinamento Ltda Curso de Microcontroladores PIC Linguagem C – Compilador MikroC Programa 3 Objetivo: Fazer leitura de um botão e utilização do IF-ELSE *********************************************************************/ void main ( ) { trisd = 0b00000001. // todos os pinos de saída do portd = nível baixo while(1) //loop infinito { if (portd. // configura RD0 entrada restante como saída portd = 0. // se sim todo portd em nível baixo else portd.

/********************************************************************** Uptex Tecnologia & Treinamento Ltda Curso de Microcontroladores PIC Linguagem C – Compilador MikroC Programa 4 Objetivo: Fazer leitura de um botão e utilização do IF-ELSE *********************************************************************/ void main ( ) { trisc = 0. // todos os pinos de saída do portd = nível baixo portc = 0 // todos os pinos de saída do portc = nível baixo while(1) //loop infinito { if (portd. delay_ms(1000). delay_ms(1000). portd.f2=1. } } } 41 . // se sim todo portc em nível alto else { portc=0.f2=0. // configura RD0 entrada restante como saída portd = 0. // configura todo o portc como saída trisd = 0b00000001. portd.f0==0) //RD0 está pressionado? portc=0xFF.

// define RD0 como entrada e restante dos pinos como saída portd=0. // coloca portd em 0 portc=0. } else // se for = 1 . delay_ms(1000)./********************************************************************** Uptex Tecnologia & Treinamento Ltda Curso de Microcontroladores PIC Linguagem C – Compilador MikroC Programa 5 Objetivo: Fazer leitura de um botão e utilização do IF-ELSE *********************************************************************/ void main() { trisc=0.f2=0.botão pressionado // então faz o que está entre chaves abaixo { portc=0.f0==0) // RD0 esta presionado? //se está. delay_1sec(). portc=0. // define todo o portc como saída trisd=0b00000001. portd. delay_1sec(). } } } 42 . portd. // coloca portc em 0 while(1) { if (portd. faz o que está entre chaves abaixo { portc=0xff. delay_ms(1000).f2=1.

volta ao loop para testar //chaves // se pressionado. entao aciona RC4 // RD5 esta presionado? se nao.f4==1) portc.f5=1.f5==1) portc. entao aciona RC6 // RD7 esta presionado? se nao. entao aciona RC2 // RD3 esta presionado? se nao. else if (portd./********************************************************************** Uptex Tecnologia & Treinamento Ltda Curso de Microcontroladores PIC Linguagem C – Compilador MikroC Programa 6 Objetivo: Fazer leitura de vários botões e verificar a utilização do IF-ELSE-IF *********************************************************************/ void main() { trisc=0. pula para testar RD1 // se pressionado. pula para testar RD2 // se pressionado.f1=1.f7=1.f0=1.f1==1) portc. pula para testar RD6 // se pressionado. entao aciona RC3 // RD4 esta presionado? se nao. pula para testar RD3 // se pressionado.f2==1) portc. pula para testar RD4 // se pressionado. else if (portd. else if (portd.f3==1) portc.f4=1. // define todo o portc como saída trisd=0b11111111.f6==1) portc. else if (portd. } } // RD0 esta presionado? se nao.f3=1. entao aciona RC1 // RD2 esta presionado? se nao. // define todos os pinos do portd como entrada portc=0. pula para testar RD5 // se pressionado. else if (portd. else if (portd.f0==1) portc. else if (portd.f7==1) portc. // coloca portc em 0 while(1) { if (portd. entao aciona RC5 // RD6 esta presionado? se nao. entao aciona RC7 43 . entao aciona RC0 // RD1 esta presionado? se nao.f2=1.f6=1. pula para testar RD7 // se pressionado.

{ } } } } // aguarda soltar o botão 44 . pinoX. // 20ms é o tempo e 1 é nível para tecla acionada { portc. tempoX = tempo de Debounce em milisegundos. 20. portc=0. Estado_Tecla = Valor do nível lógico quando a tecla é pressionada. /********************************************************************** Uptex Tecnologia & Treinamento Ltda Curso de Microcontroladores PIC Linguagem C – Compilador MikroC Programa 7 Objetivo: Solucionar o problema de Debounce do programa anterior e também. portb.Função Button: Button(&portX. 0. então aciona RC0 while(portd. portd ou porte). portc. tempoX. *********************************************************************/ void main() { trisc=0.f0. aguardar soltar o botão. 1)) // &port identifica o port. Estado_Tecla) Onde: &portX = port da tecla (porta. // define todo o portc como saída // define RD0 como entrada e restante como saída // coloca portc em 0 while(1) { if (button(&portd. 0 identifica o pino. trisd=0b00000001.f0==1).f0=~portc. pinoX = é o pino onde está conectado a tecla (varia de 0 à 7). // se pressionado.

0. portc=0. ao lado da cama. RD3 (quarto 1) e RD4 (quarto 2). 1)) // &port identifica o port. Então teremos as chaves em RD0. delay_ms(200). podendo com praticidade controlar/monitorar a iluminação da casa. // define todo o portc como saída // define todo o portd como entrada // coloca portc em 0 while(1) { if (button(&portd. 20. 45 . // 20ms é o tempo e 1 é nível para tecla acionada portc. 1)) portc.f0=1. RD6 e RD7. 20. RD5. 20.f3=1. *********************************************************************/ void main() { trisc=0. 20. RD2 e RD3 e as saídas para acionar os relés em RD4. 1)) portc.f2=1. 1)) portc. 20. 1)) portc. 0 identifica o pino.f1=1. Esse controle ficará no quarto do casal. Idem para RD2 (cozinha)./********************************************************************** Uptex Tecnologia & Treinamento Ltda Curso de Microcontroladores PIC Linguagem C – Compilador MikroC Programa 8 Objetivo: Testar várias chaves sem ter problema de ruído (Debounce). 3. 4. trisd=0xFF. else if (button(&portd. Pressionado RD1 acende iluminação da sala e pressionado RD1 novamente apaga. 1. 2. RD1. // se pressionado aciona RC0 else if (button(&portd. else if (button(&portd. } } Exercício: 1) Imagine que vamos montar um circuito que controle através de 4 chaves (ligar/desligar) a iluminação de uma casa. else if (button(&portd.f4=1.

} void main ( ) { int c. while(1) { portd=c. Como declarar uma Função: Tipo + Nome da Função (parâmetro) Bloco de execução Exemplo: int soma(int a.Funções: As Funções em Linguagem C são como as Subrotinas em Assembly. int b) { return a + b. São muito usadas pois. trisd=0x00. permite executar um bloco de comandos sem a necessidade de repeti-lo no bloco principal. portd=0x00. } } 46 .3). c=soma(2.

f0=0. Não podemos utilizar //função antes de declará-la //delay de 1 minuto //delay de 2 minutos void tempo_diverso ( ) //delay para n minutos { int cont. portd. while(1) { cont1=60. void main ( ) { trisd=0 . cont1=120. } } 47 . cont++) { delay_ms(1000) .Outro exemplo: void tempo_diverso( ) .f0=1. tempo_diverso( ). portd=0 . cont<cont1. portd. } } // protótipo de função. tempo_diverso ( ) . nenhuma int cont1 . for (cont=0.

Barramento de Dados 8 B1 .Barramento de Dados 15 Anodo para Display com recurso de BackLight 16 Catodo para Display com recurso de BackLight Endereço dos caracteres para display 16 x 2 (16 colunas x 2 linhas): 80 C0 81 C1 82 C2 83 C3 84 C4 85 C5 86 C6 87 C7 88 C8 89 C9 8A 8B 8C 8D 8E 8F CA CB CC CD CE CF 48 .Barramento de Dados 13 B6 .Display de Cristal Líquido – LCD Esta é um dos recursos mais interessantes quando utilizamos Microcontroladores. Isto porque podemos implementar projetos muito interessantes onde pode-se desenvolver uma IHM (Interface Homem Máquina) agregando valor muito interessante ao projeto.Barramento de Dados 10 B3 .Barramento de Dados 12 B5 . Descrição da pinagem do display: Pino Descrição 1 GND (Terra) 2 VCC (+5V) 3 Ajuste de contraste 4 Seleção – RS=1 Dado RS=0 Instrução 5 Seleção .Enable – Chip Select 1 ou 1 p/ 0 habilita e em 0 desabilita 7 B0 .RW=1 Leitura RW=0 Escrita 6 Seleção . Isto facilita bastante o desenvolvimento do projeto pois. O interessante é que o display já possui internamente outro microcontrolador que gerencia as funções do mesmo.Barramento de Dados 11 B4 . o programador se preocupa apenas em enviar os dados e a localização onde quer que os mesmos apareçam no display. Utilizaremos um Display alfanumérico 16x2 (dezesseis caracteres e duas linhas).Barramento de Dados 9 B2 .Barramento de Dados 14 B7 .

Comandos disponíveis: 49 .

2. 50 . R/W=RB2.0.No MikroC podemos utilizar um LCD em dois modos: . R/W e R/S. pin_dado. R/S = pino utilizado para controle R/S.1. para os sinais de controle utilizamos alguns pinos de outro port.D ou E. dados = RB4. Por exemplo: RD0 a RD7 para dados e RB7. pin_dado. RB6 e RB5 para sinais E. Quando utilizamos o Modo 4 bits. R/W = pino utilizado para controle R/W. R/S.5. podemos utilizar somente um port para dados e controle ou utilizar dois ports. No KIT CUSCOPIC utilizaremos o Modo 4 bits usando o portb para envio de dados e também sinais de controle. Sintaxe: lcd_config(&portX. utilizamos um port para envio de dados e.Modo 8 bits Quando utilizamos o Modo 8 bits. Temos então: R/S = RB1. pin_dado) Onde: &portX=port utilizado A. pin_dado. EN = pino utilizado para controle R/S.C. pin_dados = pinos utilizados para envio de dados Para nosso KIT teremos então: lcd_config(&portb.B. um para dados e outro para controle. R/W.Modo 4 bits .6. EN. RB6 e RB7 O Comando lcd_config ( ) inicializa o lcd e também configura os respectivos pinos de dados/controle na qual o módulo lcd irá trabalhar.7.4). RB5. EN = RB0.

} lcd_Cmd(Lcd_turn_off). lcd_cmd(lcd_underline_on).2. void main() { unsigned i. lcd_config(&portb. lcd_Cmd(Lcd_Cursor_off).i++){ lcd_cmd(Lcd_move_cursor_left).1. lcd_Cmd(Lcd_turn_on). } } 51 . while(1){ lcd_cmd(lcd_return_home).4). lcd_out(1. 1.7.i++){ lcd_cmd(Lcd_move_cursor_right). for(i=0.i<=15.Muito bem. delay_ms(500).0. } for(i=0. delay_ms(100).i<=15. delay_ms(100).5. trisb=0. text).6. vamos então praticar envio de uma mensagem ao modulo: /********************************************************************** Uptex Tecnologia & Treinamento Ltda Curso de Microcontroladores PIC Linguagem C – Compilador MikroC Programa 9 Objetivo: inicializar o módulo e apresentar uma mensagem no mesmo *********************************************************************/ char *text="LCD Display Test".

Lcd_out(2. lcd_cmd(lcd_clear).2. 1." uptex. o usuário monitorar pelo LCD o funcionamento do sistema.Outro exemplo: /********************************************************************** Uptex Tecnologia & Treinamento Ltda Curso de Microcontroladores PIC Linguagem C – Compilador MikroC Programa 10 Objetivo: inicializar o módulo e apresentar uma mensagem no mesmo *********************************************************************/ void main(){ while(1){ trisb=0. delay_ms (2000). lcd_config(&portb. Lcd_out(1. 1. } } Exercício: . Benjamim"). 1. Lcd_out(1.7."& Treinamentos"). Lcd_out(1. lcd_cmd(Lcd_Cursor_off). delay_ms (500).Para o exercício da página 45 (controle de iluminação residencial). lcd_cmd(lcd_clear). delay_ms (2000). delay_ms (500).com."Uptex Tecnologia"). conforme é ativado/desativado a iluminação dos ambientes.6. lcd_cmd(lcd_clear). lcd_cmd(lcd_clear). 1429"). 1.5."Constant. delay_ms (3000).0. Lcd_out(2. 1."cursos Rapidos"). Lcd_out(1.1."Av. o resultado é apresentado no visor podendo assim."Visite o site"). 1. 1. delay_ms (500)."com qualidade"). lcd_cmd(lcd_clear). Lcd_out(2. delay_ms (2000).4). 1. delay_ms (500). Lcd_out(2.br "). 52 . implemente o projeto apresentando no módulo LCD uma tela de apresentação da sua Empresa assim que o equipamento é ligado e.

EM.4. 53 .D7.3.D5. O comando utilizado será: lcd_custom_config(&port_data. D7. RS.D2.6. EN: pino do PIC que está ligado ao Enable do LCD – Habilita LCD RW: pino do PIC que está ligado ao sinal RW do LCD responsável pelo leitura/escrita.”Tecnologia”). RW. &port_data.0.5.D5.2. &port_data: port utilizado para sinais de dados (8 bits). &port_control.”informação”). EN).D4. Por exemplo.D4. no entanto. &portb. RS: pino do PIC que está ligado ao sinal RS responsável pelo controle (inst/dado).7.5.6.D6. Onde: &port_control: port utilizado para sinais de controle (3 bits). 2. &porte. 1.1. Exemplo : Lcd_custom_config(&portb.D6.0) Temos então: RE2 = RS RE1 = EN RE0 = RW RB7 à RB0 = dados Para escrever uma mensagem Modo 8 Bits é muito simples: lcd8_out(linha.RW. É possível também que o Hardware utilize 2 ports em 4 bits onde.coluna. utilizar o Modo 8 Bits onde temos todo o portd para enviar os dados e o algumas saídas do porte para enviar os sinais de controle.1. ter um Hardware diferente do nosso KIT.1. teremos que utilizar o seguinte comando: lcd8_config(&port_control. Exemplo de configuração onde controle está no porte e dados no porte lcd8_config(&porte. Exemplo: Escrever Uptex na primeira linha e Tecnologia na segunda linha: lcd8_out(1. RS.3) . D7 à D0: pinos do PIC que estão ligados no LCD – port_data.D3.”Uptex).D0). lcd8_out(2.7.2.Podemos. Neste caso. Por exemplo: porte sinais de controle e portb dados.5. um dos ports será responsável pelos sinais de controle (4 bits) e outro port responsável pelos dados.4.D1.

.Módulo PWM (Pulse Width Modulation) – Modulação por largura de pulso Encontramos uso do mesmo em Inversores de freqüência. Portanto. uma onda pulsante. Fontes chaveadas. controle de potência e velocidade de motores. Conforme figura acima. com amplitude 5V é acionada/desacionada no tempo.pwm_change_duty(Y) Onde Y é valor tipo char entre 0 e 255 Valor 0 e 255 determina a porcentagem em que está operando o Módulo.5V. A tensão média varia em função do tempo em que o sinal fica no nível alto (5V) e do tempo em que a onda fica no nível baixo (0V). o que significa que se colocarmos uma fonte contínua com 2. Exemplo: para duty-cycle de 50% basta colocar valor de Y=127.pwm_start( ) Inicia o Módulo. A relação entre o tempo em que a onda fica em nível alto e o período total é chamado de Duty-cycle ou ciclo de trabalho. Para a figura acima. etc. Isso implica em uma tensão média de 2. obtemos neste caso uma tensão média de 2.5V.pwm_init(X) Onde X é o valor da freqüência em Hz. O PIC 18F452 possui 2 módulos CCP – CCP1 e CCP2 (Capture/Compare/PWM) Os Comandos abaixo são para o Módulo CCP1: .5V produz o mesmo efeito que a fonte pulsante de 5V com duty-cycle de 50%. controle de servo motores. para um duty-cycle de 50% temos metade do tempo com a onda em VCC e a outra metade em 0V. como 50% do tempo a onda fica em 5V e 50% em 0V. . -pwm_stop( ) Finaliza o módulo PWM 54 .

pwm2_change_duty(Y). Exemplos: Utilizando o osciloscópio. pwm_change_duty(127). verifique os sinais das saídas PWM /********************************************************************** Uptex Tecnologia & Treinamento Ltda Curso de Microcontroladores PIC Linguagem C – Compilador MikroC Programa 11 Objetivo: verificar funcionamento do Módulo CCP1 *********************************************************************/ //programa que configura CCP1 em 1KHz e duty cycle de 50%. while(1). pwm_start(). pwm2_change_duty(25). pwm2_start(). } 55 . pwm2_stop( ) . while(1). void main(){ pwm_init(1000).Para o Módulo CCP2 temos os seguintes comandos: pwm2_init(X). pwm2_start( ). } /********************************************************************** Uptex Tecnologia & Treinamento Ltda Curso de Microcontroladores PIC Linguagem C – Compilador MikroC Programa 12 Objetivo: verificar funcionamento do Módulo CCP2 *********************************************************************/ //programa que configura Módulo CCP2 em 3KHz e duty cicle 10% void main(){ pwm2_init(3000).

pwm2_change_duty(254). pwm1_init(250). 56 . while(1). } Exercício : Modifique os valores dos duty-cycle e verifique com o osciloscópio o resultado. pwm2_start(). pwm1_change_duty(10). pwm1_start()./********************************************************************** Uptex Tecnologia & Treinamento Ltda Curso de Microcontroladores PIC Linguagem C – Compilador MikroC Programa 13 Objetivo: verificar funcionamento simultâneo dos Módulos CCP1 e CCP2 *********************************************************************/ void main() { pwm2_init(250).

pwm1_start().1)) { 57 . modificar o duty-cycle dos Módulos CCP1 e CCP2 *********************************************************************/ unsigned short int var1=127. } if (button(&portd. } void main() { seta(). pwm2_start(). pwm2_init(1000).20. } if (button(&portd. unsigned short int var2=30. 1./********************************************************************** Uptex Tecnologia & Treinamento Ltda Curso de Microcontroladores PIC Linguagem C – Compilador MikroC Programa 14 Objetivo: através de botões. 2. 0. seta().1)) { var1++ .1)) { var1--. seta(). pwm2_change_duty(var2).20. pwm1_change_duty(var1). delay_ms(100). void seta() { pwm1_init(1000). while(1) { if (button(&portd. delay_ms(100).20.

pois através dele podemos fazer leitura de grandezas físicas como temperatura. seta(). seta(). para um sinal de 5V teremos poderemos fazer leitura de 4.20. } } } Conversor A/D – Analógico/Digital Este é um dos periféricos mais importantes do Microcontrolador. 3.1)) { var2--. delay_ms(100). As 8 entradas são multiplexadas ou seja. O PIC 18F452 possui 8 canais com resolução de 10 bits ou seja. Na figura abaixo temos o circuito interno do conversor A/D no PIC: 58 . etc.8876mV. delay_ms(100). pressão.var2++ . } if (button(&portd. humidade. na verdade temos apenas 1 conversor de 10 bits e 8 entradas disponíveis para serem selecionadas pelo MUX e obter a conversão.

Estas entradas estão disponíveis nos seguintes pinos: RA0 – Entrada Analógica 0 = AN0 RA1 – Entrada Analógica 1 = AN1 RA2 – Entrada Analógica 2 = AN2 RA3 – Entrada Analógica 3 = AN3 RA4 – Entrada Analógica 4 = AN4 RA5 – Entrada Analógica 5 = AN5 RA6 – Entrada Analógica 6 = AN6 RA7 – Entrada Analógica 7 = AN7 Os Registradores que configuram como irá trabalhar o Conversor A/D são: . Agora. teremos então 2 registradores para receberem os dados da conversão: . Isso funciona da seguinte maneira: Caso seja configurado para justificativa à direita.ADCON0 .justificativa será à esquerda ADFM=1 . Caso seja configurado para justificativa à esquerda. poderemos fazer é a justificativa à direita ou justificativa à esquerda. os 8 bits mais significativos ficarão no Registrador ADRESH e os 2 bits menos significativos estarão em ADRESL. o bit responsável por esta seleção é o ADFM ADFM=0 . os 8 bits menos significativos ficarão no registrador ADRESL e os 2 bits mais significativos ficarão em ADRESH.ADRESH .ADCON1 Como os registradores são de 8 bits e a resolução do A/D é de 10 bits. 59 .justificativa será à direita O bit ADFM está presente no Registrador ADCON1 que será visto em seguida.ADRESL Com isso.

6µs para poder realizar a conversão e. Operation ADCS2:ADCS1:ADCS0 Freqüência Máxima 2 TOSC 000 1. ADCS1 e ADCS0 pois precisamos verificar o cristal utilizado.Conversor A/D está desligado 1 .Conversor A/D está ligado OBS: O conversor A/D necessita de 1.5 MHz 8 TOSC 001 5.00 MHz RC 011 -------------60 . é necessário certa atenção na hora de configurar os bits ADCS2.00 MHz 32 TOSC 010 20.Registrador ADCON0: GO/Done: Bit que informa sobre a conversão: 0 – conversor está em processo 1 – conversor não está em processo ADON: 0 .00 MHz 16 TOSC 101 10. com isso.25 MHz 4 TOSC 100 2.00 MHz 64 TOSC 110 40.

Registrador ADCON1: 61 .

qual deve ser valor da tensão aplicado em Vin? Função utilizada no MikroC para trabalhar com o Conversor A/D: Adc_read(channel) Onde channel varia de 0 a 7 correspondendo ao canal a ser feita a leitura.5V.Veref-) Onde: Resposta é o valor compreendido entre 0 e 1023 Vref+ e Vref.5V. descreva como está configurado cada pino do porta. c) Para Vref+=5V e Vref-=0V. qual o valor que deve ser o valor colocado em ADCON0 e ADCON1 para habilitarmos todos os pinos como entradas analógicas? b) Idem ao anterior para configurar todos os pinos como I/O de uso geral. Exemplo: Temperatura = Adc_read(3). calcule a resposta sendo a tensão aplicada de 3. caso resposta seja 757.são os valores máximos e mínimos da tensão de referência Vin é a tensão de entrada aplicada 1023 é uma constante que na verdade é o valor máximo que podemos ter como resposta Exercícios: a) Sendo Vref+ = 4V e Vref. calcule a tensão aplicada no canal A/D para Resposta=712. d) Para exercício anterior. Geralmente usa-se AN3 e AN2 em VCC e GND como referência. calcule o valor da resposta para Vin=2. Abaixo temos a fórmula usada para a conversão: Resposta = (Vin – Vref-) * 1023 / (Vref+ .= 1V. Como nosso Módulo A/D é de 10 bits.Exercício: a) Dado a tabela acima para configurar os Registradores. Importante ressaltar que jamais poderemos aplicar uma referência externa superior a tensão de alimentação do PIC. teremos então 1024 respostas. // temperatura recebe o valor do sinal enviado do //sensor ligado na entrada RA3 62 . c) Para ADCON1=0b00001110. b) Para as mesmas tensões de referência do exercício anterior.

lcd_config(&portb.texto).0. char texto[16].6. // configura RA0 como entrada analógica e demais //pinos como I/O digital. // configura RA0 como entrada adcon1= 0b00001110.valor 0 a 1023.7. } while(1). do { leitura_canal=adc_read(0).1.4).1. lcd_out(1.2. wordtostr(leitura_canal. lcd_cmd(lcd_cursor_off). texto). *********************************************************************/ // programa que mostra o valor lido no canal 0 . delay_ms(20). // configura portb como saída trisa. lcd_out(2.5. void main() { trisc=0.valor este entre 0 e 1023. trisd=255. "canal AN0: "). int leitura_canal.1.f0=1.Vejamos um exemplo: /********************************************************************** Uptex Tecnologia & Treinamento Ltda Curso de Microcontroladores PIC Linguagem C – Compilador MikroC Programa 15 Objetivo: apresentar a leitura da tensão medida através do potenciômetro acoplado em AN0 e mostrar no LCD . } 63 . // configura portd como entrada trisb=0.

// lcd_out(2.7. lcd_config(&portb.4).2.11.6.texto). } 64 . lcd_cmd(lcd_cursor_off). texto).1. lcd_out(2./********************************************************************** Uptex Tecnologia & Treinamento Ltda Curso de Microcontroladores PIC Linguagem C – Compilador MikroC Programa 16 Objetivo: apresentar a leitura da tensão medida através do potenciômetro acoplado em AN0 e mostrar no LCD a tensão correspondente . // leitura_canal=(leitura_canal*5)/1023. //mostra 0 a 5000mv wordtostr(leitura_canal. lcd_out(2. // configura RA0 como entrada analógica e demais //pinos como I/O digital."Volts"). do { leitura_canal=adc_read(0). //mostra 0 a 5v leitura_canal=(leitura_canal)/0.5. // configura portd como entrada trisb=0.1.0.valor 0 a 5V *********************************************************************/ // programa que mostra apenas o valor de 0 a 5 volts int leitura_canal. // configura RA0 como entrada adcon1= 0b00001110.f0=1. char texto[16]. // configura portb como saída trisa. lcd_out(1. delay_ms(20)."mili Volts"). "canal AN0: "). } while(1).1. trisd=255.2048 .7. void main() { trisc=0.

valor= leitura_ch0 * 0. lcd_config(&portb. lcd_out(1.0. delay_us(10).6. "canal Ch0: ").texto). lcd_cmd(lcd_cursor_off). // configura RA0 como entrada analógica e demais pinos //como I/O digital."Volt"). } while(1). char texto[16]. *********************************************************************/ // programa que mostra apenas o valor de 0 a 5 volts com ponto flutuante int leitura_canal. texto). // configura RA0 como entrada adcon1= 0b00001110. lcd_out(2. delay_ms(20). "canal Ch0: "). leitura_ch0=adc_read(0).valor 0 a 5V com ponto flutuante./********************************************************************** Uptex Tecnologia & Treinamento Ltda Curso de Microcontroladores PIC Linguagem C – Compilador MikroC Programa 17 Objetivo: apresentar a leitura da tensão medida através do potenciômetro acoplado em AN0 e mostrar no LCD a tensão correspondente . lcd_out(2. } 65 .1.13.1.4). lcd_out(1.1. // configura portd como entrada trisb=0.2. float valor = 0. delay_ms(20).1. trisd=255. // configura portb como saída trisa.f0=1. //mostra 0 a 5000mv floattostr(valor. int leitura_ch0.7. void main() { trisc=0.5. delay_ms(1000). do { lcd_cmd(lcd_clear).0048 .

lcd_cmd(lcd_cursor_off). inttostr(valor. } while(1).potenciômetro void main () { unsigned int valor=0. lcd_chr(1.2. delay_10us.6.0. } 66 . *********************************************************************/ // controlar o canal PWM através da entrada analógica AN0 ./********************************************************************** Uptex Tecnologia & Treinamento Ltda Curso de Microcontroladores PIC Linguagem C – Compilador MikroC Programa 18 Objetivo: apresentar no LCD o controle feito do PWM utilizando o conversor A/D.1.7.f0=1. "Duty= ").5. adcon1=0b00001110. pwm_change_duty(valor/4). texto).7. Lcd_out(1. pwm_init(10000). '%'). //configura RA0 como entrada e demais como I/O digital trisa. valor=((valor/4)*100)/255.4). lcd_out(1.texto). do { valor=adc_read(0). pwm_start(). char texto[7].15.1. //configura RA0 como entrada lcd_config(&portb.

etc. Usart_read( ) – comando para fazer leitura do dado no Buffer Serial. 300.100. 1200. As Funções abaixo são responsáveis pelo tratamento da Comunicação Serial no MikroC: Usart_init(taxa).0. Exemplo: /********************************************************************** Uptex Tecnologia & Treinamento Ltda Curso de Microcontroladores PIC Linguagem C – Compilador MikroC Programa 19 Objetivo: apresentar o funcionamento da Transmissão de dados via serial (RS232). *********************************************************************/ // transmite caracteres via serial para usart terminar do MikroC ou ComDebug2 void main() { usart_init(9600). Os pinos RC6/TX e RC7/RX são responsáveis pela comunicação e também existe a necessidade de se alocar os sinais no padrão RS232 e para isso utilizamos o circuito integrado MAX232 pois o pic trabalha apenas em 5V. 19200. PCs. 2400. Usart_write(‘x’) – comando para enviar o dado. 4800. Podemos configurá-lo para as seguintes taxas(bps): 110. 9600. Usart_ready( ) – função para saber se Buffer está vazio ou se chegou algum dado. while(1) { if (button(&portd. 600. 220. 14400.1)) { 67 . etc.Comunicação Serial: O PIC 18F452 possui um USART (Universal Synchronous Asynchronous Receiver Transmitter) que têm a função de transmitir/receber dados entre o Microcontrolador e outro microcontrolador ou equipamentos em geral como PLCs. inializa o módulo de comunicação do pic e configura a taxa de transmissão.

*********************************************************************/ // transmite/recebe caracteres via serial para usart terminar do MikroC ou ComDebug2 unsigned short dado. usart_write('t'). usart_write('p'). usart_write('x'). delay_ms(1000). portc=0. } 68 . } } } /********************************************************************** Uptex Tecnologia & Treinamento Ltda Curso de Microcontroladores PIC Linguagem C – Compilador MikroC Programa 20 Objetivo: apresentar o funcionamento da Transmissão e Recepção de dados via serial (RS232). usart_write('e'). void main() { trisc=0x00. usart_write(dado). delay_ms(2000). delay_ms(1000).f0=1. do { if (usart_data_ready()) { dado=usart_read().f0=0.usart_write('U'). if (dado=='L') portc. delay_ms(1000). if (dado=='D') portc. trisd=0xff. delay_ms(1000). usart_init(9600). } } while(1).

} } } } 69 . baud rate 9600. usart_init(9600). no parity bit. portc=0. for(i=0. if((dados[0]=='S') && (dados[1]=='1') && (dados[2]=='0')) portc.i++) dados[i]='\0'.f1=1. void compara_dados() { if((dados[0]=='S') && (dados[1]=='1') && (dados[2]=='1')) portc.f1=0. short i. i++. i=0.. *********************************************************************/ // transmite/recebe caracteres via serial para usart terminar do MikroC ou ComDebug2 char dados[4]. while(1) { if (usart_data_ready()) { dados[i]=usart_read()./********************************************************************** Uptex Tecnologia & Treinamento Ltda Curso de Microcontroladores PIC Linguagem C – Compilador MikroC Programa 21 Objetivo: apresentar o funcionamento da Transmissão e Recepção de dados via serial. } void main() { trisc=0.i<=3.. // inicializa usart (8bits. if(dados[i-1]==0x0D) // verifica se chegou o comando ENTER { compara_dados(). i=0.

// envia um caracter pela porta serial *p1++. // incrementa o ponteiro delay_ms(200)./********************************************************************** Uptex Tecnologia & Treinamento Ltda Curso de Microcontroladores PIC Linguagem C – Compilador MikroC Programa 22 Objetivo: apresentar o funcionamento da Transmissão de dados fazendo uso de ponteiros *********************************************************************/ unsigned char *p1="Uptex Tecnologia". // verifica se ponteiro enviou o último caracter } 70 . // mudar tempo para verificar resultado na transmissão dos dados } while (*p1!='\0'). do { usart_write(*p1). void main() { usart_init(9600).

"Comunicação: "). "PC / PIC / LCD"). "Dado Enviado: "). LCD_Cmd(lcd_cursor_off).1. Lcd_Cmd(Lcd_clear). Lcd_chr(1.2.1. trisd=0.1. PIC e PC *********************************************************************/ char texto [16]. Lcd_out(1. } switch(dado) { case 'a': portd.5.f0=1. portd=0. 71 . Lcd_Config(&portb.4). trisb=0.7.1. usart_init(9600). entao: { dado=usart_read(). Lcd_out(1./********************************************************************** Uptex Tecnologia & Treinamento Ltda Curso de Microcontroladores PIC Linguagem C – Compilador MikroC Programa 23 Objetivo: apresentar o funcionamento da Transmissão de dados utilizando LCD. 'a'). Lcd_out(2.15.0.6. delay_ms(10000). usart_write(dado). void main () { unsigned char dado. do { if (usart_data_ready()) // se chegou algum byte no buufer.

1.15. } 72 . } } while(1). break. case 'c': portd. "Saida RD0 ON break. "Saida RD1 ON "). "Saida RD2 ON "). ").f1=1.1. "Todas Saidas OFF"). "Dado Enviado: "). "Dado Enviado: "). Lcd_chr(1.15. Lcd_out(1. case 'b': portd.Lcd_out(2. "Dado Enviado: "). case 'd': portd=0. Lcd_out(2. 'c'). Lcd_out(2.1.f2=1. Lcd_chr(1. Lcd_out(2.15. Lcd_chr(1. 'd').1. break. Lcd_out(1.1. break.1. 'b'). Lcd_out(1.1.

char texto[16]. } while(1). // configura portb como saída trisa. lcd_out(2. // configura portd como entrada trisb=0. RA1 e RA3 como entrada analógica e //demais pinos como I/O digital. trisd=255. } 73 . usart_write(leitura_canal). lcd_out(1.048 .5. //mostra temperatura 28mv = 28 graus inttostr(leitura_canal. void main() { trisc=0.f1=1. leitura_canal=(leitura_canal)/2. texto).6.1. delay_ms(20).0.1.texto).7. lcd_cmd(lcd_cursor_off).1. // configura RA0. do { delay_ms(10000). "Temperatura: "). lcd_config(&portb./********************************************************************** Uptex Tecnologia & Treinamento Ltda Curso de Microcontroladores PIC Linguagem C – Compilador MikroC Programa 24 Objetivo: Faz leitura da temperatura e transmite via serial para PC *********************************************************************/ /* programa que mostra no display a temperatura ambiente e transmite a cada 10 segundos para o PC via canal serial */ int leitura_canal. lcd_out(2. leitura_canal=adc_read(1).7.4). // configura RA1 como entrada adcon1= 0b00000100."oC"). usart_init(9600).2.

// configura portb como saída trisa. lcd_cmd(lcd_cursor_off). compara com SetPoint e aciona alarme *********************************************************************/ /* programa que mostra no display a temperatura ambiente e se temperatura for maior que 40 graus. // configura RA0.7. texto). delay_ms(20). portd=0. int leitura_canal.0. // configura RA1 como entrada adcon1= 0b00000100. *i++."oC"). delay_ms(100). } while(*i!='\0'). // configura portd como entrada trisb=0.f1=1./********************************************************************** Uptex Tecnologia & Treinamento Ltda Curso de Microcontroladores PIC Linguagem C – Compilador MikroC Programa 25 Objetivo: Faz leitura da temperatura . void main() { trisd=0.7. lcd_config(&portb. deverá acionar todo o portd (alarme) e transmitir via serial ao PC a string ALARME */ unsigned char *i= "ALARME" .5. //mostra temperatura 28mv = 28 graus inttostr(leitura_canal. lcd_out(2.texto). delay_ms(10000). lcd_out(1. "Temperatura: "). lcd_out(2.1. } } } 74 . leitura_canal=(leitura_canal)/2. RA1 e RA3 como entrada analógica e //demais pinos como I/O digital. usart_init(9600).6.2.1. while(1) { leitura_canal=adc_read(1).4). do { usart_write(*i). char texto[16]. if (leitura_canal>40) { portd=255.048 .1.

Podemos por exemplo usar o timer/contador para gerar uma informação para o PIC a cada 1 segundo fazer aquisição de dado da temperatura de uma amostra ou contar o número de voltas que um motor está realizando. O “estouro” do Timer2 ocorre quando igualar o valor do Timer2 com o valor do Registrador PR2. Também possui um Prescaler dedicado.Conhecendo os Timers/Counters: O PIC18F452 possui internamente 4 Timers/Counters (Temporizadores/Contadores) de grande utilização para desenvolvimento de rotinas de tempos ou contagem de eventos. T0CON TMR0ON T08BIT T0CS T0SE PSA T0PS2 T0PS1 T0PS0 Os 3 primeiros bits são responsáveis pela seleção do Prescaler T0PS2 0 0 0 0 1 1 1 1 T0PS1 0 0 1 1 0 0 1 1 T0PS0 0 1 0 1 0 1 0 1 Prescaler 1:2 1:4 1:8 1:16 1:32 1:64 1:128 1:256 PSA: Bit de seleção do Prescaler 0 = prescaler será utilizado 1 = Prescaler não será utilizado. Este timer possui ainda o Postscale que trabalha contando o número de estouro (igualdade entre timer2 e PR2). funcionando igual ao Timer0. O Timer0 pode ser configurado para trabalhar em 8 ou 16 bits fazendo contagem (0 a 255 ou 0 a 65535). uma nova contagem é realizada. Quando isso ocorre. Possui ainda um Prescaler que nada mais é do que um divisor programável possibilitando aumentar o tempo ou reduzir a freqência de operação. O Timer1 é um timer de 16 bits. 75 . conseguimos então Prescaler 1:1 – a cada pulso o timer0 será incrementado. Após realizar N comparações é que irá ocorrer o “estouro” do Timer2. ou seja. Abaixo temos o Registro e a função de cada bit. Timer0: O Registrador T0CON é responsável pela configuração deste timer. porém pode-se acoplar um cristal externo para gerar os pulsos de clock (RC0 e RC1). O Timer2 é um timer de 8 bits mas com funcionamento diferente. Neste caso. O Timer3 é um temporizador/contador de 16 bits possuindo também um Prescaler dedicado. a tabela acima não tem valor.

TMR0H: Responsável pela contagem da parte alta (0 a 65535). Se Timer0 estiver Trabalhando no Modo 8 bits utiliza apenas o TMR0L e se estiver em 16 bits utiliza os 2 Registradores – TMR0L e TMR0H. Utilizaremos então cristal de 4MHz e Prescaler de 1:64 76 .T0SE: Bit que faz a seleção da borda 0 = sensível a borda de subida em T0CKI 1 = sensível a borda de descida em T0CKI T0CS: Bit que seleciona como será o clock do Timer0 0 = Cristal interno incremeta o timer 1 = Pulso externo aplicado no pino T0CKI incrementa o timer T08BIT: Bit que seleciona o modo de operação 0 = 16 Bits 1 = 8 Bits TMR0ON: Bit que ativa/desativa o Timer0 0 = Timer0 desabilitado 1 = Timer0 habilitado Existe também 2 Registradores que trabalham juto com o Timer0. Calculando o Tempo no Timer0: Tempo = ciclo de máquina * prescaler * (modo 8 ou 16 bits – valor_inicial) Onde: Tempo = Tempo que irá demorar para ocorrer o estouro do Timer0. São eles: TMR0L: Responsável pela contagem da parte baixa (0 a 255). Ciclo de máquina = 1/(Fosc/4) Fosc = freqüência do cristal Modo 8 ou 16 bits = Modo escolhido 256 ou 65536 Valor_inicial = valor que será colocado nos Registradores TMR0L e TMR0H Vamos fazer um exemplo: Queremos em nosso projeto utilizar o Timer0 para a piscar um led ficando aceso 1 segundo e apagado por 1 segundo identificando através deste Led que o equipamento está ativado. operando normalmente.

Como deverá ficar configurado o Registrador T0CON para o exercício anterior? Calcular o tempo de estouro do Timer0 onde T0CON = 0B10000010 e TMR0H=0x9E e TMR0L=0x58 b) c) Registrador INTCON: Para configurar as interrupções que o microcontrolador poderá atuar. TMR0H = C2 e TMR0L = F7 Exercício: a) Seguindo a idéia do exemplo anterior. 77 . 0 = nenhuma interrupção será tratada. 1 = liga chave geral para tratamento das interrupções.Tempo = ciclo de máquina * Prescaler * X Onde X é o valor a ser colocado nos Registradores e dependendo deste valor utilizaremos modo 8 bits (valores até 256) ou 16 bits (valores até 65536). GIE/GIEH PEIE/GIEL TMR0IE INT0IE RBIE TMR0IF INT0IF RBIF GIE/GIEH: Bit chave geral das interrupções e também chave que habilita as interrupções para atuar em alta prioridade. 1s = 1µs * 64 * X X = 1s / (64 * 1µs) X = 15625 Como valor é maior que 256 teremos que usar Modo 16 bits Com isso. mude o tempo on/off do Led para 10s e modifique o Prescaler para 256. fazemos a seguinte conta: 65536 – 15625 = 49911 Este valor 49911 deve ser convertido de decimal para hexadecimal = C2F7 Então. precisamos conhecer os bits deste registrador. Encontre os valores que devem ser carregados em TMR0L e TMR0H.

TMR0IE: Bit que habilita tratamento de interrupção por estouro no TMR0. 78 . 0 = desabilita 1 = habilita INT0IE: Bit que habilita interrupção pela entrada INT0 0 = desabilita 1 = habilita RBIE: Bit que habilita interrupção pelo entrada RB0 0 = desabilita 1 = habilita TMR0F: Bit que sinaliza (Flag) ocorrência da interrupção por estouro no TMR0 0 = não ocorreu Overflow 1 = ocorreu Overflow INT0F: Bit que sinaliza (Flag) ocorrência da interrupção por evento na entrada INT0 0 = não ocorreu evento 1 = ocorreu evento RBIF: Bit que sinaliza (Flag) ocorrência da interrupção por evento na entrada RB0 0 = não ocorreu evento 1 = ocorreu evento Existem outros Registradores responsáveis pelo tratamento/configuração de interrupções e serão vistos oportunamente. estaremos usando os Registradores INTCON.PEIE/GIEL: Bit que habilita interrupções de baixa prioridade 0 = desativado baixa prioridade. TMR0H e TMR0L. 1 = ativado alta prioridade. como estamos trabalhando apenas com o Timer0. T0CON. Por hora.

// habilita contagem do TMR0. configura para 8 bits TRISD = 0. // Habilita chave geral para estouro do TMR0 contagem = 0./********************************************************************** Uptex Tecnologia & Treinamento Ltda Curso de Microcontroladores PIC Linguagem C – Compilador MikroC Programa 26 Objetivo: Configurar e verificar a interrupção do timer0 em 8 bits .Timer0 em 8 bits //aciona RD0 a cada 1 segundo unsigned contagem.02ms x 1000 = 1. INTCON = 0xA0.f0 = ~portd.f0.Temporizador *********************************************************************/ //programa que faz uso do Interrupção . void interrupt() { contagem++. tmr0h = 0. // incrementa variável de contagem TMR0L = 0. TMR0L = 0. e limpa a flag do estouro do TMR0 = T0IF }//~ void main() { T0CON = 0b11000001. } 79 . // e prescaler 1:4 portd=0. INTCON = 0x20. // Reseta contagem } } while(1). // Seta T0IE. // troca estado do RD0 contagem = 0.02s PORTD. // Initialize variável contagem do { if (contagem == 1000) { // para contagem = 1000 teremos 1.

f0. TMR0H = 0xC2. // para 5 segundos: x=5/128us=39062 onde valor inicial será //65532-39062 = 26470 que em hexa=0x6766 TMR0L = 0x66 e //TMRH=67. } 80 . delay_ms(250).Temporizador *********************************************************************/ //programa que faz uso do Interrupção . configura para 16 bits TRISD = 0.f0 = ~portd. // habilita contagem do TMR0. // para 2 segundos: x=2/128us= 15625 onde valor inicial //será 65532 . } while(1).f4=1.Timer0 em 16 bits //aciona RD0 a cada 2 ou 5 segundos void interrupt() { PORTD.15625 = 49907 que em hexa=C2F3 //TMR0L=0xF3 e TMRH=C2. INTCON = 0x20. e limpa a flag do estouro do TMR0 = T0IF } void main() { T0CON = 0b10000110./********************************************************************** Uptex Tecnologia & Treinamento Ltda Curso de Microcontroladores PIC Linguagem C – Compilador MikroC Programa 27 Objetivo: Configurar e verificar a interrupção do timer0 em 16 bits .f4=0. // Habilita chave geral para estouro do TMR0 do { portd. // Seta T0IE. // troca estado do RD0 TMR0L = 0xF3. TMR0H = 0xC2. // e prescaler 1:128 portd=0. delay_ms(250). INTCON = 0xA0. portd. TMR0L = 0xF3.

4). Retorne configuração 1:1 e carregue agora o Registro TMR0L com valor 251 e verifique o que acontece na contagem. contagem++. LCD_Cmd(Lcd_Clear). 81 . do { if (INTCON. LCD_Out(2.texto).7. //carrega novamente Timer0 com 255. void main( ) { T0CON=0b11101000.2. } } while(1).6. char texto[15]. } Obs: Troque o valor do Prescaller para 1:2 e veja resultado.TMR0IF=0.1.0.1. sem uso prescaller e 1:1 trisd=0.5.Contador *********************************************************************/ int contagem=0. //limpa a flag do estouro Timer0. //configura timer0 em 8 bits.TMR0IF=0. wordtoStr(contagem. LCD_Out(1. TMR0L=255. portd=0.TMR0IF==1) { portd++.5. //inicializa flag de estouro do Timer0 em nível baixo LCD_Config(&portb. TMR0L=255. “Contador Pulsos”). //carrega timer0 com 255 (basta 1 pulso para gerar interrupção INTCON. INTCON. texto). LCD_Cmd(LCD_Cursor_Off)./********************************************************************** Uptex Tecnologia & Treinamento Ltda Curso de Microcontroladores PIC Linguagem C – Compilador MikroC Programa 28 Objetivo: Configurar e verificar a interrupção do timer0 em 8 bits .

No mikroC temos as seguintes funções de acesso à EEPROM: EEPROM_READ(adress): lê uma byte no endereço de memória. trisc=0. // faz a leitura do posição 0 da EEPROM e carrega na //variável leitura. EEPROM_WRITE(adress. Obs: É preciso ficar atento pois.data): escreve um byte (data) no endereço (adress)."Leitura AN1"). Exemplo: Eeprom_write(0. //configura RA0 como entrada analógica demais I/O lcd_config(&portb.7. //escreve o valor 25 no endereço 0 da EEPROM.Memória EEPROM: O 18F452 possui internamente 256 bytes de EEPROM.1.4).5. 82 .25).2. /********************************************************************** Uptex Tecnologia & Treinamento Ltda Curso de Microcontroladores PIC Linguagem C – Compilador MikroC Programa 29 Objetivo: Gravar e fazer leitura na EEPROM do PIC *********************************************************************/ char texto[15]. lcd_out(1. lcd_cmd(lcd_clear). Exemplo: Leitura=eeprom_read(0). void main( ) { trisd=0b00001111. adcon1=0b00001110.6. cada posição de memória não pode ter mais que 8 bits (1 byte). portc=0. lcd_cmd(lcd_cursor_off).0. valor. int leitura_canal. portd=0. unsigned int i. 1.

"Salvando. } if(button(&portd.f7=1.. portd. portc=0. valor=eeprom_read(0).do { leitura_canal=adc_read(0). lcd_cmd(lcd_clear).1)) // RD1 = busca na EEPROM valor gravado { portd.. portc=i. portd.f7=0..i). wordtostr(valor. lcd_out(1.f5=0.texto).1. lcd_cmd(lcd_clear)..texto).1)) // RD0 = grava na EEPROM valor do A/D { lcd_cmd(lcd_clear).1. if(button(&portd. portd. leitura_canal=(leitura_canal)/20.5. 83 .f5=1. texto). } Exercício: Desenvolva um programa que faça medição da Temperatura ambiente e se a temperatura ultrapassar 38 graus. delay_ms(500)."Leitura AN1")."). este valor deve ser salvo na EEPROM e também acionar uma saída (RD7) indicando alarme. } }while(1). lcd_out(1."Leitura AN1"). delay_ms(1000)."VALOR na EEPROM"). lcd_cmd(lcd_clear).50. lcd_out(1.0.50.. i=leitura_canal. delay_ms(1000). texto).. lcd_out(1. wordtostr(leitura_canal.1.1. lcd_out(2. lcd_cmd(lcd_clear). eeprom_write(0.1.1. lcd_out(2.

utilizamos os seguintes registradores: . . . Como funciona? É simples.Interrupção no estouro do TIMER3.PIR1. quando terminar. entender bem o que cada bit dentro de cada registrador faz para podermos definir como irá trabalhar o microcontrolador no controle do projeto. Para o 18F452 temos as seguintes interrupções: .INT1 (RB1). portanto.IPR1.Interrupção no estouro do TIMER1. . . .INTCON2.INT0 (RB0). .Interrupção por estímulo externo . Se o microcontrolador está tratando uma interrupção de baixa prioridade e ocorre uma interrupção de alta prioridade. RB6 e RB7. RB5.INTCON3. . . .PIE1.PIE2. .Interrupção no estouro do TIMER0. .Interrupção na Conversão do A/D. . .Interrupção no término de escrita na EEPROM.RCON.Interrupção na mudança de Estado nos pinos: RB4. . .Interrupção no Módulo LVP (detector de baixa tensão).Interrupção no Módulo CCP. definimos interrupções como baixa prioridade e alta prioridade.Interrupção na Recepção do canal serial.Interrupção por estimulo externo . já para o pic 18F452 temos dois vetores de interrupção: 0x08 para alta prioridade. nos microcontroladores da família 18F temos o recurso de priorizar as interrupções. 0x18 para baixa prioridade. .Introdução às Interrupções: Diferente da família 16F. . 84 .PIR2. vai tratar a interrupção de alta prioridade e. .IPR2.Interrupção na Transmissão do canal serial. ele pára o que está fazendo. . aí sim retorna o tratamento da interrupção de baixa prioridade.Interrupção por estímulo externo . . . Precisamos. Na família 16F tínhamos um endereço de vetor de interrupção (ex: 0x04).INT2 (RB2). Para configurar/habilitar/verificar estas interrupções.INTCON. .Interrupção no estouro do TIMER2.

Funcionamento igual à família 16F.RCON: IPEN ---------- ---------- /RI /TO /PD /POR /BOR IPEN= Habilita o tratamento de interrupções através de prioridades. 0 – desabilita prioridade. /RI= Flag que sinaliza instrução de Reset 0 – ocorreu instrução de reset 1 – Funcionamento normal do PIC /TO= Flag que sinaliza estouro do Watch-dog Timer 0 – ocorreu estouro do WDT 1 – Funcionamento normal do PIC /PD= Flag que sinaliza evento de Power-Down (economia de energia . 1 – habilita tratamento de interrupções por prioridade.SLEEP) 0 – ocorreu evento 1 – Funcionamento normal do PIC /POR= Flag que sinaliza evento de POWER ON RESET – Reset ao ligar 0 – ocorreu o evento 1 – não ocorreu o evento /BOR= Flag que sinaliza Brown-Out Reset 0 – ocorreu o evento 1 – não ocorreu o evento 85 .

0 – desabilita interrupção de baixa prioridade 1 – habilita interrupção de baixa prioridade. 1 – habilita interrupção dos periféricos. RBIE= Chave individual que ativa interrupção por mudança de estado (RB4 à RB7). GIEL= Chave geral para habilitar o tratamento de interrupções de baixa prioridade. INT0IE= Chave individual que ativa interrupção do INT0. PEIE= Chave individual para habilitar interrupção dos periféricos. 1 – Microcontrolador irá tratar interrupções. 1 – ocorreu interrupção por estouro do TIMER0. 0 – não ocorreu interrupção por mudança de Estado no pino RB0. 0 – desabilita interrupção dos periféricos. 0 – desabilita. 1 – habilita. GIEH= Chave geral para habilitar o tratamento de interrupções de alta prioridade. 1 – ocorreu interrupção por mudança de Estado nos pinos RB4 à RB7.INTCON: GIE/GIEH PEIE/GIEL TMR0IE INT0IE RBIE TMR0IF INT0IF RBIF GIE= Chave geral para habilitar o tratamento de interrupções. 0 – não ocorreu interrupção por estouro do TIMER0. RBIF= Flag de sinalização da interrupção da mudança de Estado (RB4 a RB7). 1 – ocorreu interrupção por mudança de Estado no pino RB0. INT0IF= Flag de sinalização da interrupção da mudança de Estado do INT0. 0 – desabilita. 0 – desabilita interrupção de alta prioridade 1 – habilita interrupção de alta prioridade. TMR0IF= Flag de sinalização da interrupção do estouro do TIMER0. 1 – habilita. 0 – não ocorreu interrupção por mudança de Estado nos pinos RB4 à RB7. 1 – habilita. 0 – Microcontrolador não irá tratar nenhuma interrupção. 0 – desabilita. TMR0IE= Chave individual que ativa interrupção do TIMER0. 86 .

INTEDG1= Define a borda que acionará o evento de interrupção no INT1. INTEDG2= Define a borda que acionará o evento de interrupção no INT2. 87 . 1 – definida como alta prioridade. 1 – evento ocorrerá na borda de subida. TMR0IP= Define a prioridade da interrupção do TIMER0. 0 – definida como baixa prioridade. 0 – evento ocorrerá na borda de descida. 0 – evento ocorrerá na borda de descida. 0 – definida como baixa prioridade. RBIP= Define a prioridade da interrupção da mudança de Estado (RB4 à RB7). 1 – evento ocorrerá na borda de subida.INTCON2: RBPU INTEDG0 INTEDG1 INTEDG2 ---------TMR0IP --------RBIP RBPU= Chave que define se vai haver ou não resistores de Pull-Up no PORTB. INTEDG0= Define a borda que acionará o evento de interrupção no INT0. 0 – Habilita resistores de pull-up. 1 – desabilita resistores de pull-up. 0 – evento ocorrerá na borda de descida. 1 – definida como alta prioridade. 1 – evento ocorrerá na borda de subida.

1 – habilita. 1 – ocorreu interrupção por mudança de Estado no pino RB2. 0 – não ocorreu interrupção por mudança de Estado no pino RB2. INT2IE= Chave individual que ativa interrupção do INT2. 1 – ocorreu interrupção por mudança de Estado no pino RB1. 1 – definida como alta prioridade. 0 – não ocorreu interrupção por mudança de Estado no pino RB1. 1 – habilita. INT2IF= Flag de sinalização da interrupção da mudança de Estado do INT2. 88 . 0 – desabilita. 0 – desabilita. INT1IP= Define a prioridade da interrupção externa no INT1. 1 – definida como alta prioridade. 0 – definida como baixa prioridade. INT1IF= Flag de sinalização da interrupção da mudança de Estado do INT1. 0 – definida como baixa prioridade. INT1IE= Chave individual que ativa interrupção do INT1.INTCON3: INT2IP INT1IP ---------INT2IE INT1IE --------INT2IF INT1IF INT2IP= Define a prioridade da interrupção externa no INT2.

0 – desabilita. 1 – habilita. 1 – habilita. 0 – desabilita. 0 – desabilita. RCIE= Chave individual que habilita interrupção por recebimento de dados na USART. TMR2IE= Chave individual que habilita interrupção por igualdade entre TMR2 e PR2. 89 . 1 – habilita.PIE1: PSPIE ADIE RCIE TXIE SSPIE CCP1IE TMR2IE TMR1IE PSPIE= Chave individual que habilita interrupção da Porta Paralela Escrava (R/W). 1 – habilita. 0 – desabilita. 0 – desabilita. 1 – habilita. 0 – desabilita. 1 – habilita. 0 – desabilita. ADIE= Chave individual que habilita interrupção do Conversor A/D. 1 – habilita. 1 – habilita. TXIE= Chave individual que habilita interrupção por transmissão de dados na USART. CCP1IE= Chave individual que habilita interrupção de Captura/Compare no TIMER1. TMR1IE= Chave individual que habilita interrupção de estouro do TIMER1. SSPIE= Chave individual que habilita interrupção do Módulo SSP (Máster Syncronous Serial Port). 0 – desabilita.

PIE2: ------------------------EEIE BCLIE LVDIE TMR3IE CCP2IE EEIE= Chave individual que habilita interrupção de escrita na EEPROM/FLASH. 0 – desabilita. 0 – desabilita. LVDIE= Chave individual que habilita interrupção do Módulo LVD (baixa tensão). 1 – habilita. CCP2IE= Chave individual que habilita interrupção do Módulo CCP2. 1 – habilita. 1 – habilita. 1 – habilita. TMR3IE= Chave individual que habilita interrupção por estouro do TIMER3. 0 – desabilita. 0 – desabilita. 0 – desabilita. 90 . BCLIE= Chave individual que habilita interrupção de colisão de dados. 1 – habilita.

1 – Transmissão/Recepção está completa. 0 – conversão não está completa. 0 – aguardando transmissão/recepção. 0 – buffer tem dados para enviar. 1 – ocorreu interrupção por igualdade entre TMR2 e PR2. ADIF= Flag de sinalização da interrupção do Conversor A/D. 0 – não ocorreu leitura ou escrita. 1 – buffer está vazio. 1 – ocorreu leitura ou escrita na porta paralela. CCP1IF= Flag de sinalização da interrupção de Captura/Compare no TIMER1. RCIF= Flag que sinaliza interrupção por recebimento de dados na USART. Modo Compara 0 – não ocorreu interrupção por comparação no TIMER1. 0 – não ocorreu interrupção por igualdade entre TMR2 e PR2. 91 . 1 – buffer tem dados recebidos. TMR1IF= Flag de sinalização de estouro do TIMER1. 0 – não ocorreu interrupção por estouro do TIMER1. 1 – ocorreu interrupção por captura no TIMER1. SSPIF= Flag de sinalização do Módulo SSP (Máster Syncronous Serial Port). TMR2IF= Flag de sinalização da interrupção por igualdade entre TMR2 e PR2. Modo Captura 0 – não ocorreu interrupção por captura no TIMER1. 1 – conversão finalizada. 1 – ocorreu interrupção por comparação no TIMER1.PIR1: PSPIF ADIF RCIF TXIF SSPIF CCP1IF TMR2IF TMR1IF PSPIF= Flag de sinalização da interrupção da Porta Paralela Escrava (R/W). TXIF= Flag que sinaliza interrupção por transmissão de dados na USART. 1 – ocorreu interrupção por estouro do TIMER1. 0 – buffer está vazio.

1 – ocorreu interrupção por captura no TIMER1. 0 – não ocorreu evento de interrupção. 92 . 1 – ocorreu evento de interrupção. 1 – ocorreu interrupção por comparação no TIMER1. 0 – não ocorreu evento de interrupção. Modo Captura 0 – não ocorreu interrupção por captura no TIMER1. LVDIF= Flag que sinaliza interrupção do Módulo LVD (baixa tensão). TMR3IF= Flag que sinaliza interrupção por estouro do TIMER3. 1 – ocorreu colisão de dados. 1 – ocorreu o término – operação de escrita está completa. 1 – ocorreu evento de interrupção. 0 – operação de escrita não está completa ou não foi inicializada. ‘ CCP2IF= Flag de sinalização do Módulo CCP2. Modo Compara 0 – não ocorreu interrupção por comparação no TIMER1. 0 – não ocorreu colisão de dados. BCLIF= Flag de sinalização de colisão de dados.PIR2: ------------------------EEIF BCLIF LVDIF TMR3IF CCP2IF EEIF= Flag de sinalização da interrupção de escrita na EEPROM/FLASH.

ADIP= Bit que define a prioridade na interrupção do Conversor A/D. 0 – baixa prioridade. 93 . 0 – baixa prioridade. SSPIP= Bit que define a prioridade na interrupção do Módulo SSP (Master Syncronous Serial Port). 0 – baixa prioridade. 0 – baixa prioridade. CCP1IP= Bit que define a prioridade na interrupção de Captura/Compare no TIMER1. 0 – baixa prioridade. 1 – alta prioridade. 0 – baixa prioridade. 1 – alta prioridade. 1 – alta prioridade. RCIP= Bit que define a prioridade na interrupção por recebimento de dados na USART. 0 – baixa prioridade. TMR1IP= Bit que define a prioridade na interrupção de estouro do TIMER1. TXIP= Bit que define a prioridade na interrupção por transmissão de dados na USART.IPR1: PSPIP ADIP RCIP TXIP SSPIP CCP1IP TMR2IP TMR1IP PSPIP= Bit que define a prioridade na interrupção da Porta Paralela Escrava (R/W). 1 – alta prioridade. TMR2IP= Bit que define a prioridade na interrupção por igualdade entre TMR2 e PR2. 1 – alta prioridade. 1 – alta prioridade. 1 – alta prioridade. 1 – alta prioridade. 0 – baixa prioridade.

0 – baixa prioridade. 1 – alta prioridade. 0 – baixa prioridade. Estrutura de Programa utilizando Interrupções de Alta e Baixa Prioridade: Obs: Quando utilizar alta e baixa prioridade devemos desenvolver o programa conforme segue abaixo: void interrupt ( ) // vetor de interrupção – alta prioridade { Comandos.IPR2: ------------------------EEIP BCLIP LVDIP TMR3IP CCP2IP EEIP= Bit que define a prioridade na interrupção de escrita na EEPROM/FLASH. // Obs: Não esquecer que é necessário limpar a Flag da interrupção. BCLIP= Bit que define a prioridade na interrupção de colisão de dados. } Void interrupt_low ( ) { Comandos. Comandos. 1 – alta prioridade. // Obs: Não esquecer que é necessário limpar a Flag da interrupção. 1 – alta prioridade. Comandos. 1 – alta prioridade. 0 – baixa prioridade. LVDIP= Bit que define a prioridade na interrupção do Módulo LVD (baixa tensão). ‘ CCP2IP= Bit que define a prioridade na interrupção do Módulo CCP2. Comandos. 1 – alta prioridade. } Void main ( ) { Comandos. TMR3IP= Bit que define a prioridade na interrupção por estouro do TIMER3. 0 – baixa prioridade. 0 – baixa prioridade. } 94 .

intcon=0b11010000.int0if=0. intcon. na entrada RB0 estamos com uma entrada de interrupção (INT0) onde teremos um sensores de movimento na garagem. como se fosse um simulador de presença residencial. acionando a luminação da garagem. // delay de 6 segundos portd. portc=0. /********************************************************************** Uptex Tecnologia & Treinamento Ltda Curso de Microcontroladores PIC Linguagem C – Compilador MikroC Programa 30 Objetivo: Verificar tratamento de interrupções – INT0 *********************************************************************/ int contador=0. portd=0. Para o exemplo abaixo temos um programa onde algumas saídas do portc são acionadas por determinado tempo. caso sensor seja acionado.rbpu=0.f7=1.Inicialmente vamos verificar funcionamento de Interrupções sem prioridade. trisb. // dispara iluminação da garagem delay_ms(6000). neste momento. trisc=0. Terminado este tempo.f7=0. chave periféricos ligada // chave que ativa interrupção do TIMER0 ativa //seleciona borda de descida 95 .f0=1.intedg0=0. void interrupt() { portd. trisd=0. Portanto. intcon2. //apaga a Flag da interrpção INT0 } void main ( ) { intcon2. Ocorrendo novo evento a situação se repete. o programa principal pára onde está e vai tratar a interrupção. programa retorna onde parou quando ocorreu a interrupção. no entanto. //habilita resistores de Pull-Up no portb // chave geral ligada. uma saída é acionada por determinado tempo.

do { portc. delay_ms(1000). delay_ms(1000).f4=0. portc.f2=0. delay_ms(500). } while(1). portc. } // simulador de presença residencial Vamos agora melhorar nosso projeto colocando mais um recurso. portc. (sensores ligados em série). portc. controle de iluminação da garagem (Int0) e agora vamos colocar mais uma interrupção (INT1). 96 .f3=0. delay_ms(500). portc.f0=0. Nesta entrada (pino RB1) vamos colocar um ou mais sensores de abertura de portas e janelas / sensor de movimento dentro da residência.f0=1. delay_ms(1500). portc. Já temos simulador de presença (portc).f4=1.f3=1.f2=1. portc.

portd. individual e do INT0 ligadas //seleciona borda de descida para INT0 //habilita chave individual para INT1 //seleciona borda de descida para INT1 97 . // ativa led que sinaliza ocorencia de alarme delay_ms(10000).int1if=0. intcon=0b11010000.int0if==1) { portd. //habilita resistores de Pull-Up //RB0 entrada //RB1 entrada // chave geral. trisd=0.f7=0. } } void main ( ) { intcon2.int0if=0.f7=1.int1ie=1.rbpu=0.f0=0.intedg1=0. trisb. portd=0.f1=1. trisc=0./********************************************************************** Uptex Tecnologia & Treinamento Ltda Curso de Microcontroladores PIC Linguagem C – Compilador MikroC Programa 31 Objetivo: Verificar tratamento das interrupções – INT1 e INT2 *********************************************************************/ int contador=0.f0=1. delay_ms(6000).f5=1. portc=0. void interrupt() { if (intcon. intcon2. intcon3.int1if==1) // testa se foi interrupção INT1 (Sistema de Alarme) { portd.f0=1. intcon. // dispara a sirene portd. intcon2. intcon3.intedg0=0. trisb. } // testa se foi interrupção INT0 (Iluminação da Garagem) // aciona iluminação // delay de 6 segundos // apaga Flag do INT0 if (intcon3. portd.

f4=0. podemos separar as interrupções entre alta e baixa prioridade.invasão na residência (INT1) o alarme só irá disparar após o tratamento da interrupção INT0. Como o 18F452 possui dois vetores de interrupção. portc. portc. } Para o programa acima. Deparamos neste caso com a grande vantagem e potencialidade da família 18F. // simulador de presença residencial delay_ms(1000). portc. portc.f2=1.f0=1. delay_ms(1500). delay_ms(500).f2=0. enquanto o microcontrolador ainda está tratando esta interrupção e ocorrer outra interrupção . delay_ms(500).f4=1. INT2 colocar a iluminação da garagem em Baixa Prioridade 98 . observe que problema interessante: Ao gerar interrupção pelo acionamento da iluminação da garagem (INT0) e em seguida.f3=1. Vamos então fazer uma modificação: INT1 colocar sistema de Alarme em Alta Prioridade. aí sim irá retornar para continuar execução da baixa prioridade e por fim voltar ao programa principal (Simulação de Presença). Ai está um problema grave.do { portc. portc.f0=0. portc. caso o Microcontrolador esteja tratando uma interrupção de baixa prioridade e vir a ocorrer a interrupção de alta prioridade. portc. o programa irá parar temporariamente o tratamento da baixa prioridade e irá executar o de alta prioridade. Terminando a alta prioridade. } while(1). pois teríamos que priorizar o alarme sobre a iluminação da garagem.f3=0. delay_ms(1000). Com isso.

rbpu=0. //ativa chave geral de baixa prioridade intcon2.f2=1.f5=1.f0=1. intcon3. portd. intcon3. // Interrupção de alta prioridade // interrupção INT1 (Sistema de Alarme) // dispara a sirene // ativa led que sinaliza ocorrência de alarme // apaga Flag do INT1 // Interrupção de baixa prioridade // interrupção INT2 (Iluminação da Garagem) // aciona iluminação // delay de 6 segundos //habilita resistores de Pull-Up //RB0 entrada //RB2 entrada rcon.ipen=1. trisb.f7=1. //ativa chave geral de alta prioridade intcon. } void interrupt_low() { portd. trisc=0. portc=0.Compilador MikroC Programa 32 Objetivo: Verificar tratamento das interrupções .INT2 e INT1 com prioridade *********************************************************************/ int contador=0. portd.giel=1.intedg2=0.int2if=0. void interrupt() { portd./********************************************************************** Uptex Tecnologia & Treinamento Ltda Curso de Microcontroladores PIC Linguagem C . } void main ( ) { intcon2. delay_ms(6000). // Habilita interrupção com prioridade intcon. //seleciona borda de descida para INT2 99 . portd. delay_ms(10000).int1if=0. portd=0.f0=0. trisb.gieh=1.f7=0.f0=1. trisd=0.

} while(1). 100 .int2ip=0.f0=0.f2=0.f0=1. // habilita INT2 como baixa prioridade do { portc. // habilita INT1 como prioridade alta intcon3. portc. // simulador de presença residencial delay_ms(1000). // habilita chave individual para INT1 intcon3. delay_ms(500).f4=0. delay_ms(500).f4=1. portc. } Exercício: Modifique o programa fazendo uso agora da prioridade alta em RB4 a RB7 (4 zonas de alarme). // habilita chave individual para INT2 intcon3.f2=1.f3=1. RC3 = Zona 3 e RC4 = Zona 4). portc. portc. delay_ms(1500). portc.int1ie=1.intcon3.f3=0. portc. usando o portc para sinalização de zona disparada (RC0= Zona 1.int1ip=1. delay_ms(1000).int2ie=1. portc. Manter prioridade alta para alarme e baixa para iluminação da garagem. RC1= Zona 2. RD7 para saída para iluminação da garagem (minuteria) e RD0 à RD6 para Simulador de Presença.

Sign up to vote on this title
UsefulNot useful