Linguagem C para sistemas embarcados

Linguagem C
Disciplina: AAM
Profa. Ana Watanabe
17/02/20
 “Porque o SENHOR dá a sabedoria; da sua
boca é que vem o conhecimento e o
entendimento.” Provérbios 2:6
Linguagem C
 Objetivo da aula:
 Revisão da Linguagem;
 Otimização de programa em C para Sistemas
Embarcados.
 Exercício
Revisão da Linguagem C
 Anos 70 de uma linguagem chamada B
por Dennis Ritchie.
 Qualquer programa C ANSI pode ser

compilado em qualquer compilador C
ANSI não importando onde o programa
vai ser rodado.
 Portanto => portabilidade

 Criada por programadores.
 Características:poucas restrições,
código rápido e eficiência.
É a linguagem mais popular entre

os programadores profissionais
altamente qualificados.
 Programação estruturada:
 A linguagem C é uma linguagem estruturada

em bloco simples.
 Declaração de variáveis: Variáveis devem ser

declaradas antes de serem usadas
(compilador saber de antemão);
 Funções: Blocos de Código: Conjunto de
comandos que executa uma determinada
operação no programa.
 Útil quando se necessita repetir um mesmo

trecho de código várias vezes em um
programa.
 Sensitive case: Letras maiúsculas e
minúsculas são tratadas como caracteres
diferenciados.
 Ex.: Podemos declarar uma variável For,

apesar de haver uma palavra reservada for,
mas isto não é uma coisa recomendável de se
fazer pois pode gerar confusão!!
Palavras reservadas:
auto else register un
break enum return un
case extern short vo
char float signed vo
const for sizeof wh
continued goto static
efault if struct
do int switch
double long typedef
 Comentários:
 /* comentário de uma ou várias linhas.

O padrão não permite comentários
aninhados (um dentro do outro), mas alguns
compiladores os aceitam.
*/
 // comentário de uma linha!!!!

 ESTRUTURA BÁSICA DE UM PROGRAMA:
1) INCLUSÃO DE ARQUIVOS EXTERNOS
2) DECLARAÇÃO DE VARIÁVEIS GLOBAIS
3) DECLARAÇÃO DE PROTÓTIPOS DE FUNÇÕES
4) FUNÇÃO PRINCIPAL (main)
5) FUNÇÕES
• Protótipos de Funções:
• Normalmente escrevemos as funções antes de
escrevermos a função main( ).
• Isto é, as funções estão fisicamente antes da

função main( ).
• Se você fosse compilar a função main( ), onde são

chamadas as funções, você teria que saber com
antecedência quais são os tipos de retorno e quais
são os parâmetros das funções para que você
pudesse gerar o código corretamente.
#include <stdio.h>
float Square (float a)

{
return (a*a);
}
int main ( )
{
float num;
num=Square(num);
return 0;
}
 Protótipos de Funções:
 Foi por isto que as funções foram colocadas
antes da função main( ): quando o

compilador chegasse à função main( ) ele já
teria compilado as funções e já saberia seus
formatos.
 Protótipos de Funções:
 Muitas vezes teremos o nosso programa

espalhado por vários arquivos. Ou seja,
estaremos chamando funções em um arquivo
que serão compiladas em outro arquivo.
Como manter a coerência?
• Protótipos de Funções:
• A solução são os protótipos de funções.
Protótipos são nada mais, nada menos, que
declarações de funções. Isto é, você declara uma
função que irá usar. O compilador toma então
conhecimento do formato daquela função antes
de compilá-la. O código correto será então
gerado. Um protótipo tem o seguinte formato:
• tipo_de_retorno nome_da_função
(declaração_de_parâmetros);
 tipo_de_retorno nome_da_função
(declaração_de_parâmetros);
 onde o tipo_de_retorno, o nome_da_função e a
declaração_de_parâmetros são os mesmos que
você pretende usar quando realmente escrever a
função.
 Repare que os protótipos têm uma nítida
semelhança com as declarações de variáveis.

#include <stdio.h>
int main ( ) // Tem algum problema?

{ // Como resolver??
float num;
num=Square(num);
return 0;
}
{
return (a*a);
}
#include <stdio.h>
float Square (float a); // protótipo
int main ( )
{
float num;
num=Square(num);
return 0;
}
{
return (a*a);
}
Tipos de Dados:
• char ( sinalizados –positivo ou negativo)
ou não sinalizado – positivo)
• inteiro ( sinalizados –positivo ou negativo)
ou não sinalizado – positivo)

• real ( valores inteiros ou fracionários –
float ou double)
• nulo ( void – tipo vazio, ou um "tipo sem
tipo". Não retornam e/ou recebem
valores – parâmetros)
Modificadores de Tipos de dados:
 short (reduz a faixa de representação do

tipo)
 long (ampliar a faixa de representação do
tipo)
 signed (para especificar a representação de
valores sinalizados )
 unsigned (para especificar a representação
de valores não sinalizados)

OTIMIZAÇÃO DE PROGRAMA EM C
PARA SISTEMAS EMBARCADOS
http://sergioprado.org/otimizacao-de-codigo-em-linguage
m-c-parte-1
Escrever código para estes dispositivos

requer atenção especial quanto a utilização e
gerenciamento eficiente dos recursos
disponíveis.
Por que?
 Sistemas embarcados têm como uma de

suas principais características a limitação de
recursos computacionais (quantidade de
memória, capacidade de processamento e
dispositivos de I/O).
 Aplicações bem específicas => projetadas na

medida para cumprir sua função.
Vantagens da otimização:
 Diminuir custos do projeto;
 Tempo de desenvolvimento;
 Tamanho do dispositivo;
 Consumo elétrico.
Vantagens da otimização:
 Diminuir custos do projeto;
 Tempo de desenvolvimento;
 Tamanho do dispositivo;
 Consumo elétrico.
 O compilador C transformar os algoritmos

(código-fonte C) em aplicação.
 O compilador realiza uma série de transformações

no código-fonte para gerar o melhor código
possível: Ex.: salva variáveis em registradores ao
invés de usar a memória para melhorar o tempo
de acesso (otimização de processamento) ou
remover código inútil do programa (otimização de
espaço).
 Em um compilador C moderno, o processo de

compilação envolve basicamente os seis passos,
na ordem apresentada:
 1. Pré-processamento: Conversão do código-
fonte em uma linguagem intermediária.
As diretivas de compilação são processadas e a
sintaxe do código é verificada.
 2. Otimização de alto nível: O compilador realiza

a primeira otimização do código em cima do
código-fonte da aplicação.
 Veremos mais adiante algumas das técnicas para

auxiliar o compilador neste trabalho de
otimização.
 3. Geração do código: Geração do código de

máquina para a arquitetura-alvo. Nesta fase o
compilador faz todas as conversões necessárias
para a arquitetura em questão.
 Ex.:
 Expressões aritméticas de 32 bits em
processadores de 8 bits são convertidas em
expressões aritméticas de 8 bits, por exemplo.
 4. Otimização de baixo nível: A otimização é

realizada em cima do código-objeto gerado na
fase anterior, como por exemplo removendo
instruções não usadas ou redundantes.
 5. Assembler: Nesta etapa o compilador gera o

arquivo-objeto correspondente ao arquivo-fonte
C compilado.
 6. Linkagem: O compilador faz a linkagem de

todos os arquivos-objeto em um único arquivo
binário para ser carregado na memória do
dispositivo.
 Etapas para otimização:

 Etapa 2 (Otimização de alto nível) e
 Etapa 4 (Otimização de baixo nível).
Técnicas que podem auxiliar e

instruir o compilador na tarefa de
otimizar o código gerado:
A) O tempo de acesso aos registradores da CPU é
normalmente muito mais rápido do que o tempo
de acesso à memória de dados, e o processador
possui melhor performance quando realiza
cálculos utilizando registradores ao invés de
memória.
 => O compilador procura alocar variáveis locais e
parâmetros para funções em registradores para

melhorar a performance do sistema.
 Pode-se instruir o compilador através da palavra-
chave register, conforme mostra o código:
int exp(register int base, register int expoente) {

register int resultado = 1;
for (; expoente; expoente--)
resultado *= base;
return(resultado); }
 Devemos ressaltar que nem sempre será possível alocar
todas as variáveis em registradores.
 A palavra-chave register é apenas uma orientação para

auxiliar o compilador a decidir quais variáveis são mais
prioritárias para a alocação em registradores.
 Por este motivo é importante ter um código modular,

com funções pequenas e específicas, para que a
quantidade de variáveis locais também seja pequena,
aumentando as chances de que estas sejam otimizadas
através do armazenamento em registradores.
B) Funções
 Uma chamada de função é um processo complexo

e deve ser levado em consideração quando
pensamos em performance. Basicamente, antes de
uma chamada à função o compilador salva em
memória (ou registradores) os argumentos da
função e o endereço de retorno.
 Essa região de memória é chamada de stack.
Dentro da função chamada, os registradores são
salvos, parâmetros são lidos do stack ou de
registradores, e variáveis locais são alocadas em
memória ou em registradores (se disponíveis).
 Funções com uma quantidade grande de

parâmetros => custo de uma chamada pode ser
enorme para a performance do sistema.
 Como melhorar a performance?
 Diminuir a quantidade de parâmetros passados
para funções.
 O custo de chamada da função atualiza_dados()

com 5 parâmetros >> o custo de chamada da
função atualiza_dados_otimizada() que recebe
apenas um ponteiro para uma estrutura de dados
como parâmetro.
void atualiza_dados(char nome, char endereco, char cidade, char
telefone, double salario)
{
...
} //
OU
//OU
typedef struct {
char nome;
char endereco;
char cidade;
char telefone;
double salario;
}tdados;
void atualiza_dados_otimizada(tdados *cliente)

{
... cliente->nome = “Maria”;
}
C) Inlining de funções:
 A chamada à função é substituída por uma cópia
do seu código através da definição de macros.
 No primeiro exemplo, a função soma( ) será

chamada 100 vezes, diminuindo a performance do
sistema.
int soma(int a, int b)
{
return(a + b);
}
int main( ) {
int i, res, a = 1;
/* primeiro exemplo */
for (i = 0; i < 100; i++)
res = soma(a, res);
}
C) Inlining de funções:
 Como usar macros eliminando a chamada

à função e conseqüentemente aumentando
a performance do sistema?
#define SOMA(a, b) (a + b) // macro

Como reescrever o código?????
int main( ) {
int i, res, a = 1;
}
#define SOMA(a, b) (a + b)
int main( ) {
int i, res, a = 1;
for (i = 0, i < 100; i++)

res = SOMA(a, res);
}
D) Otimização do compilador
O compilador pode ser instruído para compilar o
programa priorizando tempo de processamento
(speed optimization) ou tamanho de código (size
optimization).
 É sempre bom testar as duas opções no seu

código e verificar os resultados, antes de definir
a otimização ótima para seu projeto.
E) Tamanho das variáveis
 o compilador compila o código otimizado para a
arquitetura-alvo do seu sistema.

 Se o microprocessador é de 8 bits, os cálculos
terão maior performance se realizados com 8 bits

de dados, em variáveis do tipo char.
 Da mesma forma, se você estiver trabalhando com
processadores de 32 bits, os cálculos terão maior

performance se realizados com variáveis do tipo
int.
 Por que? O compilador realiza os cálculos com
base no tamanho de seus registradores, que por
sua vez são baseados na arquitetura da CPU.
 Se a sua CPU é de 32 bits (registradores de 32

bits), e se você está realizando cálculos com
variáveis char (8 bits), nesta arquitetura, o
compilador terá o esforço extra de converter o
resultado final, de 32 bits, em uma variável de
8 bits.
F) Incremento de variáveis
 É muito mais eficiente incrementar variáveis com o
uso de operadores de incremento (ex: ind++) do

que o comando de atribuição (ex: ind = ind + 1).
 Isso porque a maioria dos compiladores usam, se

disponível, a instrução de incremento do
processador, o que torna o código-objeto gerado
muito mais otimizado. Exemplo:
/* incremento com atribuicao */
x = x + 1;
/* codigo gerado em assembly

mov A, x ; carrega o valor de x no registrador A
add A, 1 ; soma 1 ao registrador A
mov x, A ; carrega de volta o valor do registrador A em x
*/
/* operador de incremento */
x++;
/* codigo gerado em assembly
inc x; incrementa x em 1 */
G) Protótipos para funções
 Se o protótipo da função não é devidamente
definido, o compilador precisará “adivinhar” quais

os tipos de dados com que sua função trabalha, o
que diminui bastante a performance do sistema.
H) Códigos muito “inteligentes”
 Alguns programadores acreditam que, ao escrever
em poucas linhas de código fazendo uso

“inteligente” de construções complexas em
linguagem C, deixarão o código menor e mais
rápido.
 Cuidado nem sempre o compilador vai criar
códigos menores e pode tornar o código quase

indecifrável!
I) Uso de bibliotecas
 O uso da função de uma biblioteca, ex.: printf( )
pode trazer junto com ela, implicitamente, outras

funções necessárias para sua utilização=> pode
aumentar muito o tamanho do seu código.
 Portanto, sistemas embarcados com poucos

recursos disponíveis => melhor implementar
uma função simples sem uso de uma biblioteca.
Exercício para nivelamento:
 Escreva um programa que faça o seguinte:
 1)Crie uma função que retorna um valor após decrementar

b vezes o parâmetro de entrada a. Exemplo: int função
(a,b).
 2) Faça uma nova versão utilizando endereço da estrutura

(ponteiro) como parâmetro de entrada para otimização.
Use protótipo, operador de decremento e registradores

para otimizar!!!
Sugestão da parte 1:
#include <avr/io.h>
int sub(register int a, register int b); // protótipo
void main (void)

{
register int a,b, resultado;
a = 10;
b= 3;
resultado=sub(a,b);
}
int sub(register int a,register int b)

{
register int i;
for (i = 0; i < b; i++)
a--;
return (a);
}

Sugestão do 2: #include <avr/io.h>
typedef struct {
int a;
int b;
} tvalores;
int sub(tvalores *c); // protótipo
void main (void)

{
tvalores conta;
int resultado;
conta.a = 10;
conta.b= 3;
resultado=sub(&conta);
}
int sub (tvalores *c)

{
int i;
for (i = 0; i < c->b; i++)
c->a--;

Linguagem C para sistemas embarcados

Enviado por

Dados do documento

Descrição original:

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Linguagem C para sistemas embarcados

Enviado por

Direitos autorais:

Formatos disponíveis

Linguagem C

 Qualquer programa C ANSI pode ser

 Portanto => portabilidade

É a linguagem mais popular entre

 A linguagem C é uma linguagem estruturada

 Declaração de variáveis: Variáveis devem ser

 Útil quando se necessita repetir um mesmo

 Ex.: Podemos declarar uma variável For,

 /* comentário de uma ou várias linhas.

 // comentário de uma linha!!!!

1) INCLUSÃO DE ARQUIVOS EXTERNOS

2) DECLARAÇÃO DE VARIÁVEIS GLOBAIS

3) DECLARAÇÃO DE PROTÓTIPOS DE FUNÇÕES

4) FUNÇÃO PRINCIPAL (main)

• Isto é, as funções estão fisicamente antes da

• Se você fosse compilar a função main( ), onde são

float Square (float a)

antes da função main( ): quando o

 Muitas vezes teremos o nosso programa

semelhança com as declarações de variáveis.

int main ( ) // Tem algum problema?

ou não sinalizado – positivo)

 short (reduz a faixa de representação do

de valores não sinalizados)

Escrever código para estes dispositivos

 Sistemas embarcados têm como uma de

 Aplicações bem específicas => projetadas na

 O compilador C transformar os algoritmos

 O compilador realiza uma série de transformações

 Em um compilador C moderno, o processo de

 2. Otimização de alto nível: O compilador realiza

 Veremos mais adiante algumas das técnicas para

 3. Geração do código: Geração do código de

 4. Otimização de baixo nível: A otimização é

 5. Assembler: Nesta etapa o compilador gera o

 6. Linkagem: O compilador faz a linkagem de

 Etapas para otimização:

Técnicas que podem auxiliar e

parâmetros para funções em registradores para

int exp(register int base, register int expoente) {

 A palavra-chave register é apenas uma orientação para

 Por este motivo é importante ter um código modular,

 Uma chamada de função é um processo complexo

 Funções com uma quantidade grande de

 O custo de chamada da função atualiza_dados()

void atualiza_dados_otimizada(tdados *cliente)

do seu código através da definição de macros.

 No primeiro exemplo, a função soma( ) será

 Como usar macros eliminando a chamada

#define SOMA(a, b) (a + b) // macro

for (i = 0, i < 100; i++)

 É sempre bom testar as duas opções no seu

arquitetura-alvo do seu sistema.

terão maior performance se realizados com 8 bits

processadores de 32 bits, os cálculos terão maior

 Se a sua CPU é de 32 bits (registradores de 32

uso de operadores de incremento (ex: ind++) do

 Isso porque a maioria dos compiladores usam, se

/* codigo gerado em assembly

definido, o compilador precisará “adivinhar” quais

em poucas linhas de código fazendo uso

códigos menores e pode tornar o código quase