projetar sistema microcontrolado

Prévia do material em texto

Universidade Federal do Piauí
Centro de Tecnologia
Curso de Engenharia Elétrica
MICROCONTROLADORES
Prof. Marcos Zurita
zurita@ufpi.edu.br
www.ufpi.br/zurita
Teresina - 2012
 Linguagem C
2
Microcontroladores – Prof. Marcos Zurita
Sumário
● 1. Introdução
● 1.1. C vs Assembly
● 2. Compiladores
● 3. A Linguagem C do CCS
● Bibliografia
3
Microcontroladores – Prof. Marcos Zurita
 
1. Introdução
4
Microcontroladores – Prof. Marcos Zurita
Introdução
C vs Assembly
● Código Assembly
●  Gera um código compilado “enxuto”
●  Veloz 
●  Controle “total” sobre as operações
●  Códigos fonte extensos
●  Difícil de programar
●  Difícil de entender
●  Difícil manutenção
●  Grande dependência do hardware
●  Baixo reaproveitamento de código
●  Impossibilidade de migração para outros µC´s
5
Microcontroladores – Prof. Marcos Zurita
Introdução
● Código C
●  Código compilado quase tão “enxuto” quanto ASM
●  Quase tão veloz quanto ASM
●  Abstração das operações em baixo nível
●  Códigos-fonte enxutos
●  Fácil de programar
●  Fácil de entender
●  Fácil manutenção
●  Baixa dependência do hardware
●  Bom reaproveitamento de código
●  Possibilidade de integração com ASM
●  Menor velocidade em operações críticas
6
Microcontroladores – Prof. Marcos Zurita
Introdução
Como Projetar Sistemas com Microcontroladores
Despeça-se da sua 
família e de seus 
pais por alguns 
dias...
Abasteça seu 
mascote com boas 
reservas de ração
Estude o dispositivo que 
será controlado pelo 
microcontrolador.
7
Microcontroladores – Prof. Marcos Zurita
Introdução
 
Examine “todos” os 
microcontroladores 
de que você dispõe 
(n° de E/S, conver-
sores, temporiza-
dores, etc.)
Escolha o que melhor atende 
aos requisitos de funciona-
mento do sistema desejado.
Projete e, se possível,
construa um protótipo
do sistema que será con-
trolado pelo uC, incluindo 
periféricos que serão utiliza-
dos na aplicação real.
8
Microcontroladores – Prof. Marcos Zurita
Introdução
 
Escreva o programa 
em uma linguagem 
de alto nível para 
programar o uC.
Escolha também um 
simulador para 
auxiliar o 
desenvolvimento.
Com alguns pucos cliques o 
programa inteiro se converte 
em algo compreensível pelo 
uC. Utilize um gravador para 
programa-lo. 
9
Microcontroladores – Prof. Marcos Zurita
Introdução
 
Agora o uC já está suficientemente ma-
duro para começar a dar retorno a 
sociedade! Coloque o chip programado 
no sistema, respire fundo e ligue-o!
Feito! Desfrute o sucesso da empreitada 
e comece a pensar em novos projetos.
10
Microcontroladores – Prof. Marcos Zurita
 
2. Compiladores
11
Microcontroladores – Prof. Marcos Zurita
Compiladores
Alguns Compiladores para PIC
● Assembly
● MPASM (compilador)
● MPLAB (depuração, emulação e gravação)
● C
● PicAnt
● pico-C
● PIXIE
● C2C
● CC5x
● Hi-Tech PICC
● MikroC
● CCS
12
Microcontroladores – Prof. Marcos Zurita
Compiladores
O Compilador CCS C
● Suporta toda linha de µC´s PIC (PIC12, 14, 16 e 18)
● Integração com o MPLAB
● Compatibilidade com ANSI e ISO
● Gera códigos eficientes
● Grande diversidade de bibliotecas e funções
● Grande portabilidade de código
● Implementação natural de ponto flutuante
● Assistente de criação de código
● Geração automática de código ASM e relatórios
● Grande nível de abstração no uso de:
● Delays
● Comunicação serial
● LCD
13
Microcontroladores – Prof. Marcos Zurita
 
3. A Linguagem C do CCS
14
Microcontroladores – Prof. Marcos Zurita
A Linguagem C do CCS
A Linguagem do CCS C
● Variáveis e tipos de dados
● Operadores
● Estruturas de condição
● Estruturas de repetição
● Funções
15
Microcontroladores – Prof. Marcos Zurita
A Linguagem C do CCS
Variáveis e Tipos de Dados
● Tipos nativos da linguagem C
● char
● int
● float
● void
● Tipos específicos do compilador CCS C
● int1
● int8
● int16
● int32
● boolean
● byte
16
Microcontroladores – Prof. Marcos Zurita
A Linguagem C do CCS
Modificadores de Tipo
● Alteram o tamanho ou a forma com que os tipos são 
tratados.
● signed
● unsigned
● short
● long
17
Microcontroladores – Prof. Marcos Zurita
A Linguagem C do CCS
Tipos Disponíveis no CCS C
Tipo Tamanho em Bits Faixa de Valores
short int, int1, boolean 1 0 ou 1
char 8 0 a 255
signed char 8 -128 a 127
unsigned char 8 0 a 255
int, int8, byte 8 0 a 255
signed int, signed byte 8 -128 a 127
unsigned int, unsigned byte 8 0 a 255
long int, int16 16 0 a 65.535
signed long int 16 -32.768 a 32.767
unsigned long int 16 0 a 65.535
int32 32 0 a 4.294.967.295
signed int32 32 -2.147.483.648 a 2.147.483.647
unsigned int32 32 0 a 4.294.967.295
float 32 -3.4x1038 a 3.4x1038
18
Microcontroladores – Prof. Marcos Zurita
A Linguagem C do CCS
Uso de Variáveis
int cont; // contador de 8 bits 
unsigned int ciclo, j; // ciclos de maquina
float tensao; // tensao lida
cont = 0;
ciclo = 1;
j = ciclo + 1;
tensao = 3.496;
19
Microcontroladores – Prof. Marcos Zurita
A Linguagem C do CCS
Matrizes
● Definem um conjunto de elementos do mesmo tipo 
(tamanho fixo):
● Cada elemento deste conjunto pode ser acessado 
através de seu índice no conjunto (1º elemento = índice 
0):
b = v[2]; // recebe o 3º elemento
v[0] = 34; // atribui 34 ao 1º elemento 
int v[10]; // conj. de 10 inteiros 
20
Microcontroladores – Prof. Marcos Zurita
A Linguagem C do CCS
Matrizes Multidimensionais
● São associações de matrizes unidimensionais (vetores).
int p[16][16]; // matriz bidimensional 16x16 
int1 q[2][4]; // matriz bidimensional 2x4
p[0][0] = 200; // atribui 200 ao elemento 0,0
p[0xf][0xf] = 0; // atribui 0 ao elemento 15,15
q = {0,0,1,0 // preenche toda a matriz
 1,1,0,0}; 
21
Microcontroladores – Prof. Marcos Zurita
A Linguagem C do CCS
Strings
● Tratam-se de um conjunto de caracteres.
● Podem ser declaradas na forma de vetores ou de 
ponteiros.
● Quando declaradas sob a forma de vetor, devem ter 
sempre o tamanho do número máximo de caracteres + 
1.
char msg[14]; // string de ate 13 caracteres
char mes[2][4]; // vetor de strings de 3 caracteres
msg = ”Transmitancia”; // preenche 13 caracteres
mes = {”Jan”, ”Fev”}; 
22
Microcontroladores – Prof. Marcos Zurita
A Linguagem C do CCS
Casting - Conversão de Tipos
● Casting é um recurso para forçar o compilador a tratar 
uma variável (ou expressão) como sendo de um tipo 
diferente daquele que foi declarado no programa.
● Seu uso pode ser necessário em operações envolvendo 
variáveis de tipos diferentes.
● Sintaxe:
● Exemplo:
(tipo_destino) expressao_a_ser_convertida; 
int16 adc; // variável tipo “int” 
float tensao; // variável tipo “float”
adc = faz_conversao_AD(); // “adc” está entre 0 e 1023 
tensao = (float)adc/1023; // converte “adc” para float
23
Microcontroladores – Prof. Marcos Zurita
A Linguagem C do CCS
● O uso de casting requer alguns cuidados que devem ser 
observados pelo programador:
● Casting de uma expressão com sinal para uma 
variável sem sinal: pode gerar resultados inesperados 
caso o valor seja negativo (ex.: int para unsigned int);
● Casting de uma variável/expressão cujo número de 
bits é maior que o da variável de destino: o resultado 
será truncado, isto é, todos os bits de ordem superior 
ao de maior ordem da variável de destino serão 
desprezados (ex.: int16 para int8);
● Casting de um número para um um caractere não 
gera o caractere do número (i.e., (char)5 ≠ '5'), o invés 
disto resultará numcaractere cujo valor ASCII 
corresponde ao número dado.
24
Microcontroladores – Prof. Marcos Zurita
A Linguagem C do CCS
● Casting de um ponto flutuante (float) para um tipo 
inteiro (int, int16 ou int32), pode gerar resultados 
inesperados:
● Caso o valor contido seja maior do que o aceitável pela 
variável de destino, mesmo que ela seja um tipo int32 
(float pode comportar até 3.4x1038 enquanto um int32 
sem sinal vai até 4.29x109);
● Float é um tipo com sinal, logo, sujeito aos mesmos 
problemas de conversão para tipos sem sinal, caso o 
valor contido seja negativo.
● A conversão desejável pode requerer arredondamento, 
o que não é feito pelo cast. Ex.:
int k; // variável tipo “int” 
float ganho=5.99; // variável tipo “float”
k = (int)ganho; // k vale 5 e não 6!
25
Microcontroladores – Prof. Marcos Zurita
A Linguagem C do CCS
Variáveis Globais e Locais
● Globais
● São acessíveis em qualquer ponto do programa.
● Só são destruídas no encerramento do programa.
● Locais
● Só são acessíveis dentro da função onde foram 
declaradas.
● São destruídas no encerramento da função.
26
Microcontroladores – Prof. Marcos Zurita
A Linguagem C do CCS
Ex.: Variável global vs local
#include <stdio.h>
int x = 3; // variável global 
void main ()
{
 int y = -10; // variável local
 
 x = x + y;
 printf(”Soma = %i”, x);
} 
27
Microcontroladores – Prof. Marcos Zurita
A Linguagem C do CCS
Modificador Static
● Obriga o compilador a manter a variável numa posição 
fixa da memória.
● Evita que a variável seja destruída no encerramento da 
função.
● São inicializadas com 0;
28
Microcontroladores – Prof. Marcos Zurita
A Linguagem C do CCS
Ex.: Modificador Static
#include <stdio.h>
int x = 3; // variável global
byte incrementa()
{
 static byte ciclo; // variável local estática 
 return ciclo++;
}
void main()
{
 x = x + incrementa();
 x = (x + 2) * incrementa();
 printf(”Coisa = %x”, x);
} 
29
Microcontroladores – Prof. Marcos Zurita
A Linguagem C do CCS
Ponteiros
● Ponteiro é uma variável que contém o endereço de outra 
variável.
● Podem ser utilizados para alocação dinâmica, podendo 
substituir matrizes com mais eficiência (por não ter 
tamanho fixo).
● Sintaxe:
● A manipulação de ponteiros requer dois operadores:
● & - Retorna o endereço apontado pelo ponteiro;
● * - Retorna o conteúdo armazenado no endereço 
apontado pelo ponteiro.
tipo *nome_do_ponteiro; 
30
Microcontroladores – Prof. Marcos Zurita
A Linguagem C do CCS
Ex.: Ponteiros
int *ptr; // ptr é um ponteiro para int 
int x = 10; // x é uma variável tipo int 
int y = 25; // y é uma variável tipo int
ptr = &x; // ptr agora aponta para “x”
printf(”x=%i\n”, *ptr); // imprime “x=10”
ptr = &y; // ptr agora aponta para “x”
printf(”y=%i\n”, *ptr); // imprime “y=20”
31
Microcontroladores – Prof. Marcos Zurita
A Linguagem C do CCS
Constantes
● Valores mantidos fixos na memória durante toda a 
execução do programa.
● Todo valor atribuído explicitamente no código é 
potencialmente um candidato a ser convertido em 
constante.
● Podem assumir qualquer um dos tipos nativos do C, e 
serem declaradas como hexadecimais, octais, strings e 
constantes de controle (barra invertida).
● Devem ser declaradas em caixa alta (por convenção).
32
Microcontroladores – Prof. Marcos Zurita
A Linguagem C do CCS
Ex.: Constantes
#include <stdio.h>
#define COISA 25 //const. tipo int
#define OUTRA_COISA “é outra coisa” //const. tipo string
#define MAIS_COISA 15.32F //const. tipo float
void main()
{
 float j = 0.0;
 char msg[15] = OUTRA_COISA ;
 j = j + COISA + MAIS_COISA;
 printf(”Coisas = %f”, j);
} 
33
Microcontroladores – Prof. Marcos Zurita
A Linguagem C do CCS
Expressões Constantes
Formato Descrição
123 Número decimal inteiro
12.3 Número decimal em ponto flutuante
0123 Número octal
0x123 Número hexadecimal
0b0101 Número binário
'T' Caractere
'\012' Caractere octal
'\x12' Caractere hexadecimal
'\c'
 
 
 
 
 
 
 
 
Caractere especial, onde \c pode ser:
 \n Nova linha
 \r Retorno de carro
 \t Tabulação
 \b Retrocesso (Backspace)
 \f Salta Formulário
 \' Aspas simples
 \” Aspas duplas
 \\ Barra invertida
34
Microcontroladores – Prof. Marcos Zurita
A Linguagem C do CCS
Operadores Aritméticos
● Usados para desenvolver expressões matemáticas.
● Podem ser binários ou unários. 
Operador Descrição
+ Soma (inteira e ponto flutuante)
- Subtração ou troca de sinal (inteira e ponto flutuante)
* Multiplicação (inteira e ponto flutuante)
/ Divisão (inteira e ponto flutuante)
% Resto de divisão (de inteiros)
++ Incremento (inteiro e ponto flutuante)
-- Decremento (inteiro e ponto flutuante)
35
Microcontroladores – Prof. Marcos Zurita
A Linguagem C do CCS
Ex.: Operadores Aritméticos
void main() 
{
 int x = 10, y = 18, z = 4;
 float f = 13.0f;
 x = y + z; // x = 22
 y = 23 / 2; // y = 11
 f = 23.0 / 2; // f = 11.5
 z = 24 % 5; // z = 4
 x++; // x = 15
 z--; // z = 3 
 printf(”x = %i\n”, x); 
 printf(”y = %i\n”, y);
 printf(”z = %i\n”, z);
 printf(”f = %f\n”, f);
}
36
Microcontroladores – Prof. Marcos Zurita
A Linguagem C do CCS
Operadores Relacionais e Lógicos
Operador Descrição
> Maior que 
>= Maior ou igual a
< Menor que
<= Menor ou igual a
== Igual a
!= Diferente de
Comparação Entre Valores
Operador Descrição
&& E (V && V = V, V && F = F, F && F = F)
|| OU (V | | V = V, V | | F = V, F | | F = F)
! NOT (!V = F, !F = V)
Realizam Operações Lógicas (V ou F)
37
Microcontroladores – Prof. Marcos Zurita
A Linguagem C do CCS
Operadores de Bits
● Manipulam bits em valores inteiros.
Operador Descrição
>> Deslocamento de bits para direta
<< Deslocamento de bits para esquerda
~ Complemento bit-a-bit (inverte todos os bits)
| OR bit-a-bit
& AND bit-a-bit
^ XOR bit-a-bit
38
Microcontroladores – Prof. Marcos Zurita
A Linguagem C do CCS
Ex.: Operadores de Bits
byte sm = 0b10001100; // sm = 140
byte x, y, z, k; // 
z = ~sm; // y agora vale 0b01110011
x = sm >> 3; // x agora vale 0b00010001
y = sm << 2; // y agora vale 0b00110000
k = x | y; // k agora vale 0b00110001
k = x & y; // k agora vale 0b00010000
k = x ^ y; // k agora vale 0b00100001 
39
Microcontroladores – Prof. Marcos Zurita
A Linguagem C do CCS
Registros em C (struct)
● Um registro é um conjunto de variáveis agrupadas em 
uma mesma referência.
● Podem conter variáveis de tipos distintos.
● As variáveis contidas podem ter seu tamanho em bits 
alterado através do modificador “:”.
● Sintaxe:
struct nome_estrutura { 
 tipo1 nome_var1 [:bits];
 tipo2 nome_var2 [:bits];
 (...)
 tipoN nome_varN [:bits];
 } nome_var;
40
Microcontroladores – Prof. Marcos Zurita
A Linguagem C do CCS
Ex.: Registros em C (struct)
struct lcd_pin { // cria a estrutura “lcd_pin” 
 int1 enable; // bit 0: campo “enable”
 int1 rs; // bit 1: campo “rs”
 int1 rw; // bit 2: campo “rw”
 int1 unused; // bit 3: campo “unused”
 int data:4; // bits 4-7: campo “data” (4 bits)
 } lcd; // “lcd”: variável do tipo “lcd_pin”
 
char c, ch;
struct lcd_bk lcd_pin; // “lcd_bk” édo tipo “lcd_pin”
lcd.data = 0x9;
c = lcd.data;
ch = 'a';
lcd_bk.enable = 0;
lcd_bk.data = ch;
41
Microcontroladores – Prof. Marcos Zurita
A Linguagem C do CCS
Uniões em C (union)
● Permite a criação de variáveis capazes de suportar dife-
rentes tipos de dados num mesmo espaço de memória.
● Ocupa na memória apenas o tamanho da maior variável 
declarada.
● O tamanho das variáveis pode ser alterado por “:”.
● Sintaxe:
union nome_uniao { 
 tipo1 nome_var1 [:bits];
 tipo2 nome_var2 [:bits];
 (...)
 tipoN nome_varN [:bits];
 } nome_var;
42
Microcontroladores – Prof. Marcos Zurita
A Linguagem C do CCS
Ex.: Uniões em C (union)
● Note que “dado” ora contém um inteiro de 24 bits, ora 
contém um float (32b) ora contém uma string, embora a 
união ocupe 32 bits de memória durante todo tempo.
● Cabe ao programador o conhecimento de qual tipo de 
variável foi armazenada mais recentemente na união.
union d_ifc { // Cria a união “d_ifc” de 32 bits 
 int32 i24:24; // -pode conter um inteiro de 24 bits
 float f; // ou pode conter um float
 char c[3]; // ou pode conter 3 caracteres
 } dado; // “dado”: variável do tipo “d_ifc”
 
dado.i24 = 0x2A5; // “dado” contém um inteiro de 24 bits
dado.f = 3.15; // “dado” contém agora um float
dado.char = 'pi'; // “dado” contém agora uma string
43
Microcontroladores – Prof. Marcos Zurita
A Linguagem C do CCS
Enumerações (Enum)
● Uma enumeração é uma lista de constantes inteiras.
● Sintaxe:
● Por padrão, o primeiro identificador tem valor zero, 
sendo o valor de cada identificador subsequente, o valor 
do identificador anterior + 1.
enum nome_enum {id1 [=v1], id2 [=v2], idN [=vN]}; 
enum semaforo {VERDE, AMARELO=2, VERMELHO};
// VERDE=0, AMARELO=2, VERMELHO=3
enum udcm {UNIDADE=1, DEZENA=10, CENTENA=100, MILHAR=1000};
// UNIDADE=1, DEZENA=10, CENTENA=100, MILHAR=1000
valor = m*MILHAR + c*CENTENA + d*DEZENA + u*UNIDADE;
estado = VERDE;
44
Microcontroladores – Prof. Marcos Zurita
A Linguagem C do CCS
Definição de Tipos (typedef)
● Typedef permite criar um novo tipo de variável, além dos 
tipos nativos da linguagem (int, char, float, etc).
● Sintaxe:
● Exemplo:
● Neste exemplo, “porta” é um sinônimo para int8.
typedef [tipo_qualificador] [nome_tipo] [declaração]; 
typedef int8 porta; // cria um novo tipo chamado “porta”
porta pA, pB; // as variáveis pA e pB são do tipo “porta”
pA = pB = 0x00;
45
Microcontroladores – Prof. Marcos Zurita
A Linguagem C do CCS
Ex.2: Definição de Tipos (typedef)
typedef struct coord{ // cria um novo tipo chamado “coord”
 int32 pos_x:24;
 int32 pos_y:24;
 };
float passo_x, passo_y;
void main() {
 coord coord_ini, coord_fin; // novo tipo sendo usado!
 // instruções...
 passo_x = (coord_fin.x - coord_ini.x)/100;
 passo_y = (coord_fin.y – coord_ini.y)/100;
 // mais instruções...
}
46
Microcontroladores – Prof. Marcos Zurita
A Linguagem C do CCS
Estrutura de Condição “if”
● Executa um comando ou um bloco de comandos caso a 
condição testada seja verdadeira.
void main() 
{
 int x = 10, y = 18;
 if (x >= 10)
 {
 y = 0;
 x = 0;
 }
 else
 y++;
 x++;
}
47
Microcontroladores – Prof. Marcos Zurita
A Linguagem C do CCS
Estrutura de Condição “switch”
● Comparação de diversos valores de uma mesma 
variável.
switch (tecla) 
{
 case 0: y = 1; break;
 case 1: y = 10; break;
 case 2: y = 100;
 x = 0; break;
 default:
 y++;
}
48
Microcontroladores – Prof. Marcos Zurita
A Linguagem C do CCS
Estrutura de Repetição “for”
● Repetição condicional de uma instrução ou bloco
for (i = 0; i < 5; i++) 
{
 y = y * y;
}
for (i = 12; y < 100 < 5; i--)
{
 y = y * 2;
}
49
Microcontroladores – Prof. Marcos Zurita
A Linguagem C do CCS
Estrutura de Repetição “while”
● Executa teste antes de executar o bloco
while (y != 13) 
{
 y++;
 x--;
}
while (1) // loop infinito
{
 ... // codigo
}
50
Microcontroladores – Prof. Marcos Zurita
A Linguagem C do CCS
Estrutura de Repetição “do-while”
● Executa teste após executar o bloco.
do 
{
 y++;
 x--;
}
while (y != 13)
51
Microcontroladores – Prof. Marcos Zurita
A Linguagem C do CCS
Funções
● Conjunto de rotinas agrupadas de modo a realizar uma 
determinada tarefa.
● Melhor maneira de abstrair e agrupar trechos de código 
que se repetem.
● Definida por um nome, um tipo de retorno, argumentos e 
corpo.
● Os argumentos são opcionais, e o retorno, quando não 
for necessário, deve ser void.
52
Microcontroladores – Prof. Marcos Zurita
A Linguagem C do CCS
E.: Funções
void printHelloWord() 
{
 printf(“Hello World!”);
}
int16 soma(int8 a, int8 b)
{
 return a + b;
}
void main()
{
 int16 s = soma(5, 14);
 printf(”soma = %l\n”, s); 
 printHelloWord();
}
53
Microcontroladores – Prof. Marcos Zurita
A Linguagem C do CCS
Operador Ternário
● Também conhecido como “operador de expressão 
condicional”.
● É uma forma compacta da estrutura if-else.
● Sintaxe:
● Exemplo:
condicao ? expressao1 : expressao2; 
minimo = (x<y)? x : y; //retorna o menor argumento
// o código acima equivale a:
if (x<y)
 minimo = x;
else
 minimo = y;
54
Microcontroladores – Prof. Marcos Zurita
A Linguagem C do CCS
Macros
● De maneira semelhante a declaração de constantes, 
macros são um recurso de substituição textual de 
trechos de código, comportando-se de maneira 
semelhante a pequenas funções.
● Sintaxe:
● Exemplo:
#define min(x,y) ((x<y)?x:y) //retorna o menor argumento
int a, b, c, d, menor;
// instruções...
d = min(a,b); // gera o código “d=((a<b)?a:b);”
menor = min(d,c); // gera o código “menor=((d<c)?d:c);”
#define nome_macro(arg1, arg2, ..., argN) expressao; 
55
Microcontroladores – Prof. Marcos Zurita
Bibliografia
● Milan Verle, “PIC Microcontrollers - 
Programming in C”, 1a Ed., MikroElektronika, 
2009.
● Alberto Noboru Miyadaira, “Microcontroladores 
PIC18: aprenda e programe em liguagem C”, 
2a Ed., Editora Érica, 2011.
● Andrew S. Tanenbaum, “Organização 
Estruturada de Computadores”, 5a Ed., 
Pearson, 2006.
● Microchip Tec. Inc., “8-bit PIC 
Microcontrollers”, Data Sheet, 2010.
● Microchip Tec. Inc., “PIC16F87XA - 28/40/44-Pin 
Enhanced Flash Microcontrollers”, Data Sheet, 
2003.
	Slide 1
	Slide 2
	Slide 3
	Slide 4
	Slide 5
	Slide 6
	Slide 7
	Slide 8
	Slide 9
	Slide 10
	Slide 11
	Slide 12
	Slide 13
	Slide 14
	Slide 15
	Slide 16
	Slide 17
	Slide 18
	Slide 19
	Slide 20
	Slide 21
	Slide 22
	Slide 23
	Slide 24
	Slide 25
	Slide 26
	Slide 27
	Slide 28
	Slide 29
	Slide 30
	Slide 31
	Slide 32
	Slide 33
	Slide 34
	Slide 35
	Slide 36
	Slide 37
	Slide 38
	Slide 39
	Slide 40
	Slide 41
	Slide 42
	Slide 43
	Slide 44
	Slide 45
	Slide 46
	Slide 47
	Slide 48
	Slide 49
	Slide 50
	Slide 51
	Slide 52
	Slide 53
	Slide 54
	Slide 55