爱学习的单片机

单片机-自建C库函数

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文

文章目录

前言

一、位操作运算

二、状态滤波

2.1

2.2

三缓存空间

四滤波算法

4.1 平均值滤波

五环形队列

5.1

5.2

5.3

总结

前言

在单片机开发项目的过程中，有很多与硬件无关的操作，比如位操作、滤波操作等。很多时候我们将它封装成库，在以后的代码编写过程中我们就可以直接移植就可以。

一、位操作运算

#define LIB_SET_UINT32_BIT(Data, Offset)    ((Data) |= (uint32)((uint32)1u << (Offset)))
#define LIB_SET_UINT16_BIT(Data, Offset)    ((Data) |= (uint16)((uint16)1u << (Offset)))
#define LIB_SET_UINT8_BIT(Data, Offset)     ((Data) |= (uint8)((uint8) 1u << (Offset)))

#define LIB_RESET_UINT32_BIT(Data, Offset)  ((Data) &= (uint32)(~(uint32)((uint32)1u << (Offset))))
#define LIB_RESET_UINT16_BIT(Data, Offset)  ((Data) &= (uint16)(~(uint16)((uint16)1u << (Offset))))
#define LIB_RESET_UINT8_BIT(Data, Offset)   ((Data) &= (uint8 )(~(uint8 )((uint8 )1u << (Offset))))

#define LIB_GET_UINT32_BIT(Data, Offset)    (((uint8)(((uint32) (Data)) >> (Offset))) & (uint8)0x01u)
#define LIB_GET_UINT16_BIT(Data, Offset)    (((uint8)(((uint16) (Data)) >> (Offset))) & (uint8)0x01u)
#define LIB_GET_UINT8_BIT(Data, Offset)     (((uint8)(((uint8 ) (Data)) >> (Offset))) & (uint8)0x01u)

#define LIB_GET_BYTE_0(Data)                ((uint8) (Data))
#define LIB_GET_BYTE_1(Data)                ((uint8)((Data)>>(uint8)8u))
#define LIB_GET_BYTE_2(Data)                ((uint8)((Data)>>(uint8)16u))
#define LIB_GET_BYTE_3(Data)                ((uint8)((Data)>>(uint8)24u))

#define LIB_GET_BYTE_LIT_UINT16(Data)		((uint16)Data[0u] + ((uint16)Data[1u] << 8u))
#define LIB_GET_BYTE_BIG_UINT16(Data)		((uint16)Data[1u] + ((uint16)Data[0u] << 8u))

二、状态滤波

2.1

typedef struct Type_FilterStruct
{
    uint8 ucStatus;
    uint8 ucLastStatus;
    uint8 ucValidStatus;
    uint16 usFilterCount;

} LibFilterStruct;

uint8 LIB_StatusFilter( LibFilterStruct *pFilterStatus, uint16 filterMaxCnt )
{
    uint8  e_u_reValue = FALSE;
    uint16 e_w_filterMaxCnt = (uint16)0u;

    if(( filterMaxCnt > (uint16)0u ) && ( filterMaxCnt < LIB_MAXVALUE_16 ))
    {
        e_w_filterMaxCnt = filterMaxCnt;
    }
    else
    {
        e_w_filterMaxCnt = LIB_MAXVALUE_16;
    }

    if( pFilterStatus->ucStatus != pFilterStatus->ucLastStatus )
    {
        pFilterStatus->ucLastStatus = pFilterStatus->ucStatus;
        pFilterStatus->usFilterCount = (uint16)0u;
    }

    if( pFilterStatus->ucStatus != pFilterStatus->ucValidStatus )
    {
        if( pFilterStatus->usFilterCount < e_w_filterMaxCnt )
        {
            pFilterStatus->usFilterCount++;
        }
        else
        {
            pFilterStatus->ucValidStatus = pFilterStatus->ucStatus;
            e_u_reValue = TRUE;
        }
    }
    else
    {
    }

    return (e_u_reValue);
}

该函数的作用：当状态从一个状态切换到另一个状态时，稳定在多长时间不改变表示切换完成。

2.2

uint8 LIB_StatusFilterType2( LibFilterStruct *pFilterStatus, uint16 filterInMaxCnt ,uint16 filterOutMaxCnt)
{
    uint8  e_u_reValue = FALSE;
    uint16 e_w_filterInMaxCnt = (uint16)0u;
    uint16 e_w_filterOutMaxCnt = (uint16)0u;
    if(( filterInMaxCnt > (uint16)0u ) && ( filterInMaxCnt < ((uint16)0xFFFFu) ))
    {
    	e_w_filterInMaxCnt = filterInMaxCnt;
    }
    else
    {
    	e_w_filterInMaxCnt = ((uint16)0xFFFFu);
    }
    if(( filterOutMaxCnt > (uint16)0u ) && ( filterOutMaxCnt < ((uint16)0xFFFFu) ))
    {
    	e_w_filterOutMaxCnt = filterOutMaxCnt;
    }
    else
    {
    	e_w_filterOutMaxCnt = ((uint16)0xFFFFu);
    }

    if( pFilterStatus->ucStatus != pFilterStatus->ucLastStatus )
    {
        pFilterStatus->ucLastStatus = pFilterStatus->ucStatus;
        pFilterStatus->usFilterCount = (uint16)0u;
    }

    if( pFilterStatus->ucStatus != pFilterStatus->ucValidStatus )
    {
    	if(pFilterStatus->ucValidStatus == TRUE)
    	{
    	       if( pFilterStatus->usFilterCount < e_w_filterOutMaxCnt )
    	        {
    	            pFilterStatus->usFilterCount++;
    	        }
    	        else
    	        {
    	            pFilterStatus->ucValidStatus = pFilterStatus->ucStatus;
    	            e_u_reValue = TRUE;
    	        }
    	}
    	else if(pFilterStatus->ucValidStatus == FALSE)
    	{
        	if( pFilterStatus->usFilterCount < e_w_filterInMaxCnt )
            {
                pFilterStatus->usFilterCount++;
            }
            else
            {
                pFilterStatus->ucValidStatus = pFilterStatus->ucStatus;
                e_u_reValue = TRUE;
            }
    	}
    }
    else
    {
    }
    return (e_u_reValue);
}

该函数的作用：在固定时间，状态切换并且维持在稳定的时间。

三缓存空间

typedef struct
{
	uint8  bIsValid;
	uint16 u16QueueLen;
	uint16 u16ItermSize;
	uint16 u1DdataLen;
	uint16  u16Data[CP_ADC_FIFO_ITERM_SIZE];
}fifo_t;
void fifo_init(fifo_t* pFifo, uint16 queueLength,uint16 itermSize)
{
	if((pFifo == NULL) || (queueLength == 0) || (itermSize == 0))
	{
	}
	else
	{
		pFifo->u16QueueLen = queueLength;
		pFifo->u16ItermSize = itermSize;
		for(uint16 i = 0; i < pFifo->u16QueueLen; i++)
		{
			pFifo->bIsValid = 0;
			pFifo->u1DdataLen = 0;
			for(uint16 j = 0; j < itermSize; j++)
			{
				pFifo[i].u16Data[j] = 0;
			}
		}
	}
}

uint8 fifo_get(fifo_t* pFifo,uint16* buf, uint16* len)
{
	uint8 ret = 0;
	if((pFifo == NULL) || (buf == NULL) || (len == NULL))
	{
		ret = 0;
	}
	else
	{
		for(uint16 i = 0; i < pFifo->u16QueueLen; i++)
		{
			if(pFifo[i].bIsValid == 1)
			{
				pFifo[i].bIsValid = 0;
				*len = pFifo[i].u1DdataLen;
				for(uint16 j = 0; j < pFifo[i].u1DdataLen; j++)
				{
					buf[j] = pFifo[i].u16Data[j];
				}
				ret = 1;
				break;
			}
		}
	}
	return ret;
}
uint8 fifo_set(fifo_t* pFifo,uint16* buf, uint16 len)
{
	uint8 ret = 0;
	if((len > CP_ADC_FIFO_ITERM_SIZE) || (pFifo == NULL) || (buf == NULL))
	{
		ret = 0;
	}
	else
	{
		for(uint16 i = 0; i < pFifo->u16QueueLen; i++)
		{
			if(pFifo[i].bIsValid == 0)
			{
				pFifo[i].bIsValid = 1;
				if(len > pFifo[i].u16ItermSize)
				{
					len = pFifo[i].u16ItermSize;
				}
				pFifo[i].u1DdataLen = len;
				for(uint16 j = 0; j < pFifo[i].u1DdataLen; j++)
				{
					pFifo[i].u16Data[j] = buf[j];
				}
				ret = 1;
				break;
			}
		}
	}
	return ret;
}

函数作用：适用于ADC采集数据等。

四滤波算法

4.1 平均值滤波

static uint16 averageValue_Fillter(const uint16 *pData, uint16 len)
{
	uint16 min = 0, max = 0, verg = 0, invaild_count = 0,vaild_count = 0;
	uint32 sum = 0;
	uint16 tmp;
	if(pData == NULL || len == 0)
	{
		return 0;
	}
	else
	{
		min = pData[0];
		max = pData[0];
		for(uint16 i = 0; i < len; i++)
	    {
			tmp = pData[i];
	        if(pData[i] != 0)
	        {
	        	if(min == 0)
	        	{
	        		min = pData[i];
	        	}
	            if(min > pData[i])
	            {
	                min = pData[i];
	            }
	            if(max < pData[i])
	            {
	                max = pData[i];
	            }
	        }
			else
	        {
	            invaild_count++;
	        }
			sum += pData[i];
	    }
		vaild_count = len - invaild_count;
		if(vaild_count > 2)
		{
			sum -= min;
			sum -= max;
			verg = sum / (vaild_count - 2);
		}
		else if(vaild_count == 2)
		{
			verg = sum / 2;
		}
		else if((vaild_count = 0) || (vaild_count = 1))
		{
			verg = 0;
		}
		else{
			verg = 0;
		}
	}
	return verg;
}

五环形队列

5.1

#define CYCBUF_DATACOPY_MODE_0   (0)
#define CYCBUF_DATACOPY_MODE_1   (1)
#define CYCBUF_DATACOPY_MODE (CYCBUF_DATACOPY_MODE_1)

static CycBufCtrlBlock_t CycBufCtrlBlock[CYCBUF_NUM_MAX];


void CycBuf_Init(void)
{
	for(uint32_t i = 0; i < CYCBUF_NUM_MAX; i++)
	{
		CycBufCtrlBlock[i].DataBuf 		= NULL;
		CycBufCtrlBlock[i].DataBufSize 	= 0;
		CycBufCtrlBlock[i].ReadCursor 	= 0;
		CycBufCtrlBlock[i].WriteCursor 	= 0;
		CycBufCtrlBlock[i].Status 		= CYCBUF_FREE;
	}
}


uint8_t CycBuf_Open(uint8_t* const ID_Buf, uint8_t* const DataBuf, const uint32_t DataBufSize)
{
	uint8_t Ret= CYCBUF_RET_SUCCESS;
	uint8_t i;
       
    if((0 == DataBufSize) || (NULL == DataBuf)) 
    {
		if(0 == DataBufSize)
		{
			Ret =CYCBUF_RET_OPEN_ABORT;
		}
		else 
		{
			Ret = CYCBUF_RET_ERR_PARAMETER;
		}
    }
    else 
    {
			
		for(i = 0; i < CYCBUF_NUM_MAX; i++)
		{
			if(CYCBUF_FREE == CycBufCtrlBlock[i].Status) 
			{
				break;
			}
			else 
			{
				;
			}
		}
		
		if(i >= CYCBUF_NUM_MAX)
		{
			Ret = CYCBUF_RET_BUF_OUT_OF_MAX;
		}
		else 
		{        
			CycBufCtrlBlock[i].DataBuf 		= DataBuf;
			CycBufCtrlBlock[i].DataBufSize 	= DataBufSize;
			CycBufCtrlBlock[i].ReadCursor 	= 0;
			CycBufCtrlBlock[i].WriteCursor 	= 0;
			CycBufCtrlBlock[i].Status 		= CYCBUF_INUSE;
			*ID_Buf = i;
			Ret = CYCBUF_RET_SUCCESS;
		}
    }

	return Ret;
}


uint8_t CycBuf_Close(const uint8_t ID)
{
	uint8_t Ret;
	if(ID < CYCBUF_NUM_MAX)	
	{
		CycBufCtrlBlock[ID].DataBuf 	= NULL;
		CycBufCtrlBlock[ID].DataBufSize = 0;
		CycBufCtrlBlock[ID].ReadCursor 	= 0;
		CycBufCtrlBlock[ID].WriteCursor = 0;
		CycBufCtrlBlock[ID].Status 		= CYCBUF_FREE;
		Ret = CYCBUF_RET_SUCCESS;
	}
	else 
	{
		Ret = CYCBUF_RET_ERR_PARAMETER;
	}
	return Ret;
}


uint8_t CycBuf_Write(const uint8_t ID, const uint8_t* const WriteBuf, const uint32_t WriteSize)
{
	uint8_t  Ret;
	uint8_t  Rollback;
	uint32_t i;
	uint32_t FreeBufSize;


	if((ID >= CYCBUF_NUM_MAX) || (NULL == WriteBuf)	|| ( 0 == WriteSize))
	 {
		Ret = CYCBUF_RET_ERR_PARAMETER;
	}
	else 
	{
	

		if(CYCBUF_FREE == CycBufCtrlBlock[ID].Status)
		{
			Ret = CYCBUF_RET_NOT_OPEN;
		}
		else 
		{
		if(((CycBufCtrlBlock[ID].WriteCursor + 1) % CycBufCtrlBlock[ID].DataBufSize) == CycBufCtrlBlock[ID].ReadCursor)
			 {
				Ret = CYCBUF_RET_BUF_FULL;
			}
			else
			{
				if(CycBufCtrlBlock[ID].WriteCursor >= CycBufCtrlBlock[ID].ReadCursor)
		
			    {
					FreeBufSize = CycBufCtrlBlock[ID].DataBufSize + CycBufCtrlBlock[ID].ReadCursor - CycBufCtrlBlock[ID].WriteCursor;
					Rollback = TRUE;
				}
				else 
				{
					FreeBufSize = CycBufCtrlBlock[ID].ReadCursor - CycBufCtrlBlock[ID].WriteCursor;
					Rollback = FALSE;
				}
				
				if(WriteSize >= FreeBufSize) 
				{
					Ret = CYCBUF_RET_BUF_NO_ENOUGH_BUF;
				}
				else
				{		
					/* ��ѭ�����渴������,      ���ַ����������ܲ��ԱȽ�                */
					#if(CYCBUF_DATACOPY_MODE == CYCBUF_DATACOPY_MODE_0)
					
					for(i = 0; i < WriteSize; i++)
					{
						CycBufCtrlBlock[ID].DataBuf[CycBufCtrlBlock[ID].WriteCursor] = WriteBuf[i];
						CycBufCtrlBlock[ID].WriteCursor	= (CycBufCtrlBlock[ID].WriteCursor + 1) % CycBufCtrlBlock[ID].DataBufSize;
					}
					
					#else

					if(Rollback) {
						uint32_t FirstPartLen;
						uint32_t SecondPartLen;

						FirstPartLen = CycBufCtrlBlock[ID].DataBufSize - CycBufCtrlBlock[ID].WriteCursor;
						if(FirstPartLen >= WriteSize) {				
							for(i = 0; i < WriteSize; i++)
							{
								CycBufCtrlBlock[ID].DataBuf[CycBufCtrlBlock[ID].WriteCursor + i] = WriteBuf[i];
							}
						}
						else {
							for(i = 0; i < FirstPartLen; i++)
							{
								CycBufCtrlBlock[ID].DataBuf[CycBufCtrlBlock[ID].WriteCursor + i] = WriteBuf[i];
							}

							SecondPartLen = WriteSize - FirstPartLen;
							for(i = 0; i < SecondPartLen; i++)
							{
								CycBufCtrlBlock[ID].DataBuf[i] = WriteBuf[FirstPartLen + i];
							}
						}
					}
					else {
						for(i = 0; i < WriteSize; i++)
						{
							CycBufCtrlBlock[ID].DataBuf[CycBufCtrlBlock[ID].WriteCursor + i] = WriteBuf[i];
						}	
					}

					CycBufCtrlBlock[ID].WriteCursor = (CycBufCtrlBlock[ID].WriteCursor + WriteSize) % CycBufCtrlBlock[ID].DataBufSize;
					
					#endif		
					
					Ret = CYCBUF_RET_SUCCESS;
				}
			}
		}
		
		CYCBUF_EXIT_CRITICAL_AREA();
	}
	return Ret;
}


uint8_t CycBuf_PreviewRead(const uint8_t ID, uint8_t* const ReadBuf, const uint32_t ReadSize)
{
	uint8_t  Ret;
	uint32_t i;
	uint8_t  Rollback;
	uint32_t UsedBufSize;
	uint32_t WriteCursorBuf;
	uint32_t ReadCursorBuf;

	if((ID >= CYCBUF_NUM_MAX) || (NULL == ReadBuf)	|| ( 0 == ReadSize)) {
		Ret = CYCBUF_RET_ERR_PARAMETER;
	}
	else
	{
		CYCBUF_ENTER_CRITICAL_AREA();

		WriteCursorBuf =  CycBufCtrlBlock[ID].WriteCursor;
		ReadCursorBuf =  CycBufCtrlBlock[ID].ReadCursor;

		if(CYCBUF_FREE == CycBufCtrlBlock[ID].Status)
		{
			Ret = CYCBUF_RET_NOT_OPEN;
		}
		else {
			if(CycBufCtrlBlock[ID].WriteCursor == CycBufCtrlBlock[ID].ReadCursor) {
				Ret = CYCBUF_RET_BUF_EMPTY;
			}
			else  {
				/* ������Ч���ݸ��� */
				if(CycBufCtrlBlock[ID].WriteCursor >= CycBufCtrlBlock[ID].ReadCursor) {
					UsedBufSize = CycBufCtrlBlock[ID].WriteCursor - CycBufCtrlBlock[ID].ReadCursor;
					Rollback = FALSE;
				}
				else {
					UsedBufSize = CycBufCtrlBlock[ID].DataBufSize + CycBufCtrlBlock[ID].WriteCursor - CycBufCtrlBlock[ID].ReadCursor;
					Rollback = TRUE;
				}
				
				if(ReadSize > UsedBufSize) {
					Ret = CYCBUF_RET_BUF_NO_ENOUGH_DATA;
				}
				else {		
					/* ��ѭ�����渴������,      ���ַ����������ܲ��ԱȽ�                */
					#if(CYCBUF_DATACOPY_MODE == CYCBUF_DATACOPY_MODE_0)
					
					for(i = 0; i < ReadSize; i++)
					{
						ReadBuf[i] = CycBufCtrlBlock[ID].DataBuf[CycBufCtrlBlock[ID].ReadCursor];
						CycBufCtrlBlock[ID].ReadCursor = (CycBufCtrlBlock[ID].ReadCursor + 1) % CycBufCtrlBlock[ID].DataBufSize;
					}
					
					#else
					
					if(Rollback) {
						uint32_t FirstPartLen;
						uint32_t SecondPartLen;

						FirstPartLen = CycBufCtrlBlock[ID].DataBufSize - CycBufCtrlBlock[ID].ReadCursor;
						if(FirstPartLen >= ReadSize) {				
							for(i = 0; i < ReadSize; i++)
							{
								ReadBuf[i] = CycBufCtrlBlock[ID].DataBuf[CycBufCtrlBlock[ID].ReadCursor + i];
							}
						}
						else {
							for(i = 0; i < FirstPartLen; i++)
							{
								ReadBuf[i] = CycBufCtrlBlock[ID].DataBuf[CycBufCtrlBlock[ID].ReadCursor + i];
							}

							SecondPartLen = ReadSize - FirstPartLen;
							for(i = 0; i < SecondPartLen; i++)
							{
								ReadBuf[FirstPartLen + i] = CycBufCtrlBlock[ID].DataBuf[i];
							}
						}
					}
					else {
						for(i = 0; i < ReadSize; i++)
						{
							ReadBuf[i] = CycBufCtrlBlock[ID].DataBuf[CycBufCtrlBlock[ID].ReadCursor + i];
						}	
					}

					CycBufCtrlBlock[ID].ReadCursor = (CycBufCtrlBlock[ID].ReadCursor + ReadSize) % CycBufCtrlBlock[ID].DataBufSize;
					
					#endif

					Ret = CYCBUF_RET_SUCCESS;
				}
			}
		}

		CycBufCtrlBlock[ID].WriteCursor = WriteCursorBuf;
		CycBufCtrlBlock[ID].ReadCursor = ReadCursorBuf;
		
		CYCBUF_EXIT_CRITICAL_AREA();
	}
	
	return Ret;
}


uint8_t CycBuf_Read(const uint8_t ID, uint8_t* const ReadBuf, const uint32_t ReadSize)
{
	uint8_t  Ret;
	uint32_t i;
	uint8_t  Rollback;
	uint32_t UsedBufSize;

	if((ID >= CYCBUF_NUM_MAX) || (NULL == ReadBuf)	|| ( 0 == ReadSize)) {
		Ret = CYCBUF_RET_ERR_PARAMETER;
	}
	else
	{
		CYCBUF_ENTER_CRITICAL_AREA();
		
		if(CYCBUF_FREE == CycBufCtrlBlock[ID].Status)
		{
			Ret = CYCBUF_RET_NOT_OPEN;
		}
		else {
			if(CycBufCtrlBlock[ID].WriteCursor == CycBufCtrlBlock[ID].ReadCursor) {
				Ret = CYCBUF_RET_BUF_EMPTY;
			}
			else  {
				/* ������Ч���ݸ��� */
				if(CycBufCtrlBlock[ID].WriteCursor >= CycBufCtrlBlock[ID].ReadCursor) {
					UsedBufSize = CycBufCtrlBlock[ID].WriteCursor - CycBufCtrlBlock[ID].ReadCursor;
					Rollback = FALSE;
				}
				else {
					UsedBufSize = CycBufCtrlBlock[ID].DataBufSize + CycBufCtrlBlock[ID].WriteCursor - CycBufCtrlBlock[ID].ReadCursor;
					Rollback = TRUE;
				}
				
				if(ReadSize > UsedBufSize) {
					Ret = CYCBUF_RET_BUF_NO_ENOUGH_DATA;
				}
				else {		
					/* ��ѭ�����渴������,      ���ַ����������ܲ��ԱȽ�                */
					#if(CYCBUF_DATACOPY_MODE == CYCBUF_DATACOPY_MODE_0)
					
					for(i = 0; i < ReadSize; i++)
					{
						ReadBuf[i] = CycBufCtrlBlock[ID].DataBuf[CycBufCtrlBlock[ID].ReadCursor];
						CycBufCtrlBlock[ID].ReadCursor = (CycBufCtrlBlock[ID].ReadCursor + 1) % CycBufCtrlBlock[ID].DataBufSize;
					}
					
					#else
					
					if(Rollback) {
						uint32_t FirstPartLen;
						uint32_t SecondPartLen;

						FirstPartLen = CycBufCtrlBlock[ID].DataBufSize - CycBufCtrlBlock[ID].ReadCursor;
						if(FirstPartLen >= ReadSize) {				
							for(i = 0; i < ReadSize; i++)
							{
								ReadBuf[i] = CycBufCtrlBlock[ID].DataBuf[CycBufCtrlBlock[ID].ReadCursor + i];
							}
						}
						else {
							for(i = 0; i < FirstPartLen; i++)
							{
								ReadBuf[i] = CycBufCtrlBlock[ID].DataBuf[CycBufCtrlBlock[ID].ReadCursor + i];
							}

							SecondPartLen = ReadSize - FirstPartLen;
							for(i = 0; i < SecondPartLen; i++)
							{
								ReadBuf[FirstPartLen + i] = CycBufCtrlBlock[ID].DataBuf[i];
							}
						}
					}
					else {
						for(i = 0; i < ReadSize; i++)
						{
							ReadBuf[i] = CycBufCtrlBlock[ID].DataBuf[CycBufCtrlBlock[ID].ReadCursor + i];
						}	
					}

					CycBufCtrlBlock[ID].ReadCursor = (CycBufCtrlBlock[ID].ReadCursor + ReadSize) % CycBufCtrlBlock[ID].DataBufSize;
					
					#endif

					Ret = CYCBUF_RET_SUCCESS;
				}
			}
		}
		
		CYCBUF_EXIT_CRITICAL_AREA();
	}
	
	return Ret;
}


uint8_t CycBuf_Remove(const uint8_t ID, const uint32_t RemoveSize)
{
	uint8_t  Ret;
	uint32_t Len;

	if((ID >= CYCBUF_NUM_MAX) || ( 0 == RemoveSize)) {
		Ret = CYCBUF_RET_ERR_PARAMETER;
	}
	else
	{
		CYCBUF_ENTER_CRITICAL_AREA();
		
		if(CYCBUF_FREE == CycBufCtrlBlock[ID].Status)
		{
			Ret = CYCBUF_RET_NOT_OPEN;
		}
		else {
			/* �����Ч������ */
			if(CycBufCtrlBlock[ID].WriteCursor >= CycBufCtrlBlock[ID].ReadCursor) {
				Len = CycBufCtrlBlock[ID].WriteCursor - CycBufCtrlBlock[ID].ReadCursor;
			}
			else {
				Len = CycBufCtrlBlock[ID].DataBufSize + CycBufCtrlBlock[ID].WriteCursor - CycBufCtrlBlock[ID].ReadCursor;
			}

			/* �Ƴ�ָ���������� */
			if(Len >= RemoveSize) {
				CycBufCtrlBlock[ID].ReadCursor = (CycBufCtrlBlock[ID].ReadCursor + RemoveSize) % CycBufCtrlBlock[ID].DataBufSize;
				Ret = CYCBUF_RET_SUCCESS;		
			}
			else {
				Ret = CYCBUF_RET_BUF_NO_ENOUGH_DATA;
			}
		}
		
		CYCBUF_EXIT_CRITICAL_AREA();
	}
	
	return Ret;
}


uint8_t CycBuf_IsEmpty(const uint8_t ID)
{
	uint8_t Ret = CYCBUF_RET_SUCCESS;

	if(ID >= CYCBUF_NUM_MAX) {
		Ret =  CYCBUF_RET_ERR_PARAMETER;
	}
	else {
		CYCBUF_ENTER_CRITICAL_AREA();
			
		if(CYCBUF_INUSE != CycBufCtrlBlock[ID].Status) {
			Ret = CYCBUF_RET_NOT_OPEN;
		}
		else {
			if(CycBufCtrlBlock[ID].WriteCursor == CycBufCtrlBlock[ID].ReadCursor) {
				Ret = CYCBUF_RET_BUF_EMPTY;
			}
			else {
				Ret = CYCBUF_RET_BUF_NOT_EMPTY;
			}
		}

		CYCBUF_EXIT_CRITICAL_AREA();
	}
	
	return Ret;
}


uint8_t CycBuf_IsFull(const uint8_t ID)
{
	uint8_t Ret = CYCBUF_RET_SUCCESS;

	if(ID >= CYCBUF_NUM_MAX) {
		Ret =  CYCBUF_RET_ERR_PARAMETER;
	}
	else {
		CYCBUF_ENTER_CRITICAL_AREA();
		
		if(CYCBUF_INUSE != CycBufCtrlBlock[ID].Status) {
			Ret = CYCBUF_RET_NOT_OPEN;
		}
		else {
			if(CycBufCtrlBlock[ID].WriteCursor + 1 == CycBufCtrlBlock[ID].ReadCursor) {
				Ret = CYCBUF_RET_BUF_FULL;
			}
			else {
				Ret = CYCBUF_RET_BUF_NOT_FULL;
			}
		}

		CYCBUF_EXIT_CRITICAL_AREA();
	}
	return Ret;
}


uint8_t CycBuf_CheckData(const uint8_t ID, uint32_t* const len)
{
	uint8_t Ret = CYCBUF_RET_SUCCESS;

	if(ID >= CYCBUF_NUM_MAX) {
		Ret =  CYCBUF_RET_ERR_PARAMETER;
	}
	else {
		CYCBUF_ENTER_CRITICAL_AREA();
		
		if(CYCBUF_INUSE != CycBufCtrlBlock[ID].Status) {
			Ret = CYCBUF_RET_NOT_OPEN;
		}
		else {
			if(CycBufCtrlBlock[ID].WriteCursor >= CycBufCtrlBlock[ID].ReadCursor) {
				*len = CycBufCtrlBlock[ID].WriteCursor - CycBufCtrlBlock[ID].ReadCursor;
			}
			else {
				*len = CycBufCtrlBlock[ID].DataBufSize + CycBufCtrlBlock[ID].WriteCursor - CycBufCtrlBlock[ID].ReadCursor;
			}

			Ret = CYCBUF_RET_SUCCESS;
		}

		CYCBUF_EXIT_CRITICAL_AREA();
	}
	
	return Ret;
}


uint8_t CycBuf_Reset(const uint8_t ID)
{
	uint8_t Ret = CYCBUF_RET_SUCCESS;

	if(ID >= CYCBUF_NUM_MAX) {
		Ret =  CYCBUF_RET_ERR_PARAMETER;
	}
	else {
		CYCBUF_ENTER_CRITICAL_AREA();
		
		if(CYCBUF_INUSE != CycBufCtrlBlock[ID].Status) {
			Ret = CYCBUF_RET_NOT_OPEN;
		}
		else {
			CycBufCtrlBlock[ID].ReadCursor = 0;
			CycBufCtrlBlock[ID].WriteCursor = 0;
		}
		
		CYCBUF_EXIT_CRITICAL_AREA();
	}
	return Ret;
}

typedef enum {
	CYCBUF_CH_0 = 0,    /* +1, USART2 ���Դ��ڷ���ѭ������ */
	CYCBUF_CH_1, 		/* +1, USART2 ���Դ��ڽ���ѭ������ */
	CYCBUF_CH_2,		/* +1, PWR���COM��ͨ��ģ�鷢������֡���� */
	CYCBUF_CH_3,
	CYCBUF_CH_4,
	CYCBUF_CH_5,
	CYCBUF_CH_6,
	CYCBUF_CH_7,
	CYCBUF_NUM_MAX
}CycBuf_Channel_t;

#define CYCBUF_NUM_MAX 10

#define CYCBUF_ENTER_CRITICAL_AREA()  	MCAL_MCUCORE_ENTER_CRITICAL_AREA()
#define CYCBUF_EXIT_CRITICAL_AREA()  	MCAL_MCUCORE_EXIT_CRITICAL_AREA()

typedef enum {
	CYCBUF_FREE = 0,
	CYCBUF_INUSE,
	CYCBUF_BUSY,
	CYCBUF_ABANDON
}CycBuf_Status_t;
	

typedef enum {
	CYCBUF_RET_SUCCESS = 0,
	CYCBUF_RET_NOT_OPEN,
	CYCBUF_RET_OPEN_ABORT,
	CYCBUF_RET_BUF_OUT_OF_MAX,
	CYCBUF_RET_ERR_PARAMETER,
	CYCBUF_RET_BUF_FULL,
	CYCBUF_RET_BUF_EMPTY,
	CYCBUF_RET_BUF_NOT_FULL,
	CYCBUF_RET_BUF_NOT_EMPTY,
	CYCBUF_RET_BUF_NO_ENOUGH_BUF,
	CYCBUF_RET_BUF_NO_ENOUGH_DATA,
	CYCBUF_RET_ERR_UNEXPECTED
}CycBuf_Ret_Value_t;



typedef struct {
    uint8_t* DataBuf;
    uint8_t  Status;
    uint32_t DataBufSize;
    uint32_t ReadCursor;
    uint32_t WriteCursor;
}CycBufCtrlBlock_t;


void CycBuf_Init(void);

extern uint8_t CycBuf_Open(uint8_t* const ID_Buf, uint8_t* const DataBuf, const uint32_t DataBufSize);
extern uint8_t CycBuf_Close(const uint8_t ID);

extern uint8_t CycBuf_Write(const uint8_t ID, const uint8_t* const WriteBuf, const uint32_t DataSize);
extern uint8_t CycBuf_Read(const uint8_t ID, uint8_t* const ReadBuf, const uint32_t ReadSize);
extern uint8_t CycBuf_Remove(const uint8_t ID, const uint32_t RemoveSize);
extern uint8_t CycBuf_PreviewRead(const uint8_t ID, uint8_t* const ReadBuf, const uint32_t ReadSize);

extern uint8_t CycBuf_IsEmpty(const uint8_t ID);
extern uint8_t CycBuf_IsFull(const uint8_t ID);
extern uint8_t CycBuf_CheckData(const uint8_t ID, uint32_t* const len);
extern uint8_t CycBuf_Reset(const uint8_t ID);

5.2

/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef _FIFO_H_
#define _FIFO_H_
/* Includes ------------------------------------------------------------------*/

//#include "ac78xx.h"
#include 

typedef struct
{
    uint32_t head;  /* output conut */
    uint32_t tail;     /*  input count   */
    uint32_t size;   /*  total size  */
    uint8_t * baseAddr;
}fifo_TypeDef;




uint8_t fifo_Init(fifo_TypeDef * _fifo, uint8_t* data, uint32_t size);
uint8_t fifo_DeInit(fifo_TypeDef * _fifo);
uint8_t fifo_Reset(fifo_TypeDef * _fifo);


uint32_t fifo_insert(fifo_TypeDef * _fifo, uint8_t *data, uint32_t len);
uint32_t fifo_retrieve(fifo_TypeDef * _fifo, uint8_t *data, uint32_t len);

uint32_t fifo_GetLen(fifo_TypeDef * _fifo);
uint8_t fifo_NotFull(fifo_TypeDef * _fifo);
uint32_t fifo_GetFreeSpace(fifo_TypeDef * _fifo);
uint32_t  Fifo_strchr(fifo_TypeDef * _fifo, uint8_t data);

#endif

/* Includes ------------------------------------------------------------------*/
#include  
#include "fifo.h"
#include 



#define minimum(x, y)  (((x) < (y))? (x) : (y))


/************************************************************************
    Function : 
    Description : Init the fifo structure.
            _fifo : reference to _fifo struct.
            size : size of the fifo.
            retval 1 if memory allocation fails or 0.
    Change history:
    Note:
    Author:     
    Date:     Jan-10-2013
************************************************************************/
uint8_t fifo_Init(fifo_TypeDef * _fifo, uint8_t* data, uint32_t size)
{
    /* check for a valid pointer */
    if (_fifo == NULL)
    {
        return 1;
    }
    
    /* if fifo size is null nothing to do */
    if ( size == 0)
    {
        memset((uint8_t *)_fifo, 0x00, sizeof(fifo_TypeDef));
        return 1;
    }
    else
    {
        /* allocate fifo space. */
        _fifo->baseAddr = data;
        if (_fifo->baseAddr == NULL)
        {
            /* memory allocation failure. */
            #ifdef SZ_LOG
            putLine();
            putString("----> Malloc Fail!");
            #endif
            
            return 1;
        }
        else
        {
            memset((uint8_t *)_fifo->baseAddr, 0x00, sizeof(uint8_t) * size);
            /* tail = head --> empty fifo */
            _fifo->head = 0;
            _fifo->tail = 0;
            _fifo->size = size;
            return 0;
        }
    }
}


/************************************************************************
    Function : 
    Description : DeInit the fifo structure.
            _fifo : reference to _fifo struct.
    Change history:
    Note:
    Author:     
    Date:     Jan-10-2013
************************************************************************/
uint8_t fifo_DeInit(fifo_TypeDef * _fifo)
{
    uint8_t status = 1;
    
    if (_fifo == NULL)
    {
        status = 1;
    }
    else
    {
        if (_fifo->baseAddr != NULL)
        {
            /* optional (clear memory region) */
            memset((uint8_t *)_fifo->baseAddr, 0x00, _fifo->size);
            memset((uint8_t *)_fifo, 0x00, sizeof(fifo_TypeDef));
            status = 0;
        }
        else
        {
            /* FiFo invalid base address. */
            status = 1;
        }
    }
    return status;
}


/************************************************************************
    Function : 
    Description : Reset the fifo structure.
            _fifo : reference to _fifo struct.
    Change history:
    Note:
    Author:     
    Date:     Jan-10-2013
************************************************************************/
uint8_t fifo_Reset(fifo_TypeDef * _fifo)
{
    if (_fifo == NULL)
    {
        return 1;
    }
    else
    {
        if (_fifo->baseAddr != NULL)
        {
            /* optional (clear memory region) */
            memset((uint8_t *)_fifo->baseAddr, 0x00, _fifo->size);
            
            _fifo->head = 0;
            _fifo->tail = 0;
            return 0;
        }
        else
        {
            /* FiFo invalid base address. */
            return 1;
        }
    }
}



/************************************************************************
    Function : 
    Description : returns how much data is stored in the fifo.
            _fifo : reference to _fifo struct.
    Change history:
    Note:
    Author:     
    Date:     Jan-10-2013
************************************************************************/
uint32_t fifo_GetLen(fifo_TypeDef * _fifo)
{
    if (_fifo == NULL)
    {
        return 0;
    }
    else
    {
        return (_fifo->tail - _fifo->head);
    }
}


/************************************************************************
    Function : 
    Description : returns how much free sapce in the fifo.
            _fifo : reference to _fifo struct.
    Change history:
    Note:
    Author:     
    Date:     Jan-10-2013
************************************************************************/
uint32_t fifo_GetFreeSpace(fifo_TypeDef * _fifo)
{
    if (_fifo == NULL)
    {
        return 0;
    }
    else
    {
        return (_fifo->size - (_fifo->tail - _fifo->head));
    }
}



/************************************************************************
    Function : 
    Description : returns SET if the FIFO is full.
            _fifo : reference to _fifo struct.
    Change history:
    Note:
    Author:     
    Date:     Jan-10-2013
************************************************************************/
uint8_t fifo_NotFull(fifo_TypeDef * _fifo)
{
    if (_fifo == NULL)
    {
        return 0;
    }
    else
    {
        return ((_fifo->tail - _fifo->head) != _fifo->size) ? 1 : 0;
    }
}


/************************************************************************
    Function : 
    Description : Insert data to the fifo.
            _fifo : reference to _fifo struct.
            data : reference to data buffer.
            len : data buffer length.
    Change history:
    Note:
    Author:     
    Date:     Jan-10-2013
************************************************************************/
uint32_t fifo_insert(fifo_TypeDef * _fifo, uint8_t *data, uint32_t len)
{
	uint32_t real_len;
	uint32_t offset;
	uint32_t end;


	offset   = _fifo->size - (_fifo->tail - _fifo->head);
    /*Actual size of data we can write*/
    real_len = minimum(len, offset);
    /*Offset of write pointer*/
    offset   = _fifo->tail % _fifo->size;
    /*End position before buffer being warpped*/
    end      = minimum(real_len,  _fifo->size - offset);
    
	/*Copy data to buffer before warp*/
	memcpy(_fifo->baseAddr + offset, data, end);
	
	/*Copy data to buffer after warp*/
	memcpy(_fifo->baseAddr, data + end, real_len - end);
	
	_fifo->tail += real_len;
	
	return real_len;
}


/************************************************************************
    Function : 
    Description : Retrieve data from the fifo.
            _fifo : reference to _fifo struct.
            data : reference to data buffer.
            len : data buffer length.
    Change history:
    Note:
    Author:     
    Date:     Jan-10-2013
************************************************************************/
uint32_t fifo_retrieve(fifo_TypeDef * _fifo, uint8_t *data, uint32_t len)
{
	uint32_t real_len;
	uint32_t offset;
	uint32_t end;
  
	
    offset   = _fifo->tail- _fifo->head;
	real_len = minimum(len, offset);
	
    //得到偏移量
	offset = _fifo->head % _fifo->size;
    
	end = minimum(real_len, _fifo->size - offset);
	
	memcpy(data, _fifo->baseAddr + offset, end);
	
	memcpy(data + end, _fifo->baseAddr, real_len - end);
	
	_fifo->head += real_len;
	
	return real_len;
}

/*****************************************************************************
* 函数名:  串口通道帧尾获取函数
* 函数功能: 获取当前帧帧尾所在地址
* 输入参数: _fifo - fifo结构体
* 输入参数: data-帧尾结束符
* 返回数据: fifo中接收到的数据到字节data第一次出现的长度
*****************************************************************************/ 
uint32_t  Fifo_strchr(fifo_TypeDef * _fifo, uint8_t data)
{
    uint32_t remaining = 0;
    uint32_t len       = 0;
    uint32_t head;
    

    head      = _fifo->head;
    remaining = _fifo->tail- head;
    head      = head % _fifo->size;
	
	
	while(remaining)
	{   
        len++;
        if(data == *((_fifo->baseAddr + head)))
        {
            return len;
        }
        head++;
        remaining--;
		head %= _fifo->size;
	}
	return 0;
}

5.3

总结

提示：这里对文章进行总结：
例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。

你可能感兴趣的:(单片机,c语言,嵌入式硬件)

OC语言多界面传值五大方式 Magnetic_h ios ui 学习 objective-c 开发语言
前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
C语言宏函数南林yan C语言 c语言
一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
C语言如何定义宏函数？小九格物 c语言
在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
c++ 的iostream 和 c++的stdio的区别和联系黄卷青灯77 c++算法开发语言 iostream stdio
在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
C语言判断回文数 Y雨何时停T c语言学习
一，回文数概念“回文”是指正读反读都能读通的句子，它是古今中外都有的一种修辞方式和文字游戏，如“我为人人，人人为我”等。在数学中也有这样一类数字有这样的特征，成为回文数。设n是一任意自然数。若将n的各位数字反向排列所得自然数n1与n相等，则称n为一回文数。例如，若n=1234321，则称n为一回文数；但若n=1234567，则n不是回文数。二，判断回文数实现思路一：数组与字符串将数字每一位按顺序放
C语言代码练习（第十九天）小小框架 C语言 C语言重点练习 c语言
今日练习：52、有一个已经排好序的数组，要求输入一个数后，按原来排序的规律将它插入数组中53、输出"魔方阵"。所谓魔方阵是指它的每一行，每一列和对角线之和均相等。54、找出一个二维数组中的鞍点，即该位置上的元素在该行上最大、在该列上最小。也可能没有鞍点。有一个已经排好序的数组，要求输入一个数后，按原来排序的规律将它插入数组中运行代码intmain(){intarr[11]={1,3,9,12,15
基于STM32与Qt的自动平衡机器人：从控制到人机交互的的详细设计流程极客小张 stm32 qt 机器人物联网人机交互毕业设计 c语言
一、项目概述目标和用途本项目旨在开发一款基于STM32控制的自动平衡机器人，结合步进电机和陀螺仪传感器，实现对平衡机器人的精确控制。该机器人可以用于教育、科研、娱乐等多个领域，帮助用户了解自动控制、机器人运动学等相关知识。技术栈关键词STM32单片机步进电机陀螺仪传感器AD采集电路Qt人机界面实时数据监控二、系统架构系统架构设计本项目的系统架构设计包括以下主要组件：控制单元:STM32单片机传感器
c++ 内存处理函数 heeheeai c++开发语言
在C语言的头文件中，memcpy和memmove函数都用于复制内存块，但它们在处理内存重叠方面存在关键区别：内存重叠:memcpy函数不保证在源内存和目标内存区域重叠时能够正确复制数据。如果内存区域重叠，memcpy的行为是未定义的，可能会导致数据损坏或程序崩溃。memmove函数能够安全地处理源内存和目标内存区域重叠的情况。它会确保在复制过程中不会覆盖尚未复制的数据，从而保证数据的完整性。效率:
C语言---程序设计练习题目及学习方法1 Wanyu677 C语言 c语言学习方法算法
学习方法要多练习在这些题目中的代码和题目自己动手去敲练习也是在熟悉语法，写代码第一步就是熟悉语法练习是在锻炼编程思维，把实际问题转换为代码的能力学会画图画图去理解内存，理解指针这些比较难懂的知识画图可以更好的理清思路辅助理解，强化理解学会调试借助调试，更好的理解代码和感知代码找出代码中的bug和程序逻辑（1）自增自减运算符inta=5,b,c,i=10;b=a++;c=++b;printf("a=
【C语言】- 自定义类型：结构体、枚举、联合 Cavalier_01 C语言
【C语言】：操作符（https://mp.csdn.net/editor/html/115218055）数据类型（https://mp.csdn.net/editor/html/115219664）自定义类型：结构体、枚举、联合（https://mp.csdn.net/editor/html/115373785）变量、常量（https://mp.csdn.net/editor/html/11523
51单片机——I2C总线存储器24C02的应用老侯（Old monkey） 51单片机嵌入式硬件单片机
目标实现功能单片机先向24C02写入256个字节的数据，再从24C02中一次读取2个字节的数据、并在数码管上动态显示，直至读完24C02中256个字节的数据。1.I2C总线简介I2C总线有两根双向的信号线，一根是数据线SDA,另一根是时钟线SCL。I2C总线通过上拉电阻接正电源，因此，当总线空闲时为高电平。2.I2C通信协议起始信号、停止信号由主机发出。在数据传送时，当时钟线为高电平时，数据线上的
嵌入式单片机中数码管基本实现方法嵌入式开发星球单片机项目实战操作之优秀单片机
1.点亮数码管本节课利用已经学习的LED知识去控制一个8位数码管。本节的原理比较简单。不需要多少时间讲。更多时间是跟大家一起编码调试，从中学习一些编码思路和学习方法。1.1.什么是数码管数码管是什么？下图就是一个数码管从硬件上个看，其实就是8个LED组合在一起。8个LED应该有16个引脚，但是数码管上只有10个引脚。为什么呢？请看下图：1个LED有两个引脚，要控制LED，1个引脚接控制信号，另外一
华南农业大学C语言oj第八章黑兔子撒 C语言 C语言华南农业大学编程程序
18058一年的第几天时间限制:1000MS内存限制:65535K提交次数:0通过次数:0题型:填空题语言:G++;GCC;VCDescription定义一个结构体类型表示日期类型（包括年、月、日）。程序中定义一个日期类型的变量，输入该日期的年、月、日，计算并输出该日期是一年的第几天。#include struct DATE { _______________________ }; int da
linux gcc 格式,Linux下gcc与gdb简介神奇的战士 linux gcc 格式
gcc编译器可以将C、C++等语言源程序、汇编程序编译、链接成可执行程序。gdb是GNU开发的一个Unix/Linux下强大的程序调试工具。linux下没有后缀名的概念。但gcc根据文件的后缀来区别输入文件的类别：.cC语言源代码文件.a由目标文件构成的库文件.C、.cc、.cppC++源码文件.h头文件.i经过预处理之后的C语言文件.ii经过预处理之后的C++文件.o编译后的目标文件.s汇编源码
Lua 与 C#交互 z2014z lua c#开发语言
Lua与C#交互前提Lua是一种嵌入式脚本语言，Lua的解释器是用C编写的，因此可以方便的与C/C++进行相互调用。轻量级Lua语言的官方版本只包括一个精简的核心和最基本的库，这使得Lua体积小、启动速度快，也适合嵌入在别的程序里。交互过程C#调用Lua:由C#文件调用Lua解析器底层dll库（由C语言编写），再由dll文件执行相应的Lua文件。Lua调用C#：1、Wrap方式：首先生成C#源文件
⭐算法入门⭐《归并排序》简单01 —— LeetCode 21. 合并两个有序链表英雄哪里出来《LeetCode算法全集》算法数据结构链表 c++归并排序
饭不食，水不饮，题必须刷C语言免费动漫教程，和我一起打卡！《光天化日学C语言》LeetCode太难？先看简单题！《C语言入门100例》数据结构难？不存在的！《数据结构入门》LeetCode太简单？算法学起来！《夜深人静写算法》文章目录一、题目1、题目描述2、基础框架3、原题链接二、解题报告1、思路分析2、时间复杂度3、代码详解三、本题小知识一、题目1、题目描述将两个不降序链表合并为一个新的不降
PAT Advanced 1015. Reversible Primes (C语言实现) OliverLew
我的PAT系列文章更新重心已移至Github，欢迎来看PAT题解的小伙伴请到GithubPages浏览最新内容。此处文章目前已更新至与GithubPages同步。欢迎star我的repo。题目Areversibleprimeinanynumbersystemisaprimewhose"reverse"inthatnumbersystemisalsoaprime.Forexampleinthedec
c语言双向链表清空,C语言实现链表之双向链表（四）清空链表火龙果和哈密瓜 c语言双向链表清空
/*==============================================================================*操作：清空链表，释放结点内存，将链表重置为空表*操作前：ppHeadNode为链表头指针的二级指针*操作后：(*ppHeadNode)所指链表中的所有结点的内存被释放，重置为空表==============================
【C语言】C语言中的构造类型（自定义类型）写代码也摆烂 #C语言笔记 c语言
构造类型：也称自定义类型，构造类型是由基本数据类型组成的复合类型。一般用于存储较为复杂的数据。常见的构造类型有结构体（struct）、共用体（union）和枚举（enum）。目录正文一、结构体(struct)1、结构体概念：2、定义结构体类型与结构体变量3、结构体变量的初始化与引用3、结构体数组4、结构体指针*二、共用体（union）三、枚举类型四、用typedef声明新的类型名1、常用的方法有：
打开C语言常用内存函数的大门(一) —— memcpy()函数（内含讲解用法和模拟实现）埋头编程~ C语言 c语言开发语言 visual studio 算法
文章目录1.前言2.memcpy函数2.1memcpy函数的原型2.2memcpy函数的形参和返回值详解3.memcpy函数的演示4.memcpy函数的模拟实现5.总结1.前言在之前写的文章中，我介绍了几个比较常用的字符串函数strlen、strcmp、strcpy。它们作用的对象只能是形如字符串类型的数据。那这难免会引起我们心中一泡浓厚的求知欲——C语言有没有给我们提供一些类似于字符串函数的功能
详解C语言中的循环语句埋头编程~ C语言 c语言开发语言
文章目录1.前言2.while循环2.1if和whlie的对比2.2while语句的工作机制2.3while循环的实践3.for循环3.1for循环语法3.2for循环的工作机制3.3for循环实践4dowhile循环4.1dowhlie循环语法4.2dowhile循环的工作机理4.3dowhile循环实践5.break和continue语句5.1break举例5.2continue举例6.got
4×4矩阵键盘详解（STM32）辰哥单片机设计 STM32传感器教学矩阵计算机外设 stm32 嵌入式硬件单片机传感器
目录一、介绍二、传感器原理1.原理图2.工作原理介绍三、程序设计main.c文件button4_4.h文件button4_4.c文件四、实验效果五、资料获取项目分享一、介绍矩阵键盘，又称为行列式键盘，是用4条I/O线作为行线，4条I/O线作为列线组成的键盘。在行线和列线的每一个交叉点上设置一个按键，因此键盘中按键的个数是4×4个。这种行列式键盘结构能够有效地提高单片机系统中I/O口的利用率，节约单
C语言指针（2）星霜旅人 c语言开发语言
目录数组名使用指针访问数组一维数组传参的本质二级指针数组指针数组名数组名是数组首元素的地址。intmain(){intarr1[]={1,2,3,4,5};printf("%p\n",&arr1[0]);printf("%p\n",arr1);}//都是传入数组首元素地址但是有两点例外：sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小。&（数组名），这里的数组名也表示整个数
9.15初识指针西科Monesy c语言开发语言
初识指针什么是指针？指针是一种数据类型，它存储了变量的内存地址。通过指针，程序可以直接访问和操作内存中的数据，而不是通过变量的名称。这使得C语言在内存管理和性能优化方面具有很大的灵活性。内存是什么？内存是电脑上的存储器，计算机中程序的运行都是在内存中进行的。程序中如果有数据需要存储也会申请内存空间。为了有效的使用内存，就把内存划分成一个小小的内存单元，每个内存单元的大小是一个字节。为了能够有效的访
C语言：冒泡排序的注意事项及具体实现 z_鑫 c语言算法数据结构开发语言
一、注意事项1、函数声明为：voidbubble_sort(void*base,size_tnum,size_twidth,int(*cmp)(constvoid*e1,constvoid*e2));2、base指向所要排序的数组3、num为数组的元素个数4、width为一个元素占多少个字节的空间5、cmp为函数指针，指向用来进行比较的函数6、每趟排序都会把当前未排序部分的最大值移到正确的位置二、
学单片机怎么在3-5个月内找到工作？无际单片机编程单片机嵌入式开发物联网 stm32 c语言
每个初学者，都如履薄冰，10几年前，我自学单片机时，也一样。想通过学习，找一份体面点的工作，又害怕辛辛苦苦学出来，找不到工作。好在，当初执行力，还算可以，自学java没成功，后面自学单片机，成功入行了。转眼间，毕业到现在有13年了，马上也到了奔4的年纪。这13年一直在跟单片机打交道，打过工，创过业，对行业，对企业，都有一定的认知，坚持看完这篇内容，相信能帮你少走几个月弯路。有些老铁，加了我很久，时
C语言学习 - continue跳转语句 Hyso
continue跳转语句的使用用于for循环语句、while循环语句、dowhile循环语句中，跳过本次循环中剩余的语句而执行下一次循环。continue跳转语句的实例：#includeintmain(coid){intsum=0;inti=1;while(i<=100){sum+=i;i++;if(i==50){continue;}printf("i=%d\n",i);}printf("sum=
C语言实现一个简单的点歌系统鹿屿二向箔 c语言开发语言
创建一个简单的点歌系统可以用C语言实现，这里提供一个基本的框架。这个系统可以包括歌曲列表、用户选择歌曲的功能以及播放歌曲的功能。以下是一个示例代码：#include#include#defineMAX_SONGS100#defineMAX_LENGTH100typedefstruct{charname[MAX_LENGTH];charartist[MAX_LENGTH];}Song;typedef
学习C语言第十天（数组练习）世辰辰辰学习算法
一、三子棋game.h#define_CRT_SECURE_NO_WARNINGS#include#include#include#defineROW3#defineCOL3//初始化棋盘voidinitboard(charboard[ROW][COL],introw,intcol);//打印棋盘voiddispalyboard(charboard[ROW][COL],introw,intcol)
51单片机：P3.3口输入/P 1口输出实验 li星野单片机
51单片机：P3.3口输入/P1口输出实验一、实验内容1P3.3口做输入口，外接一脉冲,每输入一个脉冲,P1口按十六进制除2（乘2）。2.P1口做输出口，P1口接的8个发光二极管L1—L8按十六进制除2（乘2）方式点亮。二、仿真图三、代码实现C语言实现：#include#includesbitKEY=P3^3;voiddelay10ms(void);voidmain(){charnum=0xfe;
多线程编程之理财周凡杨 java 多线程生产者消费者理财
现实生活中，我们一边工作，一边消费，正常情况下会把多余的钱存起来，比如存到余额宝，还可以多挣点钱，现在就有这个情况：我每月可以发工资20000万元（暂定每月的1号），每月消费5000（租房+生活费）元（暂定每月的1号），其中租金是大头占90%，交房租的方式可以选择（一月一交，两月一交、三月一交），理财：1万元存余额宝一天可以赚1元钱，
[Zookeeper学习笔记之三]Zookeeper会话超时机制 bit1129 zookeeper
首先，会话超时是由Zookeeper服务端通知客户端会话已经超时，客户端不能自行决定会话已经超时，不过客户端可以通过调用Zookeeper.close()主动的发起会话结束请求，如下的代码输出内容 Created /zoo-739160015 CONNECTEDCONNECTED .............CONNECTEDCONNECTED CONNECTEDCLOSEDCLOSED
SecureCRT快捷键 daizj secureCRT 快捷键
ctrl + a : 移动光标到行首ctrl + e ：移动光标到行尾crtl + b: 光标前移1个字符crtl + f: 光标后移1个字符crtl + h : 删除光标之前的一个字符ctrl + d ：删除光标之后的一个字符crtl + k ：删除光标到行尾所有字符crtl + u : 删除光标至行首所有字符crtl + w: 删除光标至行首
Java 子类与父类这间的转换周凡杨 java 父类与子类的转换
最近同事调的一个服务报错，查看后是日期之间转换出的问题。代码里是把 java.sql.Date 类型的对象强制转换为 java.sql.Timestamp 类型的对象。报java.lang.ClassCastException。代码：
可视化swing界面编辑朱辉辉33 eclipse swing
今天发现了一个WindowBuilder插件，功能好强大，啊哈哈，从此告别手动编辑swing界面代码，直接像VB那样编辑界面，代码会自动生成。首先在Eclipse中点击help，选择Install New Software,然后在Work with中输入WindowBui
web报表工具FineReport常用函数的用法总结（文本函数）老A不折腾 finereport web报表工具报表软件 java报表
文本函数 CHAR CHAR(number):根据指定数字返回对应的字符。CHAR函数可将计算机其他类型的数字代码转换为字符。 Number:用于指定字符的数字，介于1Number:用于指定字符的数字，介于165535之间（包括1和65535）。示例: CHAR(88)等于“X”。 CHAR(45)等于“-”。 CODE CODE(text):计算文本串中第一个字
mysql安装出错林鹤霄 mysql安装
[root@localhost ~]# rpm -ivh MySQL-server-5.5.24-1.linux2.6.x86_64.rpm Preparing... #####################
linux下编译libuv aigo libuv
下载最新版本的libuv源码，解压后执行： ./autogen.sh 这时会提醒找不到automake命令，通过一下命令执行安装（redhat系用yum，Debian系用apt-get）： # yum -y install automake # yum -y install libtool 如果提示错误：make: *** No targe
中国行政区数据及三级联动菜单 alxw4616
近期做项目需要三级联动菜单,上网查了半天竟然没有发现一个能直接用的! 呵呵,都要自己填数据....我了个去这东西麻烦就麻烦的数据上. 哎,自己没办法动手写吧. 现将这些数据共享出了,以方便大家.嗯,代码也可以直接使用文件说明 lib\area.sql -- 县及县以上行政区划分代码（截止2013年8月31日)来源：国家统计局发布时间：2014-01-17 15:0
哈夫曼加密文件百合不是茶哈夫曼压缩哈夫曼加密二叉树
在上一篇介绍过哈夫曼编码的基础知识,下面就直接介绍使用哈夫曼编码怎么来做文件加密或者压缩与解压的软件,对于新手来是有点难度的,主要还是要理清楚步骤; 加密步骤: 1,统计文件中字节出现的次数,作为权值 2,创建节点和哈夫曼树 3,得到每个子节点01串 4,使用哈夫曼编码表示每个字节
JDK1.5 Cyclicbarrier实例 bijian1013 java thread java多线程 Cyclicbarrier
CyclicBarrier类一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中，这些线程必须不时地互相等待，此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用，所以称它为循环的 barrier。 CyclicBarrier支持一个可选的 Runnable 命令，
九项重要的职业规划 bijian1013 工作学习
一. 学习的步伐不停止古人说，活到老，学到老。终身学习应该是您的座右铭。世界在不断变化，每个人都在寻找各自的事业途径。您只有保证了足够的技能储
【Java范型四】范型方法 bit1129 java
范型参数不仅仅可以用于类型的声明上，例如 package com.tom.lang.generics; import java.util.List; public class Generics<T> { private T value; public Generics(T value) { this.value =
【Hadoop十三】HDFS Java API基本操作 bit1129 hadoop
package com.examples.hadoop; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.FSDataInputStream; import org.apache.hadoop.fs.FileStatus; import org.apache.hadoo
ua实现split字符串分隔 ronin47 lua split
LUA并不象其它许多"大而全"的语言那样，包括很多功能，比如网络通讯、图形界面等。但是LUA可以很容易地被扩展：由宿主语言(通常是C或 C++)提供这些功能，LUA可以使用它们，就像是本来就内置的功能一样。LUA只包括一个精简的核心和最基本的库。这使得LUA体积小、启动速度快，从而适合嵌入在别的程序里。因此在lua中并没有其他语言那样多的系统函数。习惯了其他语言的字符串分割函
java-从先序遍历和中序遍历重建二叉树 bylijinnan java
public class BuildTreePreOrderInOrder { /** * Build Binary Tree from PreOrder and InOrder * _______7______ / \ __10__ ___2 / \ / 4
openfire开发指南《连接和登陆》开窍的石头 openfire 开发指南 smack
第一步官网下载smack.jar包下载地址：http://www.igniterealtime.org/downloads/index.jsp#smack 第二步把smack里边的jar导入你新建的java项目中开始编写smack连接openfire代码 p
[移动通讯]手机后盖应该按需要能够随时开启 comsci 移动
看到新的手机，很多由金属材质做的外壳，内存和闪存容量越来越大，CPU速度越来越快，对于这些改进，我们非常高兴，也非常欢迎但是，对于手机的新设计，有几点我们也要注意第一：手机的后盖应该能够被用户自行取下来，手机的电池的可更换性应该是必须保留的设计,
20款国外知名的php开源cms系统 cuiyadll cms
内容管理系统，简称CMS，是一种简易的发布和管理新闻的程序。用户可以在后端管理系统中发布，编辑和删除文章，即使您不需要懂得HTML和其他脚本语言，这就是CMS的优点。在这里我决定介绍20款目前国外市面上最流行的开源的PHP内容管理系统，以便没有PHP知识的读者也可以通过国外内容管理系统建立自己的网站。 1. Wordpress WordPress的是一个功能强大且易于使用的内容管
Java生成全局唯一标识符 darrenzhu java uuid unique identifier id
How to generate a globally unique identifier in Java http://stackoverflow.com/questions/21536572/generate-unique-id-in-java-to-label-groups-of-related-entries-in-a-log http://stackoverflow
php安装模块检测是否已安装过, 使用的SQL语句 dcj3sjt126com sql
SHOW [FULL] TABLES [FROM db_name] [LIKE 'pattern'] SHOW TABLES列举了给定数据库中的非TEMPORARY表。您也可以使用mysqlshow db_name命令得到此清单。本命令也列举数据库中的其它视图。支持FULL修改符，这样SHOW FULL TABLES就可以显示第二个输出列。对于一个表，第二列的值为BASE T
5天学会一种 web 开发框架 dcj3sjt126com Web 框架 framework
web framework层出不穷，特别是ruby/python,各有10+个,php/java也是一大堆根据我自己的经验写了一个to do list,按照这个清单，一条一条的学习，事半功倍，很快就能掌握一共25条，即便很磨蹭，2小时也能搞定一条，25*2=50。只需要50小时就能掌握任意一种web框架各类web框架大同小异:现代web开发框架的6大元素，把握主线，就不会迷路建议把本文
Gson使用三(Map集合的处理,一对多处理) eksliang json gson Gson map Gson 集合处理
转载请出自出处：http://eksliang.iteye.com/blog/2175532 一、概述 Map保存的是键值对的形式，Json的格式也是键值对的，所以正常情况下，map跟json之间的转换应当是理所当然的事情。二、Map参考实例 package com.ickes.json; import java.lang.refl
cordova实现“再点击一次退出”效果 gundumw100 android
基本的写法如下： document.addEventListener("deviceready", onDeviceReady, false); function onDeviceReady() { //navigator.splashscreen.hide(); document.addEventListener("b
openldap configuration leaning note iwindyforest configuration
hostname // to display the computer name hostname <changed name> // to change go to: /etc/sysconfig/network, add/modify HOSTNAME=NEWNAME to change permenately dont forget to change /etc/hosts
Nullability and Objective-C 啸笑天 Objective-C
https://developer.apple.com/swift/blog/?id=25 http://www.cocoachina.com/ios/20150601/11989.html http://blog.csdn.net/zhangao0086/article/details/44409913 http://blog.sunnyxx
jsp中实现参数隐藏的两种方法 macroli JavaScript jsp
在一个JSP页面有一个链接，//确定是一个链接?点击弹出一个页面，需要传给这个页面一些参数。//正常的方法是设置弹出页面的src="***.do?p1=aaa&p2=bbb&p3=ccc"//确定目标URL是Action来处理?但是这样会在页面上看到传过来的参数，可能会不安全。要求实现src="***.do"，参数通过其他方法传！//////
Bootstrap A标签关闭modal并打开新的链接解决方案 qiaolevip 每天进步一点点学习永无止境 bootstrap 纵观千象
Bootstrap里面的js modal控件使用起来很方便，关闭也很简单。只需添加标签 data-dismiss="modal" 即可。可是偏偏有时候需要a标签既要关闭modal，有要打开新的链接，尝试多种方法未果。只好使用原始js来控制。 <a href="#/group-buy" class="btn bt
二维数组在Java和C中的区别流淚的芥末 java c 二维数组数组
Java代码： public class test03 { public static void main(String[] args) { int[][] a = {{1},{2,3},{4,5,6}}; System.out.println(a[0][1]); } } 运行结果： Exception in thread "mai
systemctl命令用法 wmlJava linux systemctl
对比表，以 apache / httpd 为例任务旧指令新指令使某服务自动启动 chkconfig --level 3 httpd on systemctl enable httpd.service 使某服务不自动启动 chkconfig --level 3 httpd off systemctl disable httpd.service 检查服务状态 service h

单片机-自建C库函数

文章目录

前言