Micro Control Adores

MICROCONTROLADORES -

8051 EM LINGUAGEM C Rafael Oliveira do Prado Técnico em Eletrônica

[email protected]

1

www.mecatronicadegaragem.blogspot.com.br

INTRODUÇÃO

Esta apresentação tem como objetivo introduzir alguns conceitos fundamentais sobre microcontrolares de maneira prática e de fácil compreensão para iniciantes. O microcontrolador utilizado é da família 8051 e a linguagem de programação é a linguagem C;

Além de abordar teoricamente as principais características do 8051, são descritos passo a passo como programá-lo, exemplos de circuitos, programas comentados e exercícios propostos;

Não são abordados desenhos de placa de circuito impresso nem métodos ou circuitos de programação do 8051. Para tanto procure na folha de dados do fabricante, livros ou internet;

Como pré-requisitos, são recomendados conhecimentos prévios de programação em linguagem C e eletrônica digital. 2


TEMAS ABORDADOS

Sistemas Embarcados

Definição;

Aplicações. Microcontroladores

História; Microprocessador; Microcontrolador; Microprocessador vs Microcontrolador; Microcontroladores mais Usados.

8051

Descrição; Pinagem; Descrição dos Pinos; Linguagem C vs Linguagem Assembly; Memória Externa no 8051; Memória no 8051;

3

AT89S52; Descrição do AT89S52; Memória de Programa no AT89S52; Memória de Dados no AT89S52; Keil; Leitura de Botão; Display LCD Interface 4 Bits; Teclado Matricial 4x4; Interrupções; Prioridade das Interrupções; Interrupções Externas; Temporizadores/Contadores; Comunicação Serial.


SISTEMAS EMBARCADOS

“Um sistema embarcado é a combinação de hardware e

software, e ocasionalmente elementos mecânicos ou de

outra natureza, projetados para desempenhar uma

função específica.”

Programming Embedded Systems in C and C++, Michael Barr,

1999.

4


SISTEMAS EMBARCADOS

É um sistema no qual o computador é completamente encapsulado e dedicado ao dispositivo ou sistema que controla, diferente dos computadores de uso geral como o PC;

Já que o sistema é dedicado a tarefas específicas, pode-se otimizar o projeto reduzindo tamanho, recursos computacionais e custo do produto.

5


SISTEMAS EMBARCADOS

Geralmente é baseado em Microcontroladores, no entanto existem sistemas embarcados baseados em outras tecnologias:

Dispositivos Lógico Programáveis (PLDs); FPGAs (Field-Programmable Gate Array); Processadores Digitais de Sinais (DSPs).

6


APLICAÇÕES

A aplicação para sistemas embarcados é imensa e pode ser observada em diversas áreas: Equipamentos Médicos; Automação Industrial; Automação Residencial; Automobilística; Aviônica; Televisão, Videogame; Periféricos para computador; Eletrodomésticos; Celular, iPad, iPod; Etc... 7


HISTÓRIA DO MICROCONTROLADOR

Em 1969, a INTEL encomenda circuitos integrados (CIs) japoneses para a produção de calculadoras;

Neste período, Marcian Hoff, funcionário da própria INTEL apresentou uma solução diferente: Que a função do CI fosse determinada por um programa nele armazenado;

8



Em 1971 um funcionário da INTEL chamado Frederico Faggin transformou a ideia de Hoff num produto real e assim, o primeiro microprocessador nasceu;

Com o passar dos anos, o avanço da tecnologia proporcionou a criação de microprocessadores mais rápidos e inteligentes;

Aliados a memórias RAM e ROM, disco rígido, dispositivos de entrada (teclado, mouse...) e saída (monitor, impressora..), o microprocessador é a parte central de troca de informações entre dispositivos.

9



Logo que os microprocessadores foram popularizados, a indústria percebeu que tais componentes poderiam ser aplicados na automação de processos;

Para viabilizar tal propósito, os microprocessadores foram reprojetados e os periféricos de entrada e saída foram integrados todos num único CI.

10



Esse CI, integrando periféricos em sua arquitetura, era na verdade, um sistema mais completo que um microprocessador;

Ele poderia processar dados e controlar dispositivos externos sem a necessidade de periféricos externos;

Foi este, então, batizado de microcontrolador.

11


MICROPROCESSADOR

Possui apenas CPU. Os periféricos são externos: Placa Mãe; Disco Rígido Memória RAM; Placa de Vídeo; Monitor; Teclado; Mouse; Etc...

12


MICROCONTROLADOR

Possui CPU + memória + periféricos (variam de acordo com o modelo) em um único circuito integrado: Memória (RAM, ROM, Flash); Oscilador interno; Comunicação serial, USB, 1wire, etc...; Conversor Analógico-Digital; Conversor Digital-Analógico; Comparador analógico; Modulador por largura de pulso (PWM); Etc... 13


MICROPROCESSADOR VS MICROCONTROLADOR

A principal diferença é que para um sistema microprocessado

funcionar são necessários elementos externos (memória, placa mãe e componentes para enviar e receber dados) enquanto que para um sistema microcontrolado, basta o microcontrolador.

14


MICROCONTROLADORES MAIS USADOS

Intel família 8051; PIC; Microcontroladores ATMEL; Microcontroladores COP; Microcontroladores FREESCALE (MOTOROLA).

15


8051

O microcontrolador escolhido é um microcontrolador da família 8051, porque além de já ter sido a arquitetura mais utilizada por profissionais e hobbistas (ainda é muito utilizado), o 8051 básico possui recursos mais simples, facilitando o aprendizado para iniciantes;

Uma vez que se entenda as funcionalidades e métodos de desenvolvimento com dispositivos dessa família, não será difícil migrar para outros tipos de microcontroladores.

16


DESCRIÇÃO

Algumas das características mais importantes do 8051 são:

32 pinos de Entrada/Saída programáveis; 2 Pinos de interrupção externa; 2 Temporizadores/Contadores de 16 bits; Comunicação Serial.

17


PINAGEM

18


DESCRIÇÃO DOS PINOS

Além de E/S, os pinos das portas 1, 2, 3, 4 podem assumir outras funções. Port 0 e Port 2:

Quando utilizado um sistema com memória externa de 16 bits, a PORT0 opera como barramento de dados multiplexado da parte menos significativa da palavra binária, enquanto a PORT2 fornece a parte mais significativa.

A Port 0 não possui resistores de pull-up internos. Para obter nível lógico 1 é preciso conectar em cada pino resistores de 4k7 em relação ao +VCC. Esta é a única porta que pode ter +VCC diferente de 5V.

19



Port 1:

Pino Funções

P1.5 MOSI - usado para gravação in-System (ISP) P1.6 MISO - usado para gravação in-System (ISP) P1.7 SCK - usado para gravação in-System (ISP)

20



Pino Funções

P3.0 RXD - pino de entrada serial P3.1 TXD - pino de saída serial P3.2 - interrupção externa 0 P3.3 - interrupção externa 1 P3.4 T0 - entrada externa do TIMER0 P3.5 T1 - entrada externa do TIMER1 P3.6 - pulso para escrita em memória externa P3.7 - pulso para leitura em memória externa

1

0

INT

INT

RD

WR

Port 3:

21



RST:

Nível alto nesse pino por dois ciclos de máquina enquanto o oscilador estiver funcionando, reinicia o sistema;

Ao energizar o sistema é importante que seja resetado para o programa começar a ser executado desde o endereço 00H. É interessante haver um botão para reset manual também. 22



ALE/ :

Adress Latch Enable (ALE) é um pulso para travar (latch) a parte baixa do endereço durante o acesso à memória externa. É também o pino de entrada do pulso de programação (PROG) durante a operação de gravação da memória Flash interna.

Em operação normal, sem uso da memória externa, esse pino é pulsado em uma frequência de 1/6 do oscilador interno e pode ser usado como clock externo;

PROG

23



PSEN:

Program Store Enable é o pulso de habilitação para leitura de memória de programa externa;

EA/VPP:

External Acess Enable (EA). Habilitação de memória de programa externa. Deve ser conectado ao GND quando uso de programas em memória externa e em VCC quando for utilizada a Flash interna;

24



XTAL1, XTAL2:

Pinos de entrada para configuração do circuito de clock. A frequência do sistema será igual a frequência do cristal.

25


LINGUAGEM ASSEMBLY VS LINGUAGEM C

Vantagens:

Maior controle sobre hardware;

Economia de memória de programa;

Tempo de execução de programa menor.

Desvantagens:

Conjunto de mnmônicos extenso, tornando a tarefa de programar e interpretar programas enfadonha;

Portabilidade reduzida, pois o Assembly de uma máquina é diferente de outra.

Assembly C

Vantagens:

Portabilidade elevada;

Poucos comandos são necessários para obter resultado;

Facilidade para realizar cálculos complexos.

Desvantagem:

Código gerado maior, consequentemente, maior ocupação de memória e maior tempo de execução do programa.

26



Programa escrito em C:

#include <reg51.h> // Biblioteca padrão de nomes dos RSFs do 8051 sbit LED = P0^0; // Define LED como o pino 0 da P0 sbit BOTAO = P0^1; // Define BOTAO como o pino 1 da P0 main() { int i; while(1) { if(!BOTAO) // Aguarda o botao ser pressionado { while(!BOTAO); // Espera soltar for(i=0; i<900; i++) ; // Delay de aproximadamente 50ms (cristal // 11,0592MHz) para tratar efeito bounce

LED = !LED; // Apaga/acende o LED } } }

27



Programa em C após compilação:

C:0x0000 020818 LJMP C:0818 C:0x0003 00 NOP C:0x0004 00 NOP . . . C:0x0800 2091FD JB 0x90.1,C:0800 C:0x0803 3091FD JNB 0x90.1,C:0803 C:0x0806 E4 CLR A

C:0x0807 FF MOV R7,A

C:0x0808 FE MOV R6,A

C:0x0809 0F INC R7

C:0x080A BF0001 CJNE R7,#0x00,C:080E C:0x080D 0E INC R6

C:0x080E BE03F8 CJNE R6,#0x03,C:0809

C:0x0811 BF84F5 CJNE R7,0x84,C:0809

C:0x0814 B290 CPL 0x90.0 C:0x0816 80E8 SJMP C:0800 C:0x0818 787F MOV R0,#0x7F C:0x081A E4 CLR A

C:0x081B F6 MOV @R0,A

C:0x081C D8FD DJNZ R0,C:081B C:0x081E 758107 MOV 0x81,#0x07 C:0x0821 020800 LJMP C:0800

Memória ocupada: 39 bytes

28



Programa com a mesma função escrito em Assembly:

LED equ P0.0 ; Define LED como o pino 0 da P0 BOTAO equ P0.1 ; Define BOTAO como o pino 1 da P0 ORG 0 ; Inicia escrita do programa no endereço 0 da memória aguardaBotao: JNB BOTAO, $ ; Testa se o botao foi pressionado JB BOTAO, $ ; Testa se o botao foi solto MOV R1, #60H ; Carrega R1 com o valor 60 em hexadecimal delay: ; Delay de aproximadamente 50ms (cristal 11,0592MHz) para DJNZ R0, $ ; tratar efeito bounce. Decrementa R0 e não prossegue DJNZ R1, delay ; enquanto R0 for diferente de 0. Decrementa R1 e volta para ; delay enquanto R1 for diferente de 0

CPL LED ; Apaga/acende LED SJMP aguardaBotao ; Retorna para aguardaBotao END ; Fim

29



Programa em Assembly após compilação:

C:0x0000 2081FD JB 0x80.1,C:0000 C:0x0003 3081FD JNB 0x80.1,C:0003 C:0x0006 7960 MOV R1,#0x60 C:0x0008 D8FE DJNZ R0,C:0008 C:0x000A D9FC DJNZ R1,C:0008 C:0x000C B280 CPL 0x80.0 C:0x000E 80F0 SJMP C:0000

Memória ocupada: 16 bytes

30

Um simples programa em C ocupa 23 bytes de memória a mais que o mesmo programa escrito em assembly.


MEMÓRIA EXTERNA NO 8051

Alguns dispositivos da família 8051 não possuem memória de programa interna, sendo necessário o uso de memória externa;

Para os que possuem, em determinadas aplicações a memória interna é insuficiente;

Nesses casos são utilizados circuitos de memória externa.

31


MEMÓRIA NO 8051

Atualmente grande parte dos microcontroladores possuem memória interna suficiente para a maioria das aplicações;

As aplicações aqui descritas não requisitam o recurso de memória externa, por isso tais circuitos e programação não serão abordados.

32


AT89S52

O microcontrolador utilizado será o AT89S52. Ele é essencialmente parecido com o 8051 clássico, possuindo um temporizador/contador a mais;

Atualmente existem diversos dispositivos da família 8051 com periféricos e recursos extras, além dos disponíveis nas primeiras versões;

A seguir a memória e registradores de funções especiais do AT89S52 serão brevemente descritos, no entanto, esta apresentação se limitará apenas aos recursos do 8051 tradicional.

33


DESCRIÇÃO DO AT89S52

8 Kbytes de memória de programa on-chip (Flash); 256 bytes de RAM de dados; 32 pinos de Entrada/Saída programáveis; Modo de programação serial ISP (In-System Programmable) 3 Temporizadores/Contadores de 16 bits; Comunicação Serial; Watch Dog Timer programável; Estruturas de interrupção com dois níveis de prioridade; Oscilador de clock on-chip;

Operação de 0Hz a 33MHz; Proteção contra cópias (lock bit); Alimentação de 4 a 5,5V. 34


MEMÓRIA DE PROGRAMA NO AT89S52

O AT89S52 possui 8 Kbytes de memória de programa on-

chip (Flash). O programa é executado a partir do endereço 0000H. Os primeiros endereços são reservados para rotinas de interrupção.

35


MEMÓRIA INTERNA DE DADOS NO AT89S52

36

O AT89S52 possui 256 bytes de RAM de dados (espaço para variáveis de programa);

Os primeiros 128 bytes são para uso geral;

Os 128 bytes restantes são reservados para funções específicas.



Bancos de registradores:

“Pacotes” de registradores que recebem os nomes R0, R1...R7. Para selecionar qual banco utilizar utiliza-se um dos registradores de funções especiais chamado PSW;

Bit e byte endereçável: 128 bits que podem ser acessados individualmente

37



A vantagem de utilizar as regiões Banco de Registradores e Bit e Byte Endereçáveis ao invés da região de Apenas

Bytes Endereçáveis está no tamanho e velocidade de execução da instrução.;

Como na programação C já é previsto o uso de memória e velocidade de execução elevados, deixamos que o compilador se preocupe com isso.

38



Registradores de Funções Especiais (RFE):

São registradores reservados na memória para operações

específicas. Não deve-se utilizá-los para uso geral;

Para programar microcontroladores, é preciso conhecer os RFE do referido circuito integrado pelo menos de maneira superficial, para poder utilizá-los quando necessário.

A função da maioria dos RFE do 8051 serão estudadas no decorrer desta apresentação. O mapa da memória interna dos RFE do AT89S52 é exibido no slide a seguir.

39


REGISTRADORES DE FUNÇÕES ESPECIAIS (RSF)

NO AT89S52

40


KEIL

Antes de iniciar o estudo de programação, é recomendável conhecer algum programa de desenvolvimento e depuração de programas para o 8051;

Vários códigos serão exibidos e explicados, por isso é importante testá-los para melhor compreensão.

41


KEIL

Segue abaixo o link para um tutorial de introdução ao Keil, um programa onde é possível escrever, depurar e simular códigos para diversos dispositivos da família 8051. Créditos - Gilson Yukio Sato:

Tutorial Keil uVision 4

Utilize o código fonte do próximo slide para seguir

instruções do tutorial.

42


http://pessoal.utfpr.edu.br/sato/arquivos/gs_1004_tutorial_uvision4_v0.pdf






KEIL

#include <reg51.h> //Biblioteca de nomes dos bits/bytes dos RFE do 8051 sbit pino_led = P1^0; // Define o pino P1.0 como pino_led void troca_estado_led(void) { // Funcao para inverter estado do led pino_led = !pino_led; } void atraso_ms(int i) { // TC0 configurado para uma temporizacao for(i; i > 0; i--){ // de aproximadamente 1ms * i (cristal de 11,0592MHz) TMOD = (TMOD & 0xF0) | 0x01; TH0 = 0xFC; TL0 = 0x66; TR0 = 1; while(!TF0); TR0 = 0; TF0 = 0; } } main() { while(1) { troca_estado_led(); atraso_ms(1000); }; }

43


LEITURA DE BOTÃO E ACIONAMENTO DE LED

O primeiro programa microcontrolado é o simples e clássico acionamento de um LED através da leitura de um botão. A cada vez que o botão for pressionado o LED inverte seu estado. Se continuar pressionado o estado do LED continuará sendo invertido de acordo com a taxa de repetição do botão;

Na prática botões apresentam o chamado efeito bounce

(assim como todos os outros componentes eletromecânicos), que é a sucessiva troca de estado lógico até atingir o estado final. Ocorre ao pressionar ou soltar o botão e dura de 10 a 50ms de acordo com a qualidade do componente;

Para tratar o efeito bounce pode ser inserido no código um atraso depois que o botão for pressionado. Este atraso além de tratar o efeito bounce, determina a taxa de repetição do botão.

44



45



Para ler um botão e inverter o estado de um LED é preciso

seguir a seguinte sequência de passos:

1. Testar se o botão foi pressionado;

2. Chamar uma rotina de atraso cujo período determina a taxa de

repetição do botão;

3. Inverter o estado do LED

46


#include <reg51.h> // Biblioteca padrão de nomes dos RSFs do 8051 sbit LED = P0^0; // Define LED como o pino 0 da P0 sbit BOTAO = P0^1; // Define BOTAO como o pino 1 da P0 void atraso_ms(int i) { // TC0 configurado para uma temporizacao de

for(i; i > 0; i--) { // aproximadamente 1ms * i (cristal de 11,0592MHz)

TMOD=(TMOD & 0xF0) | 0x01; TH0=0xFC; TL0=0x66; TR0=1; while(!TF0); TR0=0; TF0=0; } // Nao se preocupe em entender esta funcao agora. Os

} // temporizadores/contadores serao discutidos mais adiante main() { while(1) { if(!BOTAO); // Aguarda o botao ser pressionado atraso_ms(500); // Trata efeito bounce e determina taxa de repeticao do botao LED = !LED; // Apaga/acende o LED } }

47

Leitura de botão e acionamento de LED


DISPLAY LCD INTERFACE 4 BITS

Os módulos LCDs são interfaces de saída muito úteis em sistemas microcontrolados. Estes módulos podem ser gráficos ou a caractere. Os LCDs a caractere são especificados em número de colunas por linhas, sendo os mais usuais 16x2, 16x1, 20x2, 20x4, 8x2;

Os módulos podem ser encontrados com backlight (LEDs para iluminação de fundo), facilitando a leituras em ambientes escuros. Os LCDs mais comuns empregam o controlador HD44780 com interface paralela, todavia, existem LCDs com controle serial e a gama de LCDs aumenta constantemente.

48



A seguir iremos trabalhar com o LCD de 16 caracteres por 2 linhas. O uso de qualquer outro baseado no controlador HD44780 é similar, variando apenas o número de linhas e colunas;

A interface pode ser de 4 ou 8 bits. O mais usual é 4 bits por usar menos pinos. A diferença é que para mandar instruções ou caracteres ao módulo, deve-se enviar primeiro os 4 MSBs e depois os 4 LSBs. Por definição o módulo inicia em 8 bits, então para utilizar interface de 4 bits o primeiro comando deve ser para alterar a interface.

49



50



51

Instruções mais usuais



52

Detalhamento das instruções



53



Para ler ou escrever comandos no display LCD (4 bits) é

preciso seguir a seguinte sequência de passos:

1. Levar o pino R/W (Read/Write) a 0 para escrita, 1 para leitura. Aterra-se

o pino se não há necessidade de monitorar a resposta do LCD;

2. Escrever os dados nos pinos correspondentes a via de dados do LCD;

3. Levar o pino RS (Register Select) para 0 ou 1 (instrução ou caractere);

4. Levar o pino E (Enable) a 1 e em seguida a 0 para transferir os dados.

5. Aguardar o tempo necessário para transferir os dados e o módulo executar o comando. 2ms são suficientes;

6. Repetir os passos anteriores com os 4 LSBs (desloca-se a variável responsável pelo armazenamento dos dados 4 vezes para a esquerda.

54



Como o display LCD inicia em 8 bits mas apenas 4 bits estão conectados, é preciso enviar a primeira instrução de modo de utilização 2 vezes. Na primeira vez são enviados apenas os 4 bits que informam que será utilizada interface de 4 bits;

A partir do segundo comando, quando o módulo LCD já está operando em 4 bits, envia-se primeiro os 4 MSBs e depois os 4 LSBs. Envia-se então o comando de modo de utilização novamente;

As intruções de modo de utilização e configuração do cursor devem estar na rotina de configuração do módulo, e ser usada antes de começar a operar o display normalmente;

Quando o LCD é energizado, é executada a rotina de inicialização interna do display, por isso é preciso adicionar um atraso na nossa rotina de configuração do LCD, para garantir que o módulo não esteja ocupado no momento em que começa a receber comandos do microcontrolador. 10ms são suficientes. 55


#include <reg51.h> // Biblioteca de nomes dos bits/bytes dos RFE do 8051 #define DADOS_LCD P1 // Define DADOS_LCD como P1 sbit RS = P1^2; // Pino de instrucao ou caractere do LCD. sbit E = P1^3; // Pino de enable do LCD unsigned char i = 1; // Variavel usada para enviar comandos ao LCD. Inicia // em 1 porque a interface inicia como 8 bits void atraso_ms(int i) { // TC0 configurado para uma temporizacao de



} // temporizadores/contadores serao discutidos mais adiante

void cmd_LCD(unsigned char dado, char tipo) { // Funcao p/ enviar comandos ao LCD DADOS_LCD = dado; // Envia 4 MSBs for(; i != 0; i--) { if (tipo == 0) RS = 0; else RS = 1; // Seleciona instrucao ou caractere E = 1; E = 0; // Transfere dados atraso_ms(2); // Aguarda tempo de execucao dos comandos DADOS_LCD = dado << 4; // Envia os 4 LSBs } i = 2; // Na primeira vez que a funcao for executada sera enviado apenas os } // 4 MSBs. A partir da segunda serao enviados primeiro os 4 MSBs e // depois os 4 LSBs

56

Acionamento de display LCD interface 4 bits

// CONTINUA...


void config_LCD() { // Funcao de configuracao do LCD atraso_ms(10); // Aguarda execucao de inicializacao interna do display cmd_LCD(0x28,0); // Chaveia para modo 4 bits cmd_LCD(0x28,0); // Envia instrucao de modo de utilizacao cmd_LCD(0x0D,0); // Cursor piscante cmd_LCD(0x01,0); // Limpa o display cmd_LCD(0x80,0); // Escreve na primeira linha a esquerda }

void escreve_LCD(char *c) { // Funcao p/ escrever strings no LCD for(; *c != ‘\0’; c++) cmd_LCD(*c,1); } main() { config_LCD(); escreve_LCD(‘’Interface de”); cmd_LCD(0xC0,0); // Escreve na segunda linha a esquerda escreve_LCD(“dados de 4 bits”); while(1); }

57

Acionamento de display LCD interface 4 bits


TECLADO MATRICIAL 4X4

Uma forma muito comum de entrada de dados em um sistema microcontrolado é através de teclas (botões). Quando o número delas é pequeno, cada uma pode ser associada a um pino de entrada do microcontrolador.

Entretanto, quando o número de teclas se torna grande não é recomendado desperdiçar pinos de entrada. Utilizando um teclado matricial de 4x4 teclas, ao invés de se empregar 16 pinos para leitura das referidas teclas, emprega-se 8 pinos.

58



Os botões são arranjados em matriz (colunas e linhas), e o teclado é lido por varredura através de um CI decodificador ou um microcontrolador. O pressionar de uma tecla produzirá um curto entre uma coluna e uma linha e o sinal da coluna se refletirá na linha (ou vice-versa).

A ideia é trocar sucessivamente o nível lógico das colunas e verificar se esse nível lógico aparece nas linhas (ou vice-versa). Se por exemplo houver alteração no nível lógico de alguma linha significa que alguma tecla foi pressionada e, então, com base na coluna habilitada e na linha, se sabe qual tecla foi pressionada.

59



60



Para realizar a varredura de um teclado matricial, os bits (linhas

e colunas) devem iniciar em 1, e deve-se seguir a seguinte

sequência de passos:

1. Levar o nível lógico da primeira coluna a 0;

2. Aguardar um tempo não muito pequeno para evitar leitura de

ruídos e nem muito grande a ponto de não detectar o pressionar de uma tecla. 50ms são suficientes;

3. Testar cada linha em relação a essa coluna. Caso uma linha esteja em 0, um botão foi pressionado e deve-se retornar o valor referente ao botão dessa linha e coluna específicas;

4. Levar essa coluna a nível lógico 1 novamente;

5. Repetir os passos anteriores para cada uma das colunas restantes.

61


#include <reg51.h> // Biblioteca de nomes dos bits/bytes dos RFE do 8051 #define DADOS_LCD P1 // Define DADOS_LCD como P1 #define setBit(adress,bit) (adress|=(1<<bit)) // Seta bit do endereco selecionado #define clrBit(adress,bit) (adress&=~(1<<bit)) // Zera bit do endereco selecionado #define tstBit(adress,bit) (adress&(1<<bit)) // Testa bit do endereco selecionado

unsigned char teclado[4][4] = {{0x01, 0x02, 0x03, 0x0F}, // De acordo com o botao {0x04, 0x05, 0x06, 0x0E}, // pressionado sera enviado o {0x07, 0x08, 0x09, 0x0D}, // elemento correspondente {0x0A, 0x00, 0x0B, 0x0C}}; // da matriz

void atraso_ms(int i) { // TC0 configurado para uma temporizacao de



} // temporizadores/contadores serao discutidos mais adiante 62

Varredura de Teclado Matricial 4x4

// CONTINUA...


unsigned char lerTeclado() { unsigned char n, j, valor, linha; for(n=0; n<4; n++) { // Alterna as colunas clrBit(P2,n); // Zera bit da coluna para testar as linhas que estao em 1. // Caso um botao seja pressionado a linha tambem valera 0 atraso_ms(50); // Atraso para varredura mais lenta e trata efeito bounce linha = P2 >> 4; // Elimina informação sobre as colunas for(j=0; j<4; j++) if(!tstBit(linha,j)) valor = teclado[j][n]; // Testa cada linha j em // relacao a coluna n. Se um botao for pressionado, retorna o valor correspondente setBit(P2,n); // Seta o bit da coluna zerado anteriormente } return tecla; // Retorna botao pressionado } main() { unsigned char tecla; P2 = 0xFF; // Por padrao todas as E/S's ja iniciam em 1 while(1) { n = lerTeclado(); P0 = tecla; // Escreve na P0 o valor do botao pressionado } }

63

Varredura de Teclado Matricial 4x4


EXERCÍCIO PROPOSTO

Faça o programa que escreva no display LCD o caractere correspondente ao botão que for pressionado. O programa deve ter as seguintes restrições: Os caracteres devem aparecer um após o outro; Quando terminar a primeira linha os caracteres devem ser

escritos na linha de baixo; Quando terminar as duas linhas o display deve ser limpo e a

escrita iniciar da primeira posição da primeira linha.

64


INTERRUPÇÕES

São eventos internos ou externos que provocam a interrupção do fluxo normal do programa e o desvia para um endereço específico da memória, para atender o evento que gerou a interrupção;

As interrupções permitem que o processador foque em sua atividade principal sem precisar travar o programa em uma temporização ou verificar constantemente periféricos e outras fontes de interrupção;

O programa principal torna-se mais simples e eficiente.

65


INTERRUPÇÕES

Programa sem uso de interrupções

Programa com uso de interrupções

66


INTERRUPÇÕES

O 8051 provê 5 fontes de interrupção + reset (endereço 00H).

67


INTERRUPÇÕES

Para utilizar interrupções, é preciso habilitá-las. O RFE responsável por esta função é o IE (Interrupt Enable).

Para habilitar o uso das interrupções, deve-se setar EA

(Enable All). Esse bit apenas permite o uso das interrupções, para efetivamente habilitar uma interrupção deve-se setar o bit correspondente.

ES: Enable Serial;

ETi: Enable Timer i;

EXi: Enable External i; 68


INTERRUPÇÕES

Na programação em Assembly alguns cuidados são

necessários:

Desviar para um endereço de memória que não será utilizado, caso a rotina de interrupção seja maior que 8 bytes;

Salvar na pilha conteúdo de registradores utilizados na rotina de interrupção (A, B, R0, R1...);

Retornar da interrupção.

Em programação C, o compilador se encarrega desses

cuidados.

69


INTERRUPÇÕES

Para utilizar interrupções em linguagem C deve-se:

1. Habilitar as interrupções desejadas através do RFE IE;

2. Configurar as fontes de interrupção desejadas tais como temporizadores, interrupções externas e comunicação serial;

3. Escrever a rotina de interrupção de acordo com a sintaxe exibida no slide a seguir.

70


INTERRUPÇÕES

void nome_interrupção(void) interrupt número_interrupção

{ // rotina aqui }

nome_interrupção pode ser qualquer nome definido pelo programador;

número_interrupção é o número da interrupção de acordo com a tabela abaixo.

Interrupções não aceitam passagem nem retorno de variáveis. Para usar uma variável na rotina de interrupção, ela deve ser global.

71


PRIORIDADE DAS INTERRUPÇÕES

Ocasionalmente podem ocorrer mais de uma solicitação de interrupção ao mesmo tempo;

Por padrão o 8051 adota como prioridade a sequência:

EX0>ET0>EX1>ET1>ES

No entanto, é possível dar máxima prioridade a uma ou mais fontes de interrupção. O registrador responsável por esta função é o RFE IP.

72



Para dar alta prioridade a uma fonte de interrupção deve-se setar o bit correspondente.

PS: Priority Serial;

PTi: Priority Timer i;

PXi: Priority External i;

73



Nada pode interromper uma interrupção de alta prioridade, nem mesmo outra interrupção de alta prioridade;

Uma interrupção de alta prioridade pode interromper uma interrupção de baixa prioridade, e quando terminar sua rotina, volta para o ponto em que parou na interrupção de baixa prioridade;

Se duas interrupções ocorrerem ao mesmo tempo, a de maior prioridade é atendida primeiro. Se forem de igual prioridade, é seguida a ordem padrão do 8051.

74



#include <reg51.h> // Biblioteca de nomes dos bits/bytes dos RFE do 8051 main() { EA = 1; // Habilita uso de interrupcoes EX0 = 1; // Habilita a interrupcao externa 0 ES = 1; // Habilita interrupcao da comunicacao serial PS = 1; // Configura interrupção da serial como alta prioridade // Caso ocorra ao mesmo tempo que a interrupcao externa 0, a // interrupcao da serial sera atendida primeiro // Caso ocorra enquanto atende a rotina da interrupcao externa 0, // interrompe a rotina da interrupcao externa 0 e vai para a rotina // da serial. Quando terminar volta para a rotina da interrupcao // externa 0 . . . }

75

Habilitação das interrupções externa 0 e serial. A serial é

configurada como alta prioridade.


INTERRUPÇÕES EXTERNAS

Os pinos INT0 e INT1 podem ser utilizados com função de pedido de interrupção por dispositivos externos;

Além de adequadamente habilitada no registrador IE, uma interrupção externa deve ser configurada para disparo por nível ou por transição de nível;

Esta é a função dos bits IT0 e IT1 do RFE TCON.

76



ITi (Bit de controle do tipo de interrupção): -1 configura a interrupção externa para ser disparada por

transição de nível 1 para 0; -0 configura a interrupção para ser disparada por nível 0.

IEi (Flag de transição da interrupção): Em interrupção por nível, são setadas quando o pino INTi é

1 e resetadas quando INTi é 0. Por transição, são setadas a cada pedido de interrupção e resetadas automaticamente na rotina de interrupção. Com interrupção desabilitada podem ser testadas via software, e precisam ser resetadas no programa no caso de interrupção por transição.

77



78



Para utilizar interrupções externas em linguagem C deve-se:

1. Habilitar o uso de interrupções (bit EA);

2. Habilitar as interrupções desejadas (bits EX0 e/ou EX1) e prioridade (bit IP);

3. Configurar disparo por nível (bit ITi = 0) ou por transição (bit ITi = 1);

4. Escrever a rotina de interrupção de acordo com o slide 71.

79


#include <reg51.h> // Biblioteca de nomes dos bits/bytes dos RFE do 8051 sbit BOTAO = P3^2; // Define o pino P3.2 como BOTAO void intExterna0() interrupt 0 // Rotina da interrupcao externa 0 { P1++; // Incrementa uma contagem binaria na P1 enquanto } // o botao estiver pressionado main() { EA = 1; // Habilita uso de interrupcoes EX0 = 1; // Habilita a interrupcao externa 0 IT0 = 0; // Configura disparo por nivel while(1); // Aguarda interrupcoes }

Interrupção externa 0 por nível

80


#include <reg51.h> // Biblioteca de nomes dos bits/bytes dos RFE do 8051 sbit BOTAO = P3^2; // Define o pino P3.2 como BOTAO void intExterna0() interrupt 0 // Rotina da interrupcao externa 0 { P1++; // Incrementa uma contagem binaria na P1 cada vez } // que o botao for pressionado main() { EA = 1; // Habilita uso de interrupcoes EX0 = 1; // Habilita a interrupcao externa 0 IT0 = 1; // Configura disparo por transicao while(1); // Aguarda interrupcoes }

Interrupção externa 0 por transição

81


#include <reg51.h> // Biblioteca de nomes dos bits/bytes dos RFE do 8051 sbit BOTAO = P3^2; // Define o pino P3.2 como BOTAO main() { EA = 0; // Desabilita uso de interrupcoes (por padrao esse bit ja e // inicializado em 0) IT0 = 1; // Configura disparo por transicao while(1) { if(IE0) // Testa interrupcao externa 0 (P3.2) { P1++; // Incrementa uma contagem binaria na P1 IE0=0; // Reseta flag } }

Teste da flag de interrupção (por transição) com

interrupções desabilitadas

82


#include <reg51.h> // Biblioteca de nomes dos bits/bytes dos RFE do 8051 sbit BOTAO = P3^2; // Define o pino P3.2 como BOTAO main() { EA = 0; // Desabilita uso de interrupcoes (por padrao esse bit ja e // inicializado em 0) IT0 = 0; // Configura disparo por nível (esse tambem) while(1) { if(IE0) // Testa interrupcao externa 0 (P3.2) { P1++; // Incrementa uma contagem binaria na P1 } // Nesse caso nao e preciso resetar a flag pois // ela ja e resetada quando o pino INT0 for 1 }

Teste da flag de interrupção (por nível) com interrupções

desabilitadas

83


EXERCÍCIO PROPOSTO

A partir do circuito abaixo, faça o programa que determine qual das 8 linhas está solicitando interrupção e escreva esse valor na P1.

84


EXERCÍCIO PROPOSTO

Desenvolva um programa de segurança contra abertura de portas/janelas. O programa deve conter as seguintes funcionalidades: Usar interrupção externa; Monitorar 8 portas/janelas; Acionar um alarme (representado por um LED) quando uma

ou mais portas/janelas forem abertas; As portas/janelas que estão sendo violadas devem ser

escritas em um display LCD; O alarme só deve parar quando uma senha pré-definida de

4 dígitos for escrita através de um teclado matricial 4x4; Caso a senha esteja incorreta, deve aparecer uma

mensagem no display de senha incorreta por 3 segundos e depois retornar para a mensagem de monitoramento das portas/janelas.

85


TEMPORIZADORES/CONTADORES

O 8051 provê dois temporizadores/contadores (T/C), que podem ser individualmente configurados para operação de temporização ou contagem, em diferentes modos;

Um contador pode ser utilizado em operações como contar peças em um processo industrial;

Um temporizador geralmente é utilizado quando é preciso gerar um período preciso de tempo.

86



Operando como contador, um pedido de interrupção é solicitado após o contador atingir um número predeterminado de pulsos negativos;

Como temporizador, o pedido de interrupção é solicitado após ser atingido um período de tempo predeterminado;

Como contador, a contagem é medida diretamente pelos pinos T0 (P3.4) e T1 (P3.5). Como temporizador, o tempo é contado a partir do clock da CPU dividido por 12.

87



Geração da base de tempo primária para os T/C’s do 8051

(modo temporizador)

88



Os RFE responsáveis pela configuração dos T/C’s são o TMOD e o TCON;

TCON

Possui as flags de pedido de interrupção e os bits para ligar/desligar a temporização/contagem;

TMOD

Possui bits de controle de modo de acionamento da temporização/contagem; modo de operação (temporização ou contagem); e modo de temporização/contagem.

Não é endereçável por bit, portanto não é possível configurar os bits individualmente, é preciso configurar todos de uma vez ou utilizar lógica OU/E para configurar os bits desejados.

89



90



91

Gatei Determina o modo de habilitação do T/Ci:

-0: A temporização ocorre enquanto o bit TRi de TCON for 1 -1: A temporização ocorre apenas enquanto o bit TRi de TCON for 1 e o pino INTi também for 1

C/Ti Determina operação de temporização ou contagem:

-0: Modo temporizador -1: Modo contador

M1 e M0 Determinam o modo de temporização/contagem:

M1 M0 Modo de Operação

0 0 13 bits, sendo 8 bits no RFE THi e um prescaler de 5 bits no TLi

0 1 16 bits no par de RFE THi e TLi

1 0 8 bits com recarga automática (contagem em THi e constante de recarga em TLi)

1 1 T/C0: TL0 opera como T/C de 8 bits TH0 opera como temporizador de 8 bits T/C1: Trava a temporização.



92

Funcionamento:

Executa uma contagem crescente nos registradores THi e TLi;

A origem dos pulsos depende do bit C/Ti. Como contador incrementa a contagem a cada borda de descida no pino Ti; como temporizador a contagem é incrementada a cada clock da CPU dividido por 12;

A habilitação da contagem está relacionada ao bit Gatei. Se resetado, o início da contagem ocorre quando o bit TRi for 1. Caso o bit Gatei esteja setado, a contagem somente ocorrerá quando o bit TRi for 1 e enquanto o pino INTi estiver em nível alto.

TRi em 1 inicia a contagem. Se TRi for 0 novamente, a contagem congela no último valor, se 1 mais uma vez, a contagem recomeça do último valor atingido;



93

Gate0 = 0

Gate0 = 1



94

Um pedido de interrupção é solicitado após a contagem atingir um estouro. O modo de contagem depende dos bits M1i e M0i.

M1 M0 Modo de Operação

0 0 Modo 0: 13 bits

0 1 Modo 1: 16 bits

1 0 Modo 2: 8 bits com recarga automática

1 1 Modo 3

T/C0: TL0 opera como T/C de 8 bits TH0 opera como temporizador de 8 bits T/C1: Trava a temporização.



95

Modo 0: 13 bits

A contagem é obtida através de uma contagem crescente de 8 bits (0 a 255) no RFE THi incrementada a cada estouro na pré escala de 5 bits (0 a 31) no RFE TLi. Os 3 bits mais significativos de TLi são irrelevantes.

Lembrando que o sinal que incrementa os T/C é proveniente do clock da CPU ( ) dividido por 12, utiliza-se a seguinte equação para calcular a temporização ‘T’ desejada, onde ‘n’ é o valor inicial no RFE THi:

CPUCLKTnT *12*32*)256(

CPUCLKT



96

Modo 0: 13 bits



97

Modo 1: 16 bits

A contagem é obtida através de uma contagem crescente de 16 bits (0 a 65 535) nos RFE THi e TLi.

Lembrando que o sinal que incrementa os T/C é proveniente do clock da CPU ( ) dividido por 12, utiliza-se a seguinte equação para calcular a temporização ‘T’ desejada, onde ‘n’ é o valor inicial no par de RFE THi.TLi : Obs: lembre-se de converter ‘n’ para hexadecimal e substituir o MSB em THi e o LSB em TLi.

CPUCLKTnT *12*)65536(

CPUCLKT



98

Modo 1: 16 bits



99

Modo 1: 16 bits

Temporização de 50ms utilizando um clock de 11,0592MHz

CPUCLKTnT *12*)65536(

11059200

12*)65536(05,0

11059200

1*12*)65536(05,0

11059200

1

05,0

n

n

T

sT

CPUCLK

)(004

19456

4608065536

6553646080

6553612

11059200*05,0

lhexadecimaCn

n

n

n

n



100

Modo 2: 8 bits com recarga automática

A contagem é obtida através de uma contagem crescente de 8 bits (0 a 255) no RFE TLi, enquanto o RFE THi mantém o valor inicial da contagem que é automaticamente recarregado no TLi a cada fim de contagem, quando o bit TFi é setado.

Lembrando que o sinal que incrementa os T/C é proveniente do clock da CPU ( ) dividido por 12, utiliza-se a seguinte equação para calcular a temporização ‘T’ desejada, onde ‘n’ é o valor inicial nos RFE TLi e THi (recarga automática):

CPUCLKTnT *12*)256(

CPUCLKT



101

Modo 2: 8 bits com recarga automática



102

Modo 2: 8 bits

Temporização de aproximadamente 200µs utilizando um clock de 11,0592MHz

CPUCLKTnT *12*)256(

11059200

12*)256(0002,0

11059200

1*12*)256(0002,0

11059200

1

0002,0

n

n

T

sT

CPUCLK

)(48

72

32,184256

25632,184

25612

11059200*0002,0

lhexadeciman

n

n

n

n

(arredonda-se para um valor inteiro)



103

Modo 3: Temporizador dividido

T/C0:

TH0 e TL0 operam como temporizadores separados de 8 bits cada. O cálculo para uma temporização ‘T’ é o mesmo do modo 2;

TL0 usa os bits C/T0, Gate0, TR0 e TF0 normalmente. TH0 opera apenas como temporizador utilizando os bits TF1, TR1 e o endereço de interrupção do T/C1.

T/C1:

No modo 3 “congela” sua atividade. A temporização/contagem ainda pode ser utilizada nos outros modos, mas não pode solicitar interrupção nem habilitar/desabilitar a contagem pois os bits TF1, TR1 e o endereço de interrupção estão emprestados ao T/C0;

A contagem será desativada entrando no modo 3 e reativada voltando ao modo original.



104

Modo 3: Temporizador dividido



105

Modo 0 (13 bits):

Conta de 0 a 8,888ms (cristal 11,0592MHz); Pouco usual, é mantido para manter compatibilidade entre os

microcontroladores da família 8051.

Modo 1 (16 bits):

Conta de 0 a 71ms (cristal 11,0592MHz); Mais utilizado para temporizações maiores.

Modo 2 (8 bits):

Conta de 0 a 277μs (cristal 11,0592MHz); Utilizado para temporizações menores e gerar baud rate.

Modo 3 (Temporizador dividido):

TH0 e TL0 contam de 0 a 277μs (cristal 11,0592MHz); TC1 trava; Pouco usual. Pode ser utilizado quando houver necessidade de um T/C

de 8 bits, um temporizador de 8 bits e um gerador de baud rate para a comunicação serial.



106

A partir deste ponto não será mais detalhado o

modo 0 por não ser um modo de operação usual;

O modo 3, apesar de não usual, será discutido por

não haver muitos exemplos de aplicação na

literatura sobre o 8051.



107

Temporização:

Para calcular o valor inicial a ser carregado nos RFE THi e TLi para uma determinada temporização, deve-se utilizar a equação para o modo que será utilizado, conforme os slides anteriores.

Contagem:

Para realizar uma contagem, basta subtrair o valor da contagem “c” desejada pelos RFE THi e TLi de acordo com o modo utilizado, conforme o slide a seguir.



108

Valores ‘n’ em THi e TLi para uma contagem ‘c’

Modo 1: 0 < c ≤ 65 536

n = 65 536 – c

Obs: lembre-se de converter ‘n’ para hexadecimal e substituir o MSB em THi e o LSB em TLi.

Modos 2 e 3: 0 < c ≤ 256

n = 256 – c

Para testar uma contagem basta conectar um botão entre o pino Ti e GND.



Para utilizar interrupções dos T/C’s em linguagem C deve-se:

1. Habilitar o uso de interrupções (bit EA);

2. Habilitar as interrupções desejadas (bits ET0 e/ou ET1);

3. Configurar o RFE TMOD: Gate em 0 habilitação do T/C depende apenas do bit TR,

em 1 depende de TR e do pino INT estar em nível alto; C/T em 0 o T/C opera como temporizador, em 1 opera

como contador; Configurar o modo de contagem nos bits M1 e M0 e

calcular o valor inicial dos RFE TH e TL.

4. Escrever a rotina de interrupção de acordo com o slide 71. 109



As constantes utilizadas para as temporizações

dos códigos a seguir foram calculadas

considerando um cristal de 11,0592MHz

110


#include <reg51.h> // Biblioteca de nomes dos bits/bytes dos RFE do 8051 void intTC0() interrupt 1 // Rotina de interrupcao do TC0. Ocorre a cada 50ms { TH0 = 0x4C; // Recarga da constante de tempo TL0 = 0x00; // Recarga da constante de tempo P1++; // Incrementa uma contagem binaria na P1 } main() { EA = 1; // Habilita uso de interrupcoes ET0 = 1; // Habilita a interrupcao do TC0 TMOD = 0x01; // Configura TC0 como temporizador, modo 1, ativado // apenas pelo bit TR0 TH0 = 0x4C; // Constante de tempo para 50ms TL0 = 0x00; // Constante de tempo para 50ms TR0 = 1; // Ativa temporizacao while(1); // Aguarda interrupcao }

111

Interrupção do TC0 como temporizador em modo 1 ativado

apenas pelo bit TR0


#include <reg51.h> // Biblioteca de nomes dos bits/bytes dos RFE do 8051 void intTC0() interrupt 1 // Rotina de interrupcao do TC0. Ocorre quando { // houver uma transicao de 1 para 0 em T0 TH0 = 0xFF; // Recarga da constante de contagem TL0 = 0xFF; // Recarga da constante de contagem P1++; // Incrementa uma contagem binaria na P1 } main() { EA = 1; // Habilita uso de interrupcoes ET0 = 1; // Habilita a interrupcao do TC0 TMOD = 0x05; // Configura TC0 como contador, modo 1, ativado // apenas pelo bit TR0 TH0 = 0xFF; // Constante para contagem n=1 TL0 = 0xFF; // Constante para contagem n=1 TR0 = 1; // Ativa contagem while(1); // Aguarda interrupcao }

112

Interrupção do TC0 como contador em modo 1 ativado apenas

pelo bit TR0


#include <reg51.h> // Biblioteca de nomes dos bits/bytes dos RFE do 8051 void intTC0() interrupt 1 // Rotina de interrupcao do TC0. Ocorre apenas { // se INT0 for 1, a cada 50ms TH0 = 0x4C; // Recarga da constante de tempo TL0 = 0x00; // Recarga da constante de tempo P1++; // Incrementa uma contagem binaria na P1 } main() { EA = 1; // Habilita uso de interrupcoes ET0 = 1; // Habilita a interrupcao do TC0 TMOD = 0x09; // Configura TC0 como temporizador, modo 1, ativado // pelo bit TR0, enquanto o pino INT0 for 1 TH0 = 0x4C; // Constante de tempo para 50ms TL0 = 0x00; // Constante de tempo para 50ms TR0 = 1; // Ativa temporizacao while(1); // Aguarda interrupcao }

113

Interrupção do TC0 como temporizador em modo 1 ativado pelo

bit TR0 e o pino INT0


#include <reg51.h> // Biblioteca de nomes dos bits/bytes dos RFE do 8051 void intTC0() interrupt 1 // Rotina de interrupcao do TC0. Ocorre apenas se INT0 { // for 1 e se houver uma transição de 1 para 0 em T0 TH0 = 0xFF; // Recarga da constante de contagem TL0 = 0xFF; // Recarga da constante de contagem P1++; // Incrementa uma contagem binaria na P1 } main() { EA = 1; // Habilita uso de interrupcoes ET0 = 1; // Habilita a interrupcao do TC0 TMOD = 0x0D; // Configura TC0 como contador, modo 1, ativado // pelo bit TR0, enquanto o pino INT0 for 1 TH0 = 0xFF; // Constante para contagem n=1 TL0 = 0xFF; // Constante para contagem n=1 TR0 = 1; // Ativa contagem while(1); // Aguarda interrupcao }

114

Interrupção do TC0 como contador em modo 1 ativado pelo bit

TR0 e o pino INT0


#include <reg51.h> // Biblioteca de nomes dos bits/bytes dos RFE do 8051 void intTC0() interrupt 1 // Rotina de interrupcao do TC0. Ocorre a cada 200us { P1++; // Incrementa uma contagem binaria na P1 } main() { EA = 1; // Habilita uso de interrupcoes ET0 = 1; // Habilita a interrupcao do TC0 TMOD = 0x02; // Configura TC0 como temporizador, modo 2, ativado // apenas pelo bit TR0 TL0 = 0x48; // Constante de tempo para 200us TH0 = 0x48; // Recarga automatica para 200us TR0 = 1; // Ativa temporizacao while(1); // Aguarda interrupcao }

115

Interrupção do TC0 como temporizador em modo 2 ativado

apenas pelo bit TR0


#include <reg51.h> // Biblioteca de nomes dos bits/bytes dos RFE do 8051 void intTC0() interrupt 1 // Rotina de interrupcao do TC0. Ocorre quando { // houverem duas transicoes de 1 para 0 em T0 P1++; // Incrementa uma contagem binaria na P1 } main() { EA = 1; // Habilita uso de interrupcoes ET0 = 1; // Habilita a interrupcao do TC0 TMOD = 0x06; // Configura TC0 como contador, modo 2, ativado // apenas pelo bit TR0 TL0 = 0xFE; // Constante para contagem n=2 TH0 = 0xFE; // Recarga automatica para contagem n=2 TR0 = 1; // Ativa contagem while(1); // Aguarda interrupcao }

116

Interrupção do TC0 como contador em modo 2 ativado apenas

pelo bit TR0


#include <reg51.h> // Biblioteca de nomes dos bits/bytes dos RFE do 8051 void intTC0() interrupt 1 // Rotina de interrupcao do TC0. Ocorre apenas { // se INT0 for 1, a cada 50ms P1+; // Incrementa uma contagem binaria na P1 } main() { EA = 1; // Habilita uso de interrupcoes ET0 = 1; // Habilita a interrupcao do TC0 TMOD = 0x0A; // Configura TC0 como temporizador, modo 2, ativado // pelo bit TR0, enquanto o pino INT0 for 1 TL0 = 0x48; // Constante de tempo para 200us TH0 = 0x48; // Recarga automatica para 200us TR0 = 1; // Ativa temporizacao while(1); // Aguarda interrupcao }

117

Interrupção do TC0 como temporizador em modo 2 ativado pelo

bit TR0 e o pino INT0


#include <reg51.h> // Biblioteca de nomes dos bits/bytes dos RFE do 8051 void intTC0() interrupt 1 // Rotina de interrupcao do TC0. Ocorre apenas se INT0 { // for 1 e se houverem duas transicoes de 1 para 0 em T0 P1++; // Incrementa uma contagem binaria na P1 } main() { EA = 1; // Habilita uso de interrupcoes ET0 = 1; // Habilita a interrupcao do TC0 TMOD = 0x0E; // Configura TC0 como contador, modo 2, ativado // pelo bit TR0, enquanto o pino INT0 for 1 TL0 = 0xFE; // Constante para contagem n=2 TH0 = 0xFE; // Recarga automatica para contagem n=2 TR0 = 1; // Ativa contagem while(1); // Aguarda interrupcao }

118

Interrupção do TC0 como contador em modo 2 ativado pelo bit

TR0 e o pino INT0


#include <reg51.h> // Biblioteca de nomes dos bits/bytes dos RFE do 8051 int i = 0; // i e definido como global porque sera usado em rotina de interrupcao

void atraso_1s(void) // Funcao para atraso de aproximadamente 1s { int j; TMOD = (0x0F & TMOD) | 0x10; // Configura TC1 em modo 1 sem afetar TC0 for(j=0; j<20; j++) { TH1 = 0x4C; // Constante de tempo para 50ms TL1 = 0x00; // Constante de tempo para 50ms while(TH1 != 0xFE); // ** Próximo slide explica essa instrução } TMOD = (0x0F & TMOD) | 0x30; // Trava TC1 alternando para modo } // 3 sem afetar TC0 // CONTINUA...

119

TC0 em modo 3, TL0 como contador de 8 bits (interrupção do

TC0) e TH0 como temporizador de 8 bits (interrupção do TC1).

T/C1 utilizado para gerar um atraso de 1s (sem interrupção)


Como a flag de interrupção TR1 esta “emprestada” ao TH0, deve-se testar diretamente os RFE TH1 e TL1;

Não pode-se testar um valor exato como TH1 e TL1 iguais a 0xFF porque nesse instante a CPU pode estar ocupada com uma rotina de interrupção ao invés do programa principal;

Por isso testa-se durante todo o tempo em que TH1 vale 0xFE e os 256 valores de TL1. Caso haja uma rotina de interrupção com muitas instruções, deve-se testar um intervalo maior de tempo. Usando este recurso a temporização não é muito precisa.

Continuação do programa no próximo slide 120





void intTC0() interrupt 1 { // Rotina de interrupcao vinculada ao TL0. Ocorre // quando houver uma transicao de 1 para 0 em T0 TL0 = 0xFF; // Recarga para contagem n=1 P0+; // Incrementa uma contagem binaria na P0 } void intTC1() interrupt 3 { // Rotina de interrupcao vinculada ao TH0. Ocorre // a cada 200us TL0 = 0x48; // Recarga para 200us P1++; // Incrementa uma contagem binaria na P1 } main() { IE = 0x8A; // Habilita uso de interrupcoes, interrupcao TC0 e TC1 TMOD = 0x37; // TC1 travado. TL0 como contador ativo por TR0. TH0 como // temporizador ativo por TR1 TH0 = 0x48; // Constante de tempo para 200us TL0 = 0xFF; // Constante para contagem n=1 TR0 = 1; // Ativa contagem TR1 = 1; // Ativa temporizacao while(1) { atraso_1s(); P2++; // Incrementa contagem binaria na P2 } }

121





#include <reg51.h> // Biblioteca padrão de nomes dos RSFs do 8051 sbit LED = P0^0; // Define LED como o pino 0 da P0

void atraso_ms(int i) { // TC0 configurado para uma temporizacao de for(i; i > 0; i--){ // aproximadamente 1ms * i (cristal de 11,0592MHz) TMOD = (0x0F & TMOD) | 0x10; // Configura TC1 em modo 1 sem afetar TC0 TH0=0xFC; // Constante de tempo para 1ms TL0=0x66; // Constante de tempo para 1ms TR0=1; // Ativa temporizacao while(!TF0); // Aguarda terminar temporizacao de 1ms TR0=0; // Desativa temporizacao TF0=0; // Zera a flag de fim de temporizacao } }

main() { while(1) { atraso_ms(1000); // Atraso de 1s LED = !LED; // Apaga/acende o LED } }

122

TC0 para gerar um atraso de 1ms*i com interrupções desabilitadas


EXERCÍCIO PROPOSTO

Escreva um programa que mostre as horas, minutos e segundos em um display LCD no formato hh:mm:ss.

123


COMUNICAÇÃO SERIAL

Uma necessidade comum em sistemas microcontrolados é a troca de informação entre dispositivos. Pode-se transmitir palavras de modo paralelo utilizando-se um fio para cada bit;

Contudo é inconveniente utilizar uma grande quantidade de fios para a transmissão de dados. Utiliza-se então a comunicação serial, onde os bits são transmitidos um após o outro em uma linha única. A desvantagem é que a comunicação serial é mais lenta comparada a paralela.

Cada vez mais está sendo usada a interface USB ao invés

dos padrões mais antigos. Vários microcontroladores

suportam esse protocolo, inclusive microcontroladores da

família 8051. Procure saber mais sobre essa tecnologia. 124



O 8051 dispõe de um canal de comunicação serial com diversos recursos como: 4 modos de operação; Full duplex; Programável; Compatibilidade com o padrão RS-232 (exceto pelos níveis

de tensão); Pode trabalhar com interrupção.

Portanto, não é preciso se preocupar em desenvolver uma comunicação serial a partir do zero, pois o 8051 faz isso por nós. Basta configurar essa programação de acordo com nossa necessidade.

125



Para comunicação com dispositivos padrão RS-232 utiliza-se conversores de níveis lógicos tais como o MAX232. Ele converte +5V para +12V e vice-versa, 0V para -12V e vice-versa, que é o padrão da comunicação serial RS-232.

126



Os registradores de transmissão/recepção da porta serial são acessíveis através do RFE SBUF. Fisicamente existem dois SBUF mas para o software apenas um. Dependendo da instrução, a CPU sabe qual SBUF deve ser usado;

Toda vez que o circuito recebe um byte, ele o apresenta no SBUF e todo byte escrito no SBUF é imediatamente transmitido para a porta serial.

127

x = SBUF; // O byte recebido via serial e copiado para a variavel ‘x’ SBUF = x; // O byte da variavel ‘x’ e transmitido para a porta serial



O RFE responsável pela configuração da porta serial é o SCON. Neste registrador são configurados o modo de operação, detecção de erro, reconhecimento automático de endereços em multiprocessamento e habilitação de recepção de dados;

Ainda no SCON, estão presentes nono bit em recepção/transmissão (quando habilitados) e as flags de interrupção para recepção/transmissão;

Além do SCON, existem mais 2 bits que atuam na configuração da porta serial, localizados no RFE PCON. O baud rate nos modos 1 e 3 são configurados no T/C1. Em dispositivos que possuem um T/C2 pode-se optar para gerar o baud rate a partir do T/C1 ou do TC2.

128



FE/SM0:

FE (bit de detecção de erro) é setado automaticamente quando é detectado um bit de parada inválido. Não é resetado automaticamente, precisa ser resetado por software para limpar estado de erro. O bit SMOD0 do RFE PCON precisa estar em 1 para acessar o FE;

SM0 é referente ao modo de operação da serial. O bit SMOD0 do RFE PCON precisa estar em 0 para acessar SM0;

SM1: Referente ao modo de operação da serial;

SM2: Em 0 desabilita e em 1 habilita reconhecimento automático de endereço em multiprocessamento. Pode ser usado nos modos 2, 3 e eventualmente no 1. No modo 0 precisa estar resetado;

REN: Habilita recepção de dados. O pino RX só será efetivamente monitorado se REN for 1. Em 0 o pino RX pode ser usado para outra função;

TB8 e RB8: Nonos bits de transmissão e recepção respectivamente. Utilizados nos modos 2 e 3;

TI e RI: flags de fim de transmissão e recepção respectivamente. Não são zerados automaticamente na rotina de interrupção e devem ser resetados por software.

129



130

Seleção do modo de operação da comunicação serial.



Taxa de transmissão/recepção da comunicação serial

(Baud Rate):

Nos modos 1 e 3 a taxa de comunicação serial é determinada a partir do T/C1 (ou T/C2 em dispositivos que o possuam);

Geralmente programa-se o temporizador em modo 2 (recarga automática). Nesse caso a tabela do slide a seguir exibe os valores que devem ser armazenados em TL1 e TH1 para o baud rate desejado;

Não é necessário habilitar a interrupção de T/C1 nem resetar a flag TF1.

131



132

Constantes de tempo para o T/C1 em modo recarga automática de

acordo com o baud rate desejado

Observe que os cristais de clock de 11,0592MHz e 22,1184MHz permitem uma excelente aproximação para a taxa desejada.



Será detalhado apenas o modo 1 de operação da

comunicação serial, sem usar detecção de erro

ou reconhecimento automático de endereços em

multiprocessamento;

É suficiente para a maioria das aplicações,

porém, existem muitas outras peculiaridades

acerca da comunicação serial que não serão

tratadas aqui;

Para maiores informações consulte a folha de

dados e bibliografias complementares.

133



A seguir será exibido um programa simples de comunicação entre dois microcontroladores 8051 ambos com o mesmo código;

A partir de dois botões o microcontrolador envia o código para acender o LED correspondente ao botão pressionado no outro microcontrolador;

Observe que a interrupção não distingue transmissão de recepção, e é preciso tratar esta situação no programa.

134



135


#include <reg51.h> sbit botao0=P2^0; sbit botao1=P2^1; unsigned char dadosRX; void atraso_ms(int i) { // TC0 configurado para uma temporizacao for(i; i > 0; i--){ // de aproximadamente 1ms * i (cristal de 11,0592MHz) TMOD = (TMOD & 0xF0) | 0x01; TH0 = 0xFC; TL0 = 0x66; TR0 = 1; while(!TF0); TR0 = 0; TF0 = 0; } } void intSerial() interrupt 4 { // Rotina da interrupção da serial if(TI) { // TRANSMISSAO TI=0; // Reseta flag pois não e resetada automaticamente } if(RI) { // RECEPCAO RI=0 // Reseta flag pois não e resetada automaticamente P2=SBUF; // Acende LED correspondente atraves do valor recebido via serial atraso_ms(2000); P2=0xFF; // Após 2 segundos apaga o LED } } // CONTINUA...

136

Comunicação serial em modo 1 baud rate de 9600b/s


main() { SCON = 0x50; // Configura scon em modo 1, recepcao habilitada TMOD = 0x20; // Habilita TC1 para gerar baud rate em modo recarga automatica TL1 = 0xFD; // Baud rate 9600 TH1 = 0xFD; // Recarga automatica para Baud rate 9600 TR1 = 1; // Ativa temporizacao EA = 1; // Habilita uso de interrupcoes ES = 1; // Habilita a interrupcao da serial while(1) { if(!botao0) { // Se botao0 for pressionado aguarda um tempo para debounce atraso_ms(500); SBUF=0xFB; // Transmite via serial codigo para acender LED correspondente } if(!botao1) { // Se botao0 for pressionado aguarda um tempo para debounce atraso_ms(500); SBUF=0xF7; // Transmite via serial codigo para acender LED correspondente } } }

137

Comunicação serial em modo 1 baud rate de 9600b/s



É descrito a seguir um esboço de programa

utilizando o T/C0 em modo 3 e o T/C1 como

gerador de baud rate.

TL0 como contador de 8 bits (interrupção do TC0)

e TH0 como temporizador de 8 bits (interrupção

do TC1).

138


#include <reg51.h> void intTC0() interrupt 1 { // Rotina de interrupcao vinculada ao TL0. Ocorre // quando houver uma transicao de 1 para 0 em T0 TL0 = 0xFF; // Constante para contagem n=1 // ESCREVA SEU CODIGO AQUI } void intTC1() interrupt 3 { // Rotina de interrupcao vinculada ao TH0. Ocorre // a cada 200us TL0 = 0x48; // Recarga para 200us // ESCREVA SEU CODIGO AQUI } void intSerial() interrupt 4 { // Rotina da interrupção da serial if(TI) { // TRANSMISSAO TI=0; // Reseta flag pois não e resetada automaticamente // ESCREVA SEU CODIGO AQUI } if(RI) { // RECEPCAO RI=0 // Reseta flag pois não e resetada automaticamente // ESCREVA SEU CODIGO AQUI } } // CONTINUA...

139

T/C0 em modo 3 e T/C1 utilizado para gerar baud rate para a

comunicação serial


main() { IE = 0x9A; // Habilita uso de interrupcoes, interrupcao TC0, TC1 e serial SCON = 0x50; // Configura scon em modo 1, recepcao habilitada TMOD = 0x27; // TC1 como gerador de baud rate. TL0 como contador ativo por TR0. // TH0 como temporizador ativo por TR1 TH0 = 0x48; // Constante de tempo para 200us TL0 = 0xFF; // Constante para contagem n=1 TL1 = 0xFD; // Baud rate 9600 TH1 = 0xFD; // Recarga automatica para Baud rate 9600 TR0 = 1; // Ativa contagem TR1 = 1; // Ativa temporizacao de 200us. Quando o T/C0 esta no modo 3 a // temporizacao do T/C1 ja inicia ativa e so pausa se alternar o T/C1 para o modo 3 while(1) { // ESCREVA SEU CODIGO AQUI } }

140

T/C0 em modo 3 e T/C1 utilizado para gerar baud rate para a

comunicação serial


EXERCÍCIO PROPOSTO

Escreva um programa para um microcontrolador transmissor e outro programa para um microcontrolador receptor. O transmissor deve enviar através da serial o caractere correspondente ao botão pressionado em um teclado matricial 4x4. O receptor deve escrever o dado recebido em um display LCD.

141


CONSIDERAÇÕES FINAIS

Foram apresentadas as funcionalidades básicas do 8051 clássico e exemplos de interface com teclado matricial e display de caracteres. Uma vez que compreendidos estes conceitos não é difícil estudar diferentes tipos de microcontroladores;

Os dispositivos da família 8051 mais recentes possuem outros recursos que atendem necessidades mais modernas;

Esta apresentação é apenas uma introdução aos microcontroladores. Procure estudar não só outros dispositivos 8051 mas também outras famílias de microcontroladores. Bons estudos!

142


REFERÊNCIAS

Atmel 8051 Microcontrollers Hardware Manual: Manual do fabricante.

MELO, Édson. Arquitetura Padrão 8051 de Microcontroladores: Uma

Introdução – Apostila. Instituto Federal de Santa Catarina, 1ª ed., Departamento de Eletrônica, 2005.

SÁ, Marcio Cardoso de. Programação C para microcontroladores

8051. Érica, 1ª ed., 2005.

LIMA, Charles Borges de. Os Poderosos µcontroladores AVR – Apostila. Instituto Federal de Santa Catarina, 1ª ed., Departamento de Eletrônica, 2009.

8051 Teoria. Disponível em: http://www.u8051.com.br/aulas/8051_Teoria.pdf - Acesso em 29/08/2012.

8051 Tutorial. Disponível em: http://www.8052.com/tut8051 - Acesso em 29/08/2012.

143


http://www.u8051.com.br/aulas/8051_Teoria.pdf

http://www.u8051.com.br/aulas/8051_Teoria.pdf

http://www.8052.com/tut8051



Documents

Micro Control Adores