0904_PT/BSP/queue.c

/**
  ********************************  STM32F0xx  *********************************
  * @文件名     ： queue.c
  * @作者       ： sun
  * @库版本     ： V1.5.0
  * @文件版本   ： V1.0.0
  * @日期       ： 2016年06月10日
  * @摘要       ：循环队列源文件
  ******************************************************************************/
	
#include "queue.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//#include "uart.h"

/********************************
创建空循环队列
********************************/
sequeue_t * Create_Empty_Sequeue(uint8_t row,uint16_t col)
{
//    uint8_t i,j;
//	uint8_t i;
	sequeue_t * sq;

	sq = (sequeue_t *)malloc(sizeof(sequeue_t));
	if (sq == NULL) {
		QUEUE_DEBUG_F("error,sq == NULL\n");
		return NULL;
	}
	memset(sq,0,sizeof(sequeue_t));
	sq->data = (uint8_t **)malloc(sizeof(int*) * row);  //sizeof(int*),不能少*，一个指针的内存大小，每个元素是一个指针。

	memset(sq->data,0,sizeof(int*) * row);
//		for (i = 0;i < row;i++)
//			{
//					sq->data[i] = (uint8_t*)malloc(sizeof(uint8_t ) * col);
//					if (sq->data[i] == NULL) {
//            QUEUE_DEBUG_F("error,sq->data[i] == NULL\n");
//            return NULL;
//          }
//          memset(sq->data[i],0,sizeof(uint8_t ) * col);
//			}
	/*
	for (i = 0;i < row;i++)
	{
		for (j = 0;j < col;j++)
		{
			QUEUE_DEBUG("%p  ",&(sq->data[i][j]));
		}
		QUEUE_DEBUG("\n");
	}
	*/
    sq->depth = row;
    sq->width = col;
	sq->sum = 0;
	sq->rear = 0;
    return sq;
}
/********************************
检查循环队列是否为空
********************************/
int8_t Check_Seqeue_Empty(sequeue_t * sq)
{
    //return (sq->front == sq->rear);
	return (sq->sum == 0);
}

/********************************
检查循环队列是否为满
********************************/
int8_t Check_Seqeue_Full(sequeue_t * sq)
{
    //return (sq->sum >= SQ_DEPTH);
	return (sq->sum >= sq->depth);
}
/********************************
插入队列，插入1条记录
参数	sq	插入的队列
		p	插入的数据
		sizeof_p	插入数组的长度
		l	插入的数据长度
********************************/
int16_t En_Queue(sequeue_t *sq ,uint8_t *p,uint16_t sizeof_p,uint16_t l)
{
	uint16_t i=0;
	uint8_t r=0;

//	printf("1\n");
	//DEBUG1("En_Queue...\r\n");
	if((sq==NULL) || (p==NULL) || (l>=sq->width))	//参数合法判断
		return 0;
	
//	printf("2\n");
	//DEBUG1("En_Queue...\r\n");
	if(Check_Seqeue_Full(sq)) 				//满队列判断
		return 0;
//	printf("3\n");
	//DEBUG1("En_Queue...\r\n");
	r = (sq->rear+1) % (sq->depth);    //循环存储
//	printf("width=%d,r=%d\n",sq->width,r);
	sq->data[r] = (uint8_t*)malloc(sizeof(uint8_t ) * sq->width);//申请内存
	memset(sq->data[r],0,sizeof(uint8_t ) * sq->width);
	
//	printf("en len:%d,%02x,%02x\n",l,sq->data[r][0],sq->data[r][1]);
	sq->data[r][0] = (l&0x00ff);							//长度低位
	sq->data[r][1] = (l&0xff00)>>8;						//长度高位
//	printf("en len:%d,%02x,%02x\n",l,sq->data[r][0],sq->data[r][1]);
	
	for(i=0;i<l;i++){									//记录
		if((i>sizeof_p-1)||(i>sq->width-3))
			break;
		sq->data[r][i+2] = p[i];
	}
	
    sq->rear = r;     								//更新入队标记
    sq->sum++;     										//更新总数标记
	QUEUE_DEBUG1("En_Queue...SQ=0x%08x,sq->rear =%d,sq->sum=%d\r\n",sq,sq->rear,sq->sum);
		
    return l;													//返回插入的记录长度
}

/********************************
出队列，读取1条记录，队列改变
参数	sq	读取的队列
		p	读取的数据
		sizeof_p	接收数组的最大长度
		l	读取的数据长度
********************************/
int16_t De_Queue(sequeue_t * sq,uint8_t *p,uint16_t sizeof_p,uint16_t *l )
{
	uint16_t i=0;
	uint8_t f=0;

	if((sq==NULL) || (p==NULL) || (l==NULL))	//参数合法判断
		return 0;

	if(Check_Seqeue_Empty(sq)) 				//空队列判断
		return 0;


	f = (sq->front+1) % (sq->depth);
	*l = *(uint16_t *)sq->data[f];
	for(i=0;i<*l;i++)
	{
		if((i>sizeof_p-1)||(i>sq->width-3))
			break;
		p[i] = sq->data[f][i+2];
	}
	//val = sq->data[sq->front] ;
	//printf("p| %p ",&(sq->data[sq->front]));

	sq->front = f;										//更新出队标记
	sq->sum--;     										//更新总数标记
	free(sq->data[f]);

	QUEUE_DEBUG1("De_Queue...SQ=0x%08x,sq->front=%d,sq->sum=%d\r\n",sq,sq->front,sq->sum);
	return 1;
}

/********************************
读取队列，读取1条记录，队列不改变
********************************/
int16_t Read_Queue(sequeue_t * sq,uint8_t *p,uint16_t *l)
{
	uint16_t i=0;
	uint8_t f=0;

	if((sq==NULL) || (p==NULL) || (l==NULL))	//参数合法判断
		return 0;

	if(Check_Seqeue_Empty(sq)) 				//空队列判断
		return 0;

	f = (sq->front+1) % (sq->depth);
	*l = *(uint16_t *)sq->data[f];
	for(i=0;i<*l;i++)
		p[i] = sq->data[f][i+2];
	//val = sq->data[sq->front] ;
	//printf("p| %p ",&(sq->data[sq->front]));

	//sq->front = f;										//更新出队标记
	//sq->sum--;     										//更新总数标记
	return 1;
}
/********************************
添加1条空记录到队列，记录第0个元素代表长度，初始长度为0
********************************/
int16_t Add_Blank_Queue(sequeue_t *sq)
{
	uint16_t i=0;
	uint8_t r=0;

	if(sq==NULL)											//参数合法判断
		return 0;


	if(Check_Seqeue_Full(sq)) 				//满队列判断
		return 0;

	r = (sq->rear+1) % (sq->depth);    //循环存储
	sq->data[r] = (uint8_t*)malloc(sizeof(uint8_t ) * sq->width);//申请内存
	memset(sq->data[r],0,sizeof(uint8_t ) * sq->width);

	sq->data[r][0] = 0;								//长度
	sq->data[r][1] = 0;								//长度

	for(i=2;i<sq->width-1;i++)					//记录内容清理
		sq->data[r][i] = 0;

	sq->rear = r;     								//更新入队标记
	sq->sum++;     										//更新总数标记
	return 1;													//返回插入的记录长度
}

/********************************
更新最新1条记录内容，记录尾元添加1个元素，且长度加1
********************************/
uint8_t Update_Queue(sequeue_t *sq ,uint8_t mode,uint8_t val)
{
	uint16_t l=0;
	uint8_t r;
	uint8_t m;

	m = mode;

	if(sq==NULL)											//参数合法判断
		return 1;

	if(Check_Seqeue_Full(sq)) 				//满队列判断
		return 1;

	r = (sq->rear+1) % (sq->depth);   //队列尾

	if(m==0){ 													//注，当前操作的记录是无效的，记录的长度加1，追加数据
		l=sq->data[r][0]+1;

		if(l>=sq->width-1){ 								//记录超过宽度
			sq->data[r][0] = 0;
			return 1;
		}
		sq->data[r][l] = val;
		sq->data[r][0] = l;
	}

	if(m==1){ 								//当前记录，由无效状态变为有效状态，更新rear和sum
		sq->rear = r;
		sq->sum++;
	}

    return 0;
}