From 665c58fd2a9e3c84afc228a444e801af7c32988a Mon Sep 17 00:00:00 2001 From: nvt-se Date: Thu, 13 Dec 2007 12:51:38 +0000 Subject: [PATCH] Contributions from Michael Baar: CC1020 o Turns off only after transmission has ended and not in between o Using events for DMA takes too long. It should use a callback when DMA finishes to turn off the transmit mode as early as possible. Core/UART o Added profiling and energest initialization o Changed low-power mode from LPM1 to LPM3 --- platform/msb430/contiki-msb430-main.c | 142 +++++++++++++++++------- platform/msb430/dev/cc1020-internal.h | 23 ++-- platform/msb430/dev/cc1020.c | 113 +++++++++++-------- platform/msb430/dev/msb430-uart1.c | 152 +++++++++++++++----------- 4 files changed, 267 insertions(+), 163 deletions(-) diff --git a/platform/msb430/contiki-msb430-main.c b/platform/msb430/contiki-msb430-main.c index 385e5cb51..fc1b8aeca 100644 --- a/platform/msb430/contiki-msb430-main.c +++ b/platform/msb430/contiki-msb430-main.c @@ -47,21 +47,21 @@ #include "sys/procinit.h" #include "sys/autostart.h" -#include "sys/rtimer.h" #include "dev/adc.h" -#include "dev/dma.h" -#include "dev/sht11.h" -#include "dev/slip.h" #include "net/mac/nullmac.h" #include "net/mac/xmac.h" +#include "dev/slip.h" + +extern volatile bool uart_edge; + SENSORS(NULL); #if WITH_UIP static struct uip_fw_netif slipif = - {UIP_FW_NETIF(172,16,0,1, 255,255,255,0, slip_send)}; +{UIP_FW_NETIF(192,168,1,2, 255,255,255,255, slip_send)}; #else int putchar(int c) @@ -75,7 +75,6 @@ static void set_rime_addr(void) { rimeaddr_t addr; - addr.u16[0] = node_id; rimeaddr_set_node_addr(&addr); } @@ -83,12 +82,29 @@ set_rime_addr(void) static void msb_ports_init(void) { - P1DIR = 0x00; P1SEL = 0x00; P1OUT = 0x00; - P2DIR = 0x1A; P2SEL = 0x00; P2OUT = 0x18; - P3DIR = 0x21; P3SEL = 0x00; P3OUT = 0x09; - P4DIR = 0x00; P4SEL = 0x00; P4OUT = 0x07; - P5DIR = 0xFD; P5SEL = 0x0E; P5OUT = 0xF9; - P6DIR = 0xC8; P6SEL = 0x07; P6OUT = 0x00; + P1SEL = 0x00; + P1OUT = 0x00; + P1DIR = 0x00; + + P2SEL = 0x00; + P2OUT = 0x18; + P2DIR = 0x1A; + + P3SEL = 0x00; + P3OUT = 0x09; + P3DIR = 0x21; + + P4SEL = 0x00; + P4OUT = 0x00; + P4DIR = 0x00; + + P5SEL = 0x0E; + P5OUT = 0xF9; + P5DIR = 0xFD; + + P6SEL = 0x07; + P6OUT = 0x00; + P6DIR = 0xC8; } int @@ -99,12 +115,10 @@ main(void) /* Platform-specific initialization. */ msb_ports_init(); adc_init(); - dma_init(); clock_init(); leds_init(); leds_on(LEDS_ALL); - sht11_init(); // low level irq_init(); @@ -123,55 +137,101 @@ main(void) slip_arch_init(BAUD2UBR(115200)); #endif - rtimer_init(); - ctimer_init(); - - energest_init(); - node_id_restore(); - /* System services */ process_start(&etimer_process, NULL); -#if 0 - process_start(&sensors_process, NULL); -#endif + //process_start(&sensors_process, NULL); - /* Radio driver */ - cc1020_init(cc1020_config_19200); + //cc1020_init(cc1020_config_19200); - /* Network configuration */ + // network configuration + node_id_restore(); + #if WITH_UIP uip_init(); uip_sethostaddr(&slipif.ipaddr); uip_setnetmask(&slipif.netmask); - /* Point-to-point, no default router. */ - uip_fw_default(&slipif); + uip_fw_default(&slipif); /* Point2point, no default router. */ tcpip_set_forwarding(0); - - process_start(&tcpip_process, NULL); - process_start(&uip_fw_process, NULL); - process_start(&slip_process, NULL); #endif /* WITH_UIP */ nullmac_init(&cc1020_driver); rime_init(&nullmac_driver); set_rime_addr(); + +#if WITH_UIP + process_start(&tcpip_process, NULL); + process_start(&uip_fw_process, NULL); /* Start IP output */ + process_start(&slip_process, NULL); +#endif /* WITH_UIP */ + +#if PROFILE_CONF_ON + profile_init(); +#endif /* PROFILE_CONF_ON */ - printf(CONTIKI_VERSION_STRING " started. Node id %d.\n", node_id); - - printf("Autostarting processes\n"); - autostart_start((struct process **) autostart_processes); - leds_off(LEDS_ALL); lpm_on(); - for (;;) { - while (process_run() > 0); - if (process_nevents() == 0) { + printf(CONTIKI_VERSION_STRING " started. Node id %u.", node_id); + + autostart_start((struct process **) autostart_processes); + + energest_init(); + + /* + * This is the scheduler loop. + */ + ENERGEST_ON(ENERGEST_TYPE_CPU); + + while (1) { + int r; +#if PROFILE_CONF_ON + profile_episode_start(); +#endif /* PROFILE_CONF_ON */ + do { + /* Reset watchdog. */ + r = process_run(); + } while(r > 0); + +#if PROFILE_CONF_ON + profile_episode_end(); +#endif /* PROFILE_CONF_ON */ + + /* + * Idle processing. + */ + int s = splhigh(); /* Disable interrupts. */ + if (process_nevents() != 0) { + splx(s); /* Re-enable interrupts. */ + } else { + static unsigned long irq_energest = 0; + /* Re-enable interrupts and go to sleep atomically. */ ENERGEST_OFF(ENERGEST_TYPE_CPU); ENERGEST_ON(ENERGEST_TYPE_LPM); - LPM_SLEEP(); + /* + * We only want to measure the processing done in IRQs when we + * are asleep, so we discard the processing time done when we + * were awake. + */ + energest_type_set(ENERGEST_TYPE_IRQ, irq_energest); + + if (uart_edge) { + _BIS_SR(LPM1_bits + GIE); + } else { + _BIS_SR(LPM1_bits + GIE); + } + + /* + * We get the current processing time for interrupts that was + * done during the LPM and store it for next time around. + */ + dint(); + irq_energest = energest_type_time(ENERGEST_TYPE_IRQ); + eint(); ENERGEST_OFF(ENERGEST_TYPE_LPM); ENERGEST_ON(ENERGEST_TYPE_CPU); +#if PROFILE_CONF_ON + profile_clear_timestamps(); +#endif /* PROFILE_CONF_ON */ } } diff --git a/platform/msb430/dev/cc1020-internal.h b/platform/msb430/dev/cc1020-internal.h index 40a99288d..13d33c223 100644 --- a/platform/msb430/dev/cc1020-internal.h +++ b/platform/msb430/dev/cc1020-internal.h @@ -214,11 +214,21 @@ const uint8_t cc1020_config_115200[41] = { /// cc1020 state enum cc1020_state { - CC1020_OFF, - CC1020_RX, - CC1020_TX + CC1020_OFF = 0, + CC1020_RX = 0x01, + CC1020_TX = 0x02, + + CC1020_RX_SEARCHING = 0x10, // searching for preamble + sync word + CC1020_RX_RECEIVING = 0x20, // receiving bytes + CC1020_RX_PROCESSING = 0x40, // processing data in buffer + + CC1020_OP_STATE = 0x73, + + CC1020_TURN_OFF = 0x80, }; +#define CC1020_SET_OPSTATE(opstate) cc1020_state = ((cc1020_state & ~CC1020_OP_STATE) | (opstate)) + /****************************************************************************** * @name Packet specification * @{ @@ -241,10 +251,3 @@ struct cc1020_header { #define HDRSIZE (sizeof (struct cc1020_header)) ///@} - -/// cc1020 receiver state -enum cc1020_rxstate { - CC1020_RX_SEARCHING, // searching for preamble + sync word - CC1020_RX_RECEIVING, // receiving bytes - CC1020_RX_PROCESSING // processing data in buffer -}; diff --git a/platform/msb430/dev/cc1020.c b/platform/msb430/dev/cc1020.c index c93ebe3c8..e736f71b0 100644 --- a/platform/msb430/dev/cc1020.c +++ b/platform/msb430/dev/cc1020.c @@ -52,6 +52,7 @@ Berlin, 2006 #include #include +#include "contiki.h" #include "contiki-msb430.h" #include "cc1020-internal.h" #include "cc1020.h" @@ -59,6 +60,7 @@ Berlin, 2006 #include "net/rime/rimestats.h" #include "dev/irq.h" #include "dev/dma.h" +#include "energest.h" static int cc1020_calibrate(void); static int cc1020_setupTX(int); @@ -76,16 +78,16 @@ static enum cc1020_state cc1020_state = CC1020_OFF; static volatile uint8_t cc1020_rxbuf[HDRSIZE + CC1020_BUFFERSIZE]; static uint8_t cc1020_txbuf[PREAMBLESIZE + HDRSIZE + CC1020_BUFFERSIZE + TAILSIZE]; -static volatile enum cc1020_rxstate cc1020_rxstate = CC1020_RX_SEARCHING; +//static volatile enum cc1020_rxstate cc1020_rxstate = CC1020_RX_SEARCHING; -/// number of bytes in receive and transmit buffers respectively. +// number of bytes in receive and transmit buffers respectively. static uint16_t cc1020_rxlen; static uint16_t cc1020_txlen; -/// received signal strength indicator reading for last received packet +// received signal strength indicator reading for last received packet static volatile uint8_t rssi; -/// callback when a packet has been received +// callback when a packet has been received static uint8_t cc1020_pa_power = PA_POWER; static void (*receiver_callback)(const struct radio_driver *); @@ -155,17 +157,15 @@ cc1020_set_rx(void) // configure driver cc1020_rxlen = 0; // receive buffer position to start - cc1020_rxstate = CC1020_RX_SEARCHING; // rx state machine to searching mode - cc1020_state = CC1020_RX; // driver state to receive mode + //cc1020_rxstate = CC1020_RX_SEARCHING; // rx state machine to searching mode + CC1020_SET_OPSTATE(CC1020_RX | CC1020_RX_SEARCHING); // driver state to receive mode // configure radio + ENERGEST_ON(ENERGEST_TYPE_LISTEN); cc1020_wakeupRX(RX_CURRENT); cc1020_setupRX(RX_CURRENT); LNA_POWER_ON(); // enable amplifier - ENERGEST_OFF(ENERGEST_TYPE_TRANSMIT); - ENERGEST_ON(ENERGEST_TYPE_LISTEN); - // activate IE1 |= URXIE0; // enable interrupt } @@ -176,6 +176,7 @@ cc1020_set_tx(void) int s; // configure radio rx + ENERGEST_OFF(ENERGEST_TYPE_LISTEN); LNA_POWER_OFF(); // power down LNA s = splhigh(); DISABLE_RX_IRQ(); @@ -183,17 +184,15 @@ cc1020_set_tx(void) splx(s); // configure radio tx + ENERGEST_ON(ENERGEST_TYPE_TRANSMIT); cc1020_wakeupTX(TX_CURRENT); cc1020_setupTX(TX_CURRENT); P3SEL |= 0x0C; // select Tx line and clk U0CTL |= SWRST; // UART to reset mode IFG1 &= ~UTXIFG0; // Reset IFG. - ENERGEST_OFF(ENERGEST_TYPE_LISTEN); - ENERGEST_ON(ENERGEST_TYPE_TRANSMIT); - // configure driver - cc1020_state = CC1020_TX; + CC1020_SET_OPSTATE(CC1020_TX); } void @@ -218,8 +217,10 @@ cc1020_send(const void *buf, unsigned short len) return -1; /* Previous data hasn't been sent yet. */ - if (cc1020_txlen > 0) - return -1; + if (cc1020_txlen > 0) { + printf("data in buffer"); + return -1; + } /* The preamble and the sync word are already in buffer. */ cc1020_txlen = PREAMBLESIZE + SYNCWDSIZE; @@ -235,7 +236,8 @@ cc1020_send(const void *buf, unsigned short len) cc1020_txbuf[cc1020_txlen++] = TAIL; cc1020_txbuf[cc1020_txlen++] = TAIL; - process_poll(&cc1020_sender_process); + //process_poll(&cc1020_sender_process); + process_post_synch(&cc1020_sender_process, PROCESS_EVENT_POLL, NULL); return len; } @@ -269,6 +271,7 @@ cc1020_set_receiver(void (*recv)(const struct radio_driver *)) int cc1020_on(void) { + cc1020_state &= ~CC1020_TURN_OFF; // Switch to receive mode cc1020_set_rx(); @@ -280,21 +283,22 @@ cc1020_off(void) { int s; - // Discard the current read buffer when the radio is shutting down. - cc1020_rxlen = 0; - - LNA_POWER_OFF(); // power down lna - s = splhigh(); - cc1020_rxstate = CC1020_OFF; - DISABLE_RX_IRQ(); - cc1020_state = CC1020_OFF; - splx(s); - cc1020_setupPD(); // power down radio - cc1020_state = CC1020_OFF; - - ENERGEST_OFF(ENERGEST_TYPE_LISTEN); - ENERGEST_OFF(ENERGEST_TYPE_TRANSMIT); + if (cc1020_state & CC1020_RX_SEARCHING) { + // Discard the current read buffer when the radio is shutting down. + cc1020_rxlen = 0; + LNA_POWER_OFF(); // power down lna + s = splhigh(); + //cc1020_rxstate = CC1020_OFF; + DISABLE_RX_IRQ(); + cc1020_state = CC1020_OFF; + splx(s); + cc1020_setupPD(); // power down radio + ENERGEST_OFF(ENERGEST_TYPE_LISTEN); + cc1020_state = CC1020_OFF; + } else { + cc1020_state |= CC1020_TURN_OFF; + } return 1; } @@ -328,8 +332,7 @@ interrupt(UART0RX_VECTOR) cc1020_rxhandler(void) } shiftbuf; static unsigned char pktlen; - switch (cc1020_rxstate) { - case CC1020_RX_SEARCHING: + if (cc1020_state & CC1020_RX_SEARCHING) { shiftbuf.b1 = shiftbuf.b2; shiftbuf.b2 = shiftbuf.b3; shiftbuf.b3 = shiftbuf.b4; @@ -364,10 +367,9 @@ interrupt(UART0RX_VECTOR) cc1020_rxhandler(void) } // Update RSSI. rssi = cc1020_read_reg(CC1020_RSS); - cc1020_rxstate = CC1020_RX_RECEIVING; + CC1020_SET_OPSTATE(CC1020_RX | CC1020_RX_RECEIVING); - break; - case CC1020_RX_RECEIVING: + } else if( cc1020_state & CC1020_RX_RECEIVING ) { if (syncbs == 0) { cc1020_rxbuf[cc1020_rxlen] = RXBUF0; } else { @@ -387,13 +389,15 @@ interrupt(UART0RX_VECTOR) cc1020_rxhandler(void) pktlen = ((struct cc1020_header *)cc1020_rxbuf)->length; if (pktlen == 0 || pktlen > sizeof (cc1020_rxbuf)) { cc1020_rxlen = 0; - cc1020_rxstate = CC1020_RX_SEARCHING; + CC1020_SET_OPSTATE(CC1020_RX | CC1020_RX_SEARCHING); + //cc1020_rxstate = CC1020_RX_SEARCHING; } } else if (cc1020_rxlen > HDRSIZE) { if (cc1020_rxlen == pktlen) { // disable receiver DISABLE_RX_IRQ(); - cc1020_rxstate = CC1020_RX_PROCESSING; + CC1020_SET_OPSTATE(CC1020_RX | CC1020_RX_PROCESSING); + //cc1020_rxstate = CC1020_RX_PROCESSING; // call receiver to copy from buffer if (receiver_callback != NULL) { @@ -402,18 +406,21 @@ interrupt(UART0RX_VECTOR) cc1020_rxhandler(void) // reset receiver cc1020_rxlen = 0; - cc1020_rxstate = CC1020_RX_SEARCHING; - ENABLE_RX_IRQ(); + CC1020_SET_OPSTATE(CC1020_RX | CC1020_RX_SEARCHING); + //cc1020_rxstate = CC1020_RX_SEARCHING; + if ((cc1020_state & CC1020_TURN_OFF) && (cc1020_txlen == 0)) { + cc1020_off(); + } else { + ENABLE_RX_IRQ(); + } } } - break; - default: - break; - } + } } PROCESS_THREAD(cc1020_sender_process, ev, data) { + int i; PROCESS_BEGIN(); dma_subscribe(0, &cc1020_sender_process); @@ -423,9 +430,9 @@ PROCESS_THREAD(cc1020_sender_process, ev, data) cc1020_set_rx(); - if (cc1020_rxstate != CC1020_RX_SEARCHING) { + if((cc1020_state & CC1020_RX_SEARCHING) == 0) { // Wait until the receiver is idle. - PROCESS_WAIT_UNTIL(cc1020_rxstate == CC1020_RX_SEARCHING); + PROCESS_WAIT_UNTIL(cc1020_state & CC1020_RX_SEARCHING); // Wait for the medium to become idle. while (cc1020_carrier_sense()); @@ -437,17 +444,31 @@ PROCESS_THREAD(cc1020_sender_process, ev, data) // Switch to transceive mode. cc1020_set_tx(); +#if 0 + U0CTL &= ~SWRST; + for (i = 0; i < cc1020_txlen; i++) { + UART0_TX = cc1020_txbuf[i]; + UART0_WAIT_TX(); + } +#endif + // Initiate radio transfer. dma_transfer(&TXBUF0, cc1020_txbuf, cc1020_txlen); // wait for DMA0 to finish PROCESS_WAIT_UNTIL(ev == dma_event); + ENERGEST_OFF(ENERGEST_TYPE_TRANSMIT); RIMESTATS_ADD(lltx); // clean up cc1020_txlen = 0; - cc1020_set_rx(); + if (cc1020_state & CC1020_TURN_OFF) { + CC1020_SET_OPSTATE(CC1020_RX | CC1020_RX_SEARCHING); + cc1020_off(); + } else { + cc1020_set_rx(); + } } PROCESS_END(); diff --git a/platform/msb430/dev/msb430-uart1.c b/platform/msb430/dev/msb430-uart1.c index 6e3c4bfc5..1c7c36682 100644 --- a/platform/msb430/dev/msb430-uart1.c +++ b/platform/msb430/dev/msb430-uart1.c @@ -32,11 +32,19 @@ whether in contract, strict liability, or tort (including negligence or otherwise) arising in any way out of the use of this software, even if advised of the possibility of such damage. +This implementation was developed by the CST group at the FUB. + +For documentation and questions please use the web site +http://scatterweb.mi.fu-berlin.de and the mailinglist +scatterweb@lists.spline.inf.fu-berlin.de (subscription via the Website). +Berlin, 2007 */ /** - * \file UART interface - * \author Michael Baar + * @file ScatterWeb.Uart.c + * @addtogroup interfaces + * @brief UART interface + * @author Michael Baar * * UART switch for RS232 and SPI protocols on UART1 written for * ScatterWeb MSB boards. Compatible to ScatterWeb EOS, @@ -54,36 +62,38 @@ if advised of the possibility of such damage. #define U1ME ME2 #endif -static void uart_configure(unsigned char mode); -static void uart_set_mode(unsigned char mode); +void _uart_configure(unsigned char mode); +void _uart_set_mode(unsigned char mode); -static volatile unsigned char uart_mode = UART_MODE_RESET; -static volatile unsigned char uart_lockcnt; +volatile unsigned char uart_mode = UART_MODE_RESET; +volatile unsigned char uart_lockcnt = 0; +volatile uint8_t uart_edge = 0; -static unsigned char uart_speed_br0[UART_NUM_MODES]; -static unsigned char uart_speed_br1[UART_NUM_MODES]; -static unsigned char uart_speed_bmn[UART_NUM_MODES]; -static fp_uart_handler uart_handler[UART_NUM_MODES]; +static unsigned char _uart_speed_br0[UART_NUM_MODES]; +static unsigned char _uart_speed_br1[UART_NUM_MODES]; +static unsigned char _uart_speed_bmn[UART_NUM_MODES]; +static fp_uart_handler _uart_handler[UART_NUM_MODES] = {NULL, NULL}; +/*---------------------------------------------------------------------------*/ void uart_set_speed(unsigned char mode, unsigned char ubr0, unsigned char ubr1, unsigned char umctl) { // store setting - uart_speed_br0[mode] = ubr0; // baudrate - uart_speed_br1[mode] = ubr1; // baudrate - uart_speed_bmn[mode] = umctl; // modulation + _uart_speed_br0[mode] = ubr0; // baudrate + _uart_speed_br1[mode] = ubr1; // baudrate + _uart_speed_bmn[mode] = umctl; // modulation // reconfigure, if mode active if (uart_mode == mode) - uart_configure(mode); + _uart_configure(mode); } - +/*---------------------------------------------------------------------------*/ void uart_set_handler(unsigned char mode, fp_uart_handler fpHandler) { // store setting - uart_handler[mode] = fpHandler; + _uart_handler[mode] = fpHandler; if (mode == uart_mode) { if (fpHandler == NULL) IE2 &= ~URXIE1; // Disable USART1 RX interrupt @@ -91,28 +101,30 @@ uart_set_handler(unsigned char mode, fp_uart_handler fpHandler) IE2 |= URXIE1; // Enable USART1 RX interrupt } } - +/*---------------------------------------------------------------------------*/ int uart_lock(unsigned char mode) { // already locked? if ((mode != uart_mode) && (uart_lockcnt)) { - return FALSE; + return 0; + } else { + // increase lock count + uart_lockcnt++; + // switch mode (if neccessary) + _uart_set_mode(mode); + return 1; } - - // increase lock count - uart_lockcnt++; - // switch mode (if neccessary) - uart_set_mode(mode); - return TRUE; } - +/*---------------------------------------------------------------------------*/ int uart_unlock(unsigned char mode) { - /* Strict checking. */ - if (mode != uart_mode) - return FALSE; + /* + Do we wan't strict checking? + if( (uart_lockcnt == 0) || (mode != uart_mode) ) + return false; + */ // decrement lock if (uart_lockcnt > 0) { @@ -120,28 +132,28 @@ uart_unlock(unsigned char mode) // if no more locks, switch back to default mode if (uart_lockcnt == 0) { - uart_set_mode(UART_MODE_DEFAULT); + _uart_set_mode(UART_MODE_DEFAULT); } - return TRUE; + return 1; } - return FALSE; + return 0; } - -static void -uart_configure(unsigned char mode) +/*---------------------------------------------------------------------------*/ +void +_uart_configure(unsigned char mode) { - int s; - - s = splhigh(); + _DINT(); // disable interrupts UART_WAIT_TXDONE(); +// wait till all buffered data has been transmitted // configure if (mode == UART_MODE_RS232) { P5OUT |= 0x01; // unselect SPI P3SEL |= 0xC0; - // select rs232 to RS232 mode + // select rs232 + // to RS232 mode UCTL1 = SWRST | CHAR; // 8-bit character UTCTL1 |= SSEL1; // UCLK = MCLK // activate @@ -159,48 +171,56 @@ uart_configure(unsigned char mode) } // restore speed settings - UBR01 = uart_speed_br0[mode]; // set baudrate - UBR11 = uart_speed_br1[mode]; - UMCTL1 = uart_speed_bmn[mode]; // set modulation + UBR01 = _uart_speed_br0[mode]; // set baudrate + UBR11 = _uart_speed_br1[mode]; + UMCTL1 = _uart_speed_bmn[mode]; // set modulation UCTL1 &= ~SWRST; // clear reset flag - - splx(s); + _EINT(); // enable interrupts } - -static void -uart_set_mode(unsigned char mode) +/*---------------------------------------------------------------------------*/ +void +_uart_set_mode(unsigned char mode) { // do nothing if mode already set - if (mode == uart_mode ) + if (mode == uart_mode) return; IE2 &= ~(URXIE1 | UTXIE1); // disable irq - uart_configure(mode); // configure uart parameters + _uart_configure(mode); // configure uart parameters uart_mode = mode; - if (uart_handler[mode] != NULL) + if (_uart_handler[mode] != NULL) IE2 |= URXIE1; // Enable USART1 RX interrupt } - -interrupt(UART1RX_VECTOR) uart_rx(void) -{ - fp_uart_handler handler = uart_handler[uart_mode]; - - /* Check status register for receive errors. - before reading RXBUF since - it clears the error and interrupt flags */ - if (!(URCTL1 & RXERR) && handler != NULL) { - if(handler(UART_RX)) { - LPM_AWAKE(); - } - } else { - // read out the char to clear the I-flags, etc. - UART_RX; - } -} - +/*---------------------------------------------------------------------------*/ int uart_get_mode(void) { return uart_mode; } +/*---------------------------------------------------------------------------*/ +interrupt(UART1RX_VECTOR)_uart_rx(void) +{ + fp_uart_handler handler = _uart_handler[uart_mode]; + int c; + + if (!(IFG2 & URXIFG1)) { + // If start edge detected, toggle & return + uart_edge = 1; + U1TCTL &= ~URXSE; + U1TCTL |= URXSE; + _BIC_SR_IRQ(LPM3_bits); + return; + } + uart_edge = 0; + if (!(URCTL1 & RXERR)) { + c = UART_RX; + if (handler(c)) { + _BIC_SR_IRQ(LPM3_bits); + } + } else { + // read out the char to clear the I-flags, etc. + c = UART_RX; + } +}