关于串口驱动框架的一些建议

发布于 2010-01-15 15:18:53 浏览：10872 订阅该版

在 serial.c 的 rt_serial_write 中
```c
		/* DMA mode Tx */

/* allocate a data node */
		struct stm32_serial_data_node* data_node =
			(struct stm32_serial_data_node*) rt_malloc (sizeof(struct stm32_serial_data_node));
		if (data_node == RT_NULL)
		{
			/* set error code */
			err_code = -RT_ENOMEM;
		}
```
只看到rt_malloc 申请内存块，没有看到释放内存块，时间长了就申请不到内存了。好象以前看到过这个问题，应该被修正了，但今天重新check out代码，还是这样的，不知道何故。

另外，建议将串口封装得更加方便些，可不可以这样做：
```c
#ifdef RT_USING_UART1
  #if (UART1_RX_MODE == INT)
    struct stm32_serial_int_rx uart1_int_rx;
  #endif
  #if (UART1_RX_MODE == DMA)
    struct stm32_serial_dma_rx uart1_dma_rx;
  #endif
  #if (UART1_TX_MODE == INT)
    struct stm32_serial_int_tx uart1_int_tx;
  #endif
  #if (UART1_TX_MODE == DMA)
    struct stm32_serial_dma_tx uart1_dma_tx;
  #endif
  struct stm32_serial_device uart1 =
  {
	USART1,
    #if (UART1_RX_MODE==INT)
	  &uart1_int_rx,
    #else
      RT_NULL,
    #endif
    #if (UART1_RX_MODE==DMA)
	  &uart1_dma_rx,
    #else
      RT_NULL,
    #endif
    #if (UART1_TX_INT==INT)
	  &uart1_int_tx,
    #else
      RT_NULL,
    #endif
    #if (UART1_TX_DMA==DMA)
	  &uart1_dma_tx
    #else
      RT_NULL
    #endif
  };
  struct rt_device uart1_device;
#endif
```
可以将所有串口的参数定义一个二维数组，初始化采用条件编译，不会增加空间，用户也可以不用管细节，直接定义一下，就能初始化。
当然工作量有些大，毕竟`uart.c uart.h serial.c serial.h stm32f10x_it.c`这些都需要改动。

但我想单片机用得最多的外设还是串口，这样能减少系统出错的可能性，用户方便，才是好推广的条件之一。

12 个回答

bernard 2010-01-16

这家伙很懒，什么也没写！

coldfish 2010-01-16

这家伙很懒，什么也没写！

coldfish 2010-01-20

这家伙很懒，什么也没写！

抽空把serial device改了一下，将中断发送、接收缓冲改为动态申请，缓冲大小在rtconfig.h中定义
同时将接收、发送模式定义也放到rtconfig.h中，采用条件编译。
例如在rtconfig.h中
```c
#define RT_USING_UART1
#define UART1_BAUDRATE  115200
#define UART1_TX_MODE   INT
#define UART1_RX_MODE   POLL
#define UART1_RX_BUF_SIZE 512
#define UART1_TX_BUF_SIZE 128

#define RT_USING_UART2
#define UART2_BAUDRATE  9600
#define UART2_TX_MODE   INT
#define UART2_RX_MODE   POLL
#define UART2_RX_BUF_SIZE 256
#define UART2_TX_BUF_SIZE 128

#define RT_USING_UART3
#define UART3_BAUDRATE  115200
#define UART3_TX_MODE   INT
#define UART3_RX_MODE   POLL
#define UART3_RX_BUF_SIZE 512
#define UART3_TX_BUF_SIZE 128
```
在serial.c中设备初始化修改为
```c
rt_err_t rt_hw_serial_register(rt_device_t device, const char* name, rt_uint32_t flag, struct stm32_serial_device *serial,rt_uint16_t rx_bufsize,rt_uint16_t tx_bufsize)
{
	RT_ASSERT(device != RT_NULL);
    rt_uint8_t* uart1_rx_buf = rt_malloc (rx_bufsize);//仅为测试，未用内存申请检查
    rt_uint8_t* uart1_tx_buf = rt_malloc (tx_bufsize);
    serial->int_rx->rx_buffer=uart1_rx_buf;
    serial->int_rx->rx_buffer_size=rx_bufsize;
    serial->int_tx->tx_buffer=uart1_tx_buf;
    serial->int_tx->tx_buffer_size=tx_bufsize;

device->type 		= RT_Device_Class_Char;
	device->rx_indicate = RT_NULL;
	device->tx_complete = RT_NULL;
	device->init 		= rt_serial_init;
	device->open		= rt_serial_open;
	device->close		= rt_serial_close;
	device->read 		= rt_serial_read;
	device->write 		= rt_serial_write;
	device->control 	= rt_serial_control;
	device->private		= serial;

/* register a character device */
	return rt_device_register(device, name, RT_DEVICE_FLAG_RDWR | flag);
}
```
在stm32f10x_it.c中对中断也进行了条件编译
例如：
```c
void USART2_IRQHandler(void)
{
#ifdef RT_USING_UART2
    extern struct rt_device uart2_device;
	extern void rt_hw_serial_isr(struct rt_device *device);

/* enter interrupt */
    rt_interrupt_enter();

rt_hw_serial_isr(&uart2_device);

/* leave interrupt */
    rt_interrupt_leave();
#endif
}
```
现在DMA还没考虑好，因为一个DMA通道有几个设备共用，需要好好规划一下，看用什么方式比较好。

请bernard 提些意见和建议

coldfish 2010-01-20

这家伙很懒，什么也没写！

coldfish 2010-01-21

这家伙很懒，什么也没写！

很奇怪，在编译中选择优化为低，长时间后会死，而且不出现RTT的错误信息（没有SP什么的寄存器值打印出来），中断后能继续执行，但单步不知道会走到什么地方，经常执行到USART_GetITStatus里面。是不是系统负荷太重？
在编译优化选择为最高时，好象正常（已经测试了2个小时）
测试程序是创建两个线程，一个为GPS，一个为GSM，分别从usart1和usart2读数据，然后通过usart3(rt_kpringf())输出，对于usart3用了信号量进行访问互诉。
在NVIC中现在设置为：
```c
static void NVIC_Configuration(void)
{
	NVIC_InitTypeDef NVIC_InitStructure;

/* Configure the NVIC Preemption Priority Bits */
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);

#ifdef RT_USING_UART1
	/* Enable the USART1 Interrupt */
	NVIC_InitStructure.NVIC_IRQChannel = uart1_conf.INT_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
	NVIC_Init(&NVIC_InitStructure);
#endif

#ifdef RT_USING_UART2
	/* Enable the USART2 Interrupt */
	NVIC_InitStructure.NVIC_IRQChannel = uart2_conf.INT_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
	NVIC_Init(&NVIC_InitStructure);
#endif

#ifdef RT_USING_UART3
	/* Enable the USART3 Interrupt */
	NVIC_InitStructure.NVIC_IRQChannel = uart3_conf.INT_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
	NVIC_Init(&NVIC_InitStructure);
#endif
}
```
自己想不明白，请版主指点
gsm.c为：
```c
#include "wchar.h"
#include "gsm.h"

struct rt_thread gsm_thread;
static char gsm_thread_stack[1024];
rt_device_t gsm_device;
extern struct rt_semaphore uart3_sem;
struct rt_semaphore gsm_sem;

static rt_err_t gsm_rx_ind(rt_device_t dev, rt_size_t size)
{
	/* release semaphore to let gps thread rx data */
	rt_sem_release(&gsm_sem);
	return RT_EOK;
}

void gsm_set_device(char* device_name)
{
	rt_device_t dev = RT_NULL;

dev = rt_device_find(device_name);
	if (dev != RT_NULL && rt_device_open(dev, RT_DEVICE_OFLAG_RDWR) == RT_EOK)
	{
		if (gsm_device != RT_NULL)
		{
			/* close old finsh device */
			rt_device_close(gsm_device);
		}
		rt_device_set_rx_indicate(dev, gsm_rx_ind);
		gsm_device = dev;
	}
	else
	{
		rt_kprintf("Can not find GSM device:%s
", device_name);
	}
}

void gsm_buf_clear(void)
{
  char ch;
  while(rt_sem_take(&gsm_sem,0)==RT_EOK){};
  while(1==rt_device_read(gsm_device,0,&ch,1)){};
}

rt_err_t at_cmd(char * cmd,char * resultchar,int size,int waittime)
{
    unsigned char len;
    char *ptr;
    char ch;
    ptr=resultchar;
    rt_memset(resultchar,0,size);
    len=rt_strlen(cmd);
    gsm_buf_clear();
    rt_device_write(gsm_device,0,cmd,len);
    rt_thread_delay(waittime);
    while(rt_sem_take(&gsm_sem, waittime) == RT_EOK)
    {
        if(1==rt_device_read(gsm_device, 0, &ch,1))
            *ptr++=ch;
    }
    return (ptr-resultchar);
}

rt_bool_t at_test(void)
{
    rt_err_t len;
    char buf[16];
    rt_device_write(gsm_device,0,"AT
",3);
    rt_thread_delay(20);
    rt_memset(buf,0,16);
    len=rt_device_read(gsm_device, 0, &buf[0],16);
    if ((len>5)&&(rt_strstr(buf,"OK
")))
      return RT_TRUE;
    else 
      return RT_FALSE;
}

void gsm_thread_entry(void* parameter)
{
//	int  pos ;
    static rt_uint16_t cont=0;
    static char buf[512];
//    rt_thread_delay(1500);
    gsm_set_device("gsm");
//    while (RT_TRUE!=at_test());
	while (1)
	{
        at_cmd("AT+CMGF=0
",buf,sizeof(buf),20);
        if (rt_sem_take(&uart3_sem, -1) == RT_EOK)
        {
            rt_kprintf("%s
",&buf[0]);
            rt_sem_release(&uart3_sem);
        }
        at_cmd("AT+CMGR=8
",buf,sizeof(buf),20);
        if (rt_sem_take(&uart3_sem, -1) == RT_EOK)
        {
            rt_kprintf("%s
",&buf[0]);
            rt_kprintf("COUNTER=>> %d

",cont++);
            rt_sem_release(&uart3_sem);
        }
//        rt_thread_delay(100);
	}
}

void rt_gsm_thread_init(void)
{
	rt_sem_init(&gsm_sem, "gsm_sem", 0, 0);
	rt_thread_init(&gsm_thread,
		"gsm",
		gsm_thread_entry, RT_NULL,
		&gsm_thread_stack[0], sizeof(gsm_thread_stack),
		21, 100);
	rt_thread_startup(&gsm_thread);
}
```
gps.c为：
```c
#include <rtthread.h>
#include <rthw.h>

#include "gps.h"

enum gps_stat
{
	WAIT_DOLLAR,
	WAIT_G,
	WAIT_P,
	WAIT_R,
	WAIT_M,
	WAIT_C,
    WAIT_Data,
};

struct POI
{
  double LON;
  double LAT;
};

struct POI LastP,CurP;

/* gps thread */
struct rt_thread gps_thread;
char gps_thread_stack[512];
char GPSBuf[128];
struct rt_semaphore gps_sem;
extern struct rt_semaphore uart3_sem;
rt_device_t gps_device;

static rt_err_t gps_rx_ind(rt_device_t dev, rt_size_t size)
{
	/* release semaphore to let gps thread rx data */
	rt_sem_release(&gps_sem);

return RT_EOK;
}

void gps_set_device(char* device_name)
{
	rt_device_t dev = RT_NULL;

dev = rt_device_find(device_name);
	if (dev != RT_NULL && rt_device_open(dev, RT_DEVICE_OFLAG_RDWR) == RT_EOK)
	{
		if (gps_device != RT_NULL)
		{
			/* close old finsh device */
			rt_device_close(gps_device);
		}

gps_device = dev;
		rt_device_set_rx_indicate(dev, gps_rx_ind);
	}
	else
	{
		rt_kprintf("Can not find GPS device:%s
", device_name);
	}
}

void gps_thread_entry(void* parameter)
{
    static char line[256];
	int  pos ;
	enum gps_stat gpsstat;

gpsstat = WAIT_DOLLAR;
    gps_set_device("gps");
	while (1)
	{
		pos = 0;
		while (1)
		{
			if (rt_sem_take(&gps_sem, -1) == RT_EOK)
			{
				/* read one character from serial */
				char ch;

rt_err_t rx_result;
				rx_result = rt_device_read(gps_device, 0, &ch, 1);
				if (ch != 0 && rx_result == 1)
				{
					if (gpsstat == WAIT_DOLLAR)
					{
						if (ch == '$')
						{
							gpsstat = WAIT_G;
							continue;
						}
					}
                    
					if (gpsstat == WAIT_G)
					{
						if (ch == 'G')
						{
							gpsstat = WAIT_P;
							continue;
						}
						else
                          gpsstat = WAIT_DOLLAR;
					}

if (gpsstat == WAIT_P)
					{
						if (ch == 'P')
						{
							gpsstat = WAIT_R;
							continue;
						}
						else
                          gpsstat = WAIT_DOLLAR;
					}

if (gpsstat == WAIT_R)
					{
						if (ch == 'R')
						{
							gpsstat = WAIT_M;
							continue;
						}
						else
                          gpsstat = WAIT_DOLLAR;
					}

if (gpsstat == WAIT_M)
					{
						if (ch == 'M')
						{
							gpsstat = WAIT_Data;
							continue;
						}
						else
                          gpsstat = WAIT_DOLLAR;
					}
                    
					if (gpsstat == WAIT_Data)
					{
						if (ch != '*')
						{
							line[pos++]=ch;
							continue;
						}
						else
                        {
                            line[pos]=0;
                            rt_memcpy(GPSBuf,line,rt_strlen(line));
                            if (1==DecodeGPS()) 
                                    GPIO_WriteBit(GPIOB, GPIO_Pin_8, (BitAction)((1-GPIO_ReadOutputDataBit(GPIOB, GPIO_Pin_8))));
            			    if ((rt_strlen(GPSBuf)>10)&&(rt_sem_take(&uart3_sem, -1) == RT_EOK))
                            {
                     		  rt_kprintf("%s
", GPSBuf);
                              rt_sem_release(&uart3_sem);
                            }
                            pos=0;
                            gpsstat = WAIT_DOLLAR;
                        }
					}

}
			}
		}

}
}

void rt_gps_thread_init(void)
{
	rt_sem_init(&gps_sem, "gps_sem", 0, 0);
//	rt_sem_init(&gps_buf, "gps_buf", 0, 0);

rt_thread_init(&gps_thread,
		"gps",
		gps_thread_entry, RT_NULL,
		&gps_thread_stack[0], sizeof(gps_thread_stack),
		30, 100);
	rt_thread_startup(&gps_thread);
}

double DFM2D(double D,double F,double M)
{
  return (D+F/60+M/3600);
}

u8 CheckNumber(char * txt)//正确返回0
{
  u8 i,j;
  i=rt_strlen(txt);
  if (i==0) return 1;
  for (j=0;j<i;j++)
    if ((txt[j]>0x39)||(txt[j]<0x2E))
      return 1;
  return 0;
}

char DecodeGPS(void)
{
//$GPRMC,121252.000,A,3958.3032,N,11629.6046,E,15.15,359.95,070306,,,A*54
//C,152757.067,A,3202.3859,N,11844.0654,E,0.00,358.24,100809,,,A*6F
//0123456789012345678901234567890123456789012345678901234567890123456789
//0         1         2         3         4         5         6         
struct GPRMC
  {
  u8 PosE[15];
//  u8 PosEF[2];
  u8 PosN[15];
//  u8 PosNF[2];
  u8 PosDate[15];
  u8 PosTime[15];
//  u8 PosV[15];
//  u8 PosR[150];
//  u8 PosA[2];
  };
  struct GPRMC rmc;
  u8 i,j;
  int E,N;
  int Day,Month,Year;   
  int Hour,Minute,Second;
  float Ed,Em,Es;   
  float Nd,Nm,Ns;   
  u8 DayOfMonth[12]={31,28,31,30,31,30,31,31,30,31,30,31};
  rt_memset(&rmc,0,sizeof(rmc));
  for (j=0,i=2;GPSBuf[i]!=',';i++) rmc.PosTime[j++]=GPSBuf[i];
  for (j=0,i++;GPSBuf[i]!=',';i++) ;//rmc.PosA[j++]=GPSBuf[i];
  for (j=0,i++;GPSBuf[i]!=',';i++) rmc.PosN[j++]=GPSBuf[i];
  for (j=0,i++;GPSBuf[i]!=',';i++) ;//rmc.PosNF[j++]=GPSBuf[i];
  for (j=0,i++;GPSBuf[i]!=',';i++) rmc.PosE[j++]=GPSBuf[i];
  for (j=0,i++;GPSBuf[i]!=',';i++) ;//rmc.PosEF[j++]=GPSBuf[i];
  for (j=0,i++;GPSBuf[i]!=',';i++) ;//rmc.PosV[j++]=GPSBuf[i];
  for (j=0,i++;GPSBuf[i]!=',';i++) ;//rmc.PosR[j++]=GPSBuf[i];
  for (j=0,i++;GPSBuf[i]!=',';i++) rmc.PosDate[j++]=GPSBuf[i];

//  GPSCounter=0;

//  if (CheckNumber((char*)rmc.PosDate)||CheckNumber((char*)rmc.PosTime)||CheckNumber((char*)rmc.PosE)||CheckNumber((char*)rmc.PosN))
//    return 0;
//  sscanf((char*)rmc.PosDate, "%02d%02d%02d", &Day,&Month,&Year);   
//  sscanf((char*)rmc.PosTime, "%02d%02d%02d", &Hour,&Minute,&Second);
//  sscanf((char*)rmc.PosE, "%3d%2d.%4d", &Ed,&Em,&E);   
//  sscanf((char*)rmc.PosN, "%2d%2d.%4d", &Nd,&Nm,&N);   
//  Es=0.006*(double)E+0.005;
//  Ns=0.006*(double)N+0.005;
  Hour+=8;Year+=2000;
  if (Hour>23)//TimeZone+8
  {
    Hour-=24;Day++;
    if (Year%400==0||(Year%4==0&&Year%100!=0))  //闰年2月为29日
      DayOfMonth[1]=29;
    if (Day>DayOfMonth[Month-1])
    {
      Day=1;Month++;
    }
    if (Month>12) Year++;
  }
//  CurP.LAT=DFM2D(Ed,Em,Es);
//  CurP.LON=DFM2D(Nd,Nm,Ns);
  if (GPSBuf[13]!='A')
    return 0;

return 1;
}

//返回当前和上次保存两点间的距离,单位米
double GetDistance(void)
{
  const double Pi = 3.1415926535898;
  const double Dt = 111199.233;
  double a,b,s;
  a=(LastP.LAT-CurP.LAT)*Dt;
  b=(LastP.LON-CurP.LON)*Dt*cos((LastP.LAT-CurP.LAT)*Pi/180);
  s=sqrt(a*a+b*b);
  return s;
}

void SaveCurPOI(void)
{
  LastP.LAT=CurP.LAT;
  LastP.LON=CurP.LON;
}
/*@}*/
```