EEL7030 - Microprocessadores

Prof. Raimes Moraes

EEL - UFSC
 Arquitetura von Neumann de Computadores

Memória
 UCP: Unidade central de
processamento

 Memória: Armazenamento de
programas e dados
Unidade Unidade
de Lógica e  I/O: Transferência de dados
Controle Aritmética entre computador e ambiente
externo
Unidade Central de Processamento
 Barramentos: estabelece
comunicação entre UCP,
memória e I/O
Dispositivos de Dispositivos de
Entrada de Dados Saída de Dados
 Tipos de Memórias de Semicondutores
Não Voláteis: - geralmente utilizadas para armazenamento de programa
- retém conteúdo mesmo quando desenergizadas

q MROM ou ROM: Mask Read Exemplo de

Only Memory: Memória com encapusalmen-
to de memória
conteúdo definido em fábrica EPROM

q PROM: Programmable Read

Only Memory: Gravada em
campo uma única vez

q EPROM: Erasable
Programmable Read Only
Memory: regravável.

q Flash: Apaga-se e grava-se

setores da memória

q EEPROM: Electrically
Erasable Programmable Read
Only Memory
 Tipos de Memórias de Semicondutores

Voláteis (dados perdidos quando desenergizadas)

q RAM - Random-Access Memory: conteúdo alterado pelo processador

SRAM: RAM estática – constituída por flip-flops

DRAM: RAM dinâmica – constituída por capacitores MOS – requer

recarga periódica (refresh)
 Exemplo de Memória SRAM (Static Random Access Memory) 16x4: 74189

24 = 16 palavras de 4 bit
Endereços de 0000B a 1111B

Barramento de
endereços

Chip Select Barramento de saída

Write Enable de dados

Barramento
de entrada de
dados
 Representação da 74189

D3 D2 D1 D0
/CS

/WE

Word 15 A3
E Ck E Ck E Ck E Ck

Address Decoder
Q D Q D Q D Q D A2

Word 14 A1
E Ck E Ck E Ck E Ck
Q D Q D Q D Q D A0

: : : :

Word 0
E Ck E Ck E Ck E Ck
Q D Q D Q D Q D
Buffer Buffer Buffer Buffer

/QD /QC /QB /QA

 Exemplo de Acesso a RAM 16x4

§ Quando /CS = 1, barramento de saída em estado de alta impedância

§ 8051 trabalha com memórias que armazenam palavras de oito bits; barramento de
único dados - bidirecional;
Microprocessador de Propósito Geral conectado a Memórias e Periféricos

O número de trilhas em cada barramento varia em função da capacidade de

armazenamento da memória; tamanho da palavra armazenada nas memórias;
características das memórias e do processador.
 Funções Básicas de Unidade Central de Processamento (UCP)

Início Busca Decodifica Executa

• Busca instruções armazenadas em memória de programa, decodifica-

as e executa-as;

• Supre sinais de controle para acesso à memória e outros periféricos;

• Lê ou escreve dados da memória ou periféricos;

• Atende demanda dos periféricos (interrupções).

Microprocessador: componente eletrônico que executa
tarefas de uma unidade central de processamento (UCP)
de um computador digital; contém unidade de controle e
unidade lógica aritmética.

Microcontrolador: componente eletrônico que contém

UCP, memória de programa (memória não volátil), memória
RAM e periféricos (timers, interfaces de comunicação
serial e outros).
 Microcontrolador

§ UCP + “Periféricos”

UCP RAM EEPROM

I/O Port Timers Porta

Serial

Vantagem: rápido desenvolvimento, menor custo, menor dimensão;

Desvantagem: baixa flexibilidade, não expansível;

 Famílias de Microcontroladores

§ UCP + diferentes módulos

§ Módulos geralmente encontrados:

- Portas de entrada e saída

- Interface Serial (CAN1, SPI2, USB, RF e etc)
- Memórias (ROM, RAM, EEPROM, NVRAM3, etc)
- Conversores Analógico/Digital e Digital/Analógico
- Timers
- ...

1
CAN: Controller Area Network
2
SPI: Serial Peripheral Interface
3 NVRAM: Nonvolatile SRAM
 Escolhendo um Microcontrolador

1. Considerar: consumo, desempenho, capacidade de memória,

número de portas de entrada e saída, interfaces de comunicação,
demais periféricos necessários ao projeto, encapsulamento, faixa
de temperatura de operação e outros;

2. Custo e disponibilidade no mercado. Facilidade para upgrade

(grande família)

3. Custo e disponibilidade de ferramentas de desenvolvimento:

• Compiladores, simuladores, suporte técnico;

 8051
§ Características Básicas:

q UCP de 8 bits;
q endereça 64 KiB (kibibyte) de memória de programa externa;
q endereça 64 KiB de memória de dados externa;

q 4 KiB de memória ROM interna para programas;

q 128 bytes de memória RAM interna para dados;
q 4 portas de entrada e saída (8 pinos cada);
q 5 vetores de interrupção com 2 níveis de prioridade:

2 interrupções externas
2 temporizadores / contadores
1 interface serial

OBS: kibibyte (210 = 1024 bytes)

 8051
Interrupções Externas
ROM para
memória de
Controle de Entradas
programa RAM Timer 1
Interupções do
4 KiB 128 bytes Timer 0 contador

UCP Barramentos de Endereços, Dados e Controle

Controle de 4 Portas de Porta

OSC Barramento I/O Serial

P0 P2 P1 P3 TxD RxD

Endereço/Dados
Microcontrolador 8051

Tipo de encapsulamento do 8051

 Acesso a
dispositivos de
entrada e saída

As portas de um
microcontrolador são
úteis para escrever em
leds, ler de chaves,
como também
interagir com
periféricos mais
complexos, tais como
display de cristal
líquido (LCD), módulo
GPRS (General Packet
Radio Service) e
outros.
Exemplo de conexão a dispositivos externos

Modelo
EDSIM51
www.edsim51.com
 Para escrita no display
P0.7/ P3.4/ P3.3/ Q3 Q2 Q1 Q0
CS A1 A0
1 0 0 1 1 1 0
1 0 1 1 1 0 1
1 1 0 1 0 1 1
1 1 1 0 1 1 1
0 X X 1 1 1 1

1 0 0 1 1 1 1 1 P1
 Exercício
Fazer programa em linguagem C para mostrar 1 no display 0 do hardware
simulado pelo EDSIM51
 Linguagem C – 8051
Operadores
(http://www.keil.com/support/man/docs/c51/)

• Aritméticos: + – * / % (var = 9 % 2 => var = 1)

• Relacionais: == != < <= > >= && || !

• Lógicos (bit a bit): & | ^ ~ << >>

(ANL ORL XRL CPL)

• Atribuição: = += -=

• Incremento/decremento: ++ --
 Linguagem C – 8051
Estruturas para Seleção
if - else if (condição_1) declaração_1;

else if (condição_2) declaração_2;

else if (condição_3) {declaração_3; declaração_4}
.
.
else if (condição_n) declaração_M;
else faça_default;

switch - case
switch (variável)
{
case constante_1: declaração_1; break;
case constante_2: declaração_2; declaração_3; break;
.
.
case constante_n: declaração_L; break;
default: declaração_default;
}
 Linguagem C – 8051
Estruturas para Repetição

for (inicialização; condição de parada; incremento/decremento) {

declaração_1;
for ...
declaração_n;
}

while (condição) { declaração_1;

while ...
declaração_n;
}

do { declaração_1;
do – while ...
(Executa ao menos, declaração_n;
1 vez o laço do) }
while (condição);
 break Interrompe a execução de um comando (switch) ou de
loop (for, while, do-while). O break força a saída do
laço mais interno.

continue força a execução da próxima iteração do loop

Exemplo de tipo de dados enum (ver prox. Slide)

enum mes {jan, fev, mar, abr, mai, jun, jul, ago, set, out, nov, dez};
mes valor;

valor = ago; /* equivalente a valor = 7 */

Tipos de Dados
 Exercício
Fazer programa em linguagem C para mostrar 1 no display 0 do hardware
simulado pelo EDSIM51
Exemplo de conexão a dispositivos externos

Modelo EDSIM51
www.edsim51.com
 Organização de Programa em Liguagem C

1. Diretivas de compilação e bibliotecas (arquivos.h)

2. Declaração de funções (protótipos)
3. Declaração de variáveis globais e constantes
4. Função main
5. Funções

Startup.a51
I. Apaga RAM interna e externa

II. Inicializa variáveis e stack pointer

III. Executa JMP “main”

// EXEMPLO: Programa que mostra número 1 no display 0 do EDSIM51

// diretiva de compilação
#include <reg51.h> // inclusão de arquivo com endereços de registradores do 8051

// declaração dos protótipos de funções

unsigned char converte_7seg (unsigned char);

// declaração de constantes
#define CS 0x80; // 10000000B

// declaração de variáveis globais

unsigned char dsp_0 = 0xE7; // 111001111B

// função main
void main (void)
{
unsigned char digito = 1 ;

P0 = CS;
P3 = dsp_0;

P1 = converte_7seg(digito);

while(1);

}
// função

unsigned char converte_7seg (unsigned char dado) // função retorna valor a ser escrito…
{ //… nos displays para formar o caractere

switch (dado) // GFEDCBA

{
case 0: dado = 0x40; break; // "1000000";
case 1: dado = 0x79; break; // "1111001";
case 2: dado = 0x24; break; // "0100100";
case 3: dado = 0x30; break; // "0110000";
case 4: dado = 0x19; break; // "0011001";
case 5: dado = 0x12; break; // "0010010";
case 6: dado = 0x02; break; // "0000010";
case 7: dado = 0x78; break; // "1111000";
case 8: dado = 0x00; break; // "0000000";
case 9: dado = 0x10; break; // "0010000";
case 10: dado = 0x08; break; // "0001000";
case 11: dado = 0x03; break; // "0000011";
case 12: dado = 0x46; break; // "1000110";
case 13: dado = 0x21; break; // "0100001";
case 14: dado = 0x06; break; // "0000110";
case 15: dado = 0x0E; break; // "0001110";
default: dado = 0x80; // "0000000";
}

return dado;
} // end converte
 Conversão de
linguagem de alto
nível para código
de máquina
 8051
código binário deve
ser armazenado na
memória de programa

Interrupções Externas
ROM para
memória de
Controle de Entradas
programa RAM Timer 1
Interupções do
4 KiB 128 bytes Timer 0 contador

UCP Barramentos de Endereços, Dados e Controle

Controle de 4 Portas de Porta

OSC Barramento I/O Serial

P0 P2 P1 P3 TxD RxD

Endereço/Dados
 MEMÓRIA DE PROGRAMA
Contendo códigos das instruções (opcodes)
Representação no Keil
ENDEREÇOS Instruções ENDEREÇOS Instruções
(HEXADECIMAL) (BINÁRIO) (HEXADECIMAL) (HEXADECIMAL)

0000 1110 1010 0000 EA

0001 0010 0101 0001 25
0002 0011 0010 0002 32
0003 .... 0003 ....
0004 .... 0004 ....
0005 .... 0005 ....
0006 .... 0006 ....
.... .... .... ....

Exemplo de Alocação de Código na Memória de Programa

Registradores do 8051
 Registrador de Flags

PSW - Program Status Word - Bit Addressable

7 6 5 4 3 2 1 0
CY AC F0 RS1 RS0 OV P D0H

Nome Localização Descrição

CY PSW.7 Carry flag
AC PSW.6 Auxiliary carry flag
F0 PSW.5 Definido pelo usuário
RS1 PSW.4 FF 1 do seletor de Register Bank

RS0 PSW.3 FF 0 do seletor de Register Bank

OV PSW.2 Overflow flag
PSW.1 Definido pelo usuário
P PSW.0 Flag de paridade. 1 = ímpar.
 Flags do registrador PSW alterados por instruções
(diferentes instruções podem afetar os flags de diferentes maneiras)

P (Parity) = 1 => Se o acumulador contém nro. ímpar de 1’s.

AC (Auxiliary Carry) = 1 => ocorreu vai um do flip-flop (FF) 3 para o 4;

CY (Carry) = 1 => ocorreu vai um do FF 7;

corresponde a vai um ou vem um de operações aritméticas;

OV (Overflow) = 1 => ocorreu vai um do FF 6 para FF 7, mas não do FF 7;

ou ocorreu vai um do FF 7, mas não do FF 6 para o FF 7;

Ao somar inteiros com sinal, OV indica nro. negativo resultante da soma de

nros. positivos ou nro positivo resultante da soma de nros negativos.
 Instrução MOV A,Rn

5 bits 3 bits
Código da instrução (opcode) Operando

1 1 1 0 1 R R R

Instrução ADD A,direct

8 bits
8 bits
Código da instrução (opcode)

0 0 1 0 0 1 0 1 endereço
Valores possíveis para o campo RRR do slide anterior e seguinte

REGISTRADOR RRR
R0 000
R1 001
R2 010
R3 011
R4 100
R5 101
R6 110
R7 111
 Exercício: Obter o código das instruções abaixo

MOV A,R2
ADD A,32H

Mnemônico Código Binário Código Hexadecimal

MOV A,R2 1110 1010 EA

ADD A,32H 0010 0101 0011 0010 25 , 32

 Organização da RAM Interna 8051

Special 128
Function bytes

Registers FFH
a 80H FFh:

SFR
80h:
7Fh:
REGIS-
TERS
00h:
128
RAM bytes
(8051)
7FH
a 00H

ADD A, direct
Special Function Registers (SFR)
/*--------------------------------------------------------------------------
REG51.H // Conteúdo parcial do registrador reg51.h
Header file for generic 80C51 and 80C31 microcontroller.
Copyright (c) 1988-2002 Keil Elektronik GmbH and Keil Software, Inc.
All rights reserved.
--------------------------------------------------------------------------*/
#ifndef __REG51_H__
#define __REG51_H__

/* BYTE Register */

sfr P0 = 0x80;
sfr P1 = 0x90;
sfr P2 = 0xA0;
sfr P3 = 0xB0;
sfr PSW = 0xD0;
sfr ACC = 0xE0;
sfr B = 0xF0;
sfr SP = 0x81;
sfr DPL = 0x82;
sfr DPH = 0x83;
...
/* BIT Register */
/* PSW */

sbit CY = 0xD7;
sbit AC = 0xD6;
.....
Organização da RAM Interna
 Instrução MOV A,direct

8 bits
8 bits
Código da instrução (opcode)

1 1 1 0 0 1 0 1 endereço

Instrução MOV A,Rn

5 bits 3 bits
Código da instrução (opcode) Operando

1 1 1 0 1 R R R
 Registrador de Flags
PSW - Program Status Word - Bit Addressable

7 6 5 4 3 2 1 0
CY AC F0 RS1 RS0 OV P D0H

Nome Localização Descrição

CY PSW.7 Carry flag
AC PSW.6 Auxiliary carry flag
F0 PSW.5 Definido pelo usuário
RS1 PSW.4 FF 1 do seletor de Register Bank
RS0 PSW.3 FF 0 do seletor de Register Bank
OV PSW.2 Overflow flag
PSW.1 Definido pelo usuário
P PSW.0 Flag de paridade. 1 = ímpar.
 Organização da RAM Interna

08H

RS0=0 RS0=1
RS0 e RS1 do
registrador PSW RS1=0 Banco 0 Banco 1
RS1=1 Banco 2 Banco 3
 Special Function Registers (SFR)

Linguagem C
Assembly (SETB bit address)
sbit P0_0 = 0x80;
SETB 80H ou SETB P0.0; P0_0 = 1;
 Organização da RAM Interna

bit: (0 a 1) aloca variável na memória ram interna (0x20 a 0x2F).

 Tipos de Dados do C51
• bit: (0 a 1) define variáveis do tipo bit na memória ram interna (0x20 a 0x2F -
bdata). Não pode ser utilizado em ponteiro ou array.

• sbit: (0 a 1) define variáveis do tipo bit na região de memória dos registradores

de funções especiais (special function registers – SFR) ou em bdata (0x20 a
0x2F).

sbit P1_1 = 0x91; // declarações equivalentes

sbit P1_1 = P1^1;

• sfr: define variáveis nos endereços de memória dos SFR.

sfr P1 = 0x90; // P1 passa a corresponder ao endereço 90H

• sfr16: define endereços sequenciais nos SFR.

sfr16 DPTR = 0x82; // DPL em 0x82; DPH em 0x83;

DPTR = 0xFFA0;
 Exercício
Fazer programa em linguagem C para mostrar 1 no display 1 do hardware
simulado pelo EDSIM51
Exemplo de conexão a dispositivos externos

Modelo
EDSIM51
www.edsim51.com
 Solução do Exercício
// EXEMPLO: Programa que mostra número 1 no display 1 do EDSIM51

//diretiva de compilação
#include <reg51.h> // inclusão de arquivo com endereços de registradores SFR do 8051

// declaração de variáveis globais

sbit CS = P0^7;

sbit END1 = P3^4;

sbit END0 = P3^3;

void main (void)

{
unsigned char
dsp7_code[]={0x40,0x79,0x24,0x30,0x19,0x12,0x02,0x78,0x00,0x10,0x08,0x03,0x46,0x21,0x06,0x0E,0x80};

CS = 1;

END1 = 0;
END0 = 1;

P1=dsp7_code[1];

while(1);
}
 Solução do Exercício
// EXEMPLO: Programa que mostra número 1 no display 1 do EDSIM51

//diretiva de compilação
#include <reg51.h> // inclusão de arquivo com endereços de registradores SFR do 8051

// declaração de variáveis globais

sbit CS = P0^7;

sbit END1 = P3^4;

sbit END0 = P3^3;

void main (void)

{
unsigned char code
dsp7_code[]={0x40,0x79,0x24,0x30,0x19,0x12,0x02,0x78,0x00,0x10,0x08,0x03,0x46,0x21,0x06,0x0E,0x80};

CS = 1;

END1 = 0;
END0 = 1;

P1 = dsp7_code[1];

while(1);
}
 Especificação de Regiões de Memória

Alocação de dados/variáveis na memória:

• code: memória de programa;

• data: memória RAM interna acessada por endereçamento direto (0 a 0x7F)
• bdata: memória RAM interna acessada por endereçamento bit a bit (0x20 a
0x2F). Ex:

char bdata ibase; /* varíável char bit-addressable*/

sbit mybit0 = ibase ^ 0; /* bit 0 de ibase */

• idata: memória RAM interna acessada por endereçamento indireto (0 a

0xFF).
• xdata: memória RAM externa acessada por MOVX @DPTR
• pdata: memória RAM externa acessada por MOVX A,@Ri
(permite acessar somente os primeiros 256 bytes de XDATA:
0x0000-0x00FF).
 Exercício
Elaborar programa em linguagem C para mostrar contagem crescente (0 a
FH) de forma sequencial nos 4 displays de 7 segmentos do hardware
simulado pelo EDSIM51. Ao término da contagem, repetir o
procedimento.
//Mostra contagem crescente nos 4 displays do EDSIM51
#include <reg51.h> // diretiva de compilação

// declaração de variáveis globais

unsigned char bdata cntdsp;
sbit CS = P0^7;
sbit END1 = P3^4;
sbit END0 = P3^3;
sbit cntdsp_0 = cntdsp^0;
sbit cntdsp_1 = cntdsp^1;

void main (void) {

unsigned char code
dsp7_code[]={0x40,0x79,0x24,0x30,0x19,0x12,0x02,0x78,0x00,0x10,0x08,0x03,0x46,0x21,0x06,0x0E,0x80};
short delay;
unsigned char digito = 0;

CS = 1;
cntdsp = 3;
while (1) {
END1 = cntdsp_1; //end. dsp7
END0 = cntdsp_0;
P1 = dsp7_code[digito++];

for (delay = 0; delay< 30000; delay++); // atraso Edsim 2.1.20 – Update freq=50000

if (cntdsp == 0) cntdsp = 3;
else cntdsp--;

if ( digito == 16) digito = 0;

} // end of while
} //end of main