Mudanças entre as edições de "MIC-2013-1-CST Introdução aos Microcoprocessadores"

De MediaWiki do Campus São José
Ir para navegação Ir para pesquisar
(Criou página com '=DADOS GERAIS DA DISCIPLINA= *Professor: Eraldo Silveira e Silva (email: eraldo@ifsc.edu.br) *[PlanoMIC-CST-2013-1 Plano de Ensino 2013-1] =AULA 1 - Dia 22/04/2013= OBS: aula ...')
 
 
(189 revisões intermediárias por 2 usuários não estão sendo mostradas)
Linha 2: Linha 2:
  
 
*Professor: Eraldo Silveira e Silva (email: eraldo@ifsc.edu.br)
 
*Professor: Eraldo Silveira e Silva (email: eraldo@ifsc.edu.br)
−
*[PlanoMIC-CST-2013-1 Plano de Ensino 2013-1]
+
*[[PlanoMIC-CST-2013-1 | Plano de Ensino 2013-1]]
 +
*Link da Ementa: [http://wiki.sj.ifsc.edu.br/index.php/Microprocessadores_e_Aplica%C3%A7%C3%B5es Ementa]
 +
 
 +
=Cronograma=
 +
 
 +
{| border="1" cellpadding="2"
 +
!AULA
 +
!DATA
 +
!Descriçao
 +
|-
 +
|1
 +
| 2/4/2013
 +
|
 +
|-
 +
|2
 +
| 9/4/2013
 +
|
 +
|}
  
 
=AULA 1 - Dia 22/04/2013=
 
=AULA 1 - Dia 22/04/2013=
Linha 19: Linha 36:
  
 
==Diagrama em blocos da memória e barramentos==
 
==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.
 +
 +
[[imagem:DiagramaBlocosMemorias.jpg|800px|center]]
 +
 +
ou
 +
 +
[[imagem:DiagramaBlocosMemorias2.jpg|500px|center]]
 +
 +
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.
 +
 +
===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 <math> B_h = 1011_b </math>
 +
 +
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.,
 +
 +
==Diagrama de Tempo - Acesso para escrita==
 +
 +
[[imagem:DiagramaTempoAcessoEscrita.jpg|800px|center]]
 +
 +
 +
 +
=AULA 2 - Dia 23/04/2013 =
 +
 +
==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;
 +
 +
==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.
 +
 +
=AULA 3 - Dia 29/04/2013 =
 +
 +
=AULA 4 - Dia 30/04/2013 =
 +
 +
=AULA 5=
 +
 +
==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;
 +
 +
==Material de Aula==
 +
 +
[http://www.sj.ifsc.edu.br/~eraldo/MIC/2013-1/Arquitetura8051.pdf Arquitetura8051]
 +
 +
[http://www.google.com.br/url?sa=t&rct=j&q=apostila_asm&source=web&cd=1&ved=0CDIQFjAA&url=http%3A%2F%2Fw3.ufsm.br%2Frmbranco%2Fcefet_files%2FApostila%2Fapostila_asm.pdf&ei=P4SHUeHXCc-E0QH8moGQAg&usg=AFQjCNE7Jd3BbMX3SiGB_Oij2hSjxBju3Q&bvm=bv.45960087,d.dmQ&cad=rja Apostila Prof.Branco]
 +
 +
=AULA 6 - Dia  13/05/2013=
 +
 +
==Simulador MCU8051IDE==
 +
 +
Ver detalhes do simulador MCU8051IDE  [http://mcu8051ide.sourceforge.net/ aqui].
 +
 +
==Exercícios no simulador==
 +
 +
[[imagem:Ex1Aula6MIC.jpg|800px|center]]
 +
 +
#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).
 +
 +
=AULA 7 - Dia  14/05/2013=
 +
 +
==Instruções de Movimentação Externa de Dados==
 +
 +
Intsruções úteis:
 +
<code>
 +
; 
 +
  movx A,@dptr
 +
  movx @dptr,A
 +
  inc dptr
 +
  mov dptr,#imediato
 +
</syntaxhighlight>
 +
 +
Exemplo:
 +
[[imagem:Ex1Aula7MIC.jpg|800px|center]]
 +
 +
==Exercícios==
 +
 +
#Colocar a mensagem "ALO" nas posições de memória externa de dados 0670h,0671h e 0672h.[[imagem:Ex2Aula7MIC.jpg|800px|center]]
 +
#Copiar o bloco de memória externa de dados das posições 1800h-1804h para as posições de memória externa 0000h-0004h.
 +
 +
=AULA 8 - Dia  20/05/2013=
 +
 +
==Objetivo==
 +
 +
*Instruções de Movimentação Dados da Área de Código
 +
*Instruções de Jump Condicional para Controlar Loops
 +
*Exercícios
 +
 +
==Material de Apoio==
 +
 +
[[Media:Aula8-ModosEndereçamento-Exercícios.pdf]]
 +
 +
==Exercício 1==
 +
 +
Considere o código abaixo.
 +
 +
<code>
 +
inicio: 
 +
           
 +
loop:  jmp loop
 +
 +
msg1:
 +
        db 'ALO IFSC'
 +
</syntaxhighlight>
 +
 +
Inserir um código para ler a a cadeia 'ALO' para as posições de memória RAM interna 60h,61h e 62h.
 +
 +
SOLUÇÃO:
 +
 +
<code>
 +
inicio:
 +
        mov dptr, #msg1
 +
        mov a,#00h
 +
        movc a,@a+dptr
 +
        mov  60h,a
 +
 +
        mov a,#01h
 +
        movc a,@a+dptr
 +
        mov  61h,a
 +
 +
        mov a,#02h
 +
        movc a,@a+dptr
 +
        mov  62h,a
 +
             
 +
loop:  jmp loop
 +
 +
msg1:
 +
        db 'ALO IFSC'
 +
</syntaxhighlight>
 +
 +
==Exercício 2==
 +
 +
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.
 +
 +
<code>
 +
        . 
 +
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>
 +
 +
==Exercício 3==
 +
 +
 +
Considere o código abaixo.
 +
<code>
 +
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.
 +
 +
==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 0''000h'' a ''00ffh''. Use a instrução ''cjne'' para elaborar  ''loops'' que realizam as tarefas repetitivas.
 +
 +
==Exercício 5==
 +
 +
Seja o código abaixo:
 +
 +
<code>
 +
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''.
 +
 +
==Exercício 6==
 +
 +
Considere o programa:
 +
 +
<code>
 +
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.
 +
 +
=AULA 8 - Dia  21/05/2013=
 +
 +
==Objetivo==
 +
 +
*uso de instrução cjne para elanborar loops
 +
 +
==Exercício 1==
 +
 +
Iniciar um bloco de memória RAM interna de 50h até 7fh com o valor E5h.
 +
 +
Solução:
 +
 +
<code>
 +
        .
 +
mov A,#0E5h
 +
mov R0,#50h
 +
inicio:
 +
mov @R0,A
 +
inc R0
 +
cjne R0,#80h,inicio
 +
 +
loop:  jmp loop
 +
</syntaxhighlight>
 +
 +
==Exercício 2==
 +
 +
Copiar um bloco de memória RAM interna de 40h-7f para 20-5F usando move indireto.
 +
Sugestão: usar R0 e R1.
 +
 +
<code>
 +
        .
 +
mov R0,#40h
 +
mov R1,#20h
 +
loop1:
 +
        mov A,@R0
 +
        mov @R1,A
 +
        inc R0
 +
        inc R1
 +
        cjne R0,#80h,loop1
 +
 +
loop:  jmp loop
 +
</syntaxhighlight>
 +
 +
=AULA 9 - Dia  27/05/2013=
 +
 +
==Objetivo==
 +
 +
*Instruções de movimentação de byte para as portas
 +
*instruções de loop condicional cjne
 +
*representação de palavras binárias em binário, hexadecimal e decimal
 +
 +
==Exercício 1==
 +
 +
Piscar 8 vezes o led da posição'' P1.0'' e depois 8 vezes o LED da posição'' P1.7''. Colocar tudo em um ''loop'' infinito.
 +
Use cjne A,imediato, label
 +
 +
<code>
 +
        .       
 +
inicio:
 +
        mov A,#8
 +
loop1:
 +
mov P1,#0FEh
 +
mov P1,#0FFH
 +
dec A
 +
cjne A,#00,loop1
 +
 +
        mov A,#8
 +
loop2:
 +
mov P1,#01111111b
 +
mov P1,#11111111b
 +
dec A
 +
cjne A,#00,loop2
 +
 +
ljmp inicio
 +
</syntaxhighlight>
 +
 +
==Exercício 2==
 +
 +
Piscar 8 vezes o led da posição'' P1.0'' e depois 8 vezes o LED da posição'' P1.7''. Colocar tudo em um ''loop'' infinito.
 +
Use de cjne A,direto, label
 +
 +
<code>
 +
inicio:
 +
        mov 50h,#8
 +
loop_main:
 +
        mov A,#0
 +
loop1:
 +
mov P1,#0FEh
 +
mov P1,#0FFH
 +
inc A
 +
cjne A,50h,loop1
 +
 +
        mov A,#0
 +
loop2:
 +
mov P1,#01111111b
 +
mov P1,#11111111b
 +
inc A
 +
cjne A,50h,loop2
 +
 +
ljmp loop_main
 +
</syntaxhighlight>
 +
 +
==Exercício 3==
 +
 +
Piscar 8 vezes o led da posição'' P1.0'' e depois 8 vezes o LED da posição'' P1.7''. Colocar tudo em um ''loop'' infinito.
 +
Use de cjne @R0,imediato, label
 +
 +
<code>
 +
inicio:
 +
        mov R0,#50h
 +
loop_main:
 +
        mov @R0,#0
 +
loop1:       
 +
mov P1,#0FEh
 +
mov P1,#0FFH
 +
inc @R0
 +
cjne @R0,#8,loop1
 +
 +
        mov @R0,#0
 +
loop2:
 +
mov P1,#01111111b
 +
mov P1,#11111111b
 +
inc @R0
 +
cjne @R0,#8,loop2
 +
 +
ljmp loop_main
 +
</syntaxhighlight>
 +
 +
=AULA 10 - Dia  28/05/2013=
 +
 +
Avaliação I
 +
 +
=AULA 11 - Dia  3/06/2013=
 +
 +
==Objetivo==
 +
 +
*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
 +
 +
==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.
 +
 +
<code>
 +
.
 +
inicio:
 +
mov P2,#0FFh
 +
loop:
 +
jb P2.0,pisca1
 +
jb P2.1,pisca2
 +
sjmp loop
 +
 +
pisca1:
 +
clr  P1.0
 +
setb P1.0
 +
sjmp loop
 +
 +
pisca2:
 +
clr  P1.1
 +
setb P1.1
 +
sjmp loop
 +
 +
</syntaxhighlight>
 +
 +
EXERCÍCIOS
 +
 +
#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.
 +
<code>
 +
.
 +
inicio:
 +
mov P2,#0FFh
 +
loop:
 +
jb P2.0,rotaciona_direita
 +
sjmp rotaciona_esquerda
 +
 +
 +
rotaciona_direita:
 +
mov  P1,#01111111b
 +
mov  P1,#10111111b
 +
mov  P1,#11011111b
 +
mov  P1,#11101111b
 +
mov  P1,#11110111b
 +
mov  P1,#11111011b
 +
mov  P1,#11111101b
 +
mov  P1,#11111110b
 +
sjmp loop
 +
 +
rotaciona_esquerda:
 +
mov  P1,#11111110b
 +
mov  P1,#11111101b
 +
mov  P1,#11111011b
 +
mov  P1,#11110111b
 +
mov  P1,#11101111b
 +
mov  P1,#11011111b
 +
mov  P1,#10111111b
 +
        mov  P1,#01111111b
 +
sjmp loop
 +
</syntaxhighlight>
 +
#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.
 +
 +
==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.
 +
 +
Exemplo 1: uma implementação da porta E:
 +
 +
<code>
 +
inicio:
 +
        mov C, P2.0
 +
        anl C, P2.1
 +
        cpl c
 +
        mov P1.0,c
 +
sjmp inicio
 +
</syntaxhighlight>
 +
 +
Exemplo 2: uma implementação da porta OU:
 +
 +
<code>
 +
inicio:
 +
        mov C, P2.0
 +
        orl C, P2.1
 +
        cpl c
 +
        mov P1.0,c
 +
sjmp inicio
 +
</syntaxhighlight>
 +
 +
<code>
 +
inicio:
 +
mov P2,#0FFh
 +
mov P1,#7fh
 +
loop:
 +
jb P2.0,pisca1
 +
jb P2.1,pisca2
 +
sjmp loop
 +
 +
pisca1:
 +
mov A,P1
 +
rr A
 +
mov P1,A
 +
sjmp loop
 +
 +
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:
 +
:<math>Y = AB+CD</math>
 +
 +
=AULA 12 - Dia  4/06/2013=
 +
 +
==Objetivo==
 +
 +
*Memória RAM com acesso por bit e por byte;
 +
*Exercícios de operações com bits.
 +
 +
==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.
 +
 +
[[arquivo:OperacoesBit.pdf| Nota Operações com bit]]
 +
 +
==EXERCÍCIO 1: alarme simples==
 +
 +
 +
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
 +
 +
==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:
 +
<!--
 +
<code>
 +
.
 +
inicio:
 +
mov P2,#0FFh
 +
clr 00h
 +
loop:
 +
        jmp trata_sensor0
 +
 +
pta:
 +
        jmp trata_sensor1
 +
 +
ptb:
 +
        jmp trata_sensor2
 +
 +
ptc:
 +
        jmp trata_sensor3
 +
 +
ptd:
 +
jb  00h,alarme
 +
pte:
 +
sjmp loop
 +
 +
alarme:
 +
clr  P1.7
 +
setb P1.7
 +
clr 00h
 +
sjmp pte
 +
 +
trata_sensor0:
 +
jnb P2.0,liga_sensor0
 +
sjmp desliga_sensor0
 +
liga_sensor0:
 +
clr P1.0
 +
setb 00h
 +
sjmp fim_sensor0
 +
desliga_sensor0:
 +
        setb P1.0
 +
fim_sensor0:
 +
sjmp pta
 +
 +
trata_sensor1:
 +
jnb P2.1,liga_sensor1
 +
sjmp desliga_sensor1
 +
liga_sensor1:
 +
clr P1.1
 +
setb 00h
 +
sjmp fim_sensor1
 +
desliga_sensor1:
 +
        setb P1.1
 +
fim_sensor1:
 +
sjmp ptb
 +
 +
trata_sensor2:
 +
sjmp ptc
 +
 +
trata_sensor3:
 +
        sjmp ptd
 +
</syntaxhighlight>
 +
-->
 +
 +
==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)
 +
 +
==EXERCÍCIO 4: alarme simples com inibidor de entradas==
 +
 +
*As vezes é necessário desabilitar algum sensor. Acrescentar uma chave para desligar sensores.
 +
 +
=Aula 12 - Dia 10/06/2013=
 +
 +
*Uso de Pilha e Subrotina
 +
*Exercícios
 +
 +
==Material da Referência==
 +
 +
[[arquivo:ControleFluxo.pdf| Controle de Fluxo/Pilha e Subrotinas]]
 +
 +
Solução ex1 da nota de aula:
 +
 +
<code>
 +
;programa principal
 +
inicio:
 +
        mov A,#0eeh
 +
mov R0,#010
 +
mov R1,#056h
 +
lcall zerar_iram
 +
 +
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>
 +
 +
==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.
 +
 +
<code>
 +
.
 +
        mov A,#65H
 +
        mov B,#87H
 +
        push ACC
 +
        push B
 +
        mov A,#00H
 +
        mov B,#00H
 +
        pop B
 +
        pop ACC
 +
  loop: sjmp loop
 +
        END
 +
</syntaxhighlight>
 +
 +
=Aula 13 - Dia 24/06/2013=
 +
 +
*avaliação
 +
 +
=Aula 14 - Dia 1/6/2-13=
 +
 +
==Objetivos==
 +
 +
*operações aritméticas e lógicas
 +
 +
==Material da Aula==
 +
 +
=Aula 13 - Dia 11/06/2013=
 +
 +
*Exercícios
 +
 +
=Aula 14 - Dia 17/06/2013=
 +
 +
*Conteúdo da aula 12 (que foi a greve dos transportes)
 +
 +
=Exemplo de chamada de subrotina=
 +
 +
Complete o exercício abaixo.
 +
 +
<code>
 +
.
 +
inicio:
 +
    mov A,#5
 +
    lcall rotacionar_direita
 +
    mov A,#6
 +
    lcall piscar
 +
    mov A,#3
 +
    lcall rotacionar_esquerda
 +
    sjmp inicio
 +
 +
rotacionar_direita:
 +
    ret
 +
 +
piscar:
 +
    ret
 +
 +
rotacionar_esquerda:
 +
    ret
 +
</syntaxhighlight>
 +
 +
==Exercícios==
 +
 +
*Implementar um programa que incrementa sequencialmente um display de 7 segmentos (de 0 a 9). Após o 9 retornar ao 0.
 +
<code>
 +
.
 +
inicio:
 +
mov P1,#11000000b ; 0
 +
mov P1,#11111001b ; 1
 +
mov P1,#10100100b ; 2
 +
mov P1,#10110000b ; 3
 +
mov P1,#10011001b ; 4
 +
mov P1,#10010010b ; 5
 +
mov P1,#10000010b ; 6
 +
mov P1,#11111000b ; 7
 +
mov P1,#10000000b ; 8
 +
mov P1,#10010000b ; 9
 +
sjmp inicio
 +
</syntaxhighlight>
 +
*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.
 +
<code>
 +
.
 +
inicio:
 +
mov P1,#11000000b ; 0
 +
lcall aguardar_chave
 +
mov P1,#11111001b ; 1
 +
lcall aguardar_chave
 +
mov P1,#10100100b ; 2
 +
lcall aguardar_chave
 +
mov P1,#10110000b ; 3
 +
lcall aguardar_chave
 +
mov P1,#10011001b ; 4
 +
lcall aguardar_chave
 +
mov P1,#10010010b ; 5
 +
lcall aguardar_chave
 +
mov P1,#10000010b ; 6
 +
lcall aguardar_chave
 +
mov P1,#11111000b ; 7
 +
lcall aguardar_chave
 +
mov P1,#10000000b ; 8
 +
lcall aguardar_chave
 +
mov P1,#10010000b ; 9
 +
lcall aguardar_chave
 +
sjmp inicio
 +
</syntaxhighlight>
 +
*Modificar o alarme da aula anterior para que o número de violações de sensores seja registrado em um display (limitado ao número de 9).
 +
*Implementar um programa usando lógica binária que implementa um flip-flop JK.Considere o disparo com borda negativa.
 +
 +
{| align=center border=1
 +
|+ Tabela Verdade Flip Flop JK
 +
! CLK
 +
! J
 +
! K
 +
! <math>Q_{n+1}</math>
 +
|-
 +
| 0,1,<math>\uparrow</math>
 +
| X
 +
| X
 +
| <math>Q_n</math>
 +
|-
 +
| <math>\downarrow</math>
 +
| 0
 +
| 0
 +
| <math>Q_n</math>
 +
|-
 +
| <math>\downarrow</math>
 +
| 0
 +
| 1
 +
| 0
 +
|-
 +
| <math>\downarrow</math>
 +
| 1
 +
| 0
 +
| 1
 +
|-
 +
| <math>\downarrow</math>
 +
| 1
 +
| 1
 +
| <math>\overline{Q_n}</math>
 +
|}
 +
<code>
 +
ENT_J equ P1.0
 +
ENT_K  equ P1.1
 +
CLK    equ P1.2
 +
SAI_Q  equ P2.0
 +
SAI_QB  equ P2.1
 +
 +
;; INICIO DO PROGRAMA
 +
 +
inicio:
 +
lcall resetar_jk
 +
loop:
 +
lcall detector_borda
 +
jb ENT_J, j_setado
 +
jb ENT_K, k_setado
 +
sjmp loop
 +
;; FINAL DO LOOP PRINCIPAL
 +
 +
j_setado:
 +
jnb ENT_K, aux_k_resetado
 +
cpl SAI_Q
 +
cpl SAI_QB
 +
sjmp loop
 +
aux_k_resetado:
 +
lcall setar_jk
 +
sjmp loop
 +
 +
k_setado:
 +
lcall resetar_jk
 +
sjmp loop
 +
 +
;SUBROTINA DE DETECÇÃO DE BORDA
 +
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.
 +
 +
=Aula 15 - Dia 18/06/2013=
 +
 +
==Objetivos==
 +
 +
*Exercícios preparatórios para a avaliação 2;
 +
 +
==Operações Lógicas com bytes==
 +
 +
==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.
 +
<code>
 +
.
 +
ENTER EQU P1.0
 +
COD1  EQU P1.1
 +
COD2  EQU P1.2
 +
COD3  EQU P1.3
 +
COD4  EQU P1.4
 +
 +
;iniciar o sistema
 +
 +
;esperar que seja teclado enter
 +
loop_enter:
 +
jnb ENTER,loop_enter
 +
 +
;testar bit 1 - vai para sinalizar erro se incorreto
 +
jb COD1,sinalizar_erro
 +
jb COD2,sinalizar_erro
 +
jb COD3,sinalizar_erro
 +
jb COD4,sinalizar_erro
 +
;lcall abrir_porta
 +
        sjmp loop_enter
 +
sinalizar_erro:
 +
        ;sinalizar erro
 +
        sjmp loop_enter 
 +
</syntaxhighlight>
 +
#Implementar um programa com a seguinte lógica: <math>Y=ABC+D\overline{E}</math>. Quando o resultado de Y for 1, piscar dois LEDs de forma alternada, caso contrário piscar sumultaneamente.
 +
 +
 +
=Aula 16 - Dia 25/06/2013=
 +
 +
AVALIAÇÃO II
 +
 +
=Aula 17 - Dia 1/07/2013=
 +
 +
==Objetivos==
 +
 +
*Operações lógicas e aritméticas em nível de bytes.
 +
*Exercícios.
 +
 +
==Referências==
 +
 +
[[Arquivo:MIC-OperacoesArimeticas.pdf| Operações Aritméticas e Lógicas]]
 +
 +
==Exercícios==
 +
 +
#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
 +
<code>
 +
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>
 +
 +
=Aula 18 - Dia 2/07/2013=
 +
 +
==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.
 +
<code>
 +
inicio:
 +
  clr C
 +
  mov A,P1
 +
  mov R0,P2
 +
jb P3.1, soma
 +
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>
 +
 +
#Variação do exercício anterior com as 4 operações controladas por P3.1 e P3.2.
 +
 +
<code>
 +
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>
 +
 +
=Aula 19 - Dia 8/07/2013=
 +
 +
==Objetivos==
 +
 +
*Temporizadores e Contadores no 8051
 +
 +
==Referências==
 +
 +
*[[Arquivo:MIC_8051-TemporizadoresContadores.pdf | Temporizadores-Contadores]]
 +
 +
==Exercícios==
 +
 +
1.Implementar o exemplo da nota de aula acima (valores de timer modificado para simulação):
 +
 +
<code>
 +
.
 +
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: [http://www.google.com.br/imgres?imgurl=http://aninditadhikary.files.wordpress.com/2011/01/8051pins.png&imgrefurl=http://aninditadhikary.wordpress.com/tag/intel-8051/&h=537&w=546&sz=67&tbnid=w_AHvE4Z1AtfXM:&tbnh=90&tbnw=92&zoom=1&usg=__GFhzt-MDKo-ZQpAs4icqxTH_1tA=&docid=jQeswXN8vCbvnM&sa=X&ei=bqzWUcHQA4Pn0gGso4CYDQ&ved=0CEMQ9QEwAQ&dur=562 | 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.
 +
 +
 +
=Aula 20 - Dia 9/07/2013=
 +
 +
==Objetivos==
 +
 +
*interrrupções
 +
 +
==Referencias==
 +
 +
*[[Arquivo:MIC_8051-Interrupcoes.pdf | Interrupções]]
 +
 +
==Exercício==
 +
 +
<code>
 +
.
 +
  ;================================
 +
  ;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>
 +
 +
=Aula 21 - Dia 15/07/2013=
 +
 +
=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))
 +
 +
=Aula 22 - Dia 16/07/2013=
 +
 +
DESENVOLVIMENTO DO TRABALHO
 +
 +
=Aula 23 - Dia 22/07/2013=
 +
 +
DESENVOLVIMENTO DO TRABALHO
 +
 +
=Aula 24 - Dia 23/07/2013=
 +
 +
DESENVOLVIMENTO DO TRABALHO
 +
 +
=Aula 25 - Dia 29/07/2013=
 +
 +
REVISÃO RECUPERAÇÂO
 +
 +
=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:
 +
 +
<code>
 +
;
 +
inicio: 
 +
        mov dptr,#msg1
 +
        mov R0,#0ah
 +
        mov R1,#00h
 +
        lcall copiar_mensagem
 +
loop:  jmp loop
 +
   
 +
msg1:
 +
        db 'ALO IFSC',0
 +
 +
copiar_mensagem:
 +
        ;implementar aqui
 +
 +
</syntaxhighlight>
 +
     
 +
Exercício 2
 +
 +
Implementar no microcontrolador a seguinte função lógica:
 +
:<math>Y = A+BC+D</math>
 +
Usar como P1.0(entrada A), P1.1(entrada B), P1.2 (entrada C), P1.3(entrada D) e P1.4(saída Y).
 +
Mostrar o funcionamento nas chaves e LED.

Edição atual tal como às 11h06min de 5 de junho de 2014

DADOS GERAIS DA DISCIPLINA

Cronograma

AULA DATA Descriçao
1 2/4/2013
2 9/4/2013

AULA 1 - Dia 22/04/2013

OBS: aula improvisada pelo fato de ter sido repassada na última sexta.

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

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.
DiagramaBlocosMemorias.jpg

ou

DiagramaBlocosMemorias2.jpg

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.

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.,

Diagrama de Tempo - Acesso para escrita

DiagramaTempoAcessoEscrita.jpg


AULA 2 - Dia 23/04/2013

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;

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.

AULA 3 - Dia 29/04/2013

AULA 4 - Dia 30/04/2013

AULA 5

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;

Material de Aula

Arquitetura8051

Apostila Prof.Branco

AULA 6 - Dia 13/05/2013

Simulador MCU8051IDE

Ver detalhes do simulador MCU8051IDE aqui.

Exercícios no simulador

Ex1Aula6MIC.jpg
  1. 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).

AULA 7 - Dia 14/05/2013

Instruções de Movimentação Externa de Dados

Intsruções úteis: 

  movx A,@dptr
  movx @dptr,A
  inc dptr
  mov dptr,#imediato

</syntaxhighlight>

Exemplo:

Ex1Aula7MIC.jpg

Exercícios

  1. Colocar a mensagem "ALO" nas posições de memória externa de dados 0670h,0671h e 0672h.
    Ex2Aula7MIC.jpg
  2. Copiar o bloco de memória externa de dados das posições 1800h-1804h para as posições de memória externa 0000h-0004h.

AULA 8 - Dia 20/05/2013

Objetivo

  • Instruções de Movimentação Dados da Área de Código
  • Instruções de Jump Condicional para Controlar Loops
  • Exercícios

Material de Apoio

Media:Aula8-ModosEndereçamento-Exercícios.pdf

Exercício 1

Considere o código abaixo.

inicio:

loop: jmp loop

msg1: 

       db 'ALO IFSC'

</syntaxhighlight>

Inserir um código para ler a a cadeia 'ALO' para as posições de memória RAM interna 60h,61h e 62h.

SOLUÇÃO:

inicio: 

       mov dptr, #msg1
       mov a,#00h
       movc a,@a+dptr
       mov  60h,a

       mov a,#01h
       movc a,@a+dptr
       mov  61h,a

       mov a,#02h
       movc a,@a+dptr
       mov  62h,a

loop: jmp loop

msg1: 

       db 'ALO IFSC'

</syntaxhighlight>

Exercício 2

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>

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.

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.

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.

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.

AULA 8 - Dia 21/05/2013

Objetivo

  • uso de instrução cjne para elanborar loops

Exercício 1

Iniciar um bloco de memória RAM interna de 50h até 7fh com o valor E5h.

Solução: 

       .

mov A,#0E5h mov R0,#50h inicio: mov @R0,A inc R0 cjne R0,#80h,inicio

loop: jmp loop </syntaxhighlight>

Exercício 2

Copiar um bloco de memória RAM interna de 40h-7f para 20-5F usando move indireto. Sugestão: usar R0 e R1. 

       .

mov R0,#40h mov R1,#20h loop1: 

       mov A,@R0
       mov @R1,A
       inc R0
       inc R1
       cjne R0,#80h,loop1

loop: jmp loop </syntaxhighlight>

AULA 9 - Dia 27/05/2013

Objetivo

  • Instruções de movimentação de byte para as portas
  • instruções de loop condicional cjne
  • representação de palavras binárias em binário, hexadecimal e decimal

Exercício 1

Piscar 8 vezes o led da posição P1.0 e depois 8 vezes o LED da posição P1.7. Colocar tudo em um loop infinito. Use cjne A,imediato, label 

       .

inicio: 

       mov A,#8

loop1: mov P1,#0FEh mov P1,#0FFH dec A cjne A,#00,loop1 

       mov A,#8

loop2: mov P1,#01111111b mov P1,#11111111b dec A cjne A,#00,loop2

ljmp inicio </syntaxhighlight>

Exercício 2

Piscar 8 vezes o led da posição P1.0 e depois 8 vezes o LED da posição P1.7. Colocar tudo em um loop infinito. Use de cjne A,direto, label

inicio: 

       mov 50h,#8

loop_main: 

       mov A,#0

loop1: mov P1,#0FEh mov P1,#0FFH inc A cjne A,50h,loop1 

       mov A,#0

loop2: mov P1,#01111111b mov P1,#11111111b inc A cjne A,50h,loop2

ljmp loop_main </syntaxhighlight>

Exercício 3

Piscar 8 vezes o led da posição P1.0 e depois 8 vezes o LED da posição P1.7. Colocar tudo em um loop infinito. Use de cjne @R0,imediato, label

inicio: 

       mov R0,#50h

loop_main: 

       mov @R0,#0

loop1: mov P1,#0FEh mov P1,#0FFH inc @R0 cjne @R0,#8,loop1 

       mov @R0,#0

loop2: mov P1,#01111111b mov P1,#11111111b inc @R0 cjne @R0,#8,loop2

ljmp loop_main </syntaxhighlight>

AULA 10 - Dia 28/05/2013

Avaliação I

AULA 11 - Dia 3/06/2013

Objetivo

  • 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

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.

. inicio: mov P2,#0FFh loop: jb P2.0,pisca1 jb P2.1,pisca2 sjmp loop

pisca1: clr P1.0 setb P1.0 sjmp loop

pisca2: clr P1.1 setb P1.1 sjmp loop

</syntaxhighlight>

EXERCÍCIOS

  1. 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.

. inicio: mov P2,#0FFh loop: jb P2.0,rotaciona_direita sjmp rotaciona_esquerda


rotaciona_direita: mov P1,#01111111b mov P1,#10111111b mov P1,#11011111b mov P1,#11101111b mov P1,#11110111b mov P1,#11111011b mov P1,#11111101b mov P1,#11111110b sjmp loop

rotaciona_esquerda: mov P1,#11111110b mov P1,#11111101b mov P1,#11111011b mov P1,#11110111b mov P1,#11101111b mov P1,#11011111b mov P1,#10111111b 

       mov  P1,#01111111b

sjmp loop </syntaxhighlight>

  1. Acrescente no loop principal um jb para saltar para um código que pisca os LEDs de forma alternada.
  2. Modificar o programa exemplo substituindo as instruções de setb e clr por instruções de movimentação de byte para a porta.

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.

Exemplo 1: uma implementação da porta E:

inicio: 

       mov C, P2.0
       anl C, P2.1
       cpl c
       mov P1.0,c

sjmp inicio </syntaxhighlight>

Exemplo 2: uma implementação da porta OU:

inicio: 

       mov C, P2.0
       orl C, P2.1
       cpl c
       mov P1.0,c

sjmp inicio </syntaxhighlight>

inicio: mov P2,#0FFh mov P1,#7fh loop: jb P2.0,pisca1 jb P2.1,pisca2 sjmp loop

pisca1: mov A,P1 rr A mov P1,A sjmp loop

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:

AULA 12 - Dia 4/06/2013

Objetivo

  • Memória RAM com acesso por bit e por byte;
  • Exercícios de operações com bits.

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.

Arquivo:OperacoesBit.pdf

EXERCÍCIO 1: alarme simples

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

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:

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)

EXERCÍCIO 4: alarme simples com inibidor de entradas

  • As vezes é necessário desabilitar algum sensor. Acrescentar uma chave para desligar sensores.

Aula 12 - Dia 10/06/2013

  • Uso de Pilha e Subrotina
  • Exercícios

Material da Referência

Arquivo:ControleFluxo.pdf

Solução ex1 da nota de aula:

programa principal

inicio: 

       mov A,#0eeh

mov R0,#010 mov R1,#056h lcall zerar_iram

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>

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

</syntaxhighlight>

Aula 13 - Dia 24/06/2013

  • avaliação

Aula 14 - Dia 1/6/2-13

Objetivos

  • operações aritméticas e lógicas

Material da Aula

Aula 13 - Dia 11/06/2013

  • Exercícios

Aula 14 - Dia 17/06/2013

  • Conteúdo da aula 12 (que foi a greve dos transportes)

Exemplo de chamada de subrotina

Complete o exercício abaixo.

. inicio: 

    mov A,#5
    lcall rotacionar_direita
    mov A,#6
    lcall piscar
    mov A,#3
    lcall rotacionar_esquerda
    sjmp inicio

rotacionar_direita: 

    ret

piscar: 

    ret

rotacionar_esquerda: 

    ret

</syntaxhighlight>

Exercícios

  • Implementar um programa que incrementa sequencialmente um display de 7 segmentos (de 0 a 9). Após o 9 retornar ao 0.

. inicio: mov P1,#11000000b ; 0 mov P1,#11111001b ; 1 mov P1,#10100100b ; 2 mov P1,#10110000b ; 3 mov P1,#10011001b ; 4 mov P1,#10010010b ; 5 mov P1,#10000010b ; 6 mov P1,#11111000b ; 7 mov P1,#10000000b ; 8 mov P1,#10010000b ; 9 sjmp inicio </syntaxhighlight>

  • 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.

. inicio: mov P1,#11000000b ; 0 lcall aguardar_chave mov P1,#11111001b ; 1 lcall aguardar_chave mov P1,#10100100b ; 2 lcall aguardar_chave mov P1,#10110000b ; 3 lcall aguardar_chave mov P1,#10011001b ; 4 lcall aguardar_chave mov P1,#10010010b ; 5 lcall aguardar_chave mov P1,#10000010b ; 6 lcall aguardar_chave mov P1,#11111000b ; 7 lcall aguardar_chave mov P1,#10000000b ; 8 lcall aguardar_chave mov P1,#10010000b ; 9 lcall aguardar_chave sjmp inicio </syntaxhighlight>

  • Modificar o alarme da aula anterior para que o número de violações de sensores seja registrado em um display (limitado ao número de 9).
  • Implementar um programa usando lógica binária que implementa um flip-flop JK.Considere o disparo com borda negativa.
Tabela Verdade Flip Flop JK
CLK J K
0,1, X X
0 0
0 1 0
1 0 1
1 1

ENT_J equ P1.0 ENT_K equ P1.1 CLK equ P1.2 SAI_Q equ P2.0 SAI_QB equ P2.1

INICIO DO PROGRAMA

inicio: lcall resetar_jk loop: lcall detector_borda jb ENT_J, j_setado jb ENT_K, k_setado sjmp loop

FINAL DO LOOP PRINCIPAL

j_setado: jnb ENT_K, aux_k_resetado cpl SAI_Q cpl SAI_QB sjmp loop aux_k_resetado: lcall setar_jk sjmp loop

k_setado: lcall resetar_jk sjmp loop

SUBROTINA DE DETECÇÃO DE BORDA

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.

Aula 15 - Dia 18/06/2013

Objetivos

  • Exercícios preparatórios para a avaliação 2;

Operações Lógicas com bytes

Exercícios

  1. 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.

. ENTER EQU P1.0 COD1 EQU P1.1 COD2 EQU P1.2 COD3 EQU P1.3 COD4 EQU P1.4

iniciar o sistema
esperar que seja teclado enter

loop_enter: jnb ENTER,loop_enter

testar bit 1 - vai para sinalizar erro se incorreto

jb COD1,sinalizar_erro jb COD2,sinalizar_erro jb COD3,sinalizar_erro jb COD4,sinalizar_erro ;lcall abrir_porta 

       sjmp loop_enter

sinalizar_erro: 

       ;sinalizar erro
       sjmp loop_enter

</syntaxhighlight>

  1. 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.


Aula 16 - Dia 25/06/2013

AVALIAÇÃO II

Aula 17 - Dia 1/07/2013

Objetivos

  • Operações lógicas e aritméticas em nível de bytes.
  • Exercícios.

Referências

Arquivo:MIC-OperacoesArimeticas.pdf

Exercícios

  1. 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).
  2. 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>

Aula 18 - Dia 2/07/2013

Objetivos

  • Continuação da aula anterior
  1. 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.

inicio: 

 	clr C
 	mov A,P1
 	mov R0,P2

jb P3.1, soma 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>

  1. 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>

Aula 19 - Dia 8/07/2013

Objetivos

  • Temporizadores e Contadores no 8051

Referências

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.


Aula 20 - Dia 9/07/2013

Objetivos

  • interrrupções

Referencias

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>

Aula 21 - Dia 15/07/2013

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))

Aula 22 - Dia 16/07/2013

DESENVOLVIMENTO DO TRABALHO

Aula 23 - Dia 22/07/2013

DESENVOLVIMENTO DO TRABALHO

Aula 24 - Dia 23/07/2013

DESENVOLVIMENTO DO TRABALHO

Aula 25 - Dia 29/07/2013

REVISÃO RECUPERAÇÂO

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:

inicio: 

       mov dptr,#msg1
       mov R0,#0ah
       mov R1,#00h
       lcall copiar_mensagem

loop: jmp loop

msg1: 

       db 'ALO IFSC',0

copiar_mensagem: 

       ;implementar aqui

</syntaxhighlight>

Exercício 2

Implementar no microcontrolador a seguinte função lógica:

Usar como P1.0(entrada A), P1.1(entrada B), P1.2 (entrada C), P1.3(entrada D) e P1.4(saída Y). Mostrar o funcionamento nas chaves e LED.

Disponível em “https://wiki.sj.ifsc.edu.br/index.php?title=MIC-2013-1-CST_Introdução_aos_Microcoprocessadores&oldid=70226”