uart.c

MANTIS是由科罗拉多大学开发的传感器网络嵌入式操作系统。 这是mantis的0.9.5版本的源码。

   tx_state1 = tx_state_preamble1;
   com_swap_bufs(IFACE_SERIAL2, (comBuf *)NULL, &rx_buf1);

   // clear reset state
   U0CTL &= ~SWRST;
   U1CTL &= ~SWRST;
}

#else
#error A UART driver has not been implemented for this platform.
#endif

#define com_send_helper(uart_num, buf)				\
   handle_t int_handle;						\
   mos_mutex_lock(&if_send_mutexes[IFACE_SERIAL + uart_num]);	\
   int_handle = mos_disable_ints();				\
   tx_state##uart_num = tx_state_preamble##uart_num;		\
   tx_buf##uart_num = buf;					\
   tx_index##uart_num = 1;					\
   TX_REG##uart_num = PREAMBLE;					\
   UART_ENABLE_TX_INT##uart_num();				\
   mos_enable_ints(int_handle);					\
   mos_sem_wait(&tx_sem##uart_num);				\
   mos_mutex_unlock(&if_send_mutexes[IFACE_SERIAL + uart_num]);

/** @brief Uart send function. 
 * @param buf Buffer to use
 * @return Always returns 0
 */
uint8_t com_send_IFACE_SERIAL(comBuf *buf)
{
   com_send_helper(0, buf);
   return 0;
}

/** @brief Uart send function. 
 * @param buf Buffer to use
 * @return Always returns 0
 */
uint8_t com_send_IFACE_SERIAL2(comBuf *buf)
{
   com_send_helper(1, buf);
   return 0;
}

#ifdef NEED_RAW_MODE
#define com_ioctl_helper_raw(uart_num)				\
   /*uint8_t baud_rate;*/					\
   va_list ap;							\
   uint16_t arg;						\
   handle_t handle;						\
   va_start(ap, request);					\
   switch(request) {						\
   case UART_IOCTL_BAUD_RATE:					\
      /*baud_rate = (uint8_t)va_arg(ap, int);*/			\
      /*uart_set_baud(uart_num, 57600);*/			\
      break;							\
   case UART_IOCTL_RAW_MODE##uart_num:				\
      arg = va_arg(ap, uint16_t);				\
      handle = mos_disable_ints();				\
      tx_state##uart_num = tx_raw##uart_num;			\
      rx_state##uart_num = rx_raw##uart_num;			\
      rx_index##uart_num = 0;					\
      mos_enable_ints(handle);					\
      break;							\
   case UART_IOCTL_COM_MODE##uart_num:				\
      arg = va_arg(ap, uint16_t);				\
      handle = mos_disable_ints();				\
      tx_state##uart_num = tx_state_preamble##uart_num;		\
      rx_state##uart_num = rx_state_preamble##uart_num;		\
      rx_index##uart_num = 0;					\
      mos_enable_ints(handle);					\
      break;							\
   }								\
   va_end(ap);

#else

#define com_ioctl_helper(uart_num)			\
   /*uint8_t baud_rate;*/				\
   va_list ap;						\
   va_start(ap, request);				\
   switch(request) {					\
   case UART_IOCTL_BAUD_RATE:				\
      /*baud_rate = (uint8_t)va_arg(ap, int);*/		\
      /*uart_set_baud(uart_num, 57600);*/		\
      break;						\
   }							\
   va_end(ap);

#endif

/** @brief Uart IO control function.
 * @return Always returns 0
 */
void com_ioctl_IFACE_SERIAL(uint8_t request, ...)
{
#ifdef NEED_RAW_MODE
   com_ioctl_helper_raw(0);
#else
   com_ioctl_helper(0);
#endif
}

/** @brief Uart IO control function.
 * @return Always returns 0
 */
void com_ioctl_IFACE_SERIAL2(uint8_t request, ...)
{
#ifdef NEED_RAW_MODE
   com_ioctl_helper_raw(1);
#else
   com_ioctl_helper(1);
#endif
}

#define com_mode_helper(uart_num, mode)				\
   switch(mode) {						\
   case IF_OFF:							\
   case IF_STANDBY:						\
   case IF_IDLE:						\
      UART_DISABLE_RX_INT##uart_num();				\
      rx_state##uart_num = rx_state_preamble##uart_num;		\
      break;							\
   case IF_LISTEN:						\
      /* Start recving in the idle state */			\
      rx_state##uart_num = rx_state_preamble##uart_num;		\
      rx_index##uart_num = 0;					\
      /* Turn on the receiver and rx interrupt*/		\
      UART_ENABLE_RX_INT##uart_num();				\
      break;							\
   default:							\
      break;							\
   }

/** @brief Uart mode function. 
 * @param mode Mode
 * @return Always returns 0
 */
void com_mode_IFACE_SERIAL(uint8_t mode)
{
#ifndef RAW_MODE_UART0
   com_mode_helper(0, mode);
#endif
}

/** @brief Uart mode function. 
 * @param mode Mode
 * @return Always returns 0
 */
void com_mode_IFACE_SERIAL2(uint8_t mode)
{
#ifndef RAW_MODE_UART1
   com_mode_helper(1, mode);
#endif
}

/********************************************************************
 ********************************************************************
 ************  Here begins the state machines ***********************
 ********************************************************************
 ********************************************************************/


#define rx_state_preamble_helper(uart_num, reg)				\
   if(reg == PREAMBLE)							\
      rx_index##uart_num++;						\
   else									\
      rx_index##uart_num = 0;						\
   if(rx_index##uart_num == PREAMBLE_SIZE) {				\
      if(rx_buf##uart_num)						\
	 rx_state##uart_num = rx_state_size##uart_num;			\
      else {								\
	 if(rx_buf##uart_num)						\
	    rx_state##uart_num = rx_state_size##uart_num;		\
	 else								\
	    rx_state##uart_num = rx_state_preamble##uart_num;		\
	 com_swap_bufs(IFACE_SERIAL + uart_num, NULL, &rx_buf##uart_num); \
      }									\
   }

#define rx_state_size_helper(uart_num, reg)			\
   rx_buf##uart_num->size = reg;				\
   if(rx_buf##uart_num->size > COM_DATA_SIZE) {			\
      rx_state##uart_num = rx_state_preamble##uart_num;		\
   } else {							\
      rx_state##uart_num = rx_state_data##uart_num;		\
      rx_index##uart_num = 0;					\
   }

#define rx_state_data_helper(uart_num, reg)			\
   rx_buf##uart_num->data[rx_index##uart_num++] = reg;		\
   if(rx_index##uart_num == rx_buf##uart_num->size) {		\
      rx_state##uart_num = rx_state_preamble##uart_num;		\
      rx_index##uart_num = 0;					\
      com_swap_bufs(IFACE_SERIAL + uart_num, rx_buf##uart_num, &rx_buf##uart_num);	\
   }

#define tx_state_preamble_helper(uart_num, reg)		\
   reg = PREAMBLE;					\
   tx_index##uart_num++;				\
   if(tx_index##uart_num == PREAMBLE_SIZE)		\
      tx_state##uart_num = tx_state_size##uart_num;

#define tx_state_size_helper(uart_num, reg)		\
   reg = tx_buf##uart_num->size;			\
   tx_state##uart_num = tx_state_data##uart_num;	\
   tx_index##uart_num = 0;

#define tx_state_data_helper(uart_num, reg)				\
   if(tx_index##uart_num == tx_buf##uart_num->size) {			\
      UART_DISABLE_TX_INT##uart_num();					\
      tx_index##uart_num = 0;						\
      tx_state##uart_num = tx_state_preamble##uart_num;			\
      mos_sem_post(&tx_sem##uart_num);					\
   } else {								\
      reg = tx_buf##uart_num->data[tx_index##uart_num++];		\
   }

#ifndef RAW_MODE_UART0
static void rx_state_preamble0(void)
{
   rx_state_preamble_helper(0, RX_REG0)
}

static void rx_state_size0(void)
{
   rx_state_size_helper(0, RX_REG0)
}

static void rx_state_data0(void)
{
   rx_state_data_helper(0, RX_REG0)
}

static void tx_state_preamble0(void)
{
   tx_state_preamble_helper(0, TX_REG0)
}

static void tx_state_size0(void)
{
   tx_state_size_helper(0, TX_REG0)
}

static void tx_state_data0(void)
{
   tx_state_data_helper(0, TX_REG0)
}
#endif

#ifndef RAW_MODE_UART1
static void rx_state_preamble1(void)
{
   rx_state_preamble_helper(1, RX_REG1)
}

static void rx_state_size1(void)
{
   rx_state_size_helper(1, RX_REG1)
}

static void rx_state_data1(void)
{
   rx_state_data_helper(1, RX_REG1)
}

static void tx_state_preamble1(void)
{
   tx_state_preamble_helper(1, TX_REG1)
}

static void tx_state_size1(void)
{
   tx_state_size_helper(1, TX_REG1)
}

static void tx_state_data1(void)
{
   tx_state_data_helper(1, TX_REG1)
}
#endif

#ifdef NEED_RAW_MODE
#define rx_raw_state_helper(uart_num, reg)			\
   *(rx_raw_buf##uart_num + rx_index##uart_num++) = reg;	\
   if(rx_index##uart_num >= rx_raw_max##uart_num) {		\
      mos_sem_post(&rx_sem##uart_num);				\
   }

#define tx_raw_state_helper(uart_num, reg)			\
   reg = *(tx_raw_buf##uart_num + tx_index##uart_num++);	\
   if(tx_index##uart_num >= tx_raw_max##uart_num) {		\
      mos_sem_post(&tx_sem##uart_num);				\
   }

static void rx_raw0(void)
{
   rx_raw_state_helper(0, RX_REG0);
}

static void tx_raw0(void)
{
   tx_raw_state_helper(0, TX_REG0);
}

static void rx_raw1(void)
{
   rx_raw_state_helper(1, RX_REG1);
}

static void tx_raw1(void)
{
   tx_raw_state_helper(1, TX_REG1);
}

#endif

#ifdef ARCH_AVR

SIGNAL(SIG_UART0_DATA)
{
   tx_state0();
}

SIGNAL(SIG_UART0_RECV)
{
   rx_state0();
}

SIGNAL(SIG_UART1_DATA)
{
   tx_state1();
}
SIGNAL(SIG_UART1_RECV)
{
   rx_state1();
}

#endif

#ifdef PLATFORM_TELOSB

interrupt (UART0TX_VECTOR) uart0_tx_int(void)
{
   tx_state0();
}

interrupt (UART0RX_VECTOR) uart0_rx_int(void)
{
   rx_state0();
}

interrupt (UART1TX_VECTOR) uart1_tx_int(void)
{
   tx_state1();
}

interrupt (UART1RX_VECTOR) uart1_rx_int(void)
{
   rx_state1();
}

#endif

#endif //if defined(UART) || !defined(SCONS)
#endif //ifndef platform linux