UFPI-Microcontroladores 6-Linguagem C-v1 2

Universidade Federal do Piauí
Centro de Tecnologia
Curso de Engenharia Elétrica
MICROCONTROLADORES
Linguagem C
Prof. Marcos Zurita

zurita@ufpi.edu.br
www.ufpi.br/zurita
Teresina - 2012
Sumário
● 1. Introdução
● 1.1. C vs Assembly
● 2. Compiladores
● 3. A Linguagem C do CCS
● Bibliografia
2
Microcontroladores – Prof. Marcos Zurita
1. Introdução
3
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
4
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
5
Introdução
Como Projetar Sistemas com Microcontroladores
Despeça-se da sua
família e de seus
pais por alguns
dias...
Abasteça seu Estude o dispositivo que

mascote com boas será controlado pelo
reservas de ração microcontrolador.
6
Introdução
Examine “todos” os
microcontroladores
de que você dispõe
(n° de E/S, conver-
sores, temporiza- Projete e, se possível,
dores, etc.) construa um protótipo
do sistema que será con-
Escolha o que melhor atende trolado pelo uC, incluindo
aos requisitos de funciona- periféricos que serão utiliza-
mento do sistema desejado. dos na aplicação real.
7
Introdução
Escreva o programa
em uma linguagem
de alto nível para
programar o uC.
Escolha também um
simulador para Com alguns pucos cliques o
auxiliar o programa inteiro se converte
desenvolvimento. em algo compreensível pelo
uC. Utilize um gravador para
programa-lo.
8
Introdução
Agora o uC já está suficientemente ma- Feito! Desfrute o sucesso da empreitada

duro para começar a dar retorno a e comece a pensar em novos projetos.
sociedade! Coloque o chip programado
no sistema, respire fundo e ligue-o!
9
2. Compiladores
10
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 Microcontroladores – Prof. Marcos Zurita
11
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 12
3. A Linguagem C do CCS
13
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
14
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 15
Modificadores de Tipo
● Alteram o tamanho ou a forma com que os tipos são
tratados.
● signed
● unsigned
● short
● long
16
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
17
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;
18
Matrizes
● Definem um conjunto de elementos do mesmo tipo
(tamanho fixo):
int v[10]; // conj. de 10 inteiros
● Cada elemento deste conjunto pode ser acessado

através de seu índice no conjunto (1º elemento = índice
0):
b = v[2]; // “b” recebe o 3º elemento de “v”
v[0] = 34; // atribui 34 ao 1º elemento de “v”
19
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};
20
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”};
21
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:
(tipo_destino) expressao_a_ser_convertida;
● Exemplo:
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
22
● 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á num caractere cujo valor ASCII
corresponde ao número dado. 23
● 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!
24
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.
25
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);

}
26
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;
27
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);

}
28
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:
tipo *nome_do_ponteiro;
● 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.
29
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=25”
30
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).
31
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);

}
32
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 33
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)
34
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 = 23
z--; // z = 3
printf(”x = %i\n”, x);

printf(”y = %i\n”, y);
printf(”z = %i\n”, z);
printf(”f = %f\n”, f);
}
35
Operadores Relacionais e Lógicos

Comparação Entre Valores
> Maior que
>= Maior ou igual a
< Menor que
<= Menor ou igual a
== Igual a
!= Diferente de
Realizam Operações Lógicas (V ou F)

&& 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)
36
Operadores de Bits
● Manipulam bits em valores inteiros.
>> 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
37
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
38
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];
(...)
tipoN nome_varN [:bits];
} nome_var;
39
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;
40
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 {
(...)
tipoN nome_varN [:bits];
} nome_var;
41
Ex.: Uniões em C (union)

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
● 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.
42
Enumerações (Enum)
● Uma enumeração é uma lista de constantes inteiras.
● Sintaxe:
enum nome_enum {id1 [=v1], id2 [=v2], idN [=vN]};
● Por padrão, o primeiro identificador tem valor zero,

sendo o valor de cada identificador subsequente, o valor
do identificador anterior + 1.
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; 43
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:
typedef [tipo_qualificador] [nome_tipo] [declaração];
● Exemplo:
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;
● Neste exemplo, “porta” é um sinônimo para int8.

44
Ex.2: Definição de Tipos (typedef)

typedef struct coord{ // cria um novo tipo chamado “coord”
int32 x:24;
int32 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...
}
45
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++;
}
46
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++;
}
47
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;
}
48
Estrutura de Repetição “while”

● Executa teste antes de executar o bloco
while (y != 13)
{
y++;
x--;
}
while (1) // loop infinito

{
... // codigo
}
49
Estrutura de Repetição “do-while”

● Executa teste após executar o bloco.
do
{
y++;
x--;
}
while (y != 13)
50
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.
51
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();
}
52
Operador Ternário
● Também conhecido como “operador de expressão
condicional”.
● É uma forma compacta da estrutura if-else.
● Sintaxe:
condicao ? expressao1 : expressao2;
● Exemplo:
minimo = (x<y)? x : y; //retorna o menor argumento
// o código acima equivale a:

if (x<y)
minimo = x;
else
minimo = y;
53
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:
#define nome_macro(arg1, arg2, ..., argN) expressao;
● 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);”
54
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.
55

UFPI-Microcontroladores 6-Linguagem C-v1 2

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

UFPI-Microcontroladores 6-Linguagem C-v1 2

Загружено:

Авторское право:

Доступные форматы

Universidade Federal do Piauí

Prof. Marcos Zurita

Como Projetar Sistemas com Microcontroladores

Abasteça seu Estude o dispositivo que

Agora o uC já está suficientemente ma- Feito! Desfrute o sucesso da empreitada

Alguns Compiladores para PIC

Variáveis e Tipos de Dados

Tipos Disponíveis no CCS C

● Cada elemento deste conjunto pode ser acessado

int p[16][16]; // matriz bidimensional 16x16

p[0][0] = 200; // atribui 200 ao elemento 0,0

msg = ”Transmitancia”; // preenche 13 caracteres

Casting - Conversão de Tipos

adc = faz_conversao_AD(); // “adc” está entre 0 e 1023

variável sem sinal: pode gerar resultados inesperados

bits é maior que o da variável de destino: o resultado

gera o caractere do número (i.e., (char)5 ≠ '5'), o invés

Variáveis Globais e Locais

● Só são destruídas no encerramento do programa.

Ex.: Variável global vs local

int x = 3; // variável global

printf(”Soma = %i”, x);

Ex.: Modificador Static

int x = 3; // variável global

printf(”Coisa = %x”, x);

● A manipulação de ponteiros requer dois operadores:

int *ptr; // ptr é um ponteiro para int

ptr = &x; // ptr agora aponta para “x”

ptr = &y; // ptr agora aponta para “x”

#define COISA 25 //const. tipo int

printf(”Coisas = %f”, j);

Ex.: Operadores Aritméticos

printf(”x = %i\n”, x);

Operadores Relacionais e Lógicos

Realizam Operações Lógicas (V ou F)

Ex.: Operadores de Bits

z = ~sm; // y agora vale 0b01110011

x = sm >> 3; // x agora vale 0b00010001

k = x | y; // k agora vale 0b00110001

Ex.: Registros em C (struct)

Ex.: Uniões em C (union)

dado.i24 = 0x2A5; // “dado” contém um inteiro de 24 bits

● Note que “dado” ora contém um inteiro de 24 bits, ora

● Por padrão, o primeiro identificador tem valor zero,

enum udcm {UNIDADE=1, DEZENA=10, CENTENA=100, MILHAR=1000};

valor = m*MILHAR + c*CENTENA + d*DEZENA + u*UNIDADE;

Definição de Tipos (typedef)

porta pA, pB; // as variáveis pA e pB são do tipo “porta”

● Neste exemplo, “porta” é um sinônimo para int8.

Ex.2: Definição de Tipos (typedef)

float passo_x, passo_y;

passo_x = (coord_fin.x - coord_ini.x)/100;

Estrutura de Condição “if”

Estrutura de Condição “switch”

Estrutura de Repetição “for”

for (i = 0; i < 5; i++)

for (i = 12; y < 100 < 5; i--)

Estrutura de Repetição “while”

while (1) // loop infinito

Estrutura de Repetição “do-while”

int16 soma(int8 a, int8 b)

printf(”soma = %l\n”, s);

// o código acima equivale a:

valor = mMILHAR + cCENTENA + dDEZENA + uUNIDADE;