Relatório 5 - Placa funcionando com o programa de piscar o LED

Este relatório tem por finalidade demonstrar os testes que foram realizados com a placa desenvolvida. Para isso foram realizados 5 projetos diferentes para piscar o led da placa, sendo que cada um destes projetos utilizam uma maneira diferente para realizar isso:

Projeto 1 - Rotina de atraso implementada por laço de espera ociosa e oscilador interno.

Projeto 2 - Rotina de atraso implementada por laço de espera ociosa e oscilador por cristal externo.

Projeto 3 - Atraso gerado pelo temporizador interno.

Projeto 4 - Atraso gerado pelo temporizador e tratado por interrupção.

Projeto 5 - Uso do módulo PWM interno com a saída ligada diretamente ao LED.

Todos os projetos foram implementados com auxílio do Processor Expert, disponível no ambiente de desenvolvimento CodeWarrior.

Projeto 1 e Projeto 2

Estes se encontram no relatório do aluno MarcusLaganá

Projeto 3

Neste projeto utilizou-se o Real Time Counter (RTC) interno para piscar o LED. Trata-se de um contador que sempre que estoura acontagem seta um flag que podemos verificar para saber quando a contagem terminou. O único incoveniente é que o flag precisa ser constantemente verificado conforme podemos perceber através do código do programa apresentado abaixo:

/************************************************************/
/* Programa para piscar o led usando o temporizador interno */
/* (TI1).                                                   */
/************************************************************/

/* Including needed modules to compile this module/procedure */
#include "Cpu.h"
#include "Events.h"
#include "TI1.h"
/* Include shared modules, which are used for whole project */
#include "PE_Types.h"
#include "PE_Error.h"
#include "PE_Const.h"
#include "IO_Map.h"

// Rotina Principal
void main(void)
{

  /*** Processor Expert internal initialization. DON'T REMOVE THIS CODE!!! ***/
  PE_low_level_init();
  /*** End of Processor Expert internal initialization ***/

  SOPT1 = 0b00000000;          // Desabilita Watchdog
  PTFDD_PTFDD7 = 1;            // PortF,Bit7 = Saida

  while(1)
  {
    RTCSC_RTIF = 1;            // Limpa o flag do RTC
    while (RTCSC_RTIF==0);      // Aguarda o estouro da contagem
    PTFD_PTFD7 = ~PTFD_PTFD7;   // Se terminou, inverte o LED
  }

  /*** Don't write any code pass this line, or it will be deleted during code generation. ***/
  /*** Processor Expert end of main routine. DON'T MODIFY THIS CODE!!! ***/
  for(;;){}
  /*** Processor Expert end of main routine. DON'T WRITE CODE BELOW!!! ***/
} /*** End of main routine. DO NOT MODIFY THIS TEXT!!! ***/

Na figura abaixo temos o código gerado pelo Processor Expert para configurar o Timer e que é chamada dentro da rotina de inicialização "PE_low_level_init()".

Rotina de configuração da operação do módulo RTC: RTC1_Init()

/media/Attachments/courseEA079_1S2010/Mfab_5/Imagem7.JPG

Projeto 4

A seguir temos o programa utilizado para piscar o LED utilizando o timer interno (TI1) e interrupção. Note que o Processor Expert permite que a subrotina para tratamento das interrupções de periféricos fiquem em um arquivo separado chamado Events.C, no entanto pode-se colocar o código diretamente no arquivo principal, conforme foi feito no programa representado abaixo:

/************************************************************/
/* Programa para piscar o led usando o temporizador interno */
/* (TI1) e interrupção.                                     */
/************************************************************/

/* Including needed modules to compile this module/procedure */
#include "Cpu.h"
#include "Events.h"
#include "TI1.h"
/* Include shared modules, which are used for whole project */
#include "PE_Types.h"
#include "PE_Error.h"
#include "PE_Const.h"
#include "IO_Map.h"

// Rotina para tratamento da interrupção do Timer
void TI1_OnInterrupt(void)
{

  PTFD_PTFD7 = ~PTFD_PTFD7; // Inverte o estado do LED

}

// Rotina Principal
void main(void)
{

  /*** Processor Expert internal initialization. DON'T REMOVE THIS CODE!!! ***/
  PE_low_level_init();
  /*** End of Processor Expert internal initialization ***/

  SOPT1 = 0b00000000;          // Desabilita Watchdog
  PTFDD_PTFDD7 = 1;            // PortF,Bit7 = Saida

  while(1){}                   // Espera infinita

  /*** Don't write any code pass this line, or it will be deleted during code generation. ***/
  /*** Processor Expert end of main routine. DON'T MODIFY THIS CODE!!! ***/
  for(;;){}
  /*** Processor Expert end of main routine. DON'T WRITE CODE BELOW!!! ***/
} /*** End of main routine. DO NOT MODIFY THIS TEXT!!! ***/

Esse método para gerar o atraso no piscar do LED permite que o período seja alterado diretamente por meio do período da interrupção, o que pode ser feito no Component Inspector do Timer, conforme mostra as duas figuras abaixo:

Janela de definições do Component Inspector para o Timer

/media/Attachments/courseEA079_1S2010/Mfab_5/Imagem3.JPG

Janela de edição do período de interrupção do Timer

/media/Attachments/courseEA079_1S2010/Mfab_5/Imagem4.JPG

Na figura abaixo temos a rotina de inicialização do Timer 1 e que foi gerada pelo Processor Expert e chama dentro da rotina de inicialização do sistema: "PE_low_level_init()".

Rotina de inicialização do Timer gerada pelo Processor Expert

/media/Attachments/courseEA079_1S2010/Mfab_5/imagem6.JPG

Projeto 5

Neste projeto o programa principal não faz absolutamente nada, já que o sinal que faz com o led pisque é gerado diretamente pelo módulo Timer/PWM. Para isso este módulo é configurado pelo processor expert na inicialização do sistema e não é necessário mais nenhuma rotina ou tarefa de software, já que o sinal é gerado via hardware.

A seguir temos o programa utilizado, onde se pode notar que o programa principal não realiza absolutamente nada:

/************************************************************/
/* Programa para piscar o led usando o temporizador interno */
/* (TI1) e interrupção.                                     */
/************************************************************/

/* Including needed modules to compile this module/procedure */
#include "Cpu.h"
#include "Events.h"
#include "TO1.h"
/* Include shared modules, which are used for whole project */
#include "PE_Types.h"
#include "PE_Error.h"
#include "PE_Const.h"
#include "IO_Map.h"


// Rotina Principal
void main(void)
{

  /*** Processor Expert internal initialization. DON'T REMOVE THIS CODE!!! ***/
  PE_low_level_init();
  /*** End of Processor Expert internal initialization ***/

  SOPT1 = 0b00000000;          // Desabilita Watchdog

  /*** Don't write any code pass this line, or it will be deleted during code generation. ***/
  /*** Processor Expert end of main routine. DON'T MODIFY THIS CODE!!! ***/
  for(;;){}
  /*** Processor Expert end of main routine. DON'T WRITE CODE BELOW!!! ***/
} /*** End of main routine. DO NOT MODIFY THIS TEXT!!! ***/

Na figura abaixo temos o código gerado pelo Processor Expert para configurar o TPM2 e que é chamada dentro da rotina de inicialização "PE_low_level_init()".

Rotina de configuração da operação do módulo Timer/PWM: TO1_InitTO()

/media/Attachments/courseEA079_1S2010/Mfab_5/Imagem5.JPG

Início do Projeto de Interface Serial RS232

Para adequar os níveis de tensão entre o PC e o microcontrolador utilizamos um CI MAX232, que possui saídas padrão TTL: 0V e +5V. Esse fato não traz problemas na conexão Microcontrolador - MAX232, mas para proteger o microcontrolador podemos incluir um resistor e dois diodos de clamp na conexão MAX232 - Microcontrolador.

O esquema proposto encontra-se representado na figura abaixo:

Esquema do módulo para comunicação serial utilizando um CI MAX232

/media/Attachments/courseEA079_1S2010/Mfab_5/Max.JPG