PROGRAMAO C

ANSI
PARA
MICROCONTROLADO
RES
Dr. Ivo Reis Fontes
ivo@feb.unesp.br

COMPILADORES
Compiladores so programas utilizados para produzir o
cdigo executvel para uma determinada CPU a partir
do programa fonte escrito em linguagem de
programao.
Tipos de Compiladores:
Compiladores
Direto;
Dois passos.

Compilador Direto: Produz o cdigo executvel a partir

da compilao (.obj) e montagem do cdigo executvel
(.hex).
Dois Passos: Primeiramente o compilador produz o
cdigo assembly (.asm) para depois produzir o cdigo
executvel (.obj e .hex).

COMPILADORES C
Histrico da Linguagem C:
Programas que executam tarefas ligadas s funes do
sistema
operacional
ou
instrues
do
microprocessador/microcontrolador normalmente necessitam
ser codificados em linguagem de montagem ( assembly).
assembly A
linguagem C foi desenvolvida para resolver este problema de
forma menos penosa e mais porttil.
A linguagem C considerada de mdio nvel por possuir
controle de fluxo e estrutura de dados de forma semelhante
s linguagem de alto nvel, e ao mesmo tempo, proporcionar
facilidades que s esto disponvel em linguagem de baixo
nvel (assembly).
assembly
O C Ansi foi projetado em 1972 nos laboratrios da Bell por
Brian W. Kernighan e Dennis M. Ritchie, para o sistema
operacional UNIX..

COMPILADORES C
Principais caractersticas da Linguagem C:
Alto nvel de portabilidade, pois programas-fonte podem ser
transportados para outras CPUs sem maiores dificuldades;
de uso geral, sendo eficiente tanto para programao de
utilitrios como para sistemas operacionais, processadores
de texto, banco de dados e sistemas aplicativos em geral;
Gera cdigo executvel compacto e rpido em relao
maioria das outras linguagens compiladas, caracterstica
desejvel para computadores que tm memria reduzida;
Total interao com o sistema operacional, insero de
cdigo assembly no programa-fonte, sendo assim, ilimitada
por software;
Sintaxe de poucos comandos e grande nmero de
operadores aritmticos e lgicos;
Estruturada e modular
Permite estruturas de dados compostos na forma de
registros e campos.

COMPILADORES C
Compiladores C so programas utilizados para
produzir o cdigo executvel para uma determinada
CPU a partir do programa fonte escrito em
linguagem de programao C.
Tipos de Compiladores:
Compiladores
Direto;
Dois passos.

Compilador Direto: Produz o cdigo executvel a

partir da compilao (.obj) e montagem do cdigo
executvel (.hex).
Dois Passos: Primeiramente o compilador produz o
cdigo assembly (.asm) para depois produzir o
cdigo executvel (.obj e .hex

PROCESSO DE COMPILAO

ESTRUTURA DO CDIGOFONTE
[</*
comentrios */>]
[< incluses de arquivos de definies >]
[< declarao de prottipos de funes >]
[< declarao de variveis globais >]
[< tipo >] main([< tipo > varivel ]){
/*
corpo da funo principal main( )...
*/
[ return(var); ]
}
[
[< tipo >]func([< lista de parmetros >])
[< declarao de parmetros >]
{
/*
corpo da funo fun( )...
*/
}
]

ENTRADA E SADA
Funes de Entrada e Sada
As funes de entrada e sada de dados de um programa C so:

getchar() l um caracter (byte) da entrada padro

putchar() escreve um caracter (byte na sada padro
gets() l uma cadeia de caracteres (bytes) da entrada padro
puts() escreve uma cadeia de caracteres (bytes na sada padro
scanf() l entrada formatada de dados (usa a funo getchar())
printf() escreve sada formatada de dados (usa a funo putchar())

Exemplos da Entrada e Sada

var1 = getchar();
/* observe que esta funo no necessita de
parmetros */
putchar(var1);
nome = gets(); /* nome um vetor do tipo char p.e. char nome[20] */
puts(nome);
/* nome um apontador (pointer) do tipo char */
scanf(Entre com o seu nome: %s, nome);
printf(Hello World!.../nHoje completa %d dias que sei programar C/n, dias);

VARIVEIS E CONSTANTES
Os valores que so processados por um programa C so
guardados em variveis de diversos tipos.
A formao dos nomes das variveis, funes e constantes
simblicas se d a partir de quatro regras bsicas:
Todo nome deve comear com uma letra ou com uma sublinha (_);
Os prximos caracteres podem ser letras, sublinhas ou nmeros;
O nome pode ser de qualquer tamanho (com significncia limitada a 8 ou
mais caracteres, dependendo do compilador).
Existem certos identificadores que so palavras-chave (keywords) da
linguagem e que por isso no pdem ser usados para nomear variveis e
funes:
auto
break
case
char
continue default do
double
else
entry
extern
float
for
goto
if
int
long
register return
short
sizeof
static
struct
switch
typedef union
usigned while

TIPOS DE DADOS
Cada varivel possui um tipo e em C toda varivel
utilizada em um programa deve ser previamente,
conforme a sintaxe abaixo.
<tipo> <lista de variveis>;

Tipos de variveis em C so:

char
/* contm um caractere ASCII, ocupa 1 byte da
memria de dados */
int
/* contm valores numricos inteiros positivos ou
negativos, ocupa 2 bytes da memria de dados */
short
/* mesmo que os inteiros porm podem ocupar menor
nmero de bytes da memria de dados */
long
/* contm valores inteiros e maior valor, ocupam 4
bytes da memria de dados */
unsigned
/* valores inteiros sem representao de sinal */
float
/* nmeros reais de ponto flutuante, ocupam 4 bytes de
memria de dados*/
double /* nmeros reais como o float maiores, ocupam 8 bytes
da memria de dados */

TIPOS DE DADOS

CONTINUAO

- Caracteres
Constantes caracteres ficam entre plics () e so
representados pelo valor ASCII:
a, A, *, 2, ?

Existem caracteres que no so imprimveis (i.e. no possuem

um smbolo visvel e que tm funes especfica s:

\0 - nulo corresponde ao cdigo ASCII = 0

\n- comando newline de nova linha
\t- comando tab de tabulao
\b - comando back-space volta uma posio
\r - comando de retorno de carro CR
\f- comando form-feed comando de nova pgina
\\ - barra invertida
\ - plic
nnn - representao de um byte na base octal, p.e. O33 =
caracter scape
\xnn- representao de um byte na forma hexadecimal

TABELA ASCII

TABELA ASCII

EXTENDIDA

TIPOS DE DADOS

CONTINUAO

- Cadeia de Caracteres (String)

Alem dos caracteres isolados podemos representar cadeias
de caracteres, que so dispostas entre aspas:
Nome[ ] = Ivo Reis Fontes\n;

- Inteiros
Valores numricos do conjunto dos inteiros (Z) com ou sem
sinal podem assumir os valores:
-32768 x 32767 Importante: Os valores negativos so
armazenados na
forma de complemento de 2.

TIPOS DE DADOS

CONTINUAO

- Longos
Para diferenci-los das constantes do tipo int, os tipos long tm
sufixo L
3241L, 0L, 130000000L

- Hexadecimal
Os valores hexadecimais so representados com o prefixo 0x:
0x
0x41, 0Xffff, 0xa0, 0xC1da, 0xC1FE

- Ponto Flutuante
Os nmeros reais possuem ponto decimal e podem ou no ser
acompanhados de sinal:
3.14, 2.71, -5423.7265, 1.

REPRESENTAO DOS DADOS NA

MEMRIA
- Character (char)

Cada valor do tipo char armazenado na forma de um byte:

Exemplos:
char c;
c = A
\x41 = \101

= 0x41 = 65 =

REPRESENTAO DOS DADOS NA

MEMRIA
- Inteiro (int)

CONTINUAO

Cada valor do tipo int armazenado na forma de 2 bytes:

Exemplo:
int var1 = 1986;

e var1 = -1986 ter a forma (complemento de 2):

2

REPRESENTAO DOS DADOS NA

MEMRIA
Inteiro CONT.

CONTINUAO

A ordem de posicionamento na memria dos dois bytes

depende do sistema, que pose ser do tipo:
Little Indiam (byte lsb no endereo de memria menos significativa)
Big Indiam (byte lsb no endereo de memria mais significativa)

Exemplo de programao (prog01.c):

main(){
int
int

parc_1 = 56,
parc_2 = -47,
soma;

soma = parc_1 + parc_2;

printf(%d, soma);
}

REPRESENTAO DOS DADOS NA

MEMRIA
CONTINUAO
- ponto flutuante
(float)
Cada valor do tipo float armazenado na forma de 1 byte
para o expoente e os restantes armazenam a base.
O nmero total de bytes depende da arquitetura da CPU do computador.

OPERADORES
Operador de Atribuio Simples
A operao mais simples atribuio de um valor a uma varivel:
Exemplo:
var = 10;
string_1[ ] = Primeira string definida no programa!...;

Operadores Aritmticos
Os operadores aritmticos bsicos e que so comuns a todas as
linguagens de programao, so:
Soma
Subtrao
Multiplicao
Diviso

+
*
/

OPERADORES

CONTINUAO

Operadores Aritmticos (especficos da linguagem)

Os operadores aritmticos especficos da linguagem C so:
Diviso modulo 10
Auto incremento ++
pr-incremento ++var;
ps-incrementovar++;
Auto decremento - pr-decremento
ps-decremento
Negao

- -var;
var--;

Exemplo:
resto = dividendo % divisor;
x = x + 1 = x++ = x +=1

OPERADORES

CONTINUAO

Operadores Relacionais
Os operadores aritmticos especficos da linguagem C so:
Se iguais
Se Menor ou Igual
Se Maior ou Igual
Se no igual

Exemplo:
If((x1==x2) && (x1 != x3)){
...
}
do{
...
}while(x3 <= 10);

==
<=
>=
!=

OPERADORES

CONTINUAO

Operadores Lgicos
Os operadores lgicos da linguagem C so:
Se e (AND)
Se ou (OR)
Se no (NOT)

&&
||
!

Exemplo:
If((x1 && x2)||(x1 && x3)){
...
}
do{
...
}while(x3 != 10);

Operadores Tamanho de Varivel

Os operadores tamanho em bytes de uma varivel em C
int var1,var2;

var2 = sizeof (var1);

(var2 = 2)

OPERADORES

CONTINUAO

Operador ?
O operador ? (atribuio) tem a seguinte sintaxe:
<expresso lgica> ? <expresso-1> : <expresso-2>
Operao: Se a expresso lgica for verdadeira, ento expresso-1 aplicada, do
contrrio, a expresso-2 ser aplicada.

Exemplo:
#include <stdio.h>
Main(){
char
a,b,z;
a = getchar();
b = getchar();
z = (a > b) ? a : b;
/* se o teste lgico for verdadeiro z=a, seno z=b */
printf(O maior valor = %c,z);
}

OPERADORES

CONTINUAO

Operador de Converso Automtica

Da mesma forma que as outras linguagens de programao,
possvel converter tipos de dados utilizando-se o operador:
(<tipo>) <expresso>

Exemplos:
float
valor = 3.1415926535;
...
valor = (float) ((long) (valor * 100. + 0.5))/100.
Operao: Arredonda valor com duas casas decimais e aps a execuo da
expresso valor ser igual a 3.14.
int

valor = 0x0102;

...
valor = (int) ((char) valor);
Operao: Aps a execuo da expresso valor ser igual a 2.

OPERADORES

CONTINUAO

Precedncia de Operadores

CONTROLE DE FLUXO
Introduo
C uma linguagem com caractersticas estruturadas, isto , seus comandos
para controle de fluxo so baseados em repetio de blocos de comando,
possuindo cada bloco apenas uma entrada e uma sada bem definidas.
Define-se um comando como uma expresso seguida de um ponto-e-vrgula
( ; ); ou como um bloco de comandos delimitados por { e }; ou como um
comando de controle de fluxo.
Tomando como base esta afirmativa, so exemplos de comandos:
a) printf(Teste\n);
b) a = 2;
c) {
/* comando composto! */
a = b;
b = c;
c = a;
}
d) while ((a[i] > 0) && (i < 10))
i++;

CONTROLE DE FLUXO

CONTINUAO

Comandos:
- if
If o comando mais simples que existe em termos de controle de fluxo. Ele seleciona
a execuo de um comando se uma expresso lgica for verdadeira (quando
avaliada for diferente de zero) ou, opcionalmente, a execuo de um outro comando no
caso da expresso lgica ser falsa (quando avaliada for zero).

Sintaxe:
a) If (<expresso>)
<comando>
b) If (<expresso>)
<comando-1>
else
<comando-2>
Operao:
a) A <expresso> avaliada. Se for verdadeira o <comando> ser executado. Seno,
o prximo comando ser executado.
b) A <expresso> avaliada. Se for verdadeira o <comando-1> ser executado.
Seno, o <comando-2> ser executado.

CONTROLE DE FLUXO
Exemplos
a) If (a < 0)
printf(valor negativo);
b) if (a > 0)
z = a;
else
z = b;
c) If (a == b)
z = a + 1;
else
z = a +2;
d) If (x )
printf(x diferente de zero!);

CONTINUAO

CONTROLE DE FLUXO

CONTINUAO

- switch
A linguagem C oferece ao programador este comando que possibilita a
tomada de mltiplas decises baseada em uma expresso.
Sintaxe:
Switch ( <expresso> )
{
case <constante-1>:
<comando-1>
case <constante-1>:
<comando-2>
...
case <constante-n>:
<comando-n>
default:
<comando-z>
}

CONTROLE DE FLUXO

CONTINUAO

Operao
A <expresso> avaliada e se houver um case igual a expresso avaliada,
a execuo do programa continuar a partir do comando correspondente.
Exemplo
c = getchar( );
switch (c)
{
case 1:
insere( );
break;
case 2:
retira( );
break;
case 3:
case 4

altera( );
break;
:
list_rel( );
break;

default:
impr_erro( );
}

CONTROLE DE FLUXO

CONTINUAO

- while
O while utilizado para a execuo de um bloco de comandos enquanto
uma condio lgica for verdadeira.
Sintaxe:
while (<expresso>)
<comando>

Exemplo
while ((c=getchar( ) != 0)
{
c +=0x40;
printf(A letra maiscula digitada : %c,c);
};
while com a <expresso> vazia considerado como verdadeiro e representa um loop
infinito.

Exemplo
while ( );
equivalente a (

SJMP

* ) em assembly.

CONTROLE DE FLUXO

CONTINUAO

- for
O for um comando de repetio extremamente poderoso e um velho
conhecido das linguagens de programao. Em C ele existe em uma forma
parecida com a convencional, embora tenha uma filosofia elegante que lhe
permite construes bem mais versteis.
Sintaxe:
for (<expresso-1>; <expresso-2; expresso-3)
<comando>
equivalente a:
<expresso-1>
while (<expresso-2)
{
<comando>
expresso-3
}
Qualquer uma das partes do for pode ser omitida!

CONTROLE DE FLUXO

CONTINUAO

Exemplo
Maior = -32768;
for (i = 0; i < 100; i++)
if (val[i] > maior)
maior = val[i];

- do-while
O do-while mais conhecido em outras linguagens por uma variante com o
nome de repeat-until outra forma estruturada para controle de fluxo na
execuo repetida de um bloco de comandos enquanto uma expresso tiver
valor verdadeiro.
verdadeiro A diferena deste comando para o while que a
avaliao da expresso feita aps a execuo do comando.
Sintaxe:
do
{
<comando>
...
}while( <expresso>);

CONTROLE DE FLUXO

CONTINUAO

Exemplo
do
{
c = getchar( );
}while (c < 1 || c > 5);

- break - continue
Algumas vezes torna-se necessrio o controle da execuo de uma iterao
independentemente do teste lgico efetuado. Com esta finalidade tem-se os
comandos break e continue.
continue
- goto - rtulos
Embora seja uma linguagem estruturada, o C possui o to controvertido
comando de desvio incondicional goto.
goto
Sintaxe
goto <rtulo>

CONTROLE DE FLUXO
Exemplos
- break
while (<expresso-1)
{
.
.
.
if (expresso-2)
break;
.
.
.
}
<comando>

CONTINUAO

CONTROLE DE FLUXO
Exemplos
- continue
while (<expresso-1)
{
.
.
.
if (expresso-2)
continue;
.
.
.
}
<comando>

CONTINUAO

CONTROLE DE FLUXO
Exemplos
- goto & label
while (<expresso-1)
{
.
.
.
if (expresso-2)
goto ERRO;
.
.
.
}
ERRO:
<comando>

CONTINUAO

USO DE INTERRUPES DO 8051

Interrupo o processo atravs do qual a execuo de um programa pode
ser interrompida de forma assncrona por um evento interno/externo. Associada
ao evento existe uma rotina de servio (ISR)

No DE INTERRUES:

2 EXTERNAS
2 TMRs
1 SERIAL

REGISTROS ASSOCIADOS:
IE
IP
TCON

USO DE INTERRUPES DO 8051

CONTINUAO

CONTINUAO
ESQUEMA
DE INTERRUPO

USO DE PERIFRICOS DO 8051CONTINUAO

REGISTROS

EXT1

TMR1

SERIAL

IE Interrupt Enable

USO DE INTERRUPES DO 8051

CONTINUAO

REGISTROS CONT.

TCON Timer Control

USO DE INTERRUPES DO 8051

CONTINUAO

VETOR DE INTERRUPO
Cada interrupo atendida por uma ISR (Interrupt Service Routine)
apontada para as seguintes posies de memria:

RESET
INT0
TMR0
INT1
TMR1
UART

IE0
TF0
IE1
TF1
RI+TI

00H
03H
0BH
13H
1BH
23H

O + indica OU!

USO DE INTERRUPES DO 8051 EM

ASSEMBLY CONTINUAO
A seguir apresentada a sequncia de eventos em ciclos de mquina no
atendimento de uma interruo

USO DE INTERRUPES DO 8051 EM

ASSEMBLY CONTINUAO
EXEMPLO DO USO DE INTERRUPO (em Assembly)
A seguir apresentado um exemplo que faz uso da interruo externa INT1
para acender 4 LEDs ligados aos 4 bits menos significativos da porta P1,
sequencialmente.
Observao: Considere que uma chave SW est conectada entrada INT1, ou
seja, pino P3.3 !
;LED_INT1.ASM
DEFSEG PROG, CLASS=CODE, START=0
SEG PROG
;
ORG RESET
AJMP INICIO
;
ORG EXTI1
AJMP EXT1
;

USO DE INTERRUPES DO 8051 EM

ASSEMBLY CONTINUAO

EXEMPLO DO USO DE INTERRUPO CONT.

INICIO:

ORG 50H
MOV
A,#11101110B
CLR
C
MOV
P1,A
SETB
EX1
;HABILITAR INT. EXT. 1
SETB
EA
;HABILITAR FLAG GERAL
SJMP
$
;LOOP INFINITO

;
;ROTINA PARA ATENDER A INTERRUPCAO EXTERNA 1
EXT1:
RLC
A
;ACENDER LEDS EM SEQUENCIA
MOV
P1,A
LCALL DELAY
RETI
DELAY
L1:
L2:

MOV
MOV
DJNZ
DJNZ
RET

R0,#0FFH
R1,#0FFH
R1,L2
R0,L1

USO DE
TEMPORIZADORES/CONTADORES DO
NO 8051:
8051
CONTINUAO
Temporizadores/Contadores de 16-bits:

TIMER 0 (TMR0)
TIMER 1 (TMR1)
Operao:

TEMPORIZADOR

Os registradores (SFR) TL0/TL1 e TH0/TH1 formam os registros

de 16-bits, que so incrementados a cada ciclo de mquina
(base de tempo a partir do CLOCK, ou seja, FTMR = Fclock/12)

CONTADOR

O registradores de 16-bits so incrementados a cada transio

de 1 para 0 () nos pinos P3.4(T0) e P3.5(T1) respectivamente

USO DE
TEMPORIZADORES/CONTADORES DO
Registros & Temporizadores/Contadores
8051 CONTINUAO
SFR associados aos TMRs:
TMOD
TCON

TMOD
Os bits do registrador TMOD (SFR) definem:
Modo de Operaao (M0/M1)

Contador/Temporizador (Contador/~Temporizador)

Contagem depende do estado de INT0/INT1 e de TR0/TR1

(GATE)

TCON
Os bits do registrador TCON (SFR) correspondem a:
FLAG de OVERFLOW (TF0/TF1)
FLAG de Interrupes na transio de INT0/INT1 (IE0/IE1)
RUN/STOP TMR0/TMR1 (TR0/TR1)
BORDA/NVEL para aceitar pedido de interruo (IT0/IT1)

USO DE
TEMPORIZADORES/CONTADORES
DO
Registros de Controle
8051
TMOD: CONTINUAO

USO DE
TEMPORIZADORES/CONTADORES DO
8051 CONTINUAO
Registros de Controle

TCON:

USO DE
TEMPORIZADORES/CONTADORES DO
MODOS
8051 CONTINUAO

MODOS
Os modos de operao de TMR0/TMR1 so ajustado atravs dos
bits M0 e M1 em TMOD
MODO 0

TIMER 0/1
MODE 0

USO DE
TEMPORIZADORES/CONTADORES DO
MODOS CONTINUAO
8051 CONTINUAO

MODO 1

TIMER 0/1
MODE 1

USO DE
TEMPORIZADORES/CONTADORES DO
8051 CONTINUAO
CONTINUAO
MODOS
MODO 2

TIMER 0/1
MODE 2

USO DE
TEMPORIZADORES/CONTADORES DO
MODOS
8051 CONTINUAO

MODO 3

TIMER 0
MODE 3

Neste modo o TMR1 suspende contagem e o TMR0 opera como dois Timers de 8 bits

USO DE
TEMPORIZADORES/CONTADORES DO
8051 CONTINUAO
EXEMPLO 1 (Assembly)
EXEMPLO 1 (Assembly)

No exemplo a seguir acende-se os leds vermelho, amarelo e verde, ligados aos

pinos P1.0, P1.1 e P1.2, respectivamente, em seqncia e a uma velocidade de
10 Hz, utilizando a interrupo de TMR0 (MODO=1)com RELOAD apropriado.
ATENO: Ser necessrio calcular o valor de recarga para o TMR0

USO DE
TEMPORIZADORES/CONTADORES DO
8051 CONTINUAO
EXEMPLO 1 CONT.
Calculo do valor de carga no
registros do TIMER
;LED_10HZ.ASM
;
DEFSEG PROG, CLASS=CODE, START=0
SEG PROG
;
DEZ_HZ EQU
8800H
;N = 30720 (CLOCK=3,6864 MHz)
;RELOAD = 34816 (8800H) F = 10 Hz
ORG RESET
AJMP INIC
;
ORG TIMER0
AJMP TIM0
;
ORG 50H

USO DE
TEMPORIZADORES/CONTADORES
DO
EXEMPLO
1 CONT.
8051 CONTINUAO
INIC:
MOV TL0,#LOW DEZ_HZ
MOV TH0,#HIGH DEZ_HZ
MOV TMOD,#61H
;TIMER 0 EM MODO 1
MOV IE,#82H
;#10000010B
MOV P1,#0
;APAGAR TODOS OS LEDS
MOV A,#11011011B
PSW.CY
A
CLR C
0 1 1 0 1 1 0 1
SETB TR0
SJMP $
;
TIM0:

RLC
ORG 100H
MOV TL0,#LOW (DEZ_HZ+2)
;REINICALIZAR
MOV TH0,#HIGH DEZ_HZ
;O CONTADOR
RLC A
MOV P1,A
RETI
Compilao & Linkedio AVOCET
END
(DIRETRIO ...\AVOCET\ASM51\>)

Comandos:
avmac51 exemplo1.asm
avlink51 exemplo1=exemplo1

USO DE
TEMPORIZADORES/CONTADORES DO
EXEMPLO 2 (Assembly)
8051 CONTINUAO

No exemplo a seguir acende-se os leds vermelho, amarelo e verde do

EXEMPLO 1, em seqncia, a uma velocidade de 1 Hz, utilizando a interrupo
de TMR0 com RELOAD apropriado.
ATENO: necessrio calcular o valor de recarga para o TMR0!
PROBLEMA: No mais possvel utilizar a soluo adotada em EXEMPLO 1!
A sada adotar um contador!

USO DE
TEMPORIZADORES/CONTADORES DO
80512 CONTINUAO
EXEMPLO
CONT.
;LED_1HZ.ASM
;
DEFSEG PROG, CLASS=CODE, START=0
SEG PROG
;N = 307200 (CLOCK=3,6864 MHz)
;Impossvel!
;Adota-se: RELOAD=8800H (10 Hz)
;e CONTADOR = 10
DEZ_HZ EQU
8800H
DIVISOR EQU
10
;
ORG RESET
AJMP INIC
;
ORG TIMER0
AJMP TIM0

USO DE
TEMPORIZADORES/CONTADORES DO
80512 CONTINUAO
EXEMPLO
CONT.
;
INIC:

ORG 50H
MOV TL0,#LOW DEZ_HZ
MOV TH0,#HIGH DEZ_HZ
MOV R7,#DIVISOR
MOV TMOD,#61H
MOV IE,#82H
MOV P1,#0
MOV A,#01001001B
CLR C
SETB TR0
SJMP $

;PREPARAR DIVISAO POR 10

;TIMER 0 EM MODO 1
;HABILITA INTERRUPO
;APAGAR TODOS OS LEDS

;
TIM0:

ORG 100H
MOV TL0,#LOW (DEZ_HZ+2)
MOV TH0,#HIGH DEZ_HZ

;REINICALIZAR
;O CONTADOR

USO DE
TEMPORIZADORES/CONTADORES DO
80512 CONTINUAO
EXEMPLO
CONT.

FIM :

DJNZ R7,FIM
MOV R7,#DIVISOR
RLC A
MOV P1,A
RETI
END

;DECREMENTA DIVISOR
;(EQUIV. 10 Hz/10)

USO DE
TEMPORIZADORES/CONTADORES DO
8051 3CONTINUAO
EXEMPLO
(Assembly)
No exemplo a seguir gera um trem de pulsos, conforme mostrado na figura
abaixo, utilizando a interrupo do TMR0.

USO DE
TEMPORIZADORES/CONTADORES DO
8051 CONTINUAO

EXEMPLO 3 CONT.

SOLUO:
Ser necessrio calcular DOIS valores de RELOAD:
1) RELOAD para 1 mseg:
1 mseg = (12 N)/FCLOCK = (12 N)/3,6864 MHz
N1mseg = (10-3 seg 3,6842106)/12 = 307,2 307
RELOAD1mseg = 65229 = FEC0H
1) RELOAD para 40 seg:
40 seg = (12 N)/FCLOCK = (12 N)/3,6864 MHz
N 40seg = (4010-6 seg 3,6842106)/12 = 12,288 12
RELOAD40seg = 65524 = FFF4H

USO DE
TEMPORIZADORES/CONTADORES DO
8051
CONTINUAO
EXEMPLO 3 CONT.
;ONDA1.ASM
DEFSEG PROG, CLASS=CODE, START=0
SEG PROG
;
SAIDA
EQU
P1.7
R_1MS
EQU
0FEC0H
;RETARDO DE 1 MILISEG
R_40MICRO
EQU
0FFF4H
;RETARDO DE 40 MICROSEG
;
ORG RESET
AJMP INICIO
;
ORG TIMER0
AJMP TIM0
;
ORG 50H
INICIO: MOV TL0,#LOW R_1MS

USO DE
TEMPORIZADORES/CONTADORES DO
8051 CONTINUAO
EXEMPLO 3 CONT.
MOV TH0,#HIGH R_1MS
MOV TMOD,#61
MOV IE,#82H
CLR SAIDA
SETB TR0
SJMP $
;
TIM0:

LB1 :

JB SAIDA,LB1
MOV TL0,#LOW (R_40MICRO+4)
MOV TH0,#HIGH R_40MICRO
SETB SAIDA
RETI
MOV TL0,#LOW (R_1MS+4)
MOV TH0,#HIGH R_1MS
CLR SAIDA
RETI
END

;TIMER 0 EM MODO 1
;EA=1 E ET0=1
;PARTIDA DO TIMER 0
;LOOP INFINITO
;2 CICLOS
;2 CICLOS
;2 CICLOS
;1 CICLO
;2 CICLOS

DEFINIES PARA O 8051

typedef struct {
unsigned B7:1;
unsigned B6:1;
unsigned B5:1;
unsigned B4:1;
unsigned B3:1;
unsigned B2:1;
unsigned B1:1;
unsigned B0:1;
}
SFR_BITS;
static unsigned char
static unsigned char
static unsigned char
static unsigned char
static unsigned char
static unsigned char
static unsigned char
static unsigned char
static unsigned char
static unsigned char
static unsigned char
static unsigned char
static unsigned char

P0
TCON
P1
SCON
P2
IE
IEN0
P3
IP
IRCON
T2CON
ADCON
P5

(8051.H)

/* this is the most significant bit */

@ 0x80;
@ 0x88;
@ 0x90;
@ 0x98;
@ 0xA0;
@ 0xA8;
@ 0xA8;
@ 0xB0;
@ 0xB8;
@ 0xC0;
@ 0xC8;
@ 0xD8;
@ 0xF8;

DEFINIES PARA O 8051

static SFR_BITS
static SFR_BITS
static SFR_BITS
static SFR_BITS
static SFR_BITS
static SFR_BITS
static SFR_BITS
static SFR_BITS
static SFR_BITS
static SFR_BITS
static SFR_BITS
static SFR_BITS
static SFR_BITS

P0_BITS
TCON_BITS
P1_BITS
SCON_BITS
P2_BITS
IE_BITS
IEN0_BITS
P3_BITS
IP_BITS
IRCON_BITS
T2CON_BITS
ADCON_BITS
P5_BITS

static unsigned char

static unsigned char
static unsigned char
static unsigned char
static unsigned char
static unsigned char
static unsigned char
static unsigned char
static unsigned char

SBUF
SP
PCON
TMOD
TH0
TH1
TL0
TL1
IP1

@ 0x99;
@ 0x81;
@ 0x87;
@ 0x89;
@ 0x8C;
@ 0x8D;
@ 0x8A;
@ 0x8B;
@ 0xB9;

@ 0x80;
@ 0x88;
@ 0x90;
@ 0x98;
@ 0xA0;
@ 0xA8;
@ 0xA8;
@ 0xB0;
@ 0xB8;
@ 0xC0;
@ 0xC8;
@ 0xD8;
@ 0xF8;

(8051.H)

DEFINIES PARA O 8051

static unsigned char
static unsigned char
static unsigned char
static unsigned char
static unsigned char
static unsigned char
static unsigned char
static unsigned char
static unsigned char
static unsigned char
static unsigned char
static unsigned char
static unsigned char
static unsigned char
static unsigned char

CCEN
CCL1
CCH1
CCL2
CCH2
CCL3
CCH3
CRCL
RCAP2L
RCAP2H
CRCH
TL2
TH2
ADDAT
DAPR

static bit unsigned char

static bit unsigned char
static bit unsigned char
static bit unsigned char
static bit unsigned char
static bit unsigned char
static bit unsigned char

@ 0xC1;
@ 0xC2;
@ 0xC3;
@ 0xC4;
@ 0xC5;
@ 0xC6;
@ 0xC7;
@ 0xCA;
@ 0xCA;
@ 0xCB;
@ 0xCB;
@ 0xCC;
@ 0xCD;
@ 0xD9;
@ 0xDA;
TF1
TR1
TF0
TR0
IE1
IT1
IE0

@ 0x8F;
@ 0x8E;
@ 0x8D;
@ 0x8C;
@ 0x8B;
@ 0x8A;
@ 0x89;

(8051.H)

DEFINIES PARA O 8051

static bit unsigned char
static bit unsigned char
static bit unsigned char
static bit unsigned char
static bit unsigned char
static bit unsigned char
static bit unsigned char
static bit unsigned char
static bit unsigned char
static bit unsigned char
static bit unsigned char
static bit unsigned char
static bit unsigned char
static bit unsigned char
static bit unsigned char
static bit unsigned char
static bit unsigned char
static bit unsigned char
static bit unsigned char
static bit unsigned char
static bit unsigned char
static bit unsigned char
static bit unsigned char

IT0
SM0
SM1
SM2
REN
TB8
RB8
TI
RI
EA
ES
ET1
EX1
ET0
EX0
RD
WR
T1
T0
INT1
INT0
TXD
RXD

@ 0x88;
@ 0x9F;
@ 0x9E;
@ 0x9D;
@ 0x9C;
@ 0x9B;
@ 0x9A;
@ 0x99;
@ 0x98;
@ 0xAF;
@ 0xAC;
@ 0xAB;
@ 0xAA;
@ 0xA9;
@ 0xA8;
@ 0xB7;
@ 0xB6;
@ 0xB5;
@ 0xB4;
@ 0xB3;
@ 0xB2;
@ 0xB1;
@ 0xB0;

(8051.H)

DEFINIES PARA O 8051

static bit unsigned char
static bit unsigned char
static bit unsigned char
static bit unsigned char
static bit unsigned char
/*

Interrupt vectors */

#define
#define
#define
#define
#define
#define
#define

RESET
EXTI0
TIMER0
EXTI1
TIMER1
SINT
TIMER2

0
3
11
19
27
35
43

PS
PT1
PX1
PT0
PX0

@ 0xBC;
@ 0xBB;
@ 0xBA;
@ 0xB9;
@ 0xB8;

(8051.H)

USO DE INTERRUO EM C
Interrupo
Uma rotina para tratamento de interrupo (ISR) definida atravs dos seguintes
procedimentos:
1 Ajuste dos bits dos SFRs associados interrupo que se deseja usar (int_setup.h).
int_setup.h
2 Definindo a handler ISR:
[<type>] interrupt handler ( [<parametros>] )
{
[disable();]
/* bloqueia pedidos de novas interrupes */
.
.
.
[enable();]
/* habilita pedidos de novas interrupes */
[return();]
}
3 Ajuste da ISR ao vetor de interrupo correspondente:
set_vec(vec,
handler);
set_vec
handler

PROGRAMA FONTE
Exemplo de Programa Fonte: EPD01.C
/*
Programa: EPD01.C
Funcao: Controle de 4 LEDs acionados atravs da porta P1.0 a P1.3 do 8051
Copyright: ivo@feb.unesp.br
*/
static unsigned char P1 @0x90;
main(){
unsigned char x,y;
P1 = 0xff;
while(1){
do{
x = P1;
y = x;
x >>= 4;
}while(x==0x0f);

/* Faz enquanto no houver tecla apertada */

/* L porta P1 */
/* Salva P1 em z */
/* Desloca y 4 casas para a direita */

PROGRAMA FONTE CONTINUAO

x |= 0xf0;
P1 = x;

/* Restaura os 4 bits mais significativos como entrada */

/* Escreve o resultado na porta P1 */

do{
/* Faz enquanto a tecla nao for solta */
x = P1;
x >>=4;
}while(x != 0x0f);
};
}

Compilao e Montagem de EPC01.C

Comando DOS: .../AVOCET/AVC51/>AVC51 epc01.c <enter>

PROGRAMA FONTE CONTINUAO

Exemplo de Programa : EPD02.C
/*
EPD02: Programa exemplo que calcula a soma de duas variveis e imprime na console!
Data: 27/09/2013
Copyright: ivo@feb.unesp.br
*/
#include
<stdio.h>
#include <conio.h>
#include <8051.h>
bit unsigned
ustatus;
char
var1,var2;
int
var3;
void init_uart()
{
TMOD = 0x20;
TL1 = -3;
TH1 = -3;
TR1 = 1;
SCON = 0x52;

/* timer 1 auto-reload mode */

/* about 9600 baud at 10.695MHz */
/* enable timer 1 */
/* mode 1, receiver enable */

PROGRAMA FONTE CONTINUAO

ustatus = 1;
}
void putch(char c)
{
if(!ustatus)
init_uart();
if(c == '\n') {
while(!TI)
continue;
TI = 0;
SBUF = '\r';
}
while(!TI)
continue;
TI = 0;
SBUF = c;
}
/*----------------------------------------------------------------int kbhit()
{

PROGRAMA FONTE CONTINUAO

if(!ustatus)
init_uart();
return RI;
}
char getch()
{
if(!ustatus)
init_uart();
while(!RI)
continue;
RI = 0;
if(SBUF == '\r' || SBUF == ('\r'|0x80))
return '\n';
return SBUF & 0x7f;
}
char getche()
{
char c;
c = getch();
putch(c);
return(c);

PROGRAMA FONTE CONTINUAO

}
-----------------------------------------------------------------*/
main()
{
var1 = 11;
printf("Valor de var1 = %d\n",var1);
var2 = -1;
printf("Valor de var2 = %d\n",var2);
var3 = (int)(var1 + var2);
var3 = var3 * 1000;
printf("Valor de var3 = %d\n",var3);
while(1);
}

PONTEIROS EM C
Ponteiro
Quando declarada com ponteiro a varivel conter o endereo de uma outra
varivel do mesmo tipo. (para obter o endereo de uma varivel usamos o operador &)
Sintaxe:
<tipo> *<nome_da_varivel>;
Exemplos:
unsigned char var1, var2;
unsigned char myname[ ] = {Ivo Reis Fontes!...\n};
/* o nome do vetor, myname, um ponteiro!... */
unsigned char *ponteiro;
/* cria um apontador! */
ponteiro = &var1;
var2 = *ponteiro;
ponteiro = myname;
ponteiro +=9;
var1 = *ponteiro;

/* ponteiro conter o endereo da varivel var1 */

/* varivel var2 conter o valor da varivel var1 */
/* ponteiro est apontando para myname */
/* ponteiro est apontando para a letra F de myname */
/* var1 conter o cdigo ASCII do smbolo F */

ESTRUTURA E UNIO EM C
Estrutura
bastante comum a necessidade de se manipularem dados em conjunto, isto ,
grupos de variveis diferentes que mantm alguma relao em comum. A
linguagem C proporciona facilidades para o uso de variveis compostas, que
so constituidas de diversas variveis de mesmo tipo ou de tipos diferentes. A
seguir segue um exemplo clssico:
Cadastro de Funcionrios:
Nome;
Endereo;
Nome do Conjuge;
Nmero de Dependentes;
Cargo;
Salrio;
Data da Admisso.

ESTRUTURA E UNIO EM C
Sintaxe:
struct funcionario
{
char
char
char
int
char
}analista;

nome[30];
endereco[40];
telefone[8];
idade;
data_adm[10];

Inicializao de uma estrutura:

struct funcionario analista;
analista =
{
Jadylson Bomfim,
Rua das Flores, 514,
2517693,
50,
07/02/60
}
Acesso idade:
var1 = analista.idade;

CONTINUAO

ESTRUTURA E UNIO EM C

CONTINUAO

Union
H situaes em que uma alocao dinmica de memria se faz necessria,
devido ao enorme espao de memria utilizado pelas variveis existentes. Fica,
pois, flagrante a necessidade de se usarem ferramentas que permitam um
aproveitamento mais econmico da memria disponvel, ou mesmo aplicaes
nas quais se necessita de diferentes interpretaes para uma mesma rea de
memria.
O tipo union bastante semelhante s estruturas, nas quais podemos ter
variveis contendo valores de mais de um tipo.
Sintaxe:
union lh_byte
{
unsigned int int_16;
struct two_byte
{
unsigned char lbyte;
unsigend char hbyte;
};
};