Microcontroladors PIC - Linguagem C

1

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

www.mecatronicadegaragem.blogspot.com

2

- Programa 14 – Ajustando os Módulos usando botões -------------------------- 57 - Conversor A/D ----------------------------------------------------------------------- 58 - Programa 15 – Leitura do Canal AN0 (0 a 1023) ------------------------------- 63 - Programa 16 – Leitura do canal AN0 (0 a 5V) ---------------------------------- 64 - Programa 17 – Leitura do Canal A/D com ponto flutuante -------------------- 65 - Programa 18 – Controle PWM usando conversor A/D ------------------------- 66 - Comunicação Serial ----------------------------------------------------------------- 67 - Programa 19 – Transmissão de dado Serial -------------------------------------- 67 - Programa 20 – Transmissão/Recepção Serial ------------------------------------ 68 - Programa 21 – Transmissão/Recepção de Dados-------------------------------- 69 - Programa 22 - Uso de Ponteiros na Transmissão de Dados -------------------- 70 - Programa 23 – Transmissão de Dados -------------------------------------------- 71 - Programa 24 – Leitura de Temperatura e Transmissão Serial ----------------- 73 - Programa 25 – Leitura de Temperatura, Comparação e Acionamentos ------ 74 - Programa 26 – Configuração do TIMER0 em 8 bits – Temporizador ------- 79 - Programa 27 – Configuração do TIMER0 em 16 bits – Temporizador ----- 80 - Programa 28 – Configuração do TIMER0 em 8 bits – Contador ------------- 81 - Programa 29 – Memória EEPROM do PIC -------------------------------------- 82 - Introdução a Interrupção ------------------------------------------------------------ 84 - Registrador RCON ------------------------------------------------------------------ 85 - Registrador INTCON ---------------------------------------------------------------- 86 - Registrador INTCON2 ---------------------------------------------------------------- 87 - Registrador INTCON3 ---------------------------------------------------------------- 88 - Registrador PIE1 ----------------------------------------------------------------------- 89 - Registrador PIE2 ----------------------------------------------------------------------- 90 - Registrador PIR1 ----------------------------------------------------------------------- 91 - Registrador PIR2 ----------------------------------------------------------------------- 92 - Registrador IPR1 ----------------------------------------------------------------------- 93 - Registrador IPR2 ----------------------------------------------------------------------- 94 - Estrutura de Programa utilizando Alta e Baixa Prioridade ----------------------- 94 - Programa 30 – Tratamento de Interrupção INT0 ---------------------------------- 95 - Programa 31 – Tratamento de Interrupção INT0 e INT1 ------------------------ 97 - Programa 32 – Tratamento de Interrupção INT0 e INT1 com Prioridade ----- 99


3

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.


4

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


5

Estrutura Interna do PIC 18F452


6

Função de cada pino do 18F452

O PIC 18F452 possui cinco PORTs: PORTA, PORTB, PORTC, PORTD e PORTE. Cada PORT possui pinos com acesso aos periféricos como Conversor Analógico/Digital, Interrupções, I2C, UART, Módulo CCP, SPI, ou podem ser utilizados como I/O de uso geral. Pino Função Tipo Funcionalidade 1 /MCLR / VPP In-In Reset externo e programação ICSP 2 RA0 / AN0 I/O e input

A/D I/O digital e entrada do AD0

3 RA1 / AN1 I/O e input A/D

I/O digital e entrada do AD1

4 RA2 / AN2/ Vref- I/O e input A/D

I/O digital, entrada do AD2 e entrada baixa de referência do A/D

5 RA3/AN3/ Vref+ I/O e input A/D

I/O digital, entrada do AD3 e entrada de referência alta do A/D

6 RA4 / T0CKI I/O e Input TMR0

I/O digital e entrada do TMR0

7 RA5/AN4/SS/LVDIN I/O e Inputs I/O digital, entrada do AD4, entrada do SPI e Detector de LV

8 RE0 / RD / AN5 I/O I/O digital, Leitura da Porta Paralela e entrada do AD5

9 RE1 / WR / AN6 I/O I/O digital, Escrita da Porta Paralela e entrada do AD6

10 RE2 / CS / AN7 I/O I/O digital, Seleção da Porta Paralela e entrada do AD7

11, 32 VCC Fonte Positivo da Fonte de Alimentação 12, 31 GND Fonte Negativo da Fonte de Alimentação 13 OSC1 / CLK1 Input Entrada do Cristal e entrada do Clock

externo 14 Osc2 / CLK1 / RA6 I/O e Inputs I/O digital, Saída do Cristal e saída do

Clock externo 15 RC0/T10S0/T1Ck1 I/O Out e In I/O digital, saída do 2° oscilador e

entrada do contador externo Timer1/Timer3


7

16 RC1/T10S1/CCP2 I/O In e Out I/O digital, entrada do 2° oscilador e saída do Módulo CCP2

17 RC2 / CCP1 I/O e Out I/O digital e saída do Módulo CCP1 18 Rc3 / SCK / SCL I/O, I/O e I/O I/O digital, in e out do Clock serial

para modo SPI e in/out do Clock serial para modo I2C

19 RD0 / PSP0 I/O e I/O I/O digital e Porta de Comunicação Paralela




23 RC4 / SDI / SDA I/O in I/O I/O digital, entrada de Dados SPI e in/out de dados do modo I2C

24 RC5 / SD0 I/O e out I/O digital e saída de dados SPI 25 RC6 / TX / CK I/O out I/O I/O digital, Transmissão UART e

Clock de sincronismo UART 26 RC7 / RX / DT I/O in I/O I/O digital, Recepção UART e Dados

do UART 27 RD4 / PSP4 I/O e I/O I/O digital e Porta de Comunicação

Paralela 28 RD5 / PSP5 I/O e I/O I/O digital e Porta de Comunicação



Paralela 33 RB0 / INT0 I/O e in I/O digital e entrada de Interrupção

Externa 0 34 RB1 / INT1 I/O e in I/O digital e entrada de Interrupção

Externa 1 35 RB2 / INT2 I/O e in I/O digital e entrada de Interrupção

Externa 2 36 RB3 / CCP2 I/O e I/O I/O digital Módulo CCP2 37 RB4 I/O e in I/O digital e entrada de Interrupção

por Mudança de Estado 38 RB5 / PGM I/O in e in I/O digital, Interrupção por Mudança

de Estado e Habilita ICSP baixa tensão

39 RB6 / PGC I/O in I/O I/O digital, Interrupção por Mudança de Estado e ICSP in-circuit Debuger

40 RB7 / PGD I/O in I/O I/O digital, Interrupção por Mudança de Estado e ICSP in-circuit Debuger


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. 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, Conversores A/D, USART, etc. O Microcontrolador 18F452 possui memória RAM de 1536 bytes sendo dividido em 16 bancos de 256 bytes de memória cada um. Mapa de Registradores Especiais – SFRs


9

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


10

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. Temos então as operações E ou AND, OU ou OR e Não ou NOT e também NAND, NOR ou XOR ( OR EXCLUSIVO). OR

AND

NOT

NOR

NAND

XOR

A B S 0 0 0 0 1 1 1 0 1 1 1 1

A B S 0 0 0 0 1 0 1 0 0 1 1 1

A S 0 1 1 0

A B S 0 0 1 0 1 1 1 0 1 1 1 0

A B S 0 0 1 0 1 0 1 0 0 1 1 0

A B S 0 0 0 0 1 1 1 0 1 1 1 0


11

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, no entanto, a função Main() é a primeira a ser executada. /* ------------------------------------------------- abaixo temos um exemplo de estrutura Básica de um programa em Linguagem C ----------------------------------------------------- */ void main() // esta é a primeira função que será executada { // inicializa a função Trisb=0x00; // aqui entram os comandos que serão executados Portb=0xFF; } // finaliza a função Observações: Toda função deve iniciar abrindo chave e finalizar fechando-se a chave. 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. Utilizamos // para comentários em apenas uma linha. Representação Numérica: Decimal: Contador=125; Binário: Portb=0b11010011; Hexadecimal: Variável1=0xA4; Octal: Teste=075; String: Unsigned char *texto=”Uptex Tecnologia” Caracter: Usart_write(‘&’);


12

Tipos de Dados: Dado: Tipo: int Números inteiros char Caracteres float e double Números decimais (ponto flutuante) void valores nulos

Tipo Tamanho – bits Valor Mínimo Valor Máximo Void Zero Sem valor Sem valor Char 8 -128 127 Int 16 -32768 32767

Short 16 -32768 32767 Long 32 -231 231-1 Float 32 -3,4 x 1038 3,4 x 1038

Double 64 -1,8 x 10308 1,8 x 10308 Modificadores:

Tipo Tamanho - bits Valor Mínimo Valor Máximo Char 8 -128 127

signed char 8 -128 127 unsigned char 8 0 255

Short int 8 -128 127 signed short int 8 -128 127

unsigned short int 8 0 255 Int 16 -32768 32767

signed 16 -32768 32767 unsigned int 16 0 65535

Short 16 -32768 32767 signed short 16 -32768 32767

unsigned short 16 0 65535 long int 32 -231 231-1

signed long int 32 -231 231-1 unsigned long int 32 0 232-1


13

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; // atribui o valor 10 à variável contador Var1 = 25; // atribui o valor 25 à variável Var1 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); }


14

Operadores Matemáticos: Aritméticos: Operador Descrição Exemplo

+ Soma dos argumentos a + b - Subtração dos argumentos a – b * Multiplicação dos argumentos a * b / Divisão dos argumentos a / b

% Resto da divisão a % b ++ Soma 1 ao argumento (a=a+1) a++ -- Subtrai 1 ao argumento (a=a-1) a--

Relacionais:

Operador Descrição > Maior que < Menor que

>= Maior ou igual que <= Menor ou igual que == Igual != Diferente

Lógicos: Operador Descrição && Lógica E (AND) | | Lógica OU (OR) ! Complemento (NOT) 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


15

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


16

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


17

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


18

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


19

Exemplo: void main( ) { int a=15; While (a>10) { a--; delay_ms(100); } } Loop DO - WHILE: Neste caso, diferente do loop anterior (while), o do - 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. Sintaxe: do { comando1; comando2; } while (expressão); Exemplo: void main( ) { int a=0; do { a++; delay_ms(100); } while (a<100); }


20

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


21

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


22

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


23

Criando um Projeto: Para iniciar o desenvolvimento necessitamos inicialmente criar um projeto pois o compilador trabalha com esta concepção. Para isso, basta clicar em <Project> e em seguida <New Project>. 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. Description é opcional; é onde pode ser feita uma descrição sobre o que faz o projeto. Device é escolhido o microcontrolador utilizado pelo projeto. Clock é informado qual a freqüência que o microcontrolador irá trabalhar.


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. Funções estas que podem ser tipo de oscilador, habilitar WatchDog, Código de proteção, etc. Clock:

PIC 18F452

Resistor RS pode ser necessário para melhor funcionamento do cristal. O PIC 18F452 pode funcionar com os seguintes tipos de clock: LP cristal de baixa freqüência XT cristal ou ressonador HS cristal ou ressonado de alta freqüência HS + PLL Cristal ou ressonador com PLL habilitado RC Resistor e capacitor externo RCIO Resistor e capacitor externo e liberação de 1 pino de I/O EC Clock externo ECIO Clock externo e liberação de 1 pino de I/O Valores de capacitores que devem ser acoplado ao cristal:


25

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


26

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.


27

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


28

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


29

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:


30

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 } }


31

Uma vez escrito o programa, para compilar basta pressionar “CTRL + F9” ou, clicar em Menu Project e em seguida a opção Build, conforme figura abaixo:

Não apresentando nenhum erro, 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).


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, precisamos ainda configurar o ICPROG para o correto funcionamento com a placa CUSCOPIC. Para isso, clica-se em Configuração, opção Hardware e selecione o programador (TAIT SERIAL PROGRAMMER), Interface Direct I/O e em comunicação deve-se Inverter o MCLR.


33

Identificação dos botões:

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


34

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. Agora é só testar.


35

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


36

Usando Debug no MikroC: Ao clicar no Menu “RUN” e selecionado “START DEBUGGER”, a janela abaixo será apresentada:

Em “Select Variable from list, seleciona-se o registrador que deseja visualizar e clica-se em “Add”.


37


38

Para dar início à simulação, (Debugger), deve-se clicar no botão conforme figura abaixo ou, se desejar, pressionando a tecla “F9”.

Temos também as teclas: “F7” = faz simulação passo a passo; “F6” = inicia modo Run.

- Run/Pause Debugger (F6); - Stop Debugger (Ctrl + F12); - Step Over (F8); - Step Out (Ctrl + F8); - Run to Cursor (F4); - Step Into (F7).


39

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


40

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; // configura RD0 entrada restante como saída portd = 0; // todos os pinos de saída do portd = nível baixo while(1) //loop infinito { if (portd.f0==0) //testa de RD0 está em nível baixo portd=0; // se sim todo portd em nível baixo else portd.f7=1; //se RD0=1 então RD7 é ativado } }


41

/********************************************************************** 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; // configura todo o portc como saída trisd = 0b00000001; // configura RD0 entrada restante como saída portd = 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.f0==0) //RD0 está pressionado? portc=0xFF; // se sim todo portc em nível alto else { portc=0; portd.f2=1; delay_ms(1000); portd.f2=0; delay_ms(1000); } } }


42

/********************************************************************** 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; // define todo o portc como saída trisd=0b00000001; // define RD0 como entrada e restante dos pinos como saída portd=0; // coloca portd em 0 portc=0; // coloca portc em 0 while(1) { if (portd.f0==0) // RD0 esta presionado? //se está, faz o que está entre chaves abaixo { portc=0xff; delay_1sec(); portc=0; delay_1sec(); } else // se for = 1 - botão pressionado // então faz o que está entre chaves abaixo { portc=0; portd.f2=1; delay_ms(1000); portd.f2=0; delay_ms(1000); } } }


43

/********************************************************************** 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; // define todo o portc como saída trisd=0b11111111; // define todos os pinos do portd como entrada portc=0; // coloca portc em 0 while(1) { if (portd.f0==1) // RD0 esta presionado? se nao, pula para testar RD1 portc.f0=1; // se pressionado, entao aciona RC0 else if (portd.f1==1) // RD1 esta presionado? se nao, pula para testar RD2 portc.f1=1; // se pressionado, entao aciona RC1 else if (portd.f2==1) // RD2 esta presionado? se nao, pula para testar RD3 portc.f2=1; // se pressionado, entao aciona RC2 else if (portd.f3==1) // RD3 esta presionado? se nao, pula para testar RD4 portc.f3=1; // se pressionado, entao aciona RC3 else if (portd.f4==1) // RD4 esta presionado? se nao, pula para testar RD5 portc.f4=1; // se pressionado, entao aciona RC4 else if (portd.f5==1) // RD5 esta presionado? se nao, pula para testar RD6 portc.f5=1; // se pressionado, entao aciona RC5 else if (portd.f6==1) // RD6 esta presionado? se nao, pula para testar RD7 portc.f6=1; // se pressionado, entao aciona RC6 else if (portd.f7==1) // RD7 esta presionado? se nao, volta ao loop para testar //chaves portc.f7=1; // se pressionado, entao aciona RC7 } }


44

Função Button: Button(&portX, pinoX, tempoX, Estado_Tecla) Onde: &portX = port da tecla (porta, portb, portc, portd ou porte); pinoX = é o pino onde está conectado a tecla (varia de 0 à 7); tempoX = tempo de Debounce em milisegundos; 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, aguardar soltar o botão. *********************************************************************/ void main() { trisc=0; // define todo o portc como saída trisd=0b00000001; // define RD0 como entrada e restante como saída portc=0; // coloca portc em 0 while(1) { if (button(&portd, 0, 20, 1)) // &port identifica o port, 0 identifica o pino, // 20ms é o tempo e 1 é nível para tecla acionada { portc.f0=~portc.f0; // se pressionado, então aciona RC0 while(portd.f0==1); // aguarda soltar o botão { } } } }


45

/********************************************************************** 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). *********************************************************************/ void main() { trisc=0; // define todo o portc como saída trisd=0xFF; // define todo o portd como entrada portc=0; // coloca portc em 0 while(1) { if (button(&portd, 0, 20, 1)) // &port identifica o port, 0 identifica o pino, // 20ms é o tempo e 1 é nível para tecla acionada portc.f0=1; // se pressionado aciona RC0 else if (button(&portd, 1, 20, 1)) portc.f1=1; else if (button(&portd, 2, 20, 1)) portc.f2=1; else if (button(&portd, 3, 20, 1)) portc.f3=1; else if (button(&portd, 4, 20, 1)) portc.f4=1; delay_ms(200); } } Exercício: 1) Imagine que vamos montar um circuito que controle através de 4 chaves (ligar/desligar) a iluminação de uma casa. Esse controle ficará no quarto do casal, ao lado da cama, podendo com praticidade controlar/monitorar a iluminação da casa. Então teremos as chaves em RD0, RD1, RD2 e RD3 e as saídas para acionar os relés em RD4, RD5, RD6 e RD7. Pressionado RD1 acende iluminação da sala e pressionado RD1 novamente apaga. Idem para RD2 (cozinha), RD3 (quarto 1) e RD4 (quarto 2).


46

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


47

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


48

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. Utilizaremos um Display alfanumérico 16x2 (dezesseis caracteres e duas linhas). O interessante é que o display já possui internamente outro microcontrolador que gerencia as funções do mesmo. Isto facilita bastante o desenvolvimento do projeto pois, o programador se preocupa apenas em enviar os dados e a localização onde quer que os mesmos apareçam no display. 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 - RW=1 Leitura RW=0 Escrita 6 Seleção - Enable – Chip Select 1 ou 1 p/ 0 habilita e em 0 desabilita 7 B0 - Barramento de Dados 8 B1 - Barramento de Dados 9 B2 - Barramento de Dados

10 B3 - Barramento de Dados 11 B4 - Barramento de Dados 12 B5 - Barramento de Dados 13 B6 - Barramento de Dados 14 B7 - 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 81 82 83 84 85 86 87 88 89 8A 8B 8C 8D 8E 8F C0 C1 C2 C3 C4 C5 C6 C7 C8 C9 CA CB CC CD CE CF


49

Comandos disponíveis:


50

No MikroC podemos utilizar um LCD em dois modos: - Modo 4 bits - Modo 8 bits Quando utilizamos o Modo 8 bits, utilizamos um port para envio de dados e, para os sinais de controle utilizamos alguns pinos de outro port. Por exemplo: RD0 a RD7 para dados e RB7, RB6 e RB5 para sinais E, R/W e R/S. Quando utilizamos o Modo 4 bits, podemos utilizar somente um port para dados e controle ou utilizar dois ports, um para dados e outro para controle. No KIT CUSCOPIC utilizaremos o Modo 4 bits usando o portb para envio de dados e também sinais de controle. Temos então: R/S = RB1, EN = RB0, R/W=RB2, dados = RB4, RB5, 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. Sintaxe: lcd_config(&portX, R/S, EN, R/W, pin_dado, pin_dado, pin_dado, pin_dado) Onde: &portX=port utilizado A,B,C,D ou E; R/S = pino utilizado para controle R/S; EN = pino utilizado para controle R/S; R/W = pino utilizado para controle R/W; pin_dados = pinos utilizados para envio de dados Para nosso KIT teremos então: lcd_config(&portb,1,0,2,7,6,5,4);


51

Muito bem, 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"; void main() { unsigned i; trisb=0; lcd_config(&portb,1,0,2,7,6,5,4); lcd_Cmd(Lcd_Cursor_off); lcd_out(1, 1, text); while(1){ lcd_cmd(lcd_return_home); lcd_cmd(lcd_underline_on); for(i=0;i<=15;i++){ lcd_cmd(Lcd_move_cursor_right); delay_ms(100); } for(i=0;i<=15;i++){ lcd_cmd(Lcd_move_cursor_left); delay_ms(100); } lcd_Cmd(Lcd_turn_off); delay_ms(500); lcd_Cmd(Lcd_turn_on); } }


52

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; lcd_config(&portb,1,0,2,7,6,5,4); lcd_cmd(Lcd_Cursor_off); lcd_cmd(lcd_clear); Lcd_out(1, 1,"Uptex Tecnologia"); Lcd_out(2, 1,"& Treinamentos"); delay_ms (3000); lcd_cmd(lcd_clear); delay_ms (500); Lcd_out(1, 1,"cursos Rapidos"); Lcd_out(2, 1,"com qualidade"); delay_ms (2000); lcd_cmd(lcd_clear); delay_ms (500); Lcd_out(1, 1,"Av. Benjamim"); Lcd_out(2, 1,"Constant, 1429"); delay_ms (2000); lcd_cmd(lcd_clear); delay_ms (500); Lcd_out(1, 1,"Visite o site"); Lcd_out(2, 1," uptex.com.br "); delay_ms (2000); lcd_cmd(lcd_clear); delay_ms (500); } } Exercício: - Para o exercício da página 45 (controle de iluminação residencial), implemente o projeto apresentando no módulo LCD uma tela de apresentação da sua Empresa assim que o equipamento é ligado e, conforme é ativado/desativado a iluminação dos ambientes, o resultado é apresentado no visor podendo assim, o usuário monitorar pelo LCD o funcionamento do sistema.


53

Podemos, no entanto, ter um Hardware diferente do nosso KIT. Por exemplo, 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. Neste caso, teremos que utilizar o seguinte comando: lcd8_config(&port_control, &port_data, RS,EM,RW,D7,D6,D5,D4,D3,D2,D1,D0); Onde: &port_control: port utilizado para sinais de controle (3 bits); &port_data: port utilizado para sinais de dados (8 bits); RS: pino do PIC que está ligado ao sinal RS responsável pelo controle (inst/dado); 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; D7 à D0: pinos do PIC que estão ligados no LCD – port_data. Exemplo de configuração onde controle está no porte e dados no porte lcd8_config(&porte, &portb, 2,1,0,7,6,5,4,3,2,1,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,coluna,”informação”); Exemplo: Escrever Uptex na primeira linha e Tecnologia na segunda linha: lcd8_out(1,5,”Uptex); lcd8_out(2,1,”Tecnologia”); É possível também que o Hardware utilize 2 ports em 4 bits onde, um dos ports será responsável pelos sinais de controle (4 bits) e outro port responsável pelos dados. Por exemplo: porte sinais de controle e portb dados. O comando utilizado será: lcd_custom_config(&port_data, D7,D6,D5,D4, &port_control, RS, RW, EN); Exemplo : Lcd_custom_config(&portb,4,5,6,7, &porte, 1,2,3) ;


54

Módulo PWM (Pulse Width Modulation) – Modulação por largura de pulso Encontramos uso do mesmo em Inversores de freqüência, controle de servo motores, Fontes chaveadas, controle de potência e velocidade de motores, etc.

Conforme figura acima, uma onda pulsante, com amplitude 5V é acionada/desacionada no tempo. 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). Para a figura acima, como 50% do tempo a onda fica em 5V e 50% em 0V; obtemos neste caso uma tensão média de 2,5V. 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. Portanto, para um duty-cycle de 50% temos metade do tempo com a onda em VCC e a outra metade em 0V. Isso implica em uma tensão média de 2,5V, o que significa que se colocarmos uma fonte contínua com 2,5V produz o mesmo efeito que a fonte pulsante de 5V com duty-cycle de 50%. O PIC 18F452 possui 2 módulos CCP – CCP1 e CCP2 (Capture/Compare/PWM) Os Comandos abaixo são para o Módulo CCP1: - pwm_init(X) Onde X é o valor da freqüência em Hz; - 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. Exemplo: para duty-cycle de 50% basta colocar valor de Y=127. - pwm_start( ) Inicia o Módulo; -pwm_stop( ) Finaliza o módulo PWM


55

Para o Módulo CCP2 temos os seguintes comandos: pwm2_init(X); pwm2_change_duty(Y); pwm2_start( ); pwm2_stop( ) ; Exemplos: Utilizando o osciloscópio, 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%. void main(){ pwm_init(1000); pwm_change_duty(127); pwm_start(); while(1); } /********************************************************************** 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(25); pwm2_start(); while(1); }


56

/********************************************************************** 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); pwm2_change_duty(254); pwm2_start(); pwm1_init(250); pwm1_change_duty(10); pwm1_start(); while(1); } Exercício : Modifique os valores dos duty-cycle e verifique com o osciloscópio o resultado.


57

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


58

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


59

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: - ADCON0 - ADCON1 Como os registradores são de 8 bits e a resolução do A/D é de 10 bits, teremos então 2 registradores para receberem os dados da conversão: - ADRESH - ADRESL Com isso, poderemos fazer é a justificativa à direita ou justificativa à esquerda. Isso funciona da seguinte maneira: Caso seja configurado para justificativa à direita, os 8 bits menos significativos ficarão no registrador ADRESL e os 2 bits mais significativos ficarão em ADRESH. Caso seja configurado para justificativa à esquerda, os 8 bits mais significativos ficarão no Registrador ADRESH e os 2 bits menos significativos estarão em ADRESL. Agora, o bit responsável por esta seleção é o ADFM ADFM=0 - justificativa será à esquerda ADFM=1 - justificativa será à direita O bit ADFM está presente no Registrador ADCON1 que será visto em seguida.


60

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 - Conversor A/D está desligado 1 - Conversor A/D está ligado OBS: O conversor A/D necessita de 1,6µs para poder realizar a conversão e, com isso, é necessário certa atenção na hora de configurar os bits ADCS2, ADCS1 e ADCS0 pois precisamos verificar o cristal utilizado.

Operation ADCS2:ADCS1:ADCS0 Freqüência Máxima 2 TOSC 000 1,25 MHz 4 TOSC 100 2,5 MHz 8 TOSC 001 5,00 MHz

16 TOSC 101 10,00 MHz 32 TOSC 010 20,00 MHz 64 TOSC 110 40,00 MHz

RC 011 --------------


61

Registrador ADCON1:


62

Exercício: a) Dado a tabela acima para configurar os Registradores, 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. c) Para ADCON1=0b00001110, descreva como está configurado cada pino do porta. Como nosso Módulo A/D é de 10 bits, teremos então 1024 respostas. Geralmente usa-se AN3 e AN2 em VCC e GND como referência. Importante ressaltar que jamais poderemos aplicar uma referência externa superior a tensão de alimentação do PIC. Abaixo temos a fórmula usada para a conversão: Resposta = (Vin – Vref-) * 1023 / (Vref+ - Veref-) Onde: Resposta é o valor compreendido entre 0 e 1023 Vref+ e Vref- 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- = 1V, calcule a resposta sendo a tensão aplicada de 3,5V.

b) Para as mesmas tensões de referência do exercício anterior, calcule a tensão aplicada no canal A/D para Resposta=712.

c) Para Vref+=5V e Vref-=0V, calcule o valor da resposta para Vin=2,5V. d) Para exercício anterior, caso resposta seja 757, 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. Exemplo: Temperatura = Adc_read(3); // temperatura recebe o valor do sinal enviado do //sensor ligado na entrada RA3


63

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 - valor 0 a 1023. *********************************************************************/

// programa que mostra o valor lido no canal 0 - valor este entre 0 e 1023. char texto[16]; int leitura_canal; void main() { trisc=0; trisd=255; // configura portd como entrada trisb=0; // configura portb como saída trisa.f0=1; // configura RA0 como entrada adcon1= 0b00001110; // configura RA0 como entrada analógica e demais //pinos como I/O digital. lcd_config(&portb,1,0,2,7,6,5,4); lcd_cmd(lcd_cursor_off); lcd_out(1,1, "canal AN0: "); delay_ms(20); do { leitura_canal=adc_read(0); wordtostr(leitura_canal,texto); lcd_out(2,1, texto); } while(1); }


64

/********************************************************************** 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 - valor 0 a 5V *********************************************************************/

// programa que mostra apenas o valor de 0 a 5 volts int leitura_canal; char texto[16]; void main() { trisc=0; trisd=255; // configura portd como entrada trisb=0; // configura portb como saída trisa.f0=1; // configura RA0 como entrada adcon1= 0b00001110; // configura RA0 como entrada analógica e demais //pinos como I/O digital. lcd_config(&portb,1,0,2,7,6,5,4); lcd_cmd(lcd_cursor_off); lcd_out(1,1, "canal AN0: "); delay_ms(20); do { leitura_canal=adc_read(0); // leitura_canal=(leitura_canal*5)/1023; //mostra 0 a 5v leitura_canal=(leitura_canal)/0.2048 ; //mostra 0 a 5000mv wordtostr(leitura_canal,texto); lcd_out(2,1, texto); // lcd_out(2,11,"Volts"); lcd_out(2,7,"mili Volts"); } while(1); }


65

/********************************************************************** 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 - valor 0 a 5V com ponto flutuante. *********************************************************************/ // programa que mostra apenas o valor de 0 a 5 volts com ponto flutuante int leitura_canal; char texto[16]; int leitura_ch0; float valor = 0; void main() { trisc=0; trisd=255; // configura portd como entrada trisb=0; // configura portb como saída trisa.f0=1; // configura RA0 como entrada adcon1= 0b00001110; // configura RA0 como entrada analógica e demais pinos //como I/O digital. lcd_config(&portb,1,0,2,7,6,5,4); lcd_cmd(lcd_cursor_off); lcd_out(1,1, "canal Ch0: "); delay_ms(20); do { lcd_cmd(lcd_clear); lcd_out(1,1, "canal Ch0: "); delay_ms(20); leitura_ch0=adc_read(0); valor= leitura_ch0 * 0.0048 ; //mostra 0 a 5000mv floattostr(valor,texto); delay_us(10); lcd_out(2,1, texto); lcd_out(2,13,"Volt"); delay_ms(1000); } while(1); }


66

/********************************************************************** 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. *********************************************************************/ // controlar o canal PWM através da entrada analógica AN0 - potenciômetro void main () { unsigned int valor=0; char texto[7]; adcon1=0b00001110; //configura RA0 como entrada e demais como I/O digital trisa.f0=1; //configura RA0 como entrada lcd_config(&portb,1,0,2,7,6,5,4); lcd_cmd(lcd_cursor_off); pwm_init(10000); pwm_start(); do { valor=adc_read(0); pwm_change_duty(valor/4); valor=((valor/4)*100)/255; delay_10us; inttostr(valor,texto); lcd_out(1,1, "Duty= "); Lcd_out(1,7, texto); lcd_chr(1,15, '%'); } while(1); }


67

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, PCs, etc. Podemos configurá-lo para as seguintes taxas(bps): 110, 220, 300, 600, 1200, 2400, 4800, 9600, 14400, 19200, etc. 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. As Funções abaixo são responsáveis pelo tratamento da Comunicação Serial no MikroC: Usart_init(taxa); inializa o módulo de comunicação do pic e configura a taxa de transmissão. Usart_write(‘x’) – comando para enviar o dado. Usart_read( ) – comando para fazer leitura do dado no Buffer Serial. Usart_ready( ) – função para saber se Buffer está vazio ou se chegou algum dado. 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); while(1) { if (button(&portd,0,100,1)) {


68

usart_write('U'); delay_ms(1000); usart_write('p'); delay_ms(1000); usart_write('t'); delay_ms(1000); usart_write('e'); delay_ms(1000); usart_write('x'); } } } /********************************************************************** 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). *********************************************************************/ // transmite/recebe caracteres via serial para usart terminar do MikroC ou ComDebug2 unsigned short dado; void main() { trisc=0x00; portc=0; trisd=0xff; usart_init(9600); do { if (usart_data_ready()) { dado=usart_read(); delay_ms(2000); usart_write(dado); if (dado=='L') portc.f0=1; if (dado=='D') portc.f0=0; } } while(1); }


69

/********************************************************************** 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. *********************************************************************/ // transmite/recebe caracteres via serial para usart terminar do MikroC ou ComDebug2 char dados[4]; short i; void compara_dados() { if((dados[0]=='S') && (dados[1]=='1') && (dados[2]=='1')) portc.f1=1; if((dados[0]=='S') && (dados[1]=='1') && (dados[2]=='0')) portc.f1=0; } void main() { trisc=0; portc=0; usart_init(9600); // inicializa usart (8bits, baud rate 9600, no parity bit... i=0; while(1) { if (usart_data_ready()) { dados[i]=usart_read(); i++; if(dados[i-1]==0x0D) // verifica se chegou o comando ENTER { compara_dados(); for(i=0;i<=3;i++) dados[i]='\0'; i=0; } } } }


70

/********************************************************************** 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"; void main() { usart_init(9600); do { usart_write(*p1); // envia um caracter pela porta serial *p1++; // incrementa o ponteiro delay_ms(200); // mudar tempo para verificar resultado na transmissão dos dados } while (*p1!='\0'); // verifica se ponteiro enviou o último caracter }


71

/********************************************************************** 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, PIC e PC *********************************************************************/ char texto [16]; void main () { unsigned char dado; trisb=0; trisd=0; portd=0; usart_init(9600); Lcd_Config(&portb,1,0,2,7,6,5,4); LCD_Cmd(lcd_cursor_off); Lcd_Cmd(Lcd_clear); Lcd_out(1,1, "Comunicação: "); Lcd_out(2,1, "PC / PIC / LCD"); delay_ms(10000); do { if (usart_data_ready()) // se chegou algum byte no buufer, entao: { dado=usart_read(); usart_write(dado); } switch(dado) { case 'a': portd.f0=1; Lcd_out(1,1, "Dado Enviado: "); Lcd_chr(1,15, 'a');


72

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


73

/********************************************************************** 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; char texto[16]; void main() { trisc=0; trisd=255; // configura portd como entrada trisb=0; // configura portb como saída trisa.f1=1; // configura RA1 como entrada adcon1= 0b00000100; // configura RA0, RA1 e RA3 como entrada analógica e //demais pinos como I/O digital. lcd_config(&portb,1,0,2,7,6,5,4); lcd_cmd(lcd_cursor_off); lcd_out(1,1, "Temperatura: "); delay_ms(20); usart_init(9600); do { delay_ms(10000); leitura_canal=adc_read(1); leitura_canal=(leitura_canal)/2.048 ; //mostra temperatura 28mv = 28 graus inttostr(leitura_canal,texto); usart_write(leitura_canal); lcd_out(2,1, texto); lcd_out(2,7,"oC"); } while(1); }


74

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

}


75

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. 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 Timer0 pode ser configurado para trabalhar em 8 ou 16 bits fazendo contagem (0 a 255 ou 0 a 65535). 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, funcionando igual ao Timer0, porém pode-se acoplar um cristal externo para gerar os pulsos de clock (RC0 e RC1). Também possui um Prescaler dedicado.

O Timer2 é um timer de 8 bits mas com funcionamento diferente. O “estouro” do Timer2 ocorre quando igualar o valor do Timer2 com o valor do Registrador PR2. Quando isso ocorre, uma nova contagem é realizada. Este timer possui ainda o Postscale que trabalha contando o número de estouro (igualdade entre timer2 e PR2). Após realizar N comparações é que irá ocorrer o “estouro” do Timer2.

O Timer3 é um temporizador/contador de 16 bits possuindo também um Prescaler dedicado.

Timer0: O Registrador T0CON é responsável pela configuração deste timer. Abaixo temos o

Registro e a função de cada bit. T0CON

TMR0ON T08BIT T0CS T0SE PSA T0PS2 T0PS1 T0PS0 Os 3 primeiros bits são responsáveis pela seleção do Prescaler

T0PS2 T0PS1 T0PS0 Prescaler 0 0 0 1:2 0 0 1 1:4 0 1 0 1:8 0 1 1 1:16 1 0 0 1:32 1 0 1 1:64 1 1 0 1:128 1 1 1 1:256

PSA: Bit de seleção do Prescaler 0 = prescaler será utilizado 1 = Prescaler não será utilizado. Neste caso, a tabela acima não tem valor, ou seja,

conseguimos então Prescaler 1:1 – a cada pulso o timer0 será incrementado.


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. São eles: TMR0L: Responsável pela contagem da parte baixa (0 a 255). 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. 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; 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.

Utilizaremos então cristal de 4MHz e Prescaler de 1:64


77

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). 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, fazemos a seguinte conta: 65536 – 15625 = 49911 Este valor 49911 deve ser convertido de decimal para hexadecimal = C2F7 Então, TMR0H = C2 e TMR0L = F7 Exercício: a) Seguindo a idéia do exemplo anterior, mude o tempo on/off do Led para 10s e

modifique o Prescaler para 256. Encontre os valores que devem ser carregados em TMR0L e TMR0H.

b) Como deverá ficar configurado o Registrador T0CON para o exercício anterior? c) Calcular o tempo de estouro do Timer0 onde T0CON = 0B10000010 e

TMR0H=0x9E e TMR0L=0x58 Registrador INTCON: Para configurar as interrupções que o microcontrolador poderá atuar, precisamos conhecer os bits deste registrador.

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. 0 = nenhuma interrupção será tratada. 1 = liga chave geral para tratamento das interrupções.


78

PEIE/GIEL: Bit que habilita interrupções de baixa prioridade 0 = desativado baixa prioridade. 1 = ativado alta prioridade. TMR0IE: Bit que habilita tratamento de interrupção por estouro no TMR0. 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. Por hora, como estamos trabalhando apenas com o Timer0, estaremos usando os Registradores INTCON, T0CON, TMR0H e TMR0L.


79

/********************************************************************** 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 - Temporizador *********************************************************************/

//programa que faz uso do Interrupção - Timer0 em 8 bits //aciona RD0 a cada 1 segundo unsigned contagem; void interrupt() { contagem++; // incrementa variável de contagem TMR0L = 0; INTCON = 0x20; // Seta T0IE, e limpa a flag do estouro do TMR0 = T0IF }//~ void main() { T0CON = 0b11000001; // habilita contagem do TMR0, configura para 8 bits TRISD = 0; // e prescaler 1:4 portd=0; TMR0L = 0; tmr0h = 0; INTCON = 0xA0; // Habilita chave geral para estouro do TMR0 contagem = 0; // Initialize variável contagem do { if (contagem == 1000) { // para contagem = 1000 teremos 1,02ms x 1000 = 1,02s PORTD.f0 = ~portd.f0; // troca estado do RD0 contagem = 0; // Reseta contagem } } while(1); }


80

/********************************************************************** 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 - Temporizador *********************************************************************/

//programa que faz uso do Interrupção - Timer0 em 16 bits //aciona RD0 a cada 2 ou 5 segundos void interrupt() { PORTD.f0 = ~portd.f0; // troca estado do RD0 TMR0L = 0xF3; TMR0H = 0xC2; INTCON = 0x20; // Seta T0IE, e limpa a flag do estouro do TMR0 = T0IF } void main() { T0CON = 0b10000110; // habilita contagem do TMR0, configura para 16 bits TRISD = 0; // e prescaler 1:128 portd=0; // para 5 segundos: x=5/128us=39062 onde valor inicial será

//65532-39062 = 26470 que em hexa=0x6766 TMR0L = 0x66 e //TMRH=67;

TMR0L = 0xF3; TMR0H = 0xC2; // para 2 segundos: x=2/128us= 15625 onde valor inicial

//será 65532 - 15625 = 49907 que em hexa=C2F3 //TMR0L=0xF3 e TMRH=C2;

INTCON = 0xA0; // Habilita chave geral para estouro do TMR0 do { portd.f4=1; delay_ms(250); portd.f4=0; delay_ms(250); } while(1); }


81

/********************************************************************** 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 - Contador *********************************************************************/

int contagem=0; char texto[15]; void main( ) { T0CON=0b11101000; //configura timer0 em 8 bits, sem uso prescaller e 1:1 trisd=0; portd=0; TMR0L=255; //carrega timer0 com 255 (basta 1 pulso para gerar interrupção INTCON.TMR0IF=0; //inicializa flag de estouro do Timer0 em nível baixo LCD_Config(&portb,1,0,2,7,6,5,4); LCD_Cmd(LCD_Cursor_Off); LCD_Cmd(Lcd_Clear); LCD_Out(1,1, “Contador Pulsos”); do { if (INTCON.TMR0IF==1) { portd++; contagem++; wordtoStr(contagem,texto); LCD_Out(2,5, texto); TMR0L=255; //carrega novamente Timer0 com 255. INTCON.TMR0IF=0; //limpa a flag do estouro Timer0. } } while(1); } Obs: Troque o valor do Prescaller para 1:2 e veja resultado. Retorne configuração 1:1 e carregue agora o Registro TMR0L com valor 251 e

verifique o que acontece na contagem.


82

Memória EEPROM: O 18F452 possui internamente 256 bytes de EEPROM. No mikroC temos as seguintes funções de acesso à EEPROM: EEPROM_READ(adress): lê uma byte no endereço de memória. Exemplo: Leitura=eeprom_read(0); // faz a leitura do posição 0 da EEPROM e carrega na

//variável leitura. EEPROM_WRITE(adress,data): escreve um byte (data) no endereço (adress). Exemplo: Eeprom_write(0,25); //escreve o valor 25 no endereço 0 da EEPROM. Obs: É preciso ficar atento pois, cada posição de memória não pode ter mais que 8

bits (1 byte).

/********************************************************************** 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]; int leitura_canal, valor; unsigned int i; void main( ) { trisd=0b00001111; portd=0; trisc=0; portc=0; adcon1=0b00001110; //configura RA0 como entrada analógica demais I/O lcd_config(&portb, 1,0,2,7,6,5,4); lcd_cmd(lcd_cursor_off); lcd_cmd(lcd_clear); lcd_out(1,1,"Leitura AN1");


83

do { leitura_canal=adc_read(0); leitura_canal=(leitura_canal)/20; wordtostr(leitura_canal,texto); lcd_out(2,1, texto); if(button(&portd,0,50,1)) // RD0 = grava na EEPROM valor do A/D { lcd_cmd(lcd_clear); lcd_out(1,1,"Salvando......."); i=leitura_canal; portc=i; delay_ms(1000); eeprom_write(0,i); portd.f7=1; delay_ms(500); portd.f7=0; portc=0; lcd_cmd(lcd_clear); lcd_out(1,1,"Leitura AN1"); } if(button(&portd,1,50,1)) // RD1 = busca na EEPROM valor gravado { portd.f5=1; lcd_cmd(lcd_clear); lcd_cmd(lcd_clear); lcd_out(1,1,"VALOR na EEPROM"); portd.f5=0; valor=eeprom_read(0); wordtostr(valor,texto); lcd_out(2,5, texto); delay_ms(1000); lcd_cmd(lcd_clear); lcd_out(1,1,"Leitura AN1"); } }while(1); } Exercício: Desenvolva um programa que faça medição da Temperatura ambiente e se a

temperatura ultrapassar 38 graus, este valor deve ser salvo na EEPROM e também acionar uma saída (RD7) indicando alarme.


84

Introdução às Interrupções: Diferente da família 16F, nos microcontroladores da família 18F temos o recurso de

priorizar as interrupções. Como funciona? É simples, definimos interrupções como baixa prioridade e alta

prioridade. Se o microcontrolador está tratando uma interrupção de baixa prioridade e ocorre uma interrupção de alta prioridade, ele pára o que está fazendo, vai tratar a interrupção de alta prioridade e, quando terminar, aí sim retorna o tratamento da interrupção de baixa prioridade.

Na família 16F tínhamos um endereço de vetor de interrupção (ex: 0x04), já para o pic 18F452 temos dois vetores de interrupção:

0x08 para alta prioridade; 0x18 para baixa prioridade. Para o 18F452 temos as seguintes interrupções: - Interrupção no estouro do TIMER0; - Interrupção no estouro do TIMER1; - Interrupção no estouro do TIMER2; - Interrupção no estouro do TIMER3; - Interrupção por estimulo externo - INT0 (RB0); - Interrupção por estímulo externo - INT1 (RB1); - Interrupção por estímulo externo - INT2 (RB2); - Interrupção na mudança de Estado nos pinos: RB4, RB5, RB6 e RB7; - Interrupção na Recepção do canal serial; - Interrupção na Transmissão do canal serial; - Interrupção na Conversão do A/D; - Interrupção no Módulo CCP; - Interrupção no término de escrita na EEPROM; - Interrupção no Módulo LVP (detector de baixa tensão). Para configurar/habilitar/verificar estas interrupções, utilizamos os seguintes

registradores: - RCON; - INTCON; - INTCON2; - INTCON3; - PIE1; - PIE2; - IPR1; - IPR2; - PIR1; - PIR2. Precisamos, portanto, entender bem o que cada bit dentro de cada registrador faz para

podermos definir como irá trabalhar o microcontrolador no controle do projeto.


85

RCON:

IPEN ---------- ---------- /RI /TO /PD /POR /BOR IPEN= Habilita o tratamento de interrupções através de prioridades. 0 – desabilita prioridade. Funcionamento igual à família 16F. 1 – habilita tratamento de interrupções por 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 - 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


86

INTCON:

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


87

INTCON2:

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


88

INTCON3:

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


89

PIE1:

PSPIE ADIE RCIE TXIE SSPIE CCP1IE TMR2IE TMR1IE PSPIE= Chave individual que habilita interrupção da Porta Paralela Escrava (R/W); 0 – desabilita. 1 – habilita. ADIE= Chave individual que habilita interrupção do Conversor A/D. 0 – desabilita. 1 – habilita. RCIE= Chave individual que habilita interrupção por recebimento de dados na

USART. 0 – desabilita. 1 – habilita. TXIE= Chave individual que habilita interrupção por transmissão de dados na

USART. 0 – desabilita. 1 – habilita. SSPIE= Chave individual que habilita interrupção do Módulo SSP (Máster Syncronous Serial Port). 0 – desabilita. 1 – habilita. CCP1IE= Chave individual que habilita interrupção de Captura/Compare no

TIMER1. 0 – desabilita. 1 – habilita. TMR2IE= Chave individual que habilita interrupção por igualdade entre TMR2 e

PR2. 0 – desabilita. 1 – habilita. TMR1IE= Chave individual que habilita interrupção de estouro do TIMER1. 0 – desabilita. 1 – habilita.


90

PIE2:

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


91

PIR1:

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


92

PIR2:

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


93

IPR1:

PSPIP ADIP RCIP TXIP SSPIP CCP1IP TMR2IP TMR1IP PSPIP= Bit que define a prioridade na interrupção da Porta Paralela Escrava (R/W); 0 – baixa prioridade. 1 – alta prioridade. ADIP= Bit que define a prioridade na interrupção do Conversor A/D. 0 – baixa prioridade. 1 – alta prioridade. RCIP= Bit que define a prioridade na interrupção por recebimento de dados na

USART. 0 – baixa prioridade. 1 – alta prioridade. TXIP= Bit que define a prioridade na interrupção por transmissão de dados na

USART. 0 – baixa prioridade. 1 – alta prioridade. SSPIP= Bit que define a prioridade na interrupção do Módulo SSP (Master Syncronous Serial Port). 0 – baixa prioridade. 1 – alta prioridade. CCP1IP= Bit que define a prioridade na interrupção de Captura/Compare no

TIMER1. 0 – baixa prioridade. 1 – alta prioridade. TMR2IP= Bit que define a prioridade na interrupção por igualdade entre TMR2 e

PR2. 0 – baixa prioridade. 1 – alta prioridade. TMR1IP= Bit que define a prioridade na interrupção de estouro do TIMER1. 0 – baixa prioridade. 1 – alta prioridade.


94

IPR2:

--------- --------- --------- EEIP BCLIP LVDIP TMR3IP CCP2IP EEIP= Bit que define a prioridade na interrupção de escrita na EEPROM/FLASH. 0 – baixa prioridade. 1 – alta prioridade. BCLIP= Bit que define a prioridade na interrupção de colisão de dados. 0 – baixa prioridade. 1 – alta prioridade. LVDIP= Bit que define a prioridade na interrupção do Módulo LVD (baixa tensão). 0 – baixa prioridade. 1 – alta prioridade. TMR3IP= Bit que define a prioridade na interrupção por estouro do TIMER3. 0 – baixa prioridade. 1 – alta prioridade. ‘ CCP2IP= Bit que define a prioridade na interrupção do Módulo CCP2. 0 – baixa prioridade. 1 – alta 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; Comandos; // Obs: Não esquecer que é necessário limpar a Flag da interrupção. } Void interrupt_low ( ) { Comandos; Comandos; // Obs: Não esquecer que é necessário limpar a Flag da interrupção. } Void main ( ) { Comandos; Comandos; }


95

Inicialmente vamos verificar funcionamento de Interrupções sem prioridade. Para o exemplo abaixo temos um programa onde algumas saídas do portc são

acionadas por determinado tempo, como se fosse um simulador de presença residencial; no entanto, na entrada RB0 estamos com uma entrada de interrupção (INT0) onde teremos um sensores de movimento na garagem. Portanto, caso sensor seja acionado, o programa principal pára onde está e vai tratar a interrupção, neste momento, uma saída é acionada por determinado tempo, acionando a luminação da garagem. Terminado este tempo, programa retorna onde parou quando ocorreu a interrupção. Ocorrendo novo evento a situação se repete.

/********************************************************************** Uptex Tecnologia & Treinamento Ltda Curso de Microcontroladores PIC Linguagem C – Compilador MikroC Programa 30 Objetivo: Verificar tratamento de interrupções – INT0 *********************************************************************/

int contador=0; void interrupt() { portd.f7=1; // dispara iluminação da garagem delay_ms(6000); // delay de 6 segundos portd.f7=0; intcon.int0if=0; //apaga a Flag da interrpção INT0 } void main ( ) { intcon2.rbpu=0; //habilita resistores de Pull-Up no portb trisb.f0=1; trisd=0; trisc=0; portc=0; portd=0; intcon=0b11010000; // chave geral ligada, chave periféricos ligada // chave que ativa interrupção do TIMER0 ativa intcon2.intedg0=0; //seleciona borda de descida


96

do { portc.f0=1; // simulador de presença residencial delay_ms(1000); portc.f0=0; delay_ms(1000); portc.f4=1; delay_ms(500); portc.f4=0; portc.f2=1; delay_ms(1500); portc.f2=0; portc.f3=1; delay_ms(500); portc.f3=0; } while(1); } Vamos agora melhorar nosso projeto colocando mais um recurso. Já temos simulador de presença (portc), controle de iluminação da garagem (Int0) e

agora vamos colocar mais uma interrupção (INT1). Nesta entrada (pino RB1) vamos colocar um ou mais sensores de abertura de portas e janelas / sensor de movimento dentro da residência. (sensores ligados em série).


97

/********************************************************************** 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; void interrupt() { if (intcon.int0if==1) // testa se foi interrupção INT0 (Iluminação da Garagem) { portd.f0=1; // aciona iluminação delay_ms(6000); // delay de 6 segundos portd.f0=0; intcon.int0if=0; // apaga Flag do INT0 } if (intcon3.int1if==1) // testa se foi interrupção INT1 (Sistema de Alarme) { portd.f7=1; // dispara a sirene portd.f5=1; // ativa led que sinaliza ocorencia de alarme delay_ms(10000); portd.f7=0; intcon3.int1if=0; } } void main ( ) { intcon2.rbpu=0; //habilita resistores de Pull-Up trisb.f0=1; //RB0 entrada trisb.f1=1; //RB1 entrada trisd=0; trisc=0; portc=0; portd=0; intcon=0b11010000; // chave geral, individual e do INT0 ligadas intcon2.intedg0=0; //seleciona borda de descida para INT0 intcon3.int1ie=1; //habilita chave individual para INT1 intcon2.intedg1=0; //seleciona borda de descida para INT1


98

do { portc.f0=1; // simulador de presença residencial delay_ms(1000); portc.f0=0; delay_ms(1000); portc.f4=1; delay_ms(500); portc.f4=0; portc.f2=1; delay_ms(1500); portc.f2=0; portc.f3=1; delay_ms(500); portc.f3=0; } while(1); } Para o programa acima, observe que problema interessante: Ao gerar interrupção pelo acionamento da iluminação da garagem (INT0) e em

seguida, enquanto o microcontrolador ainda está tratando esta interrupção e ocorrer outra interrupção - invasão na residência (INT1) o alarme só irá disparar após o tratamento da interrupção INT0. Ai está um problema grave, pois teríamos que priorizar o alarme sobre a iluminação da garagem.

Deparamos neste caso com a grande vantagem e potencialidade da família 18F. Como o 18F452 possui dois vetores de interrupção, podemos separar as interrupções entre alta e baixa prioridade. Com isso, caso o Microcontrolador esteja tratando uma interrupção de baixa prioridade e vir a ocorrer a interrupção de alta prioridade, o programa irá parar temporariamente o tratamento da baixa prioridade e irá executar o de alta prioridade. Terminando a 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).

Vamos então fazer uma modificação: INT1 colocar sistema de Alarme em Alta Prioridade; INT2 colocar a iluminação da garagem em Baixa Prioridade


99

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


100

intcon3.int1ie=1; // habilita chave individual para INT1 intcon3.int2ie=1; // habilita chave individual para INT2 intcon3.int1ip=1; // habilita INT1 como prioridade alta intcon3.int2ip=0; // habilita INT2 como baixa prioridade do { portc.f0=1; // simulador de presença residencial delay_ms(1000); portc.f0=0; delay_ms(1000); portc.f4=1; delay_ms(500); portc.f4=0; portc.f2=1; delay_ms(1500); portc.f2=0; portc.f3=1; delay_ms(500); portc.f3=0; } while(1); }

Exercício: Modifique o programa fazendo uso agora da prioridade alta em RB4 a RB7 (4 zonas

de alarme), usando o portc para sinalização de zona disparada (RC0= Zona 1, RC1= Zona 2, RC3 = Zona 3 e RC4 = Zona 4), RD7 para saída para iluminação da garagem (minuteria) e RD0 à RD6 para Simulador de Presença. Manter prioridade alta para alarme e baixa para iluminação da garagem.


Microcontroladors PIC - Linguagem C

Documents

Transcript of Microcontroladors PIC - Linguagem C