Transcript
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________
Índice Linguagem C......................................................................................................
3
Programação de Microcontroladores em linguagem C......................................
3
Princípio de programação - Álgebra Booleana..........................................................................................
5
- Operações......................................................................................................
5
- Representação Gráfica das Portas Lógicas....................................................
5
Introdução à Linguagem C - Variáveis........................................................................................................
6
- Tipos de Dados..............................................................................................
6
- Qualificadores...............................................................................................
6
- Declaração de variáveis.................................................................................
7
- Operadores matemáticos - Aritméticos.................................................................................................
7
- Relacionais.................................................................................................
7
- Operadores Lógicos bit-a-bit......................................................................
8
- Operadores Lógicos relacionais.................................................................
8
- Declarações de controle - Decisão – Comando IF...............................................................................
9
- Decisão – Comando IF-ELSE....................................................................
9
- Decisão – SWITCH-CASE........................................................................
10
- Laço FOR......................................................................................................
11
- Laço WHILE.................................................................................................
11
- Laço DO-WHILE..........................................................................................
12
- Ponteiros........................................................................................................
12
- Matrizes.........................................................................................................
13
O Ambiente MikroC...........................................................................................
14
- Criando um novo projeto...............................................................................
15
- Primeiro Projeto............................................................................................
16
- Gravando o projeto........................................................................................
18
Acionamento de Botões......................................................................................
24
Estudo dos Timers e Interrupções - Timer 0.......................................................................................................... 1
26
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________ - Timer 1..........................................................................................................
30
- Timer 2..........................................................................................................
33
Funções...............................................................................................................
38
Debug no MikroC...............................................................................................
39
Display de Cristal Líquido (LCD)......................................................................
42
Conversão A/D...................................................................................................
46
Comunicação Serial (USART)...........................................................................
48
EEPRON Interna................................................................................................
53
PWM...................................................................................................................
55
2
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________
Linguagem C É uma linguagem de programação de propósito geral, estruturada, imperativa, procedural de alto e baixo nível, criada em 1972 por Dennis Ritchie no AT&T Bell Labs, para desenvolver o sistema operacional UNIX (que foi originalmente escrito em Assembly). Desde então, espalhou-se por muitos outros sistemas e tornou-se uma das linguagens de programação mais usadas influenciando muitas outras linguagens, especialmente o C++, que foi desenvolvida como uma extensão para C. Fonte: WIKIPEDIA
Programação de Microcontroladores em linguagem C Atualmente, a maioria dos microcontroladores existentes nos mercado contam com compiladores em C para o desenvolvimento de software, pois a linguagem C permite a construção de programas e aplicações muito mais complexas do que o Assembly. O compilador C tem a capacidade de “traduzir” com alto grau de inteligência e velocidade o código em C para o código de máquina, portanto podemos dizer que a linguagem C possui grande eficiência. Essa eficiência da linguagem C faz com que o programador preocupe-se mais com a programação em si e o compilador assume responsabilidades como localização da memória, operações matemáticas e lógicas, verificação de bancos de memórias e outros..
3
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________
Princípio de Programação Álgebra Booleana Na matemática e na ciência da computação, as álgebras booleanas são estruturas algébricas que “captam a essência” das operações lógicas E, OU e NÃO (NAD, OR e NOT), bem como das operações da teoria de conjuntos soma, produto e complemento. Álgebra Booleana deriva do nome de George Boole, matemático inglês que foi o primeiro a definí-las como parte de um sistema de código em meados do século XIX. Foram aplicadas pela primeira vez em eletrônica por Claude Shannon no século XX. Os operadores de álgebra booleana são frequentemente escritos com E, OU ou NÃO (mais comuns são os equivalentes em inglês, AND, OR ou NOT). Na descrição de circuitos podem ser utilizados NAND (NOT AND), NOR (NOT OR) e XOR (OR exclusivo). Operações: OR
AND
NOT
XOR
X
Y
S
X
Y
S
X
S
X
Y
S
0
0
0
0
0
0
0
1
0
0
1
0
1
1
0
1
0
1
0
0
1
0
1
0
1
1
0
0
1
0
0
1
1
1
1
1
1
1
1
1
Representação Gráfica das Portas Lógicas:
4
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________ CONT.:
5
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________
Introdução à Linguagem C Variáveis: As variáveis podem conter letras e números, sempre começando com letras e não devem ter nome de palavras reservadas pelo compilador como, por exemplo, for, do, int, etc. Tipos de Dados: Dado:
Representa:
-char
Caracteres
-int
Números inteiros
-float e double
Números decimais (ponto flutuante)
-void
Valores nulos
Qualificadores: Qualificador
Significado
-signed
Sinalizado
-unsigned
Não sinalizado
-short
Inteiro menor que o padrão
-long
Inteiro maior que o padrão
Tipo
Tamanho
Valores
signed char
8 bits
-128 à 127
(unsigned) char
8 bits
0 à 255
(signed) short (int)
8 bits
-128 à 127
unsigned short (int)
8 bits
0 à 255
(signed) int
16 bits
-32768 à 32767
unsigned int
16 bits
0 à 65535
(signed) long (int)
32 bits
-2147483648 à 2147483647
unsigned long (int)
32 bits
0 à 4294967295
float
32 bits
(+-) 1,17549435082e-38 à (+-) 6,80564774407e38
double
32 bits
(+-) 1,17549435082e-38 à (+-) 6,80564774407e38
long double
32 bits
(+-) 1,17549435082e-38 à (+-) 6,80564774407e38
* Palavras entre parenteses são opcionais. 6
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________ Declaração de Variáveis: Um variável é declarada da seguinte forma: + + + ; onde o valor pode ou não ser inicializado. Exemplos:
unsigned int x = 12345; int conta; short x1;
Para atribuir valores às variáveis: conta = 100; (atribui-se o valor 100 à variável conta) x1 = 15; (atribui-se o valor 15 à variável x1) Operadores Matemáticos: Aritméticos: Operador Descrição
Exemplo
+
Soma dos argumentos
a+b
-
Subtração dos argumentos
a-b
*
Multiplicação dos argumentos
a*b
/
Divisão dos argumentos
a/b
%
Resto da divisão (só pode ser utilizado com valores a % b inteiros)
++
Soma 1 ao argumento
a++
--
Subtrai 1 ao argumento
a--
7
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________ Relacionais: São utilizados para comparação entre argumentos e retornam uma resposta verdadeira ou falsa. Como em linguagem C não existe uma variável booleana para um resultado verdadeiro ou falso, todo valor igual a 0 será considerado falso e todo valor diferente de 0 (qualquer valor) será considerado verdadeiro. Operador Descrição
Exemplo
==
Compara se igual a
a == 5
!=
Compara se diferente de
a != 5
>
Compara se maior que
a>5
<
Compara se menor que
a<5
>=
Compara se maior ou igual a
a >= 5
<=
Compara se menor ou igual a
a <= 5
Operadores lógicos bit-a-bit: Operador Descrição &
E (AND)
|
OU (OR)
^
OU EXCLUSIVO (XOR)
~
Complemento (NOT)
>>
Deslocamento à direita
<<
Deslocamento à esquerda
Operadores lógicos relacionais: Operador Descrição &&
Comparação lógica E (AND)
||
Comparação lógica OU (OR)
!
Comparação lógica Complemento (NOT)
8
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________ Declarações de controle: Decisão – Comando IF: O comando IF é utilizado para avaliar uma determinada condição e determinar se ela é verdadeira, caso seja, executa os bloco contido dentro desta condição. Sua forma geral é: if (exp) comando; Se o resultado da condição referente a expressão (exp) for verdadeiro, o comando será executado, caso contrário, o programa segue sem executar o comando. if (exp) { comando1; comando2; } Para o caso acima, a mesma explicação anterior se encaixa, sendo que agora, se a condição da expressão for verdadeira, serão executados os comando1 e comando2. Exemplos: if (conta>50) conta = 0; if (conta>50) { conta = 0; conta1++; } Decisão – Comando IF-ELSE: Neste caso, a condição IF é utilizada da mesma forma acima, sendo que agora, se a condição da expressão for falsa a condição ELSE será executada. Sua forma é: if (exp) comando1; else comando2; Caso a expressão seja verdadeira, o comando1 será executado, caso seja falsa, o comando2 será executado. Exemplo: if (conta>0) { conta = 0; conta1++; } 9
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________ else conta++; É possível também encadear diversos comando IF, como a forma abaixo: if (exp1) comando1; else if (exp2)comando2; else if(exp3) comando3; .... Decisão SWITCH-CASE: Quando existem muitos valores para testar de uma só variável, o comando IF pode ficar meio confuso ou sem muita eficiência, para isso podemos utilizar o SWITCH-CASE. Segue sua forma: switch(variável) { case valor1: comando1; .... break; case valor2: comando2; .... break; .... .... default: comandoN; .... .... } Neste caso, a variável será testada e se o valor dela for igual a valor1, o comando1 será executado, se for igual ao valor2, o comando2 será executado e assim por diante, agora se o valor for diferente de qualquer caso (case), o comandoN será executado. Exemplo: switch(conta) { case 10 : conta1++; break; case 15: conta2++; break; case 20: conta1++; conta2++ break; default: conta3++; } Neste caso, se o valor de conta for igual a 10, conta1 será incrementado, se o valor for igual a 15, o valor de conta2 será incrementado, caso o valor de conta seja igual a 20, tanto conta1 quanto conta2 10
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________ serão incrementados, para todos outros valores diferentes, o valor de conta3 será incrementado. Laço FOR: Este é um dos comandos de laço (loop ou repetição) disponíveis na linguagem C, a sua forma é: for(inicialização;condição(término);incremento) comando: ou, for(inicialização;condição(término);incremento) { comando1; comando2; } onde: inicialização: essa seção conterá uma inicialização para a variável; condição: responsável por contar a condição de finalização do laço; incremento: aqui pode conter uma ou mais variáveis para incremento da variável. Exemplo: int conta; int a = 0; for (conta=0;conta<=10;conta++) a = a + conta; Laço WHILE: Neste laço, os comandos serão repetidos enquanto a expressão for verdadeira, sua forma é: while (exp) { comando; } Exemplo: int x; while(x<=10) x++;
11
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________ Laço DO-WHILE: Este laço é uma variação do comando WHILE, sendo que neste caso o comando será executado antes de testa se a condição é verdadeira. Sua forma é: do { comando; } while(exp); O comando será executado pelo menos uma vez antes de verificar a condição da expressão. Exemplo: int x; int y; do { x++; } while(y!=1); Ponteiros: Podemos dizer que um ponteiro é uma variável onde será armazenado o endereço de outra variável, ou seja, o ponteiro é um apontador para uma outra variável. A sintaxe para a declaração de uma variável ponteiro é: TIPO *NOME onde TIPO é um tipo de dados válido e NOME é o nome da variável. Exemplo: int *idade;
12
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________ Exibindo uma string usando um ponteiro: Uma string é uma matriz de caracteres. Podemos usar um ponteiro para exibí-la assim: unsigned char *txt = "Exibindo uma string usando um ponteiro."; do { Usart_Write(*txt); //envia um caracter pela serial *txt++; //incrementa o ponteiro delay_ms(100); } while (*txt != '\0'); } Obs.: Ver exemplo serial3, página 48. Matrizes: Uma matriz é uma estrutura de dados que pode armazenar vários valores do mesmo tipo. A sintaxe para declarar uma matriz é: TIPO NOME[QUANTIDADE]; onde TIPO é o tipo dos dados que serão armazenados na matriz. Todos os dados colocados na matriz devem ser deste tipo. NOME é o nome a ser dado a matriz. Este nome identificará a matriz no código do programa. E QUANTIDADE é a quantidade máxima de itens a ser armazenados. Exemplos: int nr_de_livros[50]; //esta matriz pode armazenar até 50 valores do tipo int. float nota[30]; //esta matriz pode armazenar até 30 valores do tipo float. Os valores armazenados na matriz são chamados de "elementos da matriz". O primeiro elemento da matriz é indexado como item zero e o último é indexado como QUANTIDADE menos 1. Assim, para nossa matriz nota, mostrada no exemplo acima, o primeiro elemento é nota[0] e o último elemento é nota[29]. Você pode inicializar os elementos de uma matriz na sua declaração usando a sintaxe: int notas[5] = {60,70,35,50,68};
Obs.: Ver exemplo na página 49.
13
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________
O Ambiente MikroC O compilador MikroC foi desenvolvido pela Mikroelektronika e é com ele que vamos desenvolver nossos projetos. Abaixo está a tela inicial do compilador.
14
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________ Criando um novo projeto: O mikroC organiza as aplicações dentro de projetos, onde nele é possível ter vários arquivos fonte. A compilação do arquivo fonte somente poderá ser realizada se fizer parte de um projeto. Para criar um projeto basta clicar menu “Project” e em seguida escolha a opção “New Project”. A seguinte tela será apresentada:
-Em Project Name, deve-se informar o nome do projeto; -Em Project Path, deverá conter o caminho da pasta onde o projeto será salvo; -Description é opcional e pode-se relatar algo sobre o projeto; -Em Device, deve-se escolher o dispositivo a ser utilizado no projeto; -Em Clock, informa-se a freqüência do cristal que será utilizado na montagem do circuito; -Em Device Flags, as informação são em relação à configuração dos fusíveis.
15
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________
Primeiro Projeto Definindo o projeto: -Project Name : PiscaLed -Project Path : \MikroC\Proj1\ -Description : .... -Device : P16F877A -Clock : 004.000000 -Device Flags: Default Circuito:
Estrutura básica de um programa em C utilizando o compilador mikroC: void main() { //Este é o bloco principal do programa e é o único que a linguagem C precisa para funcionar. } obs.: Tudo que vem precedido de // é chamado comentário e não é interpretado pelo compilador. Também pode-se fazer comentário assim: /* Isto é um comentário */
16
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________ Código do Projeto: void main() { PORTD = 0; TRISD = 0, while(1)
//Configura os pinos da porta D como saída //Começo do loop (infinito)
{ PORTD = ~PORTD; delay_ms(1000); }
//Troca situação dos pinos na porta D //Tempo de atraso de 1 segundo
} Depois de escrevermos o código, devemos compilar o projeto para que possamos gravar no microcontrolador. A compilação se dá pressionando-se “ctrl + F9” ou clicando no menu Project e escolher a opção Build, conforme abaixo.
17
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________ Estando o projeto sem erros, as informações abaixo devem ser mostradas na parte de baixo do programa.
Gravando o Projeto Utilizaremos, para gravar o programa no microcontrolador, o programa ICPROG como segue a figura abaixo:
18
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________ Antes de gravarmos o programa, precisamos configurar o ICPROG para o correto funcionamento com a placa CUSCOPIC. Para isso, clica-se em Configuração e escolhe-se a opção 'Hardware' ou, diretamente, pressiona-se a tecla F3.
A tela de 'Configurações de Hardware' aparecerá. Então, escolhe-se, em 'Programador:' a opção 'TAIT Serial Programmer', conforme acima e deve-se também em 'Comunicação' habilitar a opção 'Iverter MCLR'. Clica-se em 'OK' e o programa ICPROG estará pronto. Abrindo o programa: Vamos, então, escolher o dispositivo a ser gravado na janela destacada em vermelho, conforme abaixo:
19
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________ Agora abriremos o programa referente ao nosso projeto. Clica-se em 'Arquivo' e escolhe-se a opção 'Abrir':
Na janela que se abre a seguir, deveremos encontrar o arquivo do nosso projeto, que neste caso é o arquivo 'PiscaLed.hex'. O programa ICPROG terá a aparência parecida com a figura abaixo:
20
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________ Identificação dos botões:
-Ler Tudo: Usado para a 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, pressionaremos, então o botão 'Limpar Tudo', para certificarmos que o microcontrolador estará pronto para o nosso programa e logo após, pressiona-se 'Programar Tudo'.
Na janela que é mostrada, confirmamos a pergunta clicando em 'Sim'.
21
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________ Após a gravação, se tudo estiver correto, a seguinte mensagem aparecerá:
Pronto, nosso programa já está no microcontrolador. Projetos de fixação: -Este projeto faz piscar o led conectado ao pino 0 da porta D void main() { TRISD.F0 = 0; while (1) { PORTD.F0 = 0; delay_ms(500); PORTD.F0 = 1; delay_ms(500); } }
//Configura o pino 0 da porta D com saída
//Faz com que o pino 0 da Porta D tenha nível lógico 0 //Tempo de atraso de 500ms //Faz com que o pino 1 da porta D tenha nível lógico 1 //Tempo de atraso de 500ms
-O projeto abaixo tem a mesma função, só que utiliza a diretiva #define para identificação, conforme abaixo: #define DirLed TRISD.F0 //Identifica a variável TRISD.F0 como DirLed #define Led PORTD.F0 //Identifica a variável PORTD.F0 como Led void main() { DirLed = 0; while (1) { Led = 0; delay_ms(500); Led = 1; delay_ms(500); } }
//Configura o pino 0 da porta D com saída
//Faz com que o pino 0 da Porta D tenha nível lógico 0 //Tempo de atraso de 500ms //Faz com que o pino 1 da porta D tenha nível lógico 1 //Tempo de atraso de 500ms
22
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________ obs.: Os registradores especiais, TRISD, PORTD, PORTA, TRISA, INTCON, TMR0 e outros são tratados, pelo compilador, como variáveis, portanto, podemos atribuir valor e tratá-los exatamente como uma variável qualquer. Exercício proposto: -Fazer um programa onde todos os LEDS serão acesos em seqüência, exemplo: acende LED1, atraso de 300ms, acende LED2, outro atraso de 300ms e assim por diante até o LED8, em seguida fazer com que todos apaguem também começando do LED1 e terminando no LED8.
23
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________
Acionamento de Botões Definindo o projeto: -Project Name : Botao -Project Path : \MikroC\Proj2\ -Description : .... -Device : P16F877A -Clock : 004.000000 -Device Flags: Default Circuito:
24
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________ Código do Projeto: #define botao PORTD.F0 #define led PORTD.F1 void main() { TRISD = 0x01; //Configura o pino 0 da porta D como entrada e o restante como saída PORTD = 0x00; //Zera toda a porta D while(1) //Loop principal { if (botao == 1) //Compara o valor do pino 0 ao valor 1 (nível lógico alto) led = 1; //Sendo o valor igual a 1, então acende o led conectado ao //pino 1 da porta D. } } Projeto de fixação: #define botao PORTD.F0 #define led PORTD.F1 void main() { TRISD = 0x01; PORTD = 0x00;
//Configura o pino 0 da porta D como entrada e o restante como saída //Zera toda a porta D
while(1) //Loop principal { if (botao == 1) //Compara o valor do pino 0 ao valor 1 (nível lógico alto) { //Sendo o valor igual a 1, executa os comandos do bloco led = 1; //Coloca em 1 o pino 1 da porta D, acendendo o LED delay_ms(1000); //Atraso de 1 segundo led = 0; //Coloca em 0 o pino 1 da porta D, apagando o LED } } }
25
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________
Estudo dos Timers e interrupções TIMER 0 O Timer 0 é um contador interno e pode contar estímulos externos ou contar internamente, utilizando o oscilador. Ele possui um prescaler de até 1:256 e tem 8 bits, ou seja, para um prescaler de 1:1, haverá um overflow (estouro) a cada 256 contagens (0 à 255) . Para o controle do Timer 0, vamos utilizar os registros especiais OPTION_REG e INTCON, como segue: OPTION_REG Nome /RBPU INTEDG Bit
7
TOCS
TOSE
PSA
PS2
PS1
PS0
5
4
3
2
1
0
6
TOCS = 1: Incremento a cada transição no pino RA4/T0CKI. TOCS = 0: Incremento a cada ciclo de máquina. TOSE = 1: Incremento na borda de descida. TOSE = 0: Incremento na borda de subida. PSA = 1: Prescale aplicado ao WDT. PSA = 0: Prescale aplicado ao TMR0. PS2
PS1
PS0
TMRO
WDT
0
0
0
1:2
1:1
0
0
1
1:4
1:2
0
1
0
1:8
1:4
0
1
1
1:16
1:8
1
0
0
1:32
1:16
1
0
1
1:64
1:32
1
1
0
1:128
1:64
1
1
1
1:256
1:128
Para utilizarmos a interrupção do TMR0, devemos setar o registro INTCON.T0IE e também o registro INTCON.GIE (interrupção geral). Deste modo, toda vez que houver um estouro do TMR0, o flag INTCON.T0IF será setado, devendo ser limpo quando do tratamento da interrupção INTCON Nome Bit
GIE
PEIE
TOIE
INTE
RBIE
T0IF
INTF
RBIF
7
6
5
4
3
2
1
0
26
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________ Contando um tempo com o Timer 0: Vamos supor que queremos contar um tempo com o timer 0 de 100us e o prescaler seja de 1:1. Neste caso, só temos a opção 1:1 quando aplicamos o prescaler ao WDT, então tanto o timer0 como o WDT estarão com prescaler de 1:1. Quando fazemos o prescaler igual a 1:1, estamos fazendo com que o TMR0 incremente seu valor em 1 a cada ciclo de máquina, ou seja, para um cristal de 4MHz, o incremento se dará a cada 1us. Então para um tempo de 100us, queremos que o TMR0 seja incrementado 100 vezes. O estouro do Timer0 ocorre quando o TMR0 chega à contagem 256, portanto, no nosso caso, haverá um estouro a cada 256us, mas o que queremos é 100us. Basta, então inicializarmos o TMR0 com o valor de 256 – 100 = 156. Inserindo no código os valores de contagem: No MikroC, toda vez que ocorre uma interrupção, o programa entra na função 'interrupt' e nela serão tratadas as interrupções ocorridas. void interrupt() { { TMR0 = 156; INTCON = 0x20; }
// Valor inicial para o Timer0 // Seta T0IE e limpa T0IF
void main() { OPTION_REG = 0x80; TMR0 = 156; INTCON = 0xA0;
// Atribui prescaler de 1:1 ao to TMR0 // Valor inicial para o Timer0 // Habilita a interrupção do TMR0, seta os registros GIE e T0IE
while(1) {} } Projeto: Façamos um LED piscar a cada 1 segundo utilizando o Timer0. Resolução: Então: 1 segundo = 1000000us ou 1 segundo = 10000 x 100us.
27
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________ unsigned int cnt;
//contador para acerto do tempo (ver 'unsigned int' na pág. 4)
void interrupt() { cnt++; TMR0 = 156; INTCON = 0x20; }
// Incrementa o valor de cnt a cada interrupção // Valor inicial para o Timer0 // Seta T0IE e limpa T0IF
void main() { OPTION_REG = 0x80; TMR0 = 156; INTCON = 0xA0;
// Atribui prescaler de 1:1 ao to TMR0 // Valor inicial para o Timer0 // Habilita a interrupção do TMR0, seta os registros GIE e T0IE
TRISD.F0 = 0; PORTD.F0 = 0;
// Faz pino 0 da porta D como saída // Limpa o pino 0 da porta D, LED apagado
cnt = 0; while(1) { if (cnt >= 10000) // Executa o bloco abaixo SE a variável cnt for maior ou igual a 10000 { PORTD.F0 = ~PORTD.F0; //Inverte a situação do pino 0 da porta D. cnt = 0; //Zera cnt para um novo ciclo. } } } Ajustando alguns valores: Seguindo o exemplo acima, vamos ajustar os valores para um prescaler de 1:32, então ficaria assim: Valor Inicial para o TMR0 = 256 – 157 = 99. Calculando 157 x 32 = 5024 x 200 = 1004800 us <=> 1,005s unsigned cnt; void interrupt() { cnt++; TMR0 = 99; INTCON = 0x20; }//~
// Incrementa o valor de cnt a cada interrupção // Valor Inicial para o TMR0 // Seta T0IE e limpa T0IF
void main() { OPTION_REG = 0x84; TMR0 = 99; INTCON = 0xA0;
// Atribui prescaler de 1:32 ao TMR0 // Valor Inicial para o TMR0 // Habilita a interrupção do TMRO 28
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________ TRISD.F0 = 0; PORTD.F0 = 0; cnt = 0;
// Inicializa cnt
do { if (cnt == 200) { PORTD.F0 = ~PORTD.F0; cnt = 0; } } while(1); }
29
// Inverte os valores do pino 0 da porta D // Inicializa cnt novamente
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________
TIMER 1 O Timer 1 tem suas características muito parecidas com as do Timer 0, sendo que ele também pode operar como contador ou temporizador, mas agora, com 16 bits. Desta forma, podemos concluir que um ciclo de contagem do Timer 1 se incia em 0 e termina em 65535 (equivalente aos 16 bits do contador com prescaler de 1:1). Registradores associados: Nome
Bit 7
Bit 6
Bit 5
Bit 4
Bit 3
Bit 2
Bit 1
Bit 0
INTCON
GIE
PEIE
TOIE
INTE
RBIE
T0IF
INTF
RBIF
PIR1
PSPIF
ADIF
RCIF
RXIF
SSPIF
CCP1IF TMR2IF TMR1IF
PIE1
PSPIE
ADIE
RCIE
RXIE
SSPIE
CCP1IE TMR2IE TMR1IE
TMR1L
Contador 8 bits – Parte menos significativa
TMR1H
Contador 8 bits – Parte mais significativa
T1CON
-
-
T1CKPS1 T1CKPS2 T1OSCEN /T1SYNC TM1CS TMR1ON
Registrador T1CON T1CKPS0 e T1CKPS1, são utilizados para selecionar 1 dos 4 fatores de prescaler. T1CKPS1 T1CKPS0 Prescaler 0
0
1:1
0
1
1:2
1
0
1:4
1
1
1:8
T1OSCEN 1 - Habilita oscilador externo. O pino RC0 e RC1 são configurados como entrada e não poderão ser utilizados como I/O. 0 - Desabilita oscilador externo. RC0 opera como entrada para sinal externo para contagem (T1CKI), RC1 opera como I/O. /T1SYNC 1 - Sincronismo desligado. 0 - Sincronismo ligado.
30
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________ TMR1CS 1 - Clock externo via RC0/T1CKI. 0 - Clock interno através dos ciclos de máquina. Registrador PIR1 Neste registrador são sinalizados os flgs das interrupções e estouro dos Timer1 e Timer2. Registrador PIE1 Registrador onde são habilitadas as interrupções. Calculando o tempo total de estouro do Timer 1: Na placa em questão, o microcontrolador está trabalhando com um cristal externo de 4MHz, então o tempo total do timer 1, utilizando o maior prescaler 1:8 e clock interno pelo ciclo de máquina, será: –
(65536 – valor do contador) x (1/(FOSC/4)) x prescaler
No caso, o valor do contador será 0 (queremos o tempo total), então: Tempo = (65636 – 0) x 1us x 8 Tempo = 524,28ms Tempo máximo com prescaler 1:1: Tempo = (65636 – 0) x 1us x 1 Tempo = 65,535ms Projeto: Configurar o timer 1 para fornecer um tempo de 100ms e com isso fazer todos os LED's da porta D piscarem a cada 1s. Resolução: Como com o prescaler 1:1, conseguiremos no máximo 65,535ms, então teremos que utilizar um prescaler de 1:2, então teremos: Tempo = (65536 – TMR1) x (1/(FOSC/4) x prescaler 100ms = (65536 – TMR1) x 1us x 2
31
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________
TMR1 = 15536 = 0x3CB0 Código do projeto: unsigned short cnt; void interrupt() { cnt++ ; PIR1.TMR1IF = 0; TMR1H = 0x3C; TMR1L = 0xB0; } void main() { PORTD = 0x00; TRISD = 0; T1CON = 0x11; PIR1.TMR1IF = 0; TMR1H = 0x3C; TMR1L = 0xB0; PIE1.TMR1IE = 1; cnt = 0; INTCON = 0xC0; do { if (cnt == 10) { PORTD = ~PORTD; cnt = 0; } } while (1);
// Limpa o flag TMR1IF // Inicializa registro do Timer 1
// Inicializa PORTD // PORTD é saída // Ajuste do Timer1 // Limpa o flag TMR1IF // Inicializa o registro do Timer1 // Habilita a interrupção do Timer1 // inicializa cnt // habilita GIE, PEIE // se cnt é 10 (10 x 100ms = 1000ms) // Troca posição da porta D // zera cnt
}
32
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________
Timer 2 O timer 2 também é um contador de 8 bits, sendo relacionado somente ao clock interno, a diferença deste timer é que ele não conta de 0 à 255(8 bits). Quem impõe o limite de contagem é o valor do registrador PR2. Então sempre que o registrador TMR2 tiver o mesmo valor que PR2, o timer é resetado, voltando a zero. Quando isto ocorre, um outro contador que chamamos de postcaler é incrementado e quando houver o término do da contagem do postcaler, uma interrupção será gerada. Registradores associados: Nome
Bit 7
Bit 6
Bit 5
Bit 4
Bit 3
Bit 2
Bit 1
Bit 0
INTCON
GIE
PEIE
TOIE
INTE
RBIE
T0IF
INTF
RBIF
PIR1
PSPIF
ADIF
RCIF
RXIF
SSPIF
CCP1IF
TMR2IF
TMR1IF
PIE1
PSPIE
ADIE
RCIE
RXIE
SSPIE
CCP1IE
TMR2IE
TMR1IE
TMR2 T2CON
Contador 8 bits -
TOUTPS3 TOUTPS2 TOUTPS1 TOUTPS0
PR2
TMR2ON T2CKPS1 T2CKPS0
Limite de contagem para o timer 2
Registrador T2CON: Seleção do postcaler do timer 2 TOUTPS3 TOUTPS2 TOUTPS1 TOUTPS0 POTSCALER 0
0
0
0
1:1
0
0
0
1
1:2
0
0
1
0
1:3
0
0
1
1
1:4
0
1
0
0
1:5
0
1
0
1
1:6
0
1
1
0
1:7
0
1
1
1
1:8
1
0
0
0
1:9
1
0
0
1
1:10
1
0
1
0
1:11
1
0
1
1
1:12
1
1
0
0
1:13
1
1
0
1
1:14
1
1
1
0
1:15
1
1
1
1
1:16 33
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________ TMR2ON 1 - Timer 2 desativado. 0 - Timer 2 ativado. Seleção do prescaler: T2CKPS1 T2CKPS0 PRESCALER 0
0
1:1
0
1
1:4
1
0
1:16
1
1
1:16
Obs.: As duas últimas opções são realmente iguais. Calculando o tempo total de estouro do Timer 2: Tempo = prescaler x postcaler x PR2 x (1/(FOSC/4)) Tempo = 16 x 16 x 255 x 1us Tempo = 65,28ms Projeto 1: Configurar o timer para piscar os leds da porta D a cada 1 segundo. Resolução: Neste caso, podemos utilizar os valores acima sendo que teremos um estouro do timer a cada 65,28ms. Assim, para que possamos fazer uma contagem de 1 segundo, deveremos multiplicar o valor por 15 que resultará em 979,2 ms, aproximadamente 0,97 s. Código do projeto: unsigned short cnt; void interrupt() { if (PIR1.TMR2IF) { cnt++ ; PIR1.TMR2IF = 0; TMR2 = 0; } }
// incrementa cnt // limpa flag TMR2IF
34
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________ void main() { cnt = 0; PORTD = 0xFF; TRISD = 0; T2CON = 0xFF; TMR2 = 0; PR2 = 0xFF; PIE1.TMR2IE = 1; INTCON = 0xC0;
// inicializa cnt // Inicializa PORTD // PORTD é saída // Ajustes do Timer2 // Inicializa registro do Timer2 // Inicializa PR2 com o valor 255 (não é necessário // para este caso, pois ele já tem com default esse // valor). // habilita interrupção // habilita GIE, PEIE
while (1) { if (cnt == 15) { PORTD = ~PORTD; cnt = 0; } }
// loop infinito // se cnt = 15 // troca posição na PORTD // zera cnt
} Projeto 2: Configurar o timer2 para uma interrupção a cada 50ms e fazer piscar os Leds da porta D a cada 1 segundo. Resolução: O valor máximo de estouro para o timer2 é de 65,28ms utilizando prescaler e postcaler 1:16, então para 50ms temos:
PR2 = 195,31 <=> 195
35
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________ Código do projeto: unsigned short cnt; void interrupt() { if (PIR1.TMR2IF) { cnt++ ; PIR1.TMR2IF = 0; TMR2 = 0; PR2 = 195; } } void main() { cnt = 0; PORTD = 0xFF; TRISD = 0; T2CON = 0xFF; TMR2 = 0; PR2 = 195; PIE1.TMR2IE = 1; INTCON = 0xC0; while (1) { if (cnt == 20) { PORTD = ~PORTD; cnt = 0; } }
// incrementa cnt // limpa flag TMR2IF
// inicializa cnt // Inicializa PORTD // PORTD é saída // Ajustes do Timer2 // Inicializa registro do Timer2 // Inicializa PR2. // habilita interrupção // habilita GIE, PEIE // loop infinito // se cnt = 15 // troca posição na PORTD // zera cnt
} O importante é que o valor do PR2 – TMR2 seja de 195, então podemos fazer: Código: unsigned short cnt; void interrupt() { if (PIR1.TMR2IF) { cnt++ ; PIR1.TMR2IF = 0; TMR2 = 55; PR2 = 200; } }
// incrementa cnt // limpa flag TMR2IF
36
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________ void main() { cnt = 0; PORTD = 0xFF; TRISD = 0; T2CON = 0xFF; TMR2 = 55; PR2 = 200; PIE1.TMR2IE = 1; INTCON = 0xC0; while (1) { if (cnt == 20) { PORTD = ~PORTD; cnt = 0; } }
// inicializa cnt // Inicializa PORTD // PORTD é saída // Ajustes do Timer2 // Inicializa registro do Timer2 // Inicializa PR2. // habilita interrupção // habilita GIE, PEIE // loop infinito // se cnt = 15 // troca posição na PORTD // zera cnt
}
37
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________
Funções A linguagem C nos permite “montar” blocos de comandos para que possamos executá-los sem a necessidade de repeti-los no bloco principal. Esses blocos são chamados Funções e são parecidos com as chamadas de sub-rotinas em assembly. Nos exemplos anteriores, usamos uma função para chamar e tratarmos as interrupções, só que esta função é chamada pelo próprio compilador diratemente. Como declarar a função Tipo + Nome da Função (parâmetro) Bloco de Execução Ex: int.adição (int a, int b) Return a e b Chamando a função: Int adicao (int a, int b) { return a + b; } Void main ( ) { Int c; TRISD = 0x00; PORTD = 0x00; c = adicao (2, 3) ; While (1 ) { PORTD = c; } }
38
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________ Debug no MikroC Clicando no menu “Run” e escolhendo-se a opção “Start Debugger”, a janela abaixo será mostrada
Em “Select variable from List”, seleciona-se Portd e clica-se em “Add”,
39
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________
Repete-se a operação para as variáveis “a”, “b” e “c” Para iniciar a simulação (Debugger) deve-se clicar no botão conforme a figura abaixo ou pode-se iniciar a simulação simplesmente pressionando-se a tecla “F9”
40
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________ A tecla “F7” faz a simulação passo a passo e “F6” inicia o modo “Run”
-Run/Pause Debugger (F6) -Stop Debugger (Ctrl = F12) -Step over (F8) -Step Out (Ctrl + F8) -Run to cursor (F4) -Step Into (F7)
41
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________
Display de Cristal Líquido (LCD) Pinagem do LCD Pino
Descrição 1
Gnd
2
+5V
3
Ajuste de contraste
4
Seleção RS: 1 - dado, 0 - escrita
5
Seleção R/W, 1 – leitura, 0 - escrita
6
Em – habilita p/ dado ou escrita em 1 ou transição 1 -> 0, 0 - desabita
7 8 9 Barramento de Dados
10 11 12 13 14
Endereços dos caracteres p/um LCD de 2 linhas e 16 colunas 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
42
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________ Biblioteca LCD no MikroC para o modo de 4 bits. LCD_Custon_Config: Inicializa e configura especificação. Sintaxe:
LCD_Custon_Config, (char=data.port, char db3, char db2, char db2, char db1, char d30, char+ctel-port, char res, char rw, char em); Onde: data port => porta ondeos dados db0,db1, db2 e db3serão conectados Ctel-port => porta onde os controles r5, w e em do LCD serão conectados Exemplo: LCD_Custom_Config(&Portd, 3,2,1,0, $Portb, R, 3, 4);
LCD_Custon_Out: Sintaxe:
a linguagem do microcontrolador conforme
Escreve um texto no LCD na linha e coluna específica
LCD_Custon_Out (char row, char cal, char text) Onde: row = linha Col = coluna Exemplo: LCD_Custom_Out (1, 3,”Hello”),
LCD_Custon_Out_CP: Escreve um texto no LCD na posição corrente do cursor Sintaxe:
LCD_Custon_Out_CP (char text) Exemplo: LCD_Custon_Out_CP (“Aqui”),
LCD_Custon_Chr: Escreve um caracter numa linha e numa coluna específica no LCD Sintaxe:
LCD_Custon_Chr (char row, char cal, char character) Exemplo: LCD_Custon_Chr (2, 3,”r”),
LCD_Custon_Chr_CP: Escreve um caracter na posição corrente do cursor Sintaxe:
LCD_Custon_Chr_CP (char character) Exemplo: LCD_Custon_Chr_CP (“c”),
LCD_ Custon_CMD: Envia um comando p/o LCD Sintaxe:
LCD_Custon_CMD (char out_char), Onde: out_char = comando conforme tabela de comandos disponíveis: Exemplo: LCD_Custon_CMD (LCD-Clear),
43
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________ Comandos Disponíveis Comando
Propósito
LCD_First_Row
Move o cursor p/1a.linha
LCD_Second_Row
Move o cursor p/2a.linha
LCD_Third_Row
Move o cursor p/3a.linha
LCD_Fourth_Row
Move o cursor p/4a.linha
LCD_Clear
Limpa o display
LCD_Return_Home
Move cursor para a primeira coluna da primeira linha
LCD_Cursor_Off
Desliga o cursor
LCD_Underline_On
Liga o “Underline “ no cursor
LCD_Blink_Cursor_On
Liga o modo piscante do cursor
LCD_Move_Cursor_Left
Move o cursor p/a esquerda sem mover o texto
LCD_Blink_Cursor_Right
Move o cursor p/a direita sem mover o texto
LCD_Turn_On
Liga o visor do LCD
LCD_Turn_Off
Desliga o visor do LCD sem perder os dados
LCD_Shift_Left
Move o texto p/a esquerda
LCD_Shift_Right
Move o texto p/a direita
44
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________ Projeto LCD Escrever o texto “LCD Display Test” na primeira linha do display de LCD Resolução - Código do Projeto: char *text = "LCD Display Test"; void main() { unsigned i; TRISB = 0; // PORTB is output Lcd_Custom_Config(&PORTB,7,6,5,4,&PORTB,1,2,0); // Initialize LCD on PORTB Lcd_Custom_Cmd(Lcd_CURSOR_OFF); // Turn off cursor Lcd_Custom_Out(1, 1, text);
// Print text at LCD
while(1) { Lcd_Custom_Cmd(LCD_RETURN_HOME); Lcd_Custom_Cmd(LCD_UNDERLINE_ON); for(i=0;i<=15;i++) { Lcd_Custom_Cmd(LCD_MOVE_CURSOR_RIGHT); Delay_ms(100); } for(i=0;i<=15;i++) { Lcd_Custom_Cmd(LCD_MOVE_CURSOR_LEFT); Delay_ms(100); } Lcd_Custom_Cmd(LCD_TURN_OFF); Delay_ms(500); Lcd_Custom_Cmd(LCD_TURN_ON); } }
45
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________
Conversão A/D - Biblioteca ADC no MikroC No MikroC utiliza-se a função abaixo para leitura do conversor AD do PIC ADC_Read(channel): Faz a leitura da conversão AD no canal especificado Sintaxe: ADC_Read (unsigned short channel) Onde channel = canal do provedor AD que desejamos ler Exemplo: Int ad ad= ADC_Ready (0), //lê o canal Ado do PIC e armazena o //valor na variavel ad. Esta função retorna um valor sem sinal de 10 bits, ou seja, de 0 à 1023. Projeto ADC: Fazer uma leitura do canal do PICe mostrar os 8 bits menos siginificativos nos LCD’s conectados à porta D. Resolução: Primeiramente é necessário configurar o registrador ADCON1. Nele podemos definir o modo de trabalho dos pinos de A/D, conforme a tabela ADCON1 à seguir: ADCON1 PCFG <3 0> 0000 0001 0010 0011 0100 0101 0111 1000 1001 1010 1011 1100 1101 1110 1111
AN7
AN6
AN5
AN4
AN3
AN2
AN1
AN0
VREF+
A A D A D D D A D D D D D D D
A A D A D D D A D D D D D D D
A A D A D D D A A A A D D D D
A A A A D D D A A A A A D A A
A VREF+ A VREF+ A VREF+ D VREF+ A VREF+ VREF+ VREF+ VREF+ D VREF+
A A A A D D D VREFA A VREFVREFVREFD VREF-
A A A A A A D A A A A A A D D
A A A A A A D A A A A A A A A
VDD AN3 VDD AN3 VDD AN3 AN3 VDD AN3 AN3 AN3 AN3 VDD AN3
46
VREF VSS VSS VSS VSS VSS VSS AN2 VSS VSS AN2 AN2 AN2 VSS AN2
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________ Queremos, então, utilizar a conversão no canal 0 (RA0), então atribuímos o ADCON1 com o valor 1110 ou 14 ou ainda OxOE. Código: unsigned int ad; void main() { ADCON1 = 0x0E; // Configure analog inputs and Vref TRISA = 0xFF; // PORTA is input TRISD = 0x00; // Pins RB7, RB6 are outputs do { ad = Adc_Read(0); // Get results of AD conversion PORTD = ad; // Send lower 8 bits to PORTD } while(1); } Projeto ADC 2: Mostrar o valor da conversão no LCD Código: unsigned int ad; char txt[7]; void main() { ADCON1 = 0x0E; // Configure analog inputs and Vref TRISA = 0xFF; // PORTA is input Lcd_Custom_Config(&PORTB,7,6,5,4,&PORTB,1,2,0); // Initialize LCD on PORTB Lcd_Custom_Cmd(Lcd_CURSOR_OFF); // Turn off cursor do { ad = Adc_Read(0); // Get results of AD conversion IntToStr(ad,txt); Lcd_Custom_Out(1, 1, "AD = "); Lcd_Custom_Out(1, 5, txt);
// Print text at LCD
} while(1); }
47
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________
Comunicação Serial (USART) USART= Universal Synchronous Asynchronous Receiver Transmitter Biblioteca USART no MIKROC Usart_init: Inicializa o modo de comunicação serial informando o Band-Rate (Taxa de Comunicação) utilizado para a comunicação Sintaxe: Usart_init (BaudRate) Exemplo: Usart_init (9600), inicializa a serial com taxa de 9600 bps. Usart_Data_Ready: Verifica se existe algum byte no buffer de recepção serial, retornando 1 se existir e 0 se não existir nenhum byte. Sintaxe: var = Usart_Data_Ready( ), onde var = variável. Exemplo: if (Usart_Data_Ready()) //se existir algum byte no buffer, executa a expressão abaixo: { .....expressão...... } Usart_Read: Lê o valor armazenado no buffer de recepção serial. Sintaxe: recepção = Usart_read( ); Exemplo: if (Usart_Data_Ready()) //se existir algum byte no buffer, executa a expressão abaixo: { receive = Usart_Read(); //armazena o byte recebido na variável //receive. } Usart_Write: transmite um byte pela serial. Sintaxe: Usart_Write (byte chr), Exemplo: Usart_Write('A'); ou Usart_Write (61); // escreve o caracter “A” na serial.
48
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________ Projeto Serial: 1-) Enviar o caracter “A” pela serial. Resolução: Neste caso, vamos atuar sobre o botão conectado ao pino 0 da porta D e a cada atuação, o caracter “A” será enviado para a serial. Utilizamos, agora, uma maneira diferente de verificar o acionamento de um botão que é através da biblioteca UTIL e o comando BUTTON, conforme segue: Sintaxe: unsigned short Button(unsigned short *port, unsigned short pin, unsigned short time, unsigned short active_state); Exemplo: if (Button(&PORTD,0,1,1)) { ...comando..... } Para o exemplo acima, conclui-se que se o botão conectado ao pino 0 da porta D, por um tempo de 1 ms, o estado do pino mudará para nível lógico 1 e o que está entre chaves será executado. Código: void main() { // Initializa o módulo USART (8 bit, baud rate 9600, no parity bit..) Usart_Init(9600); while (1) { if (Button(&PORTD,0,100,1)) //Se o botão conectado ao pino 0 da Porta D, o comando //abaixo será executado. Usart_Write('A'); //Envia o caracter “A” pela serial. } } Obs.: Faça uma experíência modificando para baixo o tempo de 100ms. Projeto Serial 2: 2-) Receber um caracter do PC e enviá-lo novamente pela serial, além de acender o LED1 se o caracter for “a”e apagar o led se o caracter for “b”.
49
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________ Código: unsigned short i; void main() { TRISD = 0x00; PORTD = 0x00; // Initializa USART (8 bit, baud rate 9600, no parity bit..) Usart_Init(9600); do { if (Usart_Data_Ready()) { i = Usart_Read(); Usart_Write(i); if (i=='a') PORTD.F0 = 1; if (i=='b') PORTD.F0 = 0; } } while (1); }
// Se algum dado for recebido // Lê o dado recebido // Envia o dado pela serial novamente //Se o caracter for 'a', acende o LED 1 //Se o caracter for 'b', apaga o LED 1
Projeto Serial 3: 3-) Enviar a palavra “MICROCONTROLADOR” pela serial. Resolução: No MikroC, não existe uma maneira de enviarmos uma string, somente podemos enviar 1 caracter por vez, portanto podemos enviar assim: Usart_Write('M'); Usart_Write('I'); Usart_Write('C'); ...... Ou podemos utilizar uma maneira mais usual que é a utilização de ponteiros que será mostrada no código abaixo: No caso de ponteiros, podemos dizer que cada caracter será “colocado” numa posição do ponteiro, ou seja, o caracter “M” será colocado ou estará apontando para a posição 0, o caracter “I” será colocado ou estará apontando para aa posição 1 e assim por diante até o final, sendo que a última posição será ocupada por um valor nulo e essa será a finalização do ponteiro. M
I
C
R
O
C
O
N
T
R
O
L
A
D
O
R
\0
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
50
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________ Código: unsigned char *txt = "MICROCONTROLADOR"; void main() { // Initializa USART (8 bit, baud rate 9600, no parity bit..) Usart_Init(9600); do { Usart_Write(*txt); *txt++; delay_ms(100); } while (*txt != '\0'); }
//envia um caracter pela serial //incrementa o ponteiro //Verifica a finalização do ponteiro
Projeto Serial 4: 4-) Receber do PC a string “LD1” e acender o LED1 e se a string for “DL1”, apagar o LED1. Resolução: Neste caso utilizaremos uma matriz com 4 posições ou 4 endereços (rec[4]) onde serão armazenados os valores recebidos pela serial, lembrando que é necessário sempre inicializarmos com 0 o posicionamento. No caso, a variável i será a responsável pelo posicionamento da matriz. Código: char rec[4]; short i; void trata_serial() { if ((rec[0] == 'L') && (rec[1] == 'D') && (rec[2] == '1')) // Faz a comparação dos valores // armazenados na Matriz 'rec' PORTD.F0 = 1; if ((rec[0] == 'D') && (rec[1] == 'L') && (rec[2] == '1')) PORTD.F0 = 0; } void main() { TRISD = 0x00; PORTD = 0x00;
51
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________ // Initializa USART (8 bit, baud rate 9600, no parity bit..) Usart_Init(9600); i=0; while(1) { if (Usart_Data_Ready()) //Se existir um caracter no buffer da serial { rec[i] = Usart_Read(); //O caracter será lido e colocado na matriz 'rec' i++; //Incrementa o valor da posição da matriz if (rec[i-1] == 0x0D) { //Verifica se o valor armazenado na Matriz é // 0x0D (Código hexa para o ASCII ) trata_serial(); // Sendo 0x0D, vai para a função trata_serial //for(i=0;i<=3;i++) // 'Limpa' a Matriz // rec[i] = '\0'; i=0; // Reinicializa o posicionamento da matriz } } } }
52
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________
EEPRON Interna Biblioteca EEPRON EEPRON_Read: Lê um byte da memória EEPRON Sintaxe: Variável = EEPRON_Read (byte adress), OBS: O PIC 16F877A tem 256 bytes de memória EEPRON Exemplo: tmp = EEPRON_Read(0); //Lê a posição 0 e carrega o valor na variável tmp EEPRON_Write: Escreve um byte na memória EEPRON Sintaxe: EEPRON_Write (byte adress, byte dado) Exemplo: EEPRON_Write (0, 100); // escreve o valor 100 no endereço 0 da memória EEPRON. Projeto EEPRON: 1-) Escrever o valor 61 ('caracter “a”) no endereço 0 da memória EEPRON, após ler o valor e escrever no LCD. Código: void main() { Lcd_Custom_Config(&PORTB,7,6,5,4,&PORTB,1,2,0); // Initializa o LCD na PORTB Lcd_Custom_Cmd(Lcd_CURSOR_OFF); // Desliga o cursor EEPROM_Write(0,0x61);
// Escreve o código 0x61 ('caracter 'a') na EEPROM do PIC
Lcd_Custom_Out(1,1,"Leitura EEPROM"); //Escreve na primeira linha do LCD while(1) { if (button(&PORTD,0,100,1)) //Se o botão no pino 0 da porta D for acionado { Lcd_Custom_Chr(2, 1, EEPROM_Read(0)); // Faz a leitura no endereço 0 // da EEPROM do PIC e // escreve o conteúdo na // linha 2 do LCD } } }
53
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________ Projeto EEPRON 2: 2-) Receber da serial um caracter, escrever no endereço 10 da memória EEPRON, ler este valor da memória, escrever no LCD e envia-lo à serial. Código: unsigned short i; void main() { Usart_Init(9600); Lcd_Custom_Config(&PORTB,7,6,5,4,&PORTB,1,2,0); // Initializa LCD na PORTB Lcd_Custom_Cmd(Lcd_CURSOR_OFF); // Desliga o cursor Lcd_Custom_Out(1,1,"Leitura EEPROM");
//Escreve na primeira linha do LCD
while(1) { if (Usart_Data_Ready()) // Se existir um caracter no buffer da serial { i = Usart_Read(); // Faz a leitura do buffer e armazena na variável i Usart_Write(i); // Escreve o conteúdo da variável i na Serial EEPROM_Write(10,i); // Escreve o conteúdo da variável i na EEPROM } if (button(&PORTD,0,100,1)) //Se o botão no pino 0 da porta D for acionado { Lcd_Custom_Chr(2, 1, EEPROM_Read(10)); //Escreve na segunda linha //do LCD o valor armazenado //no endereço 10 da EEPROM. } } }
54
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________
PWM - (Pulse Width Modulation) A modulação PWM (modulação por largura de pulso) consiste basicamente na aplicação de uma onda quadrada de amplitude igual à VCC e freqüência alta substituindo a tensão contínua. A tensão média varia em função do tempo em que a onda fica em nível alto (VCC) e do tempo em que a onda fica em nível básico (0V). A relação entre o tempo em que a onda fica em nível alto e o período total é conhecido como Duty Cycle que é normalmente expresso em percentual. Portanto para um Duty Cycle de 50 %, metade do tempo a onda se mantém em nível alto e a outra metade do tempo a onda se mantém em nível baixo. Por exemplo, uma modulação de amplitude 5V e Duty Cycle de 50 %. Tem o mesmo efeito de uma tensão contínua de 2,5 V que é a tensão média para este caso.
Biblioteca PWM no MikroC PWM_init: Inicializa o módulo PWM informando a freqüência de operação. Sintaxe: PWM_init (Unsigned long Freq) Exemplo: PWM_init(5000); // inicializa o módulo PWM com frequência de 5KHz. PWM_Change_Duty: Altera o valor do Duty-Cycle. Sintaxe: PWM_Change_Duty (Unsigned Char Duty) Duty é uma valor do tipo char, portanto de 0 à 255, onde 255 representa 100 % de Duty Cycle . Exemplo: PWM_Change_Duty (192); //configura o Duty-Cycle p/ 75 %. PWM_Start: Inicializa a geração do PWM. Sintaxe: PWM_Start( );
55
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________ PWM_Stop: Interrompe a geração do PWM. Projeto PWM:
Controlar o brilho de um Led, ligado ao CCP1 (RC2), utilizando PWM e variando o Duty-Cycle de 0 a 100 %. Código: void main() { unsigned i; i = 0; Pwm_Init(5000); Pwm_Start();
//Indica ao módulo PWM o funcionamento com frequencia de 5KHz //Inicializa o Modo PWM
while(1){ Pwm_Change_Duty(i); //Modifica o Duty_cycle i++; if (i>=100) i = 0; delay_ms(50); } } 56
Curso básico de linguagem C para microcontroladores PIC ________________________________________________________________________________ Projeto PWM 2: Controlar o brilho do Led utilizando PWM e variando o Duty-Cycle de acordo com a leitura do A/D e mostrar no LCD o valor do Duty. Código: unsigned int ad; char txt[7]; void main() { ADCON1 = 0x0E; // Configura as entradas analógicas e referência TRISA = 0xFF; // Faz PORTA como entrada Pwm_Init(10000); //Indica ao módulo PWM o funcionamento com frequencia de 10KHz Pwm_Start(); //Inicializa o modo PWM Lcd_Custom_Config(&PORTB,7,6,5,4,&PORTB,1,2,0); // Initializa LCD na PORTB Lcd_Custom_Cmd(Lcd_CURSOR_OFF); // Desliga o cursor while(1) { ad = ADC_Read(0); //Faz a leitura da conversão AD e armazena na variável 'ad'. Pwm_Change_Duty(ad/4); // Modifica o Duty_cycle ad = ((ad /4) * 100) / 255; IntToStr(ad,txt); // converte a variável inteira 'ad' na variável texto txt // (matriz) Lcd_Custom_Out(1, 1, "Duty = "); // Escreve na linha 1 do LCD Lcd_Custom_Out(1, 7, txt); // Escreve o valor de Duty no LCD } }
57
