OBS: aula improvisada pelo fato de ter sido repassada na última sexta.
3.1 Objetivos
apresentar os objetivos da disciplina
trabalhar memórias na forma de diagrama em blocos
apresentar barramentos de endereço/dados/controle
diferenciar conteúdo de endereço de memória;
apresentar o procedimento de acesso para escrita e para a leitura;
apresentar um diagrama de tempo simplificado de acesso a memória;
apresentar a CPU/microcontrolador como a "entidade" que acessa a memória
3.2 Diagrama em blocos da memória e barramentos
No diagrama abaixo está representado um bloco de memória primária de 16x8 (dezesseis endereços por 8 bits).
Note que uma posição de memória pode ser vista como uma caixa que possue um endereço e um conteúdo.
O conteúdo associado a posição de memória é uma palavra binária e, neste caso, possui 8 bits.
ou
Para que us dispositivo externo possa "acessar" a memória para leitura ou escrita, ele deve se utilizar de um conjunto de fios que chamamos de barramentos.
3.2.1 Barramento de Endereços
Este barramento permite determinar o endereço de uma posição a ser acessada na memória.
Um barramento de 4 linhas de endereço é designado por A3,A2,A1 e A0.
Supondo uma memória com endereços designados da forma hexadecimal de 0h a Fh. Supondo que A3
seja associado ao bit mais significativo e A0 ao bit menos significativo. Então, para acessar
a posição Bh de memória, deve-se injetar A3=1, A2=0, A1=1 e A0=1. Note que
O termo "injetar" significa aqui que um dispositivo externo deve forçar tensão nas linhas do barramento.
Esta tensão depende da tecnologia utilizada. Poderia ser, por exemplo, 5V para o nível lógico 1 e 0V par ao nível lógico 0.,
3.3 Diagrama de Tempo - Acesso para escrita
4 AULA 2 - Dia 23/04/2013
4.1 Objetivos
apresentar, através de um exercício, um sistema hipotético de microprocessamento;
desenvolver a noção do que é a linguagem de máquina e do que é linguagem assembly;
4.2 Sistema de microprocessamento hipotético
Seja um sistema hipotético de processamento com os seguintes componentes:
Uma CPU contendo:
Unidade de Controle;
Unidade Lógica e Aritmética;
Registradores:
Registrador de Instrução (IR) de palavra de 6 bits: Armazena a instrução que será executada pela CPU;
Contador de Programa (PC) de palavra de 4 bits: Armazena o endereço da próxima instrução a ser executada;
Registrador A e Registrador B, ambos de 6 bits: Registros temporários para transferência de dados da memória e operações de lógica e aritmética.
Barramentos:
Barramento de Dados - 6 bits : D5, D4, D3, D2, D1, D0.
Barramento de Endereço - 4 bits : A3, A2, A1, A0.
Barramento de Controle:
WR - Escrever RAM (memória de dados);
RD - Ler RAM (memória de dados);
PSEN - Ler ROM (memória de programa)
Memória externa de Dados: 16 posições de 6 bits;
Memória externa de Programa: 16 posições de 6 bits;
\section{Conjunto de Intruções do Sistema Hipotético}
\begin{table}[h]
\caption{Conjunto de Intruções}
\begin{tabular} {|p{1.5cm}|c|p{10cm}|l|}
\hline %
Código & tam & Descrição & Mnemônico\\
\hline %
00\small{XXXX} & 1 & Ler endereço \small{XXXX} da memória de dados para
acumulador A. & MOV
A,direto \\
01\small{XXXX} & 1 & Escrever no endereço \small{XXXX} da memória de dados o
valor do acumulador
A. & MOV direto,A \\
100000 & 1 & Somar acumulador A com registrador B e colocar resultado em A. &
ADD A,B \\
100001 & 1 & Decrementar acumulador A. & DEC A \\
100010 & 1 & Mover o conteúdo do acumulador A para o registrador B. & MOV B,A
\\
100011 & 1 & Subtrair o valor do registrador B do acumulador A e
colocar resultado em A & SUBB A,B \\
100100 & 1 & Parar o microprocessador & HALT \\
100101 \small{YYYYYY} & 2 & Mover o dado imediato \small{YYYYYY} (armazenado na
memória
de programa) para o acumulador A & MOV A,\#dado6 \\
11\small{XXXX} & 1 & Saltar (JUMP) para o endereço \small{XXXX} da memória de
programa se
acumulador A for
diferente de 0. & JNZ direto \\
\hline %
\end{tabular}
\end{table}
\section{Executando um programa}
Considere a memoria de programa com o seguinte código:
\begin{table}[h]
\caption{Conteúdo da Memória de Programa}
\begin{tabular} {|c|c|p{8cm}|l|}
\hline %
Endereço & Conteúdo & Descrição & Mnemônico\\
\hline %
0H & 000001 & Movimenta conteúdo lido da posição 0001 da memória de dados para o
registrador A & MOV A,1H \\
1H & 100010 & Move o conteúdo do registrador A para o registrador B & MOV
B,A \\
2H & 000010 & Movimenta conteúdo lido da posição 0010 da memória de dados para o
registrador A & MOV A,2H \\
3H & 100011 & Subtrair o valor do registrador B do acumulador A e colocar
resultado
em A. & SUBB A,B \\
4H &110011 & Saltar (JUMP) para o endereço 0011 da memória de programa se
acumulador
A for diferente de 0. & JNZ 3H\\
5H & 010000 & Escrever no endereço 0000 da memória de dados o valor do
acumulador A.
& MOV 0H,A\\
6H & 100100 & Parar o microprocessador & HALT \\
\hline %
\end{tabular}
\end{table}
Preencha a taebela conforme a execução do programa:
\begin{table}[h]
\caption{Conteúdo dos principais registros a cada passo do programa exemplo}
\begin{tabular} {|c|c|c|c|c|c|c|c|c|}
\hline %
passo & IR & A & B & PC & RAM 0000 & RAM 0001 & RAM 0010 & RAM 0011\\
\hline %
0 & 000000 & 000000 & 000000 & 0000 & 000111 & 000001 & 000011 & 000010\\
\hline %
1&&&&&&&&\\
\hline %
2&&&&&&&&\\
\hline %
3&&&&&&&&\\
\hline %
4&&&&&&&&\\
\hline %
5&&&&&&&&\\
\hline %
6&&&&&&&&\\
\hline %
7&&&&&&&&\\
\hline %
8&&&&&&&&\\
\hline %
9&&&&&&&&\\
\hline %
10&&&&&&&&\\
\hline %
11&&&&&&&&\\
\hline %
12&&&&&&&&\\
\hline %
As condições de ``reset do sistem são as seguintes: Registros A, B, PC e IR
são zerados.
A CPU executará eternamente a sequência:\textbf{ ciclo de busca} e \textbf{ciclo
de execução de instrução}. O ciclo de busca consiste basicamente em:
\begin{enumerate}
\item Colocar o endereço do PC no Barramento de Endereços;
\item Enviar o controle de leitura $\overline{PSEN}$ para Memória de Programa;
\item Ler a instrução do Barramento de Dados através da aplicação de
um comando de escrita no Registrador de Instrução (IR);
\item Incrementar o PC em função do número de palavras da instrução.
\end{enumerate}
O ciclo de execução é basicamente a decoficação da instrução que está no
Registrador de Instrução (IR), atualizando os registros ou dados da memória,
dependendo da instrução em questão.
5 AULA 3 - Dia 29/04/2013
6 AULA 4 - Dia 30/04/2013
7 AULA 5
7.1 Objetivos
Os alunoss deverão ser capazes de:
enumerar as principais característcias do microcontrolador 8051;
desenvolver pequenos programas de movimentação de dados entre registradores,memória de código, memória interna e memória externa;
Implementar um código para copiar o bloco de memória de 40h-4Fh para 60-6Fh usando movimentação indireta. Usar R0 e R1 e também a instrução incrementa Rn (INC R0 e INC R1).
Ainda com relação ao código original do exercício anterior. Implementar um código para copiar a cadeia IFSC para as posições de memória RAM externa de dados 1000h,1001h,1002h e 1003h.
.
inicio:
mov dptr,#msg1
mov a,#4
movc a,@a+dptr
mov dptr,#1000h
movx @dptr, a
mov dptr,#msg1
mov a,#5
movc a,@a+dptr
mov dptr,#1001h
movx @dptr, a
mov dptr,#msg1
mov a,#6
movc a,@a+dptr
mov dptr,#1002h
movx @dptr, a
mov dptr,#msg1
mov a,#7
movc a,@a+dptr
mov dptr,#1003h
movx @dptr, a
msg1: db 'ALO IFSC'
loop: jmp loop
</syntaxhighlight>
10.5 Exercício 3
Considere o código abaixo.
inicio:
loop: jmp loop
msg1:
db 'ALO IFSC',0
</syntaxhighlight>
Implementar um código para copiar toda a mensagem iniciada em msg1 para uma área de memória interna iniciada em E0h.
OBS: Use o fato de que existe um 0 marcador de final de mensagem.
10.6 Exercício 4
Implementar uma função de boot (início de sistema) que zera as posições de memória ram interna de 40 a 7f usando movimentação indireta, e de ram externa de dados 0000h a 00ffh. Use a instrução cjne para elaborar loops que realizam as tarefas repetitivas.
10.7 Exercício 5
Seja o código abaixo:
inicio:
loop: jmp loop
msg1:
db 'ALO IFSC',0
</syntaxhighlight>
Observe que a msg 1 é terminada com o byte 0. Sabendo disto, elabore um código para copiar a msg1 para a RAM externa posição inicial 0600h, usando a instrução cjne.
10.8 Exercício 6
Considere o programa:
boot:
inicio:
mov A,#55h
mov dptr,#0e00h
movx @dptr,a
fim:
jmp fim
</syntaxhighlight>
Acrescente um código de boot que copia o código a partir do label inicio para a ram externa de dados, a partir da posição 0e000h.
11 AULA 8 - Dia 21/05/2013
11.2 Exercício 1
Iniciar um bloco de memória RAM interna de 50h até 7fh com o valor E5h.
Instruções de jump condicional controladas por bit
Instruções de set, clear bit
Operações lógicas com bit.
Registradores com acesso por bit e byte
14.2 Instruções de Salto Condicional a um BIT
Observe o exemplo abaixo. A instrução jb testa o estado de um bit (um pino da porta externa P2)
e salta se estiver 1. Nos códigos de pisca LED são usadas as instruções setb e clr que permitem setar
e resetar bit respectivamente.
Modificar o programa anterior criando um código para rotacionar bits a direita na porta P1 e para rotacionar bits a esquerda, conforme o estado das chaves.
Acrescente no loop principal um jb para saltar para um código que pisca os LEDs de forma alternada.
Modificar o programa exemplo substituindo as instruções de setb e clr por instruções de movimentação de byte para a porta.
14.3 O registrador PSW e o flag C
Todo microcontrolador possui um registrador que reflete o estado de alguns pontos do sistema. O 8051 possui o registrador PSW de 8 bits. Neste registrador existe um flag chamado de CARRY (C). Este flag possui várias aplicações, mas especialmente é usado para armazenar o VAI UM de operações aritméticas. Ele também pode ser usado para acumular operações lógicas a nível de bit. Por exemplo, as instruções
anl c,direto e orl c,direto (e os complementos do direto). Também existem as instruções jnc e jc que permite saltar se o CARRY estiver setado ou resetado.
pisca2:
mov A,P1
rl A
mov P1,A
sjmp loop
</syntaxhighlight>
EXERCÍCIO 3
Implementar no microcontrolador uma porta lógica E com 3 entradas. Usar como entrada P2.0, P2.1 e P2.2. Usar como saída P1.0.
EXERCÍCIO 4
Implementar no microcontrolador a seguinte função lógica:
15 AULA 12 - Dia 4/06/2013
15.1 Objetivo
Memória RAM com acesso por bit e por byte;
Exercícios de operações com bits.
15.2 Memória RAM com acesso por bit
Na aula anterior vimos que alguns registradores são acessíveis por bit e por byte.
Esta facilidade permite que possamos modificar o valor de um bit de um registrador sem alterar os demais. Podemos por exemplo, armazenar bits individualmente em um registrador.
Adicionalmente, o 8051 possui uma parte da memória RAM que é acessível por bit e por byte. Ver detalhes na nota de aula abaixo.
PROBLEMA: Construir um alarme com 4 sensores de entrada. Se pelo menos um sensor (chave) for ativado o sistema deve disparar um alarme. Assim que os sensores forem desabilitados o alarme desliga.
ETAPA 1: Definição de quem é entrada e que é saída.
ENTRADAS: P2.0 a P2.3
SAÌDAS: P1.7 (alarme ativado = LED piscando)
ETAPA 2: Fazer um projeto simples (um fluxograma simples do sistema)
ETAPA 3: Implementação do Código e Testes
15.4 EXERCÍCIO 2: alarme simples com memorização de sensores violados
Acrescentar saídas para representar o estado dos sensores. Se um sensor for violado um LED deve acender (de P1.0 a P1.3).
SOLUÇÃO ERALDO:
15.5 EXERCÍCIO 3
Acrescentar saídas para representar estado de sensores. Se um sensor for violado, mesmo que volte ao normal deve registrar em uma saída (de P1.0 a P1.3).
Acrescentar uma chave para resetar registros de violação (P3.0)
Acrescentar uma chave para desligar alarme (P3.1)
15.6 EXERCÍCIO 4: alarme simples com inibidor de entradas
As vezes é necessário desabilitar algum sensor. Acrescentar uma chave para desligar sensores.
mov R0,#020
mov R1,#030h
lcall zerar_iram
fim:
sjmp fim
subtorina para zerar memoria iram
R0-> numero de bytes a ser zerado
R1-> endereço inicial da IRAM
zerar_iram:
push A
mov A,#00
pto2:
cjne R0,#00,pto1
sjmp fim_sub1
pto1:
mov @R1,A
dec R0
inc R1
sjmp pto2
fim_sub1:
pop A
ret
</syntaxhighlight>
16.2 Exemplo do Funcionamento da Pilha
O programa abaixo demonstra o funcionamento da pilha. Execute-o passo a passo, verificando o estado do registrador sp e da memória interna. Note que a pilha poderá ser usada como uma área de rascunho, onde se pode salvar valores que se deseja recuperar futuramtente.
.
mov A,#65H
mov B,#87H
push ACC
push B
mov A,#00H
mov B,#00H
pop B
pop ACC
loop: sjmp loop
END
Modificar o exercício anterior para que o incremento no dsplay seja controlado por uma chave externa. Exemplo: A chave normalmente fica a 1. Quando ligada vai a 0 e incrementa em uma unidade o valor do display. Ao voltar a chave para 1 nada acontece. Ou seja, as contagens são disparadas pela borda negativa da entrada ligada a chave.
detector_borda:
loop2: jnb CLK,loop2
loop1: jb CLK,loop1
ret
SUBROTINA PARA RESETAR FLIP-FLOP (lógica negativa)
resetar_jk:
clr SAI_QB
setb SAI_Q
ret
SUBROTINA PARA SETAR FLIP-FLOP
setar_jk:
clr SAI_Q
setb SAI_QB
ret
</syntaxhighlight>
Construir o alarme da aula anterior usando subrotinas.
22 Aula 15 - Dia 18/06/2013
22.3 Exercícios
Implementar um sistema de controle de acesso com código de 4 bits. Use uma chave para validar o código. Se o código conferir, abrir uma porta (acender um LED) caso contrário piscar 30 vezes um outro LED.
Implementar um programa com a seguinte lógica: . Quando o resultado de Y for 1, piscar dois LEDs de forma alternada, caso contrário piscar sumultaneamente.
23 Aula 16 - Dia 25/06/2013
AVALIAÇÃO II
24 Aula 17 - Dia 1/07/2013
24.1 Objetivos
Operações lógicas e aritméticas em nível de bytes.
Implementar um programa que some dois números não sinalizados de 8 bits das portas P1 e P2 e mostra o resultado no display de 7 segmentos. Use o ponto do display para indicar o carry e uma chave (P0.1 como ENTER).
Incremente o programa para subtrair os numeros (P1-P2). Use uma chave (P0.2) para decidir qual a operação desejada,
SOLUÇÂO ROTINA DE SOMA DE 16 bits
inicio:
mov R1,#0FFh
mov R0,#6Ah ; primeiro numero FF6A
mov R3,#0EFh
mov R2,#0FFh ; segundo numero: EFFF
lcall somar_16u
; neste momento R6R5R4 possuem os resultados da soma
somar_16u:
push A
mov A,R0
add A,R2
mov R4,A
mov A, R1
addc A, R3
mov R5,A
mov A,#00
mov A.0, C
mov R6,A
pop A
ret
fim: sjmp fim
</syntaxhighlight>
25 Aula 18 - Dia 2/07/2013
25.1 Objetivos
Continuação da aula anterior
Modificar o exercício (primeiro) da aula anterior de modo a realizar TAMBÉM a substração dos números que estão na porta P1 e P2.
mov P0,A
cpl C
mov P3.0,C
fim: sjmp fim
</syntaxhighlight>
Variação do exercício anterior com as 4 operações controladas por P3.1 e P3.2.
inicio:
clr C
mov A,P1
mov R0,P2
jb P3.1, ponto1
jb P3.2, multiplica
;divide aqui
mov B,R0
div AB
sjmp mostrar
multiplica:
;multiplica
mov B,R0
mul AB
;aqui tem um problema com o mostrar
;mostar somente permite visualizar o A
sjmp mostrar
ponto1:
jb P3.2, soma
;subtrai aqui
subb A,R0
sjmp mostrar
soma:
add A,R0
mostrar:
cpl A
mov P0,A
cpl C
mov P3.0,C
fim: sjmp fim
</syntaxhighlight>
26 Aula 19 - Dia 8/07/2013
26.3 Exercícios
1.Implementar o exemplo da nota de aula acima (valores de timer modificado para simulação):
.
inicio:
lcall delay
fim: sjmp fim
delay:
clr TR0 ;garante que timer esteja parado
clr TF0 ;garante que flag de estouro esteja zerado
mov TMOD,#00000001b ;configura timer0 para modo 0, sem controle externo
mov TH0,#FFh ;\
mov TL0,#F0 ;/ => configura timer0 com D8F0h
setb TR0 ;liga timer0
loop:
jnb TF0,loop ;espera que timer0 estoure
clr TR0 ;para o timer0
clr TF0 ;zera TF0 - note que nao eh zerado de forma automatica
ret
</syntaxhighlight>
2.Modificar o exemplo para realizar a temporização baseada no pino externo T0 (modo contador)
3.Modificar o exemplo para realizar a contagem controlada pelo Gateway externo (INT0). Note que habilita se 0.
Ver pinos do 8051 aqui: | Pinagem 8051
4.Modificar o exemplo para ampliar o poder de contagem usando uma variável auxiliar para contagem de número de estouros.
5.Implementar um programa para contar garrafas que passam sobre uma esteira. Quando a contagem de garrafas chegar a 10 comandar a parada da esteira (LED em P1.0) e comandar acionar sistema de limpeza por 10s (pino de comando P1.1). Ao final ligar novamente a esteira, resetar a contagem e começar a contar novamente.
27 Aula 20 - Dia 9/07/2013
27.3 Exercício
.
;================================
;preparacao da entrada de reset e do vetor de interrupcao
org 00h
sjmp main
org 003h
sjmp TratarINT0
;=================================
;programa principal
main:
setb EX0
setb EA ; habilita todas interrupcoes
mov A,#00h
mov C,P2.0
mov 00h,C
mov C,P2.1
anl C,00h
mov P1.0,C
loop: sjmp loop
;=================================
;Rotina de Interrupcao
;=================================
TratarINT0:
push psw
inc A
pop psw
reti
</syntaxhighlight>
29 Definição de Trabalhos
Alarme com 4 sensores e saída conda de duas frequências com chave de desligar e ligar;
(Eq.1 - Karol e Josiane) - (Eq.9 - Juan )
Alarme com 4 entradas e com código reprogramável de ligar/desligar. Usar codigo de 6 bits e um sbit de ENTER.
(Eq.2 - Paulo e Giovana) - (eq 10 - Renato e Vinicius Rodrigues)
Alarme com 4 entradas e com código fixo de ligar/desligar mas com entrada via teclado de varredura;
(Eq.3 - Valmir e Teodor)
Alarme com 4 entradas, chave ligar/desligar e com temporização programável de ativação das entradas;
(Eq.5 - Markus e Ramon)
Gerador de onda quadrada com controle do duty cycle;
(Eq.6 - Giovani e Fabiana) (Eq.8 - Alfredo e Antônio)
Contador de eventos externos com dois displays de contagem hexadecimal controlados por varredura;
(Eq.7 - Jaison e Paulo Igor)
Calculada minimalista que soma e multiplica 1, 2 e 3 mostrando em um display de 7 segmentos (um display é suficiente). Usar teclado varredura.
(Eq.4 - Rafael e Guilherme))
30 Aula 22 - Dia 16/07/2013
DESENVOLVIMENTO DO TRABALHO
31 Aula 23 - Dia 22/07/2013
DESENVOLVIMENTO DO TRABALHO
32 Aula 24 - Dia 23/07/2013
DESENVOLVIMENTO DO TRABALHO
33 Aula 25 - Dia 29/07/2013
REVISÃO RECUPERAÇÂO
34 Aula 26 - Dia 30/07/2013
RECUPERAÇÂO
Exercício 1
Elabore uma SUBROTINA para copiar uma mensagem terminada em '0' (número zero) da MEMÓRIA DE CÓDIGO
(portanto usar movc) para a MEMÓRIA EXTERNA DE DADOS. A subrotina receberá o endereço inicial
da mensagem a ser copiada em DPTR e receberá o endereço inicial da memória para onde será copiada em
R0 (parte alta) e R1 (parte baixa do endereço). Exemplo de chamada da função:
