Este post faz parte da série Sistemas Operacionais de Tempo Real
Introdução
Este artigo é o último da série sobre rotinas padronizadas, desenvolvidas em C, para o sistema MCS-51 (8051) e para serem compilados no programa da Keil. Nesse contexto é necessário lembrar que o microcontrolador 8051 não possui em seu hardware muitas interfaces dedicadas e de certa forma autônomas para conexão com periféricos externos. Considerando isso, as rotinas dessa biblioteca realizam o acesso diretamente através dos pinos (bits) dos Ports do microcontrolador e a temporização desses procedimentos fica sendo definida implicitamente pelo clock da CPU ou pelos ciclos de máquina das instruções.
As arquiteturas mais modernas de microcontroladores já possuem hardwares dedicados para a implementação de barramentos de comunicação I2C, saídas PWM, entre outras, o que melhora o rendimento da execução do seu software embarcado, por conta do paralelismo das operações.
As rotinas apresentadas aqui, não são rotinas de tempo real propriamente ditas, mas funcionam bem como rotinas padronizadas, que podem ser utilizadas em ambientes de tempo real. São rotinas para o acesso a EEPROM serial, aos conversores A/D ADC0838 e AD7730 e ao sensor de temperatura DS1820.
Descrição das Rotinas
As rotinas que serão detalhadas a seguir foram desenvolvidas seguindo as sugestões apresentadas no artigo Boas práticas para o desenvolvimento de software – Parte I no que diz respeito a encapsular algumas funções de acesso aos periféricos.
Os Melhores Treinamentos sobre Sistemas embarcados e IoT
Cursos com professores qualificados para acelerar sua carreira e projetos
Rotinas para memórias seriais do tipo EEPROM
A EEPROM serial modelo NM24CXX da Fairchild, que já está obsoleta, mas pode ser substituída pelo componente CAT24CXX da ON Semiconductor. Na Figura 1, pode-se observar o diagrama funcional da EEPROM serial.
Definições
O trecho de código a seguir pode ser inserido num arquivo de definições do tipo *.h.
//******************************************************************************* //* * //* ROTINAS PADRONIZADAS PARA USO EM APLICAÇÕES * //* DE SISTEMAS MICROCONTROLADOS (FAMÍLIA 8051) * //* (Resp. Engenheiro Puhlmann) * //* * //* (06/07/2001 - Rev. 06/07/2001) * //* * //******************************************************************************* //=============================================================================== //= = //= ROTINAS REFERENTES AO ACESSO À EEPROM SERIAL DO TIPO NM24Cxx = //= = #define DESLIGA 0 #define LIGA 1 //**** INTERFACE COM A EEPROM SERIAL **** #define SCL P2_6 // Porta e bit onde está conectado este sinal #define SDA P2_5 // Porta e bit onde está conectado este sinal #define ENDERECO_EEPROM_ESCREVE 0xa0 // 1 0 1 0 - 0 0 0 - 0 Write no endereço 0 #define ENDERECO_EEPROM_LE 0xa1 // 1 0 1 0 - 0 0 0 - 1 READ no endereço 0 #define MARCA_0 0xa5 // As marcas são utilizadas mara informar se a EEPROM já foi gravada #define MARCA_1 0xc3 // #define ERRO_DE_COMUNICACAO_EEPROM 0x01 // Codigo de erro correspondente a alguma falha de comunicação com a EEPROM bit fFlagDeErro = DESLIGA; // Bit para sinalizar algum erro //**** PARAMETROS E VARIAVEIS DOS TIMERS DE SOFTWARE **** // Timer de 10 ms para a EEPROM #define TEMPO_DE_FIM_DE_ACESSO_EEPROM 10.0e-3 // (s) // Parametro abaixo calculado em função da freqüência de interrupção do timer principal #define CONST_TEMPORIZADOR_10ms (char)(TEMPO_DE_FIM_DE_ACESSO_EEPROM * FREQUENCIA_DE_INTERRUPCAO_TIMER_0) unsigned char ucContadorTimerEEPROM; bit fFlagFinalDeContagemTimerEEPROM;
Observe que no trecho de código acima foram definidos um contador ucContadorTimerEEPROM, que deverá ser inserido na rotina de interrupção do timer principal, uma constante de inicialização e um bit de sinalização para indicar ao processo no loop principal que a temporização terminou. Esse recurso permite uma temporização virtual de 10 ms e é explicado em detalhes no artigo Sistemas Operacionais de Tempo Real – Timers.
Rotina do Timer de 10 ms
//=======================================================================
//
// Rotina vTimer_10ms
//
// Descrição: Espera 10 ms
//
//
//=======================================================================
void vTimer_10ms(void)
{
ucContadorTimerEEPROM = CONST_TEMPORIZADOR_10ms; // Inicializa contador
fFlagFinalDeContagemTimerEEPROM = DESLIGA; // Inicializa flag
while(fFlagFinalDeContagemTimerEEPROM == DESLIGA); // Espera Passar o tempo
}
Rotina de escrita da EEPROM
//============================================================================================
//
// Rotina vEscreveE2PROM -Escreve Um dado para a EEPROM serial
//
// Entrada: - Ponteiro para o string terminado com 0 a ser transmitido a partir da RAM interna
// Saida : - Nenhuma
//
//============================================================================================
void vEscreveE2PROM(unsigned char nEndereco, unsigned char nDado)
{
unsigned char nIndice, chAux;
fFlagDeErro = DESLIGA;
// Gera o "Start"
SCL = LIGA;
SDA = DESLIGA;
SDA = DESLIGA; // Espera um tempinho
SCL = DESLIGA;
// Envia a Identificação do dispositivo (1 0 1 0) + Endereço da página (0 0 0)
chAux = ENDERECO_EEPROM_ESCREVE;
for (nIndice = 8; nIndice > 0; nIndice--)
{
SDA = chAux & 0x80; // Transmite 1 bit do endereço
SDA = chAux & 0x80; // Espera um tempinho
SCL = LIGA;
chAux = chAux << 1; // Posiciona o bit de endereço
SCL = DESLIGA;
}
// Verifica "Ack"
SDA = LIGA; // Força a saida em 1
SDA = LIGA; // Espera um tempinho
SCL = LIGA;
if(SDA != DESLIGA)
{
// vErro(); // Se não deu "Ack", trata o erro
}
SDA = LIGA; // Gasta algum tempo
SCL = DESLIGA;
// Inicia a transmissão do endereço
for (nIndice = 8; nIndice > 0; nIndice--)
{
SDA = nEndereco & 0x80; // Transmite 1 bit do endereço
SDA = nEndereco & 0x80; // Espera um tempinho
SCL = LIGA;
nEndereco = nEndereco << 1; // Posiciona o bit de endereço
SCL = DESLIGA;
}
// Verifica "Ack"
SDA = LIGA; // Força a saida em 1
SDA = LIGA; // Espera um tempinho
SCL = LIGA;
if(SDA != DESLIGA)
{
// vErro(); // Se não deu "Ack", trata o erro
}
SDA = LIGA; // Gasta algum tempo
SCL = DESLIGA;
// Inicia a transmissão do dado
for (nIndice = 8; nIndice > 0; nIndice--)
{
SDA = nDado & 0x80; // Transmite 1 bit do dado
SDA = nDado & 0x80; // Espera um pouquinho
SCL = LIGA;
nDado = nDado << 1; // Posiciona o bit do dado
SCL = DESLIGA;
}
// Verifica "Ack"
SDA = LIGA; // Força a saida em 1
SDA = LIGA; // Força a saida em 1
SCL = LIGA;
SDA = LIGA; // Gasta algum tempo
SCL = DESLIGA;
// Gera o "STOP"
SDA = DESLIGA;
SDA = DESLIGA;
SCL = LIGA;
SCL = LIGA;
SDA = LIGA;
vTimer_10ms();
}
Rotina de leitura na EEPROM
//==================================================================================
//
// Rotina vLeE2PROM - Le um dado da EEPROM serial (Endereço ramdomico)
//
// Entradas: - Endereço do primeiro byte a ser lido
// - Ponteiro para a area de RAM que receberá os dados
// Saidas : - Dado lido
//
//==================================================================================
void vLeE2PROM(char nEnderecoInicialE2PROM, char *pPonteiroRAM)
{
char nIndice, chAux;
unsigned char nDado;
fFlagDeErro = DESLIGA;
// GEra o Start
SCL = LIGA;
SDA = DESLIGA;
SDA = DESLIGA; // Espera um tempinho
SCL = DESLIGA;
// Envia a Identificação do dispositivo (1 0 1 0) + Endereço da página (0 0 0)
chAux = ENDERECO_EEPROM_ESCREVE;
for (nIndice = 8; nIndice > 0; nIndice--)
{
SDA = chAux & 0x80; // Transmite 1 bit do endereço
SDA = chAux & 0x80; // Espera um tempinho
SCL = LIGA;
chAux = chAux << 1; // Posiciona o bit de endereço
SCL = DESLIGA;
}
// Verifica "Ack"
SDA = LIGA; // Força a saida em 1
SDA = LIGA; // Espera um tempinho
SCL = LIGA;
if(SDA != DESLIGA)
{
// vErro(); // Se não deu "Ack", trata o erro
}
SDA = LIGA; // Gasta algum tempo
SCL = DESLIGA;
// Inicia a transmissão do endereço
for (nIndice = 8; nIndice > 0; nIndice--)
{
SDA = nEnderecoInicialE2PROM & 0x80; // Transmite 1 bit do endereço
SDA = nEnderecoInicialE2PROM & 0x80; // Gasta algum tempo
SCL = LIGA;
nEnderecoInicialE2PROM = nEnderecoInicialE2PROM << 1; // Posiciona o bit de endereço
SCL = DESLIGA;
}
// Verifica "Ack"
SDA = LIGA; // Força a saida em 1
SDA = LIGA; // Espera um tempinho
SCL = LIGA;
if(SDA != DESLIGA)
{
// vErro(); // Se não deu "Ack", trata o erro
}
SDA = LIGA; // Gasta algum tempo
SCL = LIGA;
SCL = DESLIGA;
SCL = DESLIGA;
SCL = DESLIGA;
SCL = DESLIGA;
SCL = LIGA;
// GEra o Start
SCL = LIGA;
SDA = DESLIGA;
SDA = DESLIGA; // Espera um tempinho
SCL = DESLIGA;
// Envia a Identificação do dispositivo (1 0 1 0) + Endereço da página (0 0 0)
chAux = ENDERECO_EEPROM_LE;
for (nIndice = 8; nIndice > 0; nIndice--)
{
SDA = chAux & 0x80; // Transmite 1 bit do endereço
SDA = chAux & 0x80; // Espera um tempinho
SCL = LIGA;
chAux = chAux << 1; // Posiciona o bit de endereço
SCL = DESLIGA;
}
// Verifica "Ack"
SDA = LIGA; // Força a saida em 1
SDA = LIGA; // Espera um tempinho
SCL = LIGA;
if(SDA != DESLIGA)
{
// vErro(); // Se não deu "Ack", trata o erro
}
SDA = LIGA; // Gasta algum tempo
SCL = DESLIGA;
SCL = DESLIGA;
// Inicia a recepção do dado
nDado = 0;
for (nIndice = 8; nIndice > 0; nIndice--)
{
nDado = nDado << 1; // Posiciona o bit do dado
SDA = LIGA;
SCL = LIGA;
SDA = LIGA;
SCL = LIGA;
nDado |= SDA; // Recebe um 1 bit do dado
SCL = DESLIGA;
}
*pPonteiroRAM++ = nDado; // Atualiza o dado
// Verifica "Ack"
SDA = LIGA; // Força a saida em 1
SDA = LIGA; // Força a saida em 1
SCL = LIGA;
SDA = LIGA; // Gasta algum tempo
SCL = DESLIGA;
// Gera o "STOP"
SDA = DESLIGA;
SDA = DESLIGA;
SCL = LIGA;
SCL = LIGA;
SDA = LIGA;
vTimer_10ms();
}
//===============================================================================
//========================= Fim das rotinas da EEPROM ===========================
Rotinas para acesso ao conversor A/D ADC0838
O conversor ADC0838 é um conversor A/D de 8 bits que possui um multiplexador de 8 canais na entrada do conversor. É um componente eletrônico muito robusto e versátil. Na Figura 2, pode-se observar uma aplicação típica para esse componente.
Definições
O trecho de código a seguir pode ser inserido num arquivo de definições do tipo *.h.
//******************************************************************************* //* * //* ROTINAS PADRONIZADAS PARA USO EM APLICAÇÕES * //* DE SISTEMAS MICROCONTROLADOS (FAMÍLIA 8051) * //* (Resp. Engenheiro Puhlmann) * //* * //* (06/07/2001 - Rev. 06/07/2001) * //* * //******************************************************************************* //=============================================================================== //= = //= ROTINAS REFERENTES AO ACESSO AO CONVERSOR A/D ADC0838 da National Semi. = //= = //**** Conversor A/D ***** #define CS_CONVERSOR_AD P2_4 // Chip Select #define SCLCK_CONVERSOR_AD P2_3 // Clock do A/D #define DIN_CONVERSOR_AD P2_1 // DOUT DO Conversor A/D #define DOUT_CONVERSOR_AD P2_2 // DIN do conversor A/D #define STATUS_AD P0_2 // Status bit fFlagStatusExisteAD; // Bit Para sinalizar a existência do A/D
Rotina de leitura do ADC0838
//==================================================================================
//
// Rotina uchLe_AD - Seta o endereço do multiplexador do AD e lê a entrada
//
//==================================================================================
unsigned char uchLe_AD(char chEnderecoMuxAD)
{
unsigned char uchAux, uchIndice;
// Inicializa o MUX do conversor A/D
uchAux = chEnderecoMuxAD; /// Transfere o endereço para uma variável
// Gera o Start Bit
DOUT_CONVERSOR_AD = LIGA;
SCLCK_CONVERSOR_AD = DESLIGA;
CS_CONVERSOR_AD = DESLIGA;
SCLCK_CONVERSOR_AD = LIGA;
SCLCK_CONVERSOR_AD = DESLIGA;
// Sinaliza que tem entradas unipolares
SCLCK_CONVERSOR_AD = LIGA;
SCLCK_CONVERSOR_AD = DESLIGA;
// Verifica se é endereço par ou ímpar
if((uchAux & 0x01) == 0)
{
// Endereço par
DOUT_CONVERSOR_AD = DESLIGA;
}
else
{
// Endereço ímpar
DOUT_CONVERSOR_AD = LIGA;
}
// Gera o Clock
SCLCK_CONVERSOR_AD = LIGA;
SCLCK_CONVERSOR_AD = DESLIGA;
// Transmite o bit mais significativo do endereço
if((uchAux & 0x04) == 0)
{
DOUT_CONVERSOR_AD = DESLIGA;
}
else
{
DOUT_CONVERSOR_AD = LIGA;
}
// Gera o Clock
SCLCK_CONVERSOR_AD = LIGA;
SCLCK_CONVERSOR_AD = DESLIGA;
// Transmite o segundo bit do endereço
if((uchAux & 0x02) == 0)
{
DOUT_CONVERSOR_AD = DESLIGA;
}
else
{
DOUT_CONVERSOR_AD = LIGA;
}
// Gera o Clock
SCLCK_CONVERSOR_AD = LIGA;
SCLCK_CONVERSOR_AD = DESLIGA;
// Espera estabilizar os Multiplexadores
SCLCK_CONVERSOR_AD = LIGA;
SCLCK_CONVERSOR_AD = DESLIGA;
// inicia a leitura dos dados
uchAux = 0;
for(uchIndice = 8; uchIndice > 0; uchIndice--)
{
uchAux = uchAux << 1;
// Gera o Clock
SCLCK_CONVERSOR_AD = LIGA;
if(DIN_CONVERSOR_AD != 0)
{
uchAux |= 1;
}
SCLCK_CONVERSOR_AD = DESLIGA;
}
// Descarta os oito bits restantes
for(uchIndice = 7; uchIndice > 0; uchIndice--)
{
// Gera o Clock
SCLCK_CONVERSOR_AD = LIGA;
SCLCK_CONVERSOR_AD = DESLIGA;
}
// Desliga o conversor A/D e encerra a conversão
CS_CONVERSOR_AD = LIGA;
return(uchAux);
}
//===============================================================================
//========== Fim das rotinas do CONVERSOR A/D ADC0838 ===========================
Rotinas para o conversor A/D AD7730
O conversor A/D AD7730 é um componente de grande precisão e ideal para a medição de sinais extraídos de pontes de strain gages, mais especificamente para a aplicação em balanças de precisão. Algumas características desse componente:
- Conversor sigma-delta de 24 bits;
- Resolução de até 1/230.000;
- Medidas razométricas com relação à fonte;
- Filtro digital programável;
- Etc.
Na Figura 3 pode ser observada uma aplicação típica desse componente e alguns módulos internos.
Para se aprofundar nos conceitos de medidas em ponte, recomendo a leitura do artigo técnico Ponte de Wheatstone.
Definições
O trecho de código a seguir pode ser inserido num arquivo de definições do tipo *.h.
//===============================================================================
//= =
//= ROTINAS REFERENTES AO ACESSO AO CONVERSOR A/D AD7730 da Analog Devices =
//= =
// INTERFACE COM O CONVERSOR A/D
#define SYNC_AD_ACTVL P1_2
#define RESET_AD_ACTVL P1_3
#define STDBY_AD_ACTVL P1_4
#define DATA_OUT_AD P1_6
#define DATA_IN_AD P1_5
#define SER_CLK_AD P1_7
#define READY_ACTVL P3_2
#define ENDERECO_DO_REGISTRO_DE_OFFSET 0x05
#define COMANDO_LEITURA_DE_OFFSET 0x15
#define ENDERECO_DO_REGISTRO_DE_GANHO 0x06
#define COMANDO_LEITURA_DE_GANHO 0x16
#define ENDERECO_DO_REGISTRO_DE_FILTRO 0x03
#define COMANDO_DO_FILTRO 0x5d7030
#define NUMERO_DE_INTERRUPCOES 69
#define ENDERECO_DO_REGISTRO_DE_DAC 0x04
#define COMANDO_DO_DAC 0x00 // 0.0 mV
#define ENDERECO_DO_REGISTRO_DE_MODO 0x02
// Referência em 5V e canal A1
#define COMANDO_DO_MODO_CALIBRACAO_FULL_SCALE 0xe1B0
// Calibração de fundo de escala
// Escala Bipolar de -80 a +80 mV
#define COMANDO_DO_MODO_CALIBRACAO_ZERO_SCALE 0x81B0
// Calibração de zero de escala
// Escala Bipolar de -80 a +80 mV
#define COMANDO_DO_MODO_CALIBRACAO_ZERO_SCALE_SISTEMA 0xc1B0
// Calibração de zero de escala
// Escala Bipolar de -80 a +80 mV
#define COMANDO_DO_MODO_LEITURA_CONTINUA 0x21B0
// Leitura Continua
// Escala Bipolar de -80 a +80 mV
#define COMANDO_DO_MODO_LEITURA_UNICA 0x41B0
// Leitura "single"
// Escala Bipolar de -80 a +80 mV
#define LEITURA_CONTINUA 0x21
#define LEITURA_UNICA 0x11
#define PARADA_DE_LEITURA 0x30
#define RESETA_COMUNICACAO 0xfffff
#define OITO_BITS 8
#define DEZESSEIS_BITS 16
#define VINTE_E_QUATRO_BITS 24
#define TRINTA_E_TRES_BITS 33
#define VALOR_DE_ZERO_NOMINAL 0x800000
Rotina para escrever uma palavra no AD7730
//=================================================================================
//
// Rotina vEscreveAD7730 Escreve uma palavra para o conversor AD7730
//
// Entradas: - Palavra a ser escrita no conversor A/D
// - Tamanho da palavra
// Saída: - Nenhuma
//
//=================================================================================
void vEscreveAD7730(unsigned long int lnComandoAD, char nBits)
{
int nIndice;
unsigned long int lnMascara;
// Prepara a mascara
lnMascara = (((unsigned long)0x01) << (nBits-1));
// Loop de geração de 8 bits
for(nIndice = nBits; nIndice > 0; nIndice--)
{
SER_CLK_AD = DESLIGA;
// Testa o bit do dado a ser enviado
if((lnComandoAD & lnMascara) != DESLIGA)
{
DATA_OUT_AD = LIGA;
}
else
{
DATA_OUT_AD = DESLIGA;
}
// Gera a transicao do clock
SER_CLK_AD = LIGA;
// Posiciona o proximo bit
lnComandoAD = lnComandoAD << 1;
}
SER_CLK_AD = DESLIGA;
DATA_OUT_AD = DESLIGA;
}
Rotina para ler dados do AD7730
//=======================================================================
//
// Rotina uchLeAD7730 - Le os dados convertidos do conversor AD7730
//
// Entradas: - Ponteiro para o buffer de recepcão
// Saída: - Nenhuma
//
//=======================================================================
void uchLeAD7730(unsigned char *uchBufferAD)
{
unsigned char uchDadoAD;
unsigned char uchIndice0, uchIndice1;
// Aguarda a confirmação do fim de conversão (5s)
bTestaRdyDoAd(CTE_5s);
// Permite a leitura da entrada
DATA_IN_AD = LIGA;
for (uchIndice0 = 3; uchIndice0 > 0; uchIndice0--)
{
// Inicializa o buffer de bits
uchDadoAD = 0;
for (uchIndice1 = 8; uchIndice1 > 0; uchIndice1--)
{
// Gera a transicao do clock
SER_CLK_AD = LIGA;
// Desloca o acumulador de bits
uchDadoAD = uchDadoAD << 1;
// Le o bit do dado
uchDadoAD |= DATA_IN_AD ;
// Gera a transicao do clock
SER_CLK_AD = DESLIGA;
}
*uchBufferAD++ = uchDadoAD;
}
}
Rotina para verificar se há dados disponíveis
//=======================================================================
//
// Rotina bTestaRdyDoAd
//
// Descrição: Temporiza a resposta do recepção do sinal de RDY do AD
//
// Entrada: Numero de 10 ms a serem esperados
//
//=======================================================================
void bTestaRdyDoAd(int n10MiliSegundos)
{
bit bFlag;
bFlag = DESLIGA; // Inicializa flag
while((n10MiliSegundos-- > 0) && (bFlag == DESLIGA))
{
TL0 = CTE_RELOGIO_10ms_LOW; // Inicializa o Timer para gerar 100 ms
TH0 = CTE_RELOGIO_10ms_HIGH;
TF0 = DESLIGA; // Reseta flag
TR0 = LIGA; // Liga o timer
while(TF0 == DESLIGA); // Espera completar os 100ms
TR0 = DESLIGA; // Desliga o timer
if (P3_2 == DESLIGA)
{
bFlag = LIGA; // Sinaliza que recebeu o RDY do AD
}
}
if (bFlag == DESLIGA)
{
TR0 = DESLIGA; // Desliga o timer
vErro(ERRO_DE_COMUNICACAO_AD);
}
}
Exemplo de rotina de interrupção gerada pelo conversor AD7730
//*********************************************************************************************
//
// Rotina de interrupção do conversor A/D (exemplo)
//
//*********************************************************************************************/
void vInterrupcaoAD() interrupt 0
{
unsigned char uchIndice0;
register char chRegAux;
long *plAux;
// Permite a leitura da entrada
DATA_IN_AD = LIGA;
// Inicializa o acumulador
chRegAux = 0;
chNovoDadoAD[0] = 0;
for (uchIndice0 = 8; uchIndice0 > 0; uchIndice0--)
{
// Gera a transicao do clock
SER_CLK_AD = LIGA;
// Desloca o acumulador de bits
chRegAux = chRegAux << 1;
// Gera a transicao do clock
SER_CLK_AD = DESLIGA;
// Le o bit do dado
chRegAux |= DATA_IN_AD;
}
chNovoDadoAD[1] = chRegAux;
for (uchIndice0 = 8; uchIndice0 > 0; uchIndice0--)
{
// Gera a transicao do clock
SER_CLK_AD = LIGA;
// Desloca o acumulador de bits
chRegAux = chRegAux << 1;
// Gera a transicao do clock
SER_CLK_AD = DESLIGA;
// Le o bit do dado
chRegAux |= DATA_IN_AD;
}
chNovoDadoAD[2] = chRegAux;
for (uchIndice0 = 8; uchIndice0 > 0; uchIndice0--)
{
// Gera a transicao do clock
SER_CLK_AD = LIGA;
// Desloca o acumulador de bits
chRegAux = chRegAux << 1;
// Gera a transicao do clock
SER_CLK_AD = DESLIGA;
// Le o bit do dado
chRegAux |= DATA_IN_AD;
}
chNovoDadoAD[3] = chRegAux;
fPermissaoParaCalculoAD = LIGA; // SInaliza que ocorreu uma interrupão do A/D
}
//===============================================================================
//========== Fim das rotinas do CONVERSOR A/D AD7730 ===========================
Rotinas para o termômetro digital DS1820
O termômetro DS1820 é um componente com boa precisão, incrementos de 0,5ºC na faixa de medição de temperaturas entre -55º a +125ºC. Como pode ser observado na Figura 4, trata-se de um termômetro digital, compacto com a interface de comunicação 1-wire (um único fio). Esse componente já está obsoleto e não há reposição direta.
Definições
O trecho de código a seguir pode ser inserido num arquivo de definições do tipo *.h.
//=============================================================================== //= = //= ROTINAS REFERENTES AO ACESSO AO Sensor de Temperatura DS1820 da Dallas = //= = // INTERFACE COM O SENSOR DE TEMPERATURA #define DQ P1_1 #define TEMPO_MINIMO_RESET 480.0e-6 // s #define TEMPO_DE_ESPERA_MINIMO 15.0e-6 // s #define TEMPO_DE_ESPERA_ESCRITA 45.0e-6 // s #define TEMPO_DE_ESPERA_ESCRITA_1B 55.0e-6 // s #define TEMPO_DE_ESPERA_LEITURA 8.0e-6 // s #define TEMPO_DE_ESPERA_ESCRITA_1 5.0e-6 // s #define TEMPO_DE_ESPERA_PRESENCA 240.0e-6 // s #define PERIODO_PADRAO_DE_TIME_OUT 255 #define PERIODO_RESET_TEMPERATURA_480u (int)((FREQUENCIA_OSCILADOR * TEMPO_MINIMO_RESET)/(12.0 * 2.0)) #define PERIODO_DE_ESPERA_5u (int)((FREQUENCIA_OSCILADOR * TEMPO_DE_ESPERA_ESCRITA_1)/(12.0 * 2.0)) - 2 #define PERIODO_DE_ESPERA_8u (int)((FREQUENCIA_OSCILADOR * TEMPO_DE_ESPERA_LEITURA)/(12.0 * 2.0)) #define PERIODO_DE_ESPERA_15u (int)((FREQUENCIA_OSCILADOR * TEMPO_DE_ESPERA_MINIMO)/(12.0 * 2.0)) #define PERIODO_DE_ESPERA_45u (int)((FREQUENCIA_OSCILADOR * TEMPO_DE_ESPERA_ESCRITA)/(12.0 * 2.0)) #define PERIODO_DE_ESPERA_55u (int)((FREQUENCIA_OSCILADOR * TEMPO_DE_ESPERA_ESCRITA_1B)/(12.0 * 2.0)) #define PERIODO_DE_ESPERA_PRESENCA (int)((FREQUENCIA_OSCILADOR * TEMPO_DE_ESPERA_PRESENCA)/(12.0 * 2.0)) #define MULTIPLICADOR_DE_TIME_OUT 3 // Vezes 255 // Sensor de temperatura #define NUMERO_DE_MEDIAS_DE_TEMPERATURA 4 // Potência de 2 #define MASCARA_DO_INDICE_DE_TEMPERATURA (NUMERO_DE_MEDIAS_DE_TEMPERATURA - 1) int idata nBufferDeLeiturasDeTemperatura[NUMERO_DE_MEDIAS_DE_TEMPERATURA]; unsigned char uchIndiceBufferDeTemperatura; int nValorMedioDeTemperatura; unsigned char uchContadorDeInterrupcoes;
Rotina para aguardar n vezes 10 ms
//=======================================================================
//
// Rotina vTimer_10ms
//
// Descrição: Espera múltiplos de 10 ms
//
// Entrada: Numero de 10 ms a serem esperados
//
//=======================================================================
void vTimer_10ms(int n10MiliSegundos)
{
while(n10MiliSegundos-- > 0)
{
TL0 = CTE_RELOGIO_10ms_LOW; // Inicializa o Timer para gerar 100 ms
TH0 = CTE_RELOGIO_10ms_HIGH;
TF0 = DESLIGA; // Reseta flag
TR0 = LIGA; // Liga o timer
while(TF0 == 0); // Espera completar os 100ms
TR0 = DESLIGA; // Desliga o timer
}
}
Rotina para gerar Reset no Bus do DS1820
//=======================================================================
//
// Gera o Reset no Bus do DS1820, e espera receber o sinal de que o Sensor está presente
//
// Entradas: Endereço do primeiro byte a ser lido
// Numero de bytes a serem transferidos
// Ponteiro para a area de RAM que receberá os dados
// Saidas : Dado lido
//
//=======================================================================
void vResetaSensorDeTemperatura(void)
{
unsigned char chAux, chAux2;
bit fFlag, fFlagAux;
EA = DESLIGA; // Desabilita todas as interrupções habilitadas
chAux = PERIODO_RESET_TEMPERATURA_480u;
// Coloca a linha em zero
DQ = DESLIGA;
// Espera os 480 us
while(chAux > 0)
{
chAux--;
}
// Libera a linha
DQ = LIGA;
chAux = PERIODO_DE_ESPERA_15u;
chAux2 = MULTIPLICADOR_DE_TIME_OUT;
fFlag = DESLIGA;
fFlagAux = DESLIGA;
while((chAux2-- > 0) && (fFlag == DESLIGA))
{
while((fFlag == DESLIGA) && (chAux-- > 0))
{
// Espera até 15us da primeira vez para a linha subir para 1, ou até time-out
if(DQ == LIGA)
{
// Foi para 1
fFlag = LIGA;
}
}
if((chAux2 == (MULTIPLICADOR_DE_TIME_OUT-1)) && (fFlag == LIGA))
{
// Sinaliza que detetou 1 nos primeiros 15 us
fFlagAux = LIGA;
}
chAux = PERIODO_PADRAO_DE_TIME_OUT;
}
// Testa se deu time-out
if(fFlag == DESLIGA)
{
vErro(0x01);
}
// Testa se foi saida normal
if(fFlagAux == LIGA)
{
// Se normal, espera o sensor retirar o sinal de presença
chAux = PERIODO_DE_ESPERA_PRESENCA;
fFlag = DESLIGA;
while((fFlag == DESLIGA) && (chAux-- > 0))
{
// Espera até 15us da primeira vez para a linha subir para 1, ou até time-out
if(DQ == LIGA)
{
// Foi para 1
fFlag = LIGA;
}
}
// Testa se deu time-out
if(fFlag == DESLIGA)
{
vErro(0x01);
}
}
EA = LIGA; // Habilita todas as interrupções
}
Rotina para escrever no DS1820
//============================================================================================
//
// Rotina vEscreveByteNoSensorDeTEmperatura
//
// Entrada: - Byte a ser enviado
// Saida : - Nenhuma
//
//============================================================================================
void vEscreveByteNoSensorDeTEmperatura(unsigned char nByte)
{
unsigned char chAux, chIndice;
EA = DESLIGA; // Desabilita todas as interrupções habilitadas
// PAra os 8 bits da palavra
for (chIndice = 8; chIndice > 0; chIndice--)
{
// Sinaliza o início de uma operação de escrita
DQ = DESLIGA;
// Transmite o bit menos significativo o byte...
DQ = nByte & 0x01;
nByte = nByte >> 1;
// Espera mais 55 us para completar o ciclo de escrita
chAux = PERIODO_DE_ESPERA_55u;
while(chAux > 0)
{
chAux--;
}
DQ = LIGA;
}
EA = LIGA; // Habilita todas as interrupções
}
Rotina para ler do DS1820
//============================================================================================
//
// Rotina chLeByteDoSensorDeTEmperatura
//
// Entrada: - Nenhuma
// Saida : - Byte lido do sensor
//
//============================================================================================
char chLeByteDoSensorDeTEmperatura(void)
{
unsigned char chAux, chIndice, chDadoLido;
EA = DESLIGA; // Desabilita todas as interrupções habilitadas
// Inicializa o dado a ser lido
chDadoLido = 0;
for (chIndice = 8; chIndice > 0; chIndice--)
{
// Sinaliza que pode iniciar a transferência do dado
DQ = DESLIGA;
DQ = DESLIGA;
DQ = LIGA;
// Espera 8 us antes de amostrar o sinal
chAux = PERIODO_DE_ESPERA_8u;
chDadoLido = chDadoLido >> 1;
chAux = DQ;
chDadoLido = chDadoLido | (chAux << 7);
// Espera mais 45 us para completar o ciclo de escrita
chAux = PERIODO_DE_ESPERA_45u;
while(chAux > 0)
{
chAux--;
}
}
EA = LIGA; // Habilita todas as interrupções
return(chDadoLido);
}
//===============================================================================
//========== Fim das rotinas do Sensor DS1820 ===================================
Resumo
Neste artigo técnico foram apresentadas algumas rotinas padronizadas, codificadas em C, para serem compiladas no programa da Keil. Essas rotinas permitem configurar e acessar alguns periféricos utilizando-se os microcontroladores da família MCS-51. Essas rotinas foram utilizadas em projetos reais e funcionam!
Este artigo é o quinto da série de artigos que abordam algumas funções comuns em projetos de sistemas embarcados de tempo real. Confira os demais artigos.
Sistemas Operacionais de Tempo Real
- Sistemas Operacionais de Tempo Real – Introdução – Apresentação introdutória do que é um sistema operacional e as características que o tornam um sistema de tempo real. Também são apresentadas algumas estruturas que facilitam o seu projeto.
Bibliotecas de funções e rotinas padronizadas em linguagem C para MCS-51
- Timers – É apresentada uma biblioteca desenvolvida em linguagem C para a inicialização e o uso dos Timers do MCS-51;
- Displays de 7 segmentos – É apresentada uma biblioteca desenvolvida em linguagem C para a inicialização e o uso em displays de 7 segmentos;
- Teclados Matriciais – É apresentada uma biblioteca desenvolvida em linguagem C para varredura, leitura, debounce, identificação da tecla acionada e desvio para a rotina de tratamento. A forma como as rotinas foram escritas, permitem sua fácil reutilização em outros projetos;
- Periféricos (este artigo) – É apresentada uma biblioteca desenvolvida em linguagem C para a inicialização e o uso de alguns periféricos, tais como conversores A/D, sensor de temperatura e memórias seriais.
Parabéns Henrique!
Um artigo no estilo “Embedded System Building Blocks” Brasileiro! muito legal! Abraços