int main(void)
{
  WDTCTL = WDTPW + WDTHOLD;                 // Stop WDT
  if (CALBC1_8MHZ==0xFF)					// If calibration constant erased
  {											
    while(1);                               // do not load, trap CPU!!	
  }
  DCOCTL = 0;                               // Select lowest DCOx and MODx settings
  BCSCTL1 = CALBC1_8MHZ;
  DCOCTL = CALDCO_8MHZ;                     // Load 8MHz constants
  P2SEL |= 0x18;                            // Use P2.3/P2.4 for Timer_A
  P2DIR |= 0x10;                            // P2.4 output
  P3SEL |= 0x30;                            // Use P3.4/P3.5 for USCI_A0
  UCA0CTL1 |= UCSWRST;                      // Set SW Reset
  UCA0CTL1 = UCSSEL_2 + UCSWRST;
  UCA0BR0 = 52;                             // 8MHz/52=153.8KHz
  UCA0BR1 = 0;
  UCA0MCTL = UCBRF_1 + UCOS16;
  UCA0IRTCTL = UCIRTXPL2 + UCIRTXPL0 + UCIRTXCLK + UCIREN;
                                            // Pulse length = 6 half clock cyc
                                            // Enable BITCLK16, IrDA enc/dec
  UCA0IRRCTL = UCIRRXPL;                    // Light = low pulse
  UCA0CTL1 &= ~UCSWRST;                     // Resume operation
  IE2 |= UCA0RXIE;                          // Enable RX int
  TACCTL2 = OUT;                            // TXD Idle as Mark
  TACTL = TASSEL_2 + MC_2;                  // SMCLK, continuous mode
  RX_Ready();                               // Ready Timer_A UART for RX

  while (1)
  {
    __disable_interrupt();                  // Disable interrupts
    if (!Flags)                             // Any events pending?
      __bis_SR_register(CPUOFF + GIE);      // Enter LPM0 w/ interrupts

    __enable_interrupt();                   // Enable interrupts

    if (Flags & FLAG_USCI)                  // USCI_A0 character received?
    {
      while (TACCTL2 & CCIE);               // Yes, ensure Timer_A UART is ready
      TX_Byte(RXDataIR);                    // Transmit using Timer_A UART
      Flags &= ~FLAG_USCI;                  // Clear flag
      IE2 |= UCA0RXIE;                      // Re-enable RX int
    }

    if (Flags & FLAG_UART)                  // Timer_A UART character received?
    {
      while (!(IFG2 & UCA0TXIFG));          // Ensure TX buffer is ready
      UCA0TXBUF = RXData;                   // Move RX'd character to USCI_A0
      Flags &= ~FLAG_UART;                  // Clear flag
      RX_Ready();                           // Ready Timer_A UART for RX
    }
  }
}
Exemplo n.º 2
0
void main (void)
{
    volatile unsigned int i;
    WDTCTL = WDTPW + WDTHOLD;                 // Stop watchdog timer

    BCSCTL1 |= XTS;                           // ACLK = LFXT1 = HF XTAL

    do
    {
        IFG1 &= ~OFIFG;                           // Clear OSCFault flag
        for (i = 0xFF; i > 0; i--);               // Time for flag to set
    }
    while ( IFG1 & OFIFG );                   // OSCFault flag still set?

    BCSCTL2 |= SELM_3;                        // MCLK = LFXT1 (safe)

    CCTL0 = OUT;                              // TXD Idle as Mark
    TACTL = TASSEL_1 + MC_2;                  // ACLK, continuous mode
    P1SEL = TXD;                              // P1.1/TA0 for TXD function
    P1DIR = TXD;                              // TXD output on P1
    P2SEL = RXD;                              // P2.2/TA0 as RXD input

// Mainloop
    for (;;)
    {
        RX_Ready();                               // UART ready to RX one Byte
        _BIS_SR(CPUOFF + GIE);                    // Enter LPM0 w/ interr until char RXed
        TX_Byte();                                // TX Back RXed Byte Received
    }
}
void main (void)
{
  WDTCTL = WDTPW + WDTHOLD;                 // Stop watchdog timer

  BCSCTL1 |= DIVA_3;                        // ACLK = LFXT1CLK/8
  Set_DCO();                                // Set DCO

  CCTL0 = OUT;                              // TXD Idle as Mark
  TACTL = TASSEL_2 + MC_2;                  // SMCLK, continuous mode
  P1SEL = TXD;                              // P1.1/TA0 for TXD function
  P1DIR = TXD;                              // TXD output on P1
  P2SEL = RXD;                              // P2.2/TA0 as RXD input

// Mainloop
  for (;;)
  {
  RX_Ready();                               // UART ready to RX one Byte
  _BIS_SR(LPM3_bits + GIE);                 // Enter LPM3 w/ interr until char RXed
  TX_Byte();                                // TX Back RXed Byte Received
  }
}