EXERCÍCIOS DE PROGRAMAÇÃO

Transcrição

1 EXERCÍCIOS DE PROGRAMAÇÃO A seguir são apresentados exercícios de programação que podem ser testados nas placas de laboratório de processadores que utilizam o MSC1211. São propostos vários exercícios. Em alguns, a solução (em assembly e C ) está impressa junto com esta documentação. Nos demais, você poderá encontrar os respectivos programas, no site desta disciplina. Junto aos circuitos você também vai encontrar a proposta de novos exercícios. Exemplo I Semáforo Este exercício utiliza a porta P1 para controlar as lâmpadas de um conjunto de três semáforos. O semáforo S3 é do pedestre e só utiliza as lâmpadas vermelha e verde. Veja a descrição do funcionamento dos semáforos que encontra-se impressa junto ao esquemático do circuito. Por simplicidade o circuito foi simplificado ao máximo. As lâmpadas do semáforo são consideradas ideiais, e portanto não consomem corrente da porta lógia. Portanto não há necessidade de resistores para limitação de corrente. Além disto, os semáforos possuem os circuitos necessários para acionar uma lâmpada conectada a rede elétrica, através de um sinal lógico do tipo TTL. Na prática, o projeto deveria contemplar tanto os resistores de limitação de corrente quanto os circuitos de disparo das lâmpadas. Para quem tiver curiosidade, procure a documentação do circuito MOC3020. Ele é um circuito de disparo para tiristores que pode ser utilizado nesta tarefa. Solução em Assembly Obs.: Este programa foi elaborado sem a adição das bibliotecas disponíveis e portanto, a listagem do programa ficou consideravelmente maior.

2 **** SEMAF_I.ASM ********************************************************* ** ** ********************************************************* by [JCLima ] *** $MOD51 *** Exemplo de Declaração de Pinos de I/ O ******************************* ** ** ************************************************************************** VM3 EQU P1.0 VM3 equ 90h AM3 EQU P1.1 AM3 equ 91h VD3 EQU P1.2 VD3 equ 92h *** Exemplo de Declarações de Constantes e Variáveis ********************* ** ** ************************************************************************** contador EQU 7FH unsigned char contador estado1 EQU 85h S1 Verde estado2 EQU 45h S1 Amarelo estado3 EQU 32h S2 Verde estado4 EQU 29h S2 Amarelo e S3 Vermelho On estado5 EQU 28h S2 Amarelo e S3 Vermelho Off *** Vetor de Reset ******************************************************* ** ** ****************************************************** Endereco: 0000H *** ORG 0000H LJMP START *** Vetor da INT0 ******************************************************** ** ** ****************************************************** Endereco: 0003H *** ORG 0003H *** Vetor do Timer 0 ***************************************************** ** ** ****************************************************** Endereco: 000BH *** ORG 000BH *** Vetor da INT1 ******************************************************** ** ** ****************************************************** Endereco: 0013H *** ORG 0013H *** Vetor do Timer 1 ***************************************************** ** ** ****************************************************** Endereco: 001BH *** ORG 001BH *** Vetor da Porta Serial ************************************************ ** ** ****************************************************** Endereco: 0023H *** ORG 0023H

3 *** PROGRAMA PRINCIPAL *************************************************** ** ** ************************************************************************** START: MOV SP,#80h Move a pilha para a RAM indireta!!! *** LOOP Programa Principal... REPETE: MOV P1,#estado1 MOV A,#22 delay 22s LCALL DELAYx1000ms MOV P1,#estado2 MOV A,#3 delay 3s LCALL DELAYx1000ms MOV P1,#estado3 MOV A,#15 delay 15s LCALL DELAYx1000ms MOV contador,#3 LOOP_REPETE: MOV P1,#estado4 LCALL DELAY500ms delay 0.5s MOV P1,#estado5 LCALL DELAY500ms delay 0.5s DJNZ contador,loop_repete LJMP REPETE Obs.: No MSC1211 um ciclo de Máquina = 4 pulsos de clock... Obs.: No 8051 um ciclo de Máquina = 12 pulsos de clock... *** DELAY 1ms ************************************************************ ** ** ******************************** [ MHz = 2757 CICLOS] *** DELAY1ms: PUSH 07H MOV R7,#83 < para um MSC1211 (4 pulsos/ciclo!!!) _LOOP1ms: NOP NOP NOP NOP NOP NOP NOP NOP NOP DJNZ POP RET R7,_LOOP1ms 07H *** DELAY 500ms ********************************************************** ** Baseada na rotina de 1ms! ** ********************************************* [ MHz ] *** DELAY500ms: PUSH 07H MOV R7,#100 _LOOP500ms: LCALL DELAY1ms Aguarda 1ms!!! LCALL DELAY1ms Aguarda 1ms!!! LCALL DELAY1ms Aguarda 1ms!!! LCALL DELAY1ms Aguarda 1ms!!! LCALL DELAY1ms Aguarda 1ms!!! DJNZ R7,_LOOP500ms Repete 100x POP 07H

4 RET *** DELAYx1000ms(A) ****************************************************** ** Baseada na rotina de 1ms! ** ********************************************* [ MHz ] *** DELAYx1000ms: PUSH 07H PUSH 06H MOV _LOOPxx1000ms: MOV R7,A R6,#200 _LOOPx1000ms: LCALL DELAY1ms Aguarda 1ms!!! LCALL DELAY1ms Aguarda 1ms!!! LCALL DELAY1ms Aguarda 1ms!!! LCALL DELAY1ms Aguarda 1ms!!! LCALL DELAY1ms Aguarda 1ms!!! DJNZ R6,_LOOPX1000ms Repete 200x = 1segundo DJNZ POP POP RET R7,_LOOPxx1000ms Repete A vezes 06H 07H END Solução em Linguagem C (utilizando o SDCC - compilado no modelo small) #include <8052.h> #include <stdio.h> **************************************************************** ** Pinos do MICROCONTROLADOR ** **************************************************************** sfr at 0x90 semaforo S1,S2,S3 --> P1 **************************************************************** ** V A R I Á V E I S E C O N S T A N T E S ** **************************************************************** const unsigned char estado[5] = 0x85, 0x45, 0x32, 0x29, 0x28 **************************************************************** ** P R O T O T Y P E S ** **************************************************************** void delay1ms(void) _naked void delay(unsigned int tempo) **************************************************************** ** M A I N ** **************************************************************** void main(void) unsigned char i while(1) semaforo = estado[0] delay(22000) semaforo = estado[1] delay(3000) semaforo = estado[2] aguarda 22s aguarda 3s

5 delay(15000) aguarda 15s for(i=0 i<3i++) Vermelho piscante por 3s semaforo = estado[3] delay(500) semaforo = estado[4] delay(500) **************************************************************** ** D E L A Y D E 1 m ** **************************************************************** mov r7,#212 <-- para um MSC1211 (4 pulsos/ciclo!!!) mov r7,#70 <-- para um AT89C52 (12 pulsos/ciclo!!!) void delay1ms(void) _naked _asm push ar7 mov r7,#70 DELAY_1ms: djnz r7,delay_1ms pop ar7 ret _endasm **************************************************************** ** D E L A Y P A R A M E T R I Z Á V E ** **************************************************************** void delay(unsigned int tempo) while (tempo > 0) tempo-- delay1ms() Exercício I Modifique o código acima, de modo que o sinal de vermelho piscante do semáforo S3 fique neste estado por 5 segundos, mas o estado de atenção do semáforo S2 permaneça em 3 segundos. Exercício II Escreva o código para fazer o acionamento de um novo conjunto de semáforos que estão representados no circuito dado a seguir. Veja a descrição do funcionamento das lâmpadas que se encontra impresso junto ao circuito elétrico.

6 Exemplo II Circuito de Display de 7 segmentos Neste exemplo utiliza-se a porta P1 para controlar um display de 7 segmentos, implementando um contador de 0 à 9 que é atualizado de segundo em segundo. No circuito, há um transistor PNP para fazer o acionamento do anodo do display. Em um circuito com apenas um display este transistor é totalmente dispensável. Ele está neste circuito apenas como exemplo de um circuito de drive de potência, para situações em que o usuário queira, por exemplo, alterar o brilho do display (através de um sinal de pwm) ou queira fazer a multiplexação de diversos dispositivos para a formação de um display de vários dígitos. Os resistores foram acrescentados para limitar a corrente de base do transistor e a corrente de cada segmento do display. Note que o circuito foi simplificado ao máximo, não estando representado no esquema elétrico o cristal oscilador e o circuito de reset. Em uma implementação real, tanto o cristal oscilador quanto o circuito de reset deveriam estar presentes.

7 Solução em Assembly **** UMDIGITO.ASM ******************************************************** ** ** ********************************************************* by [JCLima ] *** $MOD51 *** Declaração de Pinos de I/O ******************************************* ** ** ************************************************************************** display EQU P1 anodo EQU P3.2 *** Vetor de Reset ******************************************************* ** ** ****************************************************** Endereco: 0000H *** ORG 0000H LJMP START *** Vetor da INT0 ******************************************************** ** ** ****************************************************** Endereco: 0003H *** ORG 0003H *** Vetor do Timer 0 ***************************************************** ** ** ****************************************************** Endereco: 000BH ***

8 ORG 000BH *** Vetor da INT1 ******************************************************** ** ** ****************************************************** Endereco: 0013H *** ORG 0013H *** Vetor do Timer 1 ***************************************************** ** ** ****************************************************** Endereco: 001BH *** ORG 001BH *** Vetor da Porta Serial ************************************************ ** ** ****************************************************** Endereco: 0023H *** ORG 0023H *** PROGRAMA PRINCIPAL *************************************************** ** ** ************************************************************************** START: MOV DPTR,#TABELA DPTR aponta para a tabela de 7seg MOV R7,#0 R7 é o contador de 0 à 9... CLR anodo Liga o anodo para sempre... *** LOOP Programa Principal... REPETE: MOV A,R7 A = contador MOVC A,@A+DPTR Converte para 7 segmentos MOV P1,A Escreve no display... LCALL DELAY1000ms INC R7 Incrementa o contador CJNE R7,#10,REPETE Testa se contador = 10 MOV R7,#0 LJMP REPETE *** ARQUIVOS DE INCLUSAO ************************************************* ** ** ************************************************************************** Exemplos de declaração de Arquivos de Inclusão!!! OBS.: Descomente as linhas de comando, caso queira utilizar as bibliotecas listadas abaixo. $INCLUDE(DELAY_PR.INC) <--- Só esta biblioteca foi incluída!!! $INCLUDE(LCD_PROT.INC) $INCLUDE(I2C_PROT.INC) *** TABELAS, CONSTANTES, STRINGS ***************************************** ** ** ************************************************************************** TABELA: DB 0C0h, 0F9h, 0A4h, 0B0h, 99h, 92h, 82h, 0D8h, 80h, 90h END Solução em Linguagem C #include <8052.h> #include <stdio.h>

9 **************************************************************** ** Pinos do MICROCONTROLADOR ** **************************************************************** sfr at 0x90 display Display na porta P1 (A - P1.0, B - P1.1...) sbit at 0xb2 anodo Controle do anodo (P3.2) **************************************************************** ** V A R I Á V E I S E C O N S T A N T E S ** **************************************************************** const unsigned char Tabela[10] = 0xc0, 0xf9, 0xa4, 0xb0, 0x99, 0x92, 0x82, 0xd8, 0x80, 0x90 **************************************************************** ** P R O T O T Y P E S ** **************************************************************** void delay1ms(void) _naked void delay(unsigned int tempo) **************************************************************** ** M A I N ** **************************************************************** void main(void) unsigned char i = 0 anodo = 0 Liga o anodo... while(1) display = Tabela[i] i++ if(i == 10) i = 0 delay(1000) **************************************************************** ** D E L A Y D E 1 m ** **************************************************************** void delay1ms(void) _naked _asm push ar7 mov r7,#70 DELAY_1ms: djnz pop ret _endasm r7,delay_1ms ar7

10 **************************************************************** ** D E L A Y P A R A M E T R I Z Á V E ** **************************************************************** void delay(unsigned int tempo) while (tempo > 0) tempo-- delay1ms() Exercício III Modifique os programas em C e assembly do exemplo descrito acima (exemplo II), de modo a que o mesmo possa realizar a contagem em hexadecimal. Exemplo III Circuito de Display de 7 Segmentos Neste exemplo mapeia-se o mesmo display de 7 segmentos na memória RAM externa. A aplicação é a mesma, ou seja, implementar um contador de 0 à 9 que é atualizado de segundo em segundo. A diferença entre o exemplo II e este, está na forma de acessar o display. No exemplo II, o display estava conectado diretamente a porta P1 e bastava apenas um comando de MOV para acioná-lo. Para este exemplo, é necessário fazer uso da instrução para acessar o display, pois agora o mesmo está mapeado na RAM. Para simplificar, foram retirados os resistores de limitação da corrente de cada segmento. Em um circuito real isto não pode ser feito, sob pena de danificar o display e o latch conectado ao mesmo!

11 Obs.: Para que se possa acessar o display é necessário saber em que posição da memória o mesmo foi colocado. O endereço é obtido pela análise do circuito elétrico. Solução em Assembly **** UM_MEM.ASM ********************************************************** ** ** ********************************************************* by [JCLima ] *** $MOD51 *** Definições *********************************************************** ** ** ************************************************************************** display EQU 0EE00h Endereço do display na RAM externa *** Vetor de Reset ******************************************************* ** ** ****************************************************** Endereco: 0000H *** ORG 0000H LJMP START *** Vetor da INT0 ******************************************************** ** ** ****************************************************** Endereco: 0003H *** ORG 0003H *** Vetor do Timer 0 ***************************************************** ** ** ****************************************************** Endereco: 000BH *** ORG 000BH *** Vetor da INT1 ******************************************************** ** ** ****************************************************** Endereco: 0013H *** ORG 0013H *** Vetor do Timer 1 ***************************************************** ** ** ****************************************************** Endereco: 001BH *** ORG 001BH *** Vetor da Porta Serial ************************************************ ** ** ****************************************************** Endereco: 0023H *** ORG 0023H *** PROGRAMA PRINCIPAL *************************************************** ** ** ************************************************************************** START: MOV R7,#0 R7 é o contador de 0 à 9...

12 *** LOOP Programa Principal... REPETE: MOV DPTR,#TABELA DPTR aponta para a tabela de 7seg MOV A,R7 A = contador... MOVC A,@A+DPTR Converte para 7 segmentos... MOV DPTR,#display DPTR aponta para a RAM externa... Escreve na RAM externa... LCALL DELAY1000ms Delay de 1 segundo... INC R7 contador = contador + 1 CJNE R7,#10,REPETE contador = 10? MOV R7,#0 LJMP REPETE *** ARQUIVOS DE INCLUSAO ************************************************* ** ** ************************************************************************** OBS.: Descomente as linhas de comando, caso queira utilizar as bibliotecas listadas abaixo. $INCLUDE(DELAY_PR.INC) Só esta biblioteca foi incluída!!! $INCLUDE(LCD_PROT.INC) $INCLUDE(I2C_PROT.INC) *** TABELAS, CONSTANTES, STRINGS ***************************************** ** ** ************************************************************************** TABELA: DB 0C0h, 0F9h, 0A4h, 0B0h, 99h, 92h, 82h, 0D8h, 80h, 90h END Solução em Linguagem C #include <8052.h> #include <stdio.h> **************************************************************** ** Pinos do MICROCONTROLADOR ** **************************************************************** xdata at 0xee00 unsigned char display Endereço da RAM ext. **************************************************************** ** V A R I Á V E I S E C O N S T A N T E S ** **************************************************************** const unsigned char Tabela[10] = 0xc0, 0xf9, 0xa4, 0xb0, 0x99, 0x92, 0x82, 0xd8, 0x80, 0x90 **************************************************************** ** P R O T O T Y P E S ** **************************************************************** void delay1ms(void) _naked void delay(unsigned int tempo) **************************************************************** ** M A I N ** **************************************************************** void main(void)

13 unsigned char i = 0 while(1) display = Tabela[i] if(++i == 10) i = 0 delay(1000) **************************************************************** ** D E L A Y D E 1 m ** **************************************************************** void delay1ms(void) _naked _asm push ar7 mov r7,#70 DELAY_1ms: djnz pop ret _endasm r7,delay_1ms ar7 **************************************************************** ** D E L A Y P A R A M E T R I Z Á V E ** **************************************************************** void delay(unsigned int tempo) while (tempo > 0) tempo-- delay1ms() Exercício IV Modifique os programas em C e assembly do exemplo descrito acima (exemplo III), de modo a que o mesmo possa realizar uma contagem em octal. Exemplo IV Circuito de Display de 7 Segmentos Multiplexado Neste exemplo, dois displays de 7 segmentos estão conectados a porta P1. Para que seja feita a seleção de qual dígito será acionado, foram utilizadas duas linhas de controle: P3.3 para acionar o dígito da dezena e P3.2 para acionar o dígito da unidade. De modo que o usuário não perceba que os dígitos estão piscando, sugere-se que cada dígito seja acionado pelo menos 50 vezes por segundo (varredura de 100Hz). O display é do tipo anodo comum. Os segmentos

14 são acionados com nível lógico 0 e os anodos são acionados com nível lógico 1. O circuito foi simplificado ao máximo, tanto com relação ao microcontrolador quanto com relação ao circuito de multiplexação do display. Desta forma não aparecem as chaves (transistores) responsáveis pelo chaveamento dos displays. Admita que estes circuitos estão embutidos nos próprios displays. Em um circuito real não é possível conectar o display ao microcontrolador da forma como está representado no diagrama elétrico. Seria necessário acrescentar os resistores para limitação de corrente e os transistores para o chaveamento dos displays. Para o circuito proposto deseja-se implementar um contador de 0 à 99 que será atualizado a cada segundo. A contagem será feita empregando apenas um contador, ou seja, o programa deve tratar de separar a unidade da dezena, utilizando as operações de divisão inteira e resto da divisão. Solução em Assembly **** DOIS_DGT.ASM ******************************************************** ** ** ** Ultima Modificacao em: 05/10/2008 ** ** ** ********************************************************* by [JCLima ] *** $MOD51 *** Exemplos de Declaração de Pinos de I/O ******************************* ** ** ************************************************************************** display EQU P1

15 anodo_u EQU P3.2 anodo_d EQU P3.3 *** Vetor de Reset ******************************************************* ** ** ****************************************************** Endereco: 0000H *** ORG 0000H LJMP START *** Vetor da INT0 ******************************************************** ** ** ****************************************************** Endereco: 0003H *** ORG 0003H *** Vetor do Timer 0 ***************************************************** ** ** ****************************************************** Endereco: 000BH *** ORG 000BH *** Vetor da INT1 ******************************************************** ** ** ****************************************************** Endereco: 0013H *** ORG 0013H *** Vetor do Timer 1 ***************************************************** ** ** ****************************************************** Endereco: 001BH *** ORG 001BH *** Vetor da Porta Serial ************************************************ ** ** ****************************************************** Endereco: 0023H *** ORG 0023H *** PROGRAMA PRINCIPAL *************************************************** ** ** ************************************************************************** START: MOV DPTR,#TABELA DPTR aponta para a tabela de 7seg MOV R7,#0 R7 é o contador de 0 à CLR anodo_d Desliga o anodo da dezena... CLR anodo_u Desliga o anodo da unidade... *** LOOP Programa Principal... REPETE: MOV R6,#50 Contador da varredura LOOP_VAR: MOV A,R7 Carrega Contador... MOV B,#10 DIV AB Separa A = Dezena, B = Unidade MOVC A,@A+DPTR Liga dígito da dezena por 10ms MOV P1,A SETB ANODO_D LCALL DELAY10ms CLR ANODO_D MOV A,B Liga dígito da unidade por 10ms

16 MOVC MOV P1,A SETB ANODO_U LCALL DELAY10ms CLR ANODO_U DJNZ R6,LOOP_VAR Repete por 50x 50x(10ms+10ms) = 1s --> Delay da varredura INC R7 Incrementa contador... CJNE R7,#100,REPETE Contador = 100? MOV R7,#0 LJMP REPETE *** ARQUIVOS DE INCLUSAO ************************************************* ** ** ************************************************************************** $INCLUDE(DELAY_PR.INC) *** TABELAS, CONSTANTES, STRINGS ***************************************** ** ** ************************************************************************** TABELA: DB 0C0h, 0F9h, 0A4h, 0B0h, 99h, 92h, 82h, 0D8h, 80h, 90h END Solução em Linguagem C #include <8052.h> #include <stdio.h> #include <delay.h> **************************************************************** ** Pinos do MICROCONTROLADOR ** **************************************************************** sfr at 0x90 display Display na porta P1 (A - P1.0, B - P1.1...) sbit at 0xb2 anodou Controle da dezena (P3.2) sbit at 0xb3 anodod Controle da unidade (P3.3) **************************************************************** ** V A R I Á V E I S E C O N S T A N T E S ** **************************************************************** const unsigned char Tabela[10] = 0xc0, 0xf9, 0xa4, 0xb0, 0x99, 0x92, 0x82, 0xd8, 0x80, 0x90 **************************************************************** ** P R O T O T Y P E S ** **************************************************************** void delay1ms(void) _naked void delay(unsigned int tempo) **************************************************************** ** M A I N ** **************************************************************** Obs:. As rotinas de delay foram incluídas em uma biblioteca denominada de delay.lib void main(void)

17 unsigned char i, contador = 0 anodod = 0 Desliga Dezena e... anodou = 0 desliga unidade while(1) for(i=0 i<50 i++) display = Tabela[contador/10] anodod = 1 delay(10) anodod = 0 Separa a dezena... e liga display dezena display = Tabela[contador%10] anodou = 1 delay(10) anodou = 0 if(++contador == 100) contador = 0 Seapara a Unidade e liga display unidade Exercício V Modifique os programas em C e assembly do exemplo anterior (exemplo IV) de modo que o mesmo implemente um contador de 0 à 59, o qual será atualizado a cada segundo, mas com numeração em octal e em hexadecimal. A contagem será feita empregando apenas um contador, ou seja, o programa deve tratar de separar a unidade da dezena, utilizando as operações de divisão inteira e resto da divisão. Exemplo V Neste exemplo, quatro displays de 7 segmentos estão conectados a porta P1. Para que seja feita a seleção de qual dígito será acionado, foram utilizadas quatro linhas de controle: P3.2 à P3.5, para o acionamento do dígito da unidade (P3.5) até o dígito do milhar (P3.2). De modo que o usuário não perceba que os dígitos estão piscando, sugere-se que cada dígito seja acionado pelo menos 50 vezes por segundo (varredura de 200Hz). O display é do tipo anodo comum. Os segmentos são acionados com nível lógico 0 e os anodos são acionados com nível lógico 1. O circuito foi simplificado ao máximo, tanto com relação ao microcontrolador quanto com relação ao circuito de multiplexação do display. Desta forma não aparecem as chaves (transistores) responsáveis pelo chaveamento dos displays. Admita que estes circuitos estão embutidos nos próprios displays. Em um circuito real não é possível conectar o display ao microcontrolador da forma como está representado no diagrama elétrico. Seria necessário acrescentar os resistores para limitação de corrente e os transistores para o chaveamento dos displays. Para o circuito proposto deseja-se implementar um contador de 0 à 9999 que será atualizado a cada décimo de segundo. A contagem será feita empregando vários contadores, cada um responsável pelo valor do dígito correspondente, ou seja, serão utilizados quatro contadores.

18 Solução em Assembly **** DOIS_DGT.ASM ******************************************************** ** ** ** Ultima Modificacao em: 05/10/2008 ** ** ** ********************************************************* by [JCLima ] *** $MOD51 *** Declarações de Variáveis ********************************************* ** ** ************************************************************************** MILHAR EQU 7FH CENTENA EQU 7EH DEZENA EQU 7DH UNIDADE EQU 7CH *** Declaração de Pinos de I/O ******************************************* ** ** ************************************************************************** display EQU P1 anodo_m EQU P3.2 anodo_c EQU P3.3 anodo_d EQU P3.4 anodo_u EQU P3.5 *** Vetor de Reset *******************************************************

19 ** ** ****************************************************** Endereco: 0000H *** ORG 0000H LJMP START *** Vetor da INT0 ******************************************************** ** ** ****************************************************** Endereco: 0003H *** ORG 0003H *** Vetor do Timer 0 ***************************************************** ** ** ****************************************************** Endereco: 000BH *** ORG 000BH *** Vetor da INT1 ******************************************************** ** ** ****************************************************** Endereco: 0013H *** ORG 0013H *** Vetor do Timer 1 ***************************************************** ** ** ****************************************************** Endereco: 001BH *** ORG 001BH *** Vetor da Porta Serial ************************************************ ** ** ****************************************************** Endereco: 0023H *** ORG 0023H *** PROGRAMA PRINCIPAL *************************************************** ** ** ************************************************************************** START: MOV DPTR,#TABELA DPTR aponta para a tabela de 7seg MOV MOV MOV MOV MILHAR,#0 CENTENA,#0 DEZENA,#0 UNIDADE,#0 CLR ANODO_M Desliga o anodo do milhar... CLR ANODO_C Desliga o anodo da centena... CLR ANODO_D Desliga o anodo da dezena... CLR ANODO_U Desliga o anodo da unidade... *** LOOP Programa Principal... REPETE: MOV R6,#5 Contador da varredura LOOP_VAR: MOV A,MILHAR Carrega Contador do milhar... MOVC A,@A+DPTR Liga dígito do milhar por 5ms MOV P1,A SETB ANODO_M LCALL DELAY5ms CLR ANODO_M MOV A,CENTENA Carrega Contador da centena...

20 MOVC Liga dígito da centena por 5ms MOV P1,A SETB ANODO_C LCALL DELAY5ms CLR ANODO_C MOV A,DEZENA Carrega Contador da dezena... MOVC Liga dígito da dezena por 5ms MOV P1,A SETB ANODO_D LCALL DELAY5ms CLR ANODO_D MOV A,UNIDADE Carrega Contador da unidade... MOVC Liga dígito da unidade por 5ms MOV P1,A SETB ANODO_U LCALL DELAY5ms CLR ANODO_U DJNZ R6,LOOP_VAR Repete por 5x 50x(5ms+5ms+5ms+5ms)=100ms-->Delay da varredura MOV A,#10 INC UNIDADE Incrementa unidade... CJNE A,UNIDADE,REPETE unidade = 10? MOV UNIDADE,#0 INC DEZENA Incrementa dezena... CJNE A,DEZENA,REPETE dezena = 10? MOV DEZENA,#0 INC CENTENA Incrementa centena... CJNE A,CENTENA,REPETE centena = 10? MOV CENTENA,#0 INC MILHAR Incrementa milhar... CJNE A,MILHAR,REPETE milhar = 10? MOV MILHAR,#0 LJMP REPETE *** ARQUIVOS DE INCLUSAO ************************************************* ** ** ************************************************************************** $INCLUDE(DELAY_PR.INC) *** TABELAS, CONSTANTES, STRINGS ***************************************** ** ** ************************************************************************** TABELA: DB 0C0h, 0F9h, 0A4h, 0B0h, 99h, 92h, 82h, 0D8h, 80h, 90h END Solução em Linguagem C #include <8052.h> #include <stdio.h> #include <delay.h> **************************************************************** ** Pinos do MICROCONTROLADOR ** **************************************************************** sfr at 0x90 display Display na porta P1 (A - P1.0, B - P1.1...)

21 sbit at 0xb2 dig1 sbit at 0xb3 dig2 sbit at 0xb4 dig3 sbit at 0xb5 dig4 Controle do digito 1 (P3.2) Controle do digito 1 (P3.3) Controle do digito 1 (P3.4) Controle do digito 1 (P3.5) **************************************************************** ** V A R I Á V E I S E C O N S T A N T E S ** **************************************************************** const unsigned char Tabela[10] = 0xc0, 0xf9, 0xa4, 0xb0, 0x99, 0x92, 0x82, 0xd8, 0x80, 0x90 **************************************************************** ** P R O T O T Y P E S ** **************************************************************** void delay1ms(void) _naked void delay(unsigned int tempo) **************************************************************** ** M A I N ** **************************************************************** Obs:. As rotinas de delay foram incluídas em uma biblioteca denominada de delay.lib void main(void) unsigned char i, unidade, dezena, centena, milhar dig1 = 0 dig2 = 0 dig3 = 0 dig4 = 0 unidade = 0 dezena = 0 centena = 0 milhar = 0 while(1) for(i=0 i<50 i++) display = Tabela[milhar] dig1 = 1 delay(5) dig1 = 0 display = Tabela[centena] dig2 = 1 delay(5) dig2 = 0 display = Tabela[dezena] dig3 = 1 delay(5) dig3 = 0 display = Tabela[unidade] dig4 = 1 delay(5) dig4 = 0 if(++unidade == 10)

22 unidade = 0 if(++dezena == 10) dezena = 0 if(++centena == 10) centena = 0 if(++milhar == 10) milhar = 0 Outra Solução em Linguagem C Outra forma de implementar o programa seria utilizando um único contador (inteiro de 16bits) e separando através de divisões inteiras os dígitos do milhar até a unidade. Esta abordagem é fácil de ser feita em C mas não é tão simples de se implementar em assembly pois divisões de números de 16 bits não são nativas do processador e portanto o programador deve implementar os algoritmos de divisão com base na divisão de 8 bits. #include <8052.h> #include <stdio.h> #include <delay.h> **************************************************************** ** Pinos do MICROCONTROLADOR ** **************************************************************** sfr at 0x90 display Display na porta P1 (A - P1.0, B - P1.1...) sbit at 0xb2 dig1 Controle do digito 1 (P3.2) sbit at 0xb3 dig2 Controle do digito 1 (P3.3) sbit at 0xb4 dig3 Controle do digito 1 (P3.4) sbit at 0xb5 dig4 Controle do digito 1 (P3.5) **************************************************************** ** V A R I Á V E I S E C O N S T A N T E S ** **************************************************************** const unsigned char Tabela[10] = 0xc0, 0xf9, 0xa4, 0xb0, 0x99, 0x92, 0x82, 0xd8, 0x80, 0x90 **************************************************************** ** P R O T O T Y P E S ** **************************************************************** void delay1ms(void) _naked void delay(unsigned int tempo) **************************************************************** ** M A I N ** **************************************************************** Obs:. As rotinas de delay foram incluídas em uma biblioteca denominada de delay.lib void main(void) unsigned char i, unidade, dezena, milhar unsigned int centena, contador dig1 = 0

23 dig2 = 0 dig3 = 0 dig4 = 0 contador = 0 unidade = 0 dezena = 0 centena = 0 milhar = 0 while(1) for(i=0 i<5 i++) display = Tabela[milhar] dig1 = 1 delay(5) dig1 = 0 display = Tabela[centena] dig2 = 1 delay(5) dig2 = 0 display = Tabela[dezena] dig3 = 1 delay(5) dig3 = 0 display = Tabela[unidade] dig4 = 1 delay(5) dig4 = 0 if(++contador == 10000) contador = 0 milhar = contador/1000 centena = contador%1000 dezena = centena%100 centena = centena/100 unidade = dezena%10 dezena = dezena/10 Exercício VI Modifique os programas em C e assembly do exemplo anterior (exemplo V) de modo que o mesmo implemente um cronômetro centesimal de à 59.99, o qual será atualizado a cada centésimo de segundo. Exercício VII No exemplo de hardware apresentado a seguir, são utilizados seis displays de 7 segmentos, os quais estão conectados a porta P1, e duas chaves do tipo Push Button nas portas P3.0 e P3.1. Para que seja feita a seleção de qual dígito será acionado, foram utilizadas seis linhas de controle: P3.2 à P3.7. De modo que o usuário não perceba que os dígitos estão piscando, sugere-se que cada dígito seja acionado pelo menos 50 vezes por segundo (varredura de 300Hz). O display é do tipo anodo comum. Os segmentos são acionados com nível lógico 0 e os anodos são acionados com nível lógico 1. O circuito foi simplificado ao máximo, tanto com relação ao microcontrolador quanto com relação ao circuito de multiplexação do display. Desta forma não aparecem as chaves (transistores) responsáveis pelo chaveamento dos displays. Admita que estes circuitos estão embutidos nos próprios displays. Em um circuito real não é possível conectar o display ao microcontrolador da forma como está representado no

24 diagrama elétrico. Seria necessário acrescentar os resistores para limitação de corrente e os transistores para o chaveamento dos displays. Para o circuito proposto escreva um programa para implementar um relógio com indicação de hora, minuto e segundo. O ajuste da hora inicial deverá ser feito por meio das duas chaves disponibilizadas no circuito. Suponha que o ajuste da hora só pode ser feito ao iniciar o programa, ou seja, após o reset. Depois de ajustada a hora, o relógio só poderá ter sua hora novamente ajustada ao se dar um reset no microcontrolador. Exercício VIII No circuito apresentado a seguir, quatro displays de 7 segmentos multiplexados estão conectados a memória RAM externa, através de dois latchs. Um dos latchs (U4), controla o valor dos dígitos, enquanto que o outro latch (U5) controla qual dígito será acionado naquele momento. De modo a que o usuário não perceba que os dígitos estão piscando, sugere-se que cada dígito seja acionado pelo menos 50 vezes por segundo (varredura de 200Hz). O display é do tipo anodo comum. Os segmentos são acionados com nível lógico 0 e os anodos são acionados com nível lógico 1. O circuito foi simplificado ao máximo, tanto com relação ao microcontrolador quanto com relação ao circuito de multiplexação do display. Desta forma não aparecem as chaves (transistores) responsáveis pelo chaveamento dos displays. Admita que estes circuitos estão embutidos nos próprios displays. Em um circuito real não é possível conectar o display ao microcontrolador da forma como está representado no diagrama elétrico. Seria necessário acrescentar os resistores para limitação de corrente e os transistores para o chaveamento dos displays. Para o circuito proposto implemente, um contador de 0 à 9999 que indique o valor da contagem em décimos de segundo. Implemente também com este circuito, um cronômetro

25 centesimal, de à 59.99, com indicação em centésimos de segundo. Neste exemplo, faça uso do ponto decimal para separa os segundos dos centésimos de segundo. Exercício IX No circuito apresentado a seguir, quatro displays de 7 segmentos multiplexados estão conectados a memória RAM externa, através de dois latchs. Um dos latchs (U4), controla o valor dos dígitos, enquanto que o outro latch (U5) controla qual dígito será acionado naquele momento. Ao circuito foi foi acrescentado um conversor A/D do tipo ADC0831 (protocolo serial) e um potenciômetro, de modo a variar o sinal na entrada do A/D de 0 à 1Volts. Para o circuito proposto, implemente um termômetro digital com a utilização do conversor A/D e do potenciômetro, o qual vai simular um sensor de temperatura, que varia de 0 a 100ºC gerando um sinal de 10mV/ ºC (LM35). A indicação no display será feita da seguinte forma

26 Exercício X No circuito apresentado a seguir, um display LCD 20x4 está conectado diretamente as portas P1 (dados do LCD) e P3 (controle do LCD sinais RS e E do LCD). Ao circuito foi foi acrescentado um conversor A/D do tipo ADC0831 (protocolo serial) e um potenciômetro, de modo a variar o sinal na entrada do A/D de 0 à 1Volts. O conversor A/D é controlado pela porta P3. Para o circuito proposto, implemente um termômetro digital com a utilização do conversor A/D e do potenciômetro, o qual vai simular um sensor de temperatura, que varia de 0 a 100ºC gerando um sinal de 10mV/ ºC (LM35).

27 Exercício XI No circuito apresentado a seguir, um display LCD 20x4 está conectado a memória RAM externa, através de dois latchs. Um dos latchs (U4), controla o valor do barramento de dados, enquanto que o outro latch (U5) controla os sinais de controle RS e E. Ao circuito foi foi acrescentado um conversor A/D do tipo ADC0831 (protocolo serial) e um potenciômetro, de modo a variar o sinal na entrada do A/D de 0 à 1Volts. O Conversor A/D é controlado por meio da porta P1. Para o circuito proposto, implemente um termômetro digital com a utilização do conversor A/D e do potenciômetro, o qual vai simular um sensor de temperatura, que varia de 0 a 100ºC gerando um sinal de 10mV/ ºC (LM35).

28