Curso de Linguagem C. Rinaldo Câmara Gonçalves Labtools Mosaico Didactic Division Revisão 2

Curso de Linguagem C Rinaldo Câmara Gonçalves Labtools Mosaico Didactic Division Revisão 2

Sumário SUMÁRIO...3 RECURSOS BÁSICOS: EXEMPLO 1 BOTÃO E LED...5 RECURSOS DO LIVRO...5 LÓGICA DO EXEMPLO...5 ESQUEMA ELÉTRICO...6 FLUXOGRAMA...7 CÓDIGO...8 EXERCÍCIOS PROPOSTOS...10 ANOTAÇÕES...11 RECURSOS BÁSICOS: EXEMPLO 2 PISCA PISCA VARIÁVEL...13 RECURSOS DO LIVRO...13 LÓGICA DO EXEMPLO...13 ESQUEMA ELÉTRICO...14 FLUXOGRAMA...15 CÓDIGO...16 EXERCÍCIOS PROPOSTOS...18 ANOTAÇÕES...19 RECURSOS BÁSICOS: EXEMPLO 3 CONTADOR HEXADECIMAL...20 RECURSOS DO LIVRO...20 LÓGICA DO EXEMPLO...20 ESQUEMA ELÉTRICO...21 FLUXOGRAMA...22 CÓDIGO...25 EXERCÍCIOS PROPOSTOS...28 ANOTAÇÕES...29 RECURSOS AVANÇADOS: EXEMPLO 4 MAXIMIZAÇÃO DE PINOS DE I/O...30 RECURSOS DO LIVRO...30 LÓGICA DO EXEMPLO...30 ESQUEMA ELÉTRICO...31 FLUXOGRAMA...32 CÓDIGO...36 EXERCÍCIOS PROPOSTOS...40 ANOTAÇÕES...41 RECURSOS AVANÇADOS: EXEMPLO 5 VARREDURA DE DISPLAY...42 RECURSOS DO LIVRO...42 LÓGICA DO EXEMPLO...42 ESQUEMA ELÉTRICO...44 FLUXOGRAMA...45 CÓDIGO...50 EXERCÍCIOS PROPOSTOS...57 ANOTAÇÕES...58 RECURSOS AVANÇADOS: EXEMPLO 6 CONTROLE DO LCD...59 RECURSOS DO LIVRO...59 LÓGICA DO EXEMPLO...59 ESQUEMA ELÉTRICO...60 FLUXOGRAMA...61 CÓDIGO...68 EXERCÍCIOS PROPOSTOS...76 ANOTAÇÕES...77 RECURSOS AVANÇADOS: EXEMPLO 7 CONVERSOR ANALÓGICO DIGITAL...78 RECURSOS DO LIVRO...78 LÓGICA DO EXEMPLO...78 Linguagem C para PIC 3

ESQUEMA ELÉTRICO...79 FLUXOGRAMA...80 CÓDIGO...82 EXERCÍCIOS PROPOSTOS...86 ANOTAÇÕES...87 RECURSOS AVANÇADOS: EXEMPLO 8 CONTROLE DO PWM E EEPROM INTERNA...88 RECURSOS DO LIVRO...88 LÓGICA DO EXEMPLO...88 ESQUEMA ELÉTRICO...89 FLUXOGRAMA...90 CÓDIGO...93 EXERCÍCIOS PROPOSTOS...99 ANOTAÇÕES...100 RECURSOS AVANÇADOS: EXEMPLO 9 COLETOR DE DADOS...101 RECURSOS DO LIVRO...101 LÓGICA DO EXEMPLO...101 ESQUEMA ELÉTRICO...102 FLUXOGRAMA...103 CÓDIGO...109 EXERCÍCIOS PROPOSTOS...114 ANOTAÇÕES...115 RECURSOS AVANÇADOS: EXEMPLO 10 FUNÇÕES MATEMÁTICAS...116 RECURSOS DO LIVRO...116 LÓGICA DO EXEMPLO...116 ESQUEMA ELÉTRICO...117 FLUXOGRAMA...118 CÓDIGO...119 EXERCÍCIOS PROPOSTOS...121 ANOTAÇÕES...122 4 Linguagem C para PIC

Recursos Básicos: Exemplo 1 1.1 - Recursos do Livro Botão e Led Para o bom entendimento deste nosso primeiro exemplo são necessários os conhecimentos de programação em linguagem C, comandos de controle de Fluxo (cap.7 do livro Programação em C), declaração de variáveis, constantes e tipos de dados (cap.5 do livro Programação em C), diretivas de configuração dos pinos de I/O (cap.10-pág.170, cap.11.5; 11.6-pág.202; 11.7 e cap.12.2-pág. 250 do livro Programação em C). 1.2 - Lógica do exemplo Nosso exemplo será composto de um programa capaz de ler um botão e controlar um led. Com o botão S1 pressionado o led L2 acende, com o botão S1 liberado o led L2 apaga. Veremos os primeiros comandos para controle de fluxo de um programa e como ler uma entrada e acionar uma saída, fundamental já que estamos trabalhando com um microcontrolador. Neste exemplo você verá o comando WHILE, (Faça enquanto for verdadeiro) sendo utilizado para o controle de fluxo de nossa rotina principal, forçando um loop infinito. O comando IF ELSE, (Se verdadeiro comando, Se falso comando), realiza o teste do botão e determina o caminho a ser seguido, se acende ou apaga o led. Caso o botão esteja pressionado o teste determina que o led deve acender, caso contrário o led será apagado. Para o teste do botão está sendo utilizado o operando! (NOT), para botão pressionado temos nível lógico zero no pino de I/O, neste caso o teste com o comando IF será verdadeiro para botão pressionado e falso para botão liberado. Linguagem C para PIC 5

Linguagem C para PIC 6 1.3 - Esquema Elétrico +5V +5V +5V +5V S1 RB0 10K RB1 330R RESET 10K MCLR RA0 RA1 RA2 RA4 RA5 RA3 RE1 RE0 RE2 VDD VSS OSC1 OSC2 RC1 RC2 RC0 RC4 RC3 RC5 VDD VSS RB7 RB6 RB4 RB3 RB5 RB1 RB2 RB0 RD7 RD6 RD5 RD4 RD2 RD1 RD3 RC7 RD0 RC6 1 2 4 3 5 6 7 8 9 10 11 12 13 14 15 16 17 18 23 24 33 30 29 28 27 22 21 20 19 26 25 32 31 40 39 38 37 36 35 34 MC1 4MHz L2 16F877A

1.4 - Fluxograma MAIN CONFIGURAÇÕES INICIAIS TRIS, PORTAS, WATCHDOG, PRESCALER. A LIMPA WATCHDOG BOTÃO S1 PRESS.? APAGA LED L2 ACENDE LED L2 A Linguagem C para PIC 7

1.5 - Código * Programação em C - Recursos Básicos de programação * * Exemplo 1 * * * * CENTRO DE CAPACITAÇÃO - LABTOOLS * * * * TEL: (0XX11) 4992-8775 SITE: www.labtools.com.br * * E-MAIL: cursos@labtools.com.br * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * VERSÃO : 1.0 * * DATA : 05/06/2003 * /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Descrição geral * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ // Este software está preparado para demonstrar o controle dos pinos de I/O // este primeiro programa demonstrará o estado de um botão por meio de um led. /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Definição das variáveis internas do PIC * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ #include <16f877A.h> // microcontrolador utilizado /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Configurações para gravação * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ #fuses xt,wdt,noprotect,put,brownout,nolvp,nocpd,nowrt fusíveis // configuração dos /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Definição e inicialização das variáveis * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ //Neste bloco estão definidas as variáveis globais do programa. //Este programa não utiliza nenhuma variável de usuário /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Constantes internas * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ //A definição de constantes facilita a programação e a manutenção. //Este programa não utiliza nenhuma constante de usuário /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Declaração dos flags de software * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ //A definição de flags ajuda na programação e economiza memória RAM. //Este programa não utiliza nenhum flag de usuário /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Definição e inicialização dos port's * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ #use fast_io(a) #use fast_io(b) #use fast_io(c) #use fast_io(d) #use fast_io(e) #byte porta = 0x05 #byte portb = 0x06 #byte portc = 0x07 #byte portd = 0x08 #byte porte = 0x09 8 Linguagem C para PIC

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ENTRADAS * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ // As entradas devem ser associadas a nomes para facilitar a programação e //futuras alterações do hardware. #bit botao = portb.0 // Estado do botão // 1 -> Liberado // 0 -> Pressionado /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * SAÍDAS * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ // As saídas devem ser associadas a nomes para facilitar a programação e //futuras alterações do Hardware. #bit led = portb.1 // Led correspondente ao botão // 1 -> Led ligado // 0 -> Led desligado /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Configurações do Microcontrolador * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ void main () setup_counters(rtcc_internal, WDT_2304MS); set_tris_a(0b11111111); set_tris_b(0b11111101); set_tris_c(0b11111111); set_tris_d(0b11111111); set_tris_e(0b00000111); porta=0x00; portb=0x00; portc=0x00; portd=0x00; porte=0x00; // configuração dos pinos de I/O // limpa porta // limpa portb // limpa portc // limpa portd // limpa porte /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Loop principal * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ while(true) RESTART_WDT(); if(!botao) // testa botão led = 1; // Se botão = 0, então led = 1 else led=0; // caso contrário, led = 0 // FIM DO PROGRAMA 1.6 - Linguagem C para PIC 9

1.7 - Exercícios Propostos Agora que o exemplo já foi estudado e esclarecido, aproveite para gerar novos problemas e soluções, seguindo os exercícios propostos: 1. Utilize as funções do Compilador para controlar o Led, OUTPUT_HIGH e OUTPUT_LOW. 2. Altere a lógica do programa para que o led acenda com o botão liberado e apague com o botão pressionado. 3. Troque o pino de I/O que controla o botão, por exemplo, utilize o pino RB3. 4. Com o botão pressionado acenda o led 2 e apague o led 3, para o botão liberado apague o led 2 e acenda o led 3. 10 Linguagem C para PIC

1.8 - Anotações Linguagem C para PIC 11

Recursos Básicos: Exemplo 2 1.9 - Recursos do Livro Pisca Pisca Variável Para o bom entendimento deste exemplo são necessários os conhecimentos adquiridos no exemplo 1 e mais, funções do compilador para controle de atraso (cap.11.4 pág. 195 do livro Programação em C), Operadores para criação de expressões lógicas e aritméticas (cap.6 do livro Programação em C), diretivas de configuração para uso de função de atraso (cap.10, pág.169 do livro Programação em C). 1.10 - Lógica do exemplo A finalidade de nosso exemplo é demonstrar a inversão de portas e a utilização da função de delay da Linguagem C. Através dos botões S1 e S2, Up e Down é possível ajustar a freqüência de oscilação dos Leds 3 e 4 da placa McLab2. As constantes min e max determinam os limites, máximos e mínimos de ajuste da freqüência de oscilação. Para a inversão das portas está sendo utilizado o operador lógico ~, (NOT, complemento de 1), com este operando estaremos invertendo bit a bit o conteúdo do registrador portb. A função delay_ms gera um atraso de milisegundos usando o ciclo de máquina, ou seja, o programa fica travado nesta função até o tempo desejado. O camando For (inicialização, teste condicional, incremento) é utilizado para controle do laço da rotina de delay, definindo a quantidades de vezes que o laço será executado, nesta rotina não utilizaremos a opção de inicialização do comando For, sendo a mesma executada fora do laço. Linguagem C para PIC 13

Linguagem C para PIC 14 1.11 - Esquema Elétrico +5V +5V +5V +5V S1 RB0 10K +5V S2 RB1 10K RB2 330R RB3 330R RESET 10K MCLR RA0 RA1 RA2 RA4 RA5 RA3 RE1 RE0 RE2 VDD VSS OSC1 OSC2 RC1 RC2 RC0 RC4 RC3 RC5 VDD VSS RB7 RB6 RB4 RB3 RB5 RB1 RB2 RB0 RD7 RD6 RD5 RD4 RD2 RD1 RD3 RC7 RD0 RC6 1 2 4 3 5 6 7 8 9 10 11 12 13 14 15 16 17 18 23 24 33 30 29 28 27 22 21 20 19 26 25 32 31 40 39 38 37 36 35 34 MC1 4MHz L3 L4 16F877A

1.12 - Fluxograma A MAIN CONFIGURAÇÕES INICIAIS TRIS, PORTAS, WATCHDOG, PRESCALER. BOTÃO S1 PRESS.? INICIALIZA PORTB COM 0X0F TEMPO = MAX? B LIMPA WATCHDOG INCREMENTA TEMPO COMPLEMENTA PORTB A BOTÃO S2 PRESS.? TEMPO = MIN? DECREMENTA TEMPO CARREGA A VARIÁVEL CONTADOR COM O VALOR DA VARIÁVEL TEMPO ROTINA DE DELAY LAÇO FOR B CONTADOR 0 DELAY (10MS) Linguagem C para PIC 15

1.13 - Código * Programação em C - Recursos Básicos de programação * * Exemplo 2 * * * * CENTRO DE CAPACITAÇÃO - LABTOOLS * * * * TEL: (0XX11) 4992-8775 SITE: www.labtools.com.br * * E-MAIL: cursos@labtools.com.br * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * VERSÃO : 1.0 * * DATA : 05/06/2003 * /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Descrição geral * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ // Este software demonstrará a utilização da função de delay e a inversão de portas //a frequência de oscilação dos leds é controlada pelos botões S1 (UP) e S2 (DOWN). /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Definição das variáveis internas do PIC * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ #include <16f877A.h> // microcontrolador utilizado /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Configurações para gravação * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ #fuses xt,wdt,noprotect,put,brownout,nolvp,nocpd,nowrt // configuração dos fusíveis /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Definições para uso de Rotinas de Delay * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ #use delay(clock=4000000, RESTART_WDT) // diretiva para o uso da função delay /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Definição e inicialização das variáveis * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ //Neste bloco estão definidas as variáveis globais do programa. int contador = 0 ; int tempo = 9; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Constantes internas * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ //A definição de constantes facilita a programação e a manutenção. //Este programa não utiliza constantes #define max 255 // Limite de ajuste do tempo #define min 10 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Declaração dos flags de software * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ //A definição de flags ajuda na programação e economiza memória RAM. //Este programa não utiliza nenhum flag de usuário. /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Definição e inicialização dos port's * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ #use fast_io(a) #use fast_io(b) #use fast_io(c) #use fast_io(d) #use fast_io(e) #byte porta = 0x05 #byte portb = 0x06 #byte portc = 0x07 #byte portd = 0x08 16 Linguagem C para PIC

#byte porte = 0x09 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ENTRADAS * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ // As entradas devem ser associadas a nomes para facilitar a programação e //futuras alterações do hardware. #bit botao_0 = portb.0 // Estado do botão_0 // 1 -> Liberado // 0 -> Pressionado #bit botao_1 = portb.1 // Estado do botão_1 // 1 -> Liberado // 0 -> Pressionado /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * SAÍDAS * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ // As saídas devem ser associadas a nomes para facilitar a programação e //futuras alterações do hardware. /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Configurações do Microcontrolador * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ void main () setup_counters(rtcc_internal,wdt_2304ms); set_tris_a(0b11111111); set_tris_b(0b11110011); set_tris_c(0b11111111); set_tris_d(0b11111111); set_tris_e(0b00000111); porta = 0x00; portb = 0x0f; portc = 0x00; portd = 0x00; porte = 0x00; // carrega portb com valor inicial /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Loop principal * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ while(true) RESTART_WDT(); portb = ~portb; // complemanta o portb if (!botao_0) // O botão_0 foi pressionado? if (tempo!= max) // sim, tempo é diferente de max? tempo = tempo + 1; // não, incrementa tempo // botão_0 liberado, testa botão 1 if (!botao_1) // O botão 1 foi pressionado? if (tempo!= min) // sim, tempo é diferente de min? tempo = tempo - 1; // não, decrementa tempo // botão_1 liberado contador = tempo; // carrega contador for (;contador!=0; contador--) // contador é diferente de 0? se sim // decrementa contador e executa o comando delay_ms(10); // comando: delay de 10 milisegundos. // FIM DO PROGRAMA Linguagem C para PIC 17

1.14 - Exercícios Propostos Agora que o exemplo já foi estudado e esclarecido, aproveite para gerar novos problemas e soluções, seguindo os exercícios propostos: 1. Implemente a inversão de portas para que o led 3 e o led 4 pisquem alternadamente. 2. Utilize a forma reduzida para incrementar e decrementar a variável tempo. 3. Troque a função delay_ms por delay_us e ajuste as constantes para obter o mesmo ajuste de freqüência. 4. Substitua o comando For pelo comando While. 18 Linguagem C para PIC

1.15 - Anotações Linguagem C para PIC 19

Recursos Básicos: Exemplo 3 Contador Hexadecimal 1.16 - Recursos do Livro Para o bom entendimento deste exemplo são necessários os conhecimentos adquiridos nos exemplos anteriores e tabela de constante (cap.12.21 pág. 309 do livro Programação em C). 1.17 - Lógica do exemplo Através dos botões S1 e S2 o contador será incrementado ou decrementado, e o seu valor mostrado no display de sete segmentos ds4. A finalidade de nosso exemplo é demonstrar a implementação de tabelas utilizando a memória de programa, sendo está tabela uma matriz unidimensional, nossa tabela fará a conversão de BCD para sete segmentos, realizando a função de um circuito decodificador. Para o devido tratamento dos botões, neste exemplo foi implementada uma rotina de filtro para cada botão evitando o problema de debouncing, além do filtro foi criado um flag, para cada botão, que tem a função de indicar se a tecla está pressionada ou liberada. Desta forma para que o contador seja incrementado ou decrementado o botão deve ser pressionado e depois liberado. A variável contador será utilizada como indexador da tabela de constante, assim sendo para o contador igual à zero, será retornado o código de sete segmentos para o número zero e assim por diante. 20 Linguagem C para PIC

Linguagem C para PIC 21 1.18 - Esquema Elétrico MC1 MCLR RA0 RA1 RA2 RA4 RA5 RA3 RE1 RE0 RE2 VDD VSS OSC1 OSC2 RC1 RC2 RC0 RC4 RC3 RC5 VDD VSS RB7 RB6 RB4 RB3 RB5 RB1 RB2 RB0 RD7 RD6 RD5 RD4 RD2 RD1 RD3 RC7 RD0 RC6 1 2 4 3 5 6 7 8 9 10 11 12 13 14 15 16 17 18 23 24 33 30 29 28 27 22 21 20 19 26 25 32 31 40 39 38 37 36 35 34 +5V +5V +5V RESET DS4 a b c d e f g Dp a c b d e f g Dp RB0 RB1 +5V 10K +5V 10K 10K S1 S2 4,7K BC337 4MHz 220R 220R PIC16F877 PIC16F877 16F877A

1.19 - Fluxograma MAIN CONFIGURAÇÕES INICIAIS TRIS, PORTAS, WATCHDOG, PRESCALER. INICIALIZA PORTB COM 0X10 B LIMPA WATCHDOG A 22 Linguagem C para PIC

A BOTÃO S1 PRESS.? Re-carrrega o Filtro do Botão Marca botão liberado O botão já estava pressionado? C Filtro 0? Marca Botão pressionado Decrementa o Filtro Contador Max? Incrementa o contador Consulta tabela de conversão e atualiza o display C Linguagem C para PIC 23

C BOTÃO S2 PRESS.? Re-carrrega o Filtro do Botão Marca botão liberado O Botão já estava pressionado? B Filtro 0? Marca Botão pressionado Decrementa o Filtro Contador Min? Decrementa o contador Consulta tabela de conversão e atualiza o display B 24 Linguagem C para PIC

1.20 - Código * Programação em C - Recursos Básicos de programação * * Exemplo 3 * * * * CENTRO DE CAPACITAÇÃO - LABTOOLS * * * * TEL: (0XX11) 4992-8775 SITE: www.labtools.com.br * * E-MAIL: cursos@labtools.com.br * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * VERSÃO : 1.0 * * DATA : 05/06/2003 * /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Descrição geral * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ // Contador hexadecimal que utiliza dois botões para incrementar e decrementar // o valor da variável "contador". O contador está limitado pelas constantes min e max. /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * DEFINIÇÃO DAS VARIÁVEIS INTERNAS DO PIC * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ #include <16f877A.h> // microcontrolador utilizado /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Configurações para gravação * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ #fuses xt,wdt,noprotect,put,brownout,nolvp,nocpd,nowrt // configuração dos fusíveis /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Definições para uso de Rotinas de Delay * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ #use delay(clock=4000000, RESTART_WDT) /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Constantes internas * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ //A definição de constantes facilita a programação e a manutenção. #define t_filtro 400 #define min 0 #define max 15 // tamanho do filtro // valor mínimo para o contador // valor máximo para o contador /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Definição e inicialização das variáveis * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ //Neste bloco estão definidas as variáveis globais do programa. int contador=min; // inicia contador com mínimo long int filtro0=t_filtro; // inicia filtro do bot1 long int filtro1=t_filtro; // inicia filtro do bot2 int flags=0; // limpa os flags /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Declaração dos flags de software * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ //A definição de flags ajuda na programação e economiza memória RAM. #bit bt_up_press = flags.0 #bit bt_down_press = flags.1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Definição e inicialização dos port's * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ #use fast_io(a) #use fast_io(b) #use fast_io(c) #use fast_io(d) #use fast_io(e) Linguagem C para PIC 25

#byte porta = 0x05 #byte portb = 0x06 #byte portc = 0x07 #byte portd = 0x08 #byte porte = 0x09 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ENTRADAS * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ // As entradas devem ser associadas a nomes para facilitar a programação e //futuras alterações do hardware. #bit botao_up = portb.0 // Estado do botão UP // 1 -> Liberado // 0 -> Pressionado #bit botao_down = portb.1 // Estado do botão DOWN // 1 -> Liberado // 0 -> Pressionado /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * SAÍDAS * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ // As saídas devem ser associadas a nomes para facilitar a programação e // futuras alterações do hardware. /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Tabela de Valores * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ byte const tabela[16] = //PGFEDCBA ; POSIÇÃO RELATIVA AOS SEGMENTOS 0b00111111, // 0H - 0 0b00000110, // 1H - 1 0b01011011, // 2H - 2 0b01001111, // 3H - 3 0b01100110, // 4H - 4 0b01101101, // 5H - 5 0b01111101, // 6H - 6 0b00000111, // 7H - 7 0b01111111, // 8H - 8 0b01101111, // 9H - 9 0b01110111, // AH - A 0b01111100, // BH - B 0b00111001, // CH - C 0b01011110, // DH - D 0b01111001, // EH - E 0b01110001; // FH - F /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Configurações do Microcontrolador * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ void main() setup_counters(rtcc_internal, wdt_2304ms); set_tris_a(0b11111111); set_tris_b(0b11101111); set_tris_c(0b11111111); set_tris_d(0b00000000); set_tris_e(0b00000111); porta = 0x00; portb=(0b00010000); // seleciona display ds4 portc = 0x00; portd = (tabela[contador]); // mostra no display valor inicial do contador porte = 0x00; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 26 Linguagem C para PIC

* Loop principal * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ while(true) // rotina principal RESTART_WDT(); // incia o watch-dog timer /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Tratamento do Botão 0 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ if (!botao_up) // O botão UP está pressionado? // sim, if (!(bt_up_press)) // O botão UP já foi tratato? // não. if (filtro0!=0) // Fim do filtro do botão UP? filtro0--; // Não, então decrementa o filtro else // Sim, Faz a ação do botão bt_up_press = 1; // Marca que o botão está pressionado if (contador!= max) contador++; // incrementa o contador portd = (tabela[contador]); // consulta tabela, atualiza // display else // botão 0 liberado filtro0 = t_filtro; // inicia o filtro do botão 0 bt_up_press = 0; // marca que o botão foi liberado /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Tratamento do Botão 1 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ if (!botao_down) // testa botão DOWN // botão DOWN pressionado if (!(bt_down_press)) // o botão DOWN já foi tratato? // não if (filtro1!=0) // Fim do filtro do botão DOWN? filtro1--; // não, então decrementa o filtro else //. Faz a ação do botão bt_down_press = 1; // marca que o botão está pressionado if (contador!= min) contador--; // decrementa o contador portd = (tabela[contador]);// consulta tabela, atualiza // display else // botão 1 liberado filtro1 = t_filtro; // inicia o filtro do botão 1 bt_down_press = 0; // marca que o botão foi liberado Linguagem C para PIC 27

1.21 - Exercícios Propostos Agora que o exemplo já foi estudado e esclarecido, aproveite para gerar novos problemas e soluções, seguindo os exercícios propostos: 1. Modifique o programa para que o contador conte de 1 a 5. 2. Implemente um botão para reset do contador. 3. Altere a tabela para que as posições de A a F da tabela apaguem o display. 4. Mude a contagem do dsp4 para o display dsp3. 28 Linguagem C para PIC

1.22 - Anotações Linguagem C para PIC 29

Recursos Avançados: Exemplo 4 1.23 - Recursos do Livro Maximização de Pinos de I/O Para o bom entendimento deste exemplo são necessários os conhecimentos adquiridos nos exemplos anteriores e mais, funções do compilador para controle de interrupção, tratamento automático (cap.12 pág.254 do livro Programação em C), controle do processador (cap.11 pág.223 do livro Programação em C), manipulação de Timers (cap.11.8 pág.211 do livro Programação em C), diretivas de configuração para uso de interrupções, #int_xxx e #priority (cap.10, pág.161 e pág.166 do livro Programação em C). 1.24 - Lógica do exemplo Nosso exemplo será composto de um programa capaz de ler quatro botões e tocar o buzzer com uma freqüência diferente para cada combinação de botões. Para cada botão existe um led ligado no mesmo pino, que será utilizado para indicar os botões pressionados no momento. Utilizaremos os timers e duas interrupções para controlarmos a freqüência de leitura dos botões e a freqüência do buzzer: Timer 0: controlará a freqüência de varredura dos botões; Timer 2: controlará a freqüência do som. O som será feito excitando o buzzer com uma onda quadrada de freqüência variável. Variaremos esta freqüência alterando o valor de PR2, que controla o estouro deste timer. Desta forma, nosso programa principal será um loop infinito sem efeito algum. Somente ficaremos esperando o acontecimento das interrupções. Para a varredura dos botões ajustaremos a interrupção de TMR0 para aproximadamente 500Hz: Ciclo de Máq. Prescale Conta TMR0 Auxiliar Período Freqüência 1 µs 8 256-2048 µs 488 Hz Além disso, o sistema possui um filtro, regulado pela constante FILTRO_BOTAO, para evitar o debounce da tecla. Este filtro garante que a tecla fique pressionada pelo tempo de FILTRO_BOTAO x 2048µs. Quanto à freqüência do buzzer, esta será controlada por TMR2. Calibramos os valores de pre e postscale para que a freqüência da interrupção do TMR2 varie entre 100Hz e 2kHz, com a variação de PR2 entre 16 e 240: Ciclo de Máq. Prescale Postscale PR2 Período Freqüência 1 µs 16 1 16 256 µs 3906 Hz 1 µs 16 1 240 3840 µs 260 Hz Para facilitar a implementação, a cada interrupção inverteremos o estado do pino de acionamento do buzzer. Desta forma, a freqüência deste será equivalente à metade da freqüência da interrupção do TMR2. O Livro Conectando o PIC, possui um cápitulo dedicado a este assunto. 30 Linguagem C para PIC

Linguagem C para PIC 31 1.25 - Esquema Elétrico +5V +5V +5V +5V S1 RB0 10K 10K 330R +5V S2 RB1 10K 10K 330R +5V S3 RB2 10K 10K 330R +5V S4 RB3 10K 10K 330R RESET 10K MCLR RA0 RA1 RA2 RA4 RA5 RA3 RE1 RE0 RE2 VDD VSS OSC1 OSC2 RC1 RC2 RC0 RC4 RC3 RC5 VDD VSS RB7 RB6 RB4 RB3 RB5 RB1 RB2 RB0 RD7 RD6 RD5 RD4 RD2 RD1 RD3 RC7 RD0 RC6 1 2 4 3 5 6 7 8 9 10 11 12 13 14 15 16 17 18 23 24 33 30 29 28 27 22 21 20 19 26 25 32 31 40 39 38 37 36 35 34 MC1 BUZZER 4MHz L1 L2 L3 L4 16F877A

1.26 - Fluxograma MAIN CONFIGURAÇÕES INICIAIS TRIS, PORTAS, WATCHDOG, PRESCALER. LIGA AS INTERRUPÇÕES LIMPA WATCHDOG 32 Linguagem C para PIC

INTERRUPÇÕES INT DE TMR0? Trata TMR2 Trata TMR0 TRATA TMR2 SAÍDA DO BUZZER ESTÁ LIGADA? LIGA A SAÍDA DO BUZZER DESLIGA A SAÍDA DO BUZZER FIM DA INTERRUPÇÃO Linguagem C para PIC 33

TRATA TMR0 Convetre pinos dos botões em entradas Delay de 4 ciclos de máquina para estabilização do port Lê todos os botões e guarda em variável temporária (STATUS_BOTÕES) Converte pinos dos botões em saída CHECA BOTÃO S1 Reinicia Filtro Botão S1 PRESS? Limpa Flag de botão pressionado (Status Leds) Fim do Filtro? Marca flag de botão pressionado CHECA BOTÃO S2 CHECA BOTÃO S3 CHECA BOTÃO S4 A 34 Linguagem C para PIC

AÇÃO DOS BOTÕES A Atualiza leds conforme botões pressionados Algum botão pressionado? Inicializa PER com 255 Consulta tabela conforme conbinação de botões pressionados Deliga interrupção de TMR2 Inicializa TMR2 Desliga a saída do Buzzer Liga Interrupção de TMR2 FIM DA INTERRUPÇÃO Linguagem C para PIC 35

1.27 - Código * Programação em C - Recursos Básicos de programação * * Exemplo 4 * * * * CENTRO DE CAPACITAÇÃO - LABTOOLS * * * * TEL: (0XX11) 4992-8775 SITE: www.labtools.com.br * * E-MAIL: cursos@labtools.com.br * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * VERSÃO : 1.0 * * DATA : 05/06/2003 * /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Descrição geral * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ // Este software está preparado para ler quatro botões e tocar o buzzer com //duração variavel conforme a tecla pressionada, além de acender o led //indicando a última tecla pressionada. /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * DEFINIÇÃO DAS VARIÁVEIS INTERNAS DO PIC * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ #include <16f877A.h> // microcontrolador utilizado /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Configurações para gravação * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ #fuses xt,wdt,noprotect,put,brownout,nolvp,nocpd,nowrt fusíveis // configuração dos /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Constantes internas * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ //A definição de constantes facilita a programação e a manutenção. #define t_filtro 20 // tamanho do filtro /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Definição e inicialização das variáveis * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ //Neste bloco estão definidas as variáveis globais do programa. int status_botoes = 0; int status_leds = 0; int per = 0; int filtro1 = t_filtro; int filtro2 = t_filtro; int filtro3 = t_filtro; int filtro4 = t_filtro; // armazena o estado lógico dos botões // atualiza leds conforme o botão pressionado // limitador de contagem do Timer2 // inicia filtro do botao1 // inicia filtro do botao2 // inicia filtro do botao3 // inicia filtro do botao4 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Definição e inicialização dos port's * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ #use fast_io(a) #use fast_io(b) #use fast_io(c) #use fast_io(d) #use fast_io(e) #byte porta = 0x05 #byte portb = 0x06 #byte portc = 0x07 #byte portd = 0x08 #byte porte = 0x09 36 Linguagem C para PIC

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Declaração dos flags de software * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ //A definição de flags ajuda na programação e economiza memória RAM. /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ENTRADAS * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ // As entradas devem ser associadas a nomes para facilitar a programação e //futuras alterações do hardware. #bit botao1 = status_botoes.0 // Estado do botão 1 // 1 -> Liberado // 0 -> Pressionado #bit botao2 = status_botoes.1 // Estado do botão 2 // 1 -> Liberado // 0 -> Pressionado #bit botao3 = status_botoes.2// Estado do botão 3 // 1 -> Liberado // 0 -> Pressionado #bit botao4 = status_botoes.3 // Estado do botão 4 // 1 -> Liberado // 0 -> Pressionado /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * SAÍDAS * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ // AS SAÍDAS DEVEM SER ASSOCIADAS A NOMES PARA FACILITAR A PROGRAMAÇÃO E //FUTURAS ALTERAÇÕES DO HARDWARE. #bit botao1_press = status_leds.0 #bit botao2_press = status_leds.1 #bit botao3_press = status_leds.2 #bit botao4_press = status_leds.3 #bit buzzer = porta.5 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Tabela de Valores * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ byte const tabela[16] = 255,16,32,48,64,80,96,112,128,144,160,176,192,208,224,240; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Configuração do Microcontrolador * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ // A rotina principal simplesmente limpa o WDT, pois toda a lógica do // programa é tratada dentro das interrupções. void main() setup_adc_ports (no_analogs); setup_counters(rtcc_internal, rtcc_div_8); setup_timer_2 (t2_div_by_16,per,1); set_tris_a(0b11011111); set_tris_b(0b11110000); set_tris_c(0b11111111); set_tris_d(0b11111111); set_tris_e(0b00000111); porta=(0b00000000); portb=(0b00000000); portc=(0b00000000); portd=(0b00000000); porte=(0b00000000); enable_interrupts(global); enable_interrupts(int_rtcc); #priority timer0,timer2 // prioridade para a int de trm0 Linguagem C para PIC 37

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Rotina principal * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ while(true) // rotina principal RESTART_WDT(); // incia o watch-dog timer /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Rotina de Tratamento de interrupção de TMR0 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ // Esta interrupção ocorrerá a cada 2048us. // O filtro dos botões tem duração de 40ms (2048us x 20) e são decrementados a cada // interrupção. // Esta interrupção é responsável por converter os pinos dos botões em entrada, salvar // a condição dos botões em variável temporária e converter os pinos em saída // novamente. #int_rtcc void trata_int_tmr0() set_tris_b(0b00001111); delay_cycles(4); status_botoes = portb; set_tris_b(0b00000000); // configura os pinos como entrada para // testar os botões // aguarda 4 ciclos de máquina para a // estabilização do portb // lê o status dos botoes, salva em variável // temporária // configura os pinos como saída para // controle dos leds /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Tratamento do Botão 1 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ if (!botao1) // testa botão 1 // botão 1 está pressionado? filtro1--; // Sim, então decrementa o filtro if (filtro1 == 0) // acabou o filtro do botão 1? botao1_press = 1; // marca que o botão está pressionado else // botão 1 liberado filtro1 = t_filtro; // inicia o filtro do botão 1 botao1_press = 0; // marca que o botão foi liberado /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Tratamento do Botão 2 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ if (!botao2) // testa botão 2 // botão 2 está pressionado? filtro2--; // Sim, então decrementa o filtro if (filtro2 == 0) // fim do filtro do botão 2? botao2_press = 1; // marca que o botão está pressionado else // botão 2 liberado filtro2 = t_filtro; // inicia o filtro do botão 2 botao2_press = 0; // marca que o botão foi liberado /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Tratamento do Botão 3 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ if (!botao3) // testa botão 3 // botão 3 está pressionado? 38 Linguagem C para PIC

filtro3--; // Sim, então decrementa o filtro if (filtro3 == 0) // fim do filtro do botão 3? botao3_press = 1; // marca que o botão está pressionado else // botão 3 liberado filtro3 = t_filtro; // inicia o filtro do botão 3 botao3_press = 0; // marca que o botão foi liberado /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Tratamento do Botão 4 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ if (!botao4) // testa botão 4 // botão 4 está pressionado? filtro4--; // Sim, então decrementa o filtro if (filtro4 == 0) // fim do filtro do botão 4? botao4_press = 1; // marca que o botão está pressionado else // botão 4 liberado filtro4 = t_filtro; // inicia o filtro do botão 4 botao4_press = 0; // marca que o botão foi liberado /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Atualiza Leds conforme botões pressionados * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ portb = status_leds; // atualiza os leds if (status_leds == 0) per = 0xff; setup_timer_2 (t2_div_by_16,per,1); disable_interrupts (INT_TIMER2); buzzer = 0; else per = (tabela[status_leds]);// consulta tabela e inicializa timer2. setup_timer_2 (t2_div_by_16,per,1); enable_interrupts (INT_TIMER2); // habilita interrupção de timer2. /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Rotina de Tratamento de interrupção de TMR2 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ // Está interrupção só irá ocorrer quando alguma tecla estiver pressionada, // o periodo de ocorrência depende do botão ou da conbinação de botões pressionados, // ela irá inverter o pino de I/O do buzzer a cada interrupção. #int_timer2 void trata_int_tmr2() if (buzzer!= 0) // o buzzer está ligado? buzzer = 0; // sim, então desliga else buzzer = 1; // não, então liga Linguagem C para PIC 39

1.28 - Exercícios Propostos Agora que o exemplo já foi estudado e esclarecido, aproveite para gerar novos problemas e soluções, seguindo os exercícios propostos: 1. Utilize as funções disponíveis do Compilador para inverter o estado do buzzer. 2. Modifique o controle dos leds, os botões pares controlam os leds impares e os botões impares controlam os leds pares, conforme a tabela abaixo. Botão 1 Botão 2 Botão 3 Botão 4 Led 2 Led 1 Led 4 Led3 40 Linguagem C para PIC

1.29 - Anotações Linguagem C para PIC 41

Recursos Avançados: Exemplo 5 1.30 - Recursos do Livro Varredura de Display Para o bom entendimento deste exemplo são necessários os conhecimentos adquiridos nos exemplos anteriores e mais, funções do compilador para controle de interrupção, tratamento manual (cap.12 pág.254 do livro Programação em C), controle do processador (cap.11 pág.223 do livro Programação em C), manipulação de Timers (cap.11.8 pág.211 do livro Programação em C), introdução de código em assembly no programa em C (cap.10, pág.151 do livro Programação em C),retorno de valores em funções assembly (cap.9, pág.147 do livro Programação em C), diretivas de configuração para uso de interrupções, #int_global e #priority (cap.10, pág.162 e pág.166 do livro Programação em C). 1.31 - Lógica do exemplo O exemplo desenvolvido para esta aula faz muito mais que simplesmente implementar a varredura dos displays. Trata-se de um contador regressivo de segundos, ou seja, um temporizador capaz de contar até 9.999 segundos. Para isso, utilizaremos os displays para indicar o valor atual do temporizador. A primeira tecla (S1) não possui nenhuma função. Por outro lado, o led relacionado a ela (L1) será utilizado para indicar o estado do temporizador: L1 Aceso Apagado Descrição Temporizador em contagem regressiva Temporizador paralisado Os demais botões apresentam as funções de controle do temporizador: Botão S2 S3 S4 Descrição Incrementa o valor inicial em 1 segundo Decrementa o valor inicial em 1 segundo Inicia e paralisa o temporizador Os botões de incremento e decremento operam de forma rotativa, isto é, comutam automaticamente entre 0000 e 9999. Outra característica destes botões é que eles executam suas funções repetidamente quando mantidos pressionados e só funcionam quando o temporizador está paralisado. Ao atingir o valor zero (0000) o temporizador é automaticamente paralisado, desligandose o led indicativo (L1). Para o sistema de varredura foram criadas 4 variáveis para armazenamento dos dígitos mostrados nos respectivos displays: UNIDADE, DEZENA, CENTENA e MILHAR. Estas variáveis representam o valor atual do temporizador e são incrementadas e decrementadas através dos botões. Na verdade, os botões alteram diretamente o valor da unidade. A lógica do sistema compara este valor com os limites (0 e 9) para alterar ou não os demais dígitos. A freqüência de varredura é controlada pela interrupção de Timer0. Ajustamos seus parâmetros para que a comutação entre displays (tempo da interrupção) seja de aproximadamente 4kHz: Ciclo de Máq. Prescale Conta TMR0 Auxiliar Período Freqüência 1 µs 1 256-256 µs 3900 Hz 42 Linguagem C para PIC

A freqüência de varredura será a freqüência de comutação dividida pelo número de displays, que no nosso caso será de aproximadamente 1kHz. Dentro do tratamento da interrupção de TMR0 é desligado o display atual, carregado o valor do dígito correspondente ao display e ligado o display seguinte. Quanto à contagem dos segundos, utilizamos a interrupção de Timer1 para esta finalidade. Veja os ajustes dos parâmetros para esta interrupção: Ciclo de Máq. Prescale Conta TMR1 Auxiliar Período Freqüência 1 µs 8 62500 2 1.000.000 µs 1 Hz Para isso, configuramos o prescale de TMR1 em 1:8 e iniciamos o contador com o valor total menos o desejado para a contagem (65.536 62.500). Desta maneira a interrupção acontecerá a cada 0,5 segundo. Para podermos contar 1 segundo foi criado uma variável auxiliar denominada DIVISOR_TMR1. Cada vez que o sistema entrar na interrupção de TMR1 e o contador auxiliar (DIVISOR_TMR1) terminar, o tempo é decrementado, começando pela unidade e chegando até a milhar, se for necessário. Quando o tempo termina (0000) tanto o led quanto o TMR1 são desligado. Neste exemplo está sendo utilizado o tratamento Manual de interrupções, neste modo nós devemos providenciar todo o código necessário para o tratamento da interrupção, tais como: salvar contexto, restaurar contexto, limpar os flags de indicação de interrupção e criar os registradores para as rotinas de salvar e restaurar contexto. A prioridade de tratamento da interrupção depende da seqüência de teste dos flags de int, que também é de responsabilidade do programador. Para este tipo de tratamento estamos utilizando a diretiva #int global. Linguagem C para PIC 43

1.32 - Esquema Elétrico 220R a b c d e f g Dp f e DS1 a g b c d Dp f e DS2 a g b c d Dp f e DS3 a g b c d Dp f e DS4 a g b c d Dp 220R Comum 1 Comum 2 Comum 3 Comum 4 BC337 BC337 BC337 BC337 +5V +5V 4,7K 4,7K 4,7K 4,7K RESET 10K MC1 4MHz +5V 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 23 24 MCLR RA0 RA1 RA2 RA3 RA4 RA5 RE0 RE1 RE2 VDD VSS OSC1 OSC2 RC0 RC1 RC2 RC3 RC4 RC5 16F877A 32 VDD 31 VSS 40 RB7 39 RB6 38 RB5 RB4 37 36 RB3 35 RB2 34 RB1 33 RB0 30 RD7 29 RD6 28 RD5 27 RD4 22 RD3 21 RD2 20 RD1 19 RD0 26 RC7 25 RC6 RB0 +5V +5V +5V 330R 10K 10K RB1 RB2 RB3 10K L1 S2 S3 S4 44 Linguagem C para PIC

1.33 - Fluxograma MAIN CONFIGURAÇÕES INICIAIS TRIS, PORTAS, WATCHDOG, PRESCALER. Configura Timer1 Liga as interrupções A Limpa WATCHDOG BOTÃO UP PRESS.? Trata Botão UP BOTÃO DOWN PRESS.? Trata Botão Down BOTÃO Start/Stop PRESS.? Trata Botão Start/Stop Recarrega Filtro e turbo das teclas Linguagem C para PIC 45

INTERRUPÇÕES INT DE TMR0? SWITCH CASE Recarrega Timer1 decrementa contador de int. Atualiza Display da Unidade? Incrementa ponteiro de seleção de Display, desliga display do milhar, consulta tabela de conversão para sete segmentos, liga display da unidade Passou 1 segundo? Atualiza Display da Dezena? Incrementa ponteiro de seleção de Display, desliga display da unidade, consulta tabela de conversão para sete segmentos, liga display da dezena Recarrega contador de int. Decrementa Timer Atualiza Display da Centena? Incrementa ponteiro de seleção de Display, desliga display da dezena, consulta tabela de conversão para sete segmentos, liga display da centena Timer Chegou a zero? Atualiza Display do milhar? Zera ponteiro de seleção de Display, desliga display da centena, consulta tabela de conversão para sete segmentos, liga display do milhar Desliga led de indicação de timer operando FIM DA INTERRUPÇÃO Desabilita interrupção de Timer1 FIM DA INTERRUPÇÃO 46 Linguagem C para PIC

Trata Botão UP Trata Botão DOWN Timer Ligado? Timer Ligado? Decrementa Filtro Decrementa Filtro Fim do Filtro? Fim do Filtro? Decrementa Turbo Decrementa Turbo Fim do Temporizador para Turbo do Botão? Fim do Temporizador para Turbo do Botão? Recarrega temporizador para Turbo Recarrega temporizador para Turbo Incrementa Timer Decrementa Timer A A Linguagem C para PIC 47

Trata botão Start/Stop Ação já foi executada? Filtro terminou? Timer ligado? Timer é igual a zero? Apaga led de indicação de Timer ligado Acende Led de indicação de Timer ligado Desabilita interrupção de Timer1 Carrega Timer1 A Carrega contador de interrupções Habilita interrupção de Timer 1 A 48 Linguagem C para PIC

Incrementa Timer Decrementa Timer Incrementa unidade Decrementa unidade Unidade = 10? Unidade = 0XFF? Zera unidade Incrementa dezena Unidade = 9 Decrementa dezena Dezena = 10? Dezena = 0XFF? Zera dezena Incrementa centena Dezena = 9 Decrementa centena centena = 10? centena = 0XFF? Zera centena Incrementa milhar Centena = 9 Decrementa milhar Milhar = 10? Milhar = 0XFF? Zera milhar Milhar = 9 Return Return Linguagem C para PIC 49

1.34 - Código * Programação em C - Recursos Básicos de programação * * Exemplo 5 * * * * CENTRO DE CAPACITAÇÃO - LABTOOLS * * * * TEL: (0XX11) 4992-8775 SITE: www.labtools.com.br * * E-MAIL: cursos@labtools.com.br * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * VERSÃO : 1.0 * * DATA : 05/06/2003 * /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Descrição geral * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ // Este exemplo foi preparado para demonstrar o funcionamento do TIMER de // 16 bits do PIC (TMR1), da varredura de displays e do tratamento manual de int. // Consiste num temporizador de segundos. dois botões foram utilizados para // programar o tempo da contagem. Um outro botão foi utilizado para disparar // o contador. O temporizador consegue contar até 9999 segundos, de forma que // os 4 displays de 7 segmentos foram necessários. A contagem é regressiva. // um led indica que o temporizador está operando. Quando o sistema chega // a 0000 (ZERO) o led é desligado automaticamente. /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * DEFINIÇÃO DAS VARIÁVEIS INTERNAS DO PIC * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ #include <16f877A.h> // microcontrolador utilizado /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Configurações para gravação * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ #fuses xt,wdt,noprotect,put,brownout,nolvp,nocpd,nowrt fusíveis // configuração dos /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Definições para uso de Rotinas de Delay * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ #use delay(clock=4000000, RESTART_WDT) /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Constantes internas * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ //A definição de constantes facilita a programação e a manutenção. #define t_filtro 250 // tamanho do filtro #define turbo_tecla 60 #define delta_timer1 (65536-62500) /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Definição e inicialização das variáveis * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ //Neste bloco estão definidas as variáveis globais do programa. int display = 0 ; // atualiza os displays int contador = 2; // contador de interrupções de timer1 int filtro = t_filtro; // inicia filtro dos botões int turbo = 1; // inicia turbo das teclas int unidade = 9; // variável unidade do timer de 1 seg int dezena = 9; // variável dezena do timer de 1 seg int centena = 9; // variável centena do timer de 1 seg int milhar = 9; // variável milhar do timer de 1 seg static int W_TEMP; static int STATUS_TEMP; static int FSR_TEMP; static INT PCLATH_TEMP; // variáveis para salvar contexto 50 Linguagem C para PIC

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Definição e inicialização dos port's * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ #use fast_io(a) #use fast_io(b) #use fast_io(c) #use fast_io(d) #use fast_io(e) #byte porta=0x05 #byte portb=0x06 #byte portc=0x07 #byte portd=0x08 #byte porte=0x09 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Definição de SFR's * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ #bit tmr1if = 0x0c.0 // tmr1if é o bit 0 do sfr pir1 #bit t0if = 0x0b.2 // t0if é o bit 2 do sfr intcon #bit tmr1ie = 0x8c.0 // tmr1ie é o bit 0 do fsr pie1 #byte status = 0x03 // define endereço do reg de status #byte fsr = 0x04 // define endereço do reg de fsr #byte pclath = 0x0a // define endereço do reg de pclath /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Declaração dos flags de software * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ //A definição de flags ajuda na programação e economiza memória RAM. /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ENTRADAS * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ // As entradas devem ser associadas a nomes para facilitar a programação e //futuras alterações do hardware. #bit bt_up = portb.1 // Estado do botão up // 1 -> Liberado // 0 -> Pressionado #bit bt_down = portb.2 // Estado do botão down // 1 -> Liberado // 0 -> Pressionado #bit bt_start_stop = portb.3 // Estado do botão start_stop // 1 -> Liberado // 0 -> Pressionado /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * SAÍDAS * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ // AS SAÍDAS DEVEM SER ASSOCIADAS A NOMES PARA FACILITAR A PROGRAMAÇÃO E //FUTURAS ALTERAÇÕES DO HARDWARE. #bit estado_timer = portb.0 // led de estado do timer // 1 -> timer contando // 0 -> timer parado #bit disp0 = portb.4 // seleção do display unidade (0) #bit disp1 = portb.5 // seleção do display dezena (1) #bit disp2 = portb.6 // seleção do display centena (2) #bit disp3 = portb.7 // seleção do display milhar (3) Linguagem C para PIC 51