Introdução ao PIC18F4620

Sistemas

de

MicroControladores

CET em Automação, Robótica e Controlo Industrial, 4º Edição.

Bernardino Neves – Coimbra 2011

CET – Automação, Robótica e Controlo Industrial – Sistemas de MicroControladores - 2011

Bernardino Neves - 2011 Página i

Índice Introdução. ............................................................................................................................... 1

Arquitectura PIC18. .................................................................................................................. 3

O PIC18F4620........................................................................................................................ 3

Identificação e nomenclatura dos pinos. ............................................................................... 5

Estrutura interna. .................................................................................................................. 7

Configuração do oscilador. .................................................................................................... 9

Configuração do hardware. ................................................................................................. 13

Sistema de reset.................................................................................................................. 14

Ambiente de programação MPLAB IDE. ................................................................................. 17

Introdução ao sistema integrado MPLAB. ............................................................................ 17

Instalação do MPLAB. .......................................................................................................... 17

Compilador C18. ..................................................................................................................... 21

Instalação do compilador C18. ............................................................................................ 21

Especificações do compilador C18. ...................................................................................... 23

Tipo e tamanho de variáveis. ........................................................................................................ 23

Armazenamento por tipo de dados. .............................................................................................. 23

Armazenamento por classes - Overlay. ......................................................................................... 24

Armazenamento por qualificadores. ............................................................................................. 24

Incluir ficheiros - #INCLUDE .......................................................................................................... 25

Macros predefinidas do compilador C18. ...................................................................................... 25

A directiva #PRAGMA. .................................................................................................................. 26

Directivas do compilador C18. ............................................................................................. 27

Livrarias de funções do compilador C18. ............................................................................. 27

Primeiros passos com o MPLAB IDE. ...................................................................................... 29

Criar e configurar um projecto no MPLAB IDE. .................................................................... 29

Primeiro programa. ............................................................................................................. 32

Modificar o conteúdo de registos e variáveis. ............................................................................... 34

Parar o programa num determinado sitio especifico – Breakpoint. ................................................ 35

Tempo de execução...................................................................................................................... 35

O simulador STIMULUS. ...................................................................................................... 37

O logic analyzer. .................................................................................................................. 39

Depurador/Gravador PICKIT 3. ............................................................................................ 40


Página ii Bernardino Neves – 2011

Integração do PICKIT 3 com o MPLAB IDE. ........................................................................... 41

Programação em C, para microcontroladores. ....................................................................... 43

Princípios de programação. ................................................................................................. 43

Fluxogramas. ................................................................................................................................ 43

Álgebra de booleana..................................................................................................................... 44

Variáveis e dados.......................................................................................................................... 45

Operadores. ................................................................................................................................. 45

Introdução a linguagem C. ................................................................................................... 45

Palavras reservadas. ..................................................................................................................... 45

Identificadores. ............................................................................................................................ 45

Variáveis e tipos de dados. .................................................................................................. 46

Declaração de variáveis. ............................................................................................................... 46

Declaração de constantes. ............................................................................................................ 46

Operadores. ........................................................................................................................ 47

Aritméticos................................................................................................................................... 47

Relacionais. .................................................................................................................................. 47

Lógicos. ........................................................................................................................................ 48

Memoria. ..................................................................................................................................... 50

Associação de operadores. ........................................................................................................... 50

Declarações de controlo. ..................................................................................................... 51

Comando IF. ................................................................................................................................. 51

Comando SWITCH. ....................................................................................................................... 52

Comando FOR. ............................................................................................................................. 53

Comando WHILE........................................................................................................................... 53

Comando DO-WHILE..................................................................................................................... 54

Comando GOTO. .......................................................................................................................... 54

Tipos e dados avançados. .................................................................................................... 55

Ponteiros...................................................................................................................................... 55

Matrizes de dados. ....................................................................................................................... 56

Estruturas..................................................................................................................................... 58

Uniões. ......................................................................................................................................... 60

Funções. ............................................................................................................................. 61

Programação dos microcontroladores PIC18. ......................................................................... 63

Portos I/O............................................................................................................................... 69

Leitura do estado de um pino. ............................................................................................. 70

Escrita em um pino. ............................................................................................................ 70


Bernardino Neves - 2011 Página iii

Exemplos de aplicação. ....................................................................................................... 71

Exemplo 1 – Led a piscar com frequência igual a 1Hz. ................................................................... 71

Exemplo 2 – Sequência de Led’s. .................................................................................................. 72

Exemplo 3 – Variação da frequência. ............................................................................................ 75

Exemplo 4 – Activar uma saída através de uma entrada. ............................................................... 77

Exemplo 5 – Mudança de estado (Toggle). .................................................................................... 78

Exemplo 6 – Atraso a operação. .................................................................................................... 79

Exemplo 7 – Avanço a operação. .................................................................................................. 80

Exemplo 8 – Arranque estrela - triângulo. ..................................................................................... 82

Exemplo 9 – Display de 7 segmentos. ........................................................................................... 83

Exemplo 10 – Leitura e escrita em um pino (maximização do pino). .............................................. 86


Página iv Bernardino Neves – 2011

Índice de figuras

Fig 1 - Arquitectura de um sistema constituído por um µP. ....................................................... 1

Fig 2 - Arquitectura de um µC, com os mesmos periféricos. ...................................................... 1

Fig 3 - Pinout do microcontrolador PIC18F4620 versão DIP 40 pinos [1]. ................................... 5

Fig 4 - Diagrama de blocos da estrutura interna do microcontrolador PIC 18LF4620 [1]............. 8

Fig 5 - Implementação do oscilador de cristal. ........................................................................... 9

Fig 6 - Implementação do oscilador por fonte de relógio externo. ........................................... 10

Fig 7 - Implementação do oscilador RC. ................................................................................... 11

Fig 8 - Diagrama de blocos do módulo de configuração do oscilador [1]. ................................. 12

Fig 9 - Reset por alimentação inicial do µC............................................................................... 14

Fig 10 - Reset devido a alimentação inicial do µC. .................................................................... 15

Fig 11 - Reset devido a estabilização do oscilador. ................................................................... 15

Fig 12 - Reset gerado por queda de tensão. ............................................................................. 15

Fig 13 - Diagrama de blocos do circuito de reset [1]. ................................................................ 16

Fig 14 - Origem do evento de reset. ......................................................................................... 16

Fig 15 - Ficheiros descompactados. ......................................................................................... 17

Fig 16 – Selecção da instalação completa. ............................................................................... 18

Fig 17 - Localização do ficheiro de instalação. .......................................................................... 18

Fig 18 - Janela de progresso da instalação. .............................................................................. 19

Fig 19 - Localização da instalação do compilador C18. ............................................................. 21

Fig 20 - Selecção dos componentes do compilador C18. .......................................................... 21

Fig 21 - Configuração das variáveis. ......................................................................................... 22

Fig 22 - Ligação do MPLAB IDE ao compilador C18................................................................... 22

Fig 23 - Criar uma novo projecto. ............................................................................................ 29

Fig 24 - Selecção do compilador C18. ...................................................................................... 29

Fig 25 – Conclusão da configuração do projecto. ..................................................................... 30

Fig 26 - Pasta Source Files. ....................................................................................................... 30

Fig 27 - Janela para adicionar ficheiros ao projecto. ................................................................ 31

Fig 28 - Ambiente de trabalho. ................................................................................................ 31

Fig 29 - Localização do icon Make. ........................................................................................... 32

Fig 30 - Seleccionar o simulador MPALB SIM. .......................................................................... 33

Fig 31 - Comandos do simulador MPLAB SIM. ......................................................................... 33

Fig 32 – Selecção da janela File Registers e Special Function Registers. .................................... 34

Fig 33 - Inserir uma variável para se ter acesso aos seus parâmetros. ...................................... 34

Fig 34 - Janela Watch. ............................................................................................................. 35

Fig 35 - Definição da frequência de clock, base de tempo do simulador MPLAB SIM. ............... 35

Fig 36 – Exemplo, determinação do tempo de execução. ........................................................ 36

Fig 37 - Resultado do tempo de execução do exemplo proposto. ............................................ 36

Fig 38 - Janela de configuração do simulador Stimulus. ........................................................... 38

Fig 39 – Localização do Fire Button. ......................................................................................... 38


Bernardino Neves - 2011 Página v

Fig 40 – Resultado da simulação Stimulus. .............................................................................. 38

Fig 41 - Selecção do canal a analisar. ....................................................................................... 39

Fig 42 - Resultado obtido pelo analisador lógico. ..................................................................... 39

Fig 43 - Depurador/Programador PICKIT 3. .............................................................................. 40

Fig 44 - Descrição dos pinos do conector ICSP. ........................................................................ 40

Fig 45 – Ligação entre PICKIT 3 e o microcontrolador. ............................................................. 41

Fig 46 - Verificação da integração do programador PICKIT 3 com o MPLAB IDE. ....................... 41

Fig 47 – Fluxograma do exemplo proposto. ............................................................................. 44

Fig 48 - Ficheiro de instalação do bootloader AN1310. ............................................................ 63

Fig 49 - Primeira janela de instalação do software PC do bootloader AN1310. ......................... 64

Fig 50 - Segunda janela de instalação do software PC do bootloader AN1310.......................... 64

Fig 51 – Localização da instalação do software PC AN1310. ..................................................... 64

Fig 52 – Finalização da instalação do software PC AN1310. ..................................................... 65

Fig 53 - Fonte de alimentação. ................................................................................................ 65

Fig 54 - Microcontrolador PIC18F4620 e transceiver RS232. .................................................... 65

Fig 55 - Programação em circuito ICSP..................................................................................... 66

Fig 56 – Imagem do hardware desenvolvido, o kit DevBoard PIC. ............................................ 66

Fig 57 - Localização do bootloader PIC18. ................................................................................ 66

Fig 58 - Setup experimental para testar o hardware e o software PC. ...................................... 67

Fig 59 - Localização do software PC AN1310. ........................................................................... 67

Fig 60 - Software PC para carregar o programa no microcontrolador....................................... 67

Fig 61 - Configuração do Baud Rate. ........................................................................................ 68

Fig 62 – Comunicação entre o software PC e o microcontrolador. ........................................... 68

Fig 63 - Modelo simplificado do porto I/O [1]. ......................................................................... 69

Fig 64 - Layout do circuito do exemplo 1. ................................................................................ 71









Fig 73 - Diagrama temporal, da técnica para maximizar um pino I/O. ...................................... 87

Fig 74 - Layout do circuito do exemplo 10. .............................................................................. 87


Página vi Bernardino Neves – 2011

Índice de tabelas

Tabela 1 - Modos de gestão de energia. .................................................................................... 3

Tabela 2 - Memoria de programa e dados disponível. ............................................................... 4

Tabela 3 - Periféricos internos. .................................................................................................. 4

Tabela 4 - Nomenclatura do pinout do microcontrolador. ......................................................... 7

Tabela 5 - Valor dos condensadores para os diferentes tipos de cristais. ................................. 10

Tabela 6 - Registos da palavra de configuração do microcontrolador. ..................................... 13

Tabela 7 - Tipo de variáveis, o seu tamanho e limites. ............................................................. 23

Tabela 8 - Localização das variáveis em função dos qualificadores. ......................................... 25

Tabela 9 - Tamanho dos ponteiros. ......................................................................................... 25

Tabela 10 - Directivas do compilador C18. ............................................................................... 27

Tabela 11 – Livraria de funções de matemática. ...................................................................... 28

Tabela 12 - Livrarias de funções gerais. ................................................................................... 28

Tabela 13 - Livrarias de funções de software. .......................................................................... 28

Tabela 14 - Livrarias de funções de hardware. ......................................................................... 28

Tabela 15 - Código do ficheiro do exemplo. ............................................................................. 32

Tabela 16 - Código do segundo exemplo proposto. ................................................................. 37

Tabela 17 – Símbolos de fluxograma. ...................................................................................... 43

Tabela 18- Operadores lógicos. ............................................................................................... 44

Tabela 19 – Palavras reservadas em programação em C. ......................................................... 45

Referências

[1] – Datasheet PIC18F4620 (Microchip).

[2] – MPLAB C18 C Compiler User Guide (Microchip).

[3] – MPLAB C18 C Compiler Library (Microchip).

[4] – AN1310, Serial Bootloader for PIC16 and PIC18 (Microchip).

[5] – Fábio Pereira, PIC Programação em C – Érica, 2007.

[6] – Fábio Pereira, Microcontrolador PIC18 Detalhado – Érica, 2010.


Bernardino Neves - 2011 Página 1 Introdução

Introdução.

Pretende-se nesta unidade de formação, denominada de Sistemas de MicroControladores,

adquirir competências para o desenvolvimento de sistemas electrónicos com microcontroladores. O

microcontrolador que será usado como base de estudo, é o PIC18F4620, desenvolvido e produzido pela

empresa Microchip Techonology. Trata-se de um microcontrolador para aplicações de complexidade

intermédia.

Os microcontroladores têm ocupado bem o seu lugar no nosso dia-a-dia, podemos facilmente

verificar que, em média recorremos ao uso de cerca de 10 dispositivos controlados por

microcontroladores, tais como um simples relógio, o comando da TV, o circuito electrónico do nosso

carro, o telemóvel, etc.

O nascimento do microcontrolador, surge pela necessidade de integrar no mesmo

componente, o hardware necessário, para que tenha um comportamento e performances de um micro

computador, permitindo assim poupar tempo e espaço na construção de novas aplicações. Repare-se

que o uso de microprocessadores ou microcontroladores, depende do fim ou aplicação a que se destina,

tendo em consideração capacidade de processamento, memória, hardware disponível e custos.

As figuras 1 e 2 mostram dois sistemas, um constituído por um microprocessador e outro por

um microcontrolador equivalente em termos de periféricos.

µP8085

EPROM

2532

RAM

62256

USART

8251

IO

8255

Timer

8155

Bus de dados

Bus de controlo

Fig 1 - Arquitectura de um sistema constituído por um µP.

IO

Timers

RAM

USART

EPROM

µP

PIC18

Fig 2 - Arquitectura de um µC, com os mesmos periféricos.


Página 2 Bernardino Neves – 2011 Introdução

Durante a unidade de formação serão abordados os seguintes temas:

Diferenças entre microprocessadores e microcontroladores;

Arquitectura dos microcontroladores PIC18;

Configuração dos microcontroladores PIC18;

Ambiente de desenvolvimento e concepção de programas para microcontroladores PIC18;

Compilador C para microcontroladores PIC18;

Programação em C, o essencial para microcontroladores;

Programação dos microcontroladores PIC18;

Configuração e aplicação dos periféricos;

Electrónica aplicada a sistemas de microcontroladores;

Desenvolvimento de aplicações com microcontroladores PIC18.


Bernardino Neves - 2011 Página 3 Arquitectura PIC18

Arquitectura PIC18.

O PIC18F4620.

O microcontrolador em estudo é o PIC18F4620. A escolha deste microcontrolador, deve-se ao

facto, do docente de ter mais experiência com esta família de microcontroladores. O PIC18F4620 é um

microcontrolador avançado de 8 bits com memória de programa flash, caracterizado pelo conversor

analógico/digital de 10 bit’s e por utilizar a tecnologia nano watt. A versão F é caracterizada por operar

com tensões de alimentação na ordem dos 5V. Este microcontrolador tal como a sua família, tem a

particularidade de ser possível gerir os seus recursos de energia, isto é, como o microcontrolador está

dividido em duas partes, o processador e os controladores (periféricos internos), é possível definir por

questões energéticas que partes devem estar activas. Para gestão de energia é possível definir 3 estados

como demonstra a tabela seguinte.

Modo Estado do processador Estado dos controladores

Executar (Run) Activo Activo

Espera (Idle) Desactivo Activo

Adormecido (Sleep) Desactivo Desactivo

Tabela 1 - Modos de gestão de energia.

Em termos de flexibilidade e estrutura do oscilador, o PIC 18F4620 permite a configuração do

oscilador em quatro modos distintos de cristal, sendo possível utilizar cristais até 25 Mhz e recorrendo

ao Phase Lock Loop (PLL) é possível multiplicar por 4 a frequência de oscilação do cristal ou do oscilador

interno. A frequência máxima de oscilação está limitada a 40 MHz incluindo com o uso do PLL, possui

ainda um oscilador interno que pode operar desde 31Khz até 32Mhz. O microcontrolador também

permite o uso de um oscilador secundário de 32Khz, que poderá ser usado para gerar um relógio em

tempo real independente do oscilador principal.

Sobre os periféricos internos, podemos destacar as seguintes características:

Possui 36 pinos I/O distribuídos por 5 portos, podendo cada pino I/O suportar uma

corrente até 25 mA. Apesar de um pino I/O suportar uma corrente de 25 mA, o

microcontrolador apenas suporta uma corrente total de 200 mA;

Possui três modos de interrupção externos com quatro entradas destinadas a gerar

interrupção por mudança de estado;

Possui um módulo avançado de captura, comparação e modulação por largura de pulso

(PWM), sendo possível definir até 4 saídas PWM, com selecção de polaridade,

programação do tempo não activo e com reinicialização e desligamento automático;

Possui um módulo de comunicação SPI (suporta os 4 modos) e I2C;

Possui um módulo avançado de comunicação USART, que permite a comunicação segundo

os protocolos RS232, RS485 e LIN/J2602, sendo possível utilizar o protocolo RS232 com


Página 4 Bernardino Neves – 2011 Arquitectura PIC18

recurso ao oscilador interno, dispensando assim o cristal externo, sendo também possível

detectar a taxa de transmissão automaticamente;

Possui 13 canais analógicos/digitais de 10 bits, através do módulo ADC, sendo que este

módulo ADC permite a capacidade de aquisição automática e a conversão durante o modo

adormecido;

Possui um temporizador/contador de 8 bits e 3 temporizadores/contadores de 16 bits.

Além das características acima mencionadas, o microcontrolador possui ainda as seguintes

características:

Permite a escrita de cem mil vezes na memoria flash de programa;

Permite a escrita de um milhão de vezes na memória EEPROM;

Permite a retenção dos dados tanto na memória de programa como na memória EEPROM

por um período de cem anos;

Possui um multiplicador por hardware de 8 bits por 8 bits;

Possui um temporizador WatchDog (WDT) prolongado, permitindo a configuração de 4ms

ate 131s;

Permite o download de programas através da programação em circuito (ICSP).

As tabelas seguintes mostram de um modo geral e simplificado as características do

microcontrolador PIC 18F4620.

Memória de programa Memória de dados

Flash (bytes) Instruções RAM (bytes) EEPROM (bytes)

64K 32768 3968 1024

Tabela 2 - Memoria de programa e dados disponível.

I/O Canais ADC CCP/PWM SPI I2C USART COMP Timers (8/16 bits)

36 13 1/1 S S 1 2 1/3

Tabela 3 - Periféricos internos.

Em termos de encapsulamento, existem no mercado três tipos distintos, a versão DIP de 40

pinos, a versão TQFP de 44 pinos e a versão QFN também de 44 pinos, neste documento apenas se fará

referência à versão DIP de 40 pinos visto que será o encapsulamento usado no hardware proposto. No

datasheet do fabricante poderá encontrar o pinout das outras versões de encapsulamento.



Identificação e nomenclatura dos pinos.

A figura 3 mostra o pinout do microcontrolador PIC 18F4620, na versão de encapsulamento DIP

40 pinos.

Fig 3 - Pinout do microcontrolador PIC18F4620 versão DIP 40 pinos [1].

Na tabela seguinte descrimina-se detalhadamente, a identificação e função de cada um dos

pinos do microcontrolador, de modo a perceber-se melhor o significado de cada nomenclatura utilizada.

Nome do pino Número

do pino

Tipo

de

pino

Tipo de

sinal Designação

MCLR

VPP

RE3

1

I

PWR

I

ST

ST

Reset externo quando colocado a “0”.

Entrada para programação (13 V).

Entrada digital.

RA0

AN0 2

I/O

I

TTL

Analógico

Pino 0 do porto A.

Entrada analógica 0.

RA1

AN1 3

I/O

I

TTL

Analógico

Pino 1 do porto A.


RA2

AN2

Vref-

CVref

4

I/O

I

I

O

TTL

Analógico

Analógico

Analógico

Pino 2 do porto A.


Tensão negativa de referência para o ADC.

Tensão de saída de referência do comparador.

RA3

AN3

Vref-

5

I/O

I

I

TTL

Analógico

Analógico

Pino 3 do porto A.


Tensão positiva de referência para o ADC.

RA4

T0CKI

C1OUT

6

I/O

I

O

ST

ST

Pino 4 do porto A.

Entrada externa de relógio para o Timer0.

Saída do comparador 1.



RA5

AN4

SS

HLVDIN

C2OUT

7

I/O

I

I

I

O

TTL

Analógico

TTL

Analógico

Pino 5 do porto A.


Pino de selecção de dispositivo em comunicação no modo

SPI.

Pino de detecção de tensão.

Saída do comparador 2.

RE0

RD

AN5

8

I/0

I

I

ST

TTL

Analógico

Pino 1 do porto E.

Pino RD de controlo do porto paralelo de comunicações.


RE1

WR

AN6

9

I/0

I

I

ST

TTL

Analógico

Pino 2 do porto E.

Pino WR de controlo do porto paralelo de comunicações.


RE2

CS

AN7

10

I/0

I

I

ST

TTL

Analógico

Pino 2 do porto E.

Pino CS de controlo do porto paralelo de comunicações.


VDD 11 P Pino de alimentação do microcontrolador.

VSS 12 P Pino de massa do microcontrolador.

OSC1

CLKI

RA7

13

I

I

I/O

ST

CMOS

TTL

Pino 1 do cristal de oscilação.

Entrada de uma fonte de relógio externo.

Pino 7 do porto A.

OSC2

CLKO

RA6

14

O

O

I/O

TTL

Pino 2 do cristal de oscilação.

Saída de uma fonte de relógio.

Pino 6 do porto A.

RC0

T1OSO

T13CKI

15

I/O

O

I

ST

ST

Pino 0 do porto C

Pino 1 do cristal de oscilação do Timer1.

Entrada externa de relógio para Timer1 e Timer3.

RC1

T1OSI

CCP2

16

I/O

I

I/O

ST

CMOS

ST

Pino 1 do porto C.

Pino 2 do cristal de oscilação do Timer1.

Entrada/Saída do módulo CCP2.

RC2

CCP1

P1A

17

I/O

I/O

O

ST

ST

Pino 2 do porto C.


Saída dedicada do módulo CCP1.

RC3

SCK

SCL

18

I/O

I/O

I/O

ST

ST

ST

Pino 3 do porto C.

Relógio de sincronismo para comunicações SPI.

Relógio de sincronismo para comunicações I2C.

RD0

PSP0 19

I/O

I/O

ST

TTL

Pino 0 do porto D.

Bit 0 de dados do porto paralelo.

RD1

PSP1 20

I/O

I/O

ST

TTL

Pino 1 do porto D.


RD2

PSP2 21

I/O

I/O

ST

TTL

Pino 2 do porto D.


RD3

PSP3 22

I/O

I/O

ST

TTL

Pino 3 do porto D.


RC4

SDI

SDA

23

I/O

I

I/O

ST

ST

ST

Pino 4 do porto C.

Entrada de dados na comunicação SPI.

Linha de dados na comunicação I2C.

RC5

SDO 24

I/O

O

ST Pino 5 do porto C.

Saída de dados na comunicação SPI.

RC6

TX

CK

25

I/O

O

I/O

ST

ST

Pino 6 do porto C.

Linha de transmissão na comunicação USART.

Relógio de sincronismo na comunicação USART.

RC7

RX

DT

26

I/O

I

I/O

ST

ST

ST

Pino 7 do porto C.

Linha de recepção na comunicação USART.

Linha de sincronismo de dados em comunicação USART.

RD4

PSP4 27

I/O

I/O

ST

TTL

Pino 4 do porto D.


RD5

PSP5

P1B 28

I/O

I/O

O

ST

TTL

Pino 5 do porto D.





RD6

PSP6

P1C

29

I/O

I/O

O

ST

TTL

Pino 6 do porto D.



RD7

PSP7

P1D

30

I/O

I/O

O

ST

TTL

Pino 7 do porto D.



VSS 31 P Pino de massa do microcontrolador.

VDD 32 P Pino de alimentação do microcontrolador.

RB0

INT0

FLT0

AN12

33

I/O

I

I

I

TTL

ST

ST

Analógico

Pino 0 do porto B.

Pino 0 de interrupção externa.

Pino dedicado ao CCP1.


RB1

INT1

AN10

34

I/O

I

I

TTL

Analógico

ST

Pino 1 do porto B.



RB2

INT2

AN8

35

I/O

I

I

TTL

Analógico

ST

Pino 2 do porto B.



RB3

AN9

CCP2

36

I/O

I

I/O

TTL

Analógico

ST

Pino 3 do porto B.



RB4

KBI0

AN11

37

I/O

I

I

TTL

TTL

Analógico

Pino 4 do porto B.

Pino 0 de interrupção por mudança de estado.


RB5

KBI1

PGM

38

I/O

I

I/O

TTL

TTL

ST

Pino 5 do porto B.


Pino de selecção do ICSP.

RB6

KBI2

PGC

39

I/O

I

I/O

TTL

TTL

ST

Pino 6 do porto B.


Pino de sincronismo do ICSP.

RB7

KBI3

PGD

40

I/O

I

I/O

TTL

TTL

ST

Pino 7 do porto B.


Pino de dados do ICSP.

Tabela 4 - Nomenclatura do pinout do microcontrolador.

Legenda:

I - Entrada (Input).

O - Saída (Output).

I/O - Entrada ou saída.

ST - Sinal do tipo Schmitt Trigger.

TTL - Sinal do tipo TTL.

PWR - Alimentação.

Estrutura interna.

Como foi descrito nas linhas acima, neste capítulo pretende-se conhecer as características do

microcontrolador. A estrutura interna dá-nos uma ideia de como é o microcontrolador no seu interior, o

microcontrolador PIC 18F4620 foi optimizado para poder executar um conjunto de instruções em

velocidade muito alta, de facto é possível obter uma velocidade de 10 MIPS (MIPS – Milhões de

instruções por segundo) para uma frequência de oscilação de 40 Mhz, o que se pode considerar um bom

desempenho mesmo para aplicações exigentes.



Algumas das características importantes da estrutura interna são:

Capacidade de pipeline, isto é, enquanto é executa uma instrução, o processador

procura a próxima instrução a ser executada, de forma a acelerar a execução do

programa;

Cada instrução apenas ocupa uma posição de memória de programa;

Permite a execução de uma instrução num ciclo de máquina;

Capacidade de manter um tempo fixo para a execução de todas as instruções;

Semelhança e compatibilidade entre as diversas famílias de microcontrolador, o que

facilita a migração de uma aplicação de um microcontrolador para outro.

A estrutura interna do microcontrolador pode ser vista como um conjunto de blocos funcionais.

Estes blocos funcionais permitem uma maior facilidade em perceber como é constituído internamente o

microcontrolador. No datasheet do fabricante podemos visualizar um diagrama de blocos que define a

estrutura interna do microcontrolador. Tal como se ilustra na figura 4.

Fig 4 - Diagrama de blocos da estrutura interna do microcontrolador PIC 18LF4620 [1].



A partir do diagrama de blocos da estrutura interna do microcontrolador, podemos obter todas

as informações relevantes sobre o microcontrolador. No canto superior esquerdo podemos verificar

qual a estrutura e registos associados a memoria de programa FLASH. Do lado direito temos definido os

PORTOS. No centro superior temos a estrutura e registos associados a memoria RAM. No centro temos

a unidade lógica e aritmética (ULA). No lado centro esquerdo temos os registos associados a

configuração de hardware do microcontrolador e por fim no canto inferior esquerdo temos os

periféricos disponíveis no microcontrolador. Por exemplo em relação aos PORTOS, podemos verificar

que existem 5 PORTOS designados de A a E, quais os seus pinos e funções associados a cada PORTO e

também podemos verificar que o bus de dados para os PORTOS é um bus de 8 bits.

Configuração do oscilador.

O microcontrolador PIC 18F4620 pode utilizar 10 tipos diferentes de osciladores, conforme a

lista seguinte:

LP – Oscilador de cristal de baixa potência;

XT – Oscilador de cristal de quartz;

HS – Oscilador de cristal de quartz de alta velocidade;

HSPLL - Oscilador de cristal de quartz de alta velocidade com multiplicador de frequência;

RC – Oscilador formado pelo conjunto resistência e condensador, com saída de relógio no

pino RA6;

RCIO - Oscilador de formado pelo conjunto resistência e condensador;

INTIO1 – Oscilador interno com saída de relógio no pino RA6;

INTIO2 – Oscilador interno;

EC – Fonte de relógio externo com saída de relógio no pino RA6;

ECIO – Fonte de relógio externo.

O tipo de oscilador usado deve ser de acordo com a aplicação que se pretende. Por exemplo

uma aplicação simples, como o controlo automático de um portão, o oscilador interno responde bem as

necessidades pretendidas, mas se for necessária uma base de tempo mais precisa a uma grande

velocidade o mais correcto é escolher um cristal de quartz de alta velocidade. Para aplicações cuja base

de tempo é indispensável, podemos colocar externamente um relógio de tempo real (RTC).

Para implementar um oscilador de cristal, basta ligar os terminais do cristal aos pinos OSC1 e

OSC2 juntamente com um par de condensadores conforme a figura seguinte.

OSC1

OSC2

Cristal

C

C

Fig 5 - Implementação do oscilador de cristal.



O valor dos condensadores depende do valor e tipo de cristal escolhido. A tabela seguinte

mostra os valores recomendados pelo fabricante do microcontrolador.

Tipo de oscilador Frequência Valor de C em pF

LP 32 Khz 30

XT 1 Mhz 15

4 Mhz 15

HS

4 Mhz 15

10 Mhz 15

20 Mhz 15

25 Mhz 15

Tabela 5 - Valor dos condensadores para os diferentes tipos de cristais.

Os osciladores EC e ECIO requerem uma fonte de relógio externo ligado no pino OSC1. Repare-

se que no modo EC obtemos uma fonte de relógio no pino OSC2, cuja frequência é um quarto do da

fonte. Este pino OSC2 pode ser usado para sincronizar periféricos externos. A figura 6 mostra a ligação

típica da fonte de relógio ao microcontrolador.

OSC1 / CLKI

OSC2 / CLKO

Clock

Clock / 4

Fig 6 - Implementação do oscilador por fonte de relógio externo.

O oscilador RC é usado para aplicações em que a base de tempo não é relevante, sendo a sua

implementação feita a partir de um circuito simples constituído por uma resistência e um condensador.

Neste oscilador a frequência de oscilação depende da tensão de alimentação, dos valores da resistência,

do condensador, e da temperatura de funcionamento. Pode acontecer também que para os mesmos

componentes, dois dispositivos diferentes tenham frequências de oscilação diferentes. Esta situação

acontece devido às variações de fabrico dos componentes, quer do microcontrolador ou da resistência e

do condensador.



Também neste tipo de oscilador é possível obter uma saída de relógio, cuja frequência é um

quarto da frequência gerada pelo oscilador RC. A figura 7 mostra o circuito típico para a implementação

do oscilador RC.

OSC1

OSC2Clock / 4

C

R

VCC

Fig 7 - Implementação do oscilador RC.

Os valores recomendados para a resistência e o condensador são ,

e a frequência de oscilação pode ser calculada pela expressão f = 1 / RC.

O uso do multiplicador de frequência apenas pode ser usado quando o tipo de oscilador é de

cristal de alta velocidade ou então com o oscilador interno. Com esta opção é possível utilizar um cristal

de frequência mais baixo e colocar o microcontrolador a funcionar a uma frequência muito mais alta,

repare que a frequência máxima permitida pelo microcontrolador é de 40 Mhz, por essa razão quando

pensar em utilizar esta opção, o cristal de alta velocidade não deve ultrapassar os 10 Mhz. Um exemplo

típico pode ser a necessidade de utilizar uma fonte de relógio proveniente do microcontrolador, para

sincronismo de periféricos externos. Nesse caso para não limitar a frequência de oscilação do

microcontrolador podemos usar o multiplicador de frequência para obter uma maior frequência de

oscilação no microcontrolador e uma frequência mais baixa para o sincronismo.

Uma das vantagens que o microcontrolador escolhido nos apresenta, é o facto de incorporar

um oscilador interno, com capacidade de gerar uma frequência de oscilação até aos 32 Mhz. O gerador

de relógio interno, pode ser uma ideia interessante quando se pretende reduzir custos com cristais ou

outras fontes relógio externas. Existem duas fontes de relógio do oscilador interno, a primeira é uma

fonte relógio de 8 Mhz com capacidade de gerar frequências de 31 Khz até 4 Mhz, a segunda é uma

fonte de relógio proveniente de um oscilador RC interno configurado para gerar uma frequência de

31Khz.

Apesar do oscilador interno ser um pormenor a considerar, não nos podemos esquecer da

influência da temperatura na frequência gerada. O próprio microcontrolador incorpora um registo o

OSCTUNE onde uma possível função é calibrar a frequência de oscilação em função da temperatura. Esta

calibração não é automática, sendo necessário criar um programa e inserir um sensor de temperatura

no nosso hardware para ser possível calibrar a frequência de oscilação em função da temperatura.



A figura 8 mostra o diagrama de blocos do módulo de configuração do oscilador, em que

facilmente podemos verificar os componentes que integram o módulo de configuração do oscilador.

Fig 8 - Diagrama de blocos do módulo de configuração do oscilador [1].

Pelo diagrama de blocos, podemos verificar no canto superior esquerdo os pinos das fontes

externas de relógio, tanto do oscilador principal como do oscilador secundário, no centro superior

podemos verificar o multiplicador de frequência e o seu registo associado. Repare que no diagrama de

blocos é possível verificar que tipos de oscilador é permitido usar com o multiplicador de frequência. Na

parte inferior podemos visualizar os componentes do oscilador interno e o seu registo de configuração,

outra informação que podemos obter pela análise do diagrama de blocos é os registos associados ao

controlo da configuração do oscilador. Repare que é possível internamente, pela manipulação de

registos de configuração do sistema do oscilador, alterar a frequência de clock a meio de um programa

de acordo com as especificações da aplicação, mas esta possibilidade apenas é possível a quando do uso

do oscilador interno.

Os registos associados ao controlo da configuração oscilador são:

OSCCON – Registo de controlo do oscilador;

OSCTUNE – Registo de calibração do oscilador.



Configuração do hardware.

Os microcontroladores PIC, possuem uma posição de memória, situada após o final da memória

de programa, que serve para armazenar as configurações de hardware interno do microcontrolador.

Nesta zona encontram-se registos, cuja função é configurar o hardware de acordo com a aplicação

pretendida. A tabela 6, mostra os registos e a sua função. As diferentes famílias de microcontroladores

PIC, possuem distintas palavras de configuração, isto é, para cada microcontrolador, convêm consultar o

seu respectivo datasheet para confirmar os registos e funções, para posteriormente serem

configurados.

Endereço Nome Função

0x300001 CONFIG1H Configuração do oscilador.

0x300002 CONFIG2L Configurações de reset e alimentação.

0x300003 CONFIG2H Configuração do Watchdog (WDT)

0x300005 CONFIG3H Configuração da função de pinos IO.

0x300006 CONFIG4L Configuração da programação por ICSP.

0x300008 CONFIG5L Protecção de dados na memória FLASH.

0x300009 CONFIG5H Protecção de dados na memória EEPROM.

0x30000A CONFIG6L Protecção de escrita na memória FLASH.

0x30000B CONFIG6H Protecção de escrita na memória EEPROM.

0x30000C CONFIG7L Protecção de dados.

0x30000D CONFIG7H Protecção de dados.

0x3FFFFE DEVID1 Identificação do dispositivo.

0x3FFFFF DEVID3 Identificação do dispositivo.

Tabela 6 - Registos da palavra de configuração do microcontrolador.

7 6 5 4 3 2 1 0CONFIG2H

Postscale WDTHabilita o WDT

7 6 5 4 3 2 1 0CONFIG3H

Habilita o pino 1 como MCLRConfiguração do oscilador do Timer1

Selecciona o PortoB como IO ou ADCSelecciona o CCP2 no pino RC1 ou RB3

7 6 5 4 3 2 1 0CONFIG1H

Activa a transição do oscilador interno para externo

Activa a monitorização do relogioSelecção do oscilador

7 6 5 4 3 2 1 0CONFIG2L

Selecção da tensão de referencia para BORHabilita o reset por BORHabilita o reset por PWRT



7 6 5 4 3 2 1 0CONFIG4L

Habilita a programação por ICSP, pinos RB6 e RB7 dedicados ao ICSPHabilita a instrução extensaHabilita a alimentação por ICSPReset causado pela Stack

7 6 5 4 3 2 1 0CONFIG5L

Habilita a protecção de leitura do código de programa

7 6 5 4 3 2 1 0CONFIG5H

Habilita a protecção de leitura do código BOOT

Habilita a protecção de leitura da EEPROM

7 6 5 4 3 2 1 0CONFIG6L

Habilita a protecção de escrita no código de programa

7 6 5 4 3 2 1 0CONFIG6H

Habilita a protecção de escrita no código BOOTHabilita a protecção de escrita na EEPROMHabilita a protecção de escrita na palavra de configuração

7 6 5 4 3 2 1 0CONFIG7L

Habilita a protecção de leitura feita a partir de outros blocos

7 6 5 4 3 2 1 0CONFIG7H

Habilita a protecção de leitura do BOOT, a partir de outros blocos

Sistema de reset.

O sistema de reset do microcontrolador PIC, é responsável por iniciar a CPU e periféricos, após

um dos seguintes eventos:

Alimentação inicial do µC (POR), um circuito detecta a subida de tensão de alimentação e

mantém o reset até esse valor atingir o valor nominal;

VCCn

VCC

RESET

Fig 9 - Reset por alimentação inicial do µC.



Temporizador de inicialização (PWRT), um circuito mantém o reset durante um período de

tempo, cerca de 66ms após a alimentação inicial do µC, para activar o PWRT é necessário

activar o bit PWRT da palavra de configuração, registo CONFIG2L;

VCCn

VCC

TPWRT

RESET

Fig 10 - Reset devido a alimentação inicial do µC.

Arranque do oscilador (OST), um determinado tempo é anexo ao tempo total de reset do

µC, para a estabilização do oscilador externo.

VCCn

VCC

TPWRT

RESET

TOST

Fig 11 - Reset devido a estabilização do oscilador.

Queda de alimentação (BOR), quando o circuito detecta um valor abaixo de um

determinado valor de referência, especificado pelos bits BORV0 e BORV1, no registo

CONFIG2L, gera um reset ao µC.

VCC

RESET

Vref

Fig 12 - Reset gerado por queda de tensão.



Reset provocado pelo watchdog (WDT). O watchdog é um temporizador, cuja função é

gerar um reset, para que o programa não entre num ciclo infinito e bloqueie o sistema.

A figura seguinte mostra, o diagrama de blocos do circuito de reset.

Fig 13 - Diagrama de blocos do circuito de reset [1].

Pelo diagrama de blocos, podemos verificar que, além dos eventos acima referidos, é possível

também por software através da instrução RESET, gerar reset ao µC. Repare ainda que, ocorre um reset,

quando ocorre um “overflow” da pilha de desvio de programa (Stack Pointer).

A verificação da origem do reset, pode ser efectuada através do registo RCON, pois a origem do

evento apaga a sua respectiva flag no registo, devendo o utilizador voltar a colocar a “1” por software.

Reset por queda de tensão

7 6 5 4 3 2 1 0RCON

Reset causado pela inicializaçãoReset por WDT

Reset causado pela instrução RESET

Fig 14 - Origem do evento de reset.


Bernardino Neves - 2011 Página 17 Ambiente de programação MPLAB IDE

Ambiente de programação MPLAB IDE.

Introdução ao sistema integrado MPLAB.

A Microchip possibilita a utilização de diferentes sistemas de desenvolvimento, desde

compiladores, programadores, etc., todos eles controlados por uma única ferramenta de

desenvolvimento, o sistema integrado MPLAB. Este sistema inclui todos os utilitários necessários para

desenvolver qualquer projecto, assim sem sair da janela principal, tem-se acesso a qualquer utilitário

quer de hardware ou software de um modo simples e rápido.

Depois de se criar um programa é possível executá-lo através do simulador. A simulação é feita

passo a passo de um modo animado ou de forma contínua, sendo possível parar o seu funcionamento

em qualquer momento, tanto para verificar o estado de registos ou mesmo para os alterar para de

seguida voltar a executar a simulação com as modificações efectuadas.

Instalação do MPLAB.

Para instalar o MPLAB IDE, é necessário descarregar através da internet, na página da Microchip

(www.microchip.com) o software de desenvolvimento MPLAB IDE. Ao entrar na pagina Web da

Microchip, na sua pagina principal encontra-se um link com o nome de MPLAB IDE. Nessa página a

Microchip faz uma apresentação do MPLAB IDE e no final é possível descarregar o software. Após

descarregar o software MPLAB IDE, passamos à etapa seguinte que é a instalação. Numa primeira fase é

necessário descompactar o ficheiro recebido, e após este passos encontramos os ficheiros que se

mostra na figura 15.

Fig 15 - Ficheiros descompactados.

Para instalar a aplicação é necessário executar o ficheiro SETUP.exe, nas três janelas seguintes

deverá seleccionar o botão NEXT. A primeira janela é uma janela de boas vindas, a segunda é a

aceitação dos termos da licença de instalação e a terceira é a selecção por defeito de instalação

completa, como mostra a figura 16.

http://www.microchip.com/


Página 18 Bernardino Neves – 2011 Ambiente de programação MPLAB IDE

Fig 16 – Selecção da instalação completa.

Após a selecção de instalação completa, chega o momento de indicar o local onde se deve

instalar o software MPLAB IDE, pode aceitar a sugestão por defeito ou então seleccionar outra directoria

para a instalação, no final deve pressionar o botão NEXT, para executar a instalação.

Fig 17 - Localização do ficheiro de instalação.

Volte a pressionar o botão NEXT até aparecer a janela de progresso da instalação.


Bernardino Neves - 2011 Página 19 Ambiente de programação MPLAB IDE

Fig 18 - Janela de progresso da instalação.

No final da instalação irá aparecer uma janela a perguntar se pretende instalar o software HI-

TECH Software, fica ao vosso critério a sua instalação. No final da instalação é necessário reiniciar o

computador para finalizar a instalação.


Página 20 Bernardino Neves – 2011 Ambiente de programação MPLAB IDE


Bernardino Neves - 2011 Página 21 Compilador C18

Compilador C18.

Instalação do compilador C18.

Neste momento, já tem instalado o MPLAB IDE. O próximo passo é instalar o compilador C18 da

Microchip, que irá permitir compilar os programas desenvolvidos em linguagem C.

Existe uma versão para estudantes do compilador C18, o qual deve descarregar da pagina Web

da Microchip, que só permite a optimização de código até um limite de 30 dias, e neste caso para os

programas propostos a optimização de código não será um factor relevante.

A instalação do compilador C18 requer alguma atenção, para o efeito detalha-se de seguida

todos os passos requeridos na instalação.

Numa primeira fase devesse seleccionar o directório onde deve ficar o compilador, devendo-se

aceitar a sugestão que aparece na janela, porque mais tarde será necessário referenciar alguns ficheiros

desse directório e assim torna-se mais simples.

Fig 19 - Localização da instalação do compilador C18.

Na próxima janela, a figura 20 aparecem os componentes que se pretende instalar, devendo-se

instalar todos os componentes, como mostra a figura seguinte.

Fig 20 - Selecção dos componentes do compilador C18.


Página 22 Bernardino Neves – 2011 Compilador C18

Na próxima janela, a figura 21 deve seleccionar os três primeiros itens da configuração das

variáveis de ambiente.

Fig 21 - Configuração das variáveis.

A janela seguinte, a figura 22 diz respeito a ligação do MPLAB IDE ao compilador C18, devendo

seleccionar todos os itens.

Fig 22 - Ligação do MPLAB IDE ao compilador C18.

Nas próximas janelas que visualizar durante a instalação pressione o botão NEXT até concluir a

instalação. Após a instalação do compilador C18, já se encontra com as ferramentas necessárias para o

desenvolvimento de programas para os microcontroladores da Microchip. Mas ainda é necessária a

integração do compilador com o MPLAB IDE.



Especificações do compilador C18.

Tal como qualquer compilador, o compilador C18 tem as suas especificações.

Tipo e tamanho de variáveis.

O compilador C18 suporta o standard ANSI na definição de tipos de inteiros, a tabela 7 mostra o

tipo de variáveis, o seu tamanho e limites.

Tabela 7 - Tipo de variáveis, o seu tamanho e limites.

Quanto ao tipo de armazenamento de dados, o compilador C18 permite três tipos diferentes de

armazenamento de dados:

Armazenamento por tipo de dados;

Armazenamento por classes;

Armazenamento por qualificadores.

De seguida detalha-se pormenores referentes a estes três tipos.

Armazenamento por tipo de dados.

Numa variável com vários bytes o byte menos significativo esta alocado no endereço menos

significativo, por exemplo, se definirmos uma posição de memória do microcontrolador e queremos

escrever o conteúdo de uma variável do tipo long, o compilador aloca o byte menos significativo no

primeiro endereço e os restantes nas posições seguintes até atingir o byte mais significativo.

Exemplo:

#pragma idata teste=0x0200

long i=0xAABBCCDD;

Tipo Tamanho Mínimo Máximo

char 8 -128 127

unsigned char 8 0 255

int 16 -32.768 32.768

unsigned int 16 0 65.535

short 16 -32.768 32.768

unsigned short 16 0 65.535

short long 24 -8.388.608 8.388.607

unsigned short long 24 0 16.777.215

long 32 -2.147.483.648 2.147.483.648

unsigned long 32 0 4.294.967.295

Endereço 0x0200 0x0201 0x0202 0x0203

Conteúdo 0xDD 0xCC 0xBB 0xAA



Armazenamento por classes - Overlay.

A classe de armazenamento por sobreposição “overlay” apenas é permitida quando o

compilador está a operar no modo “Non-Extended”, pode ser aplicado a variáveis locais, mas não a

parâmetros, a definições de funções e a variáveis globais. A classe de armazenamento por sobreposição

associa símbolos dentro de funções específicas, isto é, uma variável definida dentro de uma função

apenas é valida dentro dessa função.

Exemplo:

void e (void)

{

overlay int X = 5;

X++;

}

void f (void)

{

overlay int Y = 2;

Y++;

}

Neste exemplo, se o compilador ao compilar o programa detectar que não executa estas duas

funções em simultâneo, a classe de armazenamento por sobreposição aloca a mesma posição de

memória para as duas variáveis definidas.

Outros tipos de armazenamento por classes são:

Auto – Define a variável como local, por defeito todas as variáveis são locais;

Extern – Define variáveis externas ao programa;

Register – Indica ao compilador que a variável é um registo do CPU;

Static – Define uma variável que ocupa uma posição permanente na memoria.

Armazenamento por qualificadores.

O compilador C18 tem como qualificadores de armazenamento de dados o far, near, rom e

ram, estes qualificadores tem a mesma função que const e volatile em ANSI C, isto é, é possível definir o

tipo de variável e o seu acesso.



A tabela seguinte mostra a localização das variáveis em função dos qualificadores.

Qualificador rom ram

far Em qualquer lugar na memória de

programa. Em qualquer lugar na memória de dados.

near Em memória de programas inferiores a

64KBytes. No acesso à memória.

Tabela 8 - Localização das variáveis em função dos qualificadores.

Em variáveis tipo ponteiros, os mesmos podem apontar tanto para posições de memória ram

ou rom. O tamanho do ponteiro depende do tipo de variável para qual aponta, isto é se apontar para

memoria de dados tem o tamanho de 16 bits, se apontar para memória de programa terá 24 bits. Por

defeito quando se define uma variável tipo ponteiro esta aponta para memória de dados, se quisermos

apontar para memória de programa temo de colocar o qualificador rom.

Tipo de ponteiro Exemplo Tamanho

Memória de dados char *a; 16 bits

near – Memória de programa rom near char *a; 16 bits

far – Memória de programa rom near char *a; 24 bits

Tabela 9 - Tamanho dos ponteiros.

Incluir ficheiros - #INCLUDE

A inclusão de ficheiros no nosso código fonte é feita a partir do uso da directiva do compilador

#Include, quando queremos incluir um ficheiro de sistema (System Header File) devemos usar a directiva

do seguinte modo #Include <Nome _do_ficheiro>, porque como se trata de um ficheiro de sistema o

compilador vai procurar na pasta INCLUDES do compilador, entretanto se for um ficheiro de cabeçalho

criado pelo usuário devemos usar a directiva do seguinte modo #Include “Nome _do_ficheiro”, porque

neste caso o compilador vai procurar o ficheiro dentro da pasta do projecto.

Macros predefinidas do compilador C18.

O compilador C18 tem predefinido as seguintes macros.

_18CXX – Indica que o compilador é o MPLAB C18;

_18F4620 – Indica ao compilador qual o microcontrolador a ser utilizado;

_TRADITIONAL18_ – Modo “Non-extended”;

_EXTENDED18_ – Modo “Extended”.



A directiva #PRAGMA.

Esta directiva serve para indicar ao compilador C18 que um determinado código se encontra

alocado numa especifica posição de memoria, essas secções de memoria tanto podem ser de dados

como de programa. Existem dois tipos de secções dependendo do tipo de memória.

Memória de programa:

code – contem instruções de execução.

romdata – contem variáveis e constantes.

Memória de dados:

udata – contem variáveis estáticas não inicializadas.

idata – contem variáveis estáticas inicializadas.

Exemplo:

#pragma code hight_vector = 0x08

…

…

#pragma code

A primeira linha de código faz o compilador desviar o programa para o endereço 0x08, a

segunda linha de código faz o compilador voltar a posição de endereço de memória de programa onde

estava antes do desvio.



Directivas do compilador C18.

As directivas são instruções de como deve ser compilado o código fonte. O compilador C18 tem

as seguintes directivas disponíveis (Tabela 10):

Directiva Descrição Exemplo

#define

Define uma constante que será

substituída dentro do código fonte

pelo seu valor, quando for

compilado.

#define Maximo 100

#define Nome “Jose”

#define Area(x,y) x*y

#if Executa uma condição se for

verdadeira.

#define Max 10

#define T 3

#if defined(Max) && defined(T)

#if (Max * T) > 50

#error “error …”

#else

#define Novo Max*T

#endif

#endif

#ifdef MAX

Contador = MAX;

#ifndef MAX

#define MAX 100

#elif Directiva associada a directiva #if e

#else.

#endif Directiva associada a directiva #if.

#error

Directiva que gera uma mensagem

de erro definida pelo usuário, a

mensagem aparece no output do

compilador.

#else Directiva associada a directiva #if .

#ifdef Executa se uma expressão estiver

definida.

#ifndef Executa se uma expressão não

estiver definida.

#include Directiva para incluir ficheiros no

código fonte

#include “main.h”

#pragma Esta directiva desvia o programa

para um endereço especificado

#pragma code

#pragma config Configura a palavra de configuração. #pragma config OCS = HS

#undef

Esta directiva serve para que uma

constante deixe de estar definida.

#define Maximo 10

….

#undef Maximo

#define Maximo 20

Tabela 10 - Directivas do compilador C18.

Livrarias de funções do compilador C18.

O compilador C18 disponibiliza quatro tipos de livrarias de funções. Nas tabelas seguintes (12,

13 e 14) mostra-se a descrição dos quatro tipos de livrarias e assim como também a sua respectiva

descrição. Num dos capítulos mais adiante serão detalhados as livrarias das funções de software e

hardware de um modo mais aplicado, pretendendo-se que neste momento o leitor tenha apenas uma

ideia abrangente sobre as funções disponibilizadas pelo compilador C18.



Nome Descrição

math.h Funções matemáticas.

Tabela 11 – Livraria de funções de matemática.

Nome Descrição

ctype.h Classificação do tipo de caracteres.

stdlib.h Conversão de dados.

string.h Manipulação de memória e strings.

delays.h Funções para gerar atrasos.

reset.h Funções de reset.

stdio.h Funções de output de caracteres.

Tabela 12 - Livrarias de funções gerais.

Nome Descrição

xlcd.h Funções de controlo de LCD

can2510.h Funções de controlo do controlador CAN2510.

sw_i2c.h Funções de controlo e comunicações por I2C.

sw_uart.h Funções de controlo e comunicações por UART.

sw-spi.h Funções de controlo e comunicações por SPI.

Tabela 13 - Livrarias de funções de software.

Nome Descrição

adc.h Funções de suporte ao periférico ADC.

capture.h Funções de suporte ao periférico captura.

i2c.h Funções de suporte ao periférico I2C.

portb.h Funções de suporte ao periférico PORTB.

mwire.h Funções de suporte ao periférico Microwire.

pwm.h Funções de suporte ao periférico PWM.

spi Funções de suporte ao periférico SPI

timers.h Funções de suporte ao periférico TIMERS

usart.h Funções de suporte ao periférico UART

Tabela 14 - Livrarias de funções de hardware.


Bernardino Neves - 2011 Página 29 Primeiros passos com o MPLAB IDE

Primeiros passos com o MPLAB IDE.

Criar e configurar um projecto no MPLAB IDE.

Agora que já tem instalado o MPLAB IDE e o compilador C18, chega o momento de dar os

primeiros passos, para começar execute a aplicação MPLAB IDE. Crie um novo projecto seleccionando

Project -> Project Wizard…, como mostra a figura 23.

Fig 23 - Criar uma novo projecto.

O Project Wizard ajuda-nos a criar e a configurar um novo projecto, seleccione seguinte após a

janela de boas vindas e seleccione o microcontrolador PIC18F4620 que será o microcontrolador, que

iremos usar em todos os exemplos, repare que em futuros projectos pode escolher o microcontrolador

que desejar.

Após seleccionar o microcontrolador chega o momento de seleccionar o compilador C18, para a

nossa linguagem de programação, neste caso seleccionamos o Microchip C18 ToolSuite, como mostra a

figura 24.

Fig 24 - Selecção do compilador C18.


Página 30 Bernardino Neves – 2011 Primeiros passos com o MPLAB IDE

Se por acaso, quando chega a esta janela e não aparece o compilador C18, ou é porque não foi

instalado correctamente ou o MPLAB IDE não o encontra, nesse caso deve indicar a localização através

do botão Browse… , tendo em atenção que é necessário indicar a localização dos quatro executáveis

MPASM, MPLINK, MPLAB C18 e o MPLIB.

O passo seguinte é criar e escolher uma localização para o ficheiro do novo projecto, vamos

escolher o nome de Exemplo1 para o nosso projecto, no final seleccione o botão seguinte, a próxima

janela pergunta se temos ficheiros para adicionar ao nosso projecto, como não temos passamos para a

janela seguinte que nos indica a conclusão da configuração do nosso projecto, indicando os parâmetros

do projecto (Figura 25).

Fig 25 – Conclusão da configuração do projecto.

Por fim seleccionamos o botão Concluir e teremos o nosso primeiro projecto criado, de seguida

é necessario inserir o ficheiro para editarmos o código em linguagem C. Para o efeito crie um novo

ficheiro em New File. Para gravar o ficheiro seleccione a página fazendo um click sobre a mesma e de

seguida no menu File seleccione a opção Save As… , escolha a localização do projecto e um nome para o

ficheiro e não se esqueça de o terminar com o “.C”.

Agora que tem o ficheiro gravado é necessário inseri-lo no projecto, deve seleccionar a pasta

Source Files com o botão direito do rato e seleccionar o item Add Files…, procure a pasta que contem o

projecto e seleccione o ficheiro *.C, as figuras 26 e 27 mostram os passos a seguir.

Fig 26 - Pasta Source Files.



Fig 27 - Janela para adicionar ficheiros ao projecto.

O MPLAB IDE permite guardar o último ambiente de trabalho, para o efeito quando fecha o

aplicativo MPLAB IDE recebe uma mensagem a perguntar se pretende guardar o ambiente de trabalho,

o qual deve responder que sim. A figura 8 mostra o ambiente de trabalho pretendido, repare que

conforme o desenrolar do desenvolvimento do projecto, mais janelas terão de ser adicionadas ao nosso

ambiente de trabalho.

Fig 28 - Ambiente de trabalho.



Primeiro programa.

Já criamos um projecto, agora vamos criar um pequeno programa com o objectivo de mostrar

como deve ser o corpo do código no editor de texto antes de ser compilado. Pretende-se também dar a

conhecer as ferramentas de simulação que o MPLAB disponibiliza, e ainda a manipulação de registos e a

simulação de sinais nos pinos do microcontrolador.

Abra o projecto do exemplo anterior e copie o código que se encontra na tabela 15, para o

editor de texto.

#include <p18f4620.h> //Declaração de definições #define SaidaTRIS (TRISBbits.TRISB7) #define SaidaIO (LATBbits.LATB7) //Declaração de variaveis int i=0; void main (void) { SaidaTRIS = 0; SaidaIO = 0; while(1) { SaidaIO ^= 1; i++; } }

Tabela 15 - Código do ficheiro do exemplo.

Depois de escrito o programa é necessário compilar, para o fazer basta pressionar a tecla de

acesso rápido F10 ou no icon MAKE, como mostra a figura 29.

Fig 29 - Localização do icon Make.

Ao compilar verificamos que não existem erros, caso existissem os mesmos apareciam na janela

OUTPUT, chega o momento de testar o nosso primeiro programa, para isso devemos activar o

simulador. O simulador encontra-se no menu Debugger -> Select tool -> 5 MPLAB SIM , como mostra a

figura 30.



Fig 30 - Seleccionar o simulador MPALB SIM.

Com o simulador activado, já podemos testar o nosso primeiro programa, mas antes disso

convêm explicar como funciona o simulador MPLAB SIM, já deve ter verificado que quando activou o

simulador, que apareceram no ambiente de trabalho uns novos icons, são os botões de controlo do

simulador, a figura 31 mostra o significado de cada um deles.

Inicia a simulação do programa.

Pausa da simulação do programa.

Executa passo a passo o programa.

Inicia a simulação no modo animado do programa.

Executa o conteúdo da função.

Faz reset ao programa.

Coloca breakpoints no programa.

Executa ate ao fim da função.

Fig 31 - Comandos do simulador MPLAB SIM.

O que o programa exemplo faz é mudar o estado do pino 7 do porto B e incrementar o

conteúdo da variável i em cada ciclo do while, o mesmo pode ser verificado quando se pressiona o icon

de simulação no modo animado. Abra a janela File Registers e Special Function Registers, no menu View

e seleccione o endereço 0xF8A da janela Special Function Registers e o endereço 0x084 da janela File

Registers. No modo de simulação animado é possível verificar o estado do bit 7 do porto B a comutar de

estado e o incremento da variável i em cada ciclo do while, ver figura 34.



Fig 32 – Selecção da janela File Registers e Special Function Registers.

Modificar o conteúdo de registos e variáveis.

Agora vamos alterar o valor da variável i, para o efeito coloque o simulador em pausa, click em

cima do conteúdo da variável, neste caso na coluna decimal e altere o valor para um a sua escolha, de

seguida volta a colocar o simulador no modo animado, pode reparar que a variável i incrementou uma

unidade.

Uma outra janela que nos permite ter acesso e alterar o conteúdo de variáveis e registos é a

janela Watch. Nesta janela é possível visualizar mais dados sobre as variáveis, tal como o endereço em

que está alocado, para podermos visualizar uma variável é necessário inseri-la como mostra a figura 33.

Fig 33 - Inserir uma variável para se ter acesso aos seus parâmetros.

Repare que a janela Watch tem dois botões de adição de registo, o Add SFR é para adicionar

registos especiais e o botão Add Symbol é para adicionar variáveis, a janela 34 mostra os dados que

pretendemos observar.



Fig 34 - Janela Watch.

Parar o programa num determinado sitio especifico – Breakpoint.

O simulador MPLAB SIM permite a inserção de breakpoint’s, já deve ter reparado que quando

inicia o programa no modo animado, ele primeiro executa um código e só passado algumas linhas de

código é que executa o nosso código do programa exemplo, podemos passar essas linhas de código

rapidamente inserindo um breakpoint no inicio do nosso programa e iniciando a simulação no modo

continuo. Quando o simulador encontrar o breakpoint pára a simulação, e nesse caso, retiramos o

breakpoint e passamos para a simulação no modo animado.

Repare que se pode colocar um breakpoint em qualquer lugar do nosso programa, onde

pretendemos que o simular pare para podermos analisar registos e variáveis.

Tempo de execução.

Às vezes é necessário saber o tempo exacto que demora umas linhas de código a correr, o

simulador permite através da janela StopWatch determinar esse tempo de modo exacto, antes de

utilizarmos a janela StopWatch é necessário definir a frequência de clock do microcontrolador que

servirá de base de tempo para o simulador, o mesmo pode ser definido na janela Settings cujo caminho

é Debugger -> Settings no item Osc/Trace.

Fig 35 - Definição da frequência de clock, base de tempo do simulador MPLAB SIM.

Agora que já temos definido a base de tempo para o simulador, podemos verificar o tempo que

demora a executar um determinado conjunto de linhas de código. Como exemplo vamos verificar o

tempo que demora a executar 25 ciclos de while no nosso programa. Abra a janela StopWatch, cujo

caminho é Debugger -> StopWatch e reinicie o contador pressionando o botão Zero.



Fig 36 – Exemplo, determinação do tempo de execução.

Este exemplo não permite determinar o tempo exacto, pois seria necessário colocar dentro do

while código que verificasse o conteúdo da variável i em cada ciclo, mas no entanto podemos obter uma

boa aproximação do tempo de execução. Para executar o nosso exemplo coloque um breakpoint como

mostra a figura e simule no modo contínuo, quando o simulador parar no breakpoint, reinicie o

simulador no modo animado e espere até que o conteúdo da variável i seja igual a 25 decimal. Nesse

momento faça pausa no simulador e verifique o tempo que demorou a executar os 25 ciclos de while na

janela StopWatch. A figura 37 mostra o resultado do tempo obtido.

Fig 37 - Resultado do tempo de execução do exemplo proposto.



O simulador STIMULUS.

Outra ferramenta que o MPLAB IDE nos disponibiliza para simulação é o simulador STIMULUS,

trata-se de um simulador que permite gerar estímulos em pinos do microcontrolador, isto é, geramos

um estímulo num pino do microcontrolador e verificamos o efeito no nosso programa. Para verificar

esta funcionalidade precisamos de um novo exemplo, nomeadamente, vamos desenvolver um

programa que leia o estado do pino 7 do porto B, se for zero incrementa uma variável, se for um

incrementa outra variável. A tabela 16 mostra o código do nosso segundo exemplo.

#include <p18f4620.h>

//Declaração de definições

#define SaidaTRIS (TRISBbits.TRISB7)

#define SaidaIO (PORTBbits.RB7)

//Declaração de variaveis

int a=0;

int b=0;

void main (void)

{

SaidaTRIS = 1;

while(1)

{

if ( SaidaIO == 0)

{

a++;

}

else

{

b++;

}

}

}

Tabela 16 - Código do segundo exemplo proposto.

Criamos um novo projecto com o nome de Exemplo2 seguindo os passos em cima descritos

para o exemplo 1, colocamos o código da tabela acima no editor de texto e compilamos o nosso

segundo exemplo. Neste momento só falta configurar o simulador Stimulus. Para o efeito aceda ao

simulador pelo caminho Debugger -> Stimulus -> New Workbook, na janela Stimulus no separador

Asynch seleccione na coluna Pin/SFR o pino RB7, como mostra a figura 38 e selecciona o pino como um

lógico “Set High”.



Fig 38 - Janela de configuração do simulador Stimulus.

Salvamos o nosso ficheiro de simulação na pasta do projecto, e já podemos testar esta nova

funcionalidade. Coloque um breakpoint na linha de código “SaidaTRIS = 1;”, execute a simulação no

modo contínuo, quando o simulador parar no breakpoint, nesta altura já é possível verificar que o pino 7

do porto B se encontra no estado lógico um. Reinicie o simulador no modo animado e pode verificar que

o programa executa as instruções indicadas para quando o estado lógico é um, isto é, incrementa o

conteúdo da variável b, para verificar, abra a janela Watch e insira as variáveis a e b para as poder

monitorizar. Para mudar o estado do pino RB7 coloque em pausa o simulador e seleccione o pino como

zero lógico “Set low”, click no fire button que se localiza no lado esquerdo da caixa de texto que indica

RB7 e grave o ficheiro, neste momento o pino RB7 esta ser estimulado com o zero lógico, volte a

reiniciar a simulação animada e verifique que agora o programa executa as instruções indicadas para

quando o estado lógico é zero, as figuras seguintes mostram a localização do fire button e o resultado da

simulação.

Fig 39 – Localização do Fire Button.

Fig 40 – Resultado da simulação Stimulus.

Esta simulação podia ser feita de um modo contínuo se a selecção do estado do pino na coluna

action fosse Toggle, nesse caso basta pressionar o fire button que o estado do pino comutava de estado.



O logic analyzer.

Esta ferramenta de simulação permite analisar o estado dos pinos do microcontrolador em

função do tempo, para testar esta funcionalidade vamos voltar ao nosso primeiro programa, guarde o

projecto do exemplo 2 e volte a abrir o projecto do exemplo 1.

Volte a colocar um breakpoint na linha de código “SaidaTRIS = 0;” e simule no modo contínuo,

quando o simulador parar no breakpoint, seleccione o logic analyser através do caminho View ->

Simulator Logic Analyser, após pressionar o botão channel seleccione o canal RB7 como mostra a figura

seguinte.

Fig 41 - Selecção do canal a analisar.

Pressione o botão OK, e neste momento já tem o analisador lógico configurado, reinicie o

simulador no modo animado e verifique o estado do pino 7 do porto B em função do tempo, a figura

seguinte mostra o resultado.

Fig 42 - Resultado obtido pelo analisador lógico.



Depurador/Gravador PICKIT 3.

O PICKIT 3 é um simples depurador e programador de microcontroladores da Microchip, trata-

se de uma ferramenta de baixo custo, é baseado na programação serie em circuito (“ICSP”), isto é,

permite a gravação do microcontrolador inserido no seu próprio circuito. O depurador (“Debugger”)

permite executar o código como um dispositivo real, porque usa um dispositivo de emulação de circuito,

todos os recursos disponíveis de um determinado microcontrolador estão acessíveis de forma

interactiva e pode ser definida e modificada pela interface MPLAB IDE.

O Depurador/Programador PICKIT 3 tem como características principais, a execução de

instruções em tempo real, permitir que o microcontrolador trabalhe á frequência máxima e fornecer

alimentação ao circuito que se pretende programar ou testar.

A figura seguinte mostra o Depurador/Programador PICKIT 3.

1 – Botão de pressão (para uso futuro).

2 – Conector USB.

3 – Pino 1 do conector ICSP.

4 – Conector ICSP.

5 – Led’s indicadores de estado.

1

Fig 43 - Depurador/Programador PICKIT 3.

Fig 44 - Descrição dos pinos do conector ICSP.



Microcontrolador

VCC

VPP/MCLR

GND

PGD

PCG

Fig 45 – Ligação entre PICKIT 3 e o microcontrolador.

Integração do PICKIT 3 com o MPLAB IDE.

A integração do Depurador/Programador PICKIT 3 com o MPLAB IDE é muito simples, ao

conectar o PICKIT 3 ao PC por uma porta USB, o sistema operativo Windows reconhece logo o

dispositivo porque utiliza drivers standard do Windows. No entanto no MPLAB IDE é necessário activar o

PICKIT 3, dependendo da sua utilização de programador ou depurador.

Para activar o modo programador aceda ao caminho Programmer -> Select Programmer -> 4

PICkit 3 e active o programador, o modo depurador é activado pelo caminho Debugger -> Select Tool ->

3 PICkit 3, para verificar a integração do PICKIT 3 com o MPLAB IDE vamos abrir o projecto do exemplo

1, no menu File no item Open WorkSpace abra o ficheiro Exemplo1.mcw, antes de iniciar qualquer passo

é necessário desactivar o simulador MPLAB SIM, o mesmo pode ser feito acedendo pelo caminho

Debugger -> Select Tool -> None, agora já é possível activar o programador PICKIT 3, active o

programador e verifique na janela OUTPUT que o MPLAB reconheceu o programador PICKIT 3, aparece

uma mensagem de erro porque o PICKIT 3 não se encontra conectado a nenhum microcontrolador, a

figura seguinte mostra a janela OUTPUT.

Fig 46 - Verificação da integração do programador PICKIT 3 com o MPLAB IDE.

O mesmo procedimento deve ser feito para activar o modo depurador, repare que para activar

o modo depurador é necessário desactivar o programador.


Bernardino Neves - 2011 Página 43 Programação em C para microcontroladores

Programação em C, para microcontroladores.

Princípios de programação.

Antes de iniciar o estudo da linguagem C, é necessário relembrar conceitos básicos de

programação de sistemas, tais como a álgebra booleana, algoritmos e princípios de programação de

sistemas.

A programação consiste na tradução do pensamento lógico necessário para o cumprimento de

uma determinada tarefa, isto é, numa sequência de comandos que podem ser interpretados e

executados por uma máquina, neste caso um microcontrolador.

A programação constitui-se num processo de identificação e solução de problemas, para o

efeito, o programador recorre a um conjunto de procedimentos genéricos:

Exposição do problema.

Análise da solução.

Codificação da solução.

Tradução do código.

Verificação e teste.

Fluxogramas.

Os fluxogramas são ferramentas que nos ajudam a codificar um programa, são elementos

gráficos utilizados para estabelecer a sequência de operações necessárias para a execução de uma

tarefa. A tabela seguinte mostra os símbolos mais utilizados na construção de fluxogramas.

Inicio ou terminação

Tomada de decisão

Dados

Processo

Tabela 17 – Símbolos de fluxograma.


Página 44 Bernardino Neves – 2011 Programação em C para microcontroladores

Agora que já se conhecem os símbolos para construir um fluxograma, o passo seguinte é

construir um simples exemplo de aplicação com fluxogramas, o exemplo consiste em somar dois

números e verificar se o resultado é positivo, se sim activa uma saída, caso contrario activa outra saída.

Soma A + B

Resultado

positivo ?

Carrega A

Inicio

Carrega B

Activa

saída 1

Activa

saída 2

Fim

Fig 47 – Fluxograma do exemplo proposto.

Álgebra de booleana.

A álgebra booleana é um ramo da matemática, que tem como função a resolução de problemas

lógicos, é baseado em regras e conceitos lógicos simples, proposições e operadores lógicos relacionais.

Uma proposição é uma afirmação que pode ser classificada como sendo verdadeira ou falsa, duas ou

mais proposições podem ser relacionadas com o uso de operadores lógicos E, OU e NÃO.

A tabela seguinte mostra a tabela de verdade para os diferentes operadores lógicos:

A B E A B OU

0 0 0 0 0 0 A NÃO 0 1 0 0 1 1 0 1

1 0 0 1 0 1 1 0

1 1 1 1 1 1

Tabela 18- Operadores lógicos.



Variáveis e dados.

Uma variável é uma representação simbólica para elementos pertencentes a um conjunto, as

variáveis são armazenadas na memória do microcontrolador e pode assumir qualquer valor dentro dos

valores possíveis, repare que os valores possíveis estão definidos nas especificações do compilador. As

variáveis são classificadas segundo o tipo de conteúdo que armazena, podendo ser numéricas,

caracteres, alfanuméricas e lógicas.

Operadores.

Os operadores são elementos, para relacionar ou modificar dados ou variáveis, podemos

classificar os operadores em cinco categorias:

Matemáticos.

Relacionais.

Lógicos.

Lógicos bit a bit.

Memoria.

Introdução a linguagem C.

Palavras reservadas.

A linguagem C possui um conjunto de palavras reservadas ou comandos para os quais já existe

interpretação prévia pelo compilador, estas palavras não podem ser usadas, a tabela seguinte mostra as

palavras reservadas.

Auto Break Case Char Const Continue Default Do Double Else Enum Extern Float For Goto If Int Long Register Return Short Signed Sizeof Static Struck Switch Typedef Union Unsigned Void Volatile While

Tabela 19 – Palavras reservadas em programação em C.

Identificadores.

Um identificador é o nome dado às variáveis, funções e outros elementos da linguagem C, pode

ser composto por caracteres e letras, o único carácter permitido na construção de identificadores é o

sublinhado “_”, alem disso um identificador só pode ser iniciado por uma letra ou sublinhado, iniciar

com um número torna invalido o identificador.



Variáveis e tipos de dados.

Declaração de variáveis.

Na linguagem C, é necessário declarar as variáveis antes de as utilizar, declarar uma variável é

informar o compilador, que a variável chamada “X” é do tipo “Y”, na declaração de variáveis é

importante saber o local onde estamos a declarar a variável, pois a variável relaciona-se directamente à

acessibilidade ou não de outras partes do programa a essa variável.

As variáveis podem ser declaradas, em três pontos distintos do programa:

No corpo principal do programa, as variáveis são declaradas como globais, isto é, tem se

acesso ao seu conteúdo em qualquer parte do programa.

No corpo de uma função, as variáveis declaradas no corpo de uma função apenas são

validas dentro da mesma, tem o nome de variável local.

As variáveis podem ainda ser declaradas como um parâmetro formal de uma função,

trata-se de uma variável local especial.

Ainda existe outra forma de declarar variáveis, as variáveis externas, são utilizadas para

declarar variáveis que possam ser acedidas em todo o projecto, quando o mesmo é constituído por

vários ficheiros.

Exemplo:

unsigned char aux = 0x41;

unsigned int aux1 = 0x1234;

unsigned int aux2;

aux2 = 0x4321;

O código acima descrito, declara três variáveis, uma do tipo char e duas do tipo inteiro, repare-

se que as variáveis podem ou não ser inicializadas.

Declaração de constantes.

As constantes são valores fixos e que não podem ser alterados pelo programa, normalmente

usado para definir valores fixos.

Exemplo:

#define FREQ_CRISTAL (20000000) //20Mhz

unsigned long Clock;

Clock = FREQ_CRISTAL / 4;

O código acima descrito, define uma constante cujo valor é 20000000, que corresponde a

frequência do oscilador, esta constante pode ser utilizado para calcular a frequência de instruções do

µC.



Operadores.

Aritméticos.

Os operadores aritméticos são utilizados para efectuarem determinadas operações

matemáticas em relação a um ou mais dados, as linhas seguintes mostram alguns dos operadores

disponíveis na linguagem C para operações aritméticas.

a = 7;

b = 2;

Operador de adição.

c = a + b;

Operador de subtracção.

c = a – b;

Operador de multiplicação.

c = a * b;

Operador de divisão.

c = a / b;

Na divisão existe o operador resto “%”, que é utilizado para retornar o resto de uma operação

de divisão inteira.

c = a / b; c = 7 / 2 = 3 (Resultado para uma divisão inteira).

c = a % b; c = 7 % 2 = 1 (Resto da divisão inteira).

Operador incremento e decremento.

a++; (Incrementa o conteúdo da variável a uma unidade).

a -- ; (Decrementa o conteúdo da variável a uma unidade).

b = a++; (O valor de a é armazenado em b, e de seguida o valor de a é incrementado).

b = ++ a; (O valor de a é incrementado, e de seguida o valor de a é armazenado em b).

Relacionais.

Os operadores relacionais são usados para testes condicionais, para determinar a relação

existente entre dados, as linhas seguintes mostram os operadores relacionais e a sua acção.

Operador Acção Operador Acção > Maior que <= Menor ou igual a

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



Lógicos.

Os operadores lógicos são utilizados para realizar conjunções, disjunções ou negações entre

elementos num teste condicional, dos operadores lógicos apenas podem resultar um de dois valores,

verdadeiro ou falso.

Operador Acção && AND || OR ! NOT

x = 10;

If (x > 5 && x < 20)

{

y= x;

}

Dentro dos operadores lógicos, ainda existem os operadores lógicos bit a bit, que são utilizados

para realizar operações entre elementos ou variáveis, o resultado de uma operação lógico bit a bit, pode

resultar em um valor do mesmo tamanho dos elementos operados.

Operador Acção & AND | OR ^ XOR ~ NOT

>> Deslocamento a direita << Deslocamento a esquerda

Operador AND (&)

AND lógico entre dois números.

x1 = 100;

x2 = X1 & 20;

Decimal Binário 100 01100100

AND 15 00001111

Resultado 4 00000100

Desligar o bit0 de um porto sem interferir com os outros bits.

PORTB = PORTB & b11111110;

Que é equivalente a:

PORTB &= b11111110;

Com esta operação os restantes bits do porto não serão afectados.



Operador OR (I)

OR lógico entre dois números.

x1 = 100;

x2 = X1 I 20;


OR 15 00001111


Activar o bit0 de um porto sem interferir com os outros bits.

PORTB = PORTB & b00000001;

Que é equivalente a:

PORTB |= b00000001;

Com esta operação os restantes bits do porto não serão afectados.

Operador XOR (^)

XOR lógico entre dois números.

x1 = 100;

x2 = X1 ^ 20;


XOR 15 00001111


Operador NOT (~)

NOT lógico de um número.

x1 = 100;

x2 = ~x1;


Resultado da operação NOT 155 10011011

Operadores de deslocamento << e >>

x1 = 100;

x2 = x1 << 4;

x3 = x1 >> 4;

Variável Decimal Binário Deslocamento Resultado x2 100 01100100 << 4 01000000 x3 100 01100100 >> 4 00000110



Memoria.

Os operadores de memória, chamados de operadores de ponteiros, permitem o acesso directo

a qualquer endereço de memória do sistema, existem dois tipos de operadores, que são também

complementares.

O operador &, que retorna o endereço de memoria do seu operando.

O operador *, que retorna o conteúdo da posição de memoria endereçada, pelo operando que

o segue.

Exemplo:

unsigned int *endereço, x, y;

x = 5;

endereco = &x;

y = *endereco;

Neste exemplo podemos verificar, que o endereço da variável x foi copiado para a variável

endereço, que por sua vez na linha de código seguinte, copiou o seu conteúdo para a variável y, o

resultado é y = 5.

Associação de operadores.

A linguagem C, permite a associação de operadores, permitindo assim reduzir código, as linhas

seguintes mostram a forma expandida e a reduzida.

Em termos de operações de atribuição temos, no caso da forma expandida:

variável = variável (operando) valor (ou variável)

A forma reduzida reduz o comando a seguinte forma:

variável (operando) = valor (ou variável)

Forma expandida Forma reduzida x = x + y x += y x = x - y x -= y x = x * y x *= y x = x / y x /= y x = x % y x %= y x = x & y x &= y x = x | y x |= y x = x ^y x ^= y

x = x << y x <<= y x = x >> y x >>= y



Declarações de controlo.

As declarações de controlo, são ferramentas importantes nas linguagens de programação, pois

permitem testar condições e executar um código em função do resultado do teste da condição, também

permite a repetição de comandos enquanto uma condição se verificar verdadeira.

Comando IF.

O comando IF, é utilizado para executar um comando ou um bloco de comandos se uma

determinada condição for verdadeira. Normalmente é acompanhada pelo comando ELSE, que tem a

função de executar outro comando ou bloco de comandos caso a condição não seja verdadeira.

A forma geral é:

IF (condição)

{

Comando1;

Comando2;

Comando3;

}

ELSE

{

Comando3;

Comando4;

Comando5;

}

Exemplo:

int x = 5;

if ( x == 5)

{

Led0 = 1;

}

else

{

Led0 = 0;

}

O comando IF, não necessita de operador relacional ou lógico, porque apenas testa se a

condição é verdadeira ou falsa, em termos práticos se é zero ou diferente de zero.

int x = 5;

if ( x) Led0 = 1;

Como o valor de x é diferente de zero executa o comando Led0 = 1.



Comando SWITCH.

O comando SWITCH, é utilizado para comparações sucessivas, em termos práticos este

comando é uma espécie de comando IF mas para múltiplas comparações, sendo possível executar este

comando com comandos IF.

int x = 5;

switch (x)

{

case 1:

Comando 1;

break;

.

.

case 5:

Comando 5;

break;

.

.

case n:

Comando n;

break;

default:

Comando m;

break;

}

No comando SWITCH o valor da variável é testada com a constante especificada pela cláusula

case, no caso da variável e a constante terem o mesmo valor, os comandos da cláusula são executados,

caso não exista correspondência entre a variável e as constantes, então os comandos especificados pela

cláusula default serão executados, repare que é possível utilizar o comando SWITCH sem recorrer a

cláusula default, veja o exemplo seguinte. A cláusula break possui a função de terminar a sequência de

comandos de uma cláusula case.

switch (x)

{

case 0:

Led0 = 0;

break;

case 1:

Led0 = 1;

break;

}



Comando FOR.

O comando FOR é um dos comandos mais utilizados em estruturas de repetição, a forma geral

em linguagem C é a seguinte:

for ( inicialização ; condição ; incremento )

{

comando;

}

O que o comando FOR faz é, inicializar uma variável e executa tantas vezes um comando até

que a condição seja verdadeira, o incremento serve para incrementar a variável.

unsigned char a;

unsigned char b = 0;

for ( a = 0; a < 10 ; a++)

{

b++;

}

Dentro de um ciclo for é possível utilizar a cláusula break, que tem a função de quebrar o ciclo

FOR, repare ainda que é possível utilizar mais que uma variável de controlo dentro do ciclo for, exemplo

seguinte mostra como quebrar um ciclo for e o uso de várias varáveis de controlo do ciclo FOR.

unsigned char a, b ;

unsigned char c = 0 ;

for ( a = 0 , b = 0 ; a < 10 ; a++ , b ++)

{

if ( Led0 == 1 )

{

break;

}

c++;

}

Comando WHILE.

O comando WHILE, tem a função de executar o comando associado tantas vezes até

que a condição seja verdadeira ou tenha o valor lógico um. Também no comando WHILE é possível

quebrar o ciclo usando a cláusula break.

while ( condição )

{

comando;

}



Exemplo:

unsigned char a = 5;

while ( a != 0)

{

a--;

}

O teste a condição é efectuado considerando o seu resultado como verdadeiro ou falso, isto é,

se o resultado é zero ou diferente de zero, com este principio podemos verificar que, se o resultado da

condição for sempre um lógico, estamos perante um ciclo WHILE infinito.

while ( 1)

{

a--;

}

Neste exemplo em cima descrito, encontramos um ciclo infinito, provocado pelo comando

WHILE .

Comando DO-WHILE.

A diferença entre este comando e o comando WHILE, é que o comando WHILE verifica a

condição no inicio do ciclo e o comando DO WHILE verifica a condição no fim do ciclo. Tal como no

comando WHILE é possível utilizar a cláusula break para quebrar o ciclo. A forma geral e a seguinte:

do

{

comando;

} while ( condição );

Comando GOTO.

Por último temos o comando GOTO, este comando tem a função de desvio incondicional do

programa, apesar de ser um comando pouco usado em linguagem C, as vezes é utilizado para aumentar

a velocidade e eficiência do programa, repare que o comando GOTO tem a mesma função que a

instrução GOTO, disponível no conjunto de instruções dos microcontroladores PIC.

unsigned char a = 0;

loop:

a++;

if ( a < 10 )

{

goto loop;

}



Tipos e dados avançados.

Ponteiros.

Um ponteiro é uma variável que guarda um endereço de outra variável, isto é, um ponteiro é

um apontador para outra variável. Para explicar melhor este conceito de ponteiros vejamos o seguinte

exemplo.

Endereço Identificador Conteúdo

0xA000 X1 5

Pela tabela em cima representada, podemos verificar quais o endereços utilizados e o conteúdo

das variáveis alocadas nesses endereços. Por exemplo para obter o endereço da variável X1 usamos a

declaração seguinte:

Endereço = &X1;

Neste contexto o operador & retorna o endereço de memória da variável X1, que neste caso a

variável Endereço toma o valor de 0xA000, a variável Endereço é um ponteiro que aponta para a

variável X1.

No caso de ser necessário modificar o conteúdo da variável X1, através do ponteiro é possível

faze-lo usando a seguinte declaração:

*Endereço = 50;

Esta declaração fará com que o valor 50 seja atribuído á posição de memória apontada pelo

ponteiro Endereço. Com esta declaração a variável X1 passa a tomar o valor 50.

Como as variáveis tipo ponteiro, formam um novo tipo de dado, é necessário declará-las

explicitamente da seguinte forma:

Unsigned char *Endereço;

A declaração em cima descrita, cria uma variável tipo ponteiro com o nome Endereço, que

aponta para variáveis do tipo char sem sinal. A necessidade de indicar o tipo de variável, para o qual o

ponteiro aponta tem a ver com o facto de a linguagem C, permitir operações matemáticas envolvendo

ponteiros e essas operações são directamente influenciadas pelo tamanho do dado apontado pelo

ponteiro.

Exemplo:

unsigned char *Endereco, X1, X2;

X1 = 10;

Endereco = &X2;

*Endereco = X1 + 10;

Neste exemplo a variável X2 passou a ser apontada pelo ponteiro Endereço, todas as operações

efectuadas com o ponteiro *Endereco produz o mesmo efeito, se fosse utilizada a variável X2, o

resultado final será X2 = 20.



Matrizes de dados.

Uma matriz de dados é um conjunto de dados homogéneo referenciado por um identificador

único, entende-se por dados homogéneos variáveis ou dados do mesmo tipo, assim uma matriz é um

conjunto de variáveis do mesmo tipo e referenciadas pelo mesmo identificador.

A declaração de uma matriz em linguagem C é feita utilizando os colchetes [ ], em que o seu

conteúdo é o tamanho ou dimensão da matriz, repare que existem matriz de uma única dimensão e

matrizes de varias dimensões.

unsigned char a [5];

Esta declaração cria uma matriz do tipo char sem sinal, de dimensão 5, isto é, uma tabela de 5

elementos, em que cada elemento é indexado por um índice, iniciado pelo índice zero.

Identificador Endereço Conteúdo

a[ 0 ] 0x0A00 2

a[ 1 ] 0x0A01 4

a[ 2 ] 0x0A02 6

a[ 3 ] 0x0A03 8

a[ 4 ] 0x0A04 10

Exemplo:

unsigned char a [5];

unsigned char b;

for ( b = 0; b < 5; b++)

{

a[b] = b;

}

O exemplo acima descrito inicializa a matriz, fazendo corresponder o seu conteúdo ao seu

índice, o resultado final é:

a[0] = 0

a[1] = 4

a[2] = 4

a[3] = 4

a[4] = 4

No entanto é possível, iniciar o conteúdo da matriz na declaração da mesma, usando a

declaração seguinte:

unsigned char a [] = { 2 , 4 , 6 , 8 , 10 };

Para as matrizes de várias dimensões, o conceito é similar ao de uma única dimensão, podemos

ver as matrizes multidimensionais como a associação de várias matrizes unidimensionais.

unsigned char a [2] [3];



A declaração em cima descrita, cria uma matriz multidimensional de duas linhas e 3 colunas, a

representação gráfica para essa matriz é:

a [ 0 ][ 0 ] a [ 0 ][ 1] a [ 0 ][ 2 ]

a [ 1 ][ 0 ] a [ 1 ][ 1 ] a [ 1 ][ 2 ]

Exemplo:

unsigned char a [2] [3];

unsigned char b;

unsigned char c;

unsigned char d = 0;

for ( b = 0; b < 2; b++)

{

for ( c = 0; c < 3; c++)

{

a[b] [c] = d++;

}

}

O resultado final é:

a [ 0 ][ 0 ] a [ 0 ][ 1] a [ 0 ][ 2 ] 0 1 2

a [ 1 ][ 0 ] a [ 1 ][ 1 ] a [ 1 ][ 2 ] 3 4 5

Para matrizes com mais de duas dimensões, o procedimento é igual ao da matriz com duas

dimensões, vejamos o seguinte exemplo, uma matriz de três dimensões.

unsigned char a [2] [3] [2];

a[0][0][0] = 1;

a[0][0][1] = 2;

a[0][1][0] = 3;

a[0][1][1] = 4;

a[0][2][0] = 5;

a[0][2][1] = 6;

a[1][0][0] = 7;

a[1][0][1] = 8;

a[1][1][0] = 9;

a[1][1][1] = 10;

a[1][2][0] = 11;

a[1][2][1] = 12;



Existe uma relação entre as matrizes e os ponteiros, a simples referencia ao nome da matriz,

sem qualquer especificação de índice, retorna o endereço do primeiro elemento da matriz, outro

aspecto é que os ponteiros podem ser indexados como as matrizes, vejamos o seguinte exemplo:

unsigned char *ponteiro, matriz[5];

ponteiro = matriz;

matriz[0] = 50;

ponteiro[1] = 60;

No exemplo em cima descrito, podemos verificar que o ponteiro aponta para o endereço do

primeiro elemento da matriz, o primeiro elemento da matriz foi carregado com o valor 50 e o segundo

elemento com o valor 60.

Existe ainda um tipo de dado especial, que se enquadra dentro das matrizes, que são as STRING

de caracteres, trata-se de uma matriz unidimensional de caracteres, com características que a diferem

das matrizes normais, por exemplo o número total da matriz deve ser sempre 1 carácter maior que a

quantidade de caracteres a ser armazenada na matriz, visto que as strings de caracteres são terminadas

por um carácter nulo.

Exemplo:

char palavra*11+ = “Exemplo…”;

Estruturas.

Uma estrutura é um agrupamento de variáveis individuais, referenciadas por um nome comum,

para criar uma estrutura é necessário passar por duas etapas, a primeira é definida pela estrutura de

dados á qual se atribui um identificador, a segunda etapa é criar as varáveis de estrutura, vejamos o

exemplo seguinte.

struct Tempo

{

int Horas;

int Minutos;

int Segundos;

};

struct Tempo Horario;

No exemplo em cima descrito definimos como identificador da estrutura o nome Tempo e

como variáveis da estrutura as variáveis inteiras Hora, Minutos e Segundos. No final é criada uma nova

variável do tipo Tempo, com o nome de Horario.

A forma geral de acesso a um elemento de uma estrutura do exemplo acima descrito é:

Horario.Hora = 0;



A linguagem C também permite a criação de ponteiros para as estruturas de dados, uma das

principais aplicações deste tipo de ponteiro é a passagem de estruturas por referência na chamada de

funções.

Para declarar um ponteiro para uma estrutura, vamos usar como exemplo o exemplo anterior,

criando assim um ponteiro para a variável de estrutura Tempo.

void main (void)

{

struct Tempo

{

int Horas;

int Minutos;

int Segundos;

};


struct Tempo *Ponteiro;

while (1) //Ciclo infinito

{

Horario.Horas = 17;

Horario.Minutos = 20;

Horario.Segundos = 53;

Ponteiro = &Horario;

(*Ponteiro).Horas = 18;

(*Ponteiro).Minutos = 15;

(*Ponteiro).Segundos = 23;

}

}

Pelo exemplo em cima descrito, podemos verificar que temos duas variáveis de estrutura, das

quais uma é definida por ponteiros, isto é, temos um ponteiro que aponta para uma variável de

estrutura, ao correr este programa no modo simulação podemos verificar que o ponteiro aponta para o

variável de estrutura Horario, visto que o ponteiro é carregado com o valor do endereço da estrutura

Horario, que seguidamente carregando essa variável com outros valores distintos.

Outro conceito interessante, ainda no campo das estruturas, é o acesso a bits individuais numa

variável. Na verdade podemos dizer que os campos de bits são uma extensão das estruturas de dados,

uma vez que apenas se podem definir dentro de uma estrutura de dados, vejamos o seguinte exemplo:

struct Estado

{

int Flag1 : 1;

int Flag2 : 1;

int Flag3 : 1;

}Flag;



No exemplo em cima descrito, foi definido uma estrutura do tipo Estado, chamada de Flag, este

tipo de estrutura permite o acesso a bits, isto é, podemos modificar apenas um bit, sem alterar os

restantes numa dada variável.

Numa estrutura, é possível definir campos de bits, bytes ou variáveis de vários comprimentos, o

seguinte exemplo mostra uma estrutura de com vários tipos de dados, repare que o comprimento em

bits da variável é definido após o simblo “:”.

void main (void)

{

struct Estado

{

int Flag1 : 1;

int Flag2 : 1;

int Flag3 : 2;

int Flag4 : 3;

int Flag5 : 1;

int Config;

}Flag;


{

Flag.Flag1 = 1;

Flag.Flag2 = 0;

Flag.Flag3 = 3;

Flag.Flag4 = 5;

Flag.Flag5 = 0;

Flag.Config = 68;

}

}

Uniões.

Uma união é um elemento que permite que uma posição de memória RAM seja compartilhada

por diversos tipos de variáveis, o formato geral é muito parecido com o das estruturas de dados,

vejamos o seguinte exemplo:

union Teste

{

int variavel_1;

unsigned int variavel_2;


struct Estado Flag;

char variavel_3;

long variavel_4;

}



Funções.

A linguagem C, permite modularizar uma sequência de comandos, para que possamos executa-

la sempre que necessário, sem a necessidade de repetir em termos de código esses comandos.

O formato geral de uma função me linguagem C é:

Tipo_da_função Nome_da_Função (Parematros _da_Função)

{

Comando_1;

Comando_2;

…

Comando_n;

}

O tipo da função, é usado para especificar o tipo de dado que a função vai devolver, o

nome da função é o identificador utilizado para especificar o nome para o qual será conhecida a

função pelo programa, os parâmetros da função são utilizados para passar o conteúdo de

variáveis para dentro da função, para que a função os possa utilizar para efectuar

procedimentos.

Em regra, na elaboração do programa, a inclusão de funções faz-se no decorrer do

desenvolvimento do programa, nesse sentido as funções devem ser criadas no fim do

programa, adoptando este principio é necessário no inicio do programa informar o compilador

que existem funções no fim do programa, esta informação é indicada pelo protótipo da função,

isto é, o protótipo de uma função é uma declaração previa com o intuito de informar o

compilador o formato da declaração da função, incluindo o tipo de dado de retorno e os tipos e

quantidades de parâmetros, normalmente são declarados no inicio do programa, sempre antes

do programa fazer referencia a função.

Exemplo:

unsigned char Soma (unsigned char b, unsigned char c);

void main (void)

{

unsigned char a;

a = Soma (3,2);

}

unsigned char Soma (unsigned char b, unsigned char c)

{

unsigned char soma;

soma = b + c;

return soma;

}



Existem duas formas básicas, de uma função retornar um valor ao local onde foi

chamada, pelo término da execução da função de todos os comandos ou pela execução da

declaração return, como mostrar o exemplo em cima descrito.

A passagem de parâmetros para dentro de uma função, pode ser feita de duas formas

distintas:

Por valor, o próprio valor é transferido para dentro da função.

Por referência, o endereço da variável é transferido para dentro da função,

como ponteiro.

Exemplo de passagem de parâmetros por referencia:

unsigned char Soma (unsigned char *b, unsigned char *c);

void main (void)

{

unsigned char a;

unsigned char a1;

unsigned char a2;

a1 = 5;

a2 = 15;

a = Soma ( &a1 , &a2);

}

unsigned char Soma (unsigned char *b, unsigned char *c)

{

unsigned char soma;

soma = *b + *c;

return soma;

}

A linguagem C permite a utilização de matrizes como argumentos de uma função, visto que o

nome da matriz sem indicação dos elementos, é um ponteiro que aponta para o primeiro elemento da

matriz, vejamos o seguinte exemplo:

void Soma (unsigned char M[10] , unsigned char Tamanho);

void main (void)

{

unsigned char M[10];

Soma (M,10);

}

void Soma (unsigned char M[10] , unsigned char Tamanho)

{

unsigned char a;

for ( a = 0 ; a < Tamanho ; a++)

M[a] = a;

}


Bernardino Neves - 2011 Página 63 Programação dos microcontroladores PIC18

Programação dos microcontroladores PIC18.

Uma vez feito o programa correctamente e compilado, o compilador gera um ficheiro

Hexadecimal, o qual é usado para programar o microcontrolador.

Apesar de existirem diversos programadores, foi escolhido a utilização de um bootloader como

recurso de programação, as razões que levaram a essa escolha dizem respeito a custos, o bootloader

permite a gravação do programa no microcontrolador sem recurso a um programador físico. Um

bootloader é um pequeno programa especial, cuja função é ser capaz de carregar um outro programa

por um dos periféricos de comunicação, neste caso a UART, repare que o bootloader é um programa e

nesse sentido terá de ser previamente programado com um programador.

O bootloader que iremos utilizar é o AN1310, desenvolvido pela Microchip Techonology, trata-

se de um bootloader de alta velocidade para microcontroladores PIC16 e PIC18. Tem como

características principais:

Possuir um tamanho pequeno de código, inferior a 450 instruções.

Sincronização automática da taxa de transmissão.

Suporta uma ampla variedade de microcontroladores PIC16 e PIC18.

Não utiliza pinos IO opcionais.

Reset do microcontrolador via software PC.

Possui um terminal RS232.

Para usar o bootloader em questão é necessário ter presente os seguintes requisitos:

Ter uma porta serie ou um conversor USB/RS232, no computador.

Hardware de desenvolvimento.

A ferramenta de programação para carregar o bootloader no µC.

Instalação do software PC AN1310.exe.

A primeira etapa é instalar o software PC “microchip_serial_bootloader_an1310.exe”. A

instalação do software requer uma ligação ao servidor da Microchip.

Fig 48 - Ficheiro de instalação do bootloader AN1310.

Após o aparecimento da primeira janela de instalação clique em seguinte.


Página 64 Bernardino Neves – 2011 Programação dos microcontroladores PIC18

Fig 49 - Primeira janela de instalação do software PC do bootloader AN1310.

Na segunda janela desactive o item “Install Babylon Toolbar …”, e clique em seguida em

seguinte.

Fig 50 - Segunda janela de instalação do software PC do bootloader AN1310.

Pressione o botão seguinte ate a janela que indica localização da instalação, mude a localização

ou deixe a localização por defeito.

Fig 51 – Localização da instalação do software PC AN1310.

Termine a instalação pressionando o botão close.



Fig 52 – Finalização da instalação do software PC AN1310.

Após a instalação do software PC AN1310, chega a altura de o testar, mas antes de o fazer é

necessário conhecer o hardware de desenvolvimento, como hardware de desenvolvimento foi

desenvolvido um circuito com o microcontrolador PIC18F4620, que permita gravação dos programas

desenvolvidos por RS232, as figuras seguintes mostram os circuitos implementados.

Fig 53 - Fonte de alimentação.

Fig 54 - Microcontrolador PIC18F4620 e transceiver RS232.



Fig 55 - Programação em circuito ICSP.

Fig 56 – Imagem do hardware desenvolvido, o kit DevBoard PIC.

A segunda etapa é gravar no microcontrolador o seu respectivo bootloader, o mesmo pode ser

encontrado na pasta que foi instalado pelo software de instalação.

Fig 57 - Localização do bootloader PIC18.

Após gravar o bootloader, através de um programador, já nos encontramos, com tudo o que é

necessário para testar todas as ferramentas, vamos começar por testar o software PC AN1310, a figura

seguinte mostra o setup experimental para um primeiro teste, que consiste em ligar o software PC ao

hardware proposto.



DevBoarb PICRS232

Fig 58 - Setup experimental para testar o hardware e o software PC.

Na terceira etapa, ligue o interruptor do kit Devboard PIC, para alimentar o kit e execute o

software PC AN1310, que se encontra na pasta que foi instalado pelo software de instalação.

Fig 59 - Localização do software PC AN1310.

Fig 60 - Software PC para carregar o programa no microcontrolador.

Após executar os passos anteriores com sucesso, chega a altura de configurar as comunicação

por RS232, apesar de o bootloader instalado no microcontrolador, reconhecer automaticamente o baud

rate, o mesmo poderá ser configurado no software PC, através do item “Settings”, como mostra as

figuras seguintes, o qual poderemos deixar nos 19200 bps e seleccionar a porta COM respectiva.



Fig 61 - Configuração do Baud Rate.

Por último, para testar o software PC pressione o botão bootloader mode, como resposta é

possível visualizar o mapa de memória do microcontrolador e o microcontrolador utilizado.

Fig 62 – Comunicação entre o software PC e o microcontrolador.


Bernardino Neves - 2011 Página 69 Portos I/O

Portos I/O.

Os portos I/O, são periféricos que nos permitem comunicar com o mundo exterior, podem ser

configurados como entradas ou como saídas, quando configurado como entradas o nível lógico presente

num determinado pino pode ser lido pelo programa, quando configurado como saída, podemos alterar

o nível lógico de um determinado pino através do nosso programa. Durante a execução de um programa

podemos alterar o sentido dos dados nos pinos de acordo com as necessidades, isto é, num

determinado momento o pino pode estar configurado como entrada e no instante seguinte pode ser

configurado como saída.

O microcontrolador em estudo, possui 5 portos I/O, que se encontram multiplexados com

outros periféricos disponíveis pelo microcontrolador. Cada pino do microcontrolador apenas pode ter

uma única função, para o mesmo instante de tempo, ou seja, ou funciona como pino I/O ou tem a

função associada a um determinado periférico.

O controlo dos portos I/O é feito essencialmente através de 3 registos:

Registo TRISx – Defini a direcção dos dados no porto x, se o bit for “0” o pino esta

configurado como saída, se for “1” o bit esta configurado como entrada;

Registo PORTx – Registo para leitura do estado lógico dos pinos associados ao porto x;

Registo LATx – Registo para escrita no porto x.

A figura 63 mostra o modelo simplificado de uma porta I/O do microcontrolador PIC18F4620.

Fig 63 - Modelo simplificado do porto I/O [1].

Um ponto importante a salientar é que ambos os registos TRISx, PORTx e LATx, são registos de

8 bits, e que a posição de cada bit corresponde a posição de cada pino do respectivo porto. Por exemplo

o bit 0 do registo TRISD, configura a direcção dos dados do pino 0 do porto D, e a escrita e leitura nesse

pino é feito a partir do bit 0 do registo PORTD para leitura do estado ou o bit 0 do registo LATD para

mudança do estado lógico do pino 0 do porto D.


Página 70 Bernardino Neves – 2011 Portos I/O

Leitura do estado de um pino.

A leitura do estado lógico presente em um pino, depende essencialmente do modo como foi

configurado a direcção dos dados, isto é, como foi configurado o registo TRISx. Quando se pretende

efectuar leituras de pinos, os bits correspondentes no registo TRISx devem ser configurados com o valor

lógico “1”. A leitura do estado lógico do pino ou conjunto de pinos, é feito pela leitura do registo PORTx,

em que o valor x corresponde ao identificador do porto.

O compilador C18, permite operações bit a bit com os portos I/O, o que permite operar apenas

com um bit, para o efeito recorremos as estruturas TRISxbits.TRISy e PORTxbits.Rxy, em que x

corresponde ao identificador do porto e y ao pino que pretendemos ler.

Exemplo:

Pretende-se configurar os pinos 2, 3 e 4 do porto D como entradas.

unsigned char a,b,c;

TRISDbits.TRISD2 = 1;



a = PORTDbits.RD2;

b = PORTDbits.RD3;

c = PORTDbits.RD4;

No exemplo em cima descrito, configuramos os pinos 2, 3 e 4 do porto D como entradas, e de

seguida lemos o estado dos pinos 2, 3 e 4 e guardamos o seu estado lógico nas variáveis a, b e c.

Escrita em um pino.

A escrita em um pino, depende também do modo como foi configurado o registo TRISx, ou

seja, para operações de escrita em pinos I/O, o bit do registo TRISx correspondente ao pino que

pretendemos escrever, deve ser configurado com o valor lógico “0”. Existem dois registos que permitem

a escrita de um estado lógico em um pino I/O, o registo LATx e o registo PORTx. Tal como acontece na

leitura de um pino, o compilador C18 permite operações de escrita bit a bit, para o efeito usamos as

estruturas TRISxbits.TRISy, PORTxbits.Rxy e LATxbits.LATxy, em que x corresponde ao identificador do

porto e y ao pino que pretendemos ler.

Exemplo:

Pretende-se configurar os pinos 0 e 1 do porto D como saídas.



LATDbits.LATD0 = 1; //Coloca o pino 0 do porto D com o nível lógico “1”.

LATDbits.LATD1 = 0; //Coloca o pino 1 do porto D com o nível lógico “0”.



Exemplos de aplicação.

Exemplo 1 – Led a piscar com frequência igual a 1Hz.

O exemplo consiste em criar uma função, que gera um atraso, onde o argumento é o tempo em

milissegundos que se pretendo do atraso, para colocar um led a piscar com uma frequência de 1 HZ.

Layout do circuito:

18

19

20

23

22

21

RD0

RD1

RC4

RD3

RD2

RC3R

270Led

Fig 64 - Layout do circuito do exemplo 1.

Função Delay_ms(): void Delay_ms ( int Delay)

{

unsigned int aux1;

for ( aux1 = 0 ; aux1 < Delay ; aux1++) //Gera um atraso de 1 ms.

{

Delay1KTCYx(CLOCK); //1000 ciclos de relógio.

}

}

A função em cima descrita gera um atraso de 1ms vezes o numero do argumento da função,

isto é, se pretendermos um atraso de 1 segundo, o argumento da função deve ser igual a 1000.

Programa: //Inclusão do microcontrolador a utilizar

#include <p18cxxx.h>

//Definição de variaveis


#define CLOCK (5) //((Fosc/4) / 1000000)

#define Pino (PORTDbits.RD0) //Pino 19 do microcontrolador

//Prototipos de funções do programa

void Delay_ms ( int a);

//Programa principal

void main (void)

{

TRISD &= 0xFE; //Configura pino RD0 como saída


{

Delay_ms(500); //Gera um delay de 500ms por polling

Pino = ~Pino; //Comuta o estado do pino RD0

}

}



Exemplo 2 – Sequência de Led’s.

O exemplo consiste em criar 4 sequências de led’s de acordo com as seguintes condições:

1º Sequencia – Varrimento num sentido.

2º Sequencia – Varrimento em sentido contrário ao anterior.

3º Sequencia – Varrimento das pontas para o centro.

4º Sequencia – Varrimento de um lado para o outro.

Cada estado tem a duração de 100ms.

No final volta a primeira sequência, e faz esse ciclo contínuo.

Layout do circuito:

18

19

20

23

22

21

RD0

RD1

RC4

RD3

RD2

RC3

R

270Led 0

R

270Led 1R

270

Led 2

R

270

Led 3

R

270

Led 4


Função Inicia_Hardware(): void Inicia_Hardware (void)

{

TRISD &= 0xF0; //Configura pino RD0, RD1, RD2 e RD3 como saida

TRISC &= 0xEF; //Configura pino RC4 como saida

//Não interfere com os outros pinos

LED0 = 0; //Inicia o Led0 a zero.





}



//Definição de variáveis



#define LED0 (LATDbits.LATD0)




#define LED4 (LATCbits.LATC4)


void Inicia_Hardware (void);





void main (void)

{

unsigned char aux1;

Inicia_Hardware();


{

//Primeira sequência

for ( aux1 = 0 ; aux1 < 4 ; aux1++)

{

if( aux1 == 0)

{

Delay_ms(100);

LED0 = ~LED0;

}

else

{

Delay_ms(100);

LED0 = ~LED0;

LED4 = ~LED4;

}

Delay_ms(100);

LED1 = ~LED1;

LED0 = ~LED0;

Delay_ms(100);

LED2 = ~LED2;

LED1 = ~LED1;

Delay_ms(100);

LED3 = ~LED3;

LED2 = ~LED2;

Delay_ms(100);

LED4 = ~LED4;

LED3 = ~LED3;

}

//Segunda sequencia

LED4 = ~LED4;

for ( aux1 = 0 ; aux1 < 4 ; aux1++)

{

if( aux1 == 0)

{

Delay_ms(100);

LED4 = ~LED4;

}

else

{

Delay_ms(100);

LED4 = ~LED4;

LED0 = ~LED0;

}

Delay_ms(100);

LED3 = ~LED3;

LED4 = ~LED4;

Delay_ms(100);

LED2 = ~LED2;

LED3 = ~LED3;

Delay_ms(100);

LED1 = ~LED1;

LED2 = ~LED2;



Delay_ms(100);

LED0 = ~LED0;

LED1 = ~LED1;

}

//Terceira sequencia

LED0 = ~LED0;

for ( aux1 = 0 ; aux1 < 4 ; aux1++)

{

if( aux1 == 0)

{

Delay_ms(100);

LED0 = ~LED0;

LED4 = ~LED4;

}

else

{

Delay_ms(100);

LED4 = ~LED4;

LED0 = ~LED0;

LED2 = ~LED2;

}

Delay_ms(100);

LED0 = ~LED0;

LED4 = ~LED4;

LED1 = ~LED1;

LED3 = ~LED3;

Delay_ms(100);

LED1 = ~LED1;

LED3 = ~LED3;

LED2 = ~LED2;

}

//Quarta sequencia

LED2 = ~LED2;

for ( aux1 = 0 ; aux1 < 4 ; aux1++)

{

if( aux1 == 0)

{

Delay_ms(100);

LED0 = ~LED0;

}

else

{

Delay_ms(100);

LED0 = ~LED0;

LED1 = ~LED1;

}

Delay_ms(100);

LED0 = ~LED0;

LED1 = ~LED1;

Delay_ms(100);

LED2 = ~LED2;

LED1 = ~LED1;

Delay_ms(100);

LED3 = ~LED3;

LED2 = ~LED2;



Delay_ms(100);

LED4 = ~LED4;

LED3 = ~LED3;

Delay_ms(100);

LED3 = ~LED3;

LED4 = ~LED4;

Delay_ms(100);

LED2 = ~LED2;

LED3 = ~LED3;

Delay_ms(100);

LED1 = ~LED1;

LED2 = ~LED2;

}

LED1 = ~LED1;

} //Fim do ciclo infinito

} //Fim do programa principal

Exemplo 3 – Variação da frequência.

O exemplo consiste em fazer um led piscar com uma frequência progressiva, o decremento da

frequência é de 1Hz, inicia a 10Hz e termina a 1Hz, com saltos de 1Hz.

Layout do circuito:

18

19

20

23

22

21

RD0

RD1

RC4

RD3

RD2

RC3

R

270Led



{

TRISD &= 0xFD; //Configura pino RD1 como saida


}






#define LED0 (PORTDbits.RD1)

//Protótipos de funções do programa






void main (void)

{

unsigned char a,b;

Inicia_Hardware();


{

for( a = 0 ; a < 20 ; a++ )

{

Delay_ms(50);

LED0 = ~LED0;

}

for( a = 0 ; a < 18 ; a++ )

{

Delay_ms(55);

LED0 = ~LED0;

}

for( a = 0 ; a < 16 ; a++ )

{

Delay_ms(63);

LED0 = ~LED0;

}

for( a = 0 ; a < 14 ; a++ )

{

Delay_ms(71);

LED0 = ~LED0;

}

for( a = 0 ; a < 12 ; a++ )

{

Delay_ms(83);

LED0 = ~LED0;

}

for( a = 0 ; a < 10 ; a++ )

{

Delay_ms(100);

LED0 = ~LED0;

}

for( a = 0 ; a < 8 ; a++ )

{

Delay_ms(125);

LED0 = ~LED0;

}

for( a = 0 ; a < 6 ; a++ )

{

Delay_ms(166);

LED0 = ~LED0;

}

for( a = 0 ; a < 4 ; a++ )

{

Delay_ms(250);

LED0 = ~LED0;

}

for( a = 0 ; a < 2 ; a++ )

{

Delay_ms(500);

LED0 = ~LED0;

}

Delay_ms(1000);

LED0 = ~LED0;





Exemplo 4 – Activar uma saída através de uma entrada.

O exemplo consiste em activar uma saída, em função do nível lógico que se encontra numa

entrada.

Layout do circuito:

19

20

33

RD0

RD1

RB0

R

270Led 1

R

470

R

10K

VCC



{

TRISD &= 0xFD; //Configura pino RD1 como saída

TRISB |= 0x01; //Configura Pino RB0 como entrada

LED0 = 0;

}







#define IN0 (PORTBbits.RB0)




void main (void)

{

Inicia_Hardware();


{

if ( IN0 == 0)

{

LED0 = 1;

}



else

{

LED0 = 0;

}



Exemplo 5 – Mudança de estado (Toggle).

O exemplo consiste em activar uma saída por mudança de estado de uma entrada, isto é, cada

pressão no botão, muda o estado do led.

Layout do circuito:

19

20

33

RD0

RD1

RB0

R

270Led 1

R

470

R

10K

VCC



{



LED0 = 0;

}













void main (void)

{

unsigned char aux1=0;

Inicia_Hardware();


{

if ( IN0 == 0)

{

while(IN0 == 0);

LED0 = ~LED0;

}



Exemplo 6 – Atraso a operação.

O exemplo consiste em criar um atraso a operação, isto é, quando o botão IN0 é pressionado,

só passado 5 segundos é que o led activa, outra entrada IN1 é usada para desligar o led.

Layout do circuito:

19

20

33

RD0

RD1

RB0

R

270Led 1

R

470

R

10K

VCC

34RB1

R

470

R

10K

VCC

IN0

IN1



{



LED0 = 0;

}















void main (void)

{

Inicia_Hardware();


{

if ( IN0 == 0 )

{

Delay_ms(5000); //Atraso de 5 segundos

LED0 = 1; //Activa a saida

}

if ( IN1 == 0 )

{

LED0 = 0; //Desactiva a saida

}



Exemplo 7 – Avanço a operação.

O exemplo consiste em criar um avanço a operação, isto é, quando o botão é pressionado,

activa o led e só depois de deixar de ser pressionado e passado 5 segundos é que o led desactiva.

Layout do circuito:

19

20

33

RD0

RD1

RB0

R

270Led 1

R

470

R

10K

VCC





{



LED0 = 0;

}












void main (void)

{

Inicia_Hardware();


{

if ( IN0 == 0 )

{

LED0 = 1; //Activa a saída

while(IN0 == 0); //Aguarda que o botão deixe de ser pressionado

Delay_ms(5000); //Aguarda de 5 segundos

LED0 = 0; //Desactiva a saída

}





Exemplo 8 – Arranque estrela - triângulo.

O exemplo consiste em criar o controlo para o arranque estrela – triângulo de motores de

indução trifásicos, o botão IN0 inicia o arranque e o botão IN1 executa a paragem.

Layout do circuito:

19

20

33

RD0

RD1

RB0

R

270

OUT1

R

470

R

10K

VCC

34RB1

R

470

R

10K

VCC

IN0

IN1

21RD2

R

270

OUT2

R

270OUT0



{

TRISD &= 0xF8; //Configura pino RD0, RD1 e RD2 como saídas

TRISB |= 0x03; //Configura pino RB0 e RB1 como entradas

OUT0 = 0; //Inicializa as saídas a zero

OUT1 = 0;

OUT2 = 0;

}

Programa:

//Inclusão do microcontrolador a utilizar





#define OUT0 (PORTDbits.RD1) //Linha

#define OUT1 (PORTDbits.RD4) //Estrela

#define OUT2 (PORTDbits.RD5) //Triângulo

#define IN0 (PORTBbits.RB0) //Arranque

#define IN1 (PORTBbits.RB1) //Paragem







void main (void)

{

Inicia_Hardware();


{

if ( IN0 == 0 ) //Verifica se o botão de arranque está pressionado

{

OUT0 = 1; //Activa a configuração estrela

OUT2 = 1;

Delay_ms(5000); //Aguarda de 5 segundos

OUT2 = 0; //Comuta para a configuração triângulo

OUT1 = 1;

while(IN1 == 0); //Aguarda que o botão de paragem seja pressionado

OUT0 = 0; //Desactiva as saídas

OUT1 = 0;

OUT2 = 0;

}



Exemplo 9 – Display de 7 segmentos.

O exemplo consiste em criar um contador, cada pressão no botão de pressão incrementa o

contador, o resultado é visível num display de 7 segmentos.

Layout do circuito:

19

20

33

RD0

RD1

RB0

R

270SEG D

R

470

R

10K

VCC

IN0

21RD2

R

270 SEG E

R

270

SEG B

21RD3

R

270SEG F

21RC4

R

270SEG G

17

18

RC2

Rc3

R

270

SEG C

R

270SEG A





{

TRISC &= 0xE3; //RC2, RC3 e RC4 como saídas

TRISD &= 0xF0; //RD0, RD1, RD2 e RD3 como saídas


SegA = 0; //Inicializa as saídas a zero

SegB = 0;

SegC = 0;

SegD = 0;

SegE = 0;

SegF = 0;

SegG = 0;

}

Função Escreve_Digito(): void Escreve_Digito( unsigned char a)

{

switch (a)

{

case 0:

SegA = 1;

SegB = 1;

SegC = 1;

SegD = 1;

SegE = 1;

SegF = 1;

SegG = 0;

break;

case 1:

SegA = 0;

SegB = 1;

SegC = 1;

SegD = 0;

SegE = 0;

SegF = 0;

SegG = 0;

break;

case 2:

SegA = 1;

SegB = 1;

SegC = 0;

SegD = 1;

SegE = 1;

SegF = 0;

SegG = 1;

break;

case 3:

SegA = 1;

SegB = 1;

SegC = 1;

SegD = 1;

SegE = 0;

SegF = 0;

SegG = 1;

break;



case 4:

SegA = 0;

SegB = 1;

SegC = 1;

SegD = 0;

SegE = 0;

SegF = 1;

SegG = 1;

break;

case 5:

SegA = 1;

SegB = 0;

SegC = 1;

SegD = 1;

SegE = 0;

SegF = 1;

SegG = 1;

break;

case 6:

SegA = 1;

SegB = 0;

SegC = 1;

SegD = 1;

SegE = 1;

SegF = 1;

SegG = 1;

break;

case 7:

SegA = 1;

SegB = 1;

SegC = 1;

SegD = 0;

SegE = 0;

SegF = 0;

SegG = 0;

break;

case 8:

SegA = 1;

SegB = 1;

SegC = 1;

SegD = 1;

SegE = 1;

SegF = 1;

SegG = 1;

break;

case 9:

SegA = 1;

SegB = 1;

SegC = 1;

SegD = 1;

SegE = 0;

SegF = 1;

SegG = 1;

break;

default:

break;

}

}



Programa:






#define SegA (PORTCbits.RC2)

#define SegB (PORTCbits.RC3)

#define SegC (PORTDbits.RD0)

#define SegD (PORTDbits.RD1)

#define SegE (PORTDbits.RD2)

#define SegF (PORTDbits.RD3)

#define SegG (PORTCbits.RC4)





void Escreve_Digito( unsigned char a);


void main (void)

{

unsigned char aux1 = 0;

Inicia_Hardware();


{

if ( IN0 == 0)

{

while(IN0 == 0);

Escreve_Digito( aux1 );

aux1++;

if( aux1 == 10 )

aux1 = 0;

}



Exemplo 10 – Leitura e escrita em um pino (maximização do pino).

O exemplo consiste em maximizar um pino, isto é, o reaproveitamento de um mesmo pino I/O

para mais que uma função, neste caso a leitura e escrita em um pino. Existem varias técnicas para

maximizar um pino I/O, uma forma de o fazer é configurar num instante de tempo como entrada e no

instante de tempo seguinte como saída, isto de uma forma periódica. Mas para esta técnica funcionar

correctamente, o tempo dedicado a saída tem de ser bastante superior (maior que 20 vezes), que o

tempo dedicado a entrada, caso contrário, corremos o risco de verificarmos na saída o efeito de

intermitência. Vejamos a seguinte figura, a figura 73, que representa o diagrama temporal desta técnica

para maximizar um pino I/O.



VCC

GND

Saída Entrada Saída Entrada

VCC

GND

Led ligado

Led desligado

Led ligado

Led desligado

O tempo dedicado a entrada deve ser de modo a que o

efeito de intermitência seja minimizado.

Fig 73 - Diagrama temporal, da técnica para maximizar um pino I/O.

Para utilizar esta técnica, podemos recorrer a uma base de tempo de 20ms, onde 19ms são

dedicados a saída e 1ms são dedicados a entrada. No exemplo o botão IN0 liga o led e o botão IN1

desliga o led.

Layout do circuito:

33RB0

R

10K

R

10K

VCC

IN0

R

330

Led

R

470

R

10K

VCC

IN1

34RB1



{

TRISB |= 0x02; //Configura RB1 como entrada.

OUT0 = 0;

}



Programa:



//Definição de variaveis



#define OUT0 (LATBbits.LATB0)



#define DIR (TRISBbits.TRISB0)





void main (void)

{

unsigned char aux = 0;

Inicia_Hardware();


{

if ( IN1 == 0) //Verifica se o botão IN1 foi pressionado

{

aux = 0;

OUT0 = 0; //Desliga o Led

}

DIR = 1; //Configura RB0 como entrada

if (IN0 == 0) //Verifica se o botão IN0 foi pressionado

{

aux = 1;

}

DIR = 0; //Configura RB0 como saída

if( aux == 1) //Se IN0 foi pressionado

{

OUT0 = 1; //Liga o led e aguarda 19ms.

Delay_ms(19);

}



Introdução ao PIC18F4620

Documents

Transcript of Introdução ao PIC18F4620