Escolar Documentos
Profissional Documentos
Cultura Documentos
8051
5) MICROCONTROLADORES..................................................................................................................................................... 21
5.1) MICROPROCESSADOR: ................................................................................................................................................. 21
5.2) BARRAMENTOS DE UM MICROCONTROLADOR.......................................................................................................... 23
5.3) MODOS DE ATENDIMENTO DE I/O................................................................................................................................ 24
6) MICROCONTROLADOR 8031/8051........................................................................................................................................ 25
6.1) PINAGEM:........................................................................................................................................................................... 25
6.2) BARRAMENTO MULTIPLEXADO:............................................................................................................................................. 26
6.3) CLOCK NO 80C51............................................................................................................................................................ 27
................................................................................................................................................................................................ 28
6.4) RESET DO MICROCONTROLADOR ............................................................................................................................... 28
6.5) INTERRUPÇOES ............................................................................................................................................................. 30
................................................................................................................................................................................................ 33
6.6) INTERRUPÇÃO EXTERNA .............................................................................................................................................. 34
6.7) TEMPORIZADOR E CONTADOR .................................................................................................................................... 35
6.8) COMUNICAÇÃO SERIAL ................................................................................................................................................. 37
6.9) INTERFACE SERIAL NO 8051......................................................................................................................................... 38
6.10) TAXA DE TRANSMISSÃO PARA OS MODOS 1 E 3 .................................................................................................... 39
6.11) TABELA PRÁTICA COM TAXAS PARA O CRISTAL DE 11,0592 MHZ .......................................................................... 39
7) PROGRAMAÇÃO “C” PARA O MICROCONTROLADOR 8051.............................................................................................. 40
7.1) TIPOS DE VARIÁVEIS EM C ........................................................................................................................................... 41
7.2) OPERADORES ARITMÉTICOS ....................................................................................................................................... 41
7.3) OPERADORES LÓGICOS E RELACIONAIS ................................................................................................................... 42
7.4) OPERADORES DE MANIPULAÇÃO DE BIT ................................................................................................................... 42
7.5) DIRETIVAS FUNDAMENTAIS DO PRÉ – COMPILADOR................................................................................................ 43
7.6) CONTROLE DE FLUXO ................................................................................................................................................... 44
7.7) MAPA DE ALOCAÇÃO DE VARIÁVEIS NO 8051 ............................................................................................................ 50
1) SISTEMAS DE NUMERAÇÃO
Onde:
An = Algarismo
B = Base do número
n = quantidade de algarismos - 1
Ex: 25934
n = 5 -1 = 4
B = 10
A0 = 4; A1 = 3; A2= 9; A3 = 5; e A4 = 2
n= 3 -1= 2
A0 = 1; A1 = 0 e A2 = 1
n= 2 -1= 1
A0 = 11(B) e A1 = 10(A)
EX: 129d = ?b
129d = 10000001b
Para converter de decimal para a base “B” basta utilizar o método das divisões
sucessivas dividindo o número pela base “B”
3882d = F2Ah
Ex: A2C7h = ?b
A 2 C 7
1010 0010 1100 0111
A2C7h = 1010001011000111b
1) 23Fh = ?d
2) 47d = ?b
3) 11010011b = ?d
4) 11100010b = ?h
5) A2Ch = ?d
6) 2DAh = ?b
7) 1110 0001b = ?d
8) 352d = ?h
9) 510d = ?h
10) 120d = ?b
Se você está confuso e não sabe qual o método
usado para fazer a conversão, lembre-se:
• Para converter de binário ou hexadecimal
para decimal utilize a lei de formação.
• Para converter de decimal para hexadecimal
ou binário faça divisões sucessivas.
• Para converter entre binário e hexadecimal
utilize a tabela.
2.1) ADIÇÃO
Para efetuarmos a adição no sistema binário, devemos agir como numa adição
convencional do sistema decimal. Convém observar que no sistema decimal 1+1 = 2d
e no sistema binário como temos apenas dois algarismos
1+1 = 0 e transporta 1.
A operação de transporte também é denominada carry.
2.2) SUBTRAÇÃO
2.3) COMPLEMENTO DE 2
Uma forma para representar números binários negativos bastante utilizada nos
sistemas já citados é a notação de complemento de 2 (C2), mas para obtê-la,
devemos primeiramente converter o número na notação de complemento de 1.
A obtenção do complemento de um ( C1) de um número binário se dá pela
troca de cada bit do número pelo seu inverso ou complemento.
Binário: 1011
Complemento 1: 0 1 0 0
Decimal -1 -2 -4 -8
Binário - 0001 - 0010 - 0100 - 1000
Comp. 2 1111 1110 1100 1000
2.4) DESLOCAMENTO
Ex:
O número que inicialmente era 0010 ( 2d) foi multiplicado pela sua base (2), que
resultou no binário 0100 (4d).
Ex:
O binário 1000 que representa 8d como foi deslocado para a direita resultou em 0100
que representa 4d, portanto podemos verificar que o número foi dividido pela base 2.
3) OPERAÇÕES LÓGICAS
3.1) AND
A B S
0 0 0
0 1 0
1 0 0
1 1 1
3.2) OR
A função “OR” é aquela que assume valor 1 quando uma ou mais entradas
forem iguais a “um” e assume valor “zero” se todas as entradas forem zero.
Sua representação algébrica para duas variáveis de entrada é S = A + B, onde
se lê S = A ou B.
A B S
0 0 0
0 1 1
1 0 1
1 1 1
3.3) NOT
A S
0 1
1 0
A B S
0 0 0
0 1 1
1 0 1
1 1 0
A função xor é utilizada para gerar PARIDADE PAR, onde este é um dos
métodos para detecção de erro em comunicação digital.
1) 10d AND 4d
2) 3Fh OR 80h
3) 1001b XOR 1010b
4) 13d OR 9Ch
5) 11000010 AND FFh
6) 24h OR 0d
7) 82h XOR 13h
8) 10101010 AND 55h
9) 5d OR 3h
10) 10111100 AND 00001010
11) NOT 5Ah
12) NOT 13d
4) TERMOS IMPORTANTES
4.1) BUFFER: Em geral, chamamos de buffer o circuito que tem por objetivo o
armazenamento temporário de informações.
4.4) TRI-STATE: Nome dado, quando o sistema está fisicamente ligado, porém não
interfere no sistema devido a alta resistência apresentada.
4.8) CHIP SELECT (/CS): Este pino está presente na grande maioria dos dispositivos
associados a microprocessadores.
Como todos os dispositivos (EPROM, RAM, I/O) estão ligados à via de dados
(D0 ... D7), os mesmos devem estar sempre em alta impedância para evitar que
enquanto um bit esteja em “0”, outro esteja em “1”, ocasionando um conflito e até
mesmo danificando o sistema.
Normalmente todos os dispositivos estão com o /CS em “1”, e somente irá a “0”
aquele dispositivo que está sendo acionado e apenas durante o tempo necessário.
Estes tempos e esta seleção são efetuados por “circuitos lógicos” conhecidos
como DECODIFICADORES DE ENDEREÇO.
Tabela verdade:
A B Y0 Y1 Y2 Y3
0 0 0 1 1 1
0 1 1 0 1 1
1 0 1 1 0 1
1 1 1 1 1 0
B) 32K RAM, 32K para I/O com mapeamento redundante nos endereços 8000H e
8001H
C) 32K RAM, 32K para I/O com mapeamento não redundante nos endereços 8000H
e 8001H
1) Projetar um decodificador com 16K de RAM e 48K bytes de I/O, mapeando 16K
para cada dispositivo. Mapeamento redundante.
5) MICROCONTROLADORES
5.1) MICROPROCESSADOR:
É uma máquina seqüencial que executa um conjunto de comandos (instruções )
previamente gravados em uma memória (ROM). Embora todos os
microprocessadores utilizem um sinal de clock, é comum encontrar na literatura, a
classificação de microprocessadores síncronos e assíncronos.
Com a evolução tecnológica, principalmente na confecção de CI’s, os
fabricantes de microprocessadores começaram a incorporar memórias e dispositivos
periféricos na mesma pastilha de seus microprocessadores. Surgiram então os
microcontroladores.
Uma vez que incorporam grande parte dos dispositivos periféricos, a
construção de um sistema baseado em um microcontrolador, freqüentemente se
resume a um circuito com um cristal, um botão de reset e a memória de programa.
A CPU do tipo CISC possui um conjunto muito grande de instruções (8051, Z80).
Interrupção: Neste tipo de atendimento, a CPU é avisada pelo dispositivo de I/O, que
o mesmo necessitam receber ou enviar dados.
Este tipo de atendimento é mais complexo, tendo como vantagem não
desperdiçar o tempo da CPU.
Como é um evento assíncrono, a CPU sempre atende no momento solicitado.
Necessita de um hardware adicional.
DMA (Direct Memory Acess) : Este tipo de atendimento é o mais complexo, porém o
mais rápido. O dispositivo de I/O solicita os barramentos da CPU (Tri - State) e
acessa diretamente a memória, transferindo então os dados. Nem toda a CPU
suporta este tipo de atendimento.
6) MICROCONTROLADOR 8031/8051
6.1) Pinagem:
Para evitar que o chip tenha mais que 40 pinos, a Intel adotou a solução de
multiplexar no mesmo barramento os dados e endereço.
Existem duas formas de gerar circuito de clock no microcontrolador. O clock pode ser
externo ou interno.
uso do clock externo é interessante quando temos outros dispositivos que utilizam um
sinal TTL para gerar sua base de tempo. Sua implementação resume-se em colocar o
pino 19 (XTAL1) no nível de terra e injetar o sinal externo no pino 18 (XTAL2), que irá
diretamente para o sistema de controle e temporização do chip.
O reset no 80C51 é ativado quando o pino 9 (RST) permanece em nível lógico 1 por 2
ou mais ciclos de máquina. Neste caso a CPU executa o chamado reset interno, que
consiste em inicializar seus registros internos com valores predeterminados:
• A memória interna não é afetada pelo reset forçado, sendo que ao ligar seu valor é
aleatório.
O microcontrolador pode ser resetado automaticamente toda vez que a fonte é ligada.
Normalmente utilizamos um resistor de 10K entre o pino do reset e o terra, e um
capacitor de 10µF entre o VCC e o pino de reset.
6.5) INTERRUPÇOES
Ativação - Existem três formas que o sistema pode reconhecer uma interrupção:
No 8051, todas as interrupções são
• pelo nível (alto ou baixo) mascaráveis e vetoradas.
• pela borda (subida ou descida)
• pela combinação de borda e nível.
Sendo que cada uma destas interrupções será desviada para os seguintes
endereços:
Onde,
Onde,
IE0 - Localizado no bit 1 de TCON. É setado pelo hardware interno quando for
detectado um pedido de interrupção. É resetado quando a interrupção for atendida.
IE1 - Localizado no bit 3 de TCON. É setado pelo hardware interno quando for
detectado um pedido de interrupção. É resetado quando a interrupção for atendida.
Onde,
TF1 - É setado pelo hardware sempre que ocorrer um overflow (estouro no contador)
no T/C1. É resetado ao final da rotina de interrupção de T/C1.
TR1 - Quando em nível lógico 1 irá ligar o T/C1, e quando em zero o mesmo será
desligado.
TF0 - É setado pelo hardware sempre que ocorrer um overflow (estouro no contador)
no T/C0. É resetado ao final da rotina de interrupção de T/C0.
TR0 - Quando em nível lógico 1 irá ligar o T/C0, e quando em zero o mesmo será
desligado.
Onde,
Gate0; Gate1 – Definem como o timer/contador irá funcionar. Quando este bit estiver
em nível lógico 1 o timer/contador será ativado se TRn e o pino INTn forem 1. Esta
configuração é bastante útil quando queremos medir largura de pulso externo.
Quando este bit estiver em nível lógico 0 o timer/contador será ativado simplesmente
colocando TRn em 1.
C/T0;C/T1 - Definem a fonte do sinal de clock. Quando em nível lógico 0 ele terá a
função de timer e a base de tempo será o clock do cristal. Quando este bit estiver em
1 ele estará operando como contador e o clock será os pulsos presentes no pino Tn
No 8051 temos uma interface serial do tipo full duplex. Desta forma, sistemas de
comunicação podem enviar e receber dados de forma simultânea com o
microcontrolador. Para este fim, o 8051 possui um registrador chamado SBUF(Serial
Buffer).Quando queremos enviar uma informação pelo canal serial devemos escrever
o byte no SBUF, e quando desejamos receber o byte pelo microcontrolador devemos
ler o SBUF. Pode parecer que ele possui apenas um registrador para Tx e Rx, mas
na verdade existem dois registradores com o mesmo nome e que serão reconhecidos
pelo sistema através da instrução assembler.
Onde,
RB8 - No modo 0 indica o estado do stop bit Nos modos 2 e 3 indica o estado do
nono bit recebido.
Frequência( Mhz).106
TH 1 = 256 −
384.Taxa( BPS )
2 SMOD .Frequência
TAXA =
384 ( 256 − THI )
6.11) TABELA PRÁTICA COM TAXAS PARA O CRISTAL DE 11,0592 Mhz
Existem basicamente três linguagens de programação que são utilizadas com o 8051,
o BASIC, ASSEMBLY e o C. Nos últimos cinco anos, a programação de
microcontroladores em linguagem C tem sido adotada pela maioria das empresas
devido as facilidades para programação e ao nível de portabilidade apresentada.
Outro detalhe importante é que no 8051 podemos utilizar uma grande variedade de
modos de acesso a memória. Como o microcontrolador suporta acesso a BIT,
memória RAM interna, memória RAM externa devemos ficar atento ao padrão
adotado pelo compilador(small ou large para o SDCC) ou especificar onde desejamos
que a memória seja reservada.
ucLValor = ucLValor & 0x7F; // Zera o bit mais significativo do byte //ucLValor
Exemplo:
#define LIGADO 1
#define MAXIMO 50 //`Substitui o nome MAXIMO por 50 no programa
B) #INCLUDE <ARQUIVO>
Exemplo:
#include <8051.h> // Inclui o arquivo 8051.h da pasta padrão
#include “8051.h” // Inclui o arquivo 8051.h da pasta do programa
A) IF – ELSE
A atribuição IF-ELSE permite que um determinado enunciado, que pode ser simples
ou composto, seja executado desde que uma determinada condição seja satisfeita. A
sintaxe é a seguinte:
If (condição)
enunciado1;
else
enunciado2;
Exemplo: Se o valor da variável for zero o pino zero da porta P3 deverá ser colocado
em nível lógico 1 senão em nível lógico zero
#include <pwlib.h>
unsigned char ucGLeitura;
void main (void)
{
ucGLeitura = P1;
if(!ucGLeitura)
P3_0 = 1;
else
P3_0 = 0;
}
If (condição)
enunciado1;
Exemplo: Se o valor da variável for zero o pino zero da porta P3 deverá ser colocado
em nível lógico 1.
#include <pwlib.h>
unsigned char ucGLeitura;
void main (void)
{
ucGLeitura = P1;
if(!ucGLeitura)
P3_0 = 1;
#include <pwlib.h>
unsigned char ucGLeitura;
void main (void)
{
ucGLeitura = P1;
if(!ucGLeitura)
{
P3_0 = 1;
P3_1 = 0;
}
else
{
P3_0 = 0;
P3_1 = 1:
}
}
SWITCH(VALOR)
{
CASE comparacao1:
enunciado1;
BREAK;
CASE comparacao2:
enunciado2;
BREAK;
DEFAULT:
enunciado3;
BREAK;
}
A palavra chave DEFAULT, tem por objetivo especificar um enunciado para ser
executado caso o valor de entrada não seja encontrado em nenhum valor de
comparação do CASE. Se não for necessário executar um enunciado quando o valor
não for encontrado a palavra chave DEFAULT não será necessária.
#include <pwlib.h>
#include <8051.h>
unsigned char ucGLeitura;
void main (void)
{
ucGLeitura = P1;
switch(ucGLeitura)
{
case 0x00:
PWDisplayEscreveString("Desligado ",2,1);
break;
case 0xFF:
PWDisplayEscreveString("Maximo ",2,1);
break;
default:
PWDisplayEscreveString("Intermediario ",2,1);
break;
}
C) WHILE
#include <pwlib.h>
#include <8051.h>
unsigned char ucGLeitura;
void main (void)
{
ucGLeitura = P1;
ucGLeitura = PWLeTeclado( );
PWDisplayEscreveString (“Selecione tecla: ”,1,1);
while (ucGLeitura == 0)
{
ucGLeitura = PWLeTeclado( );
}
}
D) DO – WHILE
#include <pwlib.h>
#include <8051.h>
unsigned char ucGLeitura;
void main (void)
{
ucGLeitura = P1;
PWDisplayEscreveString (“Selecione tecla:”,1,1);
do
{
ucGLeitura = PWLeTeclado ( );
FOR(expressao1; expressao2;expressao3)
{
enunciado1;
}
onde,
A expressao1 é a inicialização, sendo executada apenas uma vez, normalmente para
inicializar uma variável presente na condicao2. A expressao2 é a condição, cujo
resultado determina se o enunciado1 que pode ser simples ou composto será
executado. A expressao3 é o incremento ou decremento, sendo executado ao final da
passagem do loop. O loop só será abandonado quando a condição(expressao2) for
falsa ou quando dentro do loop for executada a instrução break ou return.
#include <pwlib.h>
#include <8051.h>
unsigned char ucGLoop;
void main (void)
{
unsigned char ucLBuffNome[20];
}
}
F) RETURN
XDATA (XSEG) : Se você possui memória RAM externa na CPU então esta memória
é acessada com este modo de endereçamento. Os dispositivos de I/O mapeado em
memória também são acessados através deste segmento.
IDATA (ISEG) : Este são os128 bytes extra de memória de dados acessados através
do endereçamento indireto. É importante lembrar que IDATA está disponível apenas
nas versões 8032, 8052 ou similar.
BIT (BSEG): Esta área fica entre os endereços 20h e 2Fh na memória de acesso
direto. Ela é bastante útil quando queremos sinalizar situações do tipo VERDADEIRO
ou FALSO, LIGADO ou DESLIGADO permitindo uma eficiente economia de espaço
de memória.
8.1) MIDE-51
1) Abrir o editor com um duplo clique no ícone da figura abaixo que está na área de
trabalho do Windows
/*###############################################################
# #
# PROWARE PROJ. E SIST. ELETRONICOS #
# #
# PROJETO: TESTE #
# #
# MODULO: PRIMEIRO.C #
# #
# REVISÃO: 1 #
# #
# FUNCAO: #
# #
# HISTORICO: #
# #
# - Software inicial #
# Autor: Jefferson Couto Data: 20/03/06 #
# #
##############################################################*/
#include <pwlib.h>
void main( )
{
/* Escreva o seu programa aqui */
}
4) Salve o arquivo em FILE / SAVE AS como Primeiro.C. Se tudo você fez todos os
passos de forma correta, o programa deverá ficar com alguns detalhes com cor
diferente.
Se tudo correr bem e o programa não possuir nenhum erro, na parte de baixo do
editor vai aparecer uma mensagem que o arquivo HEX foi gerado.
Para carregar o firmware na placa didática, basta clicar no icone da figura abaixo.
Para que o arquivo HEX gerado pelo edito seja compatível com a placa didática
utilizada na escola, devemos configurar o editor da seguinte forma:
PARAMETER
PATH
c:\mide\sdcc
EXECUTE FILE
C:\Arquivos de programas\WinLoader51\WinLoader51.exe
8.2) WinLoader51
Após clicar no icone para fazer a carga do firmware ( 8.1.2 ) o botão de GRAVAR no
aplicativo deverá estar habilitado se o programa for compilado e carregado com
sucesso, isto é, o texto “Gravar” deverá estar na cor verde. Caso o botão esteja com
o texto em cinza existem duas possibilidades:
Se o botão estiver habilitado, você poderá ver na parte de baixo do aplicativo o nome
do arquivo HEX que foi carregado pelo WinLoader51 e o Checksum do firmware
selecionando a opção FERRAMENTAS / STATUS.
Pressione o botão de CARGA na placa didática de forma que o LED da placa fique na
cor vermelha. Se o aplicativo estiver sendo executado, o LED de STATUS deverá
ficar na mesma cor da placa, informando que existe comunicação entre eles.
Neste momento, o usuário deve clicar no botão “Gravar”. Após alguns segundos o
aplicativo deve mostrar uma barra com o andamento da carga do firmware na placa.
#####################################################################################
# #
# PROWARE PROJ. E SIST. ELETRONICOS #
# #
# PROJETO: DIGITAR VELOCIDADE #
# #
# MODULO: TECLCD.C #
# #
# REVISÃO: 1 #
# #
# FUNCAO: #
# #
# HISTORICO: #
# #
# - Software inicial #
# Autor: Jefferson Couto Data: 10/09/06 #
# #
# #
# #
#####################################################################################*/
#include <pwlib.h>
unsigned int uiGVelocidade;
void main()
{
unsigned char ucLContador;
while(1)
{
PWDisplayLimpa(); // Limpa display
PWDisplayEscreveString ("Velocidade =" 1,1); // Mostra mensagem na linha 1
#include <pwlib.>
#include <8051.h>
void InicializaRegistradores(void);
void main(void)
{
unsigned char ucLRetorno;
unsigned char ucLPosicaoLCD;
unsigned char ucLContador = 0;
unsigned char ucLOpcao;
unsigned char ucLByte;
unsigned char ucLCanal = 0;
InicializaRegistradores();
PWDisplayInicializa();
PWDisplayPosicionaCursor(2,7);
PWDelay(30000);
ucLPosicaoLCD = 0;
ucLContador = 0;
while(1)
{
PWDisplayEscreveString("Selecione Opcao:",1,1);
PWDisplayEscreveString(" 1-A/D 2-D/A ",2,1);
do
{
ucLRetorno = PWLeTeclado();
}while(ucLRetorno == 0);
do
{
ucLRetorno = PWLeTeclado();
switch(ucLRetorno)
{
case '1':
ucLCanal = 1;
break;
case '2':
ucLCanal = 2;
break;
}
}while(ucLCanal == 0);
break;
case '2':
PWDisplayEscreveString("Selecionado: ",1,1);
PWDisplayEscreveString("Conversor D/A 0 ",2,1);
break;
}
PWDelay1Segundo(1);
break;
}
else
{
PWDisplayEscreveString("Selecao invalida",1,1);
PWDisplayEscreveString("Tente novamente.",2,1);
PWDelay1Segundo(1);
}
}
ucLByte = 0;
PWDisplayLimpa();
if(ucLOpcao == '2')
{
PWDisplayEscreveString("Fechar jump. JP1",1,1);
PWDisplayEscreveString("pres. tecla test",2,1);
do
{
ucLRetorno = PWLeTeclado();
}while(ucLRetorno == 0);
}
while(1)
{
if(ucLOpcao == '1') // Seleciona leitura do A/D canal 0
{
if(ucLCanal == 1)
{
ucLByte = PWLeituraAD(0);
}
else
{
ucLByte = PWLeituraAD(1);
}
PWBinToASCII(2,1,ucLByte );
PWDelay1Segundo(1);
}
PWDelayms(50);
PWBinToASCII(1,4,ucLByte );
ucLByte++;
do
{
ucLRetorno = PWLeituraAD(0);
PWDelay1Segundo(1);
PWBinToASCII(2,4,ucLRetorno );
ucLRetorno = PWLeTeclado();
}
while(ucLRetorno == 0);
}
}
void InicializaRegistradores(void)
{
#####################################################################################
# #
# PROWARE PROJ. E SIST. ELETRONICOS #
# #
# PROJETO: CONTROLE DE SAIDA DO D/A #
# #
# MODULO: DIGITAVO.C #
# #
# REVISÃO: 1 #
# #
# FUNCAO: #
# #
# HISTORICO: #
# #
# - Software inicial #
# Autor: Jefferson Couto Data: 20/03/06 #
#####################################################################################
#include <PWlib.h>
#include <8051.h>
void MostraValor(unsigned char);
void InicializaRegistradores(void);
void main()
{
unsigned char ucLValor;
unsigned char ucLCopia;
void InicializaRegistradores(void)
{
IP = 0x00; // Configura prioridade padrao para interrupcoes
TMOD = 0x00; // Configura modo do TIMER
IE = 0x00; // Desabilita interrupções
}
#####################################################################################
# #
# PROWARE PROJ. E SIST. ELETRONICOS #
# #
# PROJETO: PWM #
# #
# MODULO: PWM.C #
# #
# REVISÃO: 1 #
# #
# FUNCAO: #
# #
# HISTORICO: #
# #
# - Software inicial #
# Autor: Jefferson Couto Data: 28/05/06 #
#####################################################################################
#include <PWlib.h>
#include <8051.h>
void InicializaRegistradores(void);
unsigned char ucGPwmHigh = 0;
unsigned char ucGPwmLow = 0;
unsigned char ucGTecla;
unsigned char ucAtualiza = 0;
unsigned char ucGDutyCicle = 50;
#define CONTAGEM 46 // Tempo de 1ms Ciclo de máquina x 9 X 100 = aproximadamente 1mS
#define CONTAGEMH (65535-CONTAGEM)/256
#define CONTAGEML (65535-CONTAGEM)
void Int_Timer0(void) interrupt 1
{
IT0 = 0;
if(ucGPwmHigh > 0)
{
P1_0 = 1;
ucGPwmHigh--;
}
else
{
if(ucGPwmLow > 0)
{
P1_0 = 0;
ucGPwmLow--;
}
else
{ if(ucGDutyCicle == 0)
P1_0 = 0;
else
P1_0 = 1;
ucGPwmHigh = ucGDutyCicle;
ucGPwmLow = 100 - ucGDutyCicle;
}
}
TH0 = CONTAGEMH;
TL0 = CONTAGEML;
IT0 = 1;
}
void main()
while(1)
{
ucGTecla = PWLeTeclado();
if(ucGTecla == '2')
{ if(ucGDutyCicle < 100)
ucGDutyCicle++;
PWDisplayLimpa();
PWDisplayEscreveString("Aumenta PWM ",1,1); // Mostra mensagem na linha 1
PWMostraCharxxx(ucGDutyCicle);
PWEscreveCaractere('%');
PWDelayms(100);
ucAtualiza = 1;
}
if(ucGTecla == '1')
{
if(ucGDutyCicle > 0)
ucGDutyCicle--;
PWDisplayLimpa();
PWDisplayEscreveString("Diminui PWM ",1,1); // Mostra mensagem na linha 1
PWMostraCharxxx(ucGDutyCicle);
PWEscreveCaractere('%');
PWDelayms(100);
ucAtualiza = 1;
}
if((ucAtualiza)&&(ucGTecla == 0)) // Se nenhuma tecla pressionada e alterou Duty Cicle
{
PWDisplayLimpa();
PWDisplayEscreveString ("GERANDO PWM ",1,1);
PWMostraCharxxx(ucGDutyCicle);
PWEscreveCaractere('%');
ucAtualiza = 0;
}
void InicializaRegistradores(void)
{
void InicializaRegistradores(void);
unsigned char ucAtualiza = 0;
unsigned char ucGFlag = 0;
unsigned int uiGLarguraPulso;
TH1 = 0;
TL1 = 0; // Zera regustradores utilizados na medida
EX1 = 1; // Liga a interrupção externa 0
ucGFlag = 0;
TR1 = 1;
}
void main()
{
unsigned char ucLByte;
PWDisplayInicializa();
PWDisplayLimpa();
PWDisplayEscreveString("Largura = ",1,1); // Mostra mensagem na linha 1
InicializaRegistradores(); // Chama subrotina que inicializa registradores
ucAtualiza = 1;
while(1)
{
if(ucAtualiza)
{
PWEscreveComando(0x8A);
PWMostraIntxxxx(uiGLarguraPulso);
PWDisplayEscreveString("TH1=",2,1);
ucLByte = TH1;
PWMostraCharxxx(ucLByte);
PWDisplayEscreveString("TL1=",2,9);
ucLByte = TL1;
PWMostraCharxxx(ucLByte);
ucAtualiza = 0;
PWDelayms(400);
IE1 = 0;
EX1 = 1;
void InicializaRegistradores(void)
{
Exemplo:
PWDelayms(45); // Delay de 45 ms
Exemplo:
Exemplo:
PWDelay(3000); // Delay
Entrada: Nenhuma
Saida: Nenhuma
Exemplo:
PWDisplayInicializa(); // Inicializa o display
Exemplo:
Entrada: Nenhuma
Saida: Nenhuma
Exemplo:
Entrada: Nenhuma
Saida: Nenhuma
Exemplo:
Exemplo:
Exemplo:
Exemplo:
PWEscreveComando (0xC0); // Comando para posicionar o cursor na Linha 2 e
// Coluna 1
Descrição: Faz com que o cursor fique visível no LCD. Permite que o usuário visualize
a posição atual do cursor.
Entrada: Nenhuma
Saida: Nenhuma
Exemplo:
PWDisplayAtivaCursor(); // Ativa o cursor no LCD
Descrição: Faz com que o cursor fique invisível no LCD. O usuário não poderá
visualizar a posição atual do cursor.
Entrada: Nenhuma
Saida: Nenhuma
Exemplo:
PWDisplayDesativaCursor(); // Desativa o cursor no LCD
Exemplo:
Entrada: Nenhuma
Saida: Retorna 00h se nenhuma tecla foi pressionada ou o valor da tecla em ASCII
conforme a tecla que foi pressionada.
Exemplo:
Exemplo:
Exemplo:
PWConfiguraSerial8N1(3); // Programa na velocidade de 9600 bps.
Exemplo:
PWEnviaSerial(BuffDados,12 ); // Envia o conteúdo de BuffDados
Exemplo:
PWEnviaRecebeSerial(BuffDados,12,3 ); // Envia 12 bytes de BuffDados e
// armazena 3 bytes de retorno em
// BuffDados.
Exemplo:
PWBinToASCII ( Byte,1,1 ); // Mostra o valor de Byte na linha 1 e coluna 1
Exemplo:
PWMostraCharxx(Byte); // Mostra o valor de Byte no LCD
Exemplo:
PWMostraCharxxx(Byte); // Mostra o valor de Byte no LCD
Exemplo:
PWMostraIntxxx(uiLValor); // Mostra o valor de uiLValor no LCD
Exemplo:
PWMostraIntxxxx(uiLValor); // Mostra o valor de uiLValor no LCD
Exemplo:
PWMostraIntxxxx(uiLValor); // Mostra o valor de uiLValor no LCD
Descrição: Mostra o conteúdo de uma variável word no formato decimal com duas
casas decimais na posição atual do display. Valor entre 00 e 99,99.
Entrada: Word que será mostrado no LCD. Valor dividido por 100
Saida: Nenhuma
Exemplo:
PWMostraIntxx_xx(1278); // Mostra o valor 12,78 no LCD
Descrição: Solicita a entrada de um valor com uma casa decimal. Retorna um valor
entre 0 e 255 ( 255 / 10 ). Anula limpa valor e solicita nova entrada.
Exemplo:
ucLByte = PWEntraCharx_x(1,4); // Aguarda o usuário digital o valor
Descrição: Solicita a entrada de um valor com uma casa decimal. Retorna um valor
entre 0 e 255 ( 255 / 100 ). Anula limpa valor e solicita nova entrada.
Exemplo:
ucLByte = PWEntraCharxx_x(1,4); // Aguarda o usuário digital o valor
Descrição: Solicita a entrada de um valor com duas casas. Retorna um valor entre 0 e
99. Anula limpa valor e solicita nova entrada.
Exemplo:
ucLByte = PWEntraCharxx(1,4); // Aguarda o usuário digital o valor
10.30) unsigned char PWEntraCharxxx(unsigned char, unsigned char)
Descrição: Solicita a entrada de um valor com três casas. Retorna um valor entre 0 e
255. Anula limpa valor e solicita nova entrada.
Exemplo:
ucLByte = PWEntraCharxxx(1,4); // Aguarda o usuário digital o valor
Descrição: Solicita a entrada de um valor com três casas. Retorna um valor entre 0 e
999. Anula limpa valor e solicita nova entrada.
Exemplo:
uiLValor = PWEntraIntxxx(1,4); // Aguarda o usuário digital o valor
Descrição: Solicita a entrada de um valor com três casas. Retorna um valor entre 0 e
9999. Anula limpa valor e solicita nova entrada.
Exemplo:
uiLValor = PWEntraIntxxxx(1,4); // Aguarda o usuário digital o valor
Descrição: Solicita a entrada de um valor com três casas. Retorna um valor entre 0 e
.65535 Anula limpa valor e solicita nova entrada.
Exemplo:
uiLValor = PWEntraIntxxxx(1,4); // Aguarda o usuário digital o valor
Descrição: Solicita a entrada de um valor com duas casas decimais. Retorna um valor
entre 0 e 9999. Anula limpa valor e solicita nova entrada.
Exemplo:
uiLValor = PWEntraIntxx_xx(1,4); // Aguarda o usuário digital o valor
Se o usuário digitar 76,25, o valor de uiLValor será 7625 sem vírgulas.