关于两个串口干扰问题

发布于 2011-07-19 13:15:03 浏览：4137 订阅该版

您好，老大，在调试两个串口UART2和UART3的过程中，我碰到了一个问题，请您百忙之中，能给解惑一下，万分感激！问题描述如下：

串口UART2 做了一个接收数据的消息队列，UART3也做了一个接收消息的队列；UART2可以很通顺的从上位机接收数据，可是UART3却在接收数据的时候，数据有时候会产生错误！如果把UART2屏蔽掉，则UART3能顺利接收数据！望您给解答下！谢谢！
```
struct rx_msg
{
	rt_device_t dev;
	rt_size_t size;
};
struct rx_msg msgcomm2;
struct rx_msg msgcomm3;

rt_device_t dev_Commuart2;
rt_device_t dev_Commuart3;

//消息队列控制块
static struct rt_messagequeue mq_comm2;
static struct rt_messagequeue mq_comm3;
//消息队列中用到的放置消息的内存池

static char msg_pool_comm2[1024];
static char msg_pool_comm3[1024];
//用于接收消息的消息队列
static rt_mq_t rx_mqcomm2;
static rt_mq_t rx_mqcomm3;
//接收线程的接收缓冲区

char uart2_rx_buffer[RxMax_Num];
 char uart2_tx_buffer[RxMax_Num];
 char uart3_rx_buffer[RxMax_Num];
 char uart3_tx_buffer[RxMax_Num];
//数据处理缓冲区
 char Data_buffer[256];
//数据处理标志
 unsigned char Comm2RXlength;
 unsigned char Comm3RXlength;
 unsigned char completeComm2Sign;
 unsigned char completeComm3Sign;
 unsigned char SendDataComm2Long;
 unsigned char SendDataComm3Long;

//接收数据线程

static rt_thread_t Commuart2 = RT_NULL;
static rt_thread_t Commuart3 = RT_NULL;
//处理数据线程
static rt_thread_t Manageuart2 = RT_NULL;
static rt_thread_t Manageuart3 = RT_NULL;
//========================================================================================

//========================================================================================

//数据达到回调函数	COMM2
rt_err_t Commuart2input(rt_device_t dev, rt_size_t size)
{

msgcomm2.dev = dev;
	msgcomm2.size = size;
	//发送消息到消息队列中
	rt_mq_send(rx_mqcomm2, &msgcomm2, sizeof(struct rx_msg));
	
	return RT_EOK;
}

//数据达到回调函数	COMM3
rt_err_t Commuart3input(rt_device_t dev, rt_size_t size)
{

msgcomm3.dev = dev;
	msgcomm3.size = size;
	//发送消息到消息队列中
	rt_mq_send(rx_mqcomm3, &msgcomm3, sizeof(struct rx_msg));
	
	return RT_EOK;
}

//GPRS控制端口初始化
void CommunicationInit(void)
{

//UART2 
	dev_Commuart2 = rt_device_find("uart2");
	if (dev_Commuart2 != RT_NULL)
	{
		rt_device_set_rx_indicate(dev_Commuart2, Commuart2input);
		rt_device_open(dev_Commuart2, RT_DEVICE_OFLAG_RDWR);
	} 
	//recall  uart
	dev_Commuart3 = rt_device_find("uart3");
	if (dev_Commuart3 != RT_NULL)
	{
		rt_device_set_rx_indicate(dev_Commuart3, Commuart3input);
		rt_device_open(dev_Commuart3, RT_DEVICE_OFLAG_RDWR);
	}
	//消息对列2
	rx_mqcomm2 = &mq_comm2;
	//初始化COMM2消息队列//
	rt_mq_init(rx_mqcomm2,"mqtcomm2",&msg_pool_comm2[0],sizeof(msgcomm2),sizeof(msg_pool_comm2),RT_IPC_FLAG_FIFO);
	//消息对列3
	rx_mqcomm3 = &mq_comm3;
	//初始化COMM2消息队列//
	rt_mq_init(rx_mqcomm3,"mqtcomm3",&msg_pool_comm3[0],sizeof(msgcomm3),sizeof(msg_pool_comm3),RT_IPC_FLAG_FIFO);

//---------------创建数据接收线程-------------------------------------------------
	Commuart2 = rt_thread_create("SendtoUart2",
	      						  ReceiveUart2Data, RT_NULL,
								  1024, 10, 20);
	if (Commuart2 != RT_NULL)
	{
		rt_thread_startup(Commuart2);
	}
	 
	
	Commuart3 = rt_thread_create("SendtoUart3",
	      						  ReceiveUart3Data, RT_NULL,
								  1024, 9, 20);
	if (Commuart3 != RT_NULL)
	{
		rt_thread_startup(Commuart3);
	}
	//====================数据处理线程============================================
	
	Manageuart2 = rt_thread_create("MangerUart2",
	      						  ManageComm2Data, RT_NULL,
								  1024, 12, 20);
	if (Manageuart2 != RT_NULL)
	{
		rt_thread_startup(Manageuart2);
	}

// 转发UART3数据到UART1
	Manageuart3 = rt_thread_create("MangerUart3",
	      						  ManageComm3Data, RT_NULL,
								  1024, 13, 20);
	if (Manageuart3 != RT_NULL)
	{
		rt_thread_startup(Manageuart3);
	}

//--------------------end-----------------------------------------------------
}

//接收UART2数据
void ReceiveUart2Data(void* parameter)
{

rt_err_t result = RT_EOK;

rt_uint32_t rx_length;

unsigned char i;
	
	while(1)
	{
	     
		//从消息队列中读取消息
		result = rt_mq_recv(rx_mqcomm2, &msgcomm2, sizeof(struct rx_msg), 100);

if (result == RT_EOK)
		{
			
			rx_length = (sizeof(uart2_rx_buffer) - 1) > msgcomm2.size ?
			msgcomm2.size : sizeof(uart2_rx_buffer) - 1;
			//读取消息
			rx_length = rt_device_read(msgcomm2.dev, 0, &uart2_rx_buffer[Comm2RXlength], rx_length);//rt_serial_read//	 rt_device_read
			//uart_rx_buffer[rx_length] = '�';

Comm2RXlength +=  rx_length;			
		}

//成功收到消息
		if ((result != RT_EOK)&&(Comm2RXlength != 0))
		{
		   completeComm2Sign = 1;
		   SendDataComm2Long = Comm2RXlength;
		   if(SendDataComm2Long > 0)
		   {
		        //复制到数据缓冲区
				for(i = 0; i < (SendDataComm2Long); i ++)
				{
				    Data_buffer* = uart2_rx_buffer*;
				} 
		   }
		   Comm2RXlength = 0;
		}
		
		rt_thread_delay(10);
	}

}

//接收UART3数据
void ReceiveUart3Data(void* parameter)
{

rt_err_t result = RT_EOK;

rt_uint32_t rx_length;

unsigned char i;
	
	while(1)
	{
	     
		//从消息队列中读取消息
		result = rt_mq_recv(rx_mqcomm3, &msgcomm3, sizeof(struct rx_msg), 100);

if (result == RT_EOK)
		{
			
			rx_length = (sizeof(uart3_rx_buffer) - 1) > msgcomm3.size ?
			msgcomm3.size : sizeof(uart3_rx_buffer) - 1;
			//读取消息
			rx_length = rt_device_read(msgcomm3.dev, 0, &uart3_rx_buffer[Comm3RXlength], rx_length);//rt_serial_read//	 rt_device_read
			//uart_rx_buffer[rx_length] = '�';

Comm3RXlength +=  rx_length;			
		}
		
		//成功收到消息
		if ((result != RT_EOK)&&(Comm3RXlength != 0))
		{
		   completeComm3Sign = 1;
		   SendDataComm3Long = Comm3RXlength;
		   if(SendDataComm3Long > 0)
		   {
		        //复制到数据缓冲区
				for(i = 0; i < (SendDataComm3Long); i ++)
				{
				    Data_buffer* = uart3_rx_buffer*;
				} 
		   }
		   Comm3RXlength = 0;
		}
		rt_thread_delay(10);
	}

}

//处理UNRT2接收数据
void ManageComm2Data(void* parameter)
{
    //unsigned char i;

while(1)
	{

if((completeComm2Sign == 1)&&(SendDataComm2Long != 0))
	   {
	       completeComm2Sign = 0;
	       rt_device_write(dev_Commuart2, 0,&Data_buffer[0],SendDataComm2Long);//0x14

SendDataComm2Long = 0;
	   }
	   rt_thread_delay(10);
	}
}

//处理UNRT3接收数据
void ManageComm3Data(void* parameter)
{
	
		
	while(1)
	{

if((completeComm3Sign == 1)&&(SendDataComm3Long != 0))
	   {
	       completeComm3Sign = 0;
	       rt_device_write(dev_Commuart3, 0,&Data_buffer[0],SendDataComm3Long);//0x14
		   SendDataComm3Long = 0;
	   }
	   rt_thread_delay(10);
	}
}
```