Sistemas Operacionais de Tempo Real - Alguns Periféricos

Por
Henrique Frank Werner Puhlmann
-
sistemas operacionais de tempo real
Este post faz parte da série Sistemas Operacionais de Tempo Real. Leia também os outros posts da série:

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.

 

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.

 

Cat24CXX_1
Figura 1: Diagrama funcional da EEPROM serial CAT24CXX

 

 

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.

 

ADC0838
Figura 2: Aplicação típica do ADC 0838

 

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.

 

AD7730_1
Figura 3: Aplicação típica do conversor AD7730

 

 

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.

 

DS1820
Figura 4: Detalhes do componente DS 1820

 

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

 

 

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.

 

Referências

http://www.onsemi.com/pub_link/Collateral/CAT24C01-D.PDF

http://www.ti.com/lit/ds/symlink/adc0838-n.pdf

http://www.analog.com/media/en/technical-documentation/data-sheets/AD7730_7730L.pdf

http://www.systronix.com/Resource/ds1820.pdf

 

 

Outros artigos da série

<< Sistemas Operacionais de Tempo Real - Teclados Matriciais
Este post faz da série Sistemas Operacionais de Tempo Real. Leia também os outros posts da série:
NEWSLETTER

Receba os melhores conteúdos sobre sistemas eletrônicos embarcados, dicas, tutoriais e promoções.

Obrigado! Sua inscrição foi um sucesso.

Ops, algo deu errado. Por favor tente novamente.

Fique tranquilo, também não gostamos de spam.

Licença Creative Commons Esta obra está licenciada com uma Licença Creative Commons Atribuição-CompartilhaIgual 4.0 Internacional.

1
Deixe um comentário

avatar
 
1 Comment threads
0 Thread replies
0 Followers
 
Most reacted comment
Hottest comment thread
1 Comment authors
Caio Pereira Recent comment authors
  Notificações  
recentes antigos mais votados
Notificar
Caio Pereira
Visitante
Caio Pereira

Parabéns Henrique!
Um artigo no estilo "Embedded System Building Blocks" Brasileiro! muito legal! Abraços

Você deve estar autenticado para votar0Você deve estar autenticado para votar  Responder
4 anos atrás