drv_rmc.c

基于MSP430FG4618MCU的铭正同创LCD驱动程序。

#include "sys_def.h"
#include "mng_tsk.h"
#include "mng_irq.h"
#include "drv_rmc.h"

#define REMO_IDLE   0
#define REMO_HEADER 1
#define REMO_0_1    2
#define REMO_TAIL   3
#define REMO_REPEAT1 4
#define REMO_REPEAT2 5

#define KEY_ESC        0x01
#define KEY_ENTER      0x02
#define KEY_LEFT       0x03
#define KEY_DOWN       0x04
#define KEY_UP         0x05
#define KEY_RIGHT      0x06
#define KEY_POWER      0x07
#define KEY_MENU       0x08
#define KEY_NONE       0x09
#define KEY_0          0x10
#define KEY_1          0x11
#define KEY_2          0x12
#define KEY_3          0x13
#define KEY_4          0x14
#define KEY_5          0x15
#define KEY_6          0x16
#define KEY_7          0x17
#define KEY_8          0x18
#define KEY_9          0x19



#define IS_HEADER ((usRmcTimer >= 420) && (usRmcTimer <= 450)) //13ms = 32.768 * 13 = 425.987
#define IS_0 ((usRmcTimer >= 30) && (usRmcTimer <= 40)) //1ms = 32.768 * 1 = 32.768
#define IS_1 ((usRmcTimer >= 60) && (usRmcTimer <= 80)) //2ms = 32.768 * 2 = 65.536
#define IS_TAIL ((usRmcTimer >= 1310) && (usRmcTimer <= 1340)) //40ms = 32.768 * 40 = 1310.72
#define IS_REPEAT1 ((usRmcTimer >= 350) && (usRmcTimer <= 380)) //11ms = 32.768 * 11 = 360.448
#define TIME_OUT  3200  //97ms = 32.768 * 97 = 3178.496
unsigned short usRmcTimer = 0;
unsigned char ucRmcState = REMO_IDLE;
unsigned char ucRemoCode[4] = {0};
unsigned char ucRemoKeyCode = KEY_NONE;
unsigned char ucCodeCnt = 0;
unsigned char ucErrorFlag = 0;
void External_Init(void)
{
  P1DIR &= ~0x02;                           //设定p1.1端口为输入方向
  P1SEL &= ~0x02;                           //中断端口，p1.1口清零
  P1IE |= 0x02;                            // P1.0 Interrupt enabled
  P1IES &= ~0x02;                           // P1.0 low-hi edge
  P1IFG &= 0x02;                          // P1 IFG Cleared                 
}

void CLOCK_Init(void)
{
  volatile unsigned int i;            // volatile to prevent optimization
  FLL_CTL0 |= XCAP14PF;                    // Configure load caps
  // Wait for xtal to stabilize
  do
  {
    IFG1 &= ~OFIFG;                           // Clear OSCFault flag
  for (i = 0x47FF; i > 0; i--);             // Time for flag to set  延时
  }
  while ((IFG1 & OFIFG));                   // OSCFault flag still set?

  for(i=2100;i>0;i--);                      // Now with stable ACLK, wait for  延时
  
}


unsigned char RemoCode2KeyCode(unsigned char aucRemoCode[])
{
  unsigned char ucKeyCode = KEY_NONE;
  if((aucRemoCode[0] == 0x00) && (aucRemoCode[1] == 0xFF)) {
    if((aucRemoCode[2] == 0x0A) && (aucRemoCode[3] == 0xF5)) {
        ucKeyCode = KEY_ESC;
    } else if((aucRemoCode[2] == 0x92) && (aucRemoCode[3] == 0x6D)) {
        ucKeyCode = KEY_ENTER;   
    } else if((aucRemoCode[2] == 0xD0) && (aucRemoCode[3] == 0x2F)) {
         ucKeyCode = KEY_LEFT;     
    } else if((aucRemoCode[2] == 0xD2) && (aucRemoCode[3] == 0x2D)) {
         ucKeyCode = KEY_DOWN;     
    } else if((aucRemoCode[2] == 0x10) && (aucRemoCode[3] == 0xEF)) {
         ucKeyCode = KEY_RIGHT;     
    } else if((aucRemoCode[2] == 0x52) && (aucRemoCode[3] == 0xAD)) {
        ucKeyCode = KEY_UP;      
    } else if((aucRemoCode[2] == 0xF8) && (aucRemoCode[3] == 0x07)) {
        ucKeyCode = KEY_POWER;      
    } else if((aucRemoCode[2] == 0x02) && (aucRemoCode[3] == 0xFD)) {
        ucKeyCode = KEY_MENU;      
    } else if((aucRemoCode[2] == 0x9A) && (aucRemoCode[3] == 0x65)) {
        ucKeyCode = KEY_0;       
    } else if((aucRemoCode[2] == 0x3A) && (aucRemoCode[3] == 0xC5)) {
         ucKeyCode = KEY_1;     
    } else if((aucRemoCode[2] == 0x78) && (aucRemoCode[3] == 0x87)) {
         ucKeyCode = KEY_2;     
    } else if((aucRemoCode[2] == 0x7A) && (aucRemoCode[3] == 0x85)) {
         ucKeyCode = KEY_3;     
    } else if((aucRemoCode[2] == 0xB8) && (aucRemoCode[3] == 0x47)) {
        ucKeyCode = KEY_4;      
    } else if((aucRemoCode[2] == 0x1A) && (aucRemoCode[3] == 0xE5)) {
        ucKeyCode = KEY_5;      
    } else if((aucRemoCode[2] == 0x58) && (aucRemoCode[3] == 0xA7)) {
        ucKeyCode = KEY_6;  
    } else if((aucRemoCode[2] == 0xDA) && (aucRemoCode[3] == 0x25)) {
         ucKeyCode = KEY_7;   
    }  else if((aucRemoCode[2] == 0x98) && (aucRemoCode[3] == 0x67)) {
        ucKeyCode = KEY_8;      
    } else if((aucRemoCode[2] == 0xD8) && (aucRemoCode[3] == 0x27)) {
        ucKeyCode = KEY_9;  
    }
  
  }
  return ucKeyCode;
  
}

// Port 1 interrupt service routine
int Port1_ISR (void)
{
  P1IFG &= ~0x02;                          // P1.4 Interrupt Flag Registers Cleared
  usRmcTimer = TACCR1;                        //Timer_A capture/compare 1
  return OK;
}


void RmcInit()
{
  // Stop watchdog timer to prevent time out reset
  WDTCTL = WDTPW + WDTHOLD;
  CLOCK_Init();
  //ACLK = 32.768KHZ
	RegIrq(IRQ_PORT1_BIT1, Port1_ISR);
 // External_Init();
  P1DIR &= ~0x02;
  P1SEL |= 0x02;
  
  TACTL = TASSEL_1 + MC_2 + TACLR;                  //Timer_A Control Register
  TACCTL0 = CM_2 + CCIS_1 + CAP + CCIE + SCS;       //Capture/Compare Control Register
  _EINT();
}

// Timer A0 interrupt service routine
#pragma vector = TIMERA0_VECTOR
__interrupt void Timer_A0 (void)
{
  TACCTL0 &= ~CCIFG;                    // CCIFG--Capture/compare interrupt flag
  if(TACCTL0 & COV) {
    TACCTL0 &= ~COV;                    //Capture overflow
  }
  
  switch(ucRmcState) {
  case REMO_IDLE:
    usRmcTimer = TACCR0;                 //the period register
    ucRemoCode[0] = 0;
    ucRemoCode[1] = 0;
    ucRemoCode[2] = 0;
    ucRemoCode[3] = 0;
    ucRmcState = REMO_HEADER;
    break;
  case REMO_HEADER:
    if(TACCR0 < usRmcTimer) {
      usRmcTimer = TACCR0 + 0xFFFF - usRmcTimer;
    } else {
      usRmcTimer = TACCR0 - usRmcTimer;   
    }
    if(IS_HEADER){
      ucRmcState = REMO_0_1;
      usRmcTimer = TACCR0;
    } else {
      ucErrorFlag = 1;
      ucRmcState = REMO_IDLE;
      usRmcTimer = 0x00;
    }
    break;
  case REMO_0_1:
    if(TACCR0 < usRmcTimer) {
      usRmcTimer = TACCR0 + 0xFFFF - usRmcTimer;
    } else {
      usRmcTimer = TACCR0 - usRmcTimer;   
    }
    if(IS_0){
      ucRemoCode[ucCodeCnt/8] <<= 1;
      ucRemoCode[ucCodeCnt/8] |= 0;
      ucCodeCnt++;
      usRmcTimer = TACCR0;
    } else if(IS_1) {
      ucRemoCode[ucCodeCnt/8] <<= 1;
      ucRemoCode[ucCodeCnt/8] |= 1;
      ucCodeCnt++;
      usRmcTimer = TACCR0;
    } else {
      ucErrorFlag = 1;
      ucRmcState = REMO_IDLE;
      usRmcTimer = 0x00;
      ucCodeCnt = 0x00;
    }
    if(ucCodeCnt == 32) {
      ucRmcState = REMO_TAIL;
      ucCodeCnt = 0x00;   
    }
    break;
    
  case REMO_TAIL:
    if(TACCR0 < usRmcTimer) {
      usRmcTimer = TACCR0 + 0xFFFF - usRmcTimer;
    } else {
      usRmcTimer = TACCR0 - usRmcTimer;   
    }
    if(IS_TAIL) {
      ucRmcState = REMO_REPEAT1;
      usRmcTimer = TACCR0; 
      ucRemoKeyCode = RemoCode2KeyCode(ucRemoCode);
      //sendMSG Key Code ,Push 
    } else {
      ucErrorFlag = 1;
      ucRmcState = REMO_IDLE;
      usRmcTimer = 0x00;      
    }    
    break;
  case REMO_REPEAT1:
    if(TACCR0 < usRmcTimer) {
      usRmcTimer = TACCR0 + 0xFFFF - usRmcTimer;
    } else {
      usRmcTimer = TACCR0 - usRmcTimer;
    }
    if(IS_REPEAT1) {
      ucRmcState = REMO_IDLE;
      usRmcTimer = TACCR0; 
    } else {
      ucErrorFlag = 1;
      ucRmcState = REMO_IDLE;
      usRmcTimer = 0x00;      
    }    
    break;
/*  case REMO_REPEAT2:
    ucRmcState = REMO_IDLE;
    
    break;*/
  } 

}

#pragma vector = TIMERA1_VECTOR
__interrupt void Timer_A1 (void)
{
  switch( TAIV )
  {
    case  2: 
      _NOP();                         //can not use
      break;                         // TACCR1 not used
    case  4: 
      break;                         // TACCR2 not used
    case 10: 
    default:
      break;
  }
}