본문 바로가기
미정

fifo

powerdeng 2023. 12. 8. 16:32

drvfifo.h

/**
@file		DrvFifo.h
@date		2021/05
@author		bik3352@hynux.com
@version	1.0
@brief		Fifo 드라이버 헤더 파일
*/
#ifndef _DRV_FIFO_H_
#define _DRV_FIFO_H_

#include <stdbool.h>

#define	MAX(x, y)           ((x < y) ? y : x)		/**	@def	최대값 리턴	*/
#define	MIN(x, y)           ((x < y) ? x : y)		/**	@def	최소값 리턴	*/

#define	ff_flush  (x)       ((x)->iLoBound =  (x)->iHiBound = 0)	/**	@def	fifo 초기화	*/
#define	ff_isempty(x)       ((x)->iLoBound == (x)->iHiBound)		/**	@def	fifo empty 체크	*/
#define	ff_isfull (x)       (ff_getfree(x) <= 0)					/**	@def	fifo full 체크	*/


/**
@struct	stxFifo
@brief		FIFO 구조체 타입 정의
*/
#pragma pack(push, 1)
typedef struct st_Fifo_tag
{
    bool           b_Inhibit;	/// 데이터 스기 유무
    unsigned int   iDepth;		/// 메모리 할당 크기
    unsigned int   iLoBound;	/// 데이터 읽기 인덱스
    unsigned int   iHiBound;	/// 데이터 저장 인덱스
    unsigned char *p_ucQueBuff;	/// 실제 데이터 메모리 포인터
} stxFifo, *pstxFifo;
#pragma pack(pop)

#ifdef __cplusplus
extern "C" {
#endif

void ff_reload(stxFifo* ff, unsigned int i);

unsigned char* ff_at   (stxFifo* ff, unsigned int iLoct);
unsigned char  ff_peek (stxFifo* ff, unsigned int iLoct);

int ff_getsize  (stxFifo* aff);
int ff_getfree  (stxFifo* aff);

void ff_init    (stxFifo* aff, unsigned char*   ucBuf,  unsigned int iDepth);
void ff_remove  (stxFifo* aff, unsigned int iSize);
bool ff_push    (stxFifo* aff, unsigned char    ucData);
bool ff_pop     (stxFifo* aff, unsigned char* p_ucData);
bool ff_pushs   (stxFifo* aff, unsigned char*   ucData, unsigned int iSize);
bool ff_pops    (stxFifo* aff, unsigned char* p_ucData, unsigned int iSize);
bool ff_peeks   (stxFifo* aff, unsigned char* p_ucData, unsigned int iSize);
bool ff_pushFst (stxFifo* aff, unsigned char    ucData);
bool ff_pushsFst(stxFifo* aff, unsigned char* p_ucData, unsigned int iSize);
void ff_reset   (stxFifo *aff);

#ifdef __cplusplus
}
#endif
#endif //_DRV_FIFO_H_

 

drvfifo.cpp

/**
@file		DrvFifo.c
@date		2021/05
@author		bik3352@hynux.com
@version	1.0
@brief		Fifo 드라이버 소스 파일
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdint.h>

#include "DrvFifo.h"

/**
@fn		void ff_init(stxFifo* aff, unsigned char* ucBuf, unsigned int iDepth)
@brief	초기화 함수
@param	aff			stxFifo 구조체 타입 포인터
@param	ucBuf		데이터 저장 버퍼 포인터
@param	iDepth		버퍼 사이즈
*/
void ff_init(stxFifo* aff, unsigned char* ucBuf, unsigned int iDepth)
{
	stxFifo* ff = aff;

	if(ff != NULL) {
		ff->p_ucQueBuff = ucBuf;
		ff->iDepth      = iDepth;
		ff->iHiBound    = 0;
		ff->iLoBound    = 0;
		ff->b_Inhibit   = false;
#if 0
		printf(" ff->p_ucQueBuff : %d\r\n", ff->p_ucQueBuff);
		printf(" ff->iDepth      : %d\r\n", ff->iDepth);
		printf(" ff->iHiBound    : %d\r\n", ff->iHiBound);
		printf(" ff->iLoBound    : %d\r\n", ff->iLoBound);
#endif
	}
}

/**
@fn		unsigned char* ff_at(stxFifo* aff, unsigned int iLoct)
@brief	FIFO 데이터 메모리 주소 반환 함수
@param	aff			stxFifo 구조체 타입 포인터
@param	iLoct		데이터 위치
@return	메모리 주소
*/
unsigned char* ff_at(stxFifo* aff, unsigned int iLoct)
{
	stxFifo*       ff     = aff;
	unsigned char* pucRes = NULL;

	if(ff != NULL) {
		if(ff->iDepth != 0) {
			iLoct  = (iLoct+ff->iLoBound) % ff->iDepth;
			pucRes = ff->p_ucQueBuff + iLoct;
		}
	}

	return pucRes;
}

/**
@fn		void ff_remove(stxFifo* aff, unsigned int iSize)
@brief	FIFO 데이터 삭제 함수
@param	aff			stxFifo 구조체 타입 포인터
@param	iSize		삭제할 메모리 사이즈
@return
@exception
*/
void ff_remove(stxFifo* aff, unsigned int iSize)
{
	stxFifo* ff = aff;

	if(ff != NULL) {
		if(ff->iDepth != 0) {
			ff->iLoBound = (ff->iLoBound + iSize) % ff->iDepth;
		}
	}
}

/**
@fn		int ff_getsize(stxFifo* aff)
@brief	저장된즈 데이터 사이즈 반환 함수
@param	aff			stxFifo 구조체 타입 포인터
@return	저장 데이터 사이
*/
int ff_getsize(stxFifo* aff)
{
	stxFifo* ff   = aff;
	int      nRes = -1;

	if(ff != NULL) {
		int iHibound = ff->iHiBound;
		int iLobound = ff->iLoBound;

		nRes = (iHibound >= iLobound) ? (iHibound              - iLobound)
                                      : (iHibound + ff->iDepth - iLobound);
	}

	return nRes;
}

/**
@fn		int ff_getfree(stxFifo* aff)
@brief	저장 가능한 데이터 크기 반환 함수
@param	aff			stxFifo 구조체 타입 포인터
@return	저장 가능한 데이터 크기
*/
int ff_getfree(stxFifo* aff)
{
	stxFifo* ff   = aff;
	int      nRes = -1;

	if(ff != NULL) {
		int iHibound = ff->iHiBound;
		int iLobound = ff->iLoBound;

		nRes = (iHibound >= iLobound) ? (iLobound + ff->iDepth - 1 - iHibound)
									  : (iLobound              - 1 - iHibound);
	}

	return nRes;
}

/**
@fn		bool ff_push(stxFifo* aff, unsigned char ucData)
@brief	1 바이트부를 저장 함수
@param	aff			stxFifo 구조체 타입 포인터
@param	ucData		저장할 데이터
@return	저장 성공 여부
*/
bool ff_push(stxFifo* aff, unsigned char ucData)
{
	stxFifo* ff   = aff;
	bool     bRes = false;

	if(ff != NULL) {
		ff->b_Inhibit = true;

		if(ff_getfree(ff) > 0) {
			*(ff->p_ucQueBuff + ff->iHiBound) = ucData;

			if(ff->iDepth != 0) {
				ff->iHiBound  = (ff->iHiBound + 1) % ff->iDepth;
				ff->b_Inhibit = false;
				bRes          = true;
			}
		}
		ff->b_Inhibit = false;
	}

	return bRes;
}

/**
@fn		bool ff_pop(stxFifo* aff, unsigned char* p_ucData)
@brief	1 바이트 읽기 함수
@param	aff			stxFifo 구조체 타입 포인터
@param	p_ucData	데이터 저장 버퍼 포인터
@return	 읽기 설정 여부
*/
bool ff_pop(stxFifo* aff, unsigned char* p_ucData)
{
	stxFifo* ff   = aff;
	bool     bRes = false;

	if(ff != NULL) {
		if(ff->iHiBound != ff->iLoBound) {
			*p_ucData = *(ff->p_ucQueBuff + ff->iLoBound);

			if(ff->iDepth != 0) {
				ff->iLoBound = (ff->iLoBound + 1) % ff->iDepth;
				bRes         = true;
			}
		}
	}

	return bRes;
}

/**
@fn		bool ff_pushs(stxFifo* aff, unsigned char* p_ucData, unsigned int iSize)
@brief	n 바이트 저장 함수
@param	aff			stxFifo 구조체 타입 포인터
@param	p_ucData	데이터 저장 버퍼 포인터
@param	iSize		데이터 사이즈
@return	저장 성공 여부
@exception
*/
bool ff_pushs(stxFifo* aff, unsigned char* p_ucData, unsigned int iSize)
{
	stxFifo* ff    = aff;
	bool     bRes  = false;
    int      iHigh = 0;
    int      iLow  = 0;

    if(ff != NULL) {
		int iHibound = ff->iHiBound;

		ff->b_Inhibit = true;

		if(p_ucData && (iSize > 0) && (iSize <= ff_getfree(ff))) {
			iHigh = ff->iDepth - iHibound;
			
			if(iHigh > iSize) iHigh = iSize;

			iLow  = iSize - (ff->iDepth - iHibound);

			if(iHigh > 0)	memcpy (ff->p_ucQueBuff + iHibound, p_ucData,         iHigh);
			if(iLow  > 0)	memcpy (ff->p_ucQueBuff,            p_ucData + iHigh, iLow );

			if(ff->iDepth != 0) {
				ff->iHiBound  = (ff->iHiBound + iSize) % ff->iDepth;
				ff->b_Inhibit = false;
				bRes          = true;
			}
		}
		ff->b_Inhibit = false;
    }

	return bRes;
}

/**
@fn		bool ff_pops(stxFifo* aff, unsigned char* p_ucData, unsigned int iSize)
@brief	n 바이트 읽기 함수
@param	aff			stxFifo 구조체 타입 포인터
@param	p_ucData	데이터 저장 버퍼 포인터
@param	iSize		읽어갈 데이터 사이즈
@return	읽기 성공 여부
@exception
*/
bool ff_pops(stxFifo* aff, unsigned char* p_ucData, unsigned int iSize)
{
	stxFifo* ff    = aff;
	bool     bRes  = false;
	int      iHigh = 0;
	int      iLow  = 0;

	if(ff != NULL) {
		int iLobound = ff->iLoBound;

		if (p_ucData && (iSize > 0) && (iSize <= ff_getsize(ff))) {
			iHigh = ff->iDepth - iLobound;

			if (iHigh > iSize) iHigh = iSize;

			iLow  = iSize - (ff->iDepth - iLobound);

			if (iHigh > 0)	memcpy (p_ucData,         ff->p_ucQueBuff + iLobound, iHigh);
			if (iLow  > 0)	memcpy (p_ucData + iHigh, ff->p_ucQueBuff,            iLow );

			if(ff->iDepth != 0) {
				ff->iLoBound = (ff->iLoBound + iSize) % ff->iDepth;
				bRes         = true;
			}
		}
	}

    return bRes;
}

/**
@fn		bool ff_pops(stxFifo* aff, unsigned char* p_ucData, unsigned int iSize)
@brief	i 바이트 만큼 데이터 복원 함수
@param	aff			stxFifo 구조체 타입 포인터
@param	i			복원할 데이타 사이즈
@return
@exception
*/
void ff_reload(stxFifo* aff, unsigned int i)
{
	stxFifo* ff = aff;

	if(ff != NULL) {
		if(ff->iLoBound >= i)	ff->iLoBound -= i;
		else					ff->iLoBound  = ff->iDepth + ff->iLoBound - i;
	}
}

/**
@fn		unsigned char ff_peek(stxFifo* aff, unsigned int iLoct)
@brief	1 바이트 데이터 미리 읽기 함수
@param	aff			stxFifo 구조체 타입 포인터
@param	iLoct		미리 읽어갈 데이터 위치
@return	저장된 데이터
@exception
*/
unsigned char ff_peek(stxFifo* aff, unsigned int iLoct)
{
	stxFifo*      ff    = aff;
	unsigned char ucRes = 0;

	if(ff != NULL) {
		if(ff->iDepth != 0)	iLoct = (iLoct + ff->iLoBound) % ff->iDepth;

		ucRes = *(ff->p_ucQueBuff + iLoct);
	}
	return ucRes;
}

/**
@fn		bool ff_peeks(stxFifo* aff, unsigned char* p_ucData, unsigned int iSize)
@brief	iSize 만큼 데이터 미리 읽기 함수
@param	aff			stxFifo 구조체 타입 포인터
@param	p_ucData	데이터 저장 버퍼 포인터
@param	iSize		읽어갈 데이터 크기
@return	읽기 설공 여부
@exception
*/
bool ff_peeks(stxFifo* aff, unsigned char* p_ucData, unsigned int iSize)
{
	stxFifo* ff    = aff;
	bool     bRes  = false;
	int      iHigh = 0;
	int      iLow  = 0;

	if(ff != NULL) {
		int iLobound = ff->iLoBound;

		if(p_ucData && (iSize > 0) && (iSize <= ff_getsize(ff))) {
			iHigh = ff->iDepth - iLobound;

			if (iHigh > iSize) iHigh = iSize;

			iLow  = iSize - (ff->iDepth - iLobound);

			if (iHigh > 0)	memcpy (p_ucData,         ff->p_ucQueBuff + iLobound, iHigh);
			if (iLow  > 0)	memcpy (p_ucData + iHigh, ff->p_ucQueBuff,            iLow );

			bRes = true;
		}
	}

	return bRes;
}

/**
@fn		bool ff_pushFst(stxFifo* aff, unsigned char ucData)
@brief	저장될 위치 이전 1 바이트 업데이트 함수
@param	aff			stxFifo 구조체 타입 포인터
@param	ucData		업데이트 데이터
@return	저장 성공 여부
@exception
*/
bool ff_pushFst(stxFifo* aff, unsigned char ucData)
{
	stxFifo* ff   = aff;
	bool     bRes = false;

	if(ff != NULL) {
		int iLobound = ff->iLoBound;

		if(ff_getfree(ff) > 0) {
			if(ff->iDepth != 0) {
				ff->iLoBound = ((--iLobound) + ff->iDepth) % ff->iDepth;

				*(ff->p_ucQueBuff + iLobound) = ucData;

				bRes = true;
			}
		}
	}

	return bRes;
}

/**
@fn		bool ff_pushsFst(stxFifo* aff, unsigned char* p_ucData, unsigned int iSize)
@brief	저장될 위치 이전 iSize 바이트 업데이트 함수
@param	aff			stxFifo 구조체 타입 포인터
@param	p_ucData	업데이트 데이터 버퍼 포인터
@param	iSize		업데이트 데이터 사이즈
@return 저장 성공 여부
@exception
*/
bool ff_pushsFst(stxFifo* aff, unsigned char* p_ucData, unsigned int iSize)
{
	stxFifo* ff    = aff;
	bool     bRes  = false;
	int      iHigh = 0;
	int      iLow  = 0;

	if(ff != NULL) {
		int iLobound = ff->iLoBound;

		if(p_ucData && (iSize > 0) && (iSize <= ff_getfree(ff))) {
			iHigh = iLobound;

			if (iHigh > iSize) iHigh = iSize;

			iLow  = iSize - iLobound;

			if (iHigh > 0)	memcpy (ff->p_ucQueBuff - iHigh,             p_ucData + iLow, iHigh);
			if (iLow  > 0)	memcpy (ff->p_ucQueBuff + ff->iDepth - iLow, p_ucData,        iLow);

			if(ff->iDepth != 0)	ff->iLoBound = (ff->iLoBound - iSize + ff->iDepth) % ff->iDepth;

			bRes = true;
		}
	}

	return bRes;
}

/**
@fn		void ff_reset(stxFifo *aff)
@brief	저장 위치 초기화 함수
@param	aff			stxFifo 구조체 타입 포인터
@return
@exception
*/
void ff_reset(stxFifo *aff)
{
	aff->iLoBound = aff->iHiBound;
}

 

저작자표시

'미정' 카테고리의 다른 글

데이터 단위  (0) 2023.07.27
GitHub에 CMD로 파일 올리고 받기  (0) 2023.06.16
batch_size와 epochs  (0) 2022.07.15
CNN(합성곱 신경망) 개념 및 사용법  (0) 2022.07.14
WinMerge  (0) 2022.03.18

'미정' Related Articles

티스토리툴바