Microcontroladors Pic - Linguagem C 6db5r

+ + <nome da variável> + ; Obs: valor pode ou não necessariamente ser inicializado. Exemplos: int contador; short var1; unsigned int contagem = 30500; Observe agora como atribuir valores às variáveis: Contador = 10; Var1 = 25;

// atribui o valor 10 à variável contador // 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 o às variáveis globais. Exemplo: unsigned int valor1, valor 2 void subrotina_soma () { valor1=A; valor2=B; return(valor1+valor2); }

13

Operadores Matemáticos: Aritméticos: Operador + * / % ++ --

Descrição Soma dos argumentos Subtração dos argumentos Multiplicação dos argumentos Divisão dos argumentos Resto da divisão Soma 1 ao argumento (a=a+1) Subtrai 1 ao argumento (a=a-1)

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

14

Exemplo a+b a–b a*b a/b a%b a++ a--

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

15

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

16

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

17

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.

18

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

19

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}

20

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

21

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

22

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 e em seguida . 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.

23

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 XT HS HS + PLL RC RCIO EC ECIO

cristal de baixa freqüência cristal ou ressonador cristal ou ressonado de alta freqüência Cristal ou ressonador com PLL habilitado Resistor e capacitor externo Resistor e capacitor externo e liberação de 1 pino de I/O Clock externo Clock externo e liberação de 1 pino de I/O

Valores de capacitores que devem ser acoplado ao cristal:

24

Modo: RC externo com liberação do pino com ciclo de máquina Configuração RC

Clock externo com liberação de pino de I/O

25

Clock externo com liberação de um pino com clock – ciclo de máquina Configuração EC

Clock externo com liberação de pino de I/O – Configuração ECIO

Modo: HS + PLL

Neste caso, teremos a freqüência do Cristal multiplicado por 4. Por exemplo, para um cristal de 10MHz teremos a freqüência de trabalho em 40MHz.

26

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. C2MX Este bit tem a função de Multiplexar o módulo C2. Para C2MX=0 usaremos pino RC1 para C2 Para C2MX=1 usaremos pino RB3 para C2 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 ultraado. 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.

27

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

28

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

Circuito:

29

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

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

30

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).

31

Gravando o Projeto: O Programa IROG será utilizado para gravar o programa no Microcontrolador. Primeira coisa a se fazer é selecionar o Chip – PIC18F452

Porém, precisamos ainda configurar o IROG 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.

32

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 IROG e em seguida pressionamos o botão “Programar Tudo”.

33

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.

34

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.

35

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”.

36

37

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 o a o; “F6” = inicia modo Run.

- Run/Pause Debugger - Stop Debugger - Step Over - Step Out - Run to Cursor - Step Into

(F6); (Ctrl + F12); (F8); (Ctrl + F8); (F4); (F7).

38

/********************************************************************** 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; portd = 0;

// configura todo o portd como saída // todo o portd é colocado em nível baixo

while(1) //loop infinito { led1=1; delay_ms(5000); led1=0; delay_1sec( ); led2=1; delay_ms(5000); led2=0; delay_ms(5000); }

//ativa saída RD1 //aguarda 5 segundos //desativa saída RD1 //aguarda 1 segundo // ativa saída RD2 // aguarda 5 segundos // desativa saída RD2

}

39

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

40

/********************************************************************** 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); } } }

41

/********************************************************************** 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); } } }

42

/********************************************************************** 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) portc.f0=1; else if (portd.f1==1) portc.f1=1; else if (portd.f2==1) portc.f2=1; else if (portd.f3==1) portc.f3=1; else if (portd.f4==1) portc.f4=1; else if (portd.f5==1) portc.f5=1; else if (portd.f6==1) portc.f6=1; else if (portd.f7==1) portc.f7=1;

// RD0 esta presionado? se nao, pula para testar RD1 // se pressionado, entao aciona RC0 // RD1 esta presionado? se nao, pula para testar RD2 // se pressionado, entao aciona RC1 // RD2 esta presionado? se nao, pula para testar RD3 // se pressionado, entao aciona RC2 // RD3 esta presionado? se nao, pula para testar RD4 // se pressionado, entao aciona RC3 // RD4 esta presionado? se nao, pula para testar RD5 // se pressionado, entao aciona RC4 // RD5 esta presionado? se nao, pula para testar RD6 // se pressionado, entao aciona RC5 // RD6 esta presionado? se nao, pula para testar RD7 // se pressionado, entao aciona RC6 // RD7 esta presionado? se nao, volta ao loop para testar //chaves // se pressionado, entao aciona RC7

} }

43

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; trisd=0b00000001; portc=0;

// define todo o portc como saída // define RD0 como entrada e restante como saída // coloca portc em 0

while(1) { if (button(&portd, 0, 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

} } } }

44

/********************************************************************** 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; trisd=0xFF; portc=0;

// define todo o portc como saída // define todo o portd como entrada // 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).

45

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

46

Outro exemplo: void tempo_diverso( ) ; nenhuma int cont1 ; void main ( ) { trisd=0 ; portd=0 ; while(1) { cont1=60; portd.f0=1; tempo_diverso ( ) ; portd.f0=0; cont1=120; tempo_diverso( ); } }

// protótipo de função. Não podemos utilizar //função antes de declará-la

//delay de 1 minuto

//delay de 2 minutos

void tempo_diverso ( ) //delay para n minutos { int cont; for (cont=0; cont
47

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 C0

81 C1

82 C2

83 C3

84 C4

85 C5

86 C6

87 C7

88 C8

48

89 C9

8A 8B 8C 8D 8E 8F CA CB CC CD CE CF

Comandos disponíveis:

49

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);

50

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

51

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.

52

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) ;

53

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 C – C1 e C2 (Capture/Compare/PWM) Os Comandos abaixo são para o Módulo C1: - 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

54

Para o Módulo C2 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 C1 *********************************************************************/ //programa que configura C1 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 C2 *********************************************************************/ //programa que configura Módulo C2 em 3KHz e duty cicle 10% void main(){ pwm2_init(3000); pwm2_change_duty(25); pwm2_start(); while(1); }

55

/********************************************************************** Uptex Tecnologia & Treinamento Ltda Curso de Microcontroladores PIC Linguagem C – Compilador MikroC Programa 13 Objetivo: verificar funcionamento simultâneo dos Módulos C1 e C2 *********************************************************************/ 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.

56

/********************************************************************** 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 C1 e C2 *********************************************************************/ 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)) {

57

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:

58

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.

59

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

Registrador ADCON1:

61

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 62

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

63

/********************************************************************** 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); }

64

/********************************************************************** 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); }

65

/********************************************************************** 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); }

66

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)) {

67

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

68

/********************************************************************** 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); i=0;

// inicializa usart (8bits, baud rate 9600, no parity bit...

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

69

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

70

/********************************************************************** 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');

71

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

72

/********************************************************************** 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); }

73

/********************************************************************** 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; } } }

74

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 0 0 0 0 1 1 1 1

T0PS1 0 0 1 1 0 0 1 1

T0PS0 0 1 0 1 0 1 0 1

Prescaler 1:2 1:4 1:8 1:16 1:32 1:64 1:128 1:256

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

75

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

76

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

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.

77

RBIF

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.

78

/********************************************************************** 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); }

79

/********************************************************************** 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); }

80

/********************************************************************** 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; INTCON.TMR0IF=0; } } while(1);

//carrega novamente Timer0 com 255. //limpa a flag do estouro Timer0.

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

81

Memória EEPROM: O 18F452 possui internamente 256 bytes de EEPROM. No mikroC temos as seguintes funções de o à 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");

82

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 ultraar 38 graus, este valor deve ser salvo na EEPROM e também acionar uma saída (RD7) indicando alarme.

83

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 C; - 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.

84

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

85

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.

86

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.

87

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.

88

PIE1: PSPIE

ADIE

RCIE

TXIE

SSPIE

C1IE

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. C1IE= 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.

89

PIE2: ---------

---------

---------

EEIE

BCLIE

LVDIE

TMR3IE

C2IE

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. C2IE= Chave individual que habilita interrupção do Módulo C2. 0 – desabilita. 1 – habilita.

90

PIR1: PSPIF

ADIF

RCIF

TXIF

SSPIF

C1IF

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. C1IF= 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.

91

PIR2: ---------

---------

---------

EEIF

BCLIF

LVDIF

TMR3IF

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. ‘ C2IF= Flag de sinalização do Módulo C2. 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.

92

C2IF

IPR1: PSPIP

ADIP

RCIP

TXIP

SSPIP

C1IP

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. C1IP= 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.

93

IPR2: ---------

---------

---------

EEIP

BCLIP

LVDIP

TMR3IP

C2IP

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. ‘ C2IP= Bit que define a prioridade na interrupção do Módulo C2. 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; }

94

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; trisb.f0=1; trisd=0; trisc=0; portc=0; portd=0; intcon=0b11010000; intcon2.intedg0=0;

//habilita resistores de Pull-Up no portb

// chave geral ligada, chave periféricos ligada // chave que ativa interrupção do TIMER0 ativa //seleciona borda de descida

95

do { portc.f0=1; 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;

// simulador de presença residencial

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

96

/********************************************************************** 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) { portd.f0=1; delay_ms(6000); portd.f0=0; intcon.int0if=0; }

// testa se foi interrupção INT0 (Iluminação da Garagem) // aciona iluminação // delay de 6 segundos // 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; trisb.f0=1; trisb.f1=1; trisd=0; trisc=0; portc=0; portd=0; intcon=0b11010000; intcon2.intedg0=0; intcon3.int1ie=1; intcon2.intedg1=0;

//habilita resistores de Pull-Up //RB0 entrada //RB1 entrada

// chave geral, individual e do INT0 ligadas //seleciona borda de descida para INT0 //habilita chave individual para INT1 //seleciona borda de descida para INT1

97

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

98

/********************************************************************** 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() { portd.f7=1; portd.f5=1; delay_ms(10000); portd.f7=0; intcon3.int1if=0; } void interrupt_low() { portd.f0=1; delay_ms(6000); portd.f0=0; intcon3.int2if=0;

// Interrupção de alta prioridade // interrupção INT1 (Sistema de Alarme) // dispara a sirene // ativa led que sinaliza ocorrência de alarme // apaga Flag do INT1

// Interrupção de baixa prioridade // interrupção INT2 (Iluminação da Garagem) // aciona iluminação // delay de 6 segundos

} void main ( ) { intcon2.rbpu=0; trisb.f0=1; trisb.f2=1; trisd=0; trisc=0; portc=0; portd=0;

//habilita resistores de Pull-Up //RB0 entrada //RB2 entrada

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

99

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.

100

Microcontroladors Pic - Linguagem C 6db5r

Overview 26281t

More details 6y5l6z

Related Documents 3h463d

Microcontroladors Pic - Linguagem C 6db5r

Linguagem C#.pdf 436z4s

String Linguagem C g2s40

Tratado Da Linguagem C q591r

Fila Em Linguagem C 6u402y

Linguagem C# 3.5 25164l

More Documents from "José Minatelle" 23476w

Documental Husky Siberiano. 1a3p26

Armitage Shanks Blue Book Mena Edition 1 vl3j

Campo De Existencia Esquema 1o271

4p345f

Control De Calidad De Harinas 36z5w

Igic Modelo 420 6m343n