Índice Introdução ---------------------------------------------------- --------------------------------------------------------------------------------------------- Linguagem C --------------------------------------------------------- ------------------------------------------------------------------------------ Microcontrolador ------------------------------------------------------ ----------------------------------------------------------------------Estrutura Interna do 18F452 ----------------------------------------------------------- ----------------------------------------------Função de cada pino do 18F452 -------------------------------------------------------- ---------------------------------------Mapa de Registradores Especiais -------------------------------------------------------- -----------------------------------Princípio de Programação ----------------------------------------------------------- ----------------------------------------------------Introdução à Linguagem C -------------------------------------------------------------- ------------------------------------------------ Representação numérica ---------------------------------------------------------- ------------------------------------------------------ Tipos de dados ------------------------------------------------------- ------------------------------------------------------------------------------ Variável local e global ---------------------------------------------------------------- ---------------------------------------------------- Operadores matemáticos -------------------------------------------------------------- -------------------------------------------------- Controle de Fluxo ----------------------------------------------------------- --------------------------------------------------------------------- Decisão IF --------------------------------------------------------- ---------------------------------------------------------------------------------------- Decisão IF-ELSE --------------------------------------------------------------- -------------------------------------------------------------------- Decisão SWITCH-CASE ----------------------------------------------------------------- ----------------------------------------------- Loop FOR -------------------------------------------------- ------------------------------------------------------------------------------------------------- Loop WHILE --------------------------------------------------------- ---------------------------------------------------------------------------------- Loop DO-WHILE ----------------------------------------------------------- ---------------------------------------------------------------------- Ponteiros e Matrizes ------------------------------------------------------------------- --------------------------------------------------------- Introdução ao MikroC --------------------------------------------------------- --------------------------------------------------------------- Ambiente MikroC ----------------------------------------------------------- ---------------------------------------------------------------------- Criando um Projeto --------------------------------------------------------------------- --------------------------------------------------------- Device Flags (bits de configuração) ----------------------------------------------------------- ----------------------------- Primeiro Projeto ------------------------------------------------------------ ------------------------------------------------------------------------- Programa 1 – Configuração das portas --------------------------------------------------------- ------------------------- Gravando o Primeiro Projeto ------------------------------------------------------------- ------------------------------------------- Usando o Debug no MikroC --------------------------------------------------------------- ------------------------------------------- Programa 2 – Uso do Define ------------------------------------------------------ ---------------------------------------------------- Programa 3 – Acionamento de Botões ----------------------------------------------------------- ------------------------- Programa 4 – Utilização do IF-ELSE ------------------------------------------------------------- ------------------------- Programa 5 – Utilização do IF_ELSE ----------------------------------------------------------- --------------------------- Programa 6 – Utilização do IF-ELSE-IF ---------------------------------------------------------- ---------------------- Programa 7 – Função Button -------------------------------------------------------------- ---------------------------------------------- Programa 8 – Eliminando Problema do Debounce --------------------------------------------------- ------ Declaração de Funções ------------------------------------------------------------- ----------------------------------------------------------- Display LCD ----------------------------------------------------------- ------------------------------------------------------------------------------------ Comandos do LCD --------------------------------------------------------------- ------------------------------------------------------------------ Configuração Modo 4 e Modo 8 Bits --------------------------------------------------------------- ------------------------- Programa 9 – Transmissão de mensagem para LCD --------------------------------------------- ---- Programa 10 – Transmissão de mensagens para LCD ------------------------------------------- -------- Configurações do LCD em 4 Bits e 8 Bits ------------------------------------------------------ ---------------------- Módulo PWM ------------------------------------------------------------------- -------------------------------------------------------------------------- Programa 11 - Utilização do CCP1 ------------------------------------------------------------------- ------------------------- Programa 12 - Utilização do CCP2 ------------------------------------------------------------------- ------------------------- Programa 13 – Utilizando os Módulos CCP1 e CCP2 ----------------------------------------------- -1
3 3 4 5 6 8 10 11 11 12 13 14 14 15 15 17 18 18 19 20 21 22 23 24 29 30 32 35 39 40 41 42 43 44 45 46 48 49 50 51 52 53 54 55 55 56
- Programa 14 – Ajustando os Módulos usando botões ---------------------------------------------- ----- Conversor A/D ----------------------------------------------------- -------------------------------------------------------------------------------------- Programa 15 – Leitura do Canal AN0 (0 a 1023) --------------------------------------------------- ---------- Programa 16 – Leitura do canal AN0 (0 a 5V) ----------------------------------------------------- -------------- Programa 17 – Leitura do Canal A/D com ponto flutuante -------------------------------------- - Programa 18 – Controle PWM usando conversor A/D -------------------------------------------- ----- Comunicação Serial ---------------------------------------------------------------- --------------------------------------------------------------- Programa 19 – Transmissão de dado Serial --------------------------------------------------------- ------------------ Programa 20 – Transmissão/Recepção Serial ----------------------------------------------------- ------------------ Programa 21 – Transmissão/Recepção de Dados------------------------------Dados------------ --------------------- Programa 22 - Uso de Ponteiros na Transmissão de Dados ------------------------------------- -- Programa 23 – Transmissão de Dados ----------------------------------------------------------- --------------------------- Programa 24 – Leitura de Temperatura e Transmissão Serial ----------------- Programa 25 – Leitura de Temperatura, Comparação e Acionamentos ------ Programa 26 – Configuração do TIMER0 em 8 bits – Temporizador ------- Programa 27 – Configuração do TIMER0 em 16 bits – Temporizador ----- Programa 28 – Configuração do TIMER0 em 8 bits – Contador ------------- Programa 29 – Memória EEPROM do PIC --------------------------------------------------------- ------------------ Introdução a Interrupção ----------------------------------------------------------- ---------------------------------------------------------- Registrador RCON --------------------------------------------------------- ------------------------------------------------------------------------ Registrador INTCON ----------------------------------------------------------- ------------------------------------------------------------------ Registrador INTCON2 ----------------------------------------------------------------- ------------------------------------------------------------- Registrador INTCON3 ----------------------------------------------------------------- ------------------------------------------------------------- Registrador PIE1 ------------------------------------------------------ ------------------------------------------------------------------------------------- Registrador PIE2 ------------------------------------------------------ ------------------------------------------------------------------------------------- Registrador PIR1 ---------------------------------------------------------- --------------------------------------------------------------------------------- Registrador PIR2 ---------------------------------------------------------- --------------------------------------------------------------------------------- Registrador IPR1 ---------------------------------------------------------- --------------------------------------------------------------------------------- Registrador IPR2 ---------------------------------------------------------- --------------------------------------------------------------------------------- Estrutura de Programa utilizando Alta Alta e Baixa Prioridade ---------------------------------------- ----- Programa 30 – Tratamento de Interrupção INT0 ------------------------------------------------------ ------------- Programa 31 – Tratamento de Interrupção INT0 e INT1 ----------------------------------------- ------ Programa 32 – Tratamento de Interrupção INT0 INT0 e INT1 com Prioridade -----
2
57 58 63 64 65 66 67 67 68 69 70 71 73 74 79 80 81 82 84 85 86 87 88 89 90 91 92 93 94 94 95 97 99
Introdução: Linguagem C Linguagem C foi desenvolvida por Brian Kernighan e Dennis M. Ritchie na década de 70 no AT&T Bell Labs. Em pouco tempo, esta linguagem teve grande utilização em Universidades espalhadas pelo Mundo, tornando-se praticamente oficial em cursos de engenharias. É uma linguagem estruturada, eficiente, rápida e tão poderosa quanto a Linguagem Assembly. A cada ano vem aumentando o número de programadores de Microcontroladores que acabam migrando da Linguagem Assembly para o C. Os programas em C acabam ficando muito mais eficientes e mais rápidos de serem escritos pois os Compiladores de Programas em Linguagem C para Microcontroladores possuem várias bibliotecas de funções prontas como Comunicação Serial, ADC, EEPRON, I2C, PWM, LCD, etc. Existe no mercado vários compiladores para desenvolvimento de programas na Linguagem C como Hi-Tech, CCS, PICmicro C, etc. Adotamos para nosso treinamento o compilador MikroC da Microelektronika por ser bastante poderosa e fácil de trabalhar (permite Editar, Simular e Compilar programas das famílias 12, 16 e 18 da Microchip) além de também possuir uma vasta biblioteca de controle de periféricos dos Microcontroladores. Além disso, a versão estudante é gratuito para desenvolvimento de programas de até 2Kwords, o que torna bastante atraente também para uso educacional. Pode-se fazer download em www.mikroe.com www.mikroe.com.. Contudo, uma das grandes vantagens de se programar em C é que o programador não precisa se preocupar com o acesso a bancos, localização de memória e periféricos dos Microcontroladores pois o Compilador é responsável por gerenciar esses controles. Toda essa eficiência da Linguagem C proporciona ao programador preocupar-se apenas com o programa em si e o compilador traduz da Linguagem C para a Linguagem de máquina (.HEX) que é a linguagem que os Microcontroladores conseguem entender.
3
Microcontrolador Hoje existe uma grande quantidade de Microcontroladores utilizados em projetos de equipamentos eletroeletrônicos. O programador poderá escolher entre Intel, Motorola, Atmel, Microchip, etc. A Uptex decidiu pela Microchip pois a mesma encontra-se entre os mais utilizados mundialmente além de também oferecer muitos de seus compiladores gratuitamente. Existe também uma vasta literatura orientando profissionais e estudantes quanto às aplicações e projetos. Isto tudo pode ser verificado no site da Microchip em (Aplication Notes). Aplicaçõs com Dislays LCD (Display de Cristal Líquido), Displays e matrizes de leds, Comunicação Serial, USB, Conversores Analógico/Digital e Controle PWM são alguns exemplos de utilização em equipamentos suportados por microcontroladores. É só verificarmos os equipamentos hoje microcontrolados e pensarmos na evolução que existe e tudo ainda que possa a vir a existir. Vejamos alguns exemplos de equipamentos: celulares, máquinas de lavar/secar roupas, sistemas de alarme e controle de acesso, brinquedos, iluminação residencial, etc. Existem muitas aplicações também na área automobilística, aeroespacial, médica, agricultura e muitas mais. Agora é com você programador que têm a habilidade de verificar a necessidade e proporcionar então a funcionalidade de determinado aparelho/sistema através de um sistema microcontrolado. O Microcontrolador que iremos trabalhar será o 18F452 da Microchip. A grande vantagem é que possui memória Flash, possibilitando assim escrever/apagar com grande rapidez. Abaixo temos principais características do 18F452: - 40 pinos podendo ter até 34 I/O (Input/Output digital); - 8 canais A/D de 10 Bits; - 02 Módulos CCP – capture, compare e PWM; - Memória de Programa Flash – 32K - Memória RAM – 1536 bytes; - Memória EEPROM – 256 bytes; - velocidade de processamento – até 10MIPS (milhões de instruções por segundo); - Módulo MSSP (Master Synchronous Serial Port); - Módulo USART - Possibilita até 100.000 ciclos de escrita/leitura na memória de programa; - Possibilita 1.000.000 de ciclos de escrita/leitura na EEPROM; - Retenção dos dados na memória por até 40 anos; - Possibilita habilitação do Watchdog Timer; - Possibilita interrupção externa através de pinos do Microcontrolador; - 4 Temporizadores/Contadores.
4
Estrutura Interna do PIC 18F452
5
Função de cada pino do 18F452
O PIC 18F452 possui cinco PORTs: PORTA, PORTB, PORTC, PORTD e PORTE. Cada PORT possui pinos com acesso aos periféricos como Conversor Analógico/Digital, Interrupções, I2C, UART, Módulo CCP, SPI, ou podem ser utilizados como I/O de uso geral. Pino 1 2
7
Tipo In-In I/O e input A/D RA1 / AN1 I/O e input A/D RA2 / AN2/ VrefI/O e input A/D RA3/AN3/ Vref+ I/O e input A/D RA4 / T0CKI I/O e Input TMR0 RA5/AN4/SS/LVDIN I/O e Inputs
8
RE0 / RD / AN5
I/O
9
RE1 / WR / AN6
I/O
10
RE2 / CS / AN7
I/O
3 4 5 6
Função /MCLR / VPP RA0 / AN0
11, 32 VCC 12, 31 GND 13 OSC1 / CLK1
Fonte Fonte Input
14
Osc2 / CLK1 / RA6
I/O e Inputs
15
RC0/T10S0/T1Ck1
I/O Out e In
6
Funcionalidade Reset externo e programação ICSP I/O digital e entrada do AD0 I/O digital e entrada do AD1 I/O digital, entrada do AD2 e entrada baixa de referência do A/D I/O digital, entrada do AD3 e entrada de referência alta do A/D I/O digital e entrada do TMR0 I/O digital, entrada do AD4, entrada do SPI e Detector de LV I/O digital, Leitura da Porta Paralela e entrada do AD5 I/O digital, Escrita da Porta Paralela e entrada do AD6 I/O digital, Seleção da Porta Paralela e entrada do AD7 Positivo da Fonte de Alimentação Negativo da Fonte de Alimentação Entrada do Cristal e entrada do Clock externo I/O digital, Saída do Cristal e saída do Clock externo I/O digital, saída do 2° oscilador e entrada do contador externo Timer1/Timer3
16
RC1/T10S1/CCP2
17 18
RC2 / CCP1 Rc3 / SCK / SCL
19
RD0 / PSP0
20
RD1 / PSP1
21
RD2 / PSP2
22
RD3 / PSP3
23
RC4 / SDI / SDA
24 25
RC5 / SD0 RC6 / TX / CK
26
RC7 / RX / DT
27
RD4 / PSP4
28
RD5 / PSP5
29
RD6 / PSP6
30
RD7 / PSP7
33
RB0 / INT0
34
RB1 / INT1
35
RB2 / INT2
36 37
RB3 / CCP2 RB4
38
RB5 / PGM
39
RB6 / PGC
40
RB7 / PGD
I/O In e Out
I/O digital, entrada do 2° oscilador e saída do Módulo CCP2 I/O e Out I/O digital e saída do Módulo CCP1 I/O, I/O e I/O I/O digital, in e out do Clock serial para modo SPI e in/out do Clock serial para modo I2C I/O e I/O I/O digital e Porta de Comunicação Paralela I/O e I/O I/O digital e Porta de Comunicação Paralela I/O e I/O I/O digital e Porta de Comunicação Paralela I/O e I/O I/O digital e Porta de Comunicação Paralela I/O in I/O I/O digital, entrada de Dados SPI e in/out de dados do modo I2C I/O e out I/O digital e saída de dados SPI I/O out I/O I/O digital, Transmissão UART e Clock de sincronismo UART I/O in I/O I/O digital, Recepção UART e Dados do UART I/O e I/O I/O digital e Porta de Comunicação Paralela I/O e I/O I/O digital e Porta de Comunicação Paralela I/O e I/O I/O digital e Porta de Comunicação Paralela I/O e I/O I/O digital e Porta de Comunicação Paralela I/O e in I/O digital e entrada de Interrupção Externa 0 I/O e in I/O digital e entrada de Interrupção Externa 1 I/O e in I/O digital e entrada de Interrupção Externa 2 I/O e I/O I/O digital Módulo CCP2 I/O e in I/O digital e entrada de Interrupção por Mudança de Estado I/O in e in I/O digital, Interrupção por Mudança de Estado e Habilita ICSP baixa tensão I/O in I/O I/O digital, Interrupção por Mudança de Estado e ICSP in-circuit Debuger I/O in I/O I/O digital, Interrupção por Mudança de Estado e ICSP in-circuit Debuger
7
Nos Microcontroladores PIC temos os GPR (General Porpose Registers) que são os registradores de usos gerais que nada mais são do que variáveis criadas pelo programador – dados voláteis. Temos também os SFR(Special Funcion Registers) que são os Registradores de uso específico que na verdade contém o SETUP do Microcontrolador – configura como irão trabalhar determinados periféricos como PWM, Conversores A/D, USART, etc. O Microcontrolador 18F452 possui memória RAM de 1536 bytes sendo dividido em 16 bancos de 256 bytes de memória cada um.
Mapa de Registradores Especiais – SFRs
8
Temos então Portas: PORTA à PORTE e cada pino de cada porta pode ser configurado como entrada ou saída. No entanto, para podermos configurar como irá trabalhar cada pino de cada porta, temos que fazer uso do SFR – TRIS. O Registrador TRISA é responsável pela configuração do PORTA, o TRISB pelo PORTB, o TRISC pelo PORTC, o TRISD pelo PORTD e o TRISE pelo PORTE. É muito simples, se colocarmos 0 no bit do TRIS estamos definindo determinado pino como saída e colocando-se 1 no bit do TRIS estamos definindo o pino do PORT como entrada. Vejamos um exemplo: TRISB=0b00001100; Neste caso temos: RB0=saída RB1=saída RB2=entrada RB3=entrada RB4 à RB7 = saída Outro exemplo: TRISD=0b11111111; Neste caso temos todo o PORTD configurado como entrada Outro exemplo: TRISC=0b00000000; Neste caso temos todo o PORTC configurado como saída Os outros Registros Especiais iremos entender conforme andamento do curso.
9
Princípio de Programação: A Álgebra de Boole e seus operadores são muito utilizados em sistemas digitais e também na programação em Linguagens como o Assembly e também a Linguagem C. Temos então as operações E ou AND, OU ou OR e Não ou NOT e também NAND, NOR ou XOR ( OR EXCLUSIVO). OR A 0 0 1 1
B 0 1 0 1
S 0 1 1 1
AND A B 0 0 0 1 1 0 1 1
S 0 0 0 1
NOT A S 0 1 1 0 NOR A B 0 0 0 1 1 0 1 1
S 1 1 1 0
NAND A B 0 0 0 1 1 0 1 1
S 1 0 0 0
XOR A B 0 0 0 1 1 0 1 1
S 0 1 1 0
10
Introdução à Linguagem C Estrutura Básica de um programa: Programas em C são baseados em uma ou mais funções que serão executadas, no entanto, a função Main() é a primeira a ser executada. /* ------------------------------------------------abaixo temos um exemplo de estrutura Básica de um programa em Linguagem C ----------------------------------------------------- */ void main() { Trisb=0x00; Portb=0xFF; }
// esta é a primeira função que será executada // inicializa a função // aqui entram os comandos que serão executados // finaliza a função
Observações: Toda função deve iniciar abrindo chave e finalizar fechando-se a chave. Toda instrução deve ser finalizada com ponto e vírgula (obrigatoriamente) Logo após /* são inseridos os comentários para múltiplas linhas e deve-se Colocar */ para fechar o bloco de comentários. Utilizamos // para comentários em apenas uma linha.
Representação Numérica: Decimal: Contador=125; Binário: Portb=0b11010011; Hexadecimal: Variável1=0xA4; Octal: Teste=075; String: Unsigned char *texto=”Uptex Tecnologia” Caracter: Usart_write(‘&’);
11
Tipos de Dados: Dado: int char float e double void
Tipo: Números inteiros Caracteres Números decimais (ponto flutuante) valores nulos
Tipo Void Char Int Short Long Float Double
Tamanho – bits Zero 8 16 16 32 32 64
Valor Mínimo Sem valor -128 -32768 -32768 -231 -3,4 x 1038 -1,8 x 10308
Valor Máximo Sem valor 127 32767 32767 231-1 3,4 x 1038 1,8 x 10308
Modificadores: Tipo Char signed char unsigned char Short int signed short int unsigned short int Int signed unsigned int Short signed short unsigned short long int signed long int unsigned long int
Tamanho - bits 8 8 8 8 8 8 16 16 16 16 16 16 32 32 32
Valor Mínimo -128 -128 0 -128 -128 0 -32768 -32768 0 -32768 -32768 0 -231 -231 0
Valor Máximo 127 127 255 127 127 255 32767 32767 65535 32767 32767 65535 231-1 231-1 232-1
12
Declaração de variáveis: Podemos declarar da seguinte maneira:
+ + + ; 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 acesso à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 ultrapasse este valor, é necessário adquirir a versão full junto ao fabricante. Neste compilador encontramos uma vasta biblioteca de Funções: - ADC Library - CAN Library - CANSPI Library - EEPRON Library - Ethernet Library - SPI Ethernet Library - I2C Library - LCD Library - One Wire Library - PWM Library - PS2 Library - RS485 Library - SPI Library - UART Library - USB Library Bibliotecas ANSI C Stardard Demais Bibliotecas - Trigonometry Library - Time Library
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. CCP2MX Este bit tem a função de Multiplexar o módulo CCP2. Para CCP2MX=0 usaremos pino RC1 para CCP2 Para CCP2MX=1 usaremos pino RB3 para CCP2 STVREN (Stack Full / Underflow Reset Enable Bit) O Microcontrolador 18F452 possui 31 endereços de pilha. Este bit serve para habilitar o chip para ser resetado caso a limite da pilha seja ultrapassado. BKBUG (Debug) Este bit habilita o modo Debugger do PIC. Com isso pode-se emular o programa desenvolvido na placa de testes. No entanto, esta função ativa faz com os pinos RB6 e RB7 deixam de funcionar como I/O.
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, _PW RT_ON, _WDT_OFF, _LVP_OFF, _CP_OFF
Circuito:
29
Devemos então escrever o código e compilar o projeto para assim poder gravar o programa no Microcontrolador.
/********************************************************************** Uptex Tecnologia & Treinamento Ltda Curso de Microcontroladores PIC Linguagem C – Compilador MikroC Programa 1 Objetivo: Configuração das Portas e acesso das mesmas usando funções de tempo *********************************************************************/ void main ( ) { trisd = 0; //configura todo o portd como saída portd = 0; // todo o portd é colocado em nível zero while(1) //loop infinito { portd.f0=1; //ativa saída RD0 delay_ms(5000); //aguarda 5 segundos portd.f0=0; //desativa saída RD0 delay_1sec( ); //aguarda 1 segundo } }
30
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 ICPROG será utilizado para gravar o programa no Microcontrolador. Primeira coisa a se fazer é selecionar o Chip – PIC18F452
Porém, precisamos ainda configurar o ICPROG para o correto funcionamento com a placa CUSCOPIC. Para isso, clica-se em Configuração, opção Hardware e selecione o programador (TAIT SERIAL PROGRAMMER), Interface Direct I/O e em comunicação deve-se Inverter o MCLR.
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 ICPROG 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 passo a passo; “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 81 82 83 84 85 86 87 88 89 8A 8B 8C 8D 8E 8F C0 C1 C2 C3 C4 C5 C6 C7 C8 C9 CA CB CC CD CE CF
48
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 CCP – CCP1 e CCP2 (Capture/Compare/PWM) Os Comandos abaixo são para o Módulo CCP1: - pwm_init(X) Onde X é o valor da freqüência em Hz;
- pwm_change_duty(Y) Onde Y é valor tipo char entre 0 e 255 Valor 0 e 255 determina a porcentagem em que está operando o Módulo. Exemplo: para duty-cycle de 50% basta colocar valor de Y=127. - pwm_start( ) Inicia o Módulo; -pwm_stop( ) Finaliza o módulo PWM
54
Para o Módulo CCP2 temos os seguintes comandos: pwm2_init(X); pwm2_change_duty(Y); pwm2_start( ); pwm2_stop( ) ; Exemplos: Utilizando o osciloscópio, verifique os sinais das saídas PWM /********************************************************************** Uptex Tecnologia & Treinamento Ltda Curso de Microcontroladores PIC Linguagem C – Compilador MikroC Programa 11 Objetivo: verificar funcionamento do Módulo CCP1 *********************************************************************/ //programa que configura CCP1 em 1KHz e duty cycle de 50%. void main(){ pwm_init(1000); pwm_change_duty(127); pwm_start(); while(1); }
/********************************************************************** Uptex Tecnologia & Treinamento Ltda Curso de Microcontroladores PIC Linguagem C – Compilador MikroC Programa 12 Objetivo: verificar funcionamento do Módulo CCP2 *********************************************************************/ //programa que configura Módulo CCP2 em 3KHz e duty cicle 10% void main(){ pwm2_init(3000); pwm2_change_duty(25); pwm2_start(); while(1); } 55
/********************************************************************** Uptex Tecnologia & Treinamento Ltda Curso de Microcontroladores PIC Linguagem C – Compilador MikroC Programa 13 Objetivo: verificar funcionamento simultâneo dos Módulos CCP1 e CCP2 *********************************************************************/ void main() { pwm2_init(250); pwm2_change_duty(254); pwm2_start(); pwm1_init(250); pwm1_change_duty(10); pwm1_start(); while(1); }
Exercício : Modifique os valores dos duty-cycle e verifique com o osciloscópio o resultado.
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 CCP1 e CCP2 *********************************************************************/ unsigned short int var1=127; unsigned short int var2=30;
void seta() { pwm1_init(1000); pwm1_change_duty(var1); pwm1_start(); pwm2_init(1000); pwm2_change_duty(var2); pwm2_start(); } void main() { seta(); while(1) { if (button(&portd, 0,20,1)) { var1++ ; delay_ms(100); seta(); } if (button(&portd, 1,20,1)) { var1--; delay_ms(100); seta(); } if (button(&portd, 2,20,1)) { 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); // inicializa usart (8bits, baud rate 9600, no parity bit... i=0; while(1) { if (usart_data_ready()) { dados[i]=usart_read(); i++; if(dados[i-1]==0x0D) // verifica se chegou o comando ENTER { compara_dados(); for(i=0;i<=3;i++) dados[i]='\0'; i=0; } } } } 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
RBIF
GIE/GIEH: Bit chave geral das interrupções e também chave que habilita as interrupções para atuar em alta prioridade. 0 = nenhuma interrupção será tratada. 1 = liga chave geral para tratamento das interrupções.
77
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 acesso à EEPROM:
EEPROM_READ(adress): lê uma byte no endereço de memória. Exemplo: Leitura=eeprom_read(0); // faz a leitura do posição 0 da EEPROM e carrega na //variável leitura.
EEPROM_WRITE(adress,data): escreve um byte (data) no endereço (adress). Exemplo: Eeprom_write(0,25);
//escreve o valor 25 no endereço 0 da EEPROM.
Obs: É preciso ficar atento pois, cada posição de memória não pode ter mais que 8 bits (1 byte).
/********************************************************************** Uptex Tecnologia & Treinamento Ltda Curso de Microcontroladores PIC Linguagem C – Compilador MikroC Programa 29 Objetivo: Gravar e fazer leitura na EEPROM do PIC *********************************************************************/ char texto[15]; int leitura_canal, valor; unsigned int i; void main( ) { trisd=0b00001111; portd=0; trisc=0; portc=0; adcon1=0b00001110; //configura RA0 como entrada analógica demais I/O lcd_config(&portb, 1,0,2,7,6,5,4); lcd_cmd(lcd_cursor_off); lcd_cmd(lcd_clear); lcd_out(1,1,"Leitura AN1");
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 ultrapassar 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 CCP; - Interrupção no término de escrita na EEPROM; - Interrupção no Módulo LVP (detector de baixa tensão). Para configurar/habilitar/verificar estas interrupções, utilizamos os seguintes registradores: - RCON; - INTCON; - INTCON2; - INTCON3; - PIE1; - PIE2; - IPR1; - IPR2; - PIR1; - PIR2. Precisamos, portanto, entender bem o que cada bit dentro de cada registrador faz para podermos definir como irá trabalhar o microcontrolador no controle do projeto.
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
CCP1IE TMR2IE TMR1IE
PSPIE= Chave individual que habilita interrupção da Porta Paralela Escrava (R/W); 0 – desabilita. 1 – habilita. ADIE= Chave individual que habilita interrupção do Conversor A/D. 0 – desabilita. 1 – habilita. RCIE= Chave individual que habilita interrupção por recebimento de dados na USART. 0 – desabilita. 1 – habilita. TXIE= Chave individual que habilita interrupção por transmissão de dados na USART. 0 – desabilita. 1 – habilita. SSPIE= Chave individual que habilita interrupção do Módulo SSP (Máster Syncronous Serial Port). 0 – desabilita. 1 – habilita. CCP1IE= Chave individual que habilita interrupção de Captura/Compare no TIMER1. 0 – desabilita. 1 – habilita. TMR2IE= Chave individual que habilita interrupção por igualdade entre TMR2 e PR2. 0 – desabilita. 1 – habilita. TMR1IE= Chave individual que habilita interrupção de estouro do TIMER1. 0 – desabilita. 1 – habilita.
89
PIE2: ---------
---------
---------
EEIE
BCLIE
LVDIE
TMR3IE CCP2IE
EEIE= Chave individual que habilita interrupção de escrita na EEPROM/FLASH. 0 – desabilita. 1 – habilita. BCLIE= Chave individual que habilita interrupção de colisão de dados. 0 – desabilita. 1 – habilita. LVDIE= Chave individual que habilita interrupção do Módulo LVD (baixa tensão). 0 – desabilita. 1 – habilita. TMR3IE= Chave individual que habilita interrupção por estouro do TIMER3. 0 – desabilita. 1 – habilita. CCP2IE= Chave individual que habilita interrupção do Módulo CCP2. 0 – desabilita. 1 – habilita.
90
PIR1: PSPIF
ADIF
RCIF
TXIF
SSPIF
CCP1IF
TMR2IF TMR1IF
PSPIF= Flag de sinalização da interrupção da Porta Paralela Escrava (R/W); 0 – não ocorreu leitura ou escrita. 1 – ocorreu leitura ou escrita na porta paralela. ADIF= Flag de sinalização da interrupção do Conversor A/D. 0 – conversão não está completa. 1 – conversão finalizada. RCIF= Flag que sinaliza interrupção por recebimento de dados na USART. 0 – buffer está vazio. 1 – buffer tem dados recebidos. TXIF= Flag que sinaliza interrupção por transmissão de dados na USART. 0 – buffer tem dados para enviar. 1 – buffer está vazio. SSPIF= Flag de sinalização do Módulo SSP (Máster Syncronous Serial Port). 0 – aguardando transmissão/recepção. 1 – Transmissão/Recepção está completa. CCP1IF= Flag de sinalização da interrupção de Captura/Compare no TIMER1. Modo Captura 0 – não ocorreu interrupção por captura no TIMER1. 1 – ocorreu interrupção por captura no TIMER1. Modo Compara 0 – não ocorreu interrupção por comparação no TIMER1. 1 – ocorreu interrupção por comparação no TIMER1.
TMR2IF= Flag de sinalização da interrupção por igualdade entre TMR2 e PR2. 0 – não ocorreu interrupção por igualdade entre TMR2 e PR2. 1 – ocorreu interrupção por igualdade entre TMR2 e PR2. TMR1IF= Flag de sinalização de estouro do TIMER1. 0 – não ocorreu interrupção por estouro do TIMER1. 1 – ocorreu interrupção por estouro do TIMER1.
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. ‘ CCP2IF= Flag de sinalização do Módulo CCP2. Modo Captura 0 – não ocorreu interrupção por captura no TIMER1. 1 – ocorreu interrupção por captura no TIMER1. Modo Compara 0 – não ocorreu interrupção por comparação no TIMER1. 1 – ocorreu interrupção por comparação no TIMER1.
92
CCP2IF
IPR1: PSPIP
ADIP
RCIP
TXIP
SSPIP
CCP1IP
TMR2IP TMR1IP
PSPIP= Bit que define a prioridade na interrupção da Porta Paralela Escrava (R/W); 0 – baixa prioridade. 1 – alta prioridade. ADIP= Bit que define a prioridade na interrupção do Conversor A/D. 0 – baixa prioridade. 1 – alta prioridade. RCIP= Bit que define a prioridade na interrupção por recebimento de dados na USART. 0 – baixa prioridade. 1 – alta prioridade. TXIP= Bit que define a prioridade na interrupção por transmissão de dados na USART. 0 – baixa prioridade. 1 – alta prioridade. SSPIP= Bit que define a prioridade na interrupção do Módulo SSP (Master Syncronous Serial Port). 0 – baixa prioridade. 1 – alta prioridade. CCP1IP= Bit que define a prioridade na interrupção de Captura/Compare no TIMER1. 0 – baixa prioridade. 1 – alta prioridade. TMR2IP= Bit que define a prioridade na interrupção por igualdade entre TMR2 e PR2. 0 – baixa prioridade. 1 – alta prioridade. TMR1IP= Bit que define a prioridade na interrupção de estouro do TIMER1. 0 – baixa prioridade. 1 – alta prioridade.
93
IPR2: ---------
---------
---------
EEIP
BCLIP
LVDIP
TMR3IP
CCP2IP
EEIP= Bit que define a prioridade na interrupção de escrita na EEPROM/FLASH. 0 – baixa prioridade. 1 – alta prioridade. BCLIP= Bit que define a prioridade na interrupção de colisão de dados. 0 – baixa prioridade. 1 – alta prioridade. LVDIP= Bit que define a prioridade na interrupção do Módulo LVD (baixa tensão). 0 – baixa prioridade. 1 – alta prioridade. TMR3IP= Bit que define a prioridade na interrupção por estouro do TIMER3. 0 – baixa prioridade. 1 – alta prioridade. ‘ CCP2IP= Bit que define a prioridade na interrupção do Módulo CCP2. 0 – baixa prioridade. 1 – alta prioridade.
Estrutura de Programa utilizando Interrupções de Alta e Baixa Prioridade: Obs: Quando utilizar alta e baixa prioridade devemos desenvolver o programa conforme segue abaixo: void interrupt ( ) // vetor de interrupção – alta prioridade { Comandos; Comandos; // Obs: Não esquecer que é necessário limpar a Flag da interrupção. } Void interrupt_low ( ) { Comandos; Comandos; // Obs: Não esquecer que é necessário limpar a Flag da interrupção. } Void main ( ) { Comandos; Comandos; } 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
