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.

; ; **** 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áv eis ********************* ; ** ** ; ************************************************* ************************* ; contador EQU 7FH ; unsigned char conta dor 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 “Of f” ; *** Vetor de Reset ****************************** ************************* ; ** ** ; ************************************************* ***** Endereco: 0000H *** ; ORG 0000H LJMP START ; *** Vetor da INT0 ******************************* ************************* ; ** ** ; ************************************************* ***** Endereco: 0003H *** ; ORG 0003H RETI ; *** Vetor do Timer 0 **************************** ************************* ; ** ** ; ************************************************* ***** Endereco: 000BH *** ; ORG 000BH RETI ; *** Vetor da INT1 ******************************* ************************* ; ** ** ; ************************************************* ***** Endereco: 0013H *** ; ORG 0013H RETI ; *** Vetor do Timer 1 **************************** ************************* ; ** ** ; ************************************************* ***** Endereco: 001BH *** ; ORG 001BH RETI ; *** Vetor da Porta Serial *********************** ************************* ; ** ** ; ************************************************* ***** Endereco: 0023H *** ; ORG 0023H RETI

; *** PROGRAMA PRINCIPAL ************************** ************************* ; ** ** ; ************************************************* ************************* ; START: MOV SP,#80h ; Move a pi lha 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.5 s MOV P1,#estado5 LCALL DELAY500ms ; delay 0.5 s DJNZ contador,LOOP_REPETE LJMP REPETE ; Obs.: No MSC1211 um ciclo de Máquina = 4 pulsos d e clock... ; Obs.: No 8051 um ciclo de Máquina = 12 pulsos de clock... ; ; *** DELAY 1ms *********************************** ************************* ; ** ** ; ******************************** [ MSC1211 @ 11.0 592MHz = 2757 CICLOS] *** ; DELAY1ms: PUSH 07H MOV R7,#83 ; <-- 250 para um MSC1211 (4 pulsos/ ciclo!!!) _LOOP1ms: NOP NOP NOP NOP NOP NOP NOP NOP NOP DJNZ R7,_LOOP1ms POP 07H RET ; *** DELAY 500ms ********************************* ************************* ; ** Baseada na rotina de 1ms! ** ; ********************************************* [ M SC1211 @ 11.0592MHz ] *** ; 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

RET ; *** DELAYx1000ms(A) ***************************** ************************* ; ** Baseada na rotina de 1ms! ** ; ********************************************* [ M SC1211 @ 11.0592MHz ] *** ; DELAYx1000ms: PUSH 07H PUSH 06H MOV R7,A _LOOPxx1000ms: MOV 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 R7,_LOOPxx1000ms ; Repete A vezes POP 06H POP 07H RET 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); // aguarda 22s semaforo = estado[1]; delay(3000); // aguarda 3s semaforo = estado[2];

delay(15000); // aguarda 15s for(i=0; i<3;i++) // Vermelho piscante po r 3s { semaforo = estado[3]; delay(500); semaforo = estado[4]; delay(500); } } } // // ************************************************ **************** // ** D E L A Y D E 1 m s @11.0592MHz ** // ************************************************ **************** // // mov r7,#212 ; <-- para um MSC1211 (4 pulsos/c iclo!!!) // mov r7,#70 ; <-- para um AT89C52 (12 pulsos/ ciclo!!!) // void delay1ms(void) _naked { _asm push ar7 mov r7,#70 DELAY_1ms: nop nop nop nop nop nop nop nop nop nop nop 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 L @11 .0592MHz ** // ************************************************ **************** // 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.

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.

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 RETI ; *** Vetor do Timer 0 **************************** ************************* ; ** ** ; ************************************************* ***** Endereco: 000BH ***

; ORG 000BH RETI ; *** Vetor da INT1 ******************************* ************************* ; ** ** ; ************************************************* ***** Endereco: 0013H *** ; ORG 0013H RETI ; *** Vetor do Timer 1 **************************** ************************* ; ** ** ; ************************************************* ***** Endereco: 001BH *** ; ORG 001BH RETI ; *** Vetor da Porta Serial *********************** ************************* ; ** ** ; ************************************************* ***** Endereco: 0023H *** ; ORG 0023H RETI ; *** PROGRAMA PRINCIPAL ************************** ************************* ; ** ** ; ************************************************* ************************* ; START: MOV DPTR,#TABELA ; DPTR apon ta para a tabela de 7seg MOV R7,#0 ; R7 é o co ntador de 0 à 9... CLR anodo ; Liga o an odo para sempre... ; *** LOOP Programa Principal ... ; REPETE: MOV A,R7 ; A = contador MOVC A,@A+DPTR ; Converte para 7 segmentos MOV P1,A ; Escreve no displa y... LCALL DELAY1000ms INC R7 ; Incrementa o contad or 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 queir a utilizar ; as bibliotecas listadas abaixo. ; $INCLUDE(DELAY_PR.INC) ; <--- Só esta biblio teca 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 ** // ************************************************ **************** // sfr at 0x90 display; // Display na porta P1 (A - P 1.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 s @11.0592MHz ** // ************************************************ **************** // void delay1ms(void) _naked { _asm push ar7 mov r7,#70 DELAY_1ms: nop nop nop nop nop nop nop nop nop nop nop 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 L @11 .0592MHz ** // ************************************************ **************** // 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 “MOVX @DPTR” 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!

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 displ ay na RAM externa ; *** Vetor de Reset ****************************** ************************* ; ** ** ; ************************************************* ***** Endereco: 0000H *** ; ORG 0000H LJMP START ; *** Vetor da INT0 ******************************* ************************* ; ** ** ; ************************************************* ***** Endereco: 0003H *** ; ORG 0003H RETI ; *** Vetor do Timer 0 **************************** ************************* ; ** ** ; ************************************************* ***** Endereco: 000BH *** ; ORG 000BH RETI ; *** Vetor da INT1 ******************************* ************************* ; ** ** ; ************************************************* ***** Endereco: 0013H *** ; ORG 0013H RETI ; *** Vetor do Timer 1 **************************** ************************* ; ** ** ; ************************************************* ***** Endereco: 001BH *** ; ORG 001BH RETI ; *** Vetor da Porta Serial *********************** ************************* ; ** ** ; ************************************************* ***** Endereco: 0023H *** ; ORG 0023H RETI ; *** PROGRAMA PRINCIPAL ************************** ************************* ; ** ** ; ************************************************* ************************* ; START: MOV R7,#0 ; R7 é o co ntador de 0 à 9...

; *** LOOP Programa Principal ... ; REPETE: MOV DPTR,#TABELA ; DPTR apon ta para a tabela de 7seg MOV A,R7 ; A = conta dor... MOVC A,@A+DPTR ; Converte para 7 segmentos... MOV DPTR,#display ; DPTR apon ta para a RAM externa... MOVX @DPTR,A ; Escreve n a RAM externa... LCALL DELAY1000ms ; Delay de 1 segundo... INC R7 ; contador = c ontador + 1 CJNE R7,#10,REPETE ; contador = 10? MOV R7,#0 LJMP REPETE ; *** ARQUIVOS DE INCLUSAO ************************ ************************* ; ** ** ; ************************************************* ************************* ; OBS.: Descomente as linhas de comando, caso queir a utilizar ; as bibliotecas listadas abaixo. ; $INCLUDE(DELAY_PR.INC) ; Só esta biblioteca foi in cluí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)

{ 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 s @11.0592MHz ** // ************************************************ **************** // void delay1ms(void) _naked { _asm push ar7 mov r7,#70 DELAY_1ms: nop nop nop nop nop nop nop nop nop nop nop 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 L @11 .0592MHz ** // ************************************************ **************** // 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 Mul tiplexado

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

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 displ ay 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

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 RETI ; *** Vetor do Timer 0 **************************** ************************* ; ** ** ; ************************************************* ***** Endereco: 000BH *** ; ORG 000BH RETI ; *** Vetor da INT1 ******************************* ************************* ; ** ** ; ************************************************* ***** Endereco: 0013H *** ; ORG 0013H RETI ; *** Vetor do Timer 1 **************************** ************************* ; ** ** ; ************************************************* ***** Endereco: 001BH *** ; ORG 001BH RETI ; *** Vetor da Porta Serial *********************** ************************* ; ** ** ; ************************************************* ***** Endereco: 0023H *** ; ORG 0023H RETI ; *** PROGRAMA PRINCIPAL ************************** ************************* ; ** ** ; ************************************************* ************************* ; START: MOV DPTR,#TABELA ; DPTR apon ta para a tabela de 7seg MOV R7,#0 ; R7 é o co ntador de 0 à 99... 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 C ontador... MOV B,#10 DIV AB ; Separa A = Dezena, B = Unidade MOVC A,@A+DPTR ; Liga dígi to da dezena por 10ms MOV P1,A SETB ANODO_D LCALL DELAY10ms CLR ANODO_D MOV A,B ; Liga dígi to da unidade por 10ms

MOVC A,@A+DPTR MOV P1,A SETB ANODO_U LCALL DELAY10ms CLR ANODO_U DJNZ R6,LOOP_VAR ; Repete po r 50x ; 50x(10ms+ 10ms) = 1s --> Delay da varredura INC R7 ; Increment a 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 - P 1.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 um a biblioteca // denominada de delay.lib // void main(void)

{ 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]; // Separa a dezena... anodod = 1; // e liga d isplay dezena delay(10); anodod = 0; display = Tabela[contador%10]; // Seapara a Unidade anodou = 1; // e liga d isplay unidade delay(10); anodou = 0; } if(++contador == 100) contador = 0; } }

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 displ ay 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.

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

; ** ** ; ************************************************* ***** Endereco: 0000H *** ; ORG 0000H LJMP START ; *** Vetor da INT0 ******************************* ************************* ; ** ** ; ************************************************* ***** Endereco: 0003H *** ; ORG 0003H RETI ; *** Vetor do Timer 0 **************************** ************************* ; ** ** ; ************************************************* ***** Endereco: 000BH *** ; ORG 000BH RETI ; *** Vetor da INT1 ******************************* ************************* ; ** ** ; ************************************************* ***** Endereco: 0013H *** ; ORG 0013H RETI ; *** Vetor do Timer 1 **************************** ************************* ; ** ** ; ************************************************* ***** Endereco: 001BH *** ; ORG 001BH RETI ; *** Vetor da Porta Serial *********************** ************************* ; ** ** ; ************************************************* ***** Endereco: 0023H *** ; ORG 0023H RETI ; *** PROGRAMA PRINCIPAL ************************** ************************* ; ** ** ; ************************************************* ************************* ; START: MOV DPTR,#TABELA ; DPTR apon ta para a tabela de 7seg MOV MILHAR,#0 MOV CENTENA,#0 MOV DEZENA,#0 MOV 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 C ontador do milhar... MOVC A,@A+DPTR ; Liga dígi to do milhar por 5ms MOV P1,A SETB ANODO_M LCALL DELAY5ms CLR ANODO_M MOV A,CENTENA ; Carrega C ontador da centena...

MOVC A,@A+DPTR ; Liga dígi to da centena por 5ms MOV P1,A SETB ANODO_C LCALL DELAY5ms CLR ANODO_C MOV A,DEZENA ; Carrega C ontador da dezena... MOVC A,@A+DPTR ; Liga dígi to da dezena por 5ms MOV P1,A SETB ANODO_D LCALL DELAY5ms CLR ANODO_D MOV A,UNIDADE ; Carrega C ontador da unidade... MOVC A,@A+DPTR ; Liga dígi to da unidade por 5ms MOV P1,A SETB ANODO_U LCALL DELAY5ms CLR ANODO_U DJNZ R6,LOOP_VAR ; Repete po r 5x ; 50x(5ms+5 ms+5ms+5ms)=100ms-->Delay da varredura MOV A,#10 INC UNIDADE ; I ncrementa unidade... CJNE A,UNIDADE,REPETE ; u nidade = 10? MOV UNIDADE,#0 INC DEZENA ; In crementa dezena... CJNE A,DEZENA,REPETE ; de zena = 10? MOV DEZENA,#0 INC CENTENA ; In crementa centena... CJNE A,CENTENA,REPETE ; c entena = 10? MOV CENTENA,#0 INC MILHAR ; In crementa milhar... CJNE A,MILHAR,REPETE ; mi lhar = 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 ...)

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 um a 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) {

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 um a biblioteca // denominada de delay.lib // void main(void) { unsigned char i, unidade, dezena, milhar; unsigned int centena, contador; dig1 = 0;

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 00.00 à 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

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 com o 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

centesimal, de 00.00 à 59.99, com indicação em centésimos de segundo. Neste exemplo, faça uso do ponto decimal para separa os segundos dos ce nté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

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

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